модуль ActiveJob::TestHelper

# File activejob/lib/active_job/test_helper.rb, line 123
def assert_enqueued_jobs(number, only: nil, except: nil, queue: nil, &block)
  if block_given?
    original_jobs = enqueued_jobs_with(only: only, except: except, queue: queue)

    _assert_nothing_raised_or_warn("assert_enqueued_jobs", &block)

    new_jobs = enqueued_jobs_with(only: only, except: except, queue: queue)

    actual_count = (new_jobs - original_jobs).count
  else
    actual_count = enqueued_jobs_with(only: only, except: except, queue: queue).count
  end

  assert_equal number, actual_count, "#{number} jobs expected, but #{actual_count} were enqueued"
end

Утверждает, что количество поставленных в очередь задач соответствует заданному числу.

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

# File activejob/lib/active_job/test_helper.rb, line 392
def assert_enqueued_with(job: nil, args: nil, at: nil, queue: nil, priority: nil, &block)
  expected = { job: job, args: args, at: at, queue: queue, priority: priority }.compact
  expected_args = prepare_args_for_assertion(expected)
  potential_matches = []

  if block_given?
    original_enqueued_jobs = enqueued_jobs.dup

    _assert_nothing_raised_or_warn("assert_enqueued_with", &block)

    jobs = enqueued_jobs - original_enqueued_jobs
  else
    jobs = enqueued_jobs
  end

  matching_job = jobs.find do |enqueued_job|
    deserialized_job = deserialize_args_for_assertion(enqueued_job)
    potential_matches << deserialized_job

    expected_args.all? do |key, value|
      if value.respond_to?(:call)
        value.call(deserialized_job[key])
      else
        value == deserialized_job[key]
      end
    end
  end

  matching_class = potential_matches.select do |enqueued_job|
    enqueued_job["job_class"] == job.to_s
  end

  message = +"No enqueued job found with #{expected}"
  if potential_matches.empty?
    message << "\n\nNo jobs were enqueued"
  elsif matching_class.empty?
    message << "\n\nNo jobs of class #{expected[:job]} were enqueued, job classes enqueued: "
    message << potential_matches.map { |job| job["job_class"] }.join(", ")
  else
    message << "\n\nPotential matches: #{matching_class.join("\n")}"
  end

  assert matching_job, message
  instantiate_job(matching_job)
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
  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

Прок также может использоваться для сопоставления подмножества аргументов задачи:

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

# File activejob/lib/active_job/test_helper.rb, line 185
def assert_no_enqueued_jobs(only: nil, except: nil, queue: nil, &block)
  assert_enqueued_jobs 0, only: only, except: except, queue: queue, &block
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

# File activejob/lib/active_job/test_helper.rb, line 343
def assert_no_performed_jobs(only: nil, except: nil, queue: nil, &block)
  assert_performed_jobs 0, only: only, except: except, queue: queue, &block
end

Утверждает, что задачи не были выполнены.

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

# File activejob/lib/active_job/test_helper.rb, line 275
def assert_performed_jobs(number, only: nil, except: nil, queue: nil, &block)
  if block_given?
    original_count = performed_jobs.size

    perform_enqueued_jobs(only: only, except: except, queue: queue, &block)

    new_count = performed_jobs.size

    performed_jobs_size = new_count - original_count
  else
    performed_jobs_size = performed_jobs_with(only: only, except: except, queue: queue).count
  end

  assert_equal number, performed_jobs_size, "#{number} jobs expected, but #{performed_jobs_size} were performed"
end

Утверждает, что количество выполненных заданий соответствует заданному числу. Если блок не передан, необходимо вызвать 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

Также может быть указана процедура. При передаче процедуры в качестве аргумента передаётся экземпляр задания.

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

# File activejob/lib/active_job/test_helper.rb, line 494
def assert_performed_with(job: nil, args: nil, at: nil, queue: nil, priority: nil, &block)
  expected = { job: job, args: args, at: at, queue: queue, priority: priority }.compact
  expected_args = prepare_args_for_assertion(expected)
  potential_matches = []

  if block_given?
    original_performed_jobs_count = performed_jobs.count

    perform_enqueued_jobs(&block)

    jobs = performed_jobs.drop(original_performed_jobs_count)
  else
    jobs = performed_jobs
  end

  matching_job = jobs.find do |enqueued_job|
    deserialized_job = deserialize_args_for_assertion(enqueued_job)
    potential_matches << deserialized_job

    expected_args.all? do |key, value|
      if value.respond_to?(:call)
        value.call(deserialized_job[key])
      else
        value == deserialized_job[key]
      end
    end
  end

  matching_class = potential_matches.select do |enqueued_job|
    enqueued_job["job_class"] == job.to_s
  end

  message = +"No performed job found with #{expected}"
  if potential_matches.empty?
    message << "\n\nNo jobs were performed"
  elsif matching_class.empty?
    message << "\n\nNo jobs of class #{expected[:job]} were performed, job classes performed: "
    message << potential_matches.map { |job| job["job_class"] }.join(", ")
  else
    message << "\n\nPotential matches: #{matching_class.join("\n")}"
  end

  assert matching_job, message

  instantiate_job(matching_job)
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

Указанные аргументы также могут быть заданы как процедура-матчер, которая возвращает логическое значение, указывающее, соответствует ли атрибут задания определённым критериям.

Например, процедура может использоваться для сопоставления диапазона времени:

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

Процедура также может использоваться для сопоставления подмножества аргументов задания:

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

# File activejob/lib/active_job/test_helper.rb, line 598
def perform_enqueued_jobs(only: nil, except: nil, queue: nil, at: nil, &block)
  return flush_enqueued_jobs(only: only, except: except, queue: queue, at: at) unless block_given?

  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
  old_queue = queue_adapter.queue
  old_at = queue_adapter.at

  begin
    queue_adapter.perform_enqueued_jobs = true
    queue_adapter.perform_enqueued_at_jobs = true
    queue_adapter.filter = only
    queue_adapter.reject = except
    queue_adapter.queue = queue
    queue_adapter.at = at

    _assert_nothing_raised_or_warn("perform_enqueued_jobs", &block)
  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
    queue_adapter.queue = old_queue
    queue_adapter.at = old_at
  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 или Процедуру. При передаче процедуры в качестве аргумента, передаётся экземпляр задания.

Если указан параметр :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, выполняются только задания, запланированные на немедленное выполнение или до указанного времени.

# File activejob/lib/active_job/test_helper.rb, line 634
def queue_adapter
  ActiveJob::Base.queue_adapter
end

Получает доступ к queue_adapter, заданному методом ActiveJob::Base.

def test_assert_job_has_custom_queue_adapter_set
  assert_instance_of CustomQueueAdapter, HelloJob.queue_adapter
end

# File activejob/lib/active_job/test_helper.rb, line 66
def queue_adapter_for_test
  ActiveJob::QueueAdapters::TestAdapter.new
end

Устанавливает адаптер очереди для использования со всеми вспомогательными методами тестирования Active Job.

Возвращает экземпляр адаптера очереди и по умолчанию использует ActiveJob::QueueAdapters::TestAdapter.

Примечание: адаптер, предоставляемый этим методом, должен предоставлять некоторые дополнительные методы, кроме тех, которые ожидаются от стандартного ActiveJob::QueueAdapter, для использования с вспомогательными методами тестирования Active Job. Обратитесь к ActiveJob::QueueAdapters::TestAdapter.