activejob 5.2.0 → 6.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3b37142bf858d333078045c61fce484cb2c897bf5703ba3e436554ad5c121b28
-  data.tar.gz: 80da58bdf3fe33c69449673111513ab5cfd60fb3808992e49377a6b5edad524e
+  metadata.gz: 7973ed6448fa8c345584aa106b5cbb2e7d4f0ec00dd9951ac9f620592e825dc9
+  data.tar.gz: '020897732f85bb7e354ebedda165f052444dcf22f14cc111e2e5f20bca70ce95'
 SHA512:
-  metadata.gz: '099ea73c1d6becd7452954296e14caf364e7377f64a4a1797f20f2e5fb74fdd0afccb2875df531a89fee57ee614477cb5ff6d68841c258e37b12cc2c27f30635'
-  data.tar.gz: 01545f591d0f2c112f3708430c0aa32f959db1e08278b196c17a085544ca76f2adec7e692d59fc9dca148e060e278422a91713e07be84b8d0eae23d5eb6d54a1
+  metadata.gz: 3c35419aea4a165a892334a40912031468bc691effd8c88740f63a2c99cf83fdebc2a76c118c7b9a93f83ac9159ef81fca748fd42155690d058c3c76c7ac5e3b
+  data.tar.gz: 602ed0cd77b1e68a17314c134314f4fdb26fbc7fea831bfc581ec5b7da4b4ed87f4ed1142c7a43e6781b059e8df6fa5c2efb6854bb69db20aa2bbebc179615af

data/CHANGELOG.md

@@ -1,23 +1,154 @@
-## Rails 5.2.0 (April 09, 2018) ##
+## Rails 6.0.0 (August 16, 2019) ##
 
-*   Allow block to be passed to `ActiveJob::Base.discard_on` to allow custom handling of discard jobs.
+*   `assert_enqueued_with` and `assert_performed_with` can now test jobs with relative delay.
+
+    *Vlado Cingel*
+
+
+## Rails 6.0.0.rc2 (July 22, 2019) ##
+
+*   No changes.
+
+
+## Rails 6.0.0.rc1 (April 24, 2019) ##
+
+*   Use individual execution counters when calculating retry delay.
+
+    *Patrik Bóna*
+
+*   Make job argument assertions with `Time`, `ActiveSupport::TimeWithZone`, and `DateTime` work by dropping microseconds. Microsecond precision is lost during serialization.
+
+    *Gannon McGibbon*
+
+
+## Rails 6.0.0.beta3 (March 11, 2019) ##
+
+*   No changes.
+
+
+## Rails 6.0.0.beta2 (February 25, 2019) ##
+
+*   No changes.
+
+
+## Rails 6.0.0.beta1 (January 18, 2019) ##
+
+*   Return false instead of the job instance when `enqueue` is aborted.
+
+    This will be the behavior in Rails 6.1 but it can be controlled now with
+    `config.active_job.return_false_on_aborted_enqueue`.
+
+    *Kir Shatrov*
+
+*   Keep executions for each specific declaration
+
+    Each `retry_on` declaration has now its own specific executions counter. Before it was
+    shared between all executions of a job.
+
+    *Alberto Almagro*
+
+*   Allow all assertion helpers that have a `only` and `except` keyword to accept
+    Procs.
+
+    *Edouard Chin*
+
+*   Restore `HashWithIndifferentAccess` support to `ActiveJob::Arguments.deserialize`.
+
+    *Gannon McGibbon*
+
+*   Include deserialized arguments in job instances returned from
+    `assert_enqueued_with` and `assert_performed_with`
+
+    *Alan Wu*
+
+*   Allow `assert_enqueued_with`/`assert_performed_with` methods to accept
+    a proc for the `args` argument. This is useful to check if only a subset of arguments
+    matches your expectations.
+
+    *Edouard Chin*
+
+*   `ActionDispatch::IntegrationTest` includes `ActiveJob::TestHelper` module by default.
+
+    *Ricardo Díaz*
+
+*   Added `enqueue_retry.active_job`, `retry_stopped.active_job`, and `discard.active_job` hooks.
+
+    *steves*
+
+*   Allow `assert_performed_with` to be called without a block.
+
+    *bogdanvlviv*
+
+*   Execution of `assert_performed_jobs`, and `assert_no_performed_jobs`
+    without a block should respect passed `:except`, `:only`, and `:queue` options.
+
+    *bogdanvlviv*
+
+*   Allow `:queue` option to job assertions and helpers.
+
+    *bogdanvlviv*
+
+*   Allow `perform_enqueued_jobs` to be called without a block.
+
+    Performs all of the jobs that have been enqueued up to this point in the test.
+
+    *Kevin Deisz*
+
+*   Move `enqueue`/`enqueue_at` notifications to an around callback.
+
+    Improves timing accuracy over the old after callback by including
+    time spent writing to the adapter's IO implementation.
+
+    *Zach Kemp*
+
+*   Allow call `assert_enqueued_with` with no block.
 
     Example:
+    ```
+    def test_assert_enqueued_with
+      MyJob.perform_later(1,2,3)
+      assert_enqueued_with(job: MyJob, args: [1,2,3], queue: 'low')
+
+      MyJob.set(wait_until: Date.tomorrow.noon).perform_later
+      assert_enqueued_with(job: MyJob, at: Date.tomorrow.noon)
+    end
+    ```
+
+    *bogdanvlviv*
+
+*   Allow passing multiple exceptions to `retry_on`, and `discard_on`.
+
+    *George Claghorn*
+
+*   Pass the error instance as the second parameter of block executed by `discard_on`.
+
+    Fixes #32853.
+
+    *Yuji Yaginuma*
+
+*   Remove support for Qu gem.
+
+    Reasons are that the Qu gem wasn't compatible since Rails 5.1,
+    gem development was stopped in 2014 and maintainers have
+    confirmed its demise. See issue #32273
+
+    *Alberto Almagro*
+
+*   Add support for timezones to Active Job.
+
+    Record what was the current timezone in effect when the job was
+    enqueued and then restore when the job is executed in same way
+    that the current locale is recorded and restored.
+
+    *Andrew White*
 
-        class RemoteServiceJob < ActiveJob::Base
-          discard_on(CustomAppException) do |job, exception|
-            ExceptionNotifier.caught(exception)
-          end
+*   Rails 6 requires Ruby 2.5.0 or newer.
 
-          def perform(*args)
-            # Might raise CustomAppException for something domain specific
-          end
-        end
+    *Jeremy Daer*, *Kasper Timm Hansen*
 
-    *Aidan Haran*
+*   Add support to define custom argument serializers.
 
-*   Support redis-rb 4.0.
+    *Evgenii Pecherkin*, *Rafael Mendonça França*
 
-    *Jeremy Daer*
 
-Please check [5-1-stable](https://github.com/rails/rails/blob/5-1-stable/activejob/CHANGELOG.md) for previous changes.
+Please check [5-2-stable](https://github.com/rails/rails/blob/5-2-stable/activejob/CHANGELOG.md) for previous changes.

data/MIT-LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2014-2018 David Heinemeier Hansson
+Copyright (c) 2014-2019 David Heinemeier Hansson
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/README.md

@@ -1,7 +1,7 @@
-# Active Job -- Make work happen later
+# Active Job – Make work happen later
 
 Active Job is a framework for declaring jobs and making them run on a variety
-of queueing backends. These jobs can be everything from regularly scheduled
+of queuing backends. These jobs can be everything from regularly scheduled
 clean-ups, to billing charges, to mailings. Anything that can be chopped up into
 small units of work and run in parallel, really.
 
@@ -17,12 +17,13 @@ about API differences between Delayed Job and Resque. Picking your queuing
 backend becomes more of an operational concern, then. And you'll be able to
 switch between them without having to rewrite your jobs.
 
+You can read more about Active Job in the [Active Job Basics](https://edgeguides.rubyonrails.org/active_job_basics.html) guide.
 
 ## Usage
 
-To learn how to use your preferred queueing backend see its adapter
+To learn how to use your preferred queuing backend see its adapter
 documentation at
-[ActiveJob::QueueAdapters](http://api.rubyonrails.org/classes/ActiveJob/QueueAdapters.html).
+[ActiveJob::QueueAdapters](https://api.rubyonrails.org/classes/ActiveJob/QueueAdapters.html).
 
 Declare a job like so:
 
@@ -39,7 +40,7 @@ end
 Enqueue a job like so:
 
 ```ruby
-MyJob.perform_later record  # Enqueue a job to be performed as soon as the queueing system is free.
+MyJob.perform_later record  # Enqueue a job to be performed as soon as the queuing system is free.
 ```
 
 ```ruby
@@ -82,11 +83,17 @@ This works with any class that mixes in GlobalID::Identification, which
 by default has been mixed into Active Record classes.
 
 
-## Supported queueing systems
+## Supported queuing systems
 
-Active Job has built-in adapters for multiple queueing backends (Sidekiq,
+Active Job has built-in adapters for multiple queuing backends (Sidekiq,
 Resque, Delayed Job and others). To get an up-to-date list of the adapters
-see the API Documentation for [ActiveJob::QueueAdapters](http://api.rubyonrails.org/classes/ActiveJob/QueueAdapters.html).
+see the API Documentation for [ActiveJob::QueueAdapters](https://api.rubyonrails.org/classes/ActiveJob/QueueAdapters.html).
+
+**Please note:** We are not accepting pull requests for new adapters. We
+encourage library authors to provide an ActiveJob adapter as part of
+their gem, or as a stand-alone gem. For discussion about this see the
+following PRs: [23311](https://github.com/rails/rails/issues/23311#issuecomment-176275718),
+[21406](https://github.com/rails/rails/pull/21406#issuecomment-138813484), and [#32285](https://github.com/rails/rails/pull/32285).
 
 ## Auxiliary gems
 
@@ -102,7 +109,7 @@ The latest version of Active Job can be installed with RubyGems:
 
 Source code can be downloaded as part of the Rails project on GitHub:
 
-* https://github.com/rails/rails/tree/5-2-stable/activejob
+* https://github.com/rails/rails/tree/master/activejob
 
 ## License
 
@@ -115,7 +122,7 @@ Active Job is released under the MIT license:
 
 API documentation is at:
 
-* http://api.rubyonrails.org
+* https://api.rubyonrails.org
 
 Bug reports for the Ruby on Rails project can be filed here:
 

data/lib/active_job/arguments.rb

@@ -14,29 +14,30 @@ module ActiveJob
   end
 
   # Raised when an unsupported argument type is set as a job argument. We
-  # currently support NilClass, Integer, Fixnum, Float, String, TrueClass, FalseClass,
-  # Bignum, BigDecimal, and objects that can be represented as GlobalIDs (ex: Active Record).
+  # currently support String, Integer, Float, NilClass, TrueClass, FalseClass,
+  # BigDecimal, Symbol, Date, Time, DateTime, ActiveSupport::TimeWithZone,
+  # ActiveSupport::Duration, Hash, ActiveSupport::HashWithIndifferentAccess,
+  # Array or GlobalID::Identification instances, although this can be extended
+  # by adding custom serializers.
   # Raised if you set the key for a Hash something else than a string or
   # a symbol. Also raised when trying to serialize an object which can't be
-  # identified with a Global ID - such as an unpersisted Active Record model.
+  # identified with a GlobalID - such as an unpersisted Active Record model.
   class SerializationError < ArgumentError; end
 
   module Arguments
     extend self
-    # :nodoc:
-    TYPE_WHITELIST = [ NilClass, String, Integer, Float, BigDecimal, TrueClass, FalseClass ]
-    TYPE_WHITELIST.push(Fixnum, Bignum) unless 1.class == Integer
-
-    # Serializes a set of arguments. Whitelisted types are returned
-    # as-is. Arrays/Hashes are serialized element by element.
-    # All other types are serialized using GlobalID.
+    # Serializes a set of arguments. Intrinsic types that can safely be
+    # serialized without mutation are returned as-is. Arrays/Hashes are
+    # serialized element by element. All other types are serialized using
+    # GlobalID.
     def serialize(arguments)
       arguments.map { |argument| serialize_argument(argument) }
     end
 
-    # Deserializes a set of arguments. Whitelisted types are returned
-    # as-is. Arrays/Hashes are deserialized element by element.
-    # All other types are deserialized using GlobalID.
+    # Deserializes a set of arguments. Intrinsic types that can safely be
+    # deserialized without mutation are returned as-is. Arrays/Hashes are
+    # deserialized element by element. All other types are deserialized using
+    # GlobalID.
     def deserialize(arguments)
       arguments.map { |argument| deserialize_argument(argument) }
     rescue
@@ -44,47 +45,62 @@ module ActiveJob
     end
 
     private
+
+      # :nodoc:
+      PERMITTED_TYPES = [ NilClass, String, Integer, Float, BigDecimal, TrueClass, FalseClass ]
+      # :nodoc:
+      GLOBALID_KEY = "_aj_globalid"
       # :nodoc:
-      GLOBALID_KEY = "_aj_globalid".freeze
+      SYMBOL_KEYS_KEY = "_aj_symbol_keys"
       # :nodoc:
-      SYMBOL_KEYS_KEY = "_aj_symbol_keys".freeze
+      WITH_INDIFFERENT_ACCESS_KEY = "_aj_hash_with_indifferent_access"
       # :nodoc:
-      WITH_INDIFFERENT_ACCESS_KEY = "_aj_hash_with_indifferent_access".freeze
-      private_constant :GLOBALID_KEY, :SYMBOL_KEYS_KEY, :WITH_INDIFFERENT_ACCESS_KEY
+      OBJECT_SERIALIZER_KEY = "_aj_serialized"
+
+      # :nodoc:
+      RESERVED_KEYS = [
+        GLOBALID_KEY, GLOBALID_KEY.to_sym,
+        SYMBOL_KEYS_KEY, SYMBOL_KEYS_KEY.to_sym,
+        OBJECT_SERIALIZER_KEY, OBJECT_SERIALIZER_KEY.to_sym,
+        WITH_INDIFFERENT_ACCESS_KEY, WITH_INDIFFERENT_ACCESS_KEY.to_sym,
+      ]
+      private_constant :PERMITTED_TYPES, :RESERVED_KEYS, :GLOBALID_KEY, :SYMBOL_KEYS_KEY, :WITH_INDIFFERENT_ACCESS_KEY
 
       def serialize_argument(argument)
         case argument
-        when *TYPE_WHITELIST
+        when *PERMITTED_TYPES
           argument
         when GlobalID::Identification
           convert_to_global_id_hash(argument)
         when Array
           argument.map { |arg| serialize_argument(arg) }
         when ActiveSupport::HashWithIndifferentAccess
-          result = serialize_hash(argument)
-          result[WITH_INDIFFERENT_ACCESS_KEY] = serialize_argument(true)
-          result
+          serialize_indifferent_hash(argument)
         when Hash
           symbol_keys = argument.each_key.grep(Symbol).map(&:to_s)
           result = serialize_hash(argument)
           result[SYMBOL_KEYS_KEY] = symbol_keys
           result
+        when -> (arg) { arg.respond_to?(:permitted?) }
+          serialize_indifferent_hash(argument.to_h)
         else
-          raise SerializationError.new("Unsupported argument type: #{argument.class.name}")
+          Serializers.serialize(argument)
         end
       end
 
       def deserialize_argument(argument)
         case argument
         when String
-          GlobalID::Locator.locate(argument) || argument
-        when *TYPE_WHITELIST
+          argument
+        when *PERMITTED_TYPES
           argument
         when Array
           argument.map { |arg| deserialize_argument(arg) }
         when Hash
           if serialized_global_id?(argument)
             deserialize_global_id argument
+          elsif custom_serialized?(argument)
+            Serializers.deserialize(argument)
           else
             deserialize_hash(argument)
           end
@@ -101,6 +117,10 @@ module ActiveJob
         GlobalID::Locator.locate hash[GLOBALID_KEY]
       end
 
+      def custom_serialized?(hash)
+        hash.key?(OBJECT_SERIALIZER_KEY)
+      end
+
       def serialize_hash(argument)
         argument.each_with_object({}) do |(key, value), hash|
           hash[serialize_hash_key(key)] = serialize_argument(value)
@@ -117,14 +137,6 @@ module ActiveJob
         result
       end
 
-      # :nodoc:
-      RESERVED_KEYS = [
-        GLOBALID_KEY, GLOBALID_KEY.to_sym,
-        SYMBOL_KEYS_KEY, SYMBOL_KEYS_KEY.to_sym,
-        WITH_INDIFFERENT_ACCESS_KEY, WITH_INDIFFERENT_ACCESS_KEY.to_sym,
-      ]
-      private_constant :RESERVED_KEYS
-
       def serialize_hash_key(key)
         case key
         when *RESERVED_KEYS
@@ -136,8 +148,17 @@ module ActiveJob
         end
       end
 
+      def serialize_indifferent_hash(indifferent_hash)
+        result = serialize_hash(indifferent_hash)
+        result[WITH_INDIFFERENT_ACCESS_KEY] = serialize_argument(true)
+        result
+      end
+
       def transform_symbol_keys(hash, symbol_keys)
-        hash.transform_keys do |key|
+        # NOTE: HashWithIndifferentAccess#transform_keys always
+        # returns stringified keys with indifferent access
+        # so we call #to_h here to ensure keys are symbolized.
+        hash.to_h.transform_keys do |key|
           if symbol_keys.include?(key)
             key.to_sym
           else

data/lib/active_job/base.rb

@@ -9,6 +9,7 @@ require "active_job/execution"
 require "active_job/callbacks"
 require "active_job/exceptions"
 require "active_job/logging"
+require "active_job/timezones"
 require "active_job/translation"
 
 module ActiveJob #:nodoc:
@@ -39,7 +40,7 @@ module ActiveJob #:nodoc:
   # Records that are passed in are serialized/deserialized using Global
   # ID. More information can be found in Arguments.
   #
-  # To enqueue a job to be performed as soon as the queueing system is free:
+  # To enqueue a job to be performed as soon as the queuing system is free:
   #
   #   ProcessPhotoJob.perform_later(photo)
   #
@@ -67,6 +68,7 @@ module ActiveJob #:nodoc:
     include Callbacks
     include Exceptions
     include Logging
+    include Timezones
     include Translation
 
     ActiveSupport.run_load_hooks(:active_job, self)

data/lib/active_job/callbacks.rb

@@ -29,6 +29,9 @@ module ActiveJob
     included do
       define_callbacks :perform
       define_callbacks :enqueue
+
+      class_attribute :return_false_on_aborted_enqueue, instance_accessor: false, instance_predicate: false
+      self.return_false_on_aborted_enqueue = false
     end
 
     # These methods will be included into any Active Job object, adding
@@ -130,7 +133,7 @@ module ActiveJob
         set_callback(:enqueue, :after, *filters, &blk)
       end
 
-      # Defines a callback that will get called around the enqueueing
+      # Defines a callback that will get called around the enqueuing
       # of the job.
       #
       #   class VideoProcessJob < ActiveJob::Base

data/lib/active_job/core.rb

@@ -6,32 +6,42 @@ module ActiveJob
   module Core
     extend ActiveSupport::Concern
 
-    included do
-      # Job arguments
-      attr_accessor :arguments
-      attr_writer :serialized_arguments
+    # Job arguments
+    attr_accessor :arguments
+    attr_writer :serialized_arguments
 
-      # Timestamp when the job should be performed
-      attr_accessor :scheduled_at
+    # Timestamp when the job should be performed
+    attr_accessor :scheduled_at
 
-      # Job Identifier
-      attr_accessor :job_id
+    # Job Identifier
+    attr_accessor :job_id
 
-      # Queue in which the job will reside.
-      attr_writer :queue_name
+    # Queue in which the job will reside.
+    attr_writer :queue_name
 
-      # Priority that the job will have (lower is more priority).
-      attr_writer :priority
+    # Priority that the job will have (lower is more priority).
+    attr_writer :priority
 
-      # ID optionally provided by adapter
-      attr_accessor :provider_job_id
+    # ID optionally provided by adapter
+    attr_accessor :provider_job_id
 
-      # Number of times this job has been executed (which increments on every retry, like after an exception).
-      attr_accessor :executions
+    # Number of times this job has been executed (which increments on every retry, like after an exception).
+    attr_accessor :executions
 
-      # I18n.locale to be used during the job.
-      attr_accessor :locale
-    end
+    # Hash that contains the number of times this job handled errors for each specific retry_on declaration.
+    # Keys are the string representation of the exceptions listed in the retry_on declaration,
+    # while its associated value holds the number of executions where the corresponding retry_on
+    # declaration handled one of its listed exceptions.
+    attr_accessor :exception_executions
+
+    # I18n.locale to be used during the job.
+    attr_accessor :locale
+
+    # Timezone to be used during the job.
+    attr_accessor :timezone
+
+    # Track when a job was enqueued
+    attr_accessor :enqueued_at
 
     # These methods will be included into any Active Job object, adding
     # helpers for de/serialization and creation of job instances.
@@ -74,10 +84,11 @@ module ActiveJob
       @queue_name = self.class.queue_name
       @priority   = self.class.priority
       @executions = 0
+      @exception_executions = {}
     end
 
     # Returns a hash with the job data that can safely be passed to the
-    # queueing adapter.
+    # queuing adapter.
     def serialize
       {
         "job_class"  => self.class.name,
@@ -85,9 +96,12 @@ module ActiveJob
         "provider_job_id" => provider_job_id,
         "queue_name" => queue_name,
         "priority"   => priority,
-        "arguments"  => serialize_arguments(arguments),
+        "arguments"  => serialize_arguments_if_needed(arguments),
         "executions" => executions,
-        "locale"     => I18n.locale.to_s
+        "exception_executions" => exception_executions,
+        "locale"     => I18n.locale.to_s,
+        "timezone"   => Time.zone.try(:name),
+        "enqueued_at" => Time.now.utc.iso8601
       }
     end
 
@@ -124,23 +138,38 @@ module ActiveJob
       self.priority             = job_data["priority"]
       self.serialized_arguments = job_data["arguments"]
       self.executions           = job_data["executions"]
+      self.exception_executions = job_data["exception_executions"]
       self.locale               = job_data["locale"] || I18n.locale.to_s
+      self.timezone             = job_data["timezone"] || Time.zone.try(:name)
+      self.enqueued_at          = job_data["enqueued_at"]
     end
 
     private
+      def serialize_arguments_if_needed(arguments)
+        if arguments_serialized?
+          @serialized_arguments
+        else
+          serialize_arguments(arguments)
+        end
+      end
+
       def deserialize_arguments_if_needed
-        if defined?(@serialized_arguments) && @serialized_arguments.present?
+        if arguments_serialized?
           @arguments = deserialize_arguments(@serialized_arguments)
           @serialized_arguments = nil
         end
       end
 
-      def serialize_arguments(serialized_args)
-        Arguments.serialize(serialized_args)
+      def serialize_arguments(arguments)
+        Arguments.serialize(arguments)
       end
 
       def deserialize_arguments(serialized_args)
         Arguments.deserialize(serialized_args)
       end
+
+      def arguments_serialized?
+        defined?(@serialized_arguments) && @serialized_arguments
+      end
   end
 end

data/lib/active_job/enqueuing.rb

@@ -9,10 +9,12 @@ module ActiveJob
 
     # Includes the +perform_later+ method for job initialization.
     module ClassMethods
-      # Push a job onto the queue. The arguments must be legal JSON types
-      # (+string+, +int+, +float+, +nil+, +true+, +false+, +hash+ or +array+) or
-      # GlobalID::Identification instances. Arbitrary Ruby objects
-      # are not supported.
+      # Push a job onto the queue. By default the arguments must be either String,
+      # Integer, Float, NilClass, TrueClass, FalseClass, BigDecimal, Symbol, Date,
+      # Time, DateTime, ActiveSupport::TimeWithZone, ActiveSupport::Duration,
+      # Hash, ActiveSupport::HashWithIndifferentAccess, Array or
+      # GlobalID::Identification instances, although this can be extended by adding
+      # custom serializers.
       #
       # Returns an instance of the job class queued with arguments available in
       # Job#arguments.
@@ -46,14 +48,33 @@ module ActiveJob
       self.scheduled_at = options[:wait_until].to_f if options[:wait_until]
       self.queue_name   = self.class.queue_name_from_part(options[:queue]) if options[:queue]
       self.priority     = options[:priority].to_i if options[:priority]
+      successfully_enqueued = false
+
       run_callbacks :enqueue do
         if scheduled_at
           self.class.queue_adapter.enqueue_at self, scheduled_at
         else
           self.class.queue_adapter.enqueue self
         end
+
+        successfully_enqueued = true
+      end
+
+      if successfully_enqueued
+        self
+      else
+        if self.class.return_false_on_aborted_enqueue
+          false
+        else
+          ActiveSupport::Deprecation.warn(
+            "Rails 6.1 will return false when the enqueuing is aborted. Make sure your code doesn't depend on it" \
+            " returning the instance of the job and set `config.active_job.return_false_on_aborted_enqueue = true`" \
+            " to remove the deprecations."
+          )
+
+          self
+        end
       end
-      self
     end
   end
 end