delayed_job 4.0.2 → 4.0.3

checksums.yaml

@@ -1,15 +1,7 @@
 ---
-!binary "U0hBMQ==":
-  metadata.gz: !binary |-
-    YjQ5ZWQ1YmMzNWIxNTVhYzllZTdhNWI0ZWI4MzAwMzA3YjdjN2IyYg==
-  data.tar.gz: !binary |-
-    MDJmZDk3ZjJjYmNkZWFiMmIzNTU5MGQzMmNiOWM4Mzk2ODE0ODkzZg==
+SHA1:
+  metadata.gz: f8464e2a78c559301360d0c083d940e73f314406
+  data.tar.gz: 819bd2dc775364ed9e6311be0a82fb3bdc20d6a6
 SHA512:
-  metadata.gz: !binary |-
-    ZGVkODJjNTNkYTc5YmJkYWIxN2NiZjVkZTA4M2ExYzg5ZjU5NjRkNDBmMjAz
-    ZWVkNjcxMWRlZmZmOTU4OGNiMTU0N2E2N2QwODczYmQyNjI5YmM3MDc3ZTNm
-    YTI2Njk1NzBjZDFmYTkxZmE1YmVkYzJkOWI3NDZiODc2NDc1NjM=
-  data.tar.gz: !binary |-
-    OTBkOGMwYjNiZGIxNWMxODk3ZjI1OWFlZTU5NDlmNTZiZTBhNGQ0ZTY1ZjRm
-    ZWYwYzFkZjgxMTE5OWJhMzg3NWU0YzU3MWNhMGJmMjg0N2Y4NDk5MjY5ZDE3
-    NDMxYWFmOTU0M2FhZWJmMzIyYmNlMDZiYjJjODg0NjM0NWVkODQ=
+  metadata.gz: c7d9b76c5f6244b37e79f2df7f5d5d270bd0769366ab0d93967ca02bd9ff434b98801ed92032815d0e0dd1abba5f9617881dd64aeabf09ed0700066f59985a3f
+  data.tar.gz: 3f99c1bcddf3c835a4eea9cd200b559d1d284d169633016e79b0303549583be78cdfd888671139fe83ecec669b140171bb255d3f4bf03eaa9a4a45ed2c2bc7e2

data/CHANGELOG.md

@@ -1,3 +1,10 @@
+4.0.3 - 2014-09-04
+==================
+* Added --pools option to delayed_job command
+* Removed a bunch of the Psych hacks
+* Improved deserialization error reporting
+* Misc bug fixes
+
 4.0.2 - 2014-06-24
 ==================
 * Add support for RSpec 3

data/README.md

@@ -190,6 +190,11 @@ 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
 
+    # Use the --pool option to specify a worker pool. You can use this option multiple times to start different numbers of workers for different queues.
+    # The following command will start 1 worker for the tracking queue,
+    # 2 workers for the mailers and tasks queues, and 2 workers for any jobs:
+    RAILS_ENV=production script/delayed_job --pool=tracking --pool=mailers,tasks:2 --pool=*:2 start
+
     # Runs all available jobs and then exits
     RAILS_ENV=production script/delayed_job start --exit-on-complete
     # or to run in the foreground
@@ -310,22 +315,22 @@ end
 
 On failure, the job is scheduled again in 5 seconds + N ** 4, where N is the number of retries.
 
-The default Worker.max_attempts is 25. After this, the job either deleted (default), or left in the database with "failed_at" set.
+The default `Worker.max_attempts` is 25. After this, the job either deleted (default), or left in the database with "failed_at" set.
 With the default of 25 attempts, the last retry will be 20 days later, with the last interval being almost 100 hours.
 
-The default Worker.max_run_time is 4.hours. If your job takes longer than that, another computer could pick it up. It's up to you to
+The default `Worker.max_run_time` is 4.hours. If your job takes longer than that, another computer could pick it up. It's up to you to
 make sure your job doesn't exceed this time. You should set this to the longest time you think the job could take.
 
 By default, it will delete failed jobs (and it always deletes successful jobs). If you want to keep failed jobs, set
-Delayed::Worker.destroy_failed_jobs = false. The failed jobs will be marked with non-null failed_at.
+`Delayed::Worker.destroy_failed_jobs = false`. The failed jobs will be marked with non-null failed_at.
 
-By default all jobs are scheduled with priority = 0, which is top priority. You can change this by setting Delayed::Worker.default_priority to something else. Lower numbers have higher priority.
+By default all jobs are scheduled with `priority = 0`, which is top priority. You can change this by setting `Delayed::Worker.default_priority` to something else. Lower numbers have higher priority.
 
-The default behavior is to read 5 jobs from the queue when finding an available job. You can configure this by setting Delayed::Worker.read_ahead.
+The default behavior is to read 5 jobs from the queue when finding an available job. You can configure this by setting `Delayed::Worker.read_ahead`.
 
-By default all jobs will be queued without a named queue. A default named queue can be specified by using Delayed::Worker.default_queue_name.
+By default all jobs will be queued without a named queue. A default named queue can be specified by using `Delayed::Worker.default_queue_name`.
 
-It is possible to disable delayed jobs for testing purposes. Set Delayed::Worker.delay_jobs = false to execute all jobs realtime.
+It is possible to disable delayed jobs for testing purposes. Set `Delayed::Worker.delay_jobs = false` to execute all jobs realtime.
 
 Here is an example of changing job parameters in Rails:
 

data/Rakefile

@@ -7,4 +7,9 @@ RSpec::Core::RakeTask.new do |r|
   r.verbose = false
 end
 
-task :default => :spec
+task :test => :spec
+
+require 'rubocop/rake_task'
+RuboCop::RakeTask.new
+
+task :default => [:spec, :rubocop]

data/delayed_job.gemspec

@@ -1,9 +1,9 @@
 Gem::Specification.new do |spec|
-  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.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']
-  spec.files          = %w(CHANGELOG.md CONTRIBUTING.md LICENSE.md README.md Rakefile delayed_job.gemspec)
+  spec.files          = %w[CHANGELOG.md CONTRIBUTING.md LICENSE.md README.md Rakefile delayed_job.gemspec]
   spec.files         += Dir.glob('{contrib,lib,recipes,spec}/**/*')
   spec.homepage       = 'http://github.com/collectiveidea/delayed_job'
   spec.licenses       = ['MIT']
@@ -11,5 +11,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.2'
+  spec.version        = '4.0.3'
 end

data/lib/delayed/backend/base.rb

@@ -16,7 +16,7 @@ module Delayed
           options[:payload_object] ||= args.shift
 
           if args.size > 0
-            warn "[DEPRECATION] Passing multiple arguments to `#enqueue` is deprecated. Pass a hash with :priority and :run_at."
+            warn '[DEPRECATION] Passing multiple arguments to `#enqueue` is deprecated. Pass a hash with :priority and :run_at.'
             options[:priority] = args.first || options[:priority]
             options[:run_at]   = args[1]
           end
@@ -26,7 +26,7 @@ module Delayed
           end
 
           if Delayed::Worker.delay_jobs
-            self.new(options).tap do |job|
+            new(options).tap do |job|
               Delayed::Worker.lifecycle.run_callbacks(:enqueue, job) do
                 job.hook(:enqueue)
                 job.save
@@ -48,7 +48,7 @@ module Delayed
         end
 
         # Allow the backend to attempt recovery from reserve errors
-        def recover_from(error)
+        def recover_from(_error)
         end
 
         # Hook method that is called before a new worker is forked
@@ -60,7 +60,7 @@ module Delayed
         end
 
         def work_off(num = 100)
-          warn "[DEPRECATION] `Delayed::Job.work_off` is deprecated. Use `Delayed::Worker.new.work_off instead."
+          warn '[DEPRECATION] `Delayed::Job.work_off` is deprecated. Use `Delayed::Worker.new.work_off instead.'
           Delayed::Worker.new.work_off(num)
         end
       end
@@ -70,12 +70,10 @@ module Delayed
       end
       alias_method :failed, :failed?
 
-      ParseObjectFromYaml = /\!ruby\/\w+\:([^\s]+)/
+      ParseObjectFromYaml = /\!ruby\/\w+\:([^\s]+)/ # rubocop:disable ConstantName
 
       def name
-        @name ||= payload_object.respond_to?(:display_name) ?
-                    payload_object.display_name :
-                    payload_object.class.name
+        @name ||= payload_object.respond_to?(:display_name) ? payload_object.display_name : payload_object.class.name
       rescue DeserializationError
         ParseObjectFromYaml.match(handler)[1]
       end
@@ -87,15 +85,14 @@ module Delayed
 
       def payload_object
         if YAML.respond_to?(:unsafe_load)
-          #See https://github.com/dtao/safe_yaml
-          #When the method is there, we need to load our YAML like this...
-          @payload_object ||= YAML.load(self.handler, :safe => false)
+          # See https://github.com/dtao/safe_yaml
+          # When the method is there, we need to load our YAML like this...
+          @payload_object ||= YAML.load(handler, :safe => false)
         else
-          @payload_object ||= YAML.load(self.handler)
+          @payload_object ||= YAML.load(handler)
         end
       rescue TypeError, LoadError, NameError, ArgumentError => e
-        raise DeserializationError,
-          "Job failed to load: #{e.message}. Handler: #{handler.inspect}"
+        raise DeserializationError, "Job failed to load: #{e.message}. Handler: #{handler.inspect}"
       end
 
       def invoke_job
@@ -104,7 +101,7 @@ module Delayed
             hook :before
             payload_object.perform
             hook :success
-          rescue Exception => e
+          rescue => e
             hook :error, e
             raise e
           ensure
@@ -124,14 +121,15 @@ module Delayed
           method = payload_object.method(name)
           method.arity == 0 ? method.call : method.call(self, *args)
         end
-      rescue DeserializationError
-        # do nothing
+      rescue DeserializationError # rubocop:disable HandleExceptions
       end
 
       def reschedule_at
-        payload_object.respond_to?(:reschedule_at) ?
-          payload_object.reschedule_at(self.class.db_time_now, attempts) :
-          self.class.db_time_now + (attempts ** 4) + 5
+        if payload_object.respond_to?(:reschedule_at)
+          payload_object.reschedule_at(self.class.db_time_now, attempts)
+        else
+          self.class.db_time_now + (attempts**4) + 5
+        end
       end
 
       def max_attempts

data/lib/delayed/backend/shared_spec.rb

@@ -2,7 +2,7 @@ require File.expand_path('../../../../spec/sample_jobs', __FILE__)
 
 require 'active_support/core_ext'
 
-shared_examples_for "a delayed_job backend" do
+shared_examples_for 'a delayed_job backend' do
   let(:worker) { Delayed::Worker.new }
 
   def create_job(opts = {})
@@ -22,74 +22,74 @@ shared_examples_for "a delayed_job backend" do
     Delayed::Worker.reset
   end
 
-  it "sets run_at automatically if not set" do
-    expect(described_class.create(:payload_object => ErrorJob.new ).run_at).not_to be_nil
+  it 'sets run_at automatically if not set' do
+    expect(described_class.create(:payload_object => ErrorJob.new).run_at).not_to be_nil
   end
 
-  it "does not set run_at automatically if already set" do
+  it 'does not set run_at automatically if already set' do
     later = described_class.db_time_now + 5.minutes
     job = described_class.create(:payload_object => ErrorJob.new, :run_at => later)
     expect(job.run_at).to be_within(1).of(later)
   end
 
-  describe "#reload" do
-    it "reloads the payload" do
+  describe '#reload' do
+    it 'reloads the payload' do
       job = described_class.enqueue :payload_object => SimpleJob.new
       expect(job.payload_object.object_id).not_to eq(job.reload.payload_object.object_id)
     end
   end
 
-  describe "enqueue" do
-    context "with a hash" do
+  describe 'enqueue' do
+    context 'with a hash' do
       it "raises ArgumentError when handler doesn't respond_to :perform" do
-        expect{described_class.enqueue(:payload_object => Object.new)}.to raise_error(ArgumentError)
+        expect { described_class.enqueue(:payload_object => Object.new) }.to raise_error(ArgumentError)
       end
 
-      it "is able to set priority" do
+      it 'is able to set priority' do
         job = described_class.enqueue :payload_object => SimpleJob.new, :priority => 5
         expect(job.priority).to eq(5)
       end
 
-      it "uses default priority" do
+      it 'uses default priority' do
         job = described_class.enqueue :payload_object => SimpleJob.new
         expect(job.priority).to eq(99)
       end
 
-      it "is able to set run_at" do
+      it 'is able to set run_at' do
         later = described_class.db_time_now + 5.minutes
         job = described_class.enqueue :payload_object => SimpleJob.new, :run_at => later
         expect(job.run_at).to be_within(1).of(later)
       end
 
-      it "is able to set queue" do
+      it 'is able to set queue' do
         job = described_class.enqueue :payload_object => SimpleJob.new, :queue => 'tracking'
         expect(job.queue).to eq('tracking')
       end
     end
 
-    context "with multiple arguments" do
+    context 'with multiple arguments' do
       it "raises ArgumentError when handler doesn't respond_to :perform" do
-        expect{described_class.enqueue(Object.new)}.to raise_error(ArgumentError)
+        expect { described_class.enqueue(Object.new) }.to raise_error(ArgumentError)
       end
 
-      it "increases count after enqueuing items" do
+      it 'increases count after enqueuing items' do
         described_class.enqueue SimpleJob.new
         expect(described_class.count).to eq(1)
       end
 
-      it "is able to set priority [DEPRECATED]" do
+      it 'is able to set priority [DEPRECATED]' do
         silence_warnings do
           job = described_class.enqueue SimpleJob.new, 5
           expect(job.priority).to eq(5)
         end
       end
 
-      it "uses default priority when it is not set" do
+      it 'uses default priority when it is not set' do
         @job = described_class.enqueue SimpleJob.new
         expect(@job.priority).to eq(99)
       end
 
-      it "is able to set run_at [DEPRECATED]" do
+      it 'is able to set run_at [DEPRECATED]' do
         silence_warnings do
           later = described_class.db_time_now + 5.minutes
           @job = described_class.enqueue SimpleJob.new, 5, later
@@ -97,41 +97,41 @@ shared_examples_for "a delayed_job backend" do
         end
       end
 
-      it "works with jobs in modules" do
+      it 'works with jobs in modules' do
         M::ModuleJob.runs = 0
         job = described_class.enqueue M::ModuleJob.new
-        expect{job.invoke_job}.to change { M::ModuleJob.runs }.from(0).to(1)
+        expect { job.invoke_job }.to change { M::ModuleJob.runs }.from(0).to(1)
       end
     end
 
-    context "with delay_jobs = false" do
+    context 'with delay_jobs = false' do
       before(:each) do
         Delayed::Worker.delay_jobs = false
       end
 
-      it "does not increase count after enqueuing items" do
+      it 'does not increase count after enqueuing items' do
         described_class.enqueue SimpleJob.new
         expect(described_class.count).to eq(0)
       end
 
-      it "invokes the enqueued job" do
+      it 'invokes the enqueued job' do
         job = SimpleJob.new
         expect(job).to receive(:perform)
         described_class.enqueue job
       end
 
-      it "returns a job, not the result of invocation" do
+      it 'returns a job, not the result of invocation' do
         expect(described_class.enqueue(SimpleJob.new)).to be_instance_of(described_class)
       end
     end
   end
 
-  describe "callbacks" do
+  describe 'callbacks' do
     before(:each) do
       CallbackJob.messages = []
     end
 
-    %w(before success after).each do |callback|
+    %w[before success after].each do |callback|
       it "calls #{callback} with job" do
         job = described_class.enqueue(CallbackJob.new)
         expect(job.payload_object).to receive(callback).with(job)
@@ -139,48 +139,48 @@ shared_examples_for "a delayed_job backend" do
       end
     end
 
-    it "calls before and after callbacks" do
+    it 'calls before and after callbacks' do
       job = described_class.enqueue(CallbackJob.new)
-      expect(CallbackJob.messages).to eq(["enqueue"])
+      expect(CallbackJob.messages).to eq(['enqueue'])
       job.invoke_job
-      expect(CallbackJob.messages).to eq(["enqueue", "before", "perform", "success", "after"])
+      expect(CallbackJob.messages).to eq(%w[enqueue before perform success after])
     end
 
-    it "calls the after callback with an error" do
+    it 'calls the after callback with an error' do
       job = described_class.enqueue(CallbackJob.new)
-      expect(job.payload_object).to 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"])
+      expect { job.invoke_job }.to raise_error
+      expect(CallbackJob.messages).to eq(['enqueue', 'before', 'error: RuntimeError', 'after'])
     end
 
-    it "calls error when before raises an error" do
+    it 'calls error when before raises an error' do
       job = described_class.enqueue(CallbackJob.new)
-      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"])
+      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
   end
 
-  describe "payload_object" do
-    it "raises a DeserializationError when the job class is totally unknown" do
-      job = described_class.new :handler => "--- !ruby/object:JobThatDoesNotExist {}"
-      expect{job.payload_object}.to raise_error(Delayed::DeserializationError)
+  describe 'payload_object' do
+    it 'raises a DeserializationError when the job class is totally unknown' do
+      job = described_class.new :handler => '--- !ruby/object:JobThatDoesNotExist {}'
+      expect { job.payload_object }.to raise_error(Delayed::DeserializationError)
     end
 
-    it "raises a DeserializationError when the job struct is totally unknown" do
-      job = described_class.new :handler => "--- !ruby/struct:StructThatDoesNotExist {}"
-      expect{job.payload_object}.to raise_error(Delayed::DeserializationError)
+    it 'raises a DeserializationError when the job struct is totally unknown' do
+      job = described_class.new :handler => '--- !ruby/struct:StructThatDoesNotExist {}'
+      expect { job.payload_object }.to raise_error(Delayed::DeserializationError)
     end
 
-    it "raises a DeserializationError when the YAML.load raises argument error" do
-      job = described_class.new :handler => "--- !ruby/struct:GoingToRaiseArgError {}"
+    it 'raises a DeserializationError when the YAML.load raises argument error' do
+      job = described_class.new :handler => '--- !ruby/struct:GoingToRaiseArgError {}'
       expect(YAML).to receive(:load).and_raise(ArgumentError)
-      expect{job.payload_object}.to raise_error(Delayed::DeserializationError)
+      expect { job.payload_object }.to raise_error(Delayed::DeserializationError)
     end
   end
 
-  describe "reserve" do
+  describe 'reserve' do
     before do
       Delayed::Worker.max_run_time = 2.minutes
     end
@@ -189,28 +189,28 @@ shared_examples_for "a delayed_job backend" do
       Time.zone = nil
     end
 
-    it "does not reserve failed jobs" do
+    it 'does not reserve failed jobs' do
       create_job :attempts => 50, :failed_at => described_class.db_time_now
       expect(described_class.reserve(worker)).to be_nil
     end
 
-    it "does not reserve jobs scheduled for the future" do
+    it 'does not reserve jobs scheduled for the future' do
       create_job :run_at => described_class.db_time_now + 1.minute
       expect(described_class.reserve(worker)).to be_nil
     end
 
-    it "reserves jobs scheduled for the past" do
+    it 'reserves jobs scheduled for the past' do
       job = create_job :run_at => described_class.db_time_now - 1.minute
       expect(described_class.reserve(worker)).to eq(job)
     end
 
-    it "reserves jobs scheduled for the past when time zones are involved" do
+    it 'reserves jobs scheduled for the past when time zones are involved' do
       Time.zone = 'US/Eastern'
       job = create_job :run_at => described_class.db_time_now - 1.minute
       expect(described_class.reserve(worker)).to eq(job)
     end
 
-    it "does not reserve jobs locked by other workers" do
+    it 'does not reserve jobs locked by other workers' do
       job = create_job
       other_worker = Delayed::Worker.new
       other_worker.name = 'other_worker'
@@ -218,51 +218,51 @@ shared_examples_for "a delayed_job backend" do
       expect(described_class.reserve(worker)).to be_nil
     end
 
-    it "reserves open jobs" do
+    it 'reserves open jobs' do
       job = create_job
       expect(described_class.reserve(worker)).to eq(job)
     end
 
-    it "reserves expired jobs" do
+    it 'reserves expired jobs' do
       job = create_job(:locked_by => 'some other worker', :locked_at => described_class.db_time_now - Delayed::Worker.max_run_time - 1.minute)
       expect(described_class.reserve(worker)).to eq(job)
     end
 
-    it "reserves own jobs" do
+    it 'reserves own jobs' do
       job = create_job(:locked_by => worker.name, :locked_at => (described_class.db_time_now - 1.minutes))
       expect(described_class.reserve(worker)).to eq(job)
     end
   end
 
-  context "#name" do
-    it "is the class name of the job that was enqueued" do
-      expect(described_class.create(:payload_object => ErrorJob.new ).name).to eq('ErrorJob')
+  context '#name' do
+    it 'is the class name of the job that was enqueued' do
+      expect(described_class.create(:payload_object => ErrorJob.new).name).to eq('ErrorJob')
     end
 
-    it "is the method that will be called if its a performable method object" do
+    it 'is the method that will be called if its a performable method object' do
       job = described_class.new(:payload_object => NamedJob.new)
       expect(job.name).to eq('named_job')
     end
 
-    it "is the instance method that will be called if its a performable method object" do
-      job = Story.create(:text => "...").delay.save
+    it 'is the instance method that will be called if its a performable method object' do
+      job = Story.create(:text => '...').delay.save
       expect(job.name).to eq('Story#save')
     end
 
-    it "parses from handler on deserialization error" do
-      job = Story.create(:text => "...").delay.text
+    it 'parses from handler on deserialization error' do
+      job = Story.create(:text => '...').delay.text
       job.payload_object.object.destroy
       expect(job.reload.name).to eq('Delayed::PerformableMethod')
     end
   end
 
-  context "worker prioritization" do
+  context 'worker prioritization' do
     after do
       Delayed::Worker.max_priority = nil
       Delayed::Worker.min_priority = nil
     end
 
-    it "fetches jobs ordered by priority" do
+    it 'fetches jobs ordered by priority' do
       10.times { described_class.enqueue SimpleJob.new, :priority => rand(10) }
       jobs = []
       10.times { jobs << described_class.reserve(worker) }
@@ -272,10 +272,10 @@ shared_examples_for "a delayed_job backend" do
       end
     end
 
-    it "only finds jobs greater than or equal to min priority" do
+    it 'only finds jobs greater than or equal to min priority' do
       min = 5
       Delayed::Worker.min_priority = min
-      [4,5,6].sort_by {|i| rand }.each {|i| create_job :priority => i }
+      [4, 5, 6].sort_by { |_i| rand }.each { |i| create_job :priority => i }
       2.times do
         job = described_class.reserve(worker)
         expect(job.priority).to be >= min
@@ -284,10 +284,10 @@ shared_examples_for "a delayed_job backend" do
       expect(described_class.reserve(worker)).to be_nil
     end
 
-    it "only finds jobs less than or equal to max priority" do
+    it 'only finds jobs less than or equal to max priority' do
       max = 5
       Delayed::Worker.max_priority = max
-      [4,5,6].sort_by {|i| rand }.each {|i| create_job :priority => i }
+      [4, 5, 6].sort_by { |_i| rand }.each { |i| create_job :priority => i }
       2.times do
         job = described_class.reserve(worker)
         expect(job.priority).to be <= max
@@ -297,73 +297,73 @@ shared_examples_for "a delayed_job backend" do
     end
   end
 
-  context "clear_locks!" do
+  context 'clear_locks!' do
     before do
       @job = create_job(:locked_by => 'worker1', :locked_at => described_class.db_time_now)
     end
 
-    it "clears locks for the given worker" do
+    it 'clears locks for the given worker' do
       described_class.clear_locks!('worker1')
       expect(described_class.reserve(worker)).to eq(@job)
     end
 
-    it "does not clear locks for other workers" do
+    it 'does not clear locks for other workers' do
       described_class.clear_locks!('different_worker')
       expect(described_class.reserve(worker)).not_to eq(@job)
     end
   end
 
-  context "unlock" do
+  context 'unlock' do
     before do
       @job = create_job(:locked_by => 'worker', :locked_at => described_class.db_time_now)
     end
 
-    it "clears locks" do
+    it 'clears locks' do
       @job.unlock
       expect(@job.locked_by).to be_nil
       expect(@job.locked_at).to be_nil
     end
   end
 
-  context "large handler" do
+  context 'large handler' do
     before do
-      text = "Lorem ipsum dolor sit amet. " * 1000
+      text = 'Lorem ipsum dolor sit amet. ' * 1000
       @job = described_class.enqueue Delayed::PerformableMethod.new(text, :length, {})
     end
 
-    it "has an id" do
+    it 'has an id' do
       expect(@job.id).not_to be_nil
     end
   end
 
-  context "named queues" do
-    context "when worker has one queue set" do
+  context 'named queues' do
+    context 'when worker has one queue set' do
       before(:each) do
         worker.queues = ['large']
       end
 
-      it "only works off jobs which are from its queue" do
+      it 'only works off jobs which are from its queue' do
         expect(SimpleJob.runs).to eq(0)
 
-        create_job(:queue => "large")
-        create_job(:queue => "small")
+        create_job(:queue => 'large')
+        create_job(:queue => 'small')
         worker.work_off
 
         expect(SimpleJob.runs).to eq(1)
       end
     end
 
-    context "when worker has two queue set" do
+    context 'when worker has two queue set' do
       before(:each) do
-        worker.queues = ['large', 'small']
+        worker.queues = %w[large small]
       end
 
-      it "only works off jobs which are from its queue" do
+      it 'only works off jobs which are from its queue' do
         expect(SimpleJob.runs).to eq(0)
 
-        create_job(:queue => "large")
-        create_job(:queue => "small")
-        create_job(:queue => "medium")
+        create_job(:queue => 'large')
+        create_job(:queue => 'small')
+        create_job(:queue => 'medium')
         create_job
         worker.work_off
 
@@ -371,16 +371,16 @@ shared_examples_for "a delayed_job backend" do
       end
     end
 
-    context "when worker does not have queue set" do
+    context 'when worker does not have queue set' do
       before(:each) do
         worker.queues = []
       end
 
-      it "works off all jobs" do
+      it 'works off all jobs' do
         expect(SimpleJob.runs).to eq(0)
 
-        create_job(:queue => "one")
-        create_job(:queue => "two")
+        create_job(:queue => 'one')
+        create_job(:queue => 'two')
         create_job
         worker.work_off
 
@@ -389,84 +389,78 @@ shared_examples_for "a delayed_job backend" do
     end
   end
 
-  context "max_attempts" do
+  context 'max_attempts' do
     before(:each) do
       @job = described_class.enqueue SimpleJob.new
     end
 
-    it "is not defined" do
+    it 'is not defined' do
       expect(@job.max_attempts).to be_nil
     end
 
-    it "uses the max_retries value on the payload when defined" do
+    it 'uses the max_retries value on the payload when defined' do
       expect(@job.payload_object).to receive(:max_attempts).and_return(99)
       expect(@job.max_attempts).to eq(99)
     end
   end
 
-  describe "yaml serialization" do
-    context "when serializing jobs" do
-      it "raises error ArgumentError for new records" do
+  describe 'yaml serialization' do
+    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')
+          expect { story.delay.tell }.to raise_error(ArgumentError, 'Jobs cannot be created for non-persisted records')
         end
       end
 
-      it "raises error ArgumentError for destroyed records" do
+      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 non-persisted records')
+        expect { story.delay.tell }.to raise_error(ArgumentError, 'Jobs cannot be created for non-persisted records')
       end
     end
 
-    context "when reload jobs back" do
-      it "reloads changed attributes" do
+    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
+      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)
+        expect { job.reload.payload_object }.to raise_error(Delayed::DeserializationError)
       end
     end
   end
 
-  describe "worker integration" do
+  describe 'worker integration' do
     before do
       Delayed::Job.delete_all
       SimpleJob.runs = 0
     end
 
-    describe "running a job" do
-      it "fails after Worker.max_run_time" do
+    describe 'running a job' do
+      it 'fails after Worker.max_run_time' do
         Delayed::Worker.max_run_time = 1.second
         job = Delayed::Job.create :payload_object => LongRunningJob.new
         worker.run(job)
         expect(job.reload.last_error).to match(/expired/)
-        expect(job.reload.last_error).to match(/Delayed::Worker.max_run_time is only 1 second/)
+        expect(job.reload.last_error).to match(/Delayed::Worker\.max_run_time is only 1 second/)
         expect(job.attempts).to eq(1)
       end
 
-      context "when the job raises a deserialization error" do
+      context 'when the job raises a deserialization error' do
         after do
           Delayed::Worker.destroy_failed_jobs = true
         end
 
-        it "marks the job as failed" do
+        it 'marks the job as failed' do
           Delayed::Worker.destroy_failed_jobs = false
-          job = described_class.create! :handler => "--- !ruby/object:JobThatDoesNotExist {}"
+          job = described_class.create! :handler => '--- !ruby/object:JobThatDoesNotExist {}'
           worker.work_off
           job.reload
           expect(job).to be_failed
@@ -474,7 +468,7 @@ shared_examples_for "a delayed_job backend" do
       end
     end
 
-    describe "failed jobs" do
+    describe 'failed jobs' do
       before do
         @job = Delayed::Job.enqueue(ErrorJob.new, :run_at => described_class.db_time_now - 1)
       end
@@ -484,7 +478,7 @@ shared_examples_for "a delayed_job backend" do
         Delayed::Worker.destroy_failed_jobs = true
       end
 
-      it "records last_error when destroy_failed_jobs = false, max_attempts = 1" do
+      it 'records 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)
@@ -494,7 +488,7 @@ shared_examples_for "a delayed_job backend" do
         expect(@job).to be_failed
       end
 
-      it "re-schedules jobs after failing" do
+      it 're-schedules jobs after failing' do
         worker.work_off
         @job.reload
         expect(@job.last_error).to match(/did not work/)
@@ -506,7 +500,7 @@ shared_examples_for "a delayed_job backend" do
         expect(@job.locked_at).to be_nil
       end
 
-      it "re-schedules jobs with handler provided time if present" do
+      it 're-schedules jobs with handler provided time if present' do
         job = Delayed::Job.enqueue(CustomRescheduleJob.new(99.minutes))
         worker.run(job)
         job.reload
@@ -518,26 +512,33 @@ shared_examples_for "a delayed_job backend" do
         error_with_nil_message = StandardError.new
         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
+        expect { worker.run(@job) }.not_to raise_error
       end
     end
 
-    context "reschedule" do
+    context 'reschedule' do
       before do
         @job = Delayed::Job.create :payload_object => SimpleJob.new
       end
 
-      shared_examples_for "any failure more than Worker.max_attempts times" do
+      shared_examples_for 'any failure more than Worker.max_attempts times' 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)
           end
 
-          it "runs that hook" do
+          it 'runs that hook' do
             expect(@job.payload_object).to receive(:failure)
             worker.reschedule(@job)
           end
+
+          it 'handles error in hook' do
+            Delayed::Worker.destroy_failed_jobs = false
+            @job.payload_object.raise_error = true
+            expect { worker.reschedule(@job) }.not_to raise_error
+            expect(@job.failed_at).to_not be_nil
+          end
         end
 
         context "when the job's payload has no #failure hook" do
@@ -555,23 +556,23 @@ shared_examples_for "a delayed_job backend" do
             expect(@job.payload_object).not_to respond_to(:failure)
           end
 
-          it "does not try to run that hook" do
-            expect {
+          it 'does not try to run that hook' do
+            expect do
               Delayed::Worker.max_attempts.times { worker.reschedule(@job) }
-            }.not_to raise_exception
+            end.not_to raise_exception
           end
         end
       end
 
-      context "and we want to destroy jobs" do
-        it_should_behave_like "any failure more than Worker.max_attempts times"
+      context 'and we want to destroy jobs' do
+        it_behaves_like 'any failure more than Worker.max_attempts times'
 
-        it "is destroyed if it failed more than Worker.max_attempts times" do
+        it 'is destroyed if it failed more than Worker.max_attempts times' do
           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
+        it 'is not destroyed if failed fewer than Worker.max_attempts times' do
           expect(@job).not_to receive(:destroy)
           (Delayed::Worker.max_attempts - 1).times { worker.reschedule(@job) }
         end
@@ -586,15 +587,15 @@ shared_examples_for "a delayed_job backend" do
           Delayed::Worker.destroy_failed_jobs = true
         end
 
-        it_should_behave_like "any failure more than Worker.max_attempts times"
+        it_behaves_like 'any failure more than Worker.max_attempts times'
 
-        it "is failed if it failed more than Worker.max_attempts times" do
+        it 'is failed if it failed more than Worker.max_attempts times' do
           expect(@job.reload).not_to be_failed
           Delayed::Worker.max_attempts.times { worker.reschedule(@job) }
           expect(@job.reload).to be_failed
         end
 
-        it "is not failed if it failed fewer than Worker.max_attempts times" do
+        it 'is not failed if it failed fewer than Worker.max_attempts times' do
           (Delayed::Worker.max_attempts - 1).times { worker.reschedule(@job) }
           expect(@job.reload).not_to be_failed
         end