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

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选项接受类、数组的类或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选项接受类、数组的类或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, ...)的快捷方式。

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选项接受类、数组的类或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_enqueued_jobs(0, ...)的快捷方式。

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选项接受类、数组的类或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相同的接口。