carrierwave_backgrounder_revived 1.0.0

data/lib/carrierwave_backgrounder.rb

@@ -0,0 +1,35 @@
+require 'active_support/core_ext/object'
+require 'backgrounder/support/backends'
+require 'backgrounder/orm/base'
+require 'backgrounder/delay'
+
+module CarrierWave
+  module Backgrounder
+    include Support::Backends
+
+    def self.configure
+      yield self
+      case @backend
+      when :sidekiq
+        require 'sidekiq'
+        ::CarrierWave::Workers::ProcessAsset.class_eval do
+          include ::Sidekiq::Worker
+        end
+        ::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
+
+require 'backgrounder/railtie' if defined?(Rails)

data/lib/generators/carrierwave_backgrounder/USAGE

@@ -0,0 +1,8 @@
+Description:
+    To copy CarrierWaveBackgrounder initializer to your Rails App, with some configuration values, run the following:
+
+Example:
+    rails generate carrierwave_backgrounder:install
+
+    This will create:
+        config/initializer/carrierwave_backgrounder.rb

data/lib/generators/carrierwave_backgrounder/install_generator.rb

@@ -0,0 +1,20 @@
+module CarrierwaveBackgrounder
+  module Generators
+    class InstallGenerator < Rails::Generators::Base
+      source_root File.expand_path('../templates', __FILE__)
+
+      def copy_config
+        template "config/initializers/carrierwave_backgrounder.rb"
+      end
+
+      def info_config
+        puts <<-EOF
+
+        \e[33mBy default :delayed_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
+      end
+    end
+  end
+end

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

@@ -0,0 +1,10 @@
+CarrierWave::Backgrounder.configure do |c|
+  c.backend :delayed_job, queue: :carrierwave
+  # c.backend :active_job, queue: :carrierwave
+  # c.backend :resque, 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

@@ -0,0 +1,97 @@
+require 'spec_helper'
+require 'ostruct'
+require 'backgrounder/orm/activemodel'
+
+RSpec.describe CarrierWave::Backgrounder::ORM::ActiveModel do
+  before do
+    @mock_class = Class.new do
+      def self.before_save(method, opts); nil; end
+      def self.after_commit(method, opts); nil; end
+      def avatar_changed?; nil;  end
+      def remote_avatar_url; OpenStruct.new(:present? => true); end
+      def remove_avatar?; false; end
+      def previous_changes; {}; end
+      def self.uploader_options; {}; end
+    end
+
+    @mock_class.extend CarrierWave::Backgrounder::ORM::ActiveModel
+  end
+
+  describe '.store_in_background' do
+    context 'setting up callbacks' do
+      it 'creates an after_commit hook' do
+        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
+  end
+
+  describe '.process_in_background' do
+    context 'setting up callbacks' do
+      it 'creates a before_save hook' do
+        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
+        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
+  end
+
+  describe '#trigger_column_background_processing?' do
+    let(:instance) { @mock_class.new }
+
+    before do
+      @mock_class.process_in_background :avatar
+    end
+
+    context 'mount_on option is set' do
+      before do
+        options_hash = {:avatar => {:mount_on => :some_other_column}}
+        expect(@mock_class).to receive(:uploader_options).and_return(options_hash)
+      end
+
+      it "returns true if alternate column is changed" do
+        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
+      expect(instance).to receive(:process_avatar_upload)
+      expect(instance.enqueue_avatar_background_job?).to be_truthy
+    end
+
+    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
+    end
+
+    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')
+      expect(instance.enqueue_avatar_background_job?).to be_truthy
+    end
+  end
+end

data/spec/backgrounder/orm/base_spec.rb

@@ -0,0 +1,74 @@
+require 'spec_helper'
+
+
+RSpec.describe CarrierWave::Backgrounder::ORM::Base do
+  before do
+    @mock_class = Class.new do
+      def self.before_save(method, opts); nil; end
+      def self.after_commit(method, opts); nil; end
+    end
+
+    @mock_class.extend CarrierWave::Backgrounder::ORM::Base
+  end
+
+  it 'mixes in the two DSL methods' do
+    expect(@mock_class).to respond_to(:process_in_background)
+    expect(@mock_class).to respond_to(:store_in_background)
+  end
+
+  describe '.process_in_background' do
+    context 'including new methods' do
+      before do
+        @mock_class.process_in_background :avatar
+        @instance = @mock_class.new
+      end
+
+      it 'creates a processing enabled accessor' do
+        expect(@instance).to respond_to(:process_avatar_upload)
+        expect(@instance).to respond_to(:process_avatar_upload=)
+      end
+
+      it 'create a setter for the processing attribute' do
+        expect(@instance).to respond_to(:set_avatar_processing)
+      end
+
+      it 'create a background job queuer' do
+        expect(@instance).to respond_to(:enqueue_avatar_background_job)
+      end
+
+      it 'create a trigger interrogator' do
+        expect(@instance).to respond_to(:enqueue_avatar_background_job?)
+      end
+    end
+  end
+
+  describe 'store in background' do
+    describe 'including new methods' do
+      before do
+        @mock_class.store_in_background :avatar
+        @instance = @mock_class.new
+      end
+
+      it 'creates a processing enabled accessor' do
+        expect(@instance).to respond_to(:process_avatar_upload)
+        expect(@instance).to respond_to(:process_avatar_upload=)
+      end
+
+      it 'overrides the write column identifier method from carrierwave' do
+        expect(@instance).to respond_to(:write_avatar_identifier)
+      end
+
+      it 'overrides the store column method from carrierwave' do
+        expect(@instance).to respond_to(:store_avatar!)
+      end
+
+      it 'create a background job queuer' do
+        expect(@instance).to respond_to(:enqueue_avatar_background_job)
+      end
+
+      it 'create a trigger interrogator' do
+        expect(@instance).to respond_to(:enqueue_avatar_background_job?)
+      end
+    end
+  end
+end

data/spec/backgrounder/support/backends_spec.rb

@@ -0,0 +1,234 @@
+require 'spec_helper'
+require 'support/backend_constants'
+require 'support/mock_worker'
+
+module CarrierWave::Backgrounder
+  RSpec.describe Support::Backends do
+    let(:mock_module) { Module.new }
+
+    before do
+      mock_module.send :include, Support::Backends
+    end
+
+    describe 'setting backend' do
+      it 'using #backend=' do
+        expect {
+          mock_module.backend = :delayed_job
+        }.to raise_error(NoMethodError)
+      end
+
+      it 'using #backend' do
+        mock_module.backend(:delayed_job)
+        expect(mock_module.backend).to eql(:delayed_job)
+      end
+
+      it 'allows passing of queue_options' do
+        mock_module.backend(:delayed_job, :queue => :awesome_queue)
+        expect(mock_module.queue_options).to eql({:queue => :awesome_queue})
+      end
+    end
+
+    describe '#enqueue_for_backend' do
+      let!(:worker) { MockWorker.new('FakeClass', 1, :image) }
+
+      context 'active_job' do
+        let(:args) { ['FakeClass', 1, :image] }
+
+        it 'invokes perform with string arguments' do
+          expect(MockWorker).to receive(:perform).with('FakeClass', '1', 'image')
+          mock_module.backend :active_job
+          mock_module.enqueue_for_backend(MockWorker, *args)
+        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] }
+
+        it 'invokes client_push on the class with passed args' do
+          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
+          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
+        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