delayed_job 4.0.6 → 4.1.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 437dd17835ae0e764f1fbd9ce13c55be2b7ddead
-  data.tar.gz: abb136834dd2e39edb5a6cf5c846613734c3b518
+SHA256:
+  metadata.gz: 3671145ff491daea2d3e26336b54cdae0d4e0293654c11fdcb3a41a516741219
+  data.tar.gz: 1dab4a137c0cec054cd7c73fc395d5a918f5fc7cc619ae3879687ae17b36a439
 SHA512:
-  metadata.gz: b89e00ad9d939277b9f2da9e94a1b45310c9b7ea3b7e3f7535f434eb8b9ad46a6589ef541e76501e5c2da07cb982fb337453d6c5b642b2e20274daa1c0321452
-  data.tar.gz: 3cb7e586ac2a1a7ea5967d5e35bf3cd325943bf37e28e913e77a787363c0efa46ab891c07c5f157b88a19f8bfda5444839b9b8071e9bc1feb8bcb715773089f9
+  metadata.gz: 707798d3698ef7e67896381a43b75f03f0b63653c79c514b3e932b53b6883ded11476fe8b5749e44b5722562d7f479fdb6b70f46c9c279fe08fe9eaafb0110a6
+  data.tar.gz: 917341ca90f82622329579ae796378b241822903f5570488e2a6f9dc785028f7e14567c395d5258b409ba8b2c30ee062c0cfeaf985e094b185416296d0e3a18b

data/CHANGELOG.md

@@ -1,3 +1,57 @@
+4.1.8 - 2019-08-16
+=================
+* Support for Rails 6.0.0
+
+4.1.7 - 2019-06-20
+=================
+* Fix loading Delayed::PerformableMailer when ActionMailer isn't loaded yet
+
+4.1.6 - 2019-06-19
+=================
+* Properly initialize ActionMailer outside railties (#1077)
+* Fix Psych load_tags support (#1093)
+* Replace REMOVED with FAILED in log message (#1048)
+* Misc doc updates (#1052, #1074, #1064, #1063)
+
+4.1.5 - 2018-04-13
+=================
+* Allow Rails 5.2
+
+4.1.4 - 2017-12-29
+=================
+* Use `yaml_tag` instead of deprecated `yaml_as` (#996)
+* Support ruby 2.5.0
+
+4.1.3 - 2017-05-26
+=================
+* Don't mutate the options hash (#877)
+* Log an error message when a deserialization error occurs (#894)
+* Adding the queue name to the log output (#917)
+* Don't include ClassMethods with MessageSending (#924)
+* Fix YAML deserialization error if original object is soft-deleted (#947)
+* Add support for Rails 5.1 (#982)
+
+4.1.2 - 2016-05-16
+==================
+* Added Delayed::Worker.queue_attributes
+* Limit what we require in ActiveSupport
+* Fix pid file creation when there is no tmp directory
+* Rails 5 support
+
+4.1.1 - 2015-09-24
+==================
+* Fix shared specs for back-ends that reload objects
+
+4.1.0 - 2015-09-22
+==================
+* Alter `Delayed::Command` to work with or without Rails
+* Allow `Delayed::Worker.delay_jobs` configuration to be a proc
+* Add ability to set destroy failed jobs on a per job basis
+* Make `Delayed::Worker.new` idempotent
+* Set quiet from the environment
+* Rescue `Exception` instead of `StandardError` in worker
+* Fix worker crash on serialization error
+
 4.0.6 - 2014-12-22
 ==================
 * Revert removing test files from the gem

data/README.md

@@ -1,14 +1,17 @@
+**If you're viewing this at https://github.com/collectiveidea/delayed_job,
+you're reading the documentation for the master branch.
+[View documentation for the latest release
+(4.1.8).](https://github.com/collectiveidea/delayed_job/tree/v4.1.8)**
+
 Delayed::Job
 ============
-[![Gem Version](https://badge.fury.io/rb/delayed_job.png)][gem]
-[![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 Version](https://badge.fury.io/rb/delayed_job.svg)][gem]
+[![Build Status](https://travis-ci.org/collectiveidea/delayed_job.svg?branch=master)][travis]
+[![Code Climate](https://codeclimate.com/github/collectiveidea/delayed_job.svg)][codeclimate]
+[![Coverage Status](https://coveralls.io/repos/collectiveidea/delayed_job/badge.svg?branch=master)][coveralls]
 
 [gem]: https://rubygems.org/gems/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
 
@@ -32,8 +35,7 @@ multitude of core tasks. Amongst those tasks are:
 
 Installation
 ============
-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 3.0.0 only supports Rails 3.0+.
 
 delayed_job supports multiple backends for storing the job queue. [See the wiki
 for other backends](https://github.com/collectiveidea/delayed_job/wiki/Backends).
@@ -58,14 +60,30 @@ running the following command:
     rails generate delayed_job:active_record
     rake db:migrate
 
+For Rails 4.2+, see [below](#active-job)
+
 Development
 ===========
 In development mode, if you are using Rails 3.1+, your application code will automatically reload every 100 jobs or when the queue finishes.
 You no longer need to restart Delayed Job every time you update your code in development.
 
-Rails 4
-=======
-If you are using the protected_attributes gem, it must appear before delayed_job in your gemfile.
+Active Job
+==========
+In Rails 4.2+, set the queue_adapter in config/application.rb
+
+```ruby
+config.active_job.queue_adapter = :delayed_job
+```
+
+See the [rails guide](http://guides.rubyonrails.org/active_job_basics.html#setting-the-backend) for more details.
+
+Rails 4.x
+=========
+If you are using the protected_attributes gem, it must appear before delayed_job in your gemfile. If your jobs are failing with:
+
+     ActiveRecord::StatementInvalid: PG::NotNullViolation: ERROR:  null value in column "handler" violates not-null constraint
+
+then this is the fix you're looking for.
 
 Upgrading from 2.x to 3.0.0 on Active Record
 ============================================
@@ -103,9 +121,17 @@ device = Device.new
 device.deliver
 ```
 
-handle_asynchronously can take as options anything you can pass to delay. In
-addition, the values can be Proc objects allowing call time evaluation of the
-value. For some examples:
+## Parameters
+
+`#handle_asynchronously` and `#delay` take these parameters:
+
+- `:priority` (number): lower numbers run first; default is 0 but can be reconfigured (see below)
+- `:run_at` (Time): run the job after this time (probably in the future)
+- `:queue` (string): named queue to put this job in, an alternative to priorities (see below)
+
+These params can be Proc objects, allowing call-time evaluation of the value.
+
+For example:
 
 ```ruby
 class LongTasks
@@ -176,6 +202,27 @@ Delayed::Job.enqueue job, :queue => 'tracking'
 handle_asynchronously :tweet_later, :queue => 'tweets'
 ```
 
+You can configure default priorities for named queues:
+
+```ruby
+Delayed::Worker.queue_attributes = {
+  high_priority: { priority: -10 },
+  low_priority: { priority: 10 }
+}
+```
+
+Configured queue priorities can be overriden by passing priority to the delay method
+
+```ruby
+object.delay(:queue => 'high_priority', priority: 0).method
+```
+
+You can start processes to only work certain queues with the `queue` and `queues`
+options defined below. Processes started without specifying a queue will run jobs
+from **any** queue. To effectively have a process that runs jobs where a queue is not
+specified, set a default queue name with `Delayed::Worker.default_queue_name` and
+have the processes run that queue.
+
 Running Jobs
 ============
 `script/delayed_job` can be used to manage a background process which will
@@ -282,6 +329,20 @@ NewsletterJob = Struct.new(:text, :emails) do
 end
 ```
 
+To set a per-job default for destroying failed jobs that overrides the Delayed::Worker.destroy_failed_jobs you can define a destroy_failed_jobs? method on the job
+
+```ruby
+NewsletterJob = Struct.new(:text, :emails) do
+  def perform
+    emails.each { |e| NewsletterMailer.deliver_text_to_email(text, e) }
+  end
+
+  def destroy_failed_jobs?
+    false
+  end
+end
+```
+
 To set a default queue name for a custom job that overrides Delayed::Worker.default_queue_name, you can define a queue_name method on the job
 
 ```ruby
@@ -314,6 +375,9 @@ Hooks
 =====
 You can define hooks on your job that will be called at different stages in the process:
 
+
+**NOTE:** If you are using ActiveJob these hooks are **not** available to your jobs. You will need to use ActiveJob's callbacks. You can find details here https://guides.rubyonrails.org/active_job_basics.html#callbacks
+
 ```ruby
 class ParanoidNewsletterJob < NewsletterJob
   def enqueue(job)
@@ -367,7 +431,7 @@ end
 
 On error, the job is scheduled again in 5 seconds + N ** 4, where N is the number of attempts or using the job's defined `reschedule_at` method.
 
-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 is 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
@@ -382,8 +446,18 @@ The default behavior is to read 5 jobs from the queue when finding an available
 
 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`.
 
+If no jobs are found, the worker sleeps for the amount of time specified by the sleep delay option. Set `Delayed::Worker.sleep_delay = 60` for a 60 second sleep time.
+
 It is possible to disable delayed jobs for testing purposes. Set `Delayed::Worker.delay_jobs = false` to execute all jobs realtime.
 
+Or `Delayed::Worker.delay_jobs` can be a Proc that decides whether to execute jobs inline on a per-job basis:
+
+```ruby
+Delayed::Worker.delay_jobs = ->(job) {
+  job.queue != 'inline'
+}
+```
+
 You may need to raise exceptions on SIGTERM signals, `Delayed::Worker.raise_signal_exceptions = :term` will cause the worker to raise a `SignalException` causing the running job to abort and be unlocked, which makes the job available to other workers. The default for this option is false.
 
 Here is an example of changing job parameters in Rails:

data/delayed_job.gemspec

@@ -1,15 +1,17 @@
+# -*- encoding: utf-8 -*-
+
 Gem::Specification.new do |spec|
-  spec.add_dependency 'activesupport', ['>= 3.0', '< 5.0']
+  spec.add_dependency 'activesupport', ['>= 3.0', '< 6.1']
   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         += Dir.glob('{contrib,lib,recipes,spec}/**/*')
+  spec.files          += Dir.glob('{contrib,lib,recipes,spec}/**/*') # rubocop:disable SpaceAroundOperators
   spec.homepage       = 'http://github.com/collectiveidea/delayed_job'
   spec.licenses       = ['MIT']
   spec.name           = 'delayed_job'
   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.6'
+  spec.version        = '4.1.8'
 end

data/lib/delayed/backend/base.rb

@@ -7,32 +7,16 @@ module Delayed
 
       module ClassMethods
         # Add a job to the queue
-        def enqueue(*args) # rubocop:disable CyclomaticComplexity
-          options = args.extract_options!
-          options[:payload_object] ||= args.shift
-          options[:priority]       ||= Delayed::Worker.default_priority
-
-          if options[:queue].nil?
-            if options[:payload_object].respond_to?(:queue_name)
-              options[:queue] = options[:payload_object].queue_name
-            end
-            options[:queue] ||= Delayed::Worker.default_queue_name
-          end
-
-          if args.size > 0
-            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
-
-          unless options[:payload_object].respond_to?(:perform)
-            raise ArgumentError, 'Cannot enqueue items which do not respond to perform'
-          end
+        def enqueue(*args)
+          job_options = Delayed::Backend::JobPreparer.new(*args).prepare
+          enqueue_job(job_options)
+        end
 
+        def enqueue_job(options)
           new(options).tap do |job|
             Delayed::Worker.lifecycle.run_callbacks(:enqueue, job) do
               job.hook(:enqueue)
-              Delayed::Worker.delay_jobs ? job.save : job.invoke_job
+              Delayed::Worker.delay_job?(job) ? job.save : job.invoke_job
             end
           end
         end
@@ -46,16 +30,13 @@ module Delayed
         end
 
         # Allow the backend to attempt recovery from reserve errors
-        def recover_from(_error)
-        end
+        def recover_from(_error); end
 
         # Hook method that is called before a new worker is forked
-        def before_fork
-        end
+        def before_fork; end
 
         # Hook method that is called after a new worker is forked
-        def after_fork
-        end
+        def after_fork; end
 
         def work_off(num = 100)
           warn '[DEPRECATION] `Delayed::Job.work_off` is deprecated. Use `Delayed::Worker.new.work_off instead.'
@@ -63,12 +44,18 @@ module Delayed
         end
       end
 
+      attr_reader :error
+      def error=(error)
+        @error = error
+        self.last_error = "#{error.message}\n#{error.backtrace.join("\n")}" if respond_to?(:last_error=)
+      end
+
       def failed?
         !!failed_at
       end
       alias_method :failed, :failed?
 
-      ParseObjectFromYaml = /\!ruby\/\w+\:([^\s]+)/ # rubocop:disable ConstantName
+      ParseObjectFromYaml = %r{\!ruby/\w+\:([^\s]+)} # rubocop:disable ConstantName
 
       def name
         @name ||= payload_object.respond_to?(:display_name) ? payload_object.display_name : payload_object.class.name
@@ -93,7 +80,7 @@ module Delayed
             hook :before
             payload_object.perform
             hook :success
-          rescue => e
+          rescue Exception => e # rubocop:disable RescueException
             hook :error, e
             raise e
           ensure
@@ -111,7 +98,7 @@ module Delayed
       def hook(name, *args)
         if payload_object.respond_to?(name)
           method = payload_object.method(name)
-          method.arity == 0 ? method.call : method.call(self, *args)
+          method.arity.zero? ? method.call : method.call(self, *args)
         end
       rescue DeserializationError # rubocop:disable HandleExceptions
       end
@@ -139,8 +126,15 @@ module Delayed
         end
       end
 
+      def destroy_failed_jobs?
+        payload_object.respond_to?(:destroy_failed_jobs?) ? payload_object.destroy_failed_jobs? : Delayed::Worker.destroy_failed_jobs
+      rescue DeserializationError
+        Delayed::Worker.destroy_failed_jobs
+      end
+
       def fail!
-        update_attributes(:failed_at => self.class.db_time_now)
+        self.failed_at = self.class.db_time_now
+        save!
       end
 
     protected

data/lib/delayed/backend/job_preparer.rb

@@ -0,0 +1,53 @@
+module Delayed
+  module Backend
+    class JobPreparer
+      attr_reader :options, :args
+
+      def initialize(*args)
+        @options = args.extract_options!.dup
+        @args = args
+      end
+
+      def prepare
+        set_payload
+        set_queue_name
+        set_priority
+        handle_deprecation
+        options
+      end
+
+    private
+
+      def set_payload
+        options[:payload_object] ||= args.shift
+      end
+
+      def set_queue_name
+        if options[:queue].nil? && options[:payload_object].respond_to?(:queue_name)
+          options[:queue] = options[:payload_object].queue_name
+        else
+          options[:queue] ||= Delayed::Worker.default_queue_name
+        end
+      end
+
+      def set_priority
+        queue_attribute = Delayed::Worker.queue_attributes[options[:queue]]
+        options[:priority] ||= (queue_attribute && queue_attribute[:priority]) || Delayed::Worker.default_priority
+      end
+
+      def handle_deprecation
+        if args.size > 0
+          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
+
+        # rubocop:disable GuardClause
+        unless options[:payload_object].respond_to?(:perform)
+          raise ArgumentError, 'Cannot enqueue items which do not respond to perform'
+        end
+        # rubocop:enabled GuardClause
+      end
+    end
+  end
+end

data/lib/delayed/backend/shared_spec.rb

@@ -1,6 +1,6 @@
 require File.expand_path('../../../../spec/sample_jobs', __FILE__)
 
-require 'active_support/core_ext'
+require 'active_support/core_ext/numeric/time'
 
 shared_examples_for 'a delayed_job backend' do
   let(:worker) { Delayed::Worker.new }
@@ -113,6 +113,12 @@ shared_examples_for 'a delayed_job backend' do
         job = described_class.enqueue M::ModuleJob.new
         expect { job.invoke_job }.to change { M::ModuleJob.runs }.from(0).to(1)
       end
+
+      it 'does not mutate the options hash' do
+        options = {:priority => 1}
+        described_class.enqueue SimpleJob.new, options
+        expect(options).to eq(:priority => 1)
+      end
     end
 
     context 'with delay_jobs = false' do
@@ -161,7 +167,7 @@ shared_examples_for 'a delayed_job backend' do
       job = described_class.enqueue(CallbackJob.new)
       expect(job.payload_object).to receive(:perform).and_raise(RuntimeError.new('fail'))
 
-      expect { job.invoke_job }.to raise_error
+      expect { job.invoke_job }.to raise_error(RuntimeError)
       expect(CallbackJob.messages).to eq(['enqueue', 'before', 'error: RuntimeError', 'after'])
     end
 
@@ -279,6 +285,7 @@ shared_examples_for 'a delayed_job backend' do
     after do
       Delayed::Worker.max_priority = nil
       Delayed::Worker.min_priority = nil
+      Delayed::Worker.queue_attributes = {}
     end
 
     it 'fetches jobs ordered by priority' do
@@ -314,6 +321,18 @@ shared_examples_for 'a delayed_job backend' do
       end
       expect(described_class.reserve(worker)).to be_nil
     end
+
+    it 'sets job priority based on queue_attributes configuration' do
+      Delayed::Worker.queue_attributes = {'job_tracking' => {:priority => 4}}
+      job = described_class.enqueue :payload_object => NamedQueueJob.new
+      expect(job.priority).to eq(4)
+    end
+
+    it 'sets job priority based on the passed in priority overrideing queue_attributes configuration' do
+      Delayed::Worker.queue_attributes = {'job_tracking' => {:priority => 4}}
+      job = described_class.enqueue :payload_object => NamedQueueJob.new, :priority => 10
+      expect(job.priority).to eq(10)
+    end
   end
 
   context 'clear_locks!' do
@@ -450,6 +469,34 @@ shared_examples_for 'a delayed_job backend' do
     end
   end
 
+  describe 'destroy_failed_jobs' do
+    context 'with a SimpleJob' do
+      before(:each) do
+        @job = described_class.enqueue SimpleJob.new
+      end
+
+      it 'is not defined' do
+        expect(@job.destroy_failed_jobs?).to be true
+      end
+
+      it 'uses the destroy failed jobs value on the payload when defined' do
+        expect(@job.payload_object).to receive(:destroy_failed_jobs?).and_return(false)
+        expect(@job.destroy_failed_jobs?).to be false
+      end
+    end
+
+    context 'with a job that raises DserializationError' do
+      before(:each) do
+        @job = described_class.new :handler => '--- !ruby/struct:GoingToRaiseArgError {}'
+      end
+
+      it 'falls back reasonably' do
+        expect(YAML).to receive(:load_dj).and_raise(ArgumentError)
+        expect(@job.destroy_failed_jobs?).to be true
+      end
+    end
+  end
+
   describe 'yaml serialization' do
     context 'when serializing jobs' do
       it 'raises error ArgumentError for new records' do
@@ -476,7 +523,8 @@ shared_examples_for 'a delayed_job backend' do
       it 'reloads changed attributes' do
         story = Story.create(:text => 'hello')
         job = story.delay.tell
-        story.update_attributes :text => 'goodbye'
+        story.text = 'goodbye'
+        story.save!
         expect(job.reload.payload_object.object.text).to eq('goodbye')
       end
 
@@ -500,6 +548,7 @@ shared_examples_for 'a delayed_job backend' do
         Delayed::Worker.max_run_time = 1.second
         job = Delayed::Job.create :payload_object => LongRunningJob.new
         worker.run(job)
+        expect(job.error).to_not be_nil
         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.attempts).to eq(1)
@@ -513,6 +562,7 @@ shared_examples_for 'a delayed_job backend' do
         it 'marks the job as failed' do
           Delayed::Worker.destroy_failed_jobs = false
           job = described_class.create! :handler => '--- !ruby/object:JobThatDoesNotExist {}'
+          expect_any_instance_of(described_class).to receive(:destroy_failed_jobs?).and_return(false)
           worker.work_off
           job.reload
           expect(job).to be_failed
@@ -535,6 +585,7 @@ shared_examples_for 'a delayed_job backend' do
         Delayed::Worker.max_attempts = 1
         worker.run(@job)
         @job.reload
+        expect(@job.error).to_not be_nil
         expect(@job.last_error).to match(/did not work/)
         expect(@job.attempts).to eq(1)
         expect(@job).to be_failed
@@ -617,6 +668,10 @@ shared_examples_for 'a delayed_job backend' do
       end
 
       context 'and we want to destroy jobs' do
+        after do
+          Delayed::Worker.destroy_failed_jobs = true
+        end
+
         it_behaves_like 'any failure more than Worker.max_attempts times'
 
         it 'is destroyed if it failed more than Worker.max_attempts times' do
@@ -624,6 +679,13 @@ shared_examples_for 'a delayed_job backend' do
           Delayed::Worker.max_attempts.times { worker.reschedule(@job) }
         end
 
+        it 'is destroyed if the job has destroy failed jobs set' do
+          Delayed::Worker.destroy_failed_jobs = false
+          expect(@job).to receive(:destroy_failed_jobs?).and_return(true)
+          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
           expect(@job).not_to receive(:destroy)
           (Delayed::Worker.max_attempts - 1).times { worker.reschedule(@job) }
@@ -641,15 +703,35 @@ shared_examples_for 'a delayed_job backend' do
 
         it_behaves_like 'any failure more than Worker.max_attempts times'
 
-        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
+        context 'and destroy failed jobs is false' 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
+            (Delayed::Worker.max_attempts - 1).times { worker.reschedule(@job) }
+            expect(@job.reload).not_to be_failed
+          end
         end
 
-        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
+        context 'and destroy failed jobs for job is false' do
+          before do
+            Delayed::Worker.destroy_failed_jobs = true
+          end
+
+          it 'is failed if it failed more than Worker.max_attempts times' do
+            expect(@job).to receive(:destroy_failed_jobs?).and_return(false)
+            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
+            (Delayed::Worker.max_attempts - 1).times { worker.reschedule(@job) }
+            expect(@job.reload).not_to be_failed
+          end
         end
       end
     end