activejob 5.2.3

data/lib/active_job/queue_adapters/test_adapter.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module ActiveJob
+  module QueueAdapters
+    # == Test adapter for Active Job
+    #
+    # The test adapter should be used only in testing. Along with
+    # <tt>ActiveJob::TestCase</tt> and <tt>ActiveJob::TestHelper</tt>
+    # it makes a great tool to test your Rails application.
+    #
+    # To use the test adapter set queue_adapter config to +:test+.
+    #
+    #   Rails.application.config.active_job.queue_adapter = :test
+    class TestAdapter
+      attr_accessor(:perform_enqueued_jobs, :perform_enqueued_at_jobs, :filter, :reject)
+      attr_writer(:enqueued_jobs, :performed_jobs)
+
+      # Provides a store of all the enqueued jobs with the TestAdapter so you can check them.
+      def enqueued_jobs
+        @enqueued_jobs ||= []
+      end
+
+      # Provides a store of all the performed jobs with the TestAdapter so you can check them.
+      def performed_jobs
+        @performed_jobs ||= []
+      end
+
+      def enqueue(job) #:nodoc:
+        return if filtered?(job)
+
+        job_data = job_to_hash(job)
+        enqueue_or_perform(perform_enqueued_jobs, job, job_data)
+      end
+
+      def enqueue_at(job, timestamp) #:nodoc:
+        return if filtered?(job)
+
+        job_data = job_to_hash(job, at: timestamp)
+        enqueue_or_perform(perform_enqueued_at_jobs, job, job_data)
+      end
+
+      private
+        def job_to_hash(job, extras = {})
+          { job: job.class, args: job.serialize.fetch("arguments"), queue: job.queue_name }.merge!(extras)
+        end
+
+        def enqueue_or_perform(perform, job, job_data)
+          if perform
+            performed_jobs << job_data
+            Base.execute job.serialize
+          else
+            enqueued_jobs << job_data
+          end
+        end
+
+        def filtered?(job)
+          if filter
+            !Array(filter).include?(job.class)
+          elsif reject
+            Array(reject).include?(job.class)
+          else
+            false
+          end
+        end
+    end
+  end
+end

data/lib/active_job/queue_name.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module ActiveJob
+  module QueueName
+    extend ActiveSupport::Concern
+
+    # 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.
+      #
+      #   class PublishToFeedJob < ActiveJob::Base
+      #     queue_as :feeds
+      #
+      #     def perform(post)
+      #       post.to_feed!
+      #     end
+      #   end
+      def queue_as(part_name = nil, &block)
+        if block_given?
+          self.queue_name = block
+        else
+          self.queue_name = queue_name_from_part(part_name)
+        end
+      end
+
+      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)
+      end
+    end
+
+    included do
+      class_attribute :queue_name, instance_accessor: false, default: default_queue_name
+      class_attribute :queue_name_delimiter, instance_accessor: false, default: "_"
+    end
+
+    # Returns the name of the queue the job will be run on.
+    def queue_name
+      if @queue_name.is_a?(Proc)
+        @queue_name = self.class.queue_name_from_part(instance_exec(&@queue_name))
+      end
+      @queue_name
+    end
+  end
+end

data/lib/active_job/queue_priority.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module ActiveJob
+  module QueuePriority
+    extend ActiveSupport::Concern
+
+    # Includes the ability to override the default queue priority.
+    module ClassMethods
+      mattr_accessor :default_priority
+
+      # Specifies the priority of the queue to create the job with.
+      #
+      #   class PublishToFeedJob < ActiveJob::Base
+      #     queue_with_priority 50
+      #
+      #     def perform(post)
+      #       post.to_feed!
+      #     end
+      #   end
+      #
+      # Specify either an argument or a block.
+      def queue_with_priority(priority = nil, &block)
+        if block_given?
+          self.priority = block
+        else
+          self.priority = priority
+        end
+      end
+    end
+
+    included do
+      class_attribute :priority, instance_accessor: false, default: default_priority
+    end
+
+    # Returns the priority that the job will be created with
+    def priority
+      if @priority.is_a?(Proc)
+        @priority = instance_exec(&@priority)
+      end
+      @priority
+    end
+  end
+end

data/lib/active_job/railtie.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require "global_id/railtie"
+require "active_job"
+
+module ActiveJob
+  # = Active Job Railtie
+  class Railtie < Rails::Railtie # :nodoc:
+    config.active_job = ActiveSupport::OrderedOptions.new
+
+    initializer "active_job.logger" do
+      ActiveSupport.on_load(:active_job) { self.logger = ::Rails.logger }
+    end
+
+    initializer "active_job.set_configs" do |app|
+      options = app.config.active_job
+      options.queue_adapter ||= :async
+
+      ActiveSupport.on_load(:active_job) do
+        options.each { |k, v| send("#{k}=", v) }
+      end
+    end
+
+    initializer "active_job.set_reloader_hook" do |app|
+      ActiveSupport.on_load(:active_job) do
+        ActiveJob::Callbacks.singleton_class.set_callback(:execute, :around, prepend: true) do |_, inner|
+          app.reloader.wrap do
+            inner.call
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_job/test_case.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require "active_support/test_case"
+
+module ActiveJob
+  class TestCase < ActiveSupport::TestCase
+    include ActiveJob::TestHelper
+
+    ActiveSupport.run_load_hooks(:active_job_test_case, self)
+  end
+end

data/lib/active_job/test_helper.rb

@@ -0,0 +1,456 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/class/subclasses"
+require "active_support/core_ext/hash/keys"
+
+module ActiveJob
+  # Provides helper methods for testing Active Job
+  module TestHelper
+    delegate :enqueued_jobs, :enqueued_jobs=,
+      :performed_jobs, :performed_jobs=,
+      to: :queue_adapter
+
+    module TestQueueAdapter
+      extend ActiveSupport::Concern
+
+      included do
+        class_attribute :_test_adapter, instance_accessor: false, instance_predicate: false
+      end
+
+      module ClassMethods
+        def queue_adapter
+          self._test_adapter.nil? ? super : self._test_adapter
+        end
+
+        def disable_test_adapter
+          self._test_adapter = nil
+        end
+
+        def enable_test_adapter(test_adapter)
+          self._test_adapter = test_adapter
+        end
+      end
+    end
+
+    ActiveJob::Base.include(TestQueueAdapter)
+
+    def before_setup # :nodoc:
+      test_adapter = queue_adapter_for_test
+
+      queue_adapter_changed_jobs.each do |klass|
+        klass.enable_test_adapter(test_adapter)
+      end
+
+      clear_enqueued_jobs
+      clear_performed_jobs
+      super
+    end
+
+    def after_teardown # :nodoc:
+      super
+
+      queue_adapter_changed_jobs.each { |klass| klass.disable_test_adapter }
+    end
+
+    # Specifies the queue adapter to use with all active job test helpers.
+    #
+    # Returns an instance of the queue adapter and defaults to
+    # <tt>ActiveJob::QueueAdapters::TestAdapter</tt>.
+    #
+    # Note: The adapter provided by this method must provide some additional
+    # methods from those expected of a standard <tt>ActiveJob::QueueAdapter</tt>
+    # in order to be used with the active job test helpers. Refer to
+    # <tt>ActiveJob::QueueAdapters::TestAdapter</tt>.
+    def queue_adapter_for_test
+      ActiveJob::QueueAdapters::TestAdapter.new
+    end
+
+    # Asserts that the number of enqueued jobs matches the given number.
+    #
+    #   def test_jobs
+    #     assert_enqueued_jobs 0
+    #     HelloJob.perform_later('david')
+    #     assert_enqueued_jobs 1
+    #     HelloJob.perform_later('abdelkader')
+    #     assert_enqueued_jobs 2
+    #   end
+    #
+    # If a block is passed, that block will cause the specified number of
+    # jobs to be enqueued.
+    #
+    #   def test_jobs_again
+    #     assert_enqueued_jobs 1 do
+    #       HelloJob.perform_later('cristian')
+    #     end
+    #
+    #     assert_enqueued_jobs 2 do
+    #       HelloJob.perform_later('aaron')
+    #       HelloJob.perform_later('rafael')
+    #     end
+    #   end
+    #
+    # The number of times a specific job was enqueued can be asserted.
+    #
+    #   def test_logging_job
+    #     assert_enqueued_jobs 1, only: LoggingJob do
+    #       LoggingJob.perform_later
+    #       HelloJob.perform_later('jeremy')
+    #     end
+    #   end
+    #
+    # The number of times a job except specific class was enqueued can be asserted.
+    #
+    #   def test_logging_job
+    #     assert_enqueued_jobs 1, except: HelloJob do
+    #       LoggingJob.perform_later
+    #       HelloJob.perform_later('jeremy')
+    #     end
+    #   end
+    #
+    # The number of times a job is enqueued to a specific queue can also be asserted.
+    #
+    #   def test_logging_job
+    #     assert_enqueued_jobs 2, queue: 'default' do
+    #       LoggingJob.perform_later
+    #       HelloJob.perform_later('elfassy')
+    #     end
+    #   end
+    def assert_enqueued_jobs(number, only: nil, except: nil, queue: nil)
+      if block_given?
+        original_count = enqueued_jobs_size(only: only, except: except, queue: queue)
+        yield
+        new_count = enqueued_jobs_size(only: only, except: except, queue: queue)
+        assert_equal number, new_count - original_count, "#{number} jobs expected, but #{new_count - original_count} were enqueued"
+      else
+        actual_count = enqueued_jobs_size(only: only, except: except, queue: queue)
+        assert_equal number, actual_count, "#{number} jobs expected, but #{actual_count} were enqueued"
+      end
+    end
+
+    # Asserts that no jobs have been enqueued.
+    #
+    #   def test_jobs
+    #     assert_no_enqueued_jobs
+    #     HelloJob.perform_later('jeremy')
+    #     assert_enqueued_jobs 1
+    #   end
+    #
+    # If a block is passed, that block should not cause any job to be enqueued.
+    #
+    #   def test_jobs_again
+    #     assert_no_enqueued_jobs do
+    #       # No job should be enqueued from this block
+    #     end
+    #   end
+    #
+    # It can be asserted that no jobs of a specific kind are enqueued:
+    #
+    #   def test_no_logging
+    #     assert_no_enqueued_jobs only: LoggingJob do
+    #       HelloJob.perform_later('jeremy')
+    #     end
+    #   end
+    #
+    # It can be asserted that no jobs except specific class are enqueued:
+    #
+    #   def test_no_logging
+    #     assert_no_enqueued_jobs except: HelloJob do
+    #       HelloJob.perform_later('jeremy')
+    #     end
+    #   end
+    #
+    # Note: This assertion is simply a shortcut for:
+    #
+    #   assert_enqueued_jobs 0, &block
+    def assert_no_enqueued_jobs(only: nil, except: nil, &block)
+      assert_enqueued_jobs 0, only: only, except: except, &block
+    end
+
+    # Asserts that the number of performed jobs matches the given number.
+    # If no block is passed, <tt>perform_enqueued_jobs</tt>
+    # must be called around the job call.
+    #
+    #   def test_jobs
+    #     assert_performed_jobs 0
+    #
+    #     perform_enqueued_jobs do
+    #       HelloJob.perform_later('xavier')
+    #     end
+    #     assert_performed_jobs 1
+    #
+    #     perform_enqueued_jobs do
+    #       HelloJob.perform_later('yves')
+    #       assert_performed_jobs 2
+    #     end
+    #   end
+    #
+    # If a block is passed, that block should cause the specified number of
+    # jobs to be performed.
+    #
+    #   def test_jobs_again
+    #     assert_performed_jobs 1 do
+    #       HelloJob.perform_later('robin')
+    #     end
+    #
+    #     assert_performed_jobs 2 do
+    #       HelloJob.perform_later('carlos')
+    #       HelloJob.perform_later('sean')
+    #     end
+    #   end
+    #
+    # The block form supports filtering. If the :only option is specified,
+    # then only the listed job(s) will be performed.
+    #
+    #     def test_hello_job
+    #       assert_performed_jobs 1, only: HelloJob do
+    #         HelloJob.perform_later('jeremy')
+    #         LoggingJob.perform_later
+    #       end
+    #     end
+    #
+    # Also if the :except option is specified,
+    # then the job(s) except specific class will be performed.
+    #
+    #     def test_hello_job
+    #       assert_performed_jobs 1, except: LoggingJob do
+    #         HelloJob.perform_later('jeremy')
+    #         LoggingJob.perform_later
+    #       end
+    #     end
+    #
+    # An array may also be specified, to support testing multiple jobs.
+    #
+    #     def test_hello_and_logging_jobs
+    #       assert_nothing_raised do
+    #         assert_performed_jobs 2, only: [HelloJob, LoggingJob] do
+    #           HelloJob.perform_later('jeremy')
+    #           LoggingJob.perform_later('stewie')
+    #           RescueJob.perform_later('david')
+    #         end
+    #       end
+    #     end
+    def assert_performed_jobs(number, only: nil, except: nil)
+      if block_given?
+        original_count = performed_jobs.size
+        perform_enqueued_jobs(only: only, except: except) { yield }
+        new_count = performed_jobs.size
+        assert_equal number, new_count - original_count,
+          "#{number} jobs expected, but #{new_count - original_count} were performed"
+      else
+        performed_jobs_size = performed_jobs.size
+        assert_equal number, performed_jobs_size, "#{number} jobs expected, but #{performed_jobs_size} were performed"
+      end
+    end
+
+    # Asserts that no jobs have been performed.
+    #
+    #   def test_jobs
+    #     assert_no_performed_jobs
+    #
+    #     perform_enqueued_jobs do
+    #       HelloJob.perform_later('matthew')
+    #       assert_performed_jobs 1
+    #     end
+    #   end
+    #
+    # If a block is passed, that block should not cause any job to be performed.
+    #
+    #   def test_jobs_again
+    #     assert_no_performed_jobs do
+    #       # No job should be performed from this block
+    #     end
+    #   end
+    #
+    # The block form supports filtering. If the :only option is specified,
+    # then only the listed job(s) will not be performed.
+    #
+    #   def test_no_logging
+    #     assert_no_performed_jobs only: LoggingJob do
+    #       HelloJob.perform_later('jeremy')
+    #     end
+    #   end
+    #
+    # Also if the :except option is specified,
+    # then the job(s) except specific class will not be performed.
+    #
+    #   def test_no_logging
+    #     assert_no_performed_jobs except: HelloJob do
+    #       HelloJob.perform_later('jeremy')
+    #     end
+    #   end
+    #
+    # Note: This assertion is simply a shortcut for:
+    #
+    #   assert_performed_jobs 0, &block
+    def assert_no_performed_jobs(only: nil, except: nil, &block)
+      assert_performed_jobs 0, only: only, except: except, &block
+    end
+
+    # Asserts that the job passed in the block has been enqueued with the given arguments.
+    #
+    #   def test_assert_enqueued_with
+    #     assert_enqueued_with(job: MyJob, args: [1,2,3], queue: 'low') do
+    #       MyJob.perform_later(1,2,3)
+    #     end
+    #
+    #     assert_enqueued_with(job: MyJob, at: Date.tomorrow.noon) do
+    #       MyJob.set(wait_until: Date.tomorrow.noon).perform_later
+    #     end
+    #   end
+    def assert_enqueued_with(job: nil, args: nil, at: nil, queue: nil)
+      original_enqueued_jobs_count = enqueued_jobs.count
+      expected = { job: job, args: args, at: at, queue: queue }.compact
+      expected_args = prepare_args_for_assertion(expected)
+      yield
+      in_block_jobs = enqueued_jobs.drop(original_enqueued_jobs_count)
+      matching_job = in_block_jobs.find do |in_block_job|
+        deserialized_job = deserialize_args_for_assertion(in_block_job)
+        expected_args.all? { |key, value| value == deserialized_job[key] }
+      end
+      assert matching_job, "No enqueued job found with #{expected}"
+      instantiate_job(matching_job)
+    end
+
+    # Asserts that the job passed in the block has been performed with the given arguments.
+    #
+    #   def test_assert_performed_with
+    #     assert_performed_with(job: MyJob, args: [1,2,3], queue: 'high') do
+    #       MyJob.perform_later(1,2,3)
+    #     end
+    #
+    #     assert_performed_with(job: MyJob, at: Date.tomorrow.noon) do
+    #       MyJob.set(wait_until: Date.tomorrow.noon).perform_later
+    #     end
+    #   end
+    def assert_performed_with(job: nil, args: nil, at: nil, queue: nil)
+      original_performed_jobs_count = performed_jobs.count
+      expected = { job: job, args: args, at: at, queue: queue }.compact
+      expected_args = prepare_args_for_assertion(expected)
+      perform_enqueued_jobs { yield }
+      in_block_jobs = performed_jobs.drop(original_performed_jobs_count)
+      matching_job = in_block_jobs.find do |in_block_job|
+        deserialized_job = deserialize_args_for_assertion(in_block_job)
+        expected_args.all? { |key, value| value == deserialized_job[key] }
+      end
+      assert matching_job, "No performed job found with #{expected}"
+      instantiate_job(matching_job)
+    end
+
+    # Performs all enqueued jobs in the duration of the block.
+    #
+    #   def test_perform_enqueued_jobs
+    #     perform_enqueued_jobs do
+    #       MyJob.perform_later(1, 2, 3)
+    #     end
+    #     assert_performed_jobs 1
+    #   end
+    #
+    # This method also supports filtering. If the +:only+ option is specified,
+    # then only the listed job(s) will be performed.
+    #
+    #   def test_perform_enqueued_jobs_with_only
+    #     perform_enqueued_jobs(only: MyJob) do
+    #       MyJob.perform_later(1, 2, 3) # will be performed
+    #       HelloJob.perform_later(1, 2, 3) # will not be performed
+    #     end
+    #     assert_performed_jobs 1
+    #   end
+    #
+    # Also if the +:except+ option is specified,
+    # then the job(s) except specific class will be performed.
+    #
+    #   def test_perform_enqueued_jobs_with_except
+    #     perform_enqueued_jobs(except: HelloJob) do
+    #       MyJob.perform_later(1, 2, 3) # will be performed
+    #       HelloJob.perform_later(1, 2, 3) # will not be performed
+    #     end
+    #     assert_performed_jobs 1
+    #   end
+    #
+    def perform_enqueued_jobs(only: nil, except: nil)
+      validate_option(only: only, except: except)
+      old_perform_enqueued_jobs = queue_adapter.perform_enqueued_jobs
+      old_perform_enqueued_at_jobs = queue_adapter.perform_enqueued_at_jobs
+      old_filter = queue_adapter.filter
+      old_reject = queue_adapter.reject
+
+      begin
+        queue_adapter.perform_enqueued_jobs = true
+        queue_adapter.perform_enqueued_at_jobs = true
+        queue_adapter.filter = only
+        queue_adapter.reject = except
+        yield
+      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
+      end
+    end
+
+    # Accesses the queue_adapter set by ActiveJob::Base.
+    #
+    #   def test_assert_job_has_custom_queue_adapter_set
+    #     assert_instance_of CustomQueueAdapter, HelloJob.queue_adapter
+    #   end
+    def queue_adapter
+      ActiveJob::Base.queue_adapter
+    end
+
+    private
+      def clear_enqueued_jobs
+        enqueued_jobs.clear
+      end
+
+      def clear_performed_jobs
+        performed_jobs.clear
+      end
+
+      def enqueued_jobs_size(only: nil, except: nil, queue: nil)
+        validate_option(only: only, except: except)
+        enqueued_jobs.count do |job|
+          job_class = job.fetch(:job)
+          if only
+            next false unless Array(only).include?(job_class)
+          elsif except
+            next false if Array(except).include?(job_class)
+          end
+          if queue
+            next false unless queue.to_s == job.fetch(:queue, job_class.queue_name)
+          end
+          true
+        end
+      end
+
+      def prepare_args_for_assertion(args)
+        args.dup.tap do |arguments|
+          arguments[:at] = arguments[:at].to_f if arguments[:at]
+        end
+      end
+
+      def deserialize_args_for_assertion(job)
+        job.dup.tap do |new_job|
+          new_job[:args] = ActiveJob::Arguments.deserialize(new_job[:args]) if new_job[:args]
+        end
+      end
+
+      def instantiate_job(payload)
+        args = ActiveJob::Arguments.deserialize(payload[:args])
+        job = payload[:job].new(*args)
+        job.scheduled_at = Time.at(payload[:at]) if payload.key?(:at)
+        job.queue_name = payload[:queue]
+        job
+      end
+
+      def queue_adapter_changed_jobs
+        (ActiveJob::Base.descendants << ActiveJob::Base).select do |klass|
+          # only override explicitly set adapters, a quirk of `class_attribute`
+          klass.singleton_class.public_instance_methods(false).include?(:_queue_adapter)
+        end
+      end
+
+      def validate_option(only: nil, except: nil)
+        raise ArgumentError, "Cannot specify both `:only` and `:except` options." if only && except
+      end
+  end
+end