module ActiveJob::TestHelper

def after_teardown # :nodoc:
  super
  @old_queue_adapters.each do |(klass, adapter)|
    klass.queue_adapter = adapter
  end
end

def assert_enqueued_jobs(number, only: nil)
  if block_given?
    original_count = enqueued_jobs_size(only: only)
    yield
    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
    actual_count = enqueued_jobs_size(only: only)
    assert_equal number, actual_count, "#{number} jobs expected, but #{actual_count} were enqueued"
  end
end

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

def assert_no_enqueued_jobs(only: nil, &block)
  assert_enqueued_jobs 0, only: only, &block
end

def assert_no_performed_jobs(only: nil, &block)
  assert_performed_jobs 0, only: only, &block
end

def assert_performed_jobs(number, only: nil)
  if block_given?
    original_count = performed_jobs.size
    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"
  else
    performed_jobs_size = performed_jobs.size
    assert_equal number, performed_jobs_size, "#{number} jobs expected, but #{performed_jobs_size} were performed"
  end
end

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

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 clear_enqueued_jobs # :nodoc:
  enqueued_jobs.clear
end

def clear_performed_jobs # :nodoc:
  performed_jobs.clear
end

def enqueued_jobs_size(only: nil) # :nodoc:
  if only
    enqueued_jobs.count { |job| Array(only).include?(job.fetch(:job)) }
  else
    enqueued_jobs.count
  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

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
  ActiveJob::Base.queue_adapter
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