carrierwave_backgrounder 0.4.2 → 1.0.0.beta

data/lib/backgrounder/workers/store_asset_mixin.rb

@@ -0,0 +1,38 @@
+# encoding: utf-8
+module CarrierWave
+  module Workers
+
+    module StoreAssetMixin
+      include CarrierWave::Workers::Base
+
+      def self.included(base)
+        base.extend CarrierWave::Workers::ClassMethods
+      end
+
+      def perform(*args)
+        record = super(*args)
+
+        return unless record && record.send(:"#{column}_tmp")
+
+        record.send :"process_#{column}_upload=", true
+        record.send :"#{column}_cache=", record.send(:"#{column}_tmp")  # Set the cache path
+        cache_assets! record.send(:"#{column}")                         # Trigger version creation
+        store_assets! record.send(:"#{column}")                         # Store the files
+        record.send :"#{column}_tmp=", nil
+        record.send :"#{column}_processing=", false if record.respond_to?(:"#{column}_processing")
+        record.save!
+      end
+
+      private
+
+      def cache_assets!(asset)
+        asset.is_a?(Array) ? asset.map(&:cache!) : asset.cache!
+      end
+
+      def store_assets!(asset)
+        asset.is_a?(Array) ? asset.map(&:store!) : asset.store!
+      end
+    end # StoreAssetMixin
+
+  end # Workers
+end # Backgrounder

data/lib/backgrounder/workers.rb

@@ -1,3 +1,6 @@
 require 'backgrounder/workers/base'
+require 'backgrounder/workers/class_methods'
+require 'backgrounder/workers/process_asset_mixin'
+require 'backgrounder/workers/store_asset_mixin'
 require 'backgrounder/workers/process_asset'
 require 'backgrounder/workers/store_asset'

data/lib/carrierwave_backgrounder.rb

@@ -1,3 +1,4 @@
+require 'fileutils'
 require 'active_support/core_ext/object'
 require 'backgrounder/support/backends'
 require 'backgrounder/orm/base'
@@ -7,10 +8,19 @@ module CarrierWave
   module Backgrounder
     include Support::Backends
 
+    class << self
+      attr_reader :worker_klass
+    end
+
     def self.configure
       yield self
-      case @backend
+
+      case backend
+      when :active_job
+        @worker_klass = "CarrierWave::Workers::ActiveJob"
       when :sidekiq
+        @worker_klass = "CarrierWave::Workers"
+
         require 'sidekiq'
         ::CarrierWave::Workers::ProcessAsset.class_eval do
           include ::Sidekiq::Worker
@@ -18,17 +28,8 @@ module CarrierWave
         ::CarrierWave::Workers::StoreAsset.class_eval do
           include ::Sidekiq::Worker
         end
-      when :sucker_punch
-        require 'sucker_punch'
-        ::CarrierWave::Workers::ProcessAsset.class_eval do
-          include ::SuckerPunch::Job
-        end
-        ::CarrierWave::Workers::StoreAsset.class_eval do
-          include ::SuckerPunch::Job
-        end
       end
     end
-
   end
 end
 

data/lib/generators/carrierwave_backgrounder/install_generator.rb

@@ -10,7 +10,7 @@ module CarrierwaveBackgrounder
       def info_config
         puts <<-EOF
 
-        \e[33mBy default :delayed_job is used as the backend for carrierwave_backgrounder with :carrierwave as the queue name.
+        \e[33mBy default :active_job is used as the backend for carrierwave_backgrounder with :carrierwave as the queue name.
         To change this, edit config/initializers/carrierwave_backgrounder.rb.\e[0m
 
         EOF

data/lib/generators/carrierwave_backgrounder/templates/config/initializers/carrierwave_backgrounder.rb

@@ -1,9 +1,4 @@
 CarrierWave::Backgrounder.configure do |c|
-  c.backend :delayed_job, queue: :carrierwave
-  # c.backend :resque, queue: :carrierwave
+  c.backend :active_job, queue: :carrierwave
   # c.backend :sidekiq, queue: :carrierwave
-  # c.backend :girl_friday, queue: :carrierwave
-  # c.backend :sucker_punch, queue: :carrierwave
-  # c.backend :qu, queue: :carrierwave
-  # c.backend :qc
 end

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
@@ -31,80 +30,13 @@ module CarrierWave::Backgrounder
     describe '#enqueue_for_backend' do
       let!(:worker) { MockWorker.new('FakeClass', 1, :image) }
 
-      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
+      context 'active_job' do
+        let(:args) { ['FakeClass', 1, :image] }
 
-        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)
+        it 'invokes perform_later with string arguments' do
+          expect(MockWorker).to receive(:perform_later).with('FakeClass', '1', 'image')
+          mock_module.backend :active_job
+          mock_module.enqueue_for_backend(MockWorker, *args)
         end
       end
 
@@ -112,7 +44,7 @@ module CarrierWave::Backgrounder
         let(:args) { ['FakeClass', 1, :image] }
 
         it 'invokes client_push on the class with passed args' do
-          expect(MockSidekiqWorker).to receive(:client_push).with({ 'class' => MockSidekiqWorker, 'args' => args })
+          expect(MockSidekiqWorker).to receive(:client_push).with({ 'class' => MockSidekiqWorker, 'args' => args.map(&:to_s) })
           mock_module.backend :sidekiq
           mock_module.enqueue_for_backend(MockSidekiqWorker, *args)
         end
@@ -122,7 +54,7 @@ module CarrierWave::Backgrounder
                                                                     'retry' => false,
                                                                     'timeout' => 60,
                                                                     'queue' => :awesome_queue,
-                                                                    'args' => args })
+                                                                    'args' => args.map(&:to_s) })
           options = {:retry => false, :timeout => 60, :queue => :awesome_queue}
           mock_module.backend :sidekiq, options
           mock_module.enqueue_for_backend(MockSidekiqWorker, *args)
@@ -132,93 +64,12 @@ module CarrierWave::Backgrounder
           expect(MockNamedSidekiqWorker).to receive(:client_push).with({ 'class' => MockNamedSidekiqWorker,
                                                                     'retry' => false,
                                                                     'timeout' => 60,
-                                                                    'args' => args })
+                                                                    'args' => args.map(&:to_s) })
           options = {:retry => false, :timeout => 60}
           mock_module.backend :sidekiq, options
           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