断言已入队的作业数量与给定数量匹配。

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 of 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 of 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 of 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。传递 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 of 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 将仅执行块。

访问由 ActiveJob::Base 设置的 queue_adapter。

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 相同的接口。