$LOAD_PATH.unshift File.expand_path("lib")
require 'backburner'
require 'tempfile'
require 'minitest/autorun'
require_relative '../fixtures/test_jobs'

begin
  require 'mocha/setup'
rescue LoadError
  require 'mocha'
end

# Configure Backburner
Backburner.configure do |config|
  config.allq_url = "allq://127.0.0.1:8090"
  config.tube_namespace = "demo.test"
  config.on_error            = lambda { |e| puts e }
end

def clear_jobs!(*tube_names)
  connection = allq_connection
  tube_names.each do |tube_name|
    expanded_name = [Backburner.configuration.tube_namespace, tube_name].join(".")
    connection.clear(expanded_name)
  end
ensure
  connection.close if connection
end

def allq_connection
  Backburner::Connection.new(Backburner.configuration.allq_url)
end

module Kernel
  # Redirect standard out, standard error and the buffered logger for sprinkle to StringIO
  # capture_stdout { any_commands; you_want } => "all output from the commands"
  def capture_stdout
    if ENV['DEBUG'] # Skip if debug mode
      yield
      return ""
    end

    out = StringIO.new
    $stdout = out
    $stderr = out
    yield
    return out.string
  ensure
    $stdout = STDOUT
    $stderr = STDERR
  end
end

def sleeper(duration_in_seconds)
  1.upto(duration_in_seconds) do |i|
    sleep(1)
    print '.'
  end
end

# pop_one_job(tube_name)
def pop_one_job(tube_name=Backburner.configuration.primary_queue)
  tube_name  = [Backburner.configuration.tube_namespace, tube_name].join(".")
  connection = allq_connection
  silenced(3) { @res = connection.get(tube_name)}
  data = nil
  data = Backburner.configuration.job_parser_proc.call(@res.body) if @res && @res.body
  yield @res, data
ensure
  connection.close if connection
end

# def work_one_job(tube_name=Backburner.configuration.primary_queue)
#   tube_name  = [Backburner.configuration.tube_namespace, tube_name].join(".")
#   connection = allq_connection
#   job = Backburner::Worker.work_one_job(connection, tube_name)
#   job.delete
# end

def assert_same_elements(a1, a2, msg = nil)
  [:select, :inject, :size].each do |m|
    [a1, a2].each {|a| assert_respond_to(a, m, "Are you sure that #{a.inspect} is an array?  It doesn't respond to #{m}.") }
  end

  assert a1h = a1.inject({}) { |h,e| h[e] ||= a1.select { |i| i == e }.size; h }
  assert a2h = a2.inject({}) { |h,e| h[e] ||= a2.select { |i| i == e }.size; h }

  assert_equal(a1h, a2h, msg)
end

#   assert_contains(['a', '1'], /\d/) => passes
#   assert_contains(['a', '1'], 'a') => passes
#   assert_contains(['a', '1'], /not there/) => fails
def assert_contains(collection, x, extra_msg = "")
  collection = [collection] unless collection.is_a?(Array)
  msg = "#{x.inspect} not found in #{collection.to_a.inspect} #{extra_msg}"
  case x
  when Regexp
    assert(collection.detect { |e| e =~ x }, msg)
  else
    assert(collection.include?(x), msg)
  end
end

# silenced(5) { ... }
def silenced(time=3, &block)
  Timeout::timeout(time) { capture_stdout(&block) }
end