carrierwave_backgrounder 0.4.3 → 1.0.0.beta

data/spec/backgrounder/orm/activemodel_spec.rb

@@ -8,6 +8,7 @@ RSpec.describe CarrierWave::Backgrounder::ORM::ActiveModel do
       def self.before_save(method, opts); nil; end
       def self.after_commit(method, opts); nil; end
       def avatar_changed?; nil;  end
+      def avatar_present?; true; end
       def remote_avatar_url; OpenStruct.new(:present? => true); end
       def remove_avatar?; false; end
       def previous_changes; {}; end
@@ -54,7 +55,7 @@ RSpec.describe CarrierWave::Backgrounder::ORM::ActiveModel do
       end
 
       it "returns true if alternate column is changed" do
-        expect(instance).to receive(:some_other_column_changed?).and_return(true)
+        expect(instance).to receive(:previous_changes).and_return({:some_other_column => true})
         expect(instance.avatar_updated?).to be_truthy
       end
     end
@@ -66,20 +67,17 @@ RSpec.describe CarrierWave::Backgrounder::ORM::ActiveModel do
 
     it "calls column_changed?" do
       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
       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
       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
@@ -87,7 +85,6 @@ RSpec.describe CarrierWave::Backgrounder::ORM::ActiveModel do
 
     it "calls avatar_cache" do
       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')

data/spec/backgrounder/support/backends_spec.rb

@@ -1,5 +1,4 @@
 require 'spec_helper'
-require 'support/backend_constants'
 require 'support/mock_worker'
 
 module CarrierWave::Backgrounder
@@ -41,83 +40,6 @@ module CarrierWave::Backgrounder
         end
       end
 
-      context 'delayed_job' do
-        before do
-          @mock_worker = Class.new do
-            def self.perform(*args); new(*args).perform; end
-          end
-
-          allow(MockWorker).to receive(:new).and_return(worker)
-        end
-
-        context 'queue column exists' do
-          it 'does not pass the queue name if none passed to #backend' do
-            mock_module.backend :delayed_job
-            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
-            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
-
-        context 'queue column does not exist' do
-          before do
-            column_names = Delayed::Job.column_names.tap { |cn| cn.delete('queue') }
-            allow(Delayed::Job).to receive(:column_names).and_return(column_names)
-            Delayed::Job.class_eval { remove_method(:queue) }
-          end
-
-          after do
-            Delayed::Job.class_eval { define_method(:queue) { nil } }
-          end
-
-          it 'does not pass a queue name if none passed to #backend' do
-            mock_module.backend :delayed_job
-            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
-            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
-      end
-
-      context 'resque' do
-        let(:args) { [MockWorker, 'FakeClass', 1, :image] }
-
-        before do
-          allow(Resque).to receive(:enqueue).with(*args)
-        end
-
-        it 'sets a variable with the queue name, defaults to :carrierwave' do
-          mock_module.backend :resque
-          mock_module.enqueue_for_backend(*args)
-          expect(MockWorker.instance_variable_get '@queue').to eql(:carrierwave)
-        end
-
-        it 'sets a variable to the queue name passed to #backend' do
-          mock_module.backend :resque, :queue => :awesome_queue
-          mock_module.enqueue_for_backend(*args)
-          expect(MockWorker.instance_variable_get '@queue').to eql(:awesome_queue)
-        end
-      end
-
       context 'sidekiq' do
         let(:args) { ['FakeClass', 1, :image] }
 
@@ -148,87 +70,6 @@ module CarrierWave::Backgrounder
           mock_module.enqueue_for_backend(MockNamedSidekiqWorker, *args)
         end
       end
-
-      context 'girl_friday' do
-        let(:args) { [MockWorker, 'FakeClass', 1, :image] }
-
-        it 'instantiates a GirlFriday work queue if one does not exist' do
-          mock_module.backend :girl_friday
-          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
-          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', [])
-          expect(GirlFriday::WorkQueue).to receive(:new).never
-          mock_module.enqueue_for_backend(*args)
-        end
-
-        it 'add a worker to the girl_friday queue' do
-          expected = [{ :worker => MockWorker.new('FakeClass', 1, :image) }]
-          mock_module.backend :girl_friday
-          mock_module.instance_variable_set('@girl_friday_queue', [])
-          mock_module.enqueue_for_backend(*args)
-          expect(mock_module.instance_variable_get '@girl_friday_queue').to eql(expected)
-        end
-      end
-
-      context 'sucker_punch' do
-        let(:args) { [MockWorker, 'FakeClass', 1, :image] }
-        let(:job) { double('job') }
-
-        it 'invokes a new worker' do
-          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
-      end
-
-      context 'qu' do
-        let(:args) { [MockWorker, 'FakeClass', 1, :image] }
-        before do
-          allow(Qu).to receive(:enqueue).with(*args)
-        end
-
-        it 'sets a variable with the queue name, defaults to :carrierwave' do
-          mock_module.backend :qu
-          mock_module.enqueue_for_backend(*args)
-          expect(MockWorker.instance_variable_get '@queue').to eql(:carrierwave)
-        end
-
-        it 'sets a variable to the queue name passed to #backend' do
-          mock_module.backend :qu, :queue => :awesome_queue
-          mock_module.enqueue_for_backend(*args)
-          expect(MockWorker.instance_variable_get '@queue').to eql(:awesome_queue)
-        end
-      end
-
-      context 'qc' do
-        it 'calls enqueue with the passed args' do
-          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 = 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

@@ -22,9 +22,10 @@ RSpec.describe CarrierWave::Workers::ProcessAsset do
 
     before do
       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)
+      allow(user).to receive(:image).thrice.and_return(image)
+
+      expect(image).to receive(:recreate_versions!).once.and_return(true)
+      expect(image).to receive(:file).and_return(image)
     end
 
     it 'processes versions with image_processing column' do
@@ -48,9 +49,10 @@ RSpec.describe CarrierWave::Workers::ProcessAsset do
     before do
       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)
+
+      expect(admin).to receive(:respond_to?).with(:avatar_processing).once.and_return(false)
+      expect(avatar).to receive(:recreate_versions!).once.and_return(true)
+      expect(avatar).to receive(:file).and_return(avatar)
 
       worker.perform admin, '23', :avatar
     end

data/spec/backgrounder/workers/store_asset_spec.rb

@@ -8,6 +8,22 @@ RSpec.describe CarrierWave::Workers::StoreAsset do
   let(:user) { double('User') }
   let!(:worker) { worker_class.new(user, '22', :image) }
 
+  def stub_worker(obj, asset)
+    allow(asset).to receive(:root).once.and_return(File.expand_path('..', __FILE__))
+    allow(asset).to receive(:cache_dir).once.and_return('fixtures')
+    allow(obj).to receive(:image_tmp).and_return('images/test.jpg')
+    allow(obj).to receive(:find).with('22').once.and_return(obj)
+    allow(obj).to receive(:image=)
+
+    expect(asset).to receive(:cache!).once
+    expect(asset).to receive(:store!).once
+    expect(obj).to receive(:image).twice.and_return(image)
+    expect(obj).to receive(:process_image_upload=).with(true).once
+    expect(obj).to receive(:image_cache=).with("images/test.jpg").once
+    expect(obj).to receive(:image_tmp=).with(nil).once
+    expect(obj).to receive(:save!).once
+  end
+
   describe ".perform" do
     it 'creates a new instance and calls perform' do
       args = [user, '22', :image]
@@ -17,61 +33,14 @@ RSpec.describe CarrierWave::Workers::StoreAsset do
     end
   end
 
-  describe "#perform" do
-    let(:image)  { double('UserAsset') }
-
-    before do
-      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
-      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
-      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
-      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
-      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) { double('Admin') }
     let(:image)  { double('AdminAsset') }
     let(:worker) { worker_class.new }
 
     before do
-      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
+      stub_worker(admin, image)
+      worker.perform admin, '22', :image
     end
 
     it 'sets klass' do
@@ -79,59 +48,11 @@ RSpec.describe CarrierWave::Workers::StoreAsset do
     end
 
     it 'sets column' do
-      expect(worker.id).to eql('23')
+      expect(worker.id).to eql('22')
     end
 
     it 'sets id' do
-      expect(worker.column).to eql(:avatar)
-    end
-  end
-
-  describe '#store_directories' do
-    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 = 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
-
-      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 = 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
-    end
-
-    context 'tmp_directory' 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 = 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
-
-      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 = 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
+      expect(worker.column).to eql(:image)
     end
   end
 end

data/spec/integrations/process_in_background_multi_upload_spec.rb

@@ -0,0 +1,81 @@
+require 'rails_helper'
+
+RSpec.describe '::process_in_background multi-upload support', clear_images: true do
+  let(:admin) { Admin.new }
+
+  context 'when assigning an asset' do
+    before(:each) do
+      admin.update(images: load_files('test-1.jpg', 'test-2.jpg'))
+    end
+
+    it 'creates a temp file and stores the path' do
+      expect(file_count("spec/support/dummy_app/public/uploads/admin/images/#{admin.id}")).to eql(2)
+      expect(admin.images.present?).to be(true)
+    end
+
+    it 'creates a background job in carrierwave queue' do
+      expect(Sidekiq::Queues["carrierwave"].size).to eql(1)
+    end
+
+    it 'sets the <column>_processing flag to true' do
+      expect(admin.images_processing).to be(true)
+    end
+  end
+
+  context 'when processing the worker' do
+    before do
+      admin.update(images: load_files('test-1.jpg','test-2.jpg'))
+      expect(admin.images_processing).to be(true)
+      process_latest_sidekiq_job
+      admin.reload
+    end
+
+    it 'creates the versions' do
+      version_paths = AvatarUploader.versions.keys.map { |key| admin.images.map { |i| i.send(key).current_path } }.flatten
+      version_paths.each { |path| expect(File.exist? path).to be(true) }
+    end
+
+    it 'removes the files tmp directory' do
+      expect(file_count('spec/support/dummy_app/tmp/images')).to eql(0)
+    end
+
+    it 'sets the <column>_processing flag to false' do
+      expect(admin.avatar_processing).to be(false)
+    end
+  end
+
+  context 'when saving a record' do
+    let!(:admin) {
+      Sidekiq::Testing.inline! do
+        Admin.create(images: load_files('test-1.jpg'))
+      end
+    }
+
+    it 'does not enqueue a new job' do
+      expect { admin.reload.save }.to_not change(Sidekiq::Queues["carrierwave"], :size)
+    end
+  end
+
+  context 'when setting a column for removal' do
+    let!(:admin) {
+      Sidekiq::Testing.inline! do
+        Admin.create(images: load_files('test-1.jpg'))
+      end
+    }
+
+    before do
+      expect(admin.reload.images.present?).to be(true)
+
+      admin.remove_images = true
+      admin.save!
+    end
+
+    it 'removes the attachment' do
+      expect(admin.images.present?).to be(false)
+    end
+
+    it 'does not enqueue a new job' do
+      expect(Sidekiq::Queues["carrierwave"].size).to be(0)
+    end
+  end
+end

data/spec/integrations/process_in_background_spec.rb

@@ -0,0 +1,75 @@
+require 'rails_helper'
+
+RSpec.describe '::process_in_background', clear_images: true do
+  let(:admin) { Admin.new }
+
+  context 'when assigning an asset' do
+    before(:each) do
+      admin.update(avatar: load_file('test-1.jpg'))
+    end
+
+    it 'stores the original file' do
+      expect(file_count("spec/support/dummy_app/public/uploads/admin/avatar/#{admin.id}")).to eql(1)
+      expect(admin.avatar.file.present?).to be(true)
+    end
+
+    it 'creates a background job in carrierwave queue' do
+      expect(Sidekiq::Queues["carrierwave"].size).to eql(1)
+    end
+
+    it 'sets the <column>_processing flag to true' do
+      expect(admin.avatar_processing).to be(true)
+    end
+  end
+
+  context 'when processing the worker' do
+    before do
+      admin.update(avatar: load_file('test-1.jpg'))
+      expect(admin.avatar_processing).to be(true)
+      process_latest_sidekiq_job
+      admin.reload
+    end
+
+    it 'creates the versions' do
+      version_paths = admin.avatar.versions.keys.map { |key| admin.avatar.send(key).current_path }
+      version_paths.each { |path| expect(File.exist? path).to be(true) }
+    end
+
+    it 'removes the files tmp directory' do
+      expect(file_count('spec/support/dummy_app/tmp/images')).to eql(0)
+    end
+
+    it 'sets the <column>_processing flag to false' do
+      expect(admin.avatar_processing).to be(false)
+    end
+  end
+
+  context 'when saving a record' do
+    let!(:admin) {
+      Sidekiq::Testing.inline! do
+        Admin.create(avatar: load_file('test-1.jpg'))
+      end
+    }
+
+    it 'does not enqueue a new job' do
+      expect { admin.reload.save }.to_not change(Sidekiq::Queues["carrierwave"], :size)
+    end
+  end
+
+  context 'when setting a column for removal' do
+    let!(:admin) {
+      Sidekiq::Testing.inline! do
+        Admin.create(avatar: load_file('test-1.jpg'))
+      end
+    }
+
+    it 'removes the attachment' do
+      expect(admin.reload.avatar.file.nil?).to be(false)
+
+      admin.remove_avatar = true
+      admin.save!
+
+      expect(admin.avatar.file.nil?).to be(true)
+    end
+  end
+end

data/spec/integrations/store_in_background_multi_upload_spec.rb

@@ -0,0 +1,87 @@
+require 'rails_helper'
+
+RSpec.describe '::store_in_background multi-upload support', clear_images: true do
+  let(:user) { User.new }
+
+  context 'when assigning an asset' do
+    before(:each) do
+      expect(file_count('spec/support/dummy_app/tmp/images')).to eql(0)
+      user.update(images: load_files('test-1.jpg', 'test-2.jpg'))
+    end
+
+    it 'creates a temp file and stores the path' do
+      expect(file_count('spec/support/dummy_app/tmp/images')).to eql(2)
+      expect(user.images_tmp).to include('test-1.jpg')
+    end
+
+    it 'creates a background job in carrierwave queue' do
+      expect(Sidekiq::Queues["carrierwave"].size).to eql(1)
+    end
+
+    it 'sets the <column>_processing flag to true' do
+      expect(user.images_processing).to be(true)
+    end
+  end
+
+  context 'when processing the worker' do
+    before do
+      user.update(images: load_files('test-1.jpg','test-2.jpg'))
+      expect(user.images_processing).to be(true)
+      process_latest_sidekiq_job
+      user.reload
+    end
+
+    it 'creates the versions' do
+      version_paths = AvatarUploader.versions.keys.map { |key| user.images.map { |i| i.send(key).current_path } }.flatten
+      version_paths.each { |path| expect(File.exist? path).to be(true) }
+    end
+
+    it 'sets the <column>_tmp to nil' do
+      expect(user.avatar_tmp).to be_nil
+    end
+
+    it 'removes the files tmp directory' do
+      expect(file_count('spec/support/dummy_app/tmp/images')).to eql(0)
+    end
+
+    it 'sets the <column>_processing flag to false' do
+      expect(user.avatar_processing).to be(false)
+    end
+  end
+
+  context 'when saving a record' do
+    let!(:user) {
+      Sidekiq::Testing.inline! do
+        User.create(images: load_files('test-1.jpg'))
+      end
+    }
+
+    it 'does not enqueue a new job' do
+      expect { user.reload.save }.to_not change(Sidekiq::Queues["carrierwave"], :size)
+    end
+  end
+
+  context 'when setting a column for removal' do
+    let!(:user) {
+      Sidekiq::Testing.inline! do
+        User.create(images: load_files('test-1.jpg'))
+      end
+    }
+
+    before do
+      expect(user.reload.images.present?).to be(true)
+
+      user.remove_images = true
+      user.save!
+    end
+
+    it 'removes the attachment' do
+      expect(user.images.present?).to be(false)
+    end
+
+    it 'does not enqueue a new job' do
+      expect(Sidekiq::Queues["carrierwave"].size).to be(0)
+    end
+
+  end
+end