delayed_job 3.0.3 → 3.0.4

data/lib/delayed/performable_method.rb

@@ -9,8 +9,8 @@ module Delayed
     def initialize(object, method_name, args)
       raise NoMethodError, "undefined method `#{method_name}' for #{object.inspect}" unless object.respond_to?(method_name, true)
 
-      if defined?(ActiveRecord) && object.kind_of?(ActiveRecord::Base)
-        raise(ArgumentError, 'Jobs cannot be created for records before they\'ve been persisted') if object.attributes[object.class.primary_key].nil?
+      if object.respond_to?(:new_record?) && object.new_record?
+        raise(ArgumentError, 'Jobs cannot be created for records before they\'ve been persisted')
       end
 
       self.object       = object

data/lib/delayed/psych_ext.rb

@@ -99,11 +99,7 @@ module Psych
           payload = Hash[*object.children.map { |c| accept c }]
           id = payload["attributes"][klass.primary_key]
           begin
-            if ActiveRecord::VERSION::MAJOR == 3
-              klass.unscoped.find(id)
-            else # Rails 2
-              klass.with_exclusive_scope { klass.find(id) }
-            end
+            klass.unscoped.find(id)
           rescue ActiveRecord::RecordNotFound
             raise Delayed::DeserializationError
           end

data/lib/delayed/recipes.rb

@@ -31,20 +31,24 @@ Capistrano::Configuration.instance.load do
     def roles
       fetch(:delayed_job_server_role, :app)
     end
+    
+    def delayed_job_command
+      fetch(:delayed_job_command, "script/delayed_job")
+    end
 
     desc "Stop the delayed_job process"
     task :stop, :roles => lambda { roles } do
-      run "cd #{current_path};#{rails_env} script/delayed_job stop"
+      run "cd #{current_path};#{rails_env} #{delayed_job_command} stop"
     end
 
     desc "Start the delayed_job process"
     task :start, :roles => lambda { roles } do
-      run "cd #{current_path};#{rails_env} script/delayed_job start #{args}"
+      run "cd #{current_path};#{rails_env} #{delayed_job_command} start #{args}"
     end
 
     desc "Restart the delayed_job process"
     task :restart, :roles => lambda { roles } do
-      run "cd #{current_path};#{rails_env} script/delayed_job restart #{args}"
+      run "cd #{current_path};#{rails_env} #{delayed_job_command} restart #{args}"
     end
   end
 end

data/lib/delayed/serialization/active_record.rb

@@ -3,11 +3,7 @@ if defined?(ActiveRecord)
     yaml_as "tag:ruby.yaml.org,2002:ActiveRecord"
 
     def self.yaml_new(klass, tag, val)
-      if ActiveRecord::VERSION::MAJOR == 3
-        klass.unscoped.find(val['attributes'][klass.primary_key])
-      else # Rails 2
-        klass.with_exclusive_scope { klass.find(val['attributes'][klass.primary_key]) }
-      end
+      klass.unscoped.find(val['attributes'][klass.primary_key])
     rescue ActiveRecord::RecordNotFound
       raise Delayed::DeserializationError, "ActiveRecord::RecordNotFound, class: #{klass} , primary key: #{val['attributes'][klass.primary_key]} "
     end

data/lib/delayed/worker.rb

@@ -20,6 +20,9 @@ module Delayed
       :default_priority, :sleep_delay, :logger, :delay_jobs, :queues,
       :read_ahead, :plugins, :destroy_failed_jobs
 
+    # Named queue into which jobs are enqueued by default
+    cattr_accessor :default_queue_name
+
     cattr_reader :backend
 
     # name_prefix is ignored if name is set directly
@@ -185,7 +188,7 @@ module Delayed
       say "#{job.name} completed after %.4f" % runtime
       return true  # did work
     rescue DeserializationError => error
-      job.last_error = "{#{error.message}\n#{error.backtrace.join("\n")}"
+      job.last_error = "#{error.message}\n#{error.backtrace.join("\n")}"
       failed(job)
     rescue Exception => error
       self.class.lifecycle.run_callbacks(:error, self, job){ handle_failed_job(job, error) }
@@ -226,7 +229,7 @@ module Delayed
   protected
 
     def handle_failed_job(job, error)
-      job.last_error = "{#{error.message}\n#{error.backtrace.join("\n")}"
+      job.last_error = "#{error.message}\n#{error.backtrace.join("\n")}"
       say "#{job.name} failed with #{error.class.name}: #{error.message} - #{job.attempts} failed attempts", Logger::ERROR
       reschedule(job)
     end

data/spec/lifecycle_spec.rb

@@ -12,7 +12,7 @@ describe Delayed::Lifecycle do
       lifecycle.before(:execute, &callback)
     end
 
-    it 'should execute before wrapped block' do
+    it "executes before wrapped block" do
       callback.should_receive(:call).with(*arguments).ordered
       behavior.should_receive(:inside!).ordered
       lifecycle.run_callbacks :execute, *arguments, &wrapped_block
@@ -24,7 +24,7 @@ describe Delayed::Lifecycle do
       lifecycle.after(:execute, &callback)
     end
 
-    it 'should execute after wrapped block' do
+    it "executes after wrapped block" do
       behavior.should_receive(:inside!).ordered
       callback.should_receive(:call).with(*arguments).ordered
       lifecycle.run_callbacks :execute, *arguments, &wrapped_block
@@ -40,14 +40,14 @@ describe Delayed::Lifecycle do
       end
     end
 
-    it 'should before and after wrapped block' do
+    it "wraps a block" do
       behavior.should_receive(:before!).ordered
       behavior.should_receive(:inside!).ordered
       behavior.should_receive(:after!).ordered
       lifecycle.run_callbacks :execute, *arguments, &wrapped_block
     end
 
-    it "should execute multiple callbacks in order" do
+    it "executes multiple callbacks in order" do
       behavior.should_receive(:one).ordered
       behavior.should_receive(:two).ordered
       behavior.should_receive(:three).ordered
@@ -60,7 +60,7 @@ describe Delayed::Lifecycle do
     end
   end
 
-  it "should raise if callback is executed with wrong number of parameters" do
+  it "raises if callback is executed with wrong number of parameters" do
     lifecycle.before(:execute, &callback)
     expect { lifecycle.run_callbacks(:execute, 1,2,3) {} }.to raise_error(ArgumentError, /1 parameter/)
   end

data/spec/message_sending_spec.rb

@@ -7,39 +7,39 @@ describe Delayed::MessageSending do
       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!)
+    it "aliases original method" do
+      expect(Story.new).to respond_to(:tell_without_delay!)
+      expect(Story.new).to respond_to(:tell_with_delay!)
     end
 
-    it "should create a PerformableMethod" do
+    it "creates a PerformableMethod" do
       story = Story.create
-      lambda {
+      expect {
         job = story.tell!(1)
-        job.payload_object.class.should == Delayed::PerformableMethod
-        job.payload_object.method_name.should == :tell_without_delay!
-        job.payload_object.args.should == [1]
-      }.should change { Delayed::Job.count }
+        expect(job.payload_object.class).to eq(Delayed::PerformableMethod)
+        expect(job.payload_object.method_name).to eq(:tell_without_delay!)
+        expect(job.payload_object.args).to eq([1])
+      }.to change { Delayed::Job.count }
     end
 
-    describe 'with options' do
+    describe "with options" do
       class Fable
         cattr_accessor :importance
         def tell;end
         handle_asynchronously :tell, :priority => Proc.new { self.importance }
       end
 
-      it 'should set the priority based on the Fable importance' do
+      it "sets the priority based on the Fable importance" do
         Fable.importance = 10
         job = Fable.new.tell
-        job.priority.should == 10
+        expect(job.priority).to eq(10)
 
         Fable.importance = 20
         job = Fable.new.tell
-        job.priority.should == 20
+        expect(job.priority).to eq(20)
       end
 
-      describe 'using a proc with parameters' do
+      describe "using a proc with parameters" do
         class Yarn
           attr_accessor :importance
           def spin
@@ -47,12 +47,12 @@ describe Delayed::MessageSending do
           handle_asynchronously :spin, :priority => Proc.new {|y| y.importance }
         end
 
-        it 'should set the priority based on the Fable importance' do
+        it "sets the priority based on the Fable importance" do
           job = Yarn.new.tap {|y| y.importance = 10 }.spin
-          job.priority.should == 10
+          expect(job.priority).to eq(10)
 
           job = Yarn.new.tap {|y| y.importance = 20 }.spin
-          job.priority.should == 20
+          expect(job.priority).to eq(20)
         end
       end
     end
@@ -67,47 +67,54 @@ describe Delayed::MessageSending do
       end
     end
 
-    it "should create a new PerformableMethod job" do
-      lambda {
+    it "creates a new PerformableMethod job" do
+      expect {
         job = "hello".delay.count('l')
-        job.payload_object.class.should == Delayed::PerformableMethod
-        job.payload_object.method_name.should == :count
-        job.payload_object.args.should == ['l']
-      }.should change { Delayed::Job.count }.by(1)
+        expect(job.payload_object.class).to eq(Delayed::PerformableMethod)
+        expect(job.payload_object.method_name).to eq(:count)
+        expect(job.payload_object.args).to eq(['l'])
+      }.to change { Delayed::Job.count }.by(1)
     end
 
-    it "should set default priority" do
+    it "sets default priority" do
       Delayed::Worker.default_priority = 99
       job = FairyTail.delay.to_s
-      job.priority.should == 99
+      expect(job.priority).to eq(99)
       Delayed::Worker.default_priority = 0
     end
 
-    it "should set job options" do
+    it "sets default queue name" do
+      Delayed::Worker.default_queue_name = 'abbazabba'
+      job = FairyTail.delay.to_s
+      expect(job.queue).to eq('abbazabba')
+      Delayed::Worker.default_queue_name = nil
+    end
+
+    it "sets job options" do
       run_at = Time.parse('2010-05-03 12:55 AM')
       job = FairyTail.delay(:priority => 20, :run_at => run_at).to_s
-      job.run_at.should == run_at
-      job.priority.should == 20
+      expect(job.run_at).to eq(run_at)
+      expect(job.priority).to eq(20)
     end
 
-    it "should not delay the job when delay_jobs is false" do
+    it "does not delay the job when delay_jobs is false" do
       Delayed::Worker.delay_jobs = false
       fairy_tail = FairyTail.new
-      lambda {
-        lambda {
+      expect {
+        expect {
           fairy_tail.delay.tell
-        }.should change(fairy_tail, :happy_ending).from(nil).to(true)
-      }.should_not change { Delayed::Job.count }
+        }.to change(fairy_tail, :happy_ending).from(nil).to(true)
+      }.not_to change { Delayed::Job.count }
     end
 
-    it "should delay the job when delay_jobs is true" do
+    it "does delay the job when delay_jobs is true" do
       Delayed::Worker.delay_jobs = true
       fairy_tail = FairyTail.new
-      lambda {
-        lambda {
+      expect {
+        expect {
           fairy_tail.delay.tell
-        }.should_not change(fairy_tail, :happy_ending)
-      }.should change { Delayed::Job.count }.by(1)
+        }.not_to change(fairy_tail, :happy_ending)
+      }.to change { Delayed::Job.count }.by(1)
     end
   end
 end

data/spec/performable_mailer_spec.rb

@@ -9,27 +9,27 @@ end
 
 describe ActionMailer::Base do
   describe "delay" do
-    it "should enqueue a PerformableEmail job" do
-      lambda {
+    it "enqueues a PerformableEmail job" do
+      expect {
         job = MyMailer.delay.signup('john@example.com')
-        job.payload_object.class.should == Delayed::PerformableMailer
-        job.payload_object.method_name.should == :signup
-        job.payload_object.args.should == ['john@example.com']
-      }.should change { Delayed::Job.count }.by(1)
+        expect(job.payload_object.class).to eq(Delayed::PerformableMailer)
+        expect(job.payload_object.method_name).to eq(:signup)
+        expect(job.payload_object.args).to eq(['john@example.com'])
+      }.to change { Delayed::Job.count }.by(1)
     end
   end
 
   describe "delay on a mail object" do
-    it "should raise an exception" do
-      lambda {
+    it "raises an exception" do
+      expect {
         MyMailer.signup('john@example.com').delay
-      }.should raise_error(RuntimeError)
+      }.to raise_error(RuntimeError)
     end
   end
 
   describe Delayed::PerformableMailer do
     describe "perform" do
-      it "should call the method and #deliver on the mailer" do
+      it "calls the method and #deliver on the mailer" do
         email = mock('email', :deliver => true)
         mailer_class = mock('MailerClass', :signup => email)
         mailer = Delayed::PerformableMailer.new(mailer_class, :signup, ['john@example.com'])

data/spec/performable_method_spec.rb

@@ -11,37 +11,37 @@ describe Delayed::PerformableMethod do
         @method.object = nil
       end
 
-      it "should be a no-op if object is nil" do
-        lambda { @method.perform }.should_not raise_error
+      it "does nothing if object is nil" do
+        expect{@method.perform}.not_to raise_error
       end
     end
 
-    it "should call the method on the object" do
+    it "calls the method on the object" do
       @method.object.should_receive(:count).with('o')
       @method.perform
     end
   end
 
-  it "should raise a NoMethodError if target method doesn't exist" do
-    lambda {
+  it "raises a NoMethodError if target method doesn't exist" do
+    expect {
       Delayed::PerformableMethod.new(Object, :method_that_does_not_exist, [])
-    }.should raise_error(NoMethodError)
+    }.to raise_error(NoMethodError)
   end
 
-  it "should not raise NoMethodError if target method is private" do
+  it "does not raise NoMethodError if target method is private" do
     clazz = Class.new do
       def private_method
       end
       private :private_method
     end
-    lambda {
+    expect {
       Delayed::PerformableMethod.new(clazz.new, :private_method, [])
-    }.should_not raise_error(NoMethodError)
+    }.not_to raise_error(NoMethodError)
   end
 
   describe "hooks" do
     %w(enqueue before after success).each do |hook|
-      it "should delegate #{hook} hook to object" do
+      it "delegates #{hook} hook to object" do
         story = Story.create
         story.should_receive(hook).with(an_instance_of(Delayed::Job))
         story.delay.tell.invoke_job
@@ -49,7 +49,7 @@ describe Delayed::PerformableMethod do
     end
 
     %w(before after success).each do |hook|
-      it "should delegate #{hook} hook to object when delay_jobs = false" do
+      it "delegates #{hook} hook to object when delay_jobs = false" do
         Delayed::Worker.delay_jobs = false
         story = Story.create
         story.should_receive(hook).with(an_instance_of(Delayed::Job))
@@ -57,28 +57,28 @@ describe Delayed::PerformableMethod do
       end
     end
 
-    it "should delegate error hook to object" do
+    it "delegates error hook to object" do
       story = Story.create
       story.should_receive(:error).with(an_instance_of(Delayed::Job), an_instance_of(RuntimeError))
       story.should_receive(:tell).and_raise(RuntimeError)
-      lambda { story.delay.tell.invoke_job }.should raise_error
+      expect{story.delay.tell.invoke_job}.to raise_error
     end
 
-    it "should delegate error hook to object when delay_jobs = false" do
+    it "delegates error hook to object when delay_jobs = false" do
       Delayed::Worker.delay_jobs = false
       story = Story.create
       story.should_receive(:error).with(an_instance_of(Delayed::Job), an_instance_of(RuntimeError))
       story.should_receive(:tell).and_raise(RuntimeError)
-      lambda { story.delay.tell }.should raise_error
+      expect{story.delay.tell}.to raise_error
     end
 
-    it "should delegate failure hook to object" do
+    it "delegates failure hook to object" do
       method = Delayed::PerformableMethod.new("object", :size, [])
       method.object.should_receive(:failure)
       method.failure
     end
 
-    it "should delegate failure hook to object when delay_jobs = false" do
+    it "delegates failure hook to object when delay_jobs = false" do
       Delayed::Worker.delay_jobs = false
       method = Delayed::PerformableMethod.new("object", :size, [])
       method.object.should_receive(:failure)

data/spec/spec_helper.rb

@@ -50,4 +50,8 @@ RSpec.configure do |config|
   config.after(:each) do
     Delayed::Worker.reset
   end
+
+  config.expect_with :rspec do |c|
+    c.syntax = :expect
+  end
 end

data/spec/test_backend_spec.rb

@@ -4,10 +4,10 @@ describe Delayed::Backend::Test::Job do
   it_should_behave_like 'a delayed_job backend'
 
   describe "#reload" do
-    it 'should cause the payload object to be reloaded' do
+    it "causes the payload object to be reloaded" do
       job = "foo".delay.length
       o = job.payload_object
-      o.object_id.should_not == job.reload.payload_object.object_id
+      expect(o.object_id).not_to eq(job.reload.payload_object.object_id)
     end
   end
 end

data/spec/worker_spec.rb

@@ -7,13 +7,34 @@ describe Delayed::Worker do
       Delayed::Worker.backend = @clazz
     end
 
-    it "should set the Delayed::Job constant to the backend" do
-      Delayed::Job.should == @clazz
+    it "sets the Delayed::Job constant to the backend" do
+      expect(Delayed::Job).to eq(@clazz)
     end
 
-    it "should set backend with a symbol" do
+    it "sets backend with a symbol" do
       Delayed::Worker.backend = :test
-      Delayed::Worker.backend.should == Delayed::Backend::Test::Job
+      expect(Delayed::Worker.backend).to eq(Delayed::Backend::Test::Job)
+    end
+  end
+
+  context "worker read-ahead" do
+    before do
+      @read_ahead = Delayed::Worker.read_ahead
+    end
+
+    after do
+      Delayed::Worker.read_ahead = @read_ahead
+    end
+
+    it "reads five jobs" do
+      Delayed::Job.should_receive(:find_available).with(anything, 5, anything).and_return([])
+      Delayed::Job.reserve(Delayed::Worker.new)
+    end
+
+    it "reads a configurable number of jobs" do
+      Delayed::Worker.read_ahead = 15
+      Delayed::Job.should_receive(:find_available).with(anything, Delayed::Worker.read_ahead, anything).and_return([])
+      Delayed::Job.reserve(Delayed::Worker.new)
     end
   end
 end