delayed_job 4.0.0 → 4.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 44f2fddb4257788893e27e7fe18e159748132d45
+  data.tar.gz: ed334f09c9f6d3c9ff987a04f5131d4d8bf1286a
+SHA512:
+  metadata.gz: a43f95acb0fd7b4d1eacadc523dc470f08aa290ccf2b224819a77bd60acd8b363665bd7992372420d6d382b6ca6ead131a725f0ee638abce35405900748e2612
+  data.tar.gz: ff353fb2e6115237541411a67aee47381120fda1a20d56a70a0a50a51a4cc56c21e0f7e3935c1869fbcf6dbb8051199ae95e3eec68d4208f0a6c3e3f3f252cd5

data/CHANGELOG.md

@@ -1,3 +1,9 @@
+4.0.1 - 2014-04-12
+==================
+* Update gemspec for Rails 4.1
+* Make logger calls more universal
+* Check that records are persisted? instead of new_record?
+
 4.0.0 - 2013-07-30
 ==================
 * Rails 4 compatibility

data/README.md

@@ -1,13 +1,13 @@
 Delayed::Job
 ============
 [![Gem Version](https://badge.fury.io/rb/delayed_job.png)][gem]
-[![Build Status](https://secure.travis-ci.org/collectiveidea/delayed_job.png?branch=master)][travis]
+[![Build Status](https://travis-ci.org/collectiveidea/delayed_job.png?branch=master)][travis]
 [![Dependency Status](https://gemnasium.com/collectiveidea/delayed_job.png?travis)][gemnasium]
 [![Code Climate](https://codeclimate.com/github/collectiveidea/delayed_job.png)][codeclimate]
 [![Coverage Status](https://coveralls.io/repos/collectiveidea/delayed_job/badge.png?branch=master)][coveralls]
 
 [gem]: https://rubygems.org/gems/delayed_job
-[travis]: http://travis-ci.org/collectiveidea/delayed_job
+[travis]: https://travis-ci.org/collectiveidea/delayed_job
 [gemnasium]: https://gemnasium.com/collectiveidea/delayed_job
 [codeclimate]: https://codeclimate.com/github/collectiveidea/delayed_job
 [coveralls]: https://coveralls.io/r/collectiveidea/delayed_job
@@ -36,7 +36,7 @@ delayed_job 3.0.0 only supports Rails 3.0+. See the [2.0
 branch](https://github.com/collectiveidea/delayed_job/tree/v2.0) for Rails 2.
 
 delayed_job supports multiple backends for storing the job queue. [See the wiki
-for other backends](http://wiki.github.com/collectiveidea/delayed_job/backends).
+for other backends](https://github.com/collectiveidea/delayed_job/wiki/Backends).
 
 If you plan to use delayed_job with Active Record, add `delayed_job_active_record` to your `Gemfile`.
 
@@ -58,6 +58,10 @@ running the following command:
     rails generate delayed_job:active_record
     rake db:migrate
 
+Rails 4
+=======
+If you are using the protected_attributes gem, it must appear before delayed_job in your gemfile.
+
 Upgrading from 2.x to 3.0.0 on Active Record
 ============================================
 Delayed Job 3.0.0 introduces a new column to the delayed_jobs table.
@@ -141,6 +145,9 @@ Notifier.signup(@user).deliver
 
 # with delayed_job
 Notifier.delay.signup(@user)
+
+# with delayed_job running at a specific time
+Notifier.delay(run_at: 5.minutes.from_now).signup(@user)
 ```
 
 Remove the `.deliver` method to make it work. It's not ideal, but it's the best
@@ -183,7 +190,7 @@ You can then do the following:
     RAILS_ENV=production script/delayed_job --queue=tracking start
     RAILS_ENV=production script/delayed_job --queues=mailers,tasks start
 
-    # Runs all available jobs and the exits
+    # Runs all available jobs and then exits
     RAILS_ENV=production script/delayed_job start --exit-on-complete
     # or to run in the foreground
     RAILS_ENV=production script/delayed_job run --exit-on-complete
@@ -203,7 +210,7 @@ Work off queues by setting the `QUEUE` or `QUEUES` environment variable.
 
     QUEUE=tracking rake jobs:work
     QUEUES=mailers,tasks rake jobs:work
-    
+
 Restarting delayed_job
 ======================
 
@@ -214,7 +221,7 @@ The following syntax will restart delayed jobs:
 To restart multiple delayed_job workers:
 
     RAILS_ENV=production script/delayed_job -n2 restart
-    
+
 **Rails 4:** *replace script/delayed_job with bin/delayed_job*
 
 
@@ -224,7 +231,7 @@ Custom Jobs
 Jobs are simple ruby objects with a method called perform. Any object which responds to perform can be stuffed into the jobs table. Job objects are serialized to yaml so that they can later be resurrected by the job runner.
 
 ```ruby
-class NewsletterJob < Struct.new(:text, :emails)
+NewsletterJob = Struct.new(:text, :emails) do
   def perform
     emails.each { |e| NewsletterMailer.deliver_text_to_email(text, e) }
   end
@@ -234,11 +241,11 @@ Delayed::Job.enqueue NewsletterJob.new('lorem ipsum...', Customers.find(:all).co
 ```
 To set a per-job max attempts that overrides the Delayed::Worker.max_attempts you can define a max_attempts method on the job
 ```ruby
-class NewsletterJob < Struct.new(:text, :emails)
+NewsletterJob = Struct.new(:text, :emails) do
   def perform
     emails.each { |e| NewsletterMailer.deliver_text_to_email(text, e) }
   end
-  
+
   def max_attempts
     return 3
   end
@@ -276,7 +283,7 @@ class ParanoidNewsletterJob < NewsletterJob
     Airbrake.notify(exception)
   end
 
-  def failure
+  def failure(job)
     page_sysadmin_in_the_middle_of_the_night
   end
 end

data/delayed_job.gemspec

@@ -1,7 +1,7 @@
 # -*- encoding: utf-8 -*-
 
 Gem::Specification.new do |spec|
-  spec.add_dependency   'activesupport', ['>= 3.0', '< 4.1']
+  spec.add_dependency   'activesupport', ['>= 3.0', '< 4.2']
   spec.authors        = ["Brandon Keepers", "Brian Ryckbost", "Chris Gaffney", "David Genord II", "Erik Michaels-Ober", "Matt Griffin", "Steve Richert", "Tobias Lütke"]
   spec.description    = "Delayed_job (or DJ) encapsulates the common pattern of asynchronously executing longer tasks in the background. It is a direct extraction from Shopify where the job table is responsible for a multitude of core tasks."
   spec.email          = ['brian@collectiveidea.com']
@@ -13,5 +13,5 @@ Gem::Specification.new do |spec|
   spec.require_paths  = ['lib']
   spec.summary        = 'Database-backed asynchronous priority queue system -- Extracted from Shopify'
   spec.test_files     = Dir.glob('spec/**/*')
-  spec.version        = '4.0.0'
+  spec.version        = '4.0.1'
 end

data/lib/delayed/backend/shared_spec.rb

@@ -116,7 +116,7 @@ shared_examples_for "a delayed_job backend" do
 
       it "invokes the enqueued job" do
         job = SimpleJob.new
-        job.should_receive(:perform)
+        expect(job).to receive(:perform)
         described_class.enqueue job
       end
 
@@ -134,7 +134,7 @@ shared_examples_for "a delayed_job backend" do
     %w(before success after).each do |callback|
       it "calls #{callback} with job" do
         job = described_class.enqueue(CallbackJob.new)
-        job.payload_object.should_receive(callback).with(job)
+        expect(job.payload_object).to receive(callback).with(job)
         job.invoke_job
       end
     end
@@ -148,7 +148,7 @@ shared_examples_for "a delayed_job backend" do
 
     it "calls the after callback with an error" do
       job = described_class.enqueue(CallbackJob.new)
-      job.payload_object.should_receive(:perform).and_raise(RuntimeError.new("fail"))
+      expect(job.payload_object).to receive(:perform).and_raise(RuntimeError.new("fail"))
 
       expect{job.invoke_job}.to raise_error
       expect(CallbackJob.messages).to eq(["enqueue", "before", "error: RuntimeError", "after"])
@@ -156,7 +156,7 @@ shared_examples_for "a delayed_job backend" do
 
     it "calls error when before raises an error" do
       job = described_class.enqueue(CallbackJob.new)
-      job.payload_object.should_receive(:before).and_raise(RuntimeError.new("fail"))
+      expect(job.payload_object).to receive(:before).and_raise(RuntimeError.new("fail"))
       expect{job.invoke_job}.to raise_error(RuntimeError)
       expect(CallbackJob.messages).to eq(["enqueue", "error: RuntimeError", "after"])
     end
@@ -175,7 +175,7 @@ shared_examples_for "a delayed_job backend" do
 
     it "raises a DeserializationError when the YAML.load raises argument error" do
       job = described_class.new :handler => "--- !ruby/struct:GoingToRaiseArgError {}"
-      YAML.should_receive(:load).and_raise(ArgumentError)
+      expect(YAML).to receive(:load).and_raise(ArgumentError)
       expect{job.payload_object}.to raise_error(Delayed::DeserializationError)
     end
   end
@@ -399,35 +399,47 @@ shared_examples_for "a delayed_job backend" do
     end
 
     it "uses the max_retries value on the payload when defined" do
-      @job.payload_object.stub(:max_attempts).and_return(99)
+      expect(@job.payload_object).to receive(:max_attempts).and_return(99)
       expect(@job.max_attempts).to eq(99)
     end
   end
 
   describe "yaml serialization" do
-    it "reloads changed attributes" do
-      story = Story.create(:text => 'hello')
-      job = story.delay.tell
-      story.update_attributes :text => 'goodbye'
-      expect(job.reload.payload_object.object.text).to eq('goodbye')
-    end
+    context "when serializing jobs" do
+      it "raises error ArgumentError for new records" do
+        story = Story.new(:text => 'hello')
+        if story.respond_to?(:new_record?)
+          expect {
+            story.delay.tell
+          }.to raise_error(ArgumentError, 'Jobs cannot be created for non-persisted records')
+        end
+      end
 
-    it "raises error ArgumentError the record is not persisted" do
-      story = Story.new(:text => 'hello')
-      if story.respond_to?(:new_record?)
+      it "raises error ArgumentError for destroyed records" do
+        story = Story.create(:text => 'hello')
+        story.destroy
         expect {
           story.delay.tell
-        }.to raise_error(ArgumentError, "Jobs cannot be created for records before they've been persisted")
+        }.to raise_error(ArgumentError, 'Jobs cannot be created for non-persisted records')
       end
     end
 
-    it "raises deserialization error for destroyed records" do
-      story = Story.create(:text => 'hello')
-      job = story.delay.tell
-      story.destroy
-      expect {
-        job.reload.payload_object
-      }.to raise_error(Delayed::DeserializationError)
+    context "when reload jobs back" do
+      it "reloads changed attributes" do
+        story = Story.create(:text => 'hello')
+        job = story.delay.tell
+        story.update_attributes :text => 'goodbye'
+        expect(job.reload.payload_object.object.text).to eq('goodbye')
+      end
+
+      it "raises deserialization error for destroyed records" do
+        story = Story.create(:text => 'hello')
+        job = story.delay.tell
+        story.destroy
+        expect {
+          job.reload.payload_object
+        }.to raise_error(Delayed::DeserializationError)
+      end
     end
   end
 
@@ -504,8 +516,8 @@ shared_examples_for "a delayed_job backend" do
 
       it "does not fail when the triggered error doesn't have a message" do
         error_with_nil_message = StandardError.new
-        error_with_nil_message.stub(:message).and_return nil
-        @job.stub(:invoke_job).and_raise error_with_nil_message
+        expect(error_with_nil_message).to receive(:message).twice.and_return(nil)
+        expect(@job).to receive(:invoke_job).and_raise error_with_nil_message
         expect{worker.run(@job)}.not_to raise_error
       end
     end
@@ -519,27 +531,25 @@ shared_examples_for "a delayed_job backend" do
         context "when the job's payload has a #failure hook" do
           before do
             @job = Delayed::Job.create :payload_object => OnPermanentFailureJob.new
-            expect(@job.payload_object).to respond_to :failure
+            expect(@job.payload_object).to respond_to(:failure)
           end
 
           it "runs that hook" do
-            @job.payload_object.should_receive :failure
+            expect(@job.payload_object).to receive(:failure)
             worker.reschedule(@job)
           end
         end
 
         context "when the job's payload has no #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.failure makes that object
-          # incorrectly return true to
-          # payload_object.respond_to? :failure, which is what
-          # reschedule uses to decide whether to call failure.
-          # So instead, we just make sure that the payload_object as it
-          # already stands doesn't respond_to? failure, then
-          # shove it through the iterated reschedule loop and make sure we
-          # don't get a NoMethodError (caused by calling that nonexistent
-          # failure method).
+          # because putting a not_to receive expectation on
+          # @job.payload_object.failure makes that object incorrectly return
+          # true to payload_object.respond_to? :failure, which is what
+          # reschedule uses to decide whether to call failure. So instead, we
+          # just make sure that the payload_object as it already stands doesn't
+          # respond_to? failure, then shove it through the iterated reschedule
+          # loop and make sure we don't get a NoMethodError (caused by calling
+          # that nonexistent failure method).
 
           before do
             expect(@job.payload_object).not_to respond_to(:failure)
@@ -557,12 +567,12 @@ shared_examples_for "a delayed_job backend" do
         it_should_behave_like "any failure more than Worker.max_attempts times"
 
         it "is destroyed if it failed more than Worker.max_attempts times" do
-          @job.should_receive(:destroy)
+          expect(@job).to receive(:destroy)
           Delayed::Worker.max_attempts.times { worker.reschedule(@job) }
         end
 
         it "is not destroyed if failed fewer than Worker.max_attempts times" do
-          @job.should_not_receive(:destroy)
+          expect(@job).not_to receive(:destroy)
           (Delayed::Worker.max_attempts - 1).times { worker.reschedule(@job) }
         end
       end

data/lib/delayed/exceptions.rb

@@ -6,4 +6,6 @@ module Delayed
       "#{super} (Delayed::Worker.max_run_time is only #{Delayed::Worker.max_run_time.to_i} seconds)"
     end
   end
+
+  class FatalBackendError < Exception; end
 end

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 object.respond_to?(:new_record?) && object.new_record?
-        raise(ArgumentError, 'Jobs cannot be created for records before they\'ve been persisted')
+      if object.respond_to?(:persisted?) && !object.persisted?
+        raise(ArgumentError, 'Jobs cannot be created for non-persisted records')
       end
 
       self.object       = object

data/lib/delayed/railtie.rb

@@ -5,7 +5,7 @@ module Delayed
   class Railtie < Rails::Railtie
     initializer :after_initialize do
       ActiveSupport.on_load(:action_mailer) do
-        ActionMailer::Base.send(:extend, Delayed::DelayMail)
+        ActionMailer::Base.extend(Delayed::DelayMail)
       end
     end
 

data/lib/delayed/worker.rb

@@ -7,8 +7,9 @@ require 'logger'
 require 'benchmark'
 
 module Delayed
+
   class Worker
-    DEFAULT_LOG_LEVEL        = Logger::INFO
+    DEFAULT_LOG_LEVEL        = 'info'
     DEFAULT_SLEEP_DELAY      = 5
     DEFAULT_MAX_ATTEMPTS     = 25
     DEFAULT_MAX_RUN_TIME     = 4.hours
@@ -225,7 +226,7 @@ module Delayed
         job.unlock
         job.save!
       else
-        job_say job, "REMOVED permanently because of #{job.attempts} consecutive failures", Logger::ERROR
+        job_say job, "REMOVED permanently because of #{job.attempts} consecutive failures", 'error'
         failed(job)
       end
     end
@@ -245,7 +246,13 @@ module Delayed
     def say(text, level = DEFAULT_LOG_LEVEL)
       text = "[Worker(#{name})] #{text}"
       puts text unless @quiet
-      logger.add level, "#{Time.now.strftime('%FT%T%z')}: #{text}" if logger
+      if logger
+        # TODO: Deprecate use of Fixnum log levels
+        if !level.is_a?(String)
+          level = Logger::Severity.constants.detect {|i| Logger::Severity.const_get(i) == level }.to_s.downcase
+        end
+        logger.send(level, "#{Time.now.strftime('%FT%T%z')}: #{text}")
+      end
     end
 
     def max_attempts(job)
@@ -256,7 +263,7 @@ module Delayed
 
     def handle_failed_job(job, error)
       job.last_error = "#{error.message}\n#{error.backtrace.join("\n")}"
-      job_say job, "FAILED (#{job.attempts} prior attempts) with #{error.class.name}: #{error.message}", Logger::ERROR
+      job_say job, "FAILED (#{job.attempts} prior attempts) with #{error.class.name}: #{error.message}", 'error'
       reschedule(job)
     end
 

data/spec/helper.rb

@@ -26,7 +26,7 @@ Delayed::Worker.backend = :test
 ActiveSupport::Dependencies.autoload_paths << File.dirname(__FILE__)
 
 # Add this to simulate Railtie initializer being executed
-ActionMailer::Base.send(:extend, Delayed::DelayMail)
+ActionMailer::Base.extend(Delayed::DelayMail)
 
 
 # Used to test interactions between DJ and an ORM

data/spec/lifecycle_spec.rb

@@ -13,8 +13,8 @@ describe Delayed::Lifecycle do
     end
 
     it "executes before wrapped block" do
-      callback.should_receive(:call).with(*arguments).ordered
-      behavior.should_receive(:inside!).ordered
+      expect(callback).to receive(:call).with(*arguments).ordered
+      expect(behavior).to receive(:inside!).ordered
       lifecycle.run_callbacks :execute, *arguments, &wrapped_block
     end
   end
@@ -25,8 +25,8 @@ describe Delayed::Lifecycle do
     end
 
     it "executes after wrapped block" do
-      behavior.should_receive(:inside!).ordered
-      callback.should_receive(:call).with(*arguments).ordered
+      expect(behavior).to receive(:inside!).ordered
+      expect(callback).to receive(:call).with(*arguments).ordered
       lifecycle.run_callbacks :execute, *arguments, &wrapped_block
     end
   end
@@ -41,16 +41,16 @@ describe Delayed::Lifecycle do
     end
 
     it "wraps a block" do
-      behavior.should_receive(:before!).ordered
-      behavior.should_receive(:inside!).ordered
-      behavior.should_receive(:after!).ordered
+      expect(behavior).to receive(:before!).ordered
+      expect(behavior).to receive(:inside!).ordered
+      expect(behavior).to receive(:after!).ordered
       lifecycle.run_callbacks :execute, *arguments, &wrapped_block
     end
 
     it "executes multiple callbacks in order" do
-      behavior.should_receive(:one).ordered
-      behavior.should_receive(:two).ordered
-      behavior.should_receive(:three).ordered
+      expect(behavior).to receive(:one).ordered
+      expect(behavior).to receive(:two).ordered
+      expect(behavior).to receive(:three).ordered
 
       lifecycle.around(:execute) { |*args, &block| behavior.one; block.call(*args) }
       lifecycle.around(:execute) { |*args, &block| behavior.two; block.call(*args) }

data/spec/performable_mailer_spec.rb

@@ -34,8 +34,8 @@ describe ActionMailer::Base do
         mailer_class = double('MailerClass', :signup => email)
         mailer = Delayed::PerformableMailer.new(mailer_class, :signup, ['john@example.com'])
 
-        mailer_class.should_receive(:signup).with('john@example.com')
-        email.should_receive(:deliver)
+        expect(mailer_class).to receive(:signup).with('john@example.com')
+        expect(email).to receive(:deliver)
         mailer.perform
       end
     end

data/spec/performable_method_spec.rb

@@ -17,7 +17,7 @@ describe Delayed::PerformableMethod do
     end
 
     it "calls the method on the object" do
-      @method.object.should_receive(:count).with('o')
+      expect(@method.object).to receive(:count).with('o')
       @method.perform
     end
   end
@@ -45,7 +45,7 @@ describe Delayed::PerformableMethod do
         story = Story.create
         job = story.delay.tell
 
-        story.should_receive(hook).with(job)
+        expect(story).to receive(hook).with(job)
         job.invoke_job
       end
     end
@@ -55,34 +55,34 @@ describe Delayed::PerformableMethod do
         story = Story.create
         job = story.delay.tell
 
-        story.should_receive(hook).with(job)
+        expect(story).to receive(hook).with(job)
         job.invoke_job
       end
     end
 
     it "delegates enqueue hook to object" do
       story = Story.create
-      story.should_receive(:enqueue).with(an_instance_of(Delayed::Job))
+      expect(story).to receive(:enqueue).with(an_instance_of(Delayed::Job))
       story.delay.tell
     end
 
     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)
+      expect(story).to receive(:error).with(an_instance_of(Delayed::Job), an_instance_of(RuntimeError))
+      expect(story).to receive(:tell).and_raise(RuntimeError)
       expect { story.delay.tell.invoke_job }.to raise_error
     end
 
     it "delegates error hook to object when delay_jobs = false" 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)
+      expect(story).to receive(:error).with(an_instance_of(Delayed::Job), an_instance_of(RuntimeError))
+      expect(story).to receive(:tell).and_raise(RuntimeError)
       expect { story.delay.tell.invoke_job }.to raise_error
     end
 
     it "delegates failure hook to object" do
       method = Delayed::PerformableMethod.new("object", :size, [])
-      method.object.should_receive(:failure)
+      expect(method.object).to receive(:failure)
       method.failure
     end
 
@@ -98,7 +98,7 @@ describe Delayed::PerformableMethod do
       %w(before after success).each do |hook|
         it "delegates #{hook} hook to object" do
           story = Story.create
-          story.should_receive(hook).with(an_instance_of(Delayed::Job))
+          expect(story).to receive(hook).with(an_instance_of(Delayed::Job))
           story.delay.tell
         end
       end
@@ -106,29 +106,29 @@ describe Delayed::PerformableMethod do
       %w(before after success).each do |hook|
         it "delegates #{hook} hook to object" do
           story = Story.create
-          story.should_receive(hook).with(an_instance_of(Delayed::Job))
+          expect(story).to receive(hook).with(an_instance_of(Delayed::Job))
           story.delay.tell
         end
       end
 
       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)
+        expect(story).to receive(:error).with(an_instance_of(Delayed::Job), an_instance_of(RuntimeError))
+        expect(story).to receive(:tell).and_raise(RuntimeError)
         expect { story.delay.tell }.to raise_error
       end
 
       it "delegates error hook to object when delay_jobs = false" 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)
+        expect(story).to receive(:error).with(an_instance_of(Delayed::Job), an_instance_of(RuntimeError))
+        expect(story).to receive(:tell).and_raise(RuntimeError)
         expect { story.delay.tell }.to raise_error
       end
 
       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)
+        expect(method.object).to receive(:failure)
         method.failure
       end
     end

data/spec/worker_spec.rb

@@ -28,7 +28,7 @@ describe Delayed::Worker do
     end
 
     it "logs with job name and id" do
-      @worker.should_receive(:say).
+      expect(@worker).to receive(:say).
         with('Job ExampleJob (id=123) message', Delayed::Worker::DEFAULT_LOG_LEVEL)
       @worker.job_say(@job, 'message')
     end
@@ -44,13 +44,13 @@ describe Delayed::Worker do
     end
 
     it "reads five jobs" do
-      Delayed::Job.should_receive(:find_available).with(anything, 5, anything).and_return([])
+      expect(Delayed::Job).to 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([])
+      expect(Delayed::Job).to receive(:find_available).with(anything, Delayed::Worker.read_ahead, anything).and_return([])
       Delayed::Job.reserve(Delayed::Worker.new)
     end
   end
@@ -82,21 +82,68 @@ describe Delayed::Worker do
     end
 
     it "handles error during job reservation" do
-      Delayed::Job.should_receive(:reserve).and_raise(Exception)
+      expect(Delayed::Job).to receive(:reserve).and_raise(Exception)
       Delayed::Worker.new.work_off
     end
 
     it "gives up after 10 backend failures" do
-      Delayed::Job.stub(:reserve).and_raise(Exception)
+      expect(Delayed::Job).to receive(:reserve).exactly(10).times.and_raise(Exception)
       worker = Delayed::Worker.new
       9.times { worker.work_off }
-      expect(lambda { worker.work_off }).to raise_exception
+      expect(lambda { worker.work_off }).to raise_exception Delayed::FatalBackendError
     end
 
     it "allows the backend to attempt recovery from reservation errors" do
-      Delayed::Job.should_receive(:reserve).and_raise(Exception)
-      Delayed::Job.should_receive(:recover_from).with(instance_of(Exception))
+      expect(Delayed::Job).to receive(:reserve).and_raise(Exception)
+      expect(Delayed::Job).to receive(:recover_from).with(instance_of(Exception))
       Delayed::Worker.new.work_off
     end
   end
+
+  context "#say" do
+    before(:each) do
+      @worker = Delayed::Worker.new
+      @worker.name = 'ExampleJob'
+      @worker.logger = double('job')
+      time = Time.now
+      Time.stub(:now).and_return(time)
+      @text = "Job executed"
+      @worker_name = "[Worker(ExampleJob)]"
+      @expected_time = time.strftime('%FT%T%z')
+    end
+
+    after(:each) do
+      @worker.logger = nil
+    end
+
+    shared_examples_for "a worker which logs on the correct severity" do |severity|
+      it "logs a message on the #{severity[:level].upcase} level given a string" do
+        expect(@worker.logger).to receive(:send).
+          with(severity[:level], "#{@expected_time}: #{@worker_name} #{@text}")
+        @worker.say(@text, severity[:level])
+      end
+
+      it "logs a message on the #{severity[:level].upcase} level given a fixnum" do
+        expect(@worker.logger).to receive(:send).
+          with(severity[:level], "#{@expected_time}: #{@worker_name} #{@text}")
+        @worker.say(@text, severity[:index])
+      end
+    end
+
+    severities = [ { index: 0, level: "debug" },
+                   { index: 1, level: "info" },
+                   { index: 2, level: "warn" },
+                   { index: 3, level: "error" },
+                   { index: 4, level: "fatal" },
+                   { index: 5, level: "unknown" } ]
+    severities.each do |severity|
+      it_behaves_like "a worker which logs on the correct severity", severity
+    end
+
+    it "logs a message on the default log's level" do
+      expect(@worker.logger).to receive(:send).
+        with("info", "#{@expected_time}: #{@worker_name} #{@text}")
+      @worker.say(@text, Delayed::Worker::DEFAULT_LOG_LEVEL)
+    end
+  end
 end

metadata

@@ -1,8 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: delayed_job
 version: !ruby/object:Gem::Version
-  version: 4.0.0
-  prerelease: 
+  version: 4.0.1
 platform: ruby
 authors:
 - Brandon Keepers
@@ -16,30 +15,28 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-07-30 00:00:00.000000000 Z
+date: 2014-04-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '3.0'
-    - - <
+    - - "<"
       - !ruby/object:Gem::Version
-        version: '4.1'
+        version: '4.2'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '3.0'
-    - - <
+    - - "<"
       - !ruby/object:Gem::Version
-        version: '4.1'
+        version: '4.2'
 description: Delayed_job (or DJ) encapsulates the common pattern of asynchronously
   executing longer tasks in the background. It is a direct extraction from Shopify
   where the job table is responsible for a multitude of core tasks.
@@ -54,11 +51,11 @@ files:
 - LICENSE.md
 - README.md
 - Rakefile
-- delayed_job.gemspec
 - contrib/delayed_job.monitrc
 - contrib/delayed_job_multiple.monitrc
 - contrib/delayed_job_rails_4.monitrc
 - contrib/delayed_job_rails_4_multiple.monitrc
+- delayed_job.gemspec
 - lib/delayed/backend/base.rb
 - lib/delayed/backend/shared_spec.rb
 - lib/delayed/command.rb
@@ -101,33 +98,26 @@ files:
 homepage: http://github.com/collectiveidea/delayed_job
 licenses:
 - MIT
+metadata: {}
 post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
-      segments:
-      - 0
-      hash: 3979399263094595498
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
-      segments:
-      - 0
-      hash: 3979399263094595498
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.23
+rubygems_version: 2.2.2
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: Database-backed asynchronous priority queue system -- Extracted from Shopify
 test_files:
 - spec/autoloaded/clazz.rb