Merge pull request #197 from jherdman/upgrade-rspec

Upgrade to RSpec 3.1

carrierwave_backgrounder.gemspec

@@ -19,7 +19,6 @@ Gem::Specification.new do |s|
 
   s.add_dependency "carrierwave", ["~> 0.5"]
 
-  s.add_development_dependency "rspec", ["~> 2.12.0"]
-  s.add_development_dependency "mocha", ["~> 0.13.0"]
+  s.add_development_dependency "rspec", ["~> 3.1.0"]
   s.add_development_dependency "rake"
 end

spec/backgrounder/orm/activemodel_spec.rb

@@ -2,7 +2,7 @@
 require 'ostruct'
 require 'backgrounder/orm/activemodel'
 
-describe CarrierWave::Backgrounder::ORM::ActiveModel do
+RSpec.describe CarrierWave::Backgrounder::ORM::ActiveModel do
   before do
     @mock_class = Class.new do
       def self.before_save(method, opts); nil; end
@@ -20,7 +20,7 @@ def self.uploader_options; {}; end
   describe '.store_in_background' do
     context 'setting up callbacks' do
       it 'creates an after_commit hook' do
-        @mock_class.expects(:after_commit).with(:enqueue_avatar_background_job, :if => :enqueue_avatar_background_job?)
+        expect(@mock_class).to receive(:after_commit).with(:enqueue_avatar_background_job, :if => :enqueue_avatar_background_job?)
         @mock_class.store_in_background :avatar
       end
     end
@@ -29,12 +29,12 @@ def self.uploader_options; {}; end
   describe '.process_in_background' do
     context 'setting up callbacks' do
       it 'creates a before_save hook' do
-        @mock_class.expects(:before_save).with(:set_avatar_processing, :if => :enqueue_avatar_background_job?)
+        expect(@mock_class).to receive(:before_save).with(:set_avatar_processing, :if => :enqueue_avatar_background_job?)
         @mock_class.process_in_background :avatar
       end
 
       it 'creates an after_save hook' do
-        @mock_class.expects(:after_commit).with(:enqueue_avatar_background_job, :if => :enqueue_avatar_background_job?)
+        expect(@mock_class).to receive(:after_commit).with(:enqueue_avatar_background_job, :if => :enqueue_avatar_background_job?)
         @mock_class.process_in_background :avatar
       end
     end
@@ -50,48 +50,48 @@ def self.uploader_options; {}; end
     context 'mount_on option is set' do
       before do
         options_hash = {:avatar => {:mount_on => :some_other_column}}
-        @mock_class.expects(:uploader_options).returns(options_hash)
+        expect(@mock_class).to receive(:uploader_options).and_return(options_hash)
       end
 
       it "returns true if alternate column is changed" do
-        instance.expects(:some_other_column_changed?).returns(true)
-        expect(instance.avatar_updated?).to be_true
+        expect(instance).to receive(:some_other_column_changed?).and_return(true)
+        expect(instance.avatar_updated?).to be_truthy
       end
     end
 
     it "returns true if process_avatar_upload is false" do
-      instance.expects(:process_avatar_upload)
-      expect(instance.enqueue_avatar_background_job?).to be_true
+      expect(instance).to receive(:process_avatar_upload)
+      expect(instance.enqueue_avatar_background_job?).to be_truthy
     end
 
     it "calls column_changed?" do
-      instance.expects(:process_avatar_upload).returns(false)
-      instance.expects(:avatar_changed?)
-      expect(instance.enqueue_avatar_background_job?).to be_true
+      expect(instance).to receive(:process_avatar_upload).and_return(false)
+      expect(instance).to receive(:avatar_changed?)
+      expect(instance.enqueue_avatar_background_job?).to be_truthy
     end
 
     it "calls previous_changes" do
-      instance.expects(:process_avatar_upload).returns(false)
-      instance.expects(:avatar_changed?).returns(false)
-      instance.expects(:previous_changes).returns({:avatar => true})
-      expect(instance.enqueue_avatar_background_job?).to be_true
+      expect(instance).to receive(:process_avatar_upload).and_return(false)
+      expect(instance).to receive(:avatar_changed?).and_return(false)
+      expect(instance).to receive(:previous_changes).and_return({:avatar => true})
+      expect(instance.enqueue_avatar_background_job?).to be_truthy
     end
 
     it "calls avatar_remote_url" do
-      instance.expects(:process_avatar_upload).returns(false)
-      instance.expects(:avatar_changed?).returns(false)
-      instance.expects(:previous_changes).returns({})
-      instance.expects(:remote_avatar_url).returns('yup')
-      expect(instance.enqueue_avatar_background_job?).to be_true
+      expect(instance).to receive(:process_avatar_upload).and_return(false)
+      expect(instance).to receive(:avatar_changed?).and_return(false)
+      expect(instance).to receive(:previous_changes).and_return({})
+      expect(instance).to receive(:remote_avatar_url).and_return('yup')
+      expect(instance.enqueue_avatar_background_job?).to be_truthy
     end
 
     it "calls avatar_cache" do
-      instance.expects(:process_avatar_upload).returns(false)
-      instance.expects(:avatar_changed?).returns(false)
-      instance.expects(:previous_changes).returns({})
-      instance.expects(:remote_avatar_url).returns(nil)
-      instance.expects(:avatar_cache).returns('yup')
-      expect(instance.enqueue_avatar_background_job?).to be_true
+      expect(instance).to receive(:process_avatar_upload).and_return(false)
+      expect(instance).to receive(:avatar_changed?).and_return(false)
+      expect(instance).to receive(:previous_changes).and_return({})
+      expect(instance).to receive(:remote_avatar_url).and_return(nil)
+      expect(instance).to receive(:avatar_cache).and_return('yup')
+      expect(instance.enqueue_avatar_background_job?).to be_truthy
     end
   end
 end

spec/backgrounder/orm/base_spec.rb

@@ -1,7 +1,7 @@
 require 'spec_helper'
 
 
-describe CarrierWave::Backgrounder::ORM::Base do
+RSpec.describe CarrierWave::Backgrounder::ORM::Base do
   before do
     @mock_class = Class.new do
       def self.before_save(method, opts); nil; end

spec/backgrounder/support/backends_spec.rb

@@ -3,7 +3,7 @@
 require 'support/mock_worker'
 
 module CarrierWave::Backgrounder
-  describe Support::Backends do
+  RSpec.describe Support::Backends do
     let(:mock_module) { Module.new }
 
     before do
@@ -37,27 +37,27 @@ module CarrierWave::Backgrounder
             def self.perform(*args); new(*args).perform; end
           end
 
-          MockWorker.expects(:new).returns(worker)
+          allow(MockWorker).to receive(:new).and_return(worker)
         end
 
         context 'queue column exists' do
           it 'defaults the queue name to nil if none passed to #backend' do
             mock_module.backend :delayed_job
-            Delayed::Job.expects(:enqueue).with(worker, :queue => nil)
+            expect(Delayed::Job).to receive(:enqueue).with(worker, :queue => nil)
             mock_module.enqueue_for_backend MockWorker, 'FakeClass', 1, :image
           end
 
           it 'sets the queue name to the queue name passed to #backend' do
             mock_module.backend :delayed_job, :queue => :awesome_queue
-            Delayed::Job.expects(:enqueue).with(worker, :queue => :awesome_queue)
+            expect(Delayed::Job).to receive(:enqueue).with(worker, :queue => :awesome_queue)
             mock_module.enqueue_for_backend MockWorker, 'FakeClass', 1, :image
           end
         end
 
         context 'queue column does not exist' do
           before do
             column_names = Delayed::Job.column_names.tap { |cn| cn.delete('queue') }
-            Delayed::Job.stubs(:column_names).returns(column_names)
+            allow(Delayed::Job).to receive(:column_names).and_return(column_names)
             Delayed::Job.class_eval { remove_method(:queue) }
           end
 
@@ -67,14 +67,14 @@ def self.perform(*args); new(*args).perform; end
 
           it 'does not pass a queue name if none passed to #backend' do
             mock_module.backend :delayed_job
-            Delayed::Job.expects(:enqueue).with(worker)
+            expect(Delayed::Job).to receive(:enqueue).with(worker)
             mock_module.enqueue_for_backend MockWorker, 'FakeClass', 1, :image
           end
 
           it 'does not pass a queue name and logs a warning message if a queue name is passed to #backend' do
             mock_module.backend :delayed_job, :queue => :awesome_queue
-            Delayed::Job.expects(:enqueue).with(worker)
-            Rails.logger.expects(:warn).with(instance_of(String))
+            expect(Rails.logger).to receive(:warn).with(instance_of(String))
+            expect(Delayed::Job).to receive(:enqueue).with(worker)
             mock_module.enqueue_for_backend MockWorker, 'FakeClass', 1, :image
           end
         end
@@ -84,7 +84,7 @@ def self.perform(*args); new(*args).perform; end
         let(:args) { [MockWorker, 'FakeClass', 1, :image] }
 
         before do
-          Resque.expects(:enqueue).with(*args)
+          allow(Resque).to receive(:enqueue).with(*args)
         end
 
         it 'sets a variable with the queue name, defaults to :carrierwave' do
@@ -104,17 +104,17 @@ def self.perform(*args); new(*args).perform; end
         let(:args) { ['FakeClass', 1, :image] }
 
         it 'invokes client_push on the class with passed args' do
-          MockSidekiqWorker.expects(:client_push).with({ 'class' => MockSidekiqWorker, 'args' => args })
+          expect(MockSidekiqWorker).to receive(:client_push).with({ 'class' => MockSidekiqWorker, 'args' => args })
           mock_module.backend :sidekiq
           mock_module.enqueue_for_backend(MockSidekiqWorker, *args)
         end
 
         it 'invokes client_push and includes the options passed to backend' do
-          MockSidekiqWorker.expects(:client_push).with({ 'class' => MockSidekiqWorker, 
-                                                         'retry' => false,
-                                                         'timeout' => 60,
-                                                         'queue' => :awesome_queue,
-                                                         'args' => args })
+          expect(MockSidekiqWorker).to receive(:client_push).with({ 'class' => MockSidekiqWorker,
+                                                                    'retry' => false,
+                                                                    'timeout' => 60,
+                                                                    'queue' => :awesome_queue,
+                                                                    'args' => args })
           options = {:retry => false, :timeout => 60, :queue => :awesome_queue}
           mock_module.backend :sidekiq, options
           mock_module.enqueue_for_backend(MockSidekiqWorker, *args)
@@ -126,20 +126,20 @@ def self.perform(*args); new(*args).perform; end
 
         it 'instantiates a GirlFriday work queue if one does not exist' do
           mock_module.backend :girl_friday
-          GirlFriday::WorkQueue.expects(:new).with(:carrierwave, {}).returns([])
+          expect(GirlFriday::WorkQueue).to receive(:new).with(:carrierwave, {}).and_return([])
           mock_module.enqueue_for_backend(*args)
         end
 
         it 'instantiates a GirlFriday work queue passing the args to the queue' do
           mock_module.backend :girl_friday, :queue => :awesome_queue, :size => 3
-          GirlFriday::WorkQueue.expects(:new).with(:awesome_queue, {:size => 3}).returns([])
+          expect(GirlFriday::WorkQueue).to receive(:new).with(:awesome_queue, {:size => 3}).and_return([])
           mock_module.enqueue_for_backend(*args)
         end
 
         it 'does not instantiate a GirlFriday work queue if one exists' do
           mock_module.backend :girl_friday
           mock_module.instance_variable_set('@girl_friday_queue', [])
-          GirlFriday::WorkQueue.expects(:new).never
+          expect(GirlFriday::WorkQueue).to receive(:new).never
           mock_module.enqueue_for_backend(*args)
         end
 
@@ -154,12 +154,12 @@ def self.perform(*args); new(*args).perform; end
 
       context 'sucker_punch' do
         let(:args) { [MockWorker, 'FakeClass', 1, :image] }
-        let(:job) { mock('job') }
+        let(:job) { double('job') }
 
         it 'invokes a new worker' do
-          MockWorker.expects(:new).returns(worker)
-          worker.expects(:async).returns(job)
-          job.expects(:perform).with('FakeClass', 1, :image)
+          expect(MockWorker).to receive(:new).and_return(worker)
+          expect(worker).to receive(:async).and_return(job)
+          expect(job).to receive(:perform).with('FakeClass', 1, :image)
           mock_module.backend :sucker_punch
           mock_module.enqueue_for_backend(*args)
         end
@@ -168,7 +168,7 @@ def self.perform(*args); new(*args).perform; end
       context 'qu' do
         let(:args) { [MockWorker, 'FakeClass', 1, :image] }
         before do
-          Qu.expects(:enqueue).with(*args)
+          allow(Qu).to receive(:enqueue).with(*args)
         end
 
         it 'sets a variable with the queue name, defaults to :carrierwave' do
@@ -186,22 +186,21 @@ def self.perform(*args); new(*args).perform; end
 
       context 'qc' do
         it 'calls enqueue with the passed args' do
-          QC.expects(:enqueue).with("MockWorker.perform", 'FakeClass', 1, 'image')
+          expect(QC).to receive(:enqueue).with("MockWorker.perform", 'FakeClass', 1, 'image')
           mock_module.backend :qc
           mock_module.enqueue_for_backend(MockWorker, 'FakeClass', 1, :image)
         end
       end
 
       context 'immediate' do
         it 'instantiates a worker passing the args and calls perform' do
-          worker = mock('Worker')
-          MockWorker.expects(:new).with('FakeClass', 1, :image).returns(worker)
-          worker.expects(:perform)
+          worker = double('Worker')
+          expect(MockWorker).to receive(:new).with('FakeClass', 1, :image).and_return(worker)
+          expect(worker).to receive(:perform)
           mock_module.backend :immediate
           mock_module.enqueue_for_backend(MockWorker, 'FakeClass', 1, :image)
         end
       end
-
     end
   end
 end

spec/backgrounder/workers/process_asset_spec.rb

@@ -2,55 +2,55 @@
 require 'spec_helper'
 require 'backgrounder/workers/process_asset'
 
-describe CarrierWave::Workers::ProcessAsset do
+RSpec.describe CarrierWave::Workers::ProcessAsset do
   let(:worker_class) { CarrierWave::Workers::ProcessAsset }
-  let(:user)   { mock('User') }
+  let(:user)   { double('User') }
   let!(:worker) { worker_class.new(user, '22', :image) }
 
   describe ".perform" do
     it 'creates a new instance and calls perform' do
       args = [user, '22', :image]
-      worker_class.expects(:new).with(*args).returns(worker)
-      worker_class.any_instance.expects(:perform)
+      expect(worker_class).to receive(:new).with(*args).and_return(worker)
+      expect_any_instance_of(worker_class).to receive(:perform)
 
       worker_class.perform(*args)
     end
   end
 
   describe "#perform" do
-    let(:image)  { mock('UserAsset') }
+    let(:image)  { double('UserAsset') }
 
     before do
-      user.expects(:find).with('22').returns(user).once
-      user.expects(:image).once.returns(image)
-      user.expects(:process_image_upload=).with(true).once
-      image.expects(:recreate_versions!).once.returns(true)
+      allow(user).to receive(:find).with('22').and_return(user).once
+      allow(user).to receive(:image).once.and_return(image)
+      allow(user).to receive(:process_image_upload=).with(true).once
+      allow(image).to receive(:recreate_versions!).once.and_return(true)
     end
 
     it 'processes versions with image_processing column' do
-      user.expects(:respond_to?).with(:image_processing).once.returns(true)
-      user.expects(:update_attribute).with(:image_processing, false).once
+      expect(user).to receive(:respond_to?).with(:image_processing).once.and_return(true)
+      expect(user).to receive(:update_attribute).with(:image_processing, false).once
       worker.perform
     end
 
     it 'processes versions without image_processing column' do
-      user.expects(:respond_to?).with(:image_processing).once.returns(false)
-      user.expects(:update_attribute).never
+      expect(user).to receive(:respond_to?).with(:image_processing).once.and_return(false)
+      expect(user).to receive(:update_attribute).never
       worker.perform
     end
   end
 
   describe '#perform with args' do
-    let(:admin) { mock('Admin') }
-    let(:avatar)  { mock('AdminAsset') }
+    let(:admin) { double('Admin') }
+    let(:avatar)  { double('AdminAsset') }
     let(:worker) { worker_class.new }
 
     before do
-      admin.expects(:find).with('23').returns(admin).once
-      admin.expects(:avatar).once.returns(avatar)
-      admin.expects(:process_avatar_upload=).with(true).once
-      admin.expects(:respond_to?).with(:avatar_processing).once.returns(false)
-      avatar.expects(:recreate_versions!).once.returns(true)
+      allow(admin).to receive(:find).with('23').and_return(admin).once
+      allow(admin).to receive(:avatar).once.and_return(avatar)
+      allow(admin).to receive(:process_avatar_upload=).with(true).once
+      allow(admin).to receive(:respond_to?).with(:avatar_processing).once.and_return(false)
+      allow(avatar).to receive(:recreate_versions!).once.and_return(true)
 
       worker.perform admin, '23', :avatar
     end