carrierwave_backgrounder 0.2.1 → 0.2.2

data/.travis.yml

@@ -1,8 +1,10 @@
 language: ruby
 
 rvm:
- - 1.8.7
- - 1.9.2
  - 1.9.3
  - 2.0.0
- - ree
+ - ruby-head
+
+matrix:
+  allow_failures:
+    - rvm: ruby-head

data/README.md

@@ -1,7 +1,7 @@
 # CarrierWave Backgrounder
 
 [![Build Status](https://secure.travis-ci.org/lardawge/carrierwave_backgrounder.png)](http://travis-ci.org/lardawge/carrierwave_backgrounder)
-[![Code Quality](https://codeclimate.com/badge.png)](https://codeclimate.com/github/lardawge/carrierwave_backgrounder)
+[![Code Climate](https://codeclimate.com/github/lardawge/carrierwave_backgrounder.png)](https://codeclimate.com/github/lardawge/carrierwave_backgrounder)
 [![Still Maintained](http://stillmaintained.com/lardawge/carrierwave_backgrounder.png)](http://stillmaintained.com/lardawge/carrierwave_backgrounder)
 
 I like CarrierWave. That being said, I don't like tying up app instances waiting for images to process.
@@ -58,13 +58,14 @@ end
 For SuckerPunch, you have to configure your queue with a specific worker.
 
 ```ruby
-SuckerPunch.config do
-  queue name: :carrierwave, worker: CarrierWave::Workers::StoreAsset, size: 2
-end
-
 CarrierWave::Backgrounder.configure do |c|
   c.backend :sucker_punch, queue: :carrierwave
 end
+
+# It is important to configure sucker_punch after carrierwave_backgrounder
+SuckerPunch.config do
+  queue name: :carrierwave, worker: CarrierWave::Workers::StoreAsset, size: 2
+end
 ```
 
 
@@ -117,6 +118,15 @@ If you need to process/store the upload immediately:
 @user.process_<column>_upload = true
 ```
 
+This must be set before you assign an upload:
+
+```ruby
+# In a controller
+@user = User.new
+@user.process_avatar_upload = true
+@user.attributes = params[:user]
+```
+
 ### 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
 second argument:

data/lib/backgrounder/orm/activemodel.rb

@@ -7,36 +7,30 @@ module CarrierWave
       module ActiveModel
         include CarrierWave::Backgrounder::ORM::Base
 
-        def process_in_background(column, worker=::CarrierWave::Workers::ProcessAsset)
-          before_save :"set_#{column}_processing", :if => :"enqueue_#{column}_background_job?"
-          send _supported_am_after_callback, :"enqueue_#{column}_background_job", :if => :"enqueue_#{column}_background_job?"
-          super
-        end
-
-        def store_in_background(column, worker=::CarrierWave::Workers::StoreAsset)
-          send _supported_am_after_callback, :"enqueue_#{column}_background_job", :if => :"enqueue_#{column}_background_job?"
-          super
-        end
-
         private
 
-        def _supported_am_after_callback
-          respond_to?(:after_commit) ? :after_commit : :after_save
-        end
-
         def _define_shared_backgrounder_methods(mod, column, worker)
+          before_save :"set_#{column}_processing", :if => :"enqueue_#{column}_background_job?"
+          send _supported_callback, :"enqueue_#{column}_background_job", :if => :"enqueue_#{column}_background_job?"
+
           super
 
           define_method :"#{column}_updated?" do
-            send(:"#{column}_changed?") ||              # after_save support
-            previous_changes.has_key?(:"#{column}") ||  # after_commit support
-            send(:"remote_#{column}_url").present? ||   # Remote upload support
-            send(:"#{column}_cache").present?           # Form failure support
+            options = self.class.uploader_options[column] || {}
+            serialization_column = options[:mount_on] || column
+
+            send(:"#{serialization_column}_changed?") ||              # after_save support
+            previous_changes.has_key?(:"#{serialization_column}") ||  # after_commit support
+            send(:"remote_#{column}_url").present? ||                 # Remote upload support
+            send(:"#{column}_cache").present?                         # Form failure support
           end
         end
+
+        def _supported_callback
+          respond_to?(:after_commit) ? :after_commit : :after_save
+        end
       end # ActiveModel
 
     end # ORM
   end # Backgrounder
 end # CarrierWave
-

data/lib/backgrounder/orm/base.rb

@@ -43,11 +43,6 @@ module CarrierWave
 
           mod = Module.new
           include mod
-          mod.class_eval  <<-RUBY, __FILE__, __LINE__ + 1
-            def set_#{column}_processing
-              self.#{column}_processing = true if respond_to?(:#{column}_processing)
-            end
-          RUBY
 
           _define_shared_backgrounder_methods(mod, column, worker)
         end
@@ -88,6 +83,7 @@ module CarrierWave
             def store_#{column}!
               super if process_#{column}_upload
             end
+
           RUBY
 
           _define_shared_backgrounder_methods(mod, column, worker)
@@ -99,6 +95,10 @@ module CarrierWave
           mod.class_eval  <<-RUBY, __FILE__, __LINE__ + 1
             def #{column}_updated?; true; end
 
+            def set_#{column}_processing
+              self.#{column}_processing = true if respond_to?(:#{column}_processing)
+            end
+
             def enqueue_#{column}_background_job?
               !remove_#{column}? && !process_#{column}_upload && #{column}_updated?
             end
@@ -108,7 +108,6 @@ module CarrierWave
             end
           RUBY
         end
-
       end # Base
 
     end #ORM

data/lib/backgrounder/orm/data_mapper.rb

@@ -6,8 +6,7 @@ module CarrierWave
         include CarrierWave::Backgrounder::ORM::Base
 
         def process_in_background(column, worker=::CarrierWave::Workers::ProcessAsset)
-          before :save, :"set_#{column}_processing"
-          after  :save, :"enqueue_#{column}_background_job"
+          super
 
           class_eval  <<-RUBY, __FILE__, __LINE__ + 1
             def set_#{column}_processing
@@ -18,8 +17,7 @@ module CarrierWave
         end
 
         def store_in_background(column, worker=::CarrierWave::Workers::StoreAsset)
-          before :save, :"set_#{column}_changed"
-          after  :save, :"enqueue_#{column}_background_job"
+          super
 
           class_eval  <<-RUBY, __FILE__, __LINE__ + 1
             def set_#{column}_changed
@@ -36,7 +34,11 @@ module CarrierWave
         private
 
         def _define_shared_backgrounder_methods(mod, column, worker)
+          before :save, :"set_#{column}_changed"
+          after  :save, :"enqueue_#{column}_background_job"
+
           super
+
           class_eval  <<-RUBY, __FILE__, __LINE__ + 1
             attr_reader :#{column}_changed
 

data/lib/backgrounder/support/backends.rb

@@ -1,72 +1,83 @@
-module Support
-  module Backends
+module CarrierWave
+  module Backgrounder
+    module Support
+      module Backends
 
-    def self.included(base)
-      base.extend ClassMethods
-    end
+        def self.included(base)
+          base.extend ClassMethods
+        end
 
-    module ClassMethods
-      attr_reader :queue_options
+        module ClassMethods
+          attr_reader :queue_options
 
-      def backend(queue_name=nil, args={})
-        return @backend if @backend
-        @queue_options = args
-        @backend = queue_name
-      end
+          def backend(queue_name=nil, args={})
+            return @backend if @backend
+            @queue_options = args
+            @backend = queue_name
+          end
 
-      def enqueue_for_backend(worker, class_name, subject_id, mounted_as)
-        self.send :"enqueue_#{backend}", worker, class_name, subject_id, mounted_as
-      end
+          def enqueue_for_backend(worker, class_name, subject_id, mounted_as)
+            self.send :"enqueue_#{backend}", worker, class_name, subject_id, mounted_as
+          end
 
-      private
+          private
 
-      def enqueue_delayed_job(worker, *args)
-        ::Delayed::Job.enqueue worker.new(*args), :queue => queue_options[:queue]
-      end
+          def enqueue_delayed_job(worker, *args)
+            if ::Delayed::Job.new.respond_to?(:queue)
+              ::Delayed::Job.enqueue worker.new(*args), :queue => queue_options[:queue]
+            else
+              ::Delayed::Job.enqueue worker.new(*args)
+              if queue_options[:queue]
+                ::Rails.logger.warn("Queue name given but no queue column exists for Delayed::Job")
+              end
+            end
+          end
 
-      def enqueue_resque(worker, *args)
-        worker.instance_variable_set('@queue', queue_options[:queue] || :carrierwave)
-        ::Resque.enqueue worker, *args
-      end
+          def enqueue_resque(worker, *args)
+            worker.instance_variable_set('@queue', queue_options[:queue] || :carrierwave)
+            ::Resque.enqueue worker, *args
+          end
 
-      def enqueue_sidekiq(worker, *args)
-        args = sidekiq_queue_options('class' => worker, 'args' => args)
-        worker.client_push(args)
-      end
+          def enqueue_sidekiq(worker, *args)
+            args = sidekiq_queue_options('class' => worker, 'args' => args)
+            worker.client_push(args)
+          end
 
-      def enqueue_girl_friday(worker, *args)
-        @girl_friday_queue ||= GirlFriday::WorkQueue.new(queue_options.delete(:queue) || :carrierwave, queue_options) do |msg|
-          worker = msg[:worker]
-          worker.perform
-        end
-        @girl_friday_queue << { :worker => worker.new(*args) }
-      end
+          def enqueue_girl_friday(worker, *args)
+            @girl_friday_queue ||= GirlFriday::WorkQueue.new(queue_options.delete(:queue) || :carrierwave, queue_options) do |msg|
+              worker = msg[:worker]
+              worker.perform
+            end
+            @girl_friday_queue << { :worker => worker.new(*args) }
+          end
 
-      def enqueue_sucker_punch(worker, *args)
-        @sucker_punch_queue ||= SuckerPunch::Queue[queue_options[:queue] || :carrierwave]
-        @sucker_punch_queue.async.perform(*args)
-      end
+          def enqueue_sucker_punch(worker, *args)
+            @sucker_punch_queue ||= SuckerPunch::Queue[queue_options[:queue] || :carrierwave]
+            @sucker_punch_queue.async.perform(*args)
+          end
 
-      def enqueue_qu(worker, *args)
-        worker.instance_variable_set('@queue', queue_options[:queue] || :carrierwave)
-        ::Qu.enqueue worker, *args
-      end
+          def enqueue_qu(worker, *args)
+            worker.instance_variable_set('@queue', queue_options[:queue] || :carrierwave)
+            ::Qu.enqueue worker, *args
+          end
 
-      def enqueue_qc(worker, *args)
-        class_name, subject_id, mounted_as = args
-        ::QC.enqueue "#{worker.name}.perform", class_name, subject_id, mounted_as.to_s
-      end
+          def enqueue_qc(worker, *args)
+            class_name, subject_id, mounted_as = args
+            ::QC.enqueue "#{worker.name}.perform", class_name, subject_id, mounted_as.to_s
+          end
 
-      def enqueue_immediate(worker, *args)
-        worker.new(*args).perform
-      end
+          def enqueue_immediate(worker, *args)
+            worker.new(*args).perform
+          end
 
-      def sidekiq_queue_options(args)
-        args['queue'] = queue_options[:queue] if queue_options[:queue]
-        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]
-        args
+          def sidekiq_queue_options(args)
+            args['queue'] = queue_options[:queue] if queue_options[:queue]
+            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]
+            args
+          end
+        end
       end
     end
   end

data/lib/backgrounder/version.rb

@@ -1,5 +1,5 @@
 module CarrierWave
   module Backgrounder
-    VERSION = "0.2.1"
+    VERSION = "0.2.2"
   end
 end

data/lib/backgrounder/workers/store_asset.rb

@@ -17,6 +17,7 @@ module CarrierWave
           store_directories(record)
           record.send :"process_#{column}_upload=", true
           record.send :"#{column}_tmp=", nil
+          record.send :"#{column}_processing=", nil if record.respond_to?(:"#{column}_processing")
           File.open(cache_path) { |f| record.send :"#{column}=", f }
           if record.save!
             FileUtils.rm_r(tmp_directory, :force => true)

data/lib/carrierwave_backgrounder.rb

@@ -7,28 +7,23 @@ module CarrierWave
   module Backgrounder
     include Support::Backends
 
-    class UnsupportedBackendError < StandardError ; end
-    class TooManyBackendsAvailableError < StandardError ; end
-
     def self.configure
       yield self
       case @backend
       when :sidekiq
+        require 'sidekiq'
         ::CarrierWave::Workers::ProcessAsset.class_eval do
-          require 'sidekiq'
           include ::Sidekiq::Worker
         end
         ::CarrierWave::Workers::StoreAsset.class_eval do
-          require 'sidekiq'
           include ::Sidekiq::Worker
         end
       when :sucker_punch
+        require 'sucker_punch'
         ::CarrierWave::Workers::ProcessAsset.class_eval do
-          require 'sucker_punch'
           include ::SuckerPunch::Worker
         end
         ::CarrierWave::Workers::StoreAsset.class_eval do
-          require 'sucker_punch'
           include ::SuckerPunch::Worker
         end
       end

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

@@ -3,6 +3,7 @@ CarrierWave::Backgrounder.configure do |c|
   # 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

@@ -11,6 +11,7 @@ describe CarrierWave::Backgrounder::ORM::ActiveModel do
       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
@@ -46,6 +47,18 @@ describe CarrierWave::Backgrounder::ORM::ActiveModel 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}}
+        @mock_class.expects(:uploader_options).returns(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
+      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

data/spec/backgrounder/support/backends_spec.rb

@@ -2,187 +2,215 @@ require 'spec_helper'
 require 'support/backend_constants'
 require 'support/mock_worker'
 
-describe Support::Backends do
-  let(:mock_module) { Module.new }
+module CarrierWave::Backgrounder
+  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)
+    before do
+      mock_module.send :include, Support::Backends
     end
 
-    it 'using #backend' do
-      mock_module.backend(:delayed_job)
-      expect(mock_module.backend).to eql(:delayed_job)
-    end
+    describe 'setting backend' do
+      it 'using #backend=' do
+        expect {
+          mock_module.backend = :delayed_job
+        }.to raise_error(NoMethodError)
+      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})
+      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
-  end
 
-  describe '#enqueue_for_backend' do
-    let!(:worker) { MockWorker.new('FakeClass', 1, :image) }
+    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
 
-    context 'delayed_job' do
-      before do
-        @mock_worker = Class.new do
-          def self.perform(*args); new(*args).perform; end
+          MockWorker.expects(:new).returns(worker)
         end
 
-        MockWorker.expects(:new).returns(worker)
-      end
+        context 'queue column exists' do
+          it 'defaults the queue name to nil if none passed to #backend' do
+            mock_module.backend :delayed_job
+            Delayed::Job.expects(:enqueue).with(worker, :queue => nil)
+            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)
+            mock_module.enqueue_for_backend MockWorker, 'FakeClass', 1, :image
+          end
+        end
 
-      it 'defaults the queue name to nil if none passed to #backend' do
-        mock_module.backend :delayed_job
-        Delayed::Job.expects(:enqueue).with(worker, :queue => nil)
-        mock_module.enqueue_for_backend MockWorker, 'FakeClass', 1, :image
+        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)
+            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
+            Delayed::Job.expects(: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))
+            mock_module.enqueue_for_backend MockWorker, 'FakeClass', 1, :image
+          end
+        end
       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)
-        mock_module.enqueue_for_backend MockWorker, 'FakeClass', 1, :image
-      end
-    end
+      context 'resque' do
+        let(:args) { [MockWorker, 'FakeClass', 1, :image] }
 
-    context 'resque' do
-      let(:args) { [MockWorker, 'FakeClass', 1, :image] }
+        before do
+          Resque.expects(:enqueue).with(*args)
+        end
 
-      before do
-        Resque.expects(: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 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)
+        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
 
-      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] }
 
-    context 'sidekiq' do
-      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 })
+          mock_module.backend :sidekiq
+          mock_module.enqueue_for_backend(MockSidekiqWorker, *args)
+        end
 
-      it 'invokes client_push on the class with passed args' do
-        MockSidekiqWorker.expects(:client_push).with({ 'class' => MockSidekiqWorker, 'args' => args })
-        mock_module.backend :sidekiq
-        mock_module.enqueue_for_backend(MockSidekiqWorker, *args)
+        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 })
+          options = {:retry => false, :timeout => 60, :queue => :awesome_queue}
+          mock_module.backend :sidekiq, options
+          mock_module.enqueue_for_backend(MockSidekiqWorker, *args)
+        end
       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 })
-        options = {:retry => false, :timeout => 60, :queue => :awesome_queue}
-        mock_module.backend :sidekiq, options
-        mock_module.enqueue_for_backend(MockSidekiqWorker, *args)
-      end
-    end
+      context 'girl_friday' do
+        let(:args) { [MockWorker, 'FakeClass', 1, :image] }
 
-    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
+          GirlFriday::WorkQueue.expects(:new).with(:carrierwave, {}).returns([])
+          mock_module.enqueue_for_backend(*args)
+        end
 
-      it 'instantiates a GirlFriday work queue if one does not exist' do
-        mock_module.backend :girl_friday
-        GirlFriday::WorkQueue.expects(:new).with(:carrierwave, {}).returns([])
-        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([])
+          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([])
-        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
+          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
-        mock_module.enqueue_for_backend(*args)
+        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
 
-      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(:mock_sp) { mock('SuckerPunch')}
 
-    context 'sucker_punch' do
-      let(:args) { [MockWorker, 'FakeClass', 1, :image] }
-      let(:mock_sp) { mock('SuckerPunch')}
+        before do
+          mock_sp.expects(:async).returns(mock_sp)
+          mock_sp.expects(:perform).with('FakeClass', 1, :image)
+        end
 
-      before do
-        mock_sp.expects(:async).returns(mock_sp)
-        mock_sp.expects(:perform).with('FakeClass', 1, :image)
-      end
+        it 'sets the queue to :carrierwave by default' do
+          SuckerPunch::Queue.expects(:[]).with(:carrierwave).returns(mock_sp)
+          mock_module.backend :sucker_punch
+          mock_module.enqueue_for_backend(*args)
+        end
 
-      it 'sets the queue to :carrierwave by default' do
-        SuckerPunch::Queue.expects(:[]).with(:carrierwave).returns(mock_sp)
-        mock_module.backend :sucker_punch
-        mock_module.enqueue_for_backend(*args)
+        it 'sets the queue to backend :queue option' do
+          SuckerPunch::Queue.expects(:[]).with(:awesome_queue).returns(mock_sp)
+          mock_module.backend :sucker_punch, :queue => :awesome_queue
+          mock_module.enqueue_for_backend(*args)
+        end
       end
 
-      it 'sets the queue to backend :queue option' do
-        SuckerPunch::Queue.expects(:[]).with(:awesome_queue).returns(mock_sp)
-        mock_module.backend :sucker_punch, :queue => :awesome_queue
-        mock_module.enqueue_for_backend(*args)
-      end
-    end
+      context 'qu' do
+        let(:args) { [MockWorker, 'FakeClass', 1, :image] }
+        before do
+          Qu.expects(:enqueue).with(*args)
+        end
 
-    context 'qu' do
-      let(:args) { [MockWorker, 'FakeClass', 1, :image] }
-      before do
-        Qu.expects(: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 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)
+        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
 
-      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)
+      context 'qc' do
+        it 'calls enqueue with the passed args' do
+          QC.expects(:enqueue).with("MockWorker.perform", 'FakeClass', 1, 'image')
+          mock_module.backend :qc
+          mock_module.enqueue_for_backend(MockWorker, 'FakeClass', 1, :image)
+        end
       end
-    end
 
-    context 'qc' do
-      it 'calls enqueue with the passed args' do
-        QC.expects(:enqueue).with("MockWorker.perform", 'FakeClass', 1, 'image')
-        mock_module.backend :qc
-        mock_module.enqueue_for_backend(MockWorker, 'FakeClass', 1, :image)
+      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)
+          mock_module.backend :immediate
+          mock_module.enqueue_for_backend(MockWorker, 'FakeClass', 1, :image)
+        end
       end
-    end
 
-    context 'immediate' do
-      it 'instantiates a worker passing the args and calls perform' do
-        worker = mock('Worker')
-        MockWorker.expects(:new).with('FakeClass', 1, :image).returns(worker)
-        worker.expects(:perform)
-        mock_module.backend :immediate
-        mock_module.enqueue_for_backend(MockWorker, 'FakeClass', 1, :image)
-      end
     end
-
   end
 end
-

data/spec/support/backend_constants.rb

@@ -6,7 +6,14 @@ module GirlFriday
 end
 
 module Delayed
-  module Job
+  class Job
+    def self.column_names
+      %w(id priority attempts handler queue last_error run_at locked_at failed_at locked_by created_at updated_at)
+    end
+
+    column_names.each do |column_name|
+      define_method(column_name) { nil }
+    end
   end
 end
 
@@ -42,3 +49,9 @@ module SuckerPunch
   class Queue
   end
 end
+
+module Rails
+  def self.logger
+    @logger ||= Object.new
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: carrierwave_backgrounder
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.2.2
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-03-16 00:00:00.000000000 Z
+date: 2013-07-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: carrierwave
@@ -128,7 +128,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 1936252162021597709
+      hash: -3663801014250958457
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -137,10 +137,10 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 1936252162021597709
+      hash: -3663801014250958457
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.24
+rubygems_version: 1.8.25
 signing_key: 
 specification_version: 3
 summary: Offload CarrierWave's image processing and storage to a background process