activejob 6.0.3.2 → 6.1.0

data/lib/active_job/queue_adapter.rb

@@ -11,6 +11,9 @@ module ActiveJob
     included do
       class_attribute :_queue_adapter_name, instance_accessor: false, instance_predicate: false
       class_attribute :_queue_adapter, instance_accessor: false, instance_predicate: false
+
+      delegate :queue_adapter, to: :class
+
       self.queue_adapter = :async
     end
 

data/lib/active_job/queue_adapters.rb

@@ -72,7 +72,7 @@ module ActiveJob
   # Yes: Allows the priority to be set on the job object, at the queue level or
   # as default configuration option.
   #
-  # No: Does not allow the priority of jobs to be configured.
+  # No: The adapter does not allow the priority of jobs to be configured.
   #
   # N/A: The adapter does not support queuing, and therefore sorting them.
   #
@@ -86,6 +86,8 @@ module ActiveJob
   #
   # Global: The adapter is configured that all jobs have a maximum run time.
   #
+  # No: The adapter does not allow the timeout of jobs to be configured.
+  #
   # N/A: This adapter does not run in a separate process, and therefore timeout
   # is unsupported.
   #
@@ -99,6 +101,8 @@ module ActiveJob
   #
   # Global: The adapter has a global number of retries.
   #
+  # No: The adapter does not allow the number of retries to be configured.
+  #
   # N/A: The adapter does not run in a separate process, and therefore doesn't
   # support retries.
   #

data/lib/active_job/queue_adapters/sucker_punch_adapter.rb

@@ -10,7 +10,7 @@ module ActiveJob
     # This reduces the cost of hosting on a service like Heroku along
     # with the memory footprint of having to maintain additional jobs if
     # hosting on a dedicated server. All queues can run within a
-    # single application (eg. Rails, Sinatra, etc.) process.
+    # single application (e.g. Rails, Sinatra, etc.) process.
     #
     # Read more about Sucker Punch {here}[https://github.com/brandonhilkert/sucker_punch].
     #

data/lib/active_job/queue_adapters/test_adapter.rb

@@ -12,7 +12,7 @@ module ActiveJob
     #
     #   Rails.application.config.active_job.queue_adapter = :test
     class TestAdapter
-      attr_accessor(:perform_enqueued_jobs, :perform_enqueued_at_jobs, :filter, :reject, :queue)
+      attr_accessor(:perform_enqueued_jobs, :perform_enqueued_at_jobs, :filter, :reject, :queue, :at)
       attr_writer(:enqueued_jobs, :performed_jobs)
 
       # Provides a store of all the enqueued jobs with the TestAdapter so you can check them.
@@ -54,7 +54,11 @@ module ActiveJob
         end
 
         def filtered?(job)
-          filtered_queue?(job) || filtered_job_class?(job)
+          filtered_queue?(job) || filtered_job_class?(job) || filtered_time?(job)
+        end
+
+        def filtered_time?(job)
+          job.scheduled_at > at.to_f if at && job.scheduled_at
         end
 
         def filtered_queue?(job)

data/lib/active_job/queue_name.rb

@@ -6,7 +6,6 @@ module ActiveJob
 
     # Includes the ability to override the default queue name and prefix.
     module ClassMethods
-      mattr_accessor :queue_name_prefix
       mattr_accessor :default_queue_name, default: "default"
 
       # Specifies the name of the queue to process the job on.
@@ -49,13 +48,14 @@ module ActiveJob
       def queue_name_from_part(part_name) #:nodoc:
         queue_name = part_name || default_queue_name
         name_parts = [queue_name_prefix.presence, queue_name]
-        name_parts.compact.join(queue_name_delimiter)
+        -name_parts.compact.join(queue_name_delimiter)
       end
     end
 
     included do
       class_attribute :queue_name, instance_accessor: false, default: -> { self.class.default_queue_name }
       class_attribute :queue_name_delimiter, instance_accessor: false, default: "_"
+      class_attribute :queue_name_prefix
     end
 
     # Returns the name of the queue the job will be run on.

data/lib/active_job/railtie.rb

@@ -34,6 +34,10 @@ module ActiveJob
       ActiveSupport.on_load(:action_dispatch_integration_test) do
         include ActiveJob::TestHelper
       end
+
+      ActiveSupport.on_load(:active_record) do
+        self.destroy_association_async_job = ActiveRecord::DestroyAssociationAsyncJob
+      end
     end
 
     initializer "active_job.set_reloader_hook" do |app|

data/lib/active_job/serializers.rb

@@ -9,12 +9,14 @@ module ActiveJob
     extend ActiveSupport::Autoload
 
     autoload :ObjectSerializer
+    autoload :TimeObjectSerializer
     autoload :SymbolSerializer
     autoload :DurationSerializer
     autoload :DateTimeSerializer
     autoload :DateSerializer
     autoload :TimeWithZoneSerializer
     autoload :TimeSerializer
+    autoload :ModuleSerializer
 
     mattr_accessor :_additional_serializers
     self._additional_serializers = Set.new
@@ -58,6 +60,7 @@ module ActiveJob
       DateTimeSerializer,
       DateSerializer,
       TimeWithZoneSerializer,
-      TimeSerializer
+      TimeSerializer,
+      ModuleSerializer
   end
 end

data/lib/active_job/serializers/date_time_serializer.rb

@@ -2,11 +2,7 @@
 
 module ActiveJob
   module Serializers
-    class DateTimeSerializer < ObjectSerializer # :nodoc:
-      def serialize(time)
-        super("value" => time.iso8601)
-      end
-
+    class DateTimeSerializer < TimeObjectSerializer # :nodoc:
       def deserialize(hash)
         DateTime.iso8601(hash["value"])
       end

data/lib/active_job/serializers/module_serializer.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module ActiveJob
+  module Serializers
+    class ModuleSerializer < ObjectSerializer # :nodoc:
+      def serialize(constant)
+        super("value" => constant.name)
+      end
+
+      def deserialize(hash)
+        hash["value"].constantize
+      end
+
+      private
+        def klass
+          Module
+        end
+    end
+  end
+end

data/lib/active_job/serializers/object_serializer.rb

@@ -39,7 +39,7 @@ module ActiveJob
       end
 
       # Deserializes an argument from a JSON primitive type.
-      def deserialize(_argument)
+      def deserialize(json)
         raise NotImplementedError
       end
 

data/lib/active_job/serializers/time_object_serializer.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module ActiveJob
+  module Serializers
+    class TimeObjectSerializer < ObjectSerializer # :nodoc:
+      NANO_PRECISION = 9
+
+      def serialize(time)
+        super("value" => time.iso8601(NANO_PRECISION))
+      end
+    end
+  end
+end

data/lib/active_job/serializers/time_serializer.rb

@@ -2,11 +2,7 @@
 
 module ActiveJob
   module Serializers
-    class TimeSerializer < ObjectSerializer # :nodoc:
-      def serialize(time)
-        super("value" => time.iso8601)
-      end
-
+    class TimeSerializer < TimeObjectSerializer # :nodoc:
       def deserialize(hash)
         Time.iso8601(hash["value"])
       end

data/lib/active_job/serializers/time_with_zone_serializer.rb

@@ -2,11 +2,7 @@
 
 module ActiveJob
   module Serializers
-    class TimeWithZoneSerializer < ObjectSerializer # :nodoc:
-      def serialize(time)
-        super("value" => time.iso8601)
-      end
-
+    class TimeWithZoneSerializer < TimeObjectSerializer # :nodoc:
       def deserialize(hash)
         Time.iso8601(hash["value"]).in_time_zone
       end

data/lib/active_job/test_helper.rb

@@ -117,17 +117,17 @@ module ActiveJob
     #       HelloJob.perform_later('elfassy')
     #     end
     #   end
-    def assert_enqueued_jobs(number, only: nil, except: nil, queue: nil)
+    def assert_enqueued_jobs(number, only: nil, except: nil, queue: nil, &block)
       if block_given?
-        original_count = enqueued_jobs_with(only: only, except: except, queue: queue)
+        original_jobs = enqueued_jobs_with(only: only, except: except, queue: queue)
 
-        yield
+        assert_nothing_raised(&block)
 
-        new_count = enqueued_jobs_with(only: only, except: except, queue: queue)
+        new_jobs = enqueued_jobs_with(only: only, except: except, queue: queue)
 
-        actual_count = new_count - original_count
+        actual_count = (new_jobs - original_jobs).count
       else
-        actual_count = enqueued_jobs_with(only: only, except: except, queue: queue)
+        actual_count = enqueued_jobs_with(only: only, except: except, queue: queue).count
       end
 
       assert_equal number, actual_count, "#{number} jobs expected, but #{actual_count} were enqueued"
@@ -279,7 +279,7 @@ module ActiveJob
 
         performed_jobs_size = new_count - original_count
       else
-        performed_jobs_size = performed_jobs_with(only: only, except: except, queue: queue)
+        performed_jobs_size = performed_jobs_with(only: only, except: except, queue: queue).count
       end
 
       assert_equal number, performed_jobs_size, "#{number} jobs expected, but #{performed_jobs_size} were performed"
@@ -345,44 +345,40 @@ module ActiveJob
     #
     #   def test_assert_enqueued_with
     #     MyJob.perform_later(1,2,3)
-    #     assert_enqueued_with(job: MyJob, args: [1,2,3], queue: 'low')
+    #     assert_enqueued_with(job: MyJob, args: [1,2,3])
     #
-    #     MyJob.set(wait_until: Date.tomorrow.noon).perform_later
-    #     assert_enqueued_with(job: MyJob, at: Date.tomorrow.noon)
+    #     MyJob.set(wait_until: Date.tomorrow.noon, queue: "my_queue").perform_later
+    #     assert_enqueued_with(at: Date.tomorrow.noon, queue: "my_queue")
     #   end
     #
-    # The +at+ and +args+ arguments also accept a proc.
+    # The given arguments may also be specified as matcher procs that return a
+    # boolean value indicating whether a job's attribute meets certain criteria.
     #
-    # To the +at+ proc, it will get passed the actual job's at argument.
+    # For example, a proc can be used to match a range of times:
     #
     #   def test_assert_enqueued_with
-    #     expected_time = ->(at) do
-    #       (Date.yesterday..Date.tomorrow).cover?(at)
-    #     end
+    #     at_matcher = ->(job_at) { (Date.yesterday..Date.tomorrow).cover?(job_at) }
+    #
+    #     MyJob.set(wait_until: Date.today.noon).perform_later
     #
-    #     MyJob.set(at: Date.today.noon).perform_later
-    #     assert_enqueued_with(job: MyJob, at: expected_time)
+    #     assert_enqueued_with(job: MyJob, at: at_matcher)
     #   end
     #
-    # To the +args+ proc, it will get passed the actual job's arguments
-    # Your proc needs to return a boolean value determining if
-    # the job's arguments matches your expectation. This is useful to check only
-    # for a subset of arguments.
+    # A proc can also be used to match a subset of a job's args:
     #
     #   def test_assert_enqueued_with
-    #     expected_args = ->(job_args) do
-    #       assert job_args.first.key?(:foo)
-    #     end
+    #     args_matcher = ->(job_args) { job_args[0].key?(:foo) }
     #
-    #     MyJob.perform_later(foo: 'bar', other_arg: 'No need to check in the test')
-    #     assert_enqueued_with(job: MyJob, args: expected_args, queue: 'low')
+    #     MyJob.perform_later(foo: "bar", other_arg: "No need to check in the test")
+    #
+    #     assert_enqueued_with(job: MyJob, args: args_matcher)
     #   end
     #
     # If a block is passed, asserts that the block will cause the job to be
     # enqueued with the given arguments.
     #
     #   def test_assert_enqueued_with
-    #     assert_enqueued_with(job: MyJob, args: [1,2,3], queue: 'low') do
+    #     assert_enqueued_with(job: MyJob, args: [1,2,3]) do
     #       MyJob.perform_later(1,2,3)
     #     end
     #
@@ -390,22 +386,24 @@ module ActiveJob
     #       MyJob.set(wait_until: Date.tomorrow.noon).perform_later
     #     end
     #   end
-    def assert_enqueued_with(job: nil, args: nil, at: nil, queue: nil)
+    def assert_enqueued_with(job: nil, args: nil, at: nil, queue: nil, &block)
       expected = { job: job, args: args, at: at, queue: queue }.compact
       expected_args = prepare_args_for_assertion(expected)
+      potential_matches = []
 
       if block_given?
-        original_enqueued_jobs_count = enqueued_jobs.count
+        original_enqueued_jobs = enqueued_jobs.dup
 
-        yield
+        assert_nothing_raised(&block)
 
-        jobs = enqueued_jobs.drop(original_enqueued_jobs_count)
+        jobs = enqueued_jobs - original_enqueued_jobs
       else
         jobs = enqueued_jobs
       end
 
       matching_job = jobs.find do |enqueued_job|
         deserialized_job = deserialize_args_for_assertion(enqueued_job)
+        potential_matches << deserialized_job
 
         expected_args.all? do |key, value|
           if value.respond_to?(:call)
@@ -416,7 +414,9 @@ module ActiveJob
         end
       end
 
-      assert matching_job, "No enqueued job found with #{expected}"
+      message = +"No enqueued job found with #{expected}"
+      message << "\n\nPotential matches: #{potential_matches.join("\n")}" if potential_matches.present?
+      assert matching_job, message
       instantiate_job(matching_job)
     end
 
@@ -427,42 +427,40 @@ module ActiveJob
     #
     #     perform_enqueued_jobs
     #
-    #     assert_performed_with(job: MyJob, args: [1,2,3], queue: 'high')
+    #     assert_performed_with(job: MyJob, args: [1,2,3])
     #
-    #     MyJob.set(wait_until: Date.tomorrow.noon).perform_later
+    #     MyJob.set(wait_until: Date.tomorrow.noon, queue: "my_queue").perform_later
     #
     #     perform_enqueued_jobs
     #
-    #     assert_performed_with(job: MyJob, at: Date.tomorrow.noon)
+    #     assert_performed_with(at: Date.tomorrow.noon, queue: "my_queue")
     #   end
     #
-    # The +at+ and +args+ arguments also accept a proc.
+    # The given arguments may also be specified as matcher procs that return a
+    # boolean value indicating whether a job's attribute meets certain criteria.
     #
-    # To the +at+ proc, it will get passed the actual job's at argument.
+    # For example, a proc can be used to match a range of times:
     #
-    #   def test_assert_enqueued_with
-    #     expected_time = ->(at) do
-    #       (Date.yesterday..Date.tomorrow).cover?(at)
-    #     end
+    #   def test_assert_performed_with
+    #     at_matcher = ->(job_at) { (Date.yesterday..Date.tomorrow).cover?(job_at) }
+    #
+    #     MyJob.set(wait_until: Date.today.noon).perform_later
     #
-    #     MyJob.set(at: Date.today.noon).perform_later
-    #     assert_enqueued_with(job: MyJob, at: expected_time)
+    #     perform_enqueued_jobs
+    #
+    #     assert_performed_with(job: MyJob, at: at_matcher)
     #   end
     #
-    # To the +args+ proc, it will get passed the actual job's arguments
-    # Your proc needs to return a boolean value determining if
-    # the job's arguments matches your expectation. This is useful to check only
-    # for a subset of arguments.
+    # A proc can also be used to match a subset of a job's args:
     #
     #   def test_assert_performed_with
-    #     expected_args = ->(job_args) do
-    #       assert job_args.first.key?(:foo)
-    #     end
-    #     MyJob.perform_later(foo: 'bar', other_arg: 'No need to check in the test')
+    #     args_matcher = ->(job_args) { job_args[0].key?(:foo) }
+    #
+    #     MyJob.perform_later(foo: "bar", other_arg: "No need to check in the test")
     #
     #     perform_enqueued_jobs
     #
-    #     assert_performed_with(job: MyJob, args: expected_args, queue: 'high')
+    #     assert_performed_with(job: MyJob, args: args_matcher)
     #   end
     #
     # If a block is passed, that block performs all of the jobs that were
@@ -470,7 +468,7 @@ module ActiveJob
     # the job has been performed with the given arguments in the block.
     #
     #   def test_assert_performed_with
-    #     assert_performed_with(job: MyJob, args: [1,2,3], queue: 'high') do
+    #     assert_performed_with(job: MyJob, args: [1,2,3]) do
     #       MyJob.perform_later(1,2,3)
     #     end
     #
@@ -481,6 +479,7 @@ module ActiveJob
     def assert_performed_with(job: nil, args: nil, at: nil, queue: nil, &block)
       expected = { job: job, args: args, at: at, queue: queue }.compact
       expected_args = prepare_args_for_assertion(expected)
+      potential_matches = []
 
       if block_given?
         original_performed_jobs_count = performed_jobs.count
@@ -494,6 +493,7 @@ module ActiveJob
 
       matching_job = jobs.find do |enqueued_job|
         deserialized_job = deserialize_args_for_assertion(enqueued_job)
+        potential_matches << deserialized_job
 
         expected_args.all? do |key, value|
           if value.respond_to?(:call)
@@ -504,7 +504,10 @@ module ActiveJob
         end
       end
 
-      assert matching_job, "No performed job found with #{expected}"
+      message = +"No performed job found with #{expected}"
+      message << "\n\nPotential matches: #{potential_matches.join("\n")}" if potential_matches.present?
+      assert matching_job, message
+
       instantiate_job(matching_job)
     end
 
@@ -563,8 +566,10 @@ module ActiveJob
     #     assert_performed_jobs 1
     #   end
     #
-    def perform_enqueued_jobs(only: nil, except: nil, queue: nil)
-      return flush_enqueued_jobs(only: only, except: except, queue: queue) unless block_given?
+    # If the +:at+ option is specified, then only run jobs enqueued to run
+    # immediately or before the given time
+    def perform_enqueued_jobs(only: nil, except: nil, queue: nil, at: nil, &block)
+      return flush_enqueued_jobs(only: only, except: except, queue: queue, at: at) unless block_given?
 
       validate_option(only: only, except: except)
 
@@ -573,6 +578,7 @@ module ActiveJob
       old_filter = queue_adapter.filter
       old_reject = queue_adapter.reject
       old_queue = queue_adapter.queue
+      old_at = queue_adapter.at
 
       begin
         queue_adapter.perform_enqueued_jobs = true
@@ -580,14 +586,16 @@ module ActiveJob
         queue_adapter.filter = only
         queue_adapter.reject = except
         queue_adapter.queue = queue
+        queue_adapter.at = at
 
-        yield
+        assert_nothing_raised(&block)
       ensure
         queue_adapter.perform_enqueued_jobs = old_perform_enqueued_jobs
         queue_adapter.perform_enqueued_at_jobs = old_perform_enqueued_at_jobs
         queue_adapter.filter = old_filter
         queue_adapter.reject = old_reject
         queue_adapter.queue = old_queue
+        queue_adapter.at = old_at
       end
     end
 
@@ -609,10 +617,10 @@ module ActiveJob
         performed_jobs.clear
       end
 
-      def jobs_with(jobs, only: nil, except: nil, queue: nil)
+      def jobs_with(jobs, only: nil, except: nil, queue: nil, at: nil)
         validate_option(only: only, except: except)
 
-        jobs.count do |job|
+        jobs.dup.select do |job|
           job_class = job.fetch(:job)
 
           if only
@@ -625,6 +633,10 @@ module ActiveJob
             next false unless queue.to_s == job.fetch(:queue, job_class.queue_name)
           end
 
+          if at && job[:at]
+            next false if job[:at] > at.to_f
+          end
+
           yield job if block_given?
 
           true
@@ -637,41 +649,28 @@ module ActiveJob
         ->(job) { Array(filter).include?(job.fetch(:job)) }
       end
 
-      def enqueued_jobs_with(only: nil, except: nil, queue: nil, &block)
-        jobs_with(enqueued_jobs, only: only, except: except, queue: queue, &block)
+      def enqueued_jobs_with(only: nil, except: nil, queue: nil, at: nil, &block)
+        jobs_with(enqueued_jobs, only: only, except: except, queue: queue, at: at, &block)
       end
 
       def performed_jobs_with(only: nil, except: nil, queue: nil, &block)
         jobs_with(performed_jobs, only: only, except: except, queue: queue, &block)
       end
 
-      def flush_enqueued_jobs(only: nil, except: nil, queue: nil)
-        enqueued_jobs_with(only: only, except: except, queue: queue) do |payload|
-          instantiate_job(payload).perform_now
+      def flush_enqueued_jobs(only: nil, except: nil, queue: nil, at: nil)
+        enqueued_jobs_with(only: only, except: except, queue: queue, at: at) do |payload|
+          queue_adapter.enqueued_jobs.delete(payload)
           queue_adapter.performed_jobs << payload
-        end
+          instantiate_job(payload).perform_now
+        end.count
       end
 
       def prepare_args_for_assertion(args)
         args.dup.tap do |arguments|
-          if arguments[:at] && !arguments[:at].respond_to?(:call)
+          if arguments[:at].acts_like?(:time)
             at_range = arguments[:at] - 1..arguments[:at] + 1
             arguments[:at] = ->(at) { at_range.cover?(at) }
           end
-          arguments[:args] = round_time_arguments(arguments[:args]) if arguments[:args]
-        end
-      end
-
-      def round_time_arguments(argument)
-        case argument
-        when Time, ActiveSupport::TimeWithZone, DateTime
-          argument.change(usec: 0)
-        when Hash
-          argument.transform_values { |value| round_time_arguments(value) }
-        when Array
-          argument.map { |element| round_time_arguments(element) }
-        else
-          argument
         end
       end