delayed-job-ajaycb 2.0.10

data/spec/delayed_method_spec.rb

@@ -0,0 +1,46 @@
+require 'spec_helper'
+
+describe Object do
+  before       { Delayed::Job.delete_all }
+
+  it "should call #delay on methods which are wrapped with handle_asynchronously" do
+    story = Story.create :text => 'Once upon...'
+  
+    Delayed::Job.count.should == 0
+  
+    story.whatever(1, 5)
+  
+    Delayed::Job.count.should == 1
+    job =  Delayed::Job.first
+    job.payload_object.class.should   == Delayed::PerformableMethod
+    job.payload_object.method.should  == :whatever_without_delay
+    job.payload_object.args.should    == [1, 5]
+    job.payload_object.perform.should == 'Once upon...'
+  end
+
+  context "delay" do
+    it "should raise a ArgumentError if target method doesn't exist" do
+      lambda { Object.new.delay.method_that_does_not_exist }.should raise_error(NoMethodError)
+    end
+
+    it "should add a new entry to the job table when delay is called on it" do
+      lambda { Object.new.delay.to_s }.should change { Delayed::Job.count }.by(1)
+    end
+
+    it "should add a new entry to the job table when delay is called on the class" do
+      lambda { Object.delay.to_s }.should change { Delayed::Job.count }.by(1)
+    end
+    
+    it "should set job options" do
+      run_at = 1.day.from_now
+      job = Object.delay(:priority => 20, :run_at => run_at).to_s
+      job.run_at.should == run_at
+      job.priority.should == 20
+    end
+    
+    it "should save args for original method" do
+      job = 3.delay.+(5)
+      job.payload_object.args.should == [5]
+    end
+  end
+end

data/spec/message_sending_spec.rb

@@ -0,0 +1,89 @@
+require 'spec_helper'
+
+describe Delayed::MessageSending do
+  describe "handle_asynchronously" do
+    class Story < ActiveRecord::Base
+      def tell!(arg)
+      end
+      handle_asynchronously :tell!
+    end
+    
+    it "should alias original method" do
+      Story.new.should respond_to(:tell_without_delay!)
+      Story.new.should respond_to(:tell_with_delay!)
+    end
+    
+    it "should create a PerformableMethod" do
+      story = Story.create!
+      lambda {
+        job = story.tell!(1)
+        job.payload_object.class.should   == Delayed::PerformableMethod
+        job.payload_object.method.should  == :tell_without_delay!
+        job.payload_object.args.should    == [1]
+      }.should change { Delayed::Job.count }
+    end
+
+    describe 'with options' do
+      class Fable
+        class << self
+          attr_accessor :importance
+        end
+        def tell
+        end
+        handle_asynchronously :tell, :priority => Proc.new { self.importance }
+      end
+
+      it 'should set the priority based on the Fable importance' do
+        Fable.importance = 10
+        job = Fable.new.tell
+        job.priority.should == 10
+
+        Fable.importance = 20
+        job = Fable.new.tell
+        job.priority.should == 20
+      end
+
+      describe 'using a proc with parament' do
+        class Yarn
+          attr_accessor :importance
+          def spin
+          end
+          handle_asynchronously :spin, :priority => Proc.new {|y| y.importance }
+        end
+
+        it 'should set the priority based on the Fable importance' do
+          job = Yarn.new.tap {|y| y.importance = 10 }.spin
+          job.priority.should == 10
+
+          job = Yarn.new.tap {|y| y.importance = 20 }.spin
+          job.priority.should == 20
+        end
+      end
+    end
+  end
+
+  context "delay" do
+    it "should create a new PerformableMethod job" do
+      lambda {
+        job = "hello".delay.count('l')
+        job.payload_object.class.should   == Delayed::PerformableMethod
+        job.payload_object.method.should  == :count
+        job.payload_object.args.should    == ['l']
+      }.should change { Delayed::Job.count }.by(1)
+    end
+
+    it "should set default priority" do
+      Delayed::Worker.default_priority = 99
+      job = Object.delay.to_s
+      job.priority.should == 99
+      Delayed::Worker.default_priority = 0
+    end
+
+    it "should set job options" do
+      run_at = Time.parse('2010-05-03 12:55 AM')
+      job = Object.delay(:priority => 20, :run_at => run_at).to_s
+      job.run_at.should == run_at
+      job.priority.should == 20
+    end
+  end
+end

data/spec/performable_method_spec.rb

@@ -0,0 +1,53 @@
+require 'spec_helper'
+
+class StoryReader
+  def read(story)
+    "Epilog: #{story.tell}"
+  end
+end
+
+describe Delayed::PerformableMethod do
+  
+  it "should ignore ActiveRecord::RecordNotFound errors because they are permanent" do
+    story = Story.create :text => 'Once upon...'
+    p = Delayed::PerformableMethod.new(story, :tell, [])
+    story.destroy
+    lambda { p.perform }.should_not raise_error
+  end
+  
+  it "should store the object as string if its an active record" do
+    story = Story.create :text => 'Once upon...'
+    p = Delayed::PerformableMethod.new(story, :tell, [])
+    p.class.should   == Delayed::PerformableMethod
+    p.object.should  == "LOAD;Story;#{story.id}"
+    p.method.should  == :tell
+    p.args.should    == []
+    p.perform.should == 'Once upon...'
+  end
+  
+  it "should allow class methods to be called on ActiveRecord models" do
+    p = Delayed::PerformableMethod.new(Story, :count, [])
+    lambda { p.send(:load, p.object) }.should_not raise_error
+  end
+  
+  it "should store arguments as string if they are active record objects" do
+    story = Story.create :text => 'Once upon...'
+    reader = StoryReader.new
+    p = Delayed::PerformableMethod.new(reader, :read, [story])
+    p.class.should   == Delayed::PerformableMethod
+    p.method.should  == :read
+    p.args.should    == ["LOAD;Story;#{story.id}"]
+    p.perform.should == 'Epilog: Once upon...'
+  end
+
+  it "should not raise NoMethodError if target method is private" do
+    clazz = Class.new do
+      def private_method
+      end
+      private :private_method
+    end
+    lambda {
+      Delayed::PerformableMethod.new(clazz.new, :private_method, [])
+    }.should_not raise_error(NoMethodError)
+  end
+end

data/spec/sample_jobs.rb

@@ -0,0 +1,26 @@
+class SimpleJob
+  cattr_accessor :runs; self.runs = 0
+  def perform; @@runs += 1; end
+end
+
+class ErrorJob
+  cattr_accessor :runs; self.runs = 0
+  def perform; raise 'did not work'; end
+end             
+
+class LongRunningJob
+  def perform; sleep 250; end
+end
+
+class OnPermanentFailureJob < SimpleJob
+  def on_permanent_failure
+  end
+  def max_attempts; 1; end
+end
+
+module M
+  class ModuleJob
+    cattr_accessor :runs; self.runs = 0
+    def perform; @@runs += 1; end    
+  end
+end

data/spec/setup/active_record.rb

@@ -0,0 +1,34 @@
+require 'active_record'
+
+ActiveRecord::Base.establish_connection(:adapter => 'sqlite3', :database => ':memory:')
+ActiveRecord::Base.logger = Delayed::Worker.logger
+ActiveRecord::Migration.verbose = false
+
+ActiveRecord::Schema.define do
+  create_table :delayed_jobs, :force => true do |table|
+    table.integer  :priority, :default => 0
+    table.integer  :attempts, :default => 0
+    table.text     :handler
+    table.text     :last_error
+    table.datetime :run_at
+    table.datetime :locked_at
+    table.datetime :failed_at
+    table.string   :locked_by
+    table.string   :queue_name, :default=>"default"
+    table.timestamps
+  end
+
+  add_index :delayed_jobs, [:queue_name, :priority, :run_at], :name => 'delayed_jobs_priority'
+
+  create_table :stories, :force => true do |table|
+    table.string :text
+  end
+end
+
+# Purely useful for test cases...
+class Story < ActiveRecord::Base
+  def tell; text; end       
+  def whatever(n, _); tell*n; end
+  
+  handle_asynchronously :whatever
+end

data/spec/setup/data_mapper.rb

@@ -0,0 +1,8 @@
+require 'dm-core'
+require 'dm-validations'
+
+require 'delayed/backend/data_mapper'
+
+DataMapper.logger = Delayed::Worker.logger
+DataMapper.setup(:default, "sqlite3::memory:")
+DataMapper.auto_migrate!

data/spec/setup/mongo_mapper.rb

@@ -0,0 +1,17 @@
+require 'mongo_mapper'
+
+MongoMapper.config = {
+  RAILS_ENV => {'database' => 'delayed_job'}
+}
+MongoMapper.connect RAILS_ENV
+
+unless defined?(Story)
+  class Story
+    include ::MongoMapper::Document
+    def tell; text; end       
+    def whatever(n, _); tell*n; end
+    def self.count; end
+  
+    handle_asynchronously :whatever
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,28 @@
+$:.unshift(File.dirname(__FILE__) + '/../lib')
+
+require 'rubygems'
+require 'spec'
+require 'logger'
+
+gem 'rails', '~>2.3.5'
+
+require 'delayed_job'
+require 'sample_jobs'
+
+Delayed::Worker.logger = Logger.new('/tmp/dj.log')
+RAILS_ENV = 'test'
+
+# determine the available backends
+BACKENDS = []
+Dir.glob("#{File.dirname(__FILE__)}/setup/*.rb") do |backend|
+  begin
+    backend = File.basename(backend, '.rb')
+    require "setup/#{backend}"
+    require "backend/#{backend}_job_spec"
+    BACKENDS << backend.to_sym
+  rescue LoadError, Exception
+    puts "Unable to load #{backend} backend! #{$!}"
+  end
+end
+
+Delayed::Worker.backend = BACKENDS.first

data/spec/story_spec.rb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+
+describe "A story" do
+
+  before(:all) do
+    @story = Story.create :text => "Once upon a time..."
+  end
+
+  it "should be shared" do
+    @story.tell.should == 'Once upon a time...'
+  end
+
+  it "should not return its result if it storytelling is delayed" do
+    @story.delay.tell.should_not == 'Once upon a time...'
+  end
+
+end

data/spec/worker_spec.rb

@@ -0,0 +1,237 @@
+require 'spec_helper'
+
+describe Delayed::Worker do
+  def job_create(opts = {})
+    Delayed::Job.create(opts.merge(:payload_object => SimpleJob.new))
+  end
+
+  describe "backend=" do
+    it "should set the Delayed::Job constant to the backend" do
+      @clazz = Class.new
+      Delayed::Worker.backend = @clazz
+      Delayed::Job.should == @clazz
+    end
+    
+    it "should set backend with a symbol" do
+      Delayed::Worker.backend = Class.new
+      Delayed::Worker.backend = :active_record
+      Delayed::Worker.backend.should == Delayed::Backend::ActiveRecord::Job
+    end
+  end
+  
+  BACKENDS.each do |backend|
+    describe "with the #{backend} backend" do
+      before do
+        Delayed::Worker.backend = backend
+        Delayed::Job.delete_all
+
+        @worker = Delayed::Worker.new(:max_priority => nil, :min_priority => nil, :quiet => true)
+
+        SimpleJob.runs = 0
+      end
+  
+      describe "running a job" do
+        it "should fail after Worker.max_run_time" do
+          begin
+            old_max_run_time = Delayed::Worker.max_run_time
+            Delayed::Worker.max_run_time = 1.second
+            @job = Delayed::Job.create :payload_object => LongRunningJob.new
+            @worker.run(@job)
+            @job.reload.last_error.should =~ /expired/
+            @job.attempts.should == 1
+          ensure
+            Delayed::Worker.max_run_time = old_max_run_time
+          end
+        end
+      end
+  
+      context "worker prioritization" do
+        before(:each) do
+          @worker = Delayed::Worker.new(:max_priority => 5, :min_priority => -5, :quiet => true)
+        end
+
+        it "should only work_off jobs that are >= min_priority" do
+          SimpleJob.runs.should == 0
+
+          job_create(:priority => -10)
+          job_create(:priority => 0)
+          @worker.work_off
+
+          SimpleJob.runs.should == 1
+        end
+
+        it "should only work_off jobs that are <= max_priority" do
+          SimpleJob.runs.should == 0
+
+          job_create(:priority => 10)
+          job_create(:priority => 0)
+
+          @worker.work_off
+
+          SimpleJob.runs.should == 1
+        end
+      end
+
+      context "while running with locked and expired jobs" do
+        before(:each) do
+          @worker.name = 'worker1'
+        end
+    
+        it "should not run jobs locked by another worker" do
+          job_create(:locked_by => 'other_worker', :locked_at => (Delayed::Job.db_time_now - 1.minutes))
+          lambda { @worker.work_off }.should_not change { SimpleJob.runs }
+        end
+    
+        it "should run open jobs" do
+          job_create
+          lambda { @worker.work_off }.should change { SimpleJob.runs }.from(0).to(1)
+        end
+    
+        it "should run expired jobs" do
+          expired_time = Delayed::Job.db_time_now - (1.minutes + Delayed::Worker.max_run_time)
+          job_create(:locked_by => 'other_worker', :locked_at => expired_time)
+          lambda { @worker.work_off }.should change { SimpleJob.runs }.from(0).to(1)
+        end
+    
+        it "should run own jobs" do
+          job_create(:locked_by => @worker.name, :locked_at => (Delayed::Job.db_time_now - 1.minutes))
+          lambda { @worker.work_off }.should change { SimpleJob.runs }.from(0).to(1)
+        end
+      end
+  
+      describe "failed jobs" do
+        before do
+          # reset defaults
+          Delayed::Worker.destroy_failed_jobs = true
+          Delayed::Worker.max_attempts = 25
+          Delayed::Job.delete_all
+
+          @job = Delayed::Job.enqueue ErrorJob.new
+        end
+
+        it "should record last_error when destroy_failed_jobs = false, max_attempts = 1" do
+          Delayed::Worker.destroy_failed_jobs = false
+          Delayed::Worker.max_attempts = 1
+          @worker.run(@job)
+          @job.reload
+          @job.last_error.should =~ /did not work/
+          @job.last_error.should =~ /worker_spec.rb/
+          @job.attempts.should == 1
+          @job.failed_at.should_not be_nil
+        end
+    
+        it "should re-schedule jobs after failing" do
+          @worker.work_off
+          @job.reload
+          @job.last_error.should =~ /did not work/
+          @job.last_error.should =~ /sample_jobs.rb:8:in `perform'/
+          @job.attempts.should == 1
+          @job.run_at.should > Delayed::Job.db_time_now - 10.minutes
+          @job.run_at.should < Delayed::Job.db_time_now + 10.minutes
+          @job.locked_at.should be_nil
+          @job.locked_by.should be_nil
+        end
+        
+        context "when the job's payload implements #reschedule_at" do
+          before(:each) do
+            @reschedule_at = Time.current + 7.hours
+            @job.payload_object.stub!(:reschedule_at).and_return(@reschedule_at)
+          end
+
+          it 'should invoke the strategy to re-schedule' do
+            @job.payload_object.should_receive(:reschedule_at) do |time, attempts|
+              (Delayed::Job.db_time_now - time).should < 2
+              attempts.should == 1
+
+              Delayed::Job.db_time_now + 5
+            end
+
+            @worker.run(@job)
+          end
+        end
+      end
+  
+      context "reschedule" do
+        before do
+          @job = Delayed::Job.create :payload_object => SimpleJob.new
+        end
+   
+        share_examples_for "any failure more than Worker.max_attempts times" do
+          context "when the job's payload has an #on_permanent_failure hook" do
+            before do
+              @job = Delayed::Job.create :payload_object => OnPermanentFailureJob.new
+              @job.payload_object.should respond_to :on_permanent_failure
+            end
+
+            it "should run that hook" do
+              @job.payload_object.should_receive :on_permanent_failure
+              @worker.reschedule(@job)
+            end
+          end
+
+          context "when the job's payload has no #on_permanent_failure hook" do
+            # It's a little tricky to test this in a straightforward way, 
+            # because putting a should_not_receive expectation on 
+            # @job.payload_object.on_permanent_failure makes that object
+            # incorrectly return true to 
+            # payload_object.respond_to? :on_permanent_failure, which is what
+            # reschedule uses to decide whether to call on_permanent_failure.  
+            # So instead, we just make sure that the payload_object as it 
+            # already stands doesn't respond_to? on_permanent_failure, then
+            # shove it through the iterated reschedule loop and make sure we
+            # don't get a NoMethodError (caused by calling that nonexistent
+            # on_permanent_failure method).
+            
+            before do
+              @job.payload_object.should_not respond_to(:on_permanent_failure)
+            end
+
+            it "should not try to run that hook" do
+              lambda do
+                Delayed::Worker.max_attempts.times { @worker.reschedule(@job) }
+              end.should_not raise_exception(NoMethodError)
+            end
+          end
+        end
+
+        context "and we want to destroy jobs" do
+          before do
+            Delayed::Worker.destroy_failed_jobs = true
+          end
+
+          it_should_behave_like "any failure more than Worker.max_attempts times"
+
+          it "should be destroyed if it failed more than Worker.max_attempts times" do
+            @job.should_receive(:destroy)
+            Delayed::Worker.max_attempts.times { @worker.reschedule(@job) }
+          end
+      
+          it "should not be destroyed if failed fewer than Worker.max_attempts times" do
+            @job.should_not_receive(:destroy)
+            (Delayed::Worker.max_attempts - 1).times { @worker.reschedule(@job) }
+          end
+        end
+    
+        context "and we don't want to destroy jobs" do
+          before do
+            Delayed::Worker.destroy_failed_jobs = false
+          end
+      
+          it_should_behave_like "any failure more than Worker.max_attempts times"
+
+          it "should be failed if it failed more than Worker.max_attempts times" do
+            @job.reload.failed_at.should == nil
+            Delayed::Worker.max_attempts.times { @worker.reschedule(@job) }
+            @job.reload.failed_at.should_not == nil
+          end
+
+          it "should not be failed if it failed fewer than Worker.max_attempts times" do
+            (Delayed::Worker.max_attempts - 1).times { @worker.reschedule(@job) }
+            @job.reload.failed_at.should == nil
+          end
+        end
+      end
+    end
+  end
+  
+end