carrierwave_backgrounder 0.4.1 → 0.4.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: abc9a18253e5769acf85ec7fe57cd8778d331f09
-  data.tar.gz: 8317e2803900b1c724064ec3c759558946927aca
+  metadata.gz: ea7ccc20dfbd12f0d5ca49a22aed4df13af757fe
+  data.tar.gz: 9483744462a3c7de8ec21c01c033fe5c7722c1b7
 SHA512:
-  metadata.gz: 469bc208573057e5934e8f42e21f0d95ff955b3b377b709b6aa504a4931ac80b29f42f83bd26986fa601b777b3ed9fa4b4af14b59981ca59cc14a7dc314ba4d0
-  data.tar.gz: b4fcd8692e900393d94a9ee779a605d0c733785b425312b14c5c825464e21ed07aafc3c458b398dc42bafac88562716adbb2ddf31cfb4d252e915b00a28d039e
+  metadata.gz: a9ccbcd89a9f510723a6f512197cc3595ffe4bfa00a9ea21c3c1e6b2530fee1901b47670d1bf0e6e44427d40fd71c83064eab553f09c7e1d0b75cb3283d0291e
+  data.tar.gz: 437d6b11a142e94ae83699672299bf1a3da800846f4465aa557027bb4026970619ee425b6fc63ca7e5e11687a9dfe417c08213ddbc9300ed826a8361a95f6e61

data/.gitignore

@@ -2,3 +2,4 @@
 .bundle
 Gemfile.lock
 pkg/*
+vendor/*

data/CHANGELOG.md

@@ -1,4 +1,13 @@
 
+## 0.4.2
+
+### enhancements
+  * Allow overridden worker to set a queue name
+  * [#190] Respect Carrierwave's enable_processing flag if set to false [jherdman]
+
+### bug fixes
+  * [#216] Fix for NoMethodError: undefined method `read' for nil:NilClass [kntmrkm]
+
 ## 0.4.1
 
 ### enhancements
@@ -88,4 +97,3 @@
 ### bug fixes
   * Girl Friday incorrectly referenses class #92
   * Add documentation for testing with rspec #84.
-

data/README.md

@@ -34,7 +34,7 @@ Backgrounder::ORM::Base::store_in_background
 
 ## Installation and Usage
 
-These instructions assume you have previously set up [CarrierWave](https://github.com/jnicklas/carrierwave) and your queing lib of choice.
+These instructions assume you have previously set up [CarrierWave](https://github.com/jnicklas/carrierwave) and your queuing lib of choice.
 
 In Rails, add the following your Gemfile:
 
@@ -74,10 +74,11 @@ mount_uploader :avatar, AvatarUploader
 process_in_background :avatar
 ```
 
-Optionally you can add a column to the database which will be set to nil when the background processing is complete.
+Optionally you can add a column to the database which will be set to `true` when
+the background processing is started and to `false` when the background processing is complete.
 
 ```ruby
-add_column :users, :avatar_processing, :boolean
+add_column :users, :avatar_processing, :boolean, null: false, default: false
 ```
 
 ### To use store_in_background
@@ -114,7 +115,7 @@ This must be set before you assign an upload:
 ```
 
 ### Override worker
-To overide the worker in cases where additional methods need to be called or you have app specific requirements, pass the worker class as the
+To override the worker in cases where additional methods need to be called or you have app specific requirements, pass the worker class as the
 second argument:
 
 ```ruby

data/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

data/lib/backgrounder/delay.rb

@@ -17,7 +17,8 @@ module CarrierWave
       private
 
       def proceed_with_versioning?
-        !model.respond_to?(:"process_#{mounted_as}_upload") || model.send(:"process_#{mounted_as}_upload")
+        !model.respond_to?(:"process_#{mounted_as}_upload") && enable_processing ||
+          !!(model.send(:"process_#{mounted_as}_upload") && enable_processing)
       end
     end # Delay
 

data/lib/backgrounder/support/backends.rb

@@ -23,10 +23,14 @@ module CarrierWave
           private
 
           def enqueue_delayed_job(worker, *args)
+            worker_args = {}
             if ::Delayed::Job.new.respond_to?(:queue)
-              ::Delayed::Job.enqueue worker.new(*args), :queue => queue_options[:queue]
+              worker_args[:queue] = queue_options[:queue] if queue_options[:queue]
+              worker_args[:priority] = queue_options[:priority] if queue_options[:priority]
+              ::Delayed::Job.enqueue worker.new(*args), worker_args
             else
-              ::Delayed::Job.enqueue worker.new(*args)
+              worker_args[:priority] = queue_options[:priority] if queue_options[:priority]
+              ::Delayed::Job.enqueue worker.new(*args), worker_args
               if queue_options[:queue]
                 ::Rails.logger.warn("Queue name given but no queue column exists for Delayed::Job")
               end
@@ -39,7 +43,8 @@ module CarrierWave
           end
 
           def enqueue_sidekiq(worker, *args)
-            args = sidekiq_queue_options('class' => worker, 'args' => args)
+            override_queue_name = worker.sidekiq_options['queue'] == 'default' || worker.sidekiq_options['queue'].nil?
+            args = sidekiq_queue_options(override_queue_name, 'class' => worker, 'args' => args)
             worker.client_push(args)
           end
 
@@ -69,8 +74,10 @@ module CarrierWave
             worker.new(*args).perform
           end
 
-          def sidekiq_queue_options(args)
-            args['queue'] = queue_options[:queue] if queue_options[:queue]
+          def sidekiq_queue_options(override_queue_name, args)
+            if override_queue_name && queue_options[:queue]
+              args['queue'] = queue_options[:queue]
+            end
             args['retry'] = queue_options[:retry] unless queue_options[:retry].nil?
             args['timeout'] = queue_options[:timeout] if queue_options[:timeout]
             args['backtrace'] = queue_options[:backtrace] if queue_options[:backtrace]

data/lib/backgrounder/version.rb

@@ -1,5 +1,5 @@
 module CarrierWave
   module Backgrounder
-    VERSION = "0.4.1"
+    VERSION = "0.4.2"
   end
 end

data/lib/backgrounder/workers/process_asset.rb

@@ -7,7 +7,7 @@ module CarrierWave
       def perform(*args)
         record = super(*args)
 
-        if record
+        if record && record.send(:"#{column}").present?
           record.send(:"process_#{column}_upload=", true)
           if record.send(:"#{column}").recreate_versions! && record.respond_to?(:"#{column}_processing")
             record.update_attribute :"#{column}_processing", false

data/spec/backgrounder/orm/activemodel_spec.rb

@@ -2,7 +2,7 @@ require 'spec_helper'
 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 @@ describe CarrierWave::Backgrounder::ORM::ActiveModel do
   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 @@ describe CarrierWave::Backgrounder::ORM::ActiveModel do
   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 @@ describe CarrierWave::Backgrounder::ORM::ActiveModel do
     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

data/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

data/spec/backgrounder/support/backends_spec.rb

@@ -3,7 +3,7 @@ require 'support/backend_constants'
 require 'support/mock_worker'
 
 module CarrierWave::Backgrounder
-  describe Support::Backends do
+  RSpec.describe Support::Backends do
     let(:mock_module) { Module.new }
 
     before do
@@ -37,19 +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
+          it 'does not pass the queue name 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, {})
             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 'priority set in config' do
+          it 'sets the priority which is passed to #backend' do
+            mock_module.backend :delayed_job, :priority => 5
+            expect(Delayed::Job).to receive(:enqueue).with(worker, :priority => 5)
             mock_module.enqueue_for_backend MockWorker, 'FakeClass', 1, :image
           end
         end
@@ -57,7 +65,7 @@ module CarrierWave::Backgrounder
         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 +75,14 @@ module CarrierWave::Backgrounder
 
           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 +92,7 @@ module CarrierWave::Backgrounder
         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,21 +112,31 @@ module CarrierWave::Backgrounder
         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)
         end
+
+        it 'does not override queue name if set it worker' do
+          expect(MockNamedSidekiqWorker).to receive(:client_push).with({ 'class' => MockNamedSidekiqWorker,
+                                                                    'retry' => false,
+                                                                    'timeout' => 60,
+                                                                    'args' => args })
+          options = {:retry => false, :timeout => 60}
+          mock_module.backend :sidekiq, options
+          mock_module.enqueue_for_backend(MockNamedSidekiqWorker, *args)
+        end
       end
 
       context 'girl_friday' do
@@ -126,20 +144,20 @@ module CarrierWave::Backgrounder
 
         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 +172,12 @@ module CarrierWave::Backgrounder
 
       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 +186,7 @@ module CarrierWave::Backgrounder
       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,7 +204,7 @@ module CarrierWave::Backgrounder
 
       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
@@ -194,14 +212,13 @@ module CarrierWave::Backgrounder
 
       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

data/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).twice.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).twice.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

data/spec/backgrounder/workers/store_asset_spec.rb

@@ -2,75 +2,75 @@
 require 'spec_helper'
 require 'backgrounder/workers/store_asset'
 
-describe CarrierWave::Workers::StoreAsset do
+RSpec.describe CarrierWave::Workers::StoreAsset do
   let(:fixtures_path) { File.expand_path('../fixtures/images', __FILE__) }
   let(:worker_class) { CarrierWave::Workers::StoreAsset }
-  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
-      image.expects(:root).once.returns(File.expand_path('..', __FILE__))
-      image.expects(:cache_dir).once.returns('fixtures')
-      user.expects(:image_tmp).twice.returns('images/test.jpg')
-      user.expects(:find).with('22').once.returns(user)
-      user.expects(:image).once.returns(image)
-      user.expects(:process_image_upload=).with(true).once
-      user.expects(:image=).once
-      user.expects(:image_tmp=).with(nil).once
+      allow(image).to receive(:root).once.and_return(File.expand_path('..', __FILE__))
+      allow(image).to receive(:cache_dir).once.and_return('fixtures')
+      allow(user).to receive(:image_tmp).twice.and_return('images/test.jpg')
+      allow(user).to receive(:find).with('22').once.and_return(user)
+      allow(user).to receive(:image).once.and_return(image)
+      allow(user).to receive(:process_image_upload=).with(true).once
+      allow(user).to receive(:image=).once
+      allow(user).to receive(:image_tmp=).with(nil).once
     end
 
     it 'removes tmp directory on success' do
-      FileUtils.expects(:rm_r).with(fixtures_path, :force => true).once
-      user.expects(:save!).once.returns(true)
+      expect(FileUtils).to receive(:rm_r).with(fixtures_path, :force => true).once
+      expect(user).to receive(:save!).once.and_return(true)
       worker.perform
     end
 
     it 'does not remove the tmp directory if save! fails' do
-      FileUtils.expects(:rm_r).never
-      user.expects(:save!).once.returns(false)
+      expect(FileUtils).to receive(:rm_r).never
+      expect(user).to receive(:save!).once.and_return(false)
       worker.perform
     end
 
     it 'sets the cache_path' do
-      user.expects(:save!).once.returns(false)
+      expect(user).to receive(:save!).once.and_return(false)
       worker.perform
       expect(worker.cache_path).to eql(fixtures_path + '/test.jpg')
     end
 
     it 'sets the tmp_directory' do
-      user.expects(:save!).once.returns(false)
+      expect(user).to receive(:save!).once.and_return(false)
       worker.perform
       expect(worker.tmp_directory).to eql(fixtures_path)
     end
   end
 
   describe '#perform with args' do
-    let(:admin) { mock('Admin') }
-    let(:image)  { mock('AdminAsset') }
+    let(:admin) { double('Admin') }
+    let(:image)  { double('AdminAsset') }
     let(:worker) { worker_class.new }
 
     before do
-      image.expects(:root).once.returns(File.expand_path('..', __FILE__))
-      image.expects(:cache_dir).once.returns('fixtures')
-      admin.expects(:avatar_tmp).twice.returns('images/test.jpg')
-      admin.expects(:find).with('23').once.returns(admin)
-      admin.expects(:avatar).once.returns(image)
-      admin.expects(:process_avatar_upload=).with(true).once
-      admin.expects(:avatar=).once
-      admin.expects(:avatar_tmp=).with(nil).once
-      admin.expects(:save!).once.returns(false)
+      allow(image).to receive(:root).once.and_return(File.expand_path('..', __FILE__))
+      allow(image).to receive(:cache_dir).once.and_return('fixtures')
+      allow(admin).to receive(:avatar_tmp).twice.and_return('images/test.jpg')
+      allow(admin).to receive(:find).with('23').once.and_return(admin)
+      allow(admin).to receive(:avatar).once.and_return(image)
+      allow(admin).to receive(:process_avatar_upload=).with(true).once
+      allow(admin).to receive(:avatar=).once
+      allow(admin).to receive(:avatar_tmp=).with(nil).once
+      allow(admin).to receive(:save!).once.and_return(false)
       worker.perform admin, '23', :avatar
     end
 
@@ -88,15 +88,15 @@ describe CarrierWave::Workers::StoreAsset do
   end
 
   describe '#store_directories' do
-    let(:record) { mock('Record') }
+    let(:record) { double('Record') }
 
     context 'cache_path' do
       it 'sets the cache_path correctly if a full path is set for the cache_dir' do
         root = '/Users/lar/Sites/bunker/public'
         cache_dir = '/Users/lar/Sites/bunker/tmp/uploads'
-        asset = mock(:cache_dir => cache_dir, :root => root)
-        record.expects(:image).returns(asset)
-        record.expects(:image_tmp).returns('images/test.jpg')
+        asset = double(:cache_dir => cache_dir, :root => root)
+        expect(record).to receive(:image).and_return(asset)
+        expect(record).to receive(:image_tmp).and_return('images/test.jpg')
         worker.send :store_directories, record
         expect(worker.cache_path).to eql('/Users/lar/Sites/bunker/tmp/uploads/images/test.jpg')
       end
@@ -104,9 +104,9 @@ describe CarrierWave::Workers::StoreAsset do
       it 'sets the cache_path correctly if a partial path is set for cache_dir' do
         root = '/Users/lar/Sites/bunker/public'
         cache_dir = 'uploads/tmp'
-        asset = mock(:cache_dir => cache_dir, :root => root)
-        record.expects(:image).returns(asset)
-        record.expects(:image_tmp).returns('images/test.jpg')
+        asset = double(:cache_dir => cache_dir, :root => root)
+        expect(record).to receive(:image).and_return(asset)
+        expect(record).to receive(:image_tmp).and_return('images/test.jpg')
         worker.send :store_directories, record
         expect(worker.cache_path).to eql('/Users/lar/Sites/bunker/public/uploads/tmp/images/test.jpg')
       end
@@ -116,9 +116,9 @@ describe CarrierWave::Workers::StoreAsset do
       it 'sets the tmp_directory correctly if a full path is set for the cache_dir' do
         root = '/Users/lar/Sites/bunker/public'
         cache_dir = '/Users/lar/Sites/bunker/tmp/uploads'
-        asset = mock(:cache_dir => cache_dir, :root => root)
-        record.expects(:image).returns(asset)
-        record.expects(:image_tmp).returns('images/test.jpg')
+        asset = double(:cache_dir => cache_dir, :root => root)
+        expect(record).to receive(:image).and_return(asset)
+        expect(record).to receive(:image_tmp).and_return('images/test.jpg')
         worker.send :store_directories, record
         expect(worker.tmp_directory).to eql('/Users/lar/Sites/bunker/tmp/uploads/images')
       end
@@ -126,9 +126,9 @@ describe CarrierWave::Workers::StoreAsset do
       it 'sets the tmp_directory correctly if a partial path is set for cache_dir' do
         root = '/Users/lar/Sites/bunker/public'
         cache_dir = 'uploads/tmp'
-        asset = mock(:cache_dir => cache_dir, :root => root)
-        record.expects(:image).returns(asset)
-        record.expects(:image_tmp).returns('images/test.jpg')
+        asset = double(:cache_dir => cache_dir, :root => root)
+        expect(record).to receive(:image).and_return(asset)
+        expect(record).to receive(:image_tmp).and_return('images/test.jpg')
         worker.send :store_directories, record
         expect(worker.tmp_directory).to eql('/Users/lar/Sites/bunker/public/uploads/tmp/images')
       end

data/spec/spec_helper.rb

@@ -15,7 +15,6 @@ module WarningSuppression
 end
 
 RSpec.configure do |c|
-  c.mock_with :mocha
   c.include WarningSuppression
 end
 

data/spec/support/backend_constants.rb

@@ -34,6 +34,7 @@ module Sidekiq
 
     module ClassMethods
       def sidekiq_options(opts = {})
+        opts
       end
 
       def client_push(item)
@@ -52,6 +53,6 @@ end
 
 module Rails
   def self.logger
-    @logger ||= Object.new
+    @logger ||= Logger.new(STDOUT)
   end
 end

data/spec/support/mock_worker.rb

@@ -15,3 +15,8 @@ end
 class MockSidekiqWorker < MockWorker
   include Sidekiq::Worker
 end
+
+class MockNamedSidekiqWorker < MockWorker
+  include Sidekiq::Worker
+  sidekiq_options queue: :even_better_name
+end

metadata

@@ -1,69 +1,55 @@
 --- !ruby/object:Gem::Specification
 name: carrierwave_backgrounder
 version: !ruby/object:Gem::Version
-  version: 0.4.1
+  version: 0.4.2
 platform: ruby
 authors:
 - Larry Sprock
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-06-04 00:00:00.000000000 Z
+date: 2015-08-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: carrierwave
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '0.5'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '0.5'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 2.12.0
+        version: 3.1.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 2.12.0
-- !ruby/object:Gem::Dependency
-  name: mocha
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ~>
-      - !ruby/object:Gem::Version
-        version: 0.13.0
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ~>
-      - !ruby/object:Gem::Version
-        version: 0.13.0
+        version: 3.1.0
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 description: 
@@ -73,9 +59,9 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- .gitignore
-- .rspec
-- .travis.yml
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
 - CHANGELOG.md
 - Gemfile
 - README.md
@@ -115,17 +101,17 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.0.6
+rubygems_version: 2.2.2
 signing_key: 
 specification_version: 4
 summary: Offload CarrierWave's image processing and storage to a background process