activejob 4.2.11.3 → 5.0.0.beta1

data/lib/active_job/queue_adapters/backburner_adapter.rb

@@ -13,15 +13,13 @@ module ActiveJob
     #
     #   Rails.application.config.active_job.queue_adapter = :backburner
     class BackburnerAdapter
-      class << self
-        def enqueue(job) #:nodoc:
-          Backburner::Worker.enqueue JobWrapper, [ job.serialize ], queue: job.queue_name
-        end
+      def enqueue(job) #:nodoc:
+        Backburner::Worker.enqueue JobWrapper, [ job.serialize ], queue: job.queue_name
+      end
 
-        def enqueue_at(job, timestamp) #:nodoc:
-          delay = timestamp - Time.current.to_f
-          Backburner::Worker.enqueue JobWrapper, [ job.serialize ], queue: job.queue_name, delay: delay
-        end
+      def enqueue_at(job, timestamp) #:nodoc:
+        delay = timestamp - Time.current.to_f
+        Backburner::Worker.enqueue JobWrapper, [ job.serialize ], queue: job.queue_name, delay: delay
       end
 
       class JobWrapper #:nodoc:

data/lib/active_job/queue_adapters/delayed_job_adapter.rb

@@ -13,14 +13,16 @@ module ActiveJob
     #
     #   Rails.application.config.active_job.queue_adapter = :delayed_job
     class DelayedJobAdapter
-      class << self
-        def enqueue(job) #:nodoc:
-          Delayed::Job.enqueue(JobWrapper.new(job.serialize), queue: job.queue_name)
-        end
+      def enqueue(job) #:nodoc:
+        delayed_job = Delayed::Job.enqueue(JobWrapper.new(job.serialize), queue: job.queue_name, priority: job.priority)
+        job.provider_job_id = delayed_job.id
+        delayed_job
+      end
 
-        def enqueue_at(job, timestamp) #:nodoc:
-          Delayed::Job.enqueue(JobWrapper.new(job.serialize), queue: job.queue_name, run_at: Time.at(timestamp))
-        end
+      def enqueue_at(job, timestamp) #:nodoc:
+        delayed_job = Delayed::Job.enqueue(JobWrapper.new(job.serialize), queue: job.queue_name, priority: job.priority, run_at: Time.at(timestamp))
+        job.provider_job_id = delayed_job.id
+        delayed_job
       end
 
       class JobWrapper #:nodoc:

data/lib/active_job/queue_adapters/inline_adapter.rb

@@ -9,14 +9,12 @@ module ActiveJob
     #
     #   Rails.application.config.active_job.queue_adapter = :inline
     class InlineAdapter
-      class << self
-        def enqueue(job) #:nodoc:
-          Base.execute(job.serialize)
-        end
+      def enqueue(job) #:nodoc:
+        Base.execute(job.serialize)
+      end
 
-        def enqueue_at(*) #:nodoc:
-          raise NotImplementedError.new("Use a queueing backend to enqueue jobs in the future. Read more at http://guides.rubyonrails.org/active_job_basics.html")
-        end
+      def enqueue_at(*) #:nodoc:
+        raise NotImplementedError, "Use a queueing backend to enqueue jobs in the future. Read more at http://guides.rubyonrails.org/active_job_basics.html"
       end
     end
   end

data/lib/active_job/queue_adapters/qu_adapter.rb

@@ -16,16 +16,18 @@ module ActiveJob
     #
     #   Rails.application.config.active_job.queue_adapter = :qu
     class QuAdapter
-      class << self
-        def enqueue(job, *args) #:nodoc:
-          Qu::Payload.new(klass: JobWrapper, args: [job.serialize]).tap do |payload|
-            payload.instance_variable_set(:@queue, job.queue_name)
-          end.push
-        end
+      def enqueue(job, *args) #:nodoc:
+        qu_job = Qu::Payload.new(klass: JobWrapper, args: [job.serialize]).tap do |payload|
+          payload.instance_variable_set(:@queue, job.queue_name)
+        end.push
+        
+        # qu_job can be nil depending on the configured backend
+        job.provider_job_id = qu_job.id unless qu_job.nil?
+        qu_job
+      end
 
-        def enqueue_at(job, timestamp, *args) #:nodoc:
-          raise NotImplementedError
-        end
+      def enqueue_at(job, timestamp, *args) #:nodoc:
+        raise NotImplementedError, "This queueing backend does not support scheduling jobs. To see what features are supported go to http://api.rubyonrails.org/classes/ActiveJob/QueueAdapters.html"
       end
 
       class JobWrapper < Qu::Job #:nodoc:

data/lib/active_job/queue_adapters/que_adapter.rb

@@ -15,14 +15,16 @@ module ActiveJob
     #
     #   Rails.application.config.active_job.queue_adapter = :que
     class QueAdapter
-      class << self
-        def enqueue(job) #:nodoc:
-          JobWrapper.enqueue job.serialize, queue: job.queue_name
-        end
+      def enqueue(job) #:nodoc:
+        que_job = JobWrapper.enqueue job.serialize, priority: job.priority
+        job.provider_job_id = que_job.attrs["job_id"]
+        que_job
+      end
 
-        def enqueue_at(job, timestamp) #:nodoc:
-          JobWrapper.enqueue job.serialize, queue: job.queue_name, run_at: Time.at(timestamp)
-        end
+      def enqueue_at(job, timestamp) #:nodoc:
+        que_job = JobWrapper.enqueue job.serialize, priority: job.priority, run_at: Time.at(timestamp)
+        job.provider_job_id = que_job.attrs["job_id"]
+        que_job
       end
 
       class JobWrapper < Que::Job #:nodoc:

data/lib/active_job/queue_adapters/queue_classic_adapter.rb

@@ -17,29 +17,31 @@ module ActiveJob
     #
     #   Rails.application.config.active_job.queue_adapter = :queue_classic
     class QueueClassicAdapter
-      class << self
-        def enqueue(job) #:nodoc:
-          build_queue(job.queue_name).enqueue("#{JobWrapper.name}.perform", job.serialize)
-        end
+      def enqueue(job) #:nodoc:
+        qc_job = build_queue(job.queue_name).enqueue("#{JobWrapper.name}.perform", job.serialize)
+        job.provider_job_id = qc_job["id"] if qc_job.is_a?(Hash)
+        qc_job
+      end
 
-        def enqueue_at(job, timestamp) #:nodoc:
-          queue = build_queue(job.queue_name)
-          unless queue.respond_to?(:enqueue_at)
-            raise NotImplementedError, 'To be able to schedule jobs with queue_classic ' \
-              'the QC::Queue needs to respond to `enqueue_at(timestamp, method, *args)`. ' \
-              'You can implement this yourself or you can use the queue_classic-later gem.'
-          end
-          queue.enqueue_at(timestamp, "#{JobWrapper.name}.perform", job.serialize)
+      def enqueue_at(job, timestamp) #:nodoc:
+        queue = build_queue(job.queue_name)
+        unless queue.respond_to?(:enqueue_at)
+          raise NotImplementedError, 'To be able to schedule jobs with queue_classic ' \
+            'the QC::Queue needs to respond to `enqueue_at(timestamp, method, *args)`. ' \
+            'You can implement this yourself or you can use the queue_classic-later gem.'
         end
+        qc_job = queue.enqueue_at(timestamp, "#{JobWrapper.name}.perform", job.serialize)
+        job.provider_job_id = qc_job["id"] if qc_job.is_a?(Hash)
+        qc_job
+      end
 
-        # Builds a <tt>QC::Queue</tt> object to schedule jobs on.
-        #
-        # If you have a custom <tt>QC::Queue</tt> subclass you'll need to subclass
-        # <tt>ActiveJob::QueueAdapters::QueueClassicAdapter</tt> and override the
-        # <tt>build_queue</tt> method.
-        def build_queue(queue_name)
-          QC::Queue.new(queue_name)
-        end
+      # Builds a <tt>QC::Queue</tt> object to schedule jobs on.
+      #
+      # If you have a custom <tt>QC::Queue</tt> subclass you'll need to subclass
+      # <tt>ActiveJob::QueueAdapters::QueueClassicAdapter</tt> and override the
+      # <tt>build_queue</tt> method.
+      def build_queue(queue_name)
+        QC::Queue.new(queue_name)
       end
 
       class JobWrapper #:nodoc:

data/lib/active_job/queue_adapters/resque_adapter.rb

@@ -26,18 +26,16 @@ module ActiveJob
     #
     #   Rails.application.config.active_job.queue_adapter = :resque
     class ResqueAdapter
-      class << self
-        def enqueue(job) #:nodoc:
-          Resque.enqueue_to job.queue_name, JobWrapper, job.serialize
-        end
+      def enqueue(job) #:nodoc:
+        Resque.enqueue_to job.queue_name, JobWrapper, job.serialize
+      end
 
-        def enqueue_at(job, timestamp) #:nodoc:
-          unless Resque.respond_to?(:enqueue_at_with_queue)
-            raise NotImplementedError, "To be able to schedule jobs with Resque you need the " \
-              "resque-scheduler gem. Please add it to your Gemfile and run bundle install"
-          end
-          Resque.enqueue_at_with_queue job.queue_name, timestamp, JobWrapper, job.serialize
+      def enqueue_at(job, timestamp) #:nodoc:
+        unless Resque.respond_to?(:enqueue_at_with_queue)
+          raise NotImplementedError, "To be able to schedule jobs with Resque you need the " \
+            "resque-scheduler gem. Please add it to your Gemfile and run bundle install"
         end
+        Resque.enqueue_at_with_queue job.queue_name, timestamp, JobWrapper, job.serialize
       end
 
       class JobWrapper #:nodoc:

data/lib/active_job/queue_adapters/sidekiq_adapter.rb

@@ -15,24 +15,22 @@ module ActiveJob
     #
     #   Rails.application.config.active_job.queue_adapter = :sidekiq
     class SidekiqAdapter
-      class << self
-        def enqueue(job) #:nodoc:
-          #Sidekiq::Client does not support symbols as keys
-          Sidekiq::Client.push \
-            'class' => JobWrapper,
-            'wrapped' => job.class.to_s,
-            'queue' => job.queue_name,
-            'args'  => [ job.serialize ]
-        end
+      def enqueue(job) #:nodoc:
+        #Sidekiq::Client does not support symbols as keys
+        job.provider_job_id = Sidekiq::Client.push \
+          'class'   => JobWrapper,
+          'wrapped' => job.class.to_s,
+          'queue'   => job.queue_name,
+          'args'    => [ job.serialize ]
+      end
 
-        def enqueue_at(job, timestamp) #:nodoc:
-          Sidekiq::Client.push \
-            'class' => JobWrapper,
-            'wrapped' => job.class.to_s,
-            'queue' => job.queue_name,
-            'args'  => [ job.serialize ],
-            'at'    => timestamp
-        end
+      def enqueue_at(job, timestamp) #:nodoc:
+        job.provider_job_id = Sidekiq::Client.push \
+          'class'   => JobWrapper,
+          'wrapped' => job.class.to_s,
+          'queue'   => job.queue_name,
+          'args'    => [ job.serialize ],
+          'at'      => timestamp
       end
 
       class JobWrapper #:nodoc:

data/lib/active_job/queue_adapters/sneakers_adapter.rb

@@ -1,5 +1,5 @@
 require 'sneakers'
-require 'thread'
+require 'monitor'
 
 module ActiveJob
   module QueueAdapters
@@ -16,19 +16,19 @@ module ActiveJob
     #
     #   Rails.application.config.active_job.queue_adapter = :sneakers
     class SneakersAdapter
-      @monitor = Monitor.new
+      def initialize
+        @monitor = Monitor.new
+      end
 
-      class << self
-        def enqueue(job) #:nodoc:
-          @monitor.synchronize do
-            JobWrapper.from_queue job.queue_name
-            JobWrapper.enqueue ActiveSupport::JSON.encode(job.serialize)
-          end
+      def enqueue(job) #:nodoc:
+        @monitor.synchronize do
+          JobWrapper.from_queue job.queue_name
+          JobWrapper.enqueue ActiveSupport::JSON.encode(job.serialize)
         end
+      end
 
-        def enqueue_at(job, timestamp) #:nodoc:
-          raise NotImplementedError
-        end
+      def enqueue_at(job, timestamp) #:nodoc:
+        raise NotImplementedError, "This queueing backend does not support scheduling jobs. To see what features are supported go to http://api.rubyonrails.org/classes/ActiveJob/QueueAdapters.html"
       end
 
       class JobWrapper #:nodoc:

data/lib/active_job/queue_adapters/sucker_punch_adapter.rb

@@ -18,14 +18,12 @@ module ActiveJob
     #
     #   Rails.application.config.active_job.queue_adapter = :sucker_punch
     class SuckerPunchAdapter
-      class << self
-        def enqueue(job) #:nodoc:
-          JobWrapper.new.async.perform job.serialize
-        end
+      def enqueue(job) #:nodoc:
+        JobWrapper.new.async.perform job.serialize
+      end
 
-        def enqueue_at(job, timestamp) #:nodoc:
-          raise NotImplementedError
-        end
+      def enqueue_at(job, timestamp) #:nodoc:
+        raise NotImplementedError, "This queueing backend does not support scheduling jobs. To see what features are supported go to http://api.rubyonrails.org/classes/ActiveJob/QueueAdapters.html"
       end
 
       class JobWrapper #:nodoc:

data/lib/active_job/queue_adapters/test_adapter.rb

@@ -10,15 +10,9 @@ module ActiveJob
     #
     #   Rails.application.config.active_job.queue_adapter = :test
     class TestAdapter
-      delegate :name, to: :class
-      attr_accessor(:perform_enqueued_jobs, :perform_enqueued_at_jobs)
+      attr_accessor(:perform_enqueued_jobs, :perform_enqueued_at_jobs, :filter)
       attr_writer(:enqueued_jobs, :performed_jobs)
 
-      def initialize
-        self.perform_enqueued_jobs = false
-        self.perform_enqueued_at_jobs = false
-      end
-
       # Provides a store of all the enqueued jobs with the TestAdapter so you can check them.
       def enqueued_jobs
         @enqueued_jobs ||= []
@@ -30,22 +24,37 @@ module ActiveJob
       end
 
       def enqueue(job) #:nodoc:
-        if perform_enqueued_jobs
-          performed_jobs << {job: job.class, args: job.serialize['arguments'], queue: job.queue_name}
-          Base.execute job.serialize
-        else
-          enqueued_jobs << {job: job.class, args: job.serialize['arguments'], queue: job.queue_name}
-        end
+        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:
-        if perform_enqueued_at_jobs
-          performed_jobs << {job: job.class, args: job.serialize['arguments'], queue: job.queue_name, at: timestamp}
+        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: job.class, args: job.serialize['arguments'], queue: job.queue_name, at: timestamp}
+          enqueued_jobs << job_data
         end
       end
+
+      def filtered?(job)
+        filter && !Array(filter).include?(job.class)
+      end
     end
   end
 end

data/lib/active_job/queue_name.rb

@@ -39,7 +39,7 @@ module ActiveJob
       self.queue_name_delimiter = '_' # set default delimiter to '_'
     end
 
-    # Returns the name of the queue the job will be run on
+    # 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))

data/lib/active_job/queue_priority.rb

@@ -0,0 +1,44 @@
+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
+
+      self.priority = 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/test_helper.rb

@@ -1,3 +1,4 @@
+require 'active_support/core_ext/class/subclasses'
 require 'active_support/core_ext/hash/keys'
 
 module ActiveJob
@@ -6,17 +7,28 @@ module ActiveJob
     extend ActiveSupport::Concern
 
     included do
-      def before_setup
-        @old_queue_adapter  = queue_adapter
-        ActiveJob::Base.queue_adapter = :test
+      def before_setup # :nodoc:
+        test_adapter = ActiveJob::QueueAdapters::TestAdapter.new
+
+        @old_queue_adapters = (ActiveJob::Base.subclasses << 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.map do |klass|
+          [klass, klass.queue_adapter].tap do
+            klass.queue_adapter = test_adapter
+          end
+        end
+
         clear_enqueued_jobs
         clear_performed_jobs
         super
       end
 
-      def after_teardown
+      def after_teardown # :nodoc:
         super
-        ActiveJob::Base.queue_adapter = @old_queue_adapter
+        @old_queue_adapters.each do |(klass, adapter)|
+          klass.queue_adapter = adapter
+        end
       end
 
       # Asserts that the number of enqueued jobs matches the given number.
@@ -42,16 +54,24 @@ module ActiveJob
       #       HelloJob.perform_later('rafael')
       #     end
       #   end
-      def assert_enqueued_jobs(number)
+      #
+      # The number of times a specific job is enqueued can be asserted.
+      #
+      #   def test_logging_job
+      #     assert_enqueued_jobs 2, only: LoggingJob do
+      #       LoggingJob.perform_later
+      #       HelloJob.perform_later('jeremy')
+      #     end
+      #   end
+      def assert_enqueued_jobs(number, only: nil)
         if block_given?
-          original_count = enqueued_jobs.size
+          original_count = enqueued_jobs_size(only: only)
           yield
-          new_count = enqueued_jobs.size
-          assert_equal number, new_count - original_count,
-                       "#{number} jobs expected, but #{new_count - original_count} were enqueued"
+          new_count = enqueued_jobs_size(only: only)
+          assert_equal number, new_count - original_count, "#{number} jobs expected, but #{new_count - original_count} were enqueued"
         else
-          enqueued_jobs_size = enqueued_jobs.size
-          assert_equal number, enqueued_jobs_size, "#{number} jobs expected, but #{enqueued_jobs_size} were enqueued"
+          actual_count = enqueued_jobs_size(only: only)
+          assert_equal number, actual_count, "#{number} jobs expected, but #{actual_count} were enqueued"
         end
       end
 
@@ -71,11 +91,19 @@ module ActiveJob
       #     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
+      #
       # Note: This assertion is simply a shortcut for:
       #
       #   assert_enqueued_jobs 0, &block
-      def assert_no_enqueued_jobs(&block)
-        assert_enqueued_jobs 0, &block
+      def assert_no_enqueued_jobs(only: nil, &block)
+        assert_enqueued_jobs 0, only: only, &block
       end
 
       # Asserts that the number of performed jobs matches the given number.
@@ -109,10 +137,32 @@ module ActiveJob
       #       HelloJob.perform_later('sean')
       #     end
       #   end
-      def assert_performed_jobs(number)
+      #
+      # 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
+      #
+      # 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)
         if block_given?
           original_count = performed_jobs.size
-          perform_enqueued_jobs { yield }
+          perform_enqueued_jobs(only: only) { yield }
           new_count = performed_jobs.size
           assert_equal number, new_count - original_count,
                        "#{number} jobs expected, but #{new_count - original_count} were performed"
@@ -141,11 +191,33 @@ module ActiveJob
       #     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
+      #
+      # 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
+      #
       # Note: This assertion is simply a shortcut for:
       #
       #   assert_performed_jobs 0, &block
-      def assert_no_performed_jobs(&block)
-        assert_performed_jobs 0, &block
+      def assert_no_performed_jobs(only: nil, &block)
+        assert_performed_jobs 0, only: only, &block
       end
 
       # Asserts that the job passed in the block has been enqueued with the given arguments.
@@ -154,19 +226,22 @@ module ActiveJob
       #     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(args = {}, &_block)
-        original_enqueued_jobs = enqueued_jobs.dup
-        clear_enqueued_jobs
+      def assert_enqueued_with(args = {})
+        original_enqueued_jobs_count = enqueued_jobs.count
         args.assert_valid_keys(:job, :args, :at, :queue)
         serialized_args = serialize_args_for_assertion(args)
         yield
-        matching_job = enqueued_jobs.any? do |job|
+        in_block_jobs = enqueued_jobs.drop(original_enqueued_jobs_count)
+        matching_job = in_block_jobs.find do |job|
           serialized_args.all? { |key, value| value == job[key] }
         end
         assert matching_job, "No enqueued job found with #{args}"
-      ensure
-        queue_adapter.enqueued_jobs = original_enqueued_jobs + enqueued_jobs
+        instantiate_job(matching_job)
       end
 
       # Asserts that the job passed in the block has been performed with the given arguments.
@@ -175,30 +250,39 @@ module ActiveJob
       #     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(args = {}, &_block)
-        original_performed_jobs = performed_jobs.dup
-        clear_performed_jobs
+      def assert_performed_with(args = {})
+        original_performed_jobs_count = performed_jobs.count
         args.assert_valid_keys(:job, :args, :at, :queue)
         serialized_args = serialize_args_for_assertion(args)
         perform_enqueued_jobs { yield }
-        matching_job = performed_jobs.any? do |job|
+        in_block_jobs = performed_jobs.drop(original_performed_jobs_count)
+        matching_job = in_block_jobs.find do |job|
           serialized_args.all? { |key, value| value == job[key] }
         end
         assert matching_job, "No performed job found with #{args}"
-      ensure
-        queue_adapter.performed_jobs = original_performed_jobs + performed_jobs
+        instantiate_job(matching_job)
       end
 
-      def perform_enqueued_jobs
-        @old_perform_enqueued_jobs = queue_adapter.perform_enqueued_jobs
-        @old_perform_enqueued_at_jobs = queue_adapter.perform_enqueued_at_jobs
-        queue_adapter.perform_enqueued_jobs = true
-        queue_adapter.perform_enqueued_at_jobs = true
-        yield
-      ensure
-        queue_adapter.perform_enqueued_jobs = @old_perform_enqueued_jobs
-        queue_adapter.perform_enqueued_at_jobs = @old_perform_enqueued_at_jobs
+      def perform_enqueued_jobs(only: nil)
+        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
+
+        begin
+          queue_adapter.perform_enqueued_jobs = true
+          queue_adapter.perform_enqueued_at_jobs = true
+          queue_adapter.filter = only
+          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
+        end
       end
 
       def queue_adapter
@@ -210,20 +294,34 @@ module ActiveJob
                to: :queue_adapter
 
       private
-        def clear_enqueued_jobs
+        def clear_enqueued_jobs # :nodoc:
           enqueued_jobs.clear
         end
 
-        def clear_performed_jobs
+        def clear_performed_jobs # :nodoc:
           performed_jobs.clear
         end
 
-        def serialize_args_for_assertion(args)
-          serialized_args = args.dup
-          if job_args = serialized_args.delete(:args)
-            serialized_args[:args] = ActiveJob::Arguments.serialize(job_args)
+        def enqueued_jobs_size(only: nil) # :nodoc:
+          if only
+            enqueued_jobs.count { |job| Array(only).include?(job.fetch(:job)) }
+          else
+            enqueued_jobs.count
           end
-          serialized_args
+        end
+
+        def serialize_args_for_assertion(args) # :nodoc:
+          args.dup.tap do |serialized_args|
+            serialized_args[:args] = ActiveJob::Arguments.serialize(serialized_args[:args]) if serialized_args[:args]
+            serialized_args[:at]   = serialized_args[:at].to_f if serialized_args[:at]
+          end
+        end
+
+        def instantiate_job(payload) # :nodoc:
+          job = payload[:job].new(*payload[:args])
+          job.scheduled_at = Time.at(payload[:at]) if payload.key?(:at)
+          job.queue_name = payload[:queue]
+          job
         end
     end
   end