断言已排队的作业数与给定数目相符。

def test_jobs
  assert_enqueued_jobs 0
  HelloJob.perform_later('david')
  assert_enqueued_jobs 1
  HelloJob.perform_later('abdelkader')
  assert_enqueued_jobs 2
end

如果传递了一个块，则断言该块将导致排队指定数量的作业。

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

通过传递 :only 选项，断言特定作业被排队的次数。

def test_logging_job
  assert_enqueued_jobs 1, only: LoggingJob do
    LoggingJob.perform_later
    HelloJob.perform_later('jeremy')
  end
end

通过传递 :except 选项，断言除了特定类之外的作业被排队的次数。

def test_logging_job
  assert_enqueued_jobs 1, except: HelloJob do
    LoggingJob.perform_later
    HelloJob.perform_later('jeremy')
  end
end

:only 和 :except 选项接受 Class、Array 的 Class 或 Proc。当传递一个 Proc 时，将传递包含作业类及其参数的哈希作为参数。

通过传递 :queue 选项，断言作业被排队到特定队列的次数。

def test_logging_job
  assert_enqueued_jobs 2, queue: 'default' do
    LoggingJob.perform_later
    HelloJob.perform_later('elfassy')
  end
end

断言作业已使用给定的参数排队。

def test_assert_enqueued_with
  MyJob.perform_later(1,2,3)
  assert_enqueued_with(job: MyJob, args: [1,2,3])

  MyJob.set(wait_until: Date.tomorrow.noon, queue: "my_queue").perform_later
  assert_enqueued_with(at: Date.tomorrow.noon, queue: "my_queue")
end

对于关键字参数，将它们指定为数组中的哈希

def test_assert_enqueued_with_keyword_arguments
  MyJob.perform_later(arg1: 'value1', arg2: 'value2')
  assert_enqueued_with(job: MyJob, args: [{ arg1: 'value1', arg2: 'value2' }])
end

给定的参数也可以指定为匹配器 proc，该 proc 返回布尔值，指示作业的属性是否满足某些条件。

例如，可以使用 proc 来匹配时间范围

def test_assert_enqueued_with
  at_matcher = ->(job_at) { (Date.yesterday..Date.tomorrow).cover?(job_at) }

  MyJob.set(wait_until: Date.today.noon).perform_later

  assert_enqueued_with(job: MyJob, at: at_matcher)
end

还可以使用 proc 来匹配作业参数的子集

def test_assert_enqueued_with
  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: args_matcher)
end

如果传递了一个块，则断言该块将导致作业使用给定的参数排队。

def test_assert_enqueued_with
  assert_enqueued_with(job: MyJob, args: [1,2,3]) 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 test_jobs
  assert_no_enqueued_jobs
  HelloJob.perform_later('jeremy')
  assert_enqueued_jobs 1
end

如果传递了一个块，则断言该块不会导致任何作业排队。

def test_jobs_again
  assert_no_enqueued_jobs do
    # No job should be enqueued from this block
  end
end

通过传递 :only 选项，断言没有特定类型的作业排队。

def test_no_logging
  assert_no_enqueued_jobs only: LoggingJob do
    HelloJob.perform_later('jeremy')
  end
end

通过传递 :except 选项，断言除了特定类之外没有作业入队。

def test_no_logging
  assert_no_enqueued_jobs except: HelloJob do
    HelloJob.perform_later('jeremy')
  end
end

:only 和 :except 选项接受 Class、Array 的 Class 或 Proc。当传递一个 Proc 时，将传递包含作业类及其参数的哈希作为参数。

通过传递 :queue 选项，断言没有作业入队到特定队列

def test_no_logging
  assert_no_enqueued_jobs queue: 'default' do
    LoggingJob.set(queue: :some_queue).perform_later
  end
end

注意：此断言只是以下内容的快捷方式

assert_enqueued_jobs 0, &block

断言没有执行任何作业。

def test_jobs
  assert_no_performed_jobs

  perform_enqueued_jobs do
    HelloJob.perform_later('matthew')
    assert_performed_jobs 1
  end
end

如果传递了一个块，则断言该块不会导致执行任何作业。

def test_jobs_again
  assert_no_performed_jobs do
    # No job should be performed from this block
  end
end

块形式支持过滤。如果指定了 :only 选项，则仅不会执行列出的作业。

def test_no_logging
  assert_no_performed_jobs only: LoggingJob do
    HelloJob.perform_later('jeremy')
  end
end

此外，如果指定了 :except 选项，则不会执行除特定类之外的作业。

def test_no_logging
  assert_no_performed_jobs except: HelloJob do
    HelloJob.perform_later('jeremy')
  end
end

:only 和 :except 选项接受 Class、Array 的 Class 或 Proc。当传递一个 Proc 时，作业的实例将作为参数传递。

如果指定了 :queue 选项，则仅不会执行入队到特定队列的作业。

def test_assert_no_performed_jobs_with_queue_option
  assert_no_performed_jobs queue: :some_queue do
    HelloJob.set(queue: :other_queue).perform_later("jeremy")
  end
end

注意：此断言只是以下内容的快捷方式

assert_performed_jobs 0, &block

断言已执行的作业数与给定的数字匹配。如果没有传递块，则必须在作业调用前后或周围调用 perform_enqueued_jobs。

def test_jobs
  assert_performed_jobs 0

  perform_enqueued_jobs do
    HelloJob.perform_later('xavier')
  end
  assert_performed_jobs 1

  HelloJob.perform_later('yves')

  perform_enqueued_jobs

  assert_performed_jobs 2
end

如果传递了一个块，则断言该块将导致执行指定数量的作业。

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

此方法还支持过滤。如果指定了 :only 选项，则仅执行列出的作业。

def test_hello_job
  assert_performed_jobs 1, only: HelloJob do
    HelloJob.perform_later('jeremy')
    LoggingJob.perform_later
  end
end

此外，如果指定了 :except 选项，则将执行除特定类之外的作业。

def test_hello_job
  assert_performed_jobs 1, except: LoggingJob do
    HelloJob.perform_later('jeremy')
    LoggingJob.perform_later
  end
end

还可以指定一个数组来支持测试多个作业。

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

还可以指定一个过程。当传递一个 Proc 时，作业的实例将作为参数传递。

def test_hello_and_logging_jobs
  assert_nothing_raised do
    assert_performed_jobs(1, only: ->(job) { job.is_a?(HelloJob) }) do
      HelloJob.perform_later('jeremy')
      LoggingJob.perform_later('stewie')
      RescueJob.perform_later('david')
    end
  end
end

如果指定了 :queue 选项，则仅执行入队到特定队列的作业。

def test_assert_performed_jobs_with_queue_option
  assert_performed_jobs 1, queue: :some_queue do
    HelloJob.set(queue: :some_queue).perform_later("jeremy")
    HelloJob.set(queue: :other_queue).perform_later("bogdan")
  end
end

断言作业已使用给定的参数执行。

def test_assert_performed_with
  MyJob.perform_later(1,2,3)

  perform_enqueued_jobs

  assert_performed_with(job: MyJob, args: [1,2,3])

  MyJob.set(wait_until: Date.tomorrow.noon, queue: "my_queue").perform_later

  perform_enqueued_jobs

  assert_performed_with(at: Date.tomorrow.noon, queue: "my_queue")
end

给定的参数也可以指定为匹配器 proc，该 proc 返回布尔值，指示作业的属性是否满足某些条件。

例如，可以使用 proc 来匹配时间范围

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

  perform_enqueued_jobs

  assert_performed_with(job: MyJob, at: at_matcher)
end

还可以使用 proc 来匹配作业参数的子集

def test_assert_performed_with
  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: args_matcher)
end

如果传递了一个块，则该块执行在块的持续时间内排队的全部作业，并断言作业已在块中使用给定的参数执行。

def test_assert_performed_with
  assert_performed_with(job: MyJob, args: [1,2,3]) 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 test_perform_enqueued_jobs
  perform_enqueued_jobs do
    MyJob.perform_later(1, 2, 3)
  end
  assert_performed_jobs 1
end

def test_perform_enqueued_jobs_without_block
  MyJob.perform_later(1, 2, 3)

  perform_enqueued_jobs

  assert_performed_jobs 1
end

此方法还支持过滤。如果指定了 :only 选项，则仅执行列出的作业。

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

此外，如果指定了 :except 选项，则将执行除特定类之外的作业。

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

:only 和 :except 选项接受 Class、Array 的 Class 或 Proc。当传递一个 Proc 时，作业的实例将作为参数传递。

如果指定了 :queue 选项，则仅执行入队到特定队列的作业。

def test_perform_enqueued_jobs_with_queue
  perform_enqueued_jobs queue: :some_queue do
    MyJob.set(queue: :some_queue).perform_later(1, 2, 3) # will be performed
    HelloJob.set(queue: :other_queue).perform_later(1, 2, 3) # will not be performed
  end
  assert_performed_jobs 1
end

如果指定了 :at 选项，则仅执行已排队在给定时间或之前运行的作业。这包括未排队时间的作业。

如果覆盖 queue_adapter_for_test 以返回一个不同的适配器，则 perform_enqueued_jobs 将仅仅执行块。

访问 queue_adapter 由 ActiveJob::Base 设置。

def test_assert_job_has_custom_queue_adapter_set
  assert_instance_of CustomQueueAdapter, HelloJob.queue_adapter
end

返回一个队列适配器实例，用于全部 Active Job 测试助手。默认情况下，返回 ActiveJob::QueueAdapters::TestAdapter 的一个实例。覆盖此方法以指定一个不同的适配器。适配器必须实现与 ActiveJob::QueueAdapters::TestAdapter 相同的接口。