module ActiveJob::TestHelper

def after_teardown # :nodoc:
  super
  queue_adapter_changed_jobs.each { |klass| klass.disable_test_adapter }
end

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

def assert_enqueued_with(job: nil, args: nil, at: nil, queue: nil)
  original_enqueued_jobs_count = enqueued_jobs.count
  expected = { job: job, args: args, at: at, queue: queue }.compact
  expected_args = prepare_args_for_assertion(expected)
  yield
  in_block_jobs = enqueued_jobs.drop(original_enqueued_jobs_count)
  matching_job = in_block_jobs.find do |in_block_job|
    deserialized_job = deserialize_args_for_assertion(in_block_job)
    expected_args.all? { |key, value| value == deserialized_job[key] }
  end
  assert matching_job, "No enqueued job found with #{expected}"
  instantiate_job(matching_job)
end

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

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

def assert_performed_jobs(number, only: nil, except: nil)
  if block_given?
    original_count = performed_jobs.size
    perform_enqueued_jobs(only: only, except: except) { 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(job: nil, args: nil, at: nil, queue: nil)
  original_performed_jobs_count = performed_jobs.count
  expected = { job: job, args: args, at: at, queue: queue }.compact
  expected_args = prepare_args_for_assertion(expected)
  perform_enqueued_jobs { yield }
  in_block_jobs = performed_jobs.drop(original_performed_jobs_count)
  matching_job = in_block_jobs.find do |in_block_job|
    deserialized_job = deserialize_args_for_assertion(in_block_job)
    expected_args.all? { |key, value| value == deserialized_job[key] }
  end
  assert matching_job, "No performed job found with #{expected}"
  instantiate_job(matching_job)
end

def before_setup # :nodoc:
  test_adapter = queue_adapter_for_test
  queue_adapter_changed_jobs.each do |klass|
    klass.enable_test_adapter(test_adapter)
  end
  clear_enqueued_jobs
  clear_performed_jobs
  super
end

def clear_enqueued_jobs
  enqueued_jobs.clear
end

def clear_performed_jobs
  performed_jobs.clear
end

def deserialize_args_for_assertion(job)
  job.dup.tap do |new_job|
    new_job[:args] = ActiveJob::Arguments.deserialize(new_job[:args]) if new_job[:args]
  end
end

def enqueued_jobs_size(only: nil, except: nil, queue: nil)
  validate_option(only: only, except: except)
  enqueued_jobs.count do |job|
    job_class = job.fetch(:job)
    if only
      next false unless Array(only).include?(job_class)
    elsif except
      next false if Array(except).include?(job_class)
    end
    if queue
      next false unless queue.to_s == job.fetch(:queue, job_class.queue_name)
    end
    true
  end
end

def instantiate_job(payload)
  args = ActiveJob::Arguments.deserialize(payload[:args])
  job = payload[:job].new(*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, except: nil)
  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
  begin
    queue_adapter.perform_enqueued_jobs = true
    queue_adapter.perform_enqueued_at_jobs = true
    queue_adapter.filter = only
    queue_adapter.reject = except
    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
    queue_adapter.reject = old_reject
  end
end

def prepare_args_for_assertion(args)
  args.dup.tap do |arguments|
    arguments[:at] = arguments[:at].to_f if arguments[:at]
  end
end

def queue_adapter
  ActiveJob::Base.queue_adapter
end

def queue_adapter_changed_jobs
  (ActiveJob::Base.descendants << 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
end

def queue_adapter_for_test
  ActiveJob::QueueAdapters::TestAdapter.new
end

def validate_option(only: nil, except: nil)
  raise ArgumentError, "Cannot specify both `:only` and `:except` options." if only && except
end