resque 1.26.pre.0 → 1.26.0

data/test/test_helper.rb

@@ -1,198 +0,0 @@
-require 'rubygems'
-require 'bundler/setup'
-require 'minitest/autorun'
-require 'redis/namespace'
-
-require 'mocha/setup'
-
-$dir = File.dirname(File.expand_path(__FILE__))
-$LOAD_PATH.unshift $dir + '/../lib'
-require 'resque'
-$TESTING = true
-$TEST_PID=Process.pid
-
-begin
-  require 'leftright'
-rescue LoadError
-end
-
-
-#
-# make sure we can run redis
-#
-
-if !system("which redis-server")
-  puts '', "** can't find `redis-server` in your path"
-  puts "** try running `sudo rake install`"
-  abort ''
-end
-
-
-#
-# start our own redis when the tests start,
-# kill it when they end
-#
-
-MiniTest::Unit.after_tests do
-  if Process.pid == $TEST_PID
-    processes = `ps -A -o pid,command | grep [r]edis-test`.split("\n")
-    pids = processes.map { |process| process.split(" ")[0] }
-    puts "Killing test redis server..."
-    pids.each { |pid| Process.kill("TERM", pid.to_i) }
-    system("rm -f #{$dir}/dump.rdb #{$dir}/dump-cluster.rdb")
-  end
-end
-
-if ENV.key? 'RESQUE_DISTRIBUTED'
-  require 'redis/distributed'
-  puts "Starting redis for testing at localhost:9736 and localhost:9737..."
-  `redis-server #{$dir}/redis-test.conf`
-  `redis-server #{$dir}/redis-test-cluster.conf`
-  r = Redis::Distributed.new(['redis://localhost:9736', 'redis://localhost:9737'])
-  Resque.redis = Redis::Namespace.new :resque, :redis => r
-else
-  puts "Starting redis for testing at localhost:9736..."
-  `redis-server #{$dir}/redis-test.conf`
-  Resque.redis = 'localhost:9736'
-end
-
-
-##
-# test/spec/mini 3
-# http://gist.github.com/25455
-# chris@ozmm.org
-#
-def context(*args, &block)
-  return super unless (name = args.first) && block
-  require 'test/unit'
-  klass = Class.new(defined?(ActiveSupport::TestCase) ? ActiveSupport::TestCase : Test::Unit::TestCase) do
-    def self.test(name, &block)
-      define_method("test_#{name.gsub(/\W/,'_')}", &block) if block
-    end
-    def self.xtest(*args) end
-    def self.setup(&block) define_method(:setup, &block) end
-    def self.teardown(&block) define_method(:teardown, &block) end
-  end
-  (class << klass; self end).send(:define_method, :name) { name.gsub(/\W/,'_') }
-  klass.class_eval &block
-  # XXX: In 1.8.x, not all tests will run unless anonymous classes are kept in scope.
-  ($test_classes ||= []) << klass
-end
-
-##
-# Helper to perform job classes
-#
-module PerformJob
-  def perform_job(klass, *args)
-    resque_job = Resque::Job.new(:testqueue, 'class' => klass, 'args' => args)
-    resque_job.perform
-  end
-end
-
-#
-# fixture classes
-#
-
-class SomeJob
-  def self.perform(repo_id, path)
-  end
-end
-
-class SomeIvarJob < SomeJob
-  @queue = :ivar
-end
-
-class SomeMethodJob < SomeJob
-  def self.queue
-    :method
-  end
-end
-
-class BadJob
-  def self.perform
-    raise "Bad job!"
-  end
-end
-
-class GoodJob
-  def self.perform(name)
-    "Good job, #{name}"
-  end
-end
-
-class AtExitJob
-  def self.perform(filename)
-    at_exit do
-      File.open(filename, "w") {|file| file.puts "at_exit"}
-    end
-    "at_exit job"
-  end
-end
-
-class BadJobWithSyntaxError
-  def self.perform
-    raise SyntaxError, "Extra Bad job!"
-  end
-end
-
-class BadFailureBackend < Resque::Failure::Base
-  def save
-    raise Exception.new("Failure backend error")
-  end
-end
-
-def with_failure_backend(failure_backend, &block)
-  previous_backend = Resque::Failure.backend
-  Resque::Failure.backend = failure_backend
-  yield block
-ensure
-  Resque::Failure.backend = previous_backend
-end
-
-require 'time'
-
-class Time
-  # Thanks, Timecop
-  class << self
-    attr_accessor :fake_time
-
-    alias_method :now_without_mock_time, :now
-
-    def now
-      fake_time || now_without_mock_time
-    end
-  end
-
-  self.fake_time = nil
-end
-
-# From minitest/unit
-def capture_io
-  require 'stringio'
-
-  orig_stdout, orig_stderr         = $stdout, $stderr
-  captured_stdout, captured_stderr = StringIO.new, StringIO.new
-  $stdout, $stderr                 = captured_stdout, captured_stderr
-
-  yield
-
-  return captured_stdout.string, captured_stderr.string
-ensure
-  $stdout = orig_stdout
-  $stderr = orig_stderr
-end
-
-# Log to log/test.log
-def reset_logger
-  $test_logger ||= MonoLogger.new(File.open(File.expand_path("../../log/test.log", __FILE__), "w"))
-  Resque.logger = $test_logger
-end
-
-reset_logger
-
-def suppress_warnings
-  old_verbose, $VERBOSE = $VERBOSE, nil
-  yield
-ensure
-  $VERBOSE = old_verbose
-end

data/test/worker_test.rb

@@ -1,1015 +0,0 @@
-require 'test_helper'
-require 'tmpdir'
-
-context "Resque::Worker" do
-  setup do
-    Resque.redis.flushall
-
-    Resque.before_first_fork = nil
-    Resque.before_fork = nil
-    Resque.after_fork = nil
-
-    @worker = Resque::Worker.new(:jobs)
-    Resque::Job.create(:jobs, SomeJob, 20, '/tmp')
-  end
-
-  test "can fail jobs" do
-    Resque::Job.create(:jobs, BadJob)
-    @worker.work(0)
-    assert_equal 1, Resque::Failure.count
-  end
-
-  test "failed jobs report exception and message" do
-    Resque::Job.create(:jobs, BadJobWithSyntaxError)
-    @worker.work(0)
-    assert_equal('SyntaxError', Resque::Failure.all['exception'])
-    assert_equal('Extra Bad job!', Resque::Failure.all['error'])
-  end
-
-  test "does not allow exceptions from failure backend to escape" do
-    job = Resque::Job.new(:jobs, {})
-    with_failure_backend BadFailureBackend do
-      @worker.perform job
-    end
-  end
-
-  test "does not raise exception for completed jobs" do
-    if worker_pid = Kernel.fork
-      Process.waitpid(worker_pid)
-      assert_equal 0, Resque::Failure.count
-    else
-      # ensure we actually fork
-      $TESTING = false
-      Resque.redis.client.reconnect
-      worker = Resque::Worker.new(:jobs)
-      suppress_warnings do
-        worker.work(0)
-      end
-      exit
-    end
-  end
-
-  test "executes at_exit hooks when configured with run_at_exit_hooks" do
-    tmpfile = File.join(Dir.tmpdir, "resque_at_exit_test_file")
-    FileUtils.rm_f tmpfile
-
-    if worker_pid = Kernel.fork
-      Process.waitpid(worker_pid)
-      assert File.exist?(tmpfile), "The file '#{tmpfile}' does not exist"
-      assert_equal "at_exit", File.open(tmpfile).read.strip
-    else
-      # ensure we actually fork
-      $TESTING = false
-      Resque.redis.client.reconnect
-      Resque::Job.create(:at_exit_jobs, AtExitJob, tmpfile)
-      worker = Resque::Worker.new(:at_exit_jobs)
-      worker.run_at_exit_hooks = true
-      suppress_warnings do
-        worker.work(0)
-      end
-      exit
-    end
-
-  end
-
-  class ::RaiseExceptionOnFailure
-
-    def self.on_failure_trhow_exception(exception,*args)
-      $TESTING = true
-      raise "The worker threw an exception"
-    end
-
-    def self.perform
-      ""
-    end
-  end
-
-  test "should not treat SystemExit as an exception in the child with run_at_exit_hooks == true" do
-
-    if worker_pid = Kernel.fork
-      Process.waitpid(worker_pid)
-    else
-      # ensure we actually fork
-      $TESTING = false
-      Resque.redis.client.reconnect
-      Resque::Job.create(:not_failing_job, RaiseExceptionOnFailure)
-      worker = Resque::Worker.new(:not_failing_job)
-      worker.run_at_exit_hooks = true
-      suppress_warnings do
-        worker.work(0)
-      end
-      exit
-    end
-
-  end
-
-
-  test "does not execute at_exit hooks by default" do
-    tmpfile = File.join(Dir.tmpdir, "resque_at_exit_test_file")
-    FileUtils.rm_f tmpfile
-
-    if worker_pid = Kernel.fork
-      Process.waitpid(worker_pid)
-      assert !File.exist?(tmpfile), "The file '#{tmpfile}' exists, at_exit hooks were run"
-    else
-      # ensure we actually fork
-      $TESTING = false
-      Resque.redis.client.reconnect
-      Resque::Job.create(:at_exit_jobs, AtExitJob, tmpfile)
-      worker = Resque::Worker.new(:at_exit_jobs)
-      suppress_warnings do
-        worker.work(0)
-      end
-      exit
-    end
-
-  end
-
-  test "does report failure for jobs with invalid payload" do
-    job = Resque::Job.new(:jobs, { 'class' => 'NotAValidJobClass', 'args' => '' })
-    @worker.perform job
-    assert_equal 1, Resque::Failure.count, 'failure not reported'
-  end
-
-  test "register 'run_at' time on UTC timezone in ISO8601 format" do
-    job = Resque::Job.new(:jobs, {'class' => 'GoodJob', 'args' => "blah"})
-    now = Time.now.utc.iso8601
-    @worker.working_on(job)
-    assert_equal now, @worker.processing['run_at']
-  end
-
-  test "fails uncompleted jobs with DirtyExit by default on exit" do
-    job = Resque::Job.new(:jobs, {'class' => 'GoodJob', 'args' => "blah"})
-    @worker.working_on(job)
-    @worker.unregister_worker
-    assert_equal 1, Resque::Failure.count
-    assert_equal('Resque::DirtyExit', Resque::Failure.all['exception'])
-  end
-
-  test "fails uncompleted jobs with worker exception on exit" do
-    job = Resque::Job.new(:jobs, {'class' => 'GoodJob', 'args' => "blah"})
-    @worker.working_on(job)
-    @worker.unregister_worker(StandardError.new)
-    assert_equal 1, Resque::Failure.count
-    assert_equal('StandardError', Resque::Failure.all['exception'])
-  end
-
-  class ::SimpleJobWithFailureHandling
-    def self.on_failure_record_failure(exception, *job_args)
-      @@exception = exception
-    end
-
-    def self.exception
-      @@exception
-    end
-  end
-
-  test "fails uncompleted jobs on exit, and calls failure hook" do
-    job = Resque::Job.new(:jobs, {'class' => 'SimpleJobWithFailureHandling', 'args' => ""})
-    @worker.working_on(job)
-    @worker.unregister_worker
-    assert_equal 1, Resque::Failure.count
-    assert(SimpleJobWithFailureHandling.exception.kind_of?(Resque::DirtyExit))
-  end
-
-  class ::SimpleFailingJob
-    @@exception_count = 0
-
-    def self.on_failure_record_failure(exception, *job_args)
-      @@exception_count += 1
-    end
-
-    def self.exception_count
-      @@exception_count
-    end
-
-    def self.perform
-      raise Exception.new
-    end
-  end
-
-  test "only calls failure hook once on exception" do
-    job = Resque::Job.new(:jobs, {'class' => 'SimpleFailingJob', 'args' => ""})
-    @worker.perform(job)
-    assert_equal 1, Resque::Failure.count
-    assert_equal 1, SimpleFailingJob.exception_count
-  end
-
-  test "can peek at failed jobs" do
-    10.times { Resque::Job.create(:jobs, BadJob) }
-    @worker.work(0)
-    assert_equal 10, Resque::Failure.count
-
-    assert_equal 10, Resque::Failure.all(0, 20).size
-  end
-
-  test "can clear failed jobs" do
-    Resque::Job.create(:jobs, BadJob)
-    @worker.work(0)
-    assert_equal 1, Resque::Failure.count
-    Resque::Failure.clear
-    assert_equal 0, Resque::Failure.count
-  end
-
-  test "catches exceptional jobs" do
-    Resque::Job.create(:jobs, BadJob)
-    Resque::Job.create(:jobs, BadJob)
-    @worker.process
-    @worker.process
-    @worker.process
-    assert_equal 2, Resque::Failure.count
-  end
-
-  test "strips whitespace from queue names" do
-    queues = "critical, high, low".split(',')
-    worker = Resque::Worker.new(*queues)
-    assert_equal %w( critical high low ), worker.queues
-  end
-
-  test "can work on multiple queues" do
-    Resque::Job.create(:high, GoodJob)
-    Resque::Job.create(:critical, GoodJob)
-
-    worker = Resque::Worker.new(:critical, :high)
-
-    worker.process
-    assert_equal 1, Resque.size(:high)
-    assert_equal 0, Resque.size(:critical)
-
-    worker.process
-    assert_equal 0, Resque.size(:high)
-  end
-
-  test "can work on all queues" do
-    Resque::Job.create(:high, GoodJob)
-    Resque::Job.create(:critical, GoodJob)
-    Resque::Job.create(:blahblah, GoodJob)
-
-    worker = Resque::Worker.new("*")
-
-    worker.work(0)
-    assert_equal 0, Resque.size(:high)
-    assert_equal 0, Resque.size(:critical)
-    assert_equal 0, Resque.size(:blahblah)
-  end
-
-  test "can work with wildcard at the end of the list" do
-    Resque::Job.create(:high, GoodJob)
-    Resque::Job.create(:critical, GoodJob)
-    Resque::Job.create(:blahblah, GoodJob)
-    Resque::Job.create(:beer, GoodJob)
-
-    worker = Resque::Worker.new(:critical, :high, "*")
-
-    worker.work(0)
-    assert_equal 0, Resque.size(:high)
-    assert_equal 0, Resque.size(:critical)
-    assert_equal 0, Resque.size(:blahblah)
-    assert_equal 0, Resque.size(:beer)
-  end
-
-  test "can work with wildcard at the middle of the list" do
-    Resque::Job.create(:high, GoodJob)
-    Resque::Job.create(:critical, GoodJob)
-    Resque::Job.create(:blahblah, GoodJob)
-    Resque::Job.create(:beer, GoodJob)
-
-    worker = Resque::Worker.new(:critical, "*", :high)
-
-    worker.work(0)
-    assert_equal 0, Resque.size(:high)
-    assert_equal 0, Resque.size(:critical)
-    assert_equal 0, Resque.size(:blahblah)
-    assert_equal 0, Resque.size(:beer)
-  end
-
-  test "processes * queues in alphabetical order" do
-    Resque::Job.create(:high, GoodJob)
-    Resque::Job.create(:critical, GoodJob)
-    Resque::Job.create(:blahblah, GoodJob)
-
-    worker = Resque::Worker.new("*")
-    processed_queues = []
-
-    worker.work(0) do |job|
-      processed_queues << job.queue
-    end
-
-    assert_equal %w( jobs high critical blahblah ).sort, processed_queues
-  end
-
-  test "works with globs" do
-    Resque::Job.create(:critical, GoodJob)
-    Resque::Job.create(:test_one, GoodJob)
-    Resque::Job.create(:test_two, GoodJob)
-
-    worker = Resque::Worker.new("test_*")
-
-    worker.work(0)
-    assert_equal 1, Resque.size(:critical)
-    assert_equal 0, Resque.size(:test_one)
-    assert_equal 0, Resque.size(:test_two)
-  end
-
-  test "has a unique id" do
-    assert_equal "#{`hostname`.chomp}:#{$$}:jobs", @worker.to_s
-  end
-
-  test "complains if no queues are given" do
-    assert_raise Resque::NoQueueError do
-      Resque::Worker.new
-    end
-  end
-
-  test "fails if a job class has no `perform` method" do
-    worker = Resque::Worker.new(:perform_less)
-    Resque::Job.create(:perform_less, Object)
-
-    assert_equal 0, Resque::Failure.count
-    worker.work(0)
-    assert_equal 1, Resque::Failure.count
-  end
-
-  test "inserts itself into the 'workers' list on startup" do
-    @worker.work(0) do
-      assert_equal @worker, Resque.workers[0]
-    end
-  end
-
-  test "removes itself from the 'workers' list on shutdown" do
-    @worker.work(0) do
-      assert_equal @worker, Resque.workers[0]
-    end
-
-    assert_equal [], Resque.workers
-  end
-
-  test "removes worker with stringified id" do
-    @worker.work(0) do
-      worker_id = Resque.workers[0].to_s
-      Resque.remove_worker(worker_id)
-      assert_equal [], Resque.workers
-    end
-  end
-
-  test "records what it is working on" do
-    @worker.work(0) do
-      task = @worker.job
-      assert_equal({"args"=>[20, "/tmp"], "class"=>"SomeJob"}, task['payload'])
-      assert task['run_at']
-      assert_equal 'jobs', task['queue']
-    end
-  end
-
-  test "clears its status when not working on anything" do
-    @worker.work(0)
-    assert_equal Hash.new, @worker.job
-  end
-
-  test "knows when it is working" do
-    @worker.work(0) do
-      assert @worker.working?
-    end
-  end
-
-  test "knows when it is idle" do
-    @worker.work(0)
-    assert @worker.idle?
-  end
-
-  test "knows who is working" do
-    @worker.work(0) do
-      assert_equal [@worker], Resque.working
-    end
-  end
-
-  test "keeps track of how many jobs it has processed" do
-    Resque::Job.create(:jobs, BadJob)
-    Resque::Job.create(:jobs, BadJob)
-
-    3.times do
-      job = @worker.reserve
-      @worker.process job
-    end
-    assert_equal 3, @worker.processed
-  end
-
-  test "keeps track of how many failures it has seen" do
-    Resque::Job.create(:jobs, BadJob)
-    Resque::Job.create(:jobs, BadJob)
-
-    3.times do
-      job = @worker.reserve
-      @worker.process job
-    end
-    assert_equal 2, @worker.failed
-  end
-
-  test "stats are erased when the worker goes away" do
-    @worker.work(0)
-    assert_equal 0, @worker.processed
-    assert_equal 0, @worker.failed
-  end
-
-  test "knows when it started" do
-    time = Time.now
-    @worker.work(0) do
-      assert Time.parse(@worker.started) - time < 0.1
-    end
-  end
-
-  test "knows whether it exists or not" do
-    @worker.work(0) do
-      assert Resque::Worker.exists?(@worker)
-      assert !Resque::Worker.exists?('blah-blah')
-    end
-  end
-
-  test "sets $0 while working" do
-    @worker.work(0) do
-      ver = Resque::Version
-      assert_equal "resque-#{ver}: Processing jobs since #{Time.now.to_i}", $0
-    end
-  end
-
-  test "can be found" do
-    @worker.work(0) do
-      found = Resque::Worker.find(@worker.to_s)
-      assert_equal @worker.to_s, found.to_s
-      assert found.working?
-      assert_equal @worker.job, found.job
-    end
-  end
-
-  test "doesn't find fakes" do
-    @worker.work(0) do
-      found = Resque::Worker.find('blah-blah')
-      assert_equal nil, found
-    end
-  end
-
-  test "cleans up dead worker info on start (crash recovery)" do
-    # first we fake out several dead workers
-    # 1: matches queue and hostname; gets pruned.
-    workerA = Resque::Worker.new(:jobs)
-    workerA.instance_variable_set(:@to_s, "#{`hostname`.chomp}:1:jobs")
-    workerA.register_worker
-
-    # 2. matches queue but not hostname; no prune.
-    workerB = Resque::Worker.new(:jobs)
-    workerB.instance_variable_set(:@to_s, "#{`hostname`.chomp}-foo:2:jobs")
-    workerB.register_worker
-
-    # 3. matches hostname but not queue; no prune.
-    workerB = Resque::Worker.new(:high)
-    workerB.instance_variable_set(:@to_s, "#{`hostname`.chomp}:3:high")
-    workerB.register_worker
-
-    # 4. matches neither hostname nor queue; no prune.
-    workerB = Resque::Worker.new(:high)
-    workerB.instance_variable_set(:@to_s, "#{`hostname`.chomp}-foo:4:high")
-    workerB.register_worker
-
-    assert_equal 4, Resque.workers.size
-
-    # then we prune them
-    @worker.work(0)
-
-    worker_strings = Resque::Worker.all.map(&:to_s)
-
-    assert_equal 3, Resque.workers.size
-
-    # pruned
-    assert !worker_strings.include?("#{`hostname`.chomp}:1:jobs")
-
-    # not pruned
-    assert worker_strings.include?("#{`hostname`.chomp}-foo:2:jobs")
-    assert worker_strings.include?("#{`hostname`.chomp}:3:high")
-    assert worker_strings.include?("#{`hostname`.chomp}-foo:4:high")
-  end
-
-  test "worker_pids returns pids" do
-    known_workers = @worker.worker_pids
-    assert !known_workers.empty?
-  end
-
-  test "Processed jobs count" do
-    @worker.work(0)
-    assert_equal 1, Resque.info[:processed]
-  end
-
-  test "Will call a before_first_fork hook only once" do
-    Resque.redis.flushall
-    $BEFORE_FORK_CALLED = 0
-    Resque.before_first_fork = Proc.new { $BEFORE_FORK_CALLED += 1 }
-    workerA = Resque::Worker.new(:jobs)
-    Resque::Job.create(:jobs, SomeJob, 20, '/tmp')
-
-    assert_equal 0, $BEFORE_FORK_CALLED
-
-    workerA.work(0)
-    assert_equal 1, $BEFORE_FORK_CALLED
-
-    # TODO: Verify it's only run once. Not easy.
-#     workerA.work(0)
-#     assert_equal 1, $BEFORE_FORK_CALLED
-  end
-
-  test "Will call a before_fork hook before forking" do
-    Resque.redis.flushall
-    $BEFORE_FORK_CALLED = false
-    Resque.before_fork = Proc.new { $BEFORE_FORK_CALLED = true }
-    workerA = Resque::Worker.new(:jobs)
-
-    assert !$BEFORE_FORK_CALLED
-    Resque::Job.create(:jobs, SomeJob, 20, '/tmp')
-    workerA.work(0)
-    assert $BEFORE_FORK_CALLED
-  end
-
-  test "Will not call a before_fork hook when the worker can't fork" do
-    Resque.redis.flushall
-    $BEFORE_FORK_CALLED = false
-    Resque.before_fork = Proc.new { $BEFORE_FORK_CALLED = true }
-    workerA = Resque::Worker.new(:jobs)
-    workerA.cant_fork = true
-
-    assert !$BEFORE_FORK_CALLED, "before_fork should not have been called before job runs"
-    Resque::Job.create(:jobs, SomeJob, 20, '/tmp')
-    workerA.work(0)
-    assert !$BEFORE_FORK_CALLED, "before_fork should not have been called after job runs"
-  end
-
-  test "setting verbose to true" do
-    @worker.verbose = true
-
-    assert @worker.verbose
-    assert !@worker.very_verbose
-  end
-
-  test "setting verbose to false" do
-    @worker.verbose = false
-
-    assert !@worker.verbose
-    assert !@worker.very_verbose
-  end
-
-  test "setting very_verbose to true" do
-    @worker.very_verbose = true
-
-    assert !@worker.verbose
-    assert @worker.very_verbose
-  end
-
-  test "setting setting verbose to true and then very_verbose to false" do
-    @worker.very_verbose = true
-    @worker.verbose      = true
-    @worker.very_verbose = false
-
-    assert @worker.verbose
-    assert !@worker.very_verbose
-  end
-
-  test "verbose prints out logs" do
-    messages        = StringIO.new
-    Resque.logger   = Logger.new(messages)
-    @worker.verbose = true
-
-    begin
-      @worker.log("omghi mom")
-    ensure
-      reset_logger
-    end
-
-    assert_equal "*** omghi mom\n", messages.string
-  end
-
-  test "unsetting verbose works" do
-    messages        = StringIO.new
-    Resque.logger   = Logger.new(messages)
-    @worker.verbose = true
-    @worker.verbose = false
-
-    begin
-      @worker.log("omghi mom")
-    ensure
-      reset_logger
-    end
-
-    assert_equal "", messages.string
-  end
-
-  test "very verbose works in the afternoon" do
-    messages        = StringIO.new
-    Resque.logger   = Logger.new(messages)
-
-    begin
-      require 'time'
-      last_puts = ""
-      Time.fake_time = Time.parse("15:44:33 2011-03-02")
-
-      @worker.very_verbose = true
-      @worker.log("some log text")
-
-      assert_match /\*\* \[15:44:33 2011-03-02\] \d+: some log text/, messages.string
-    ensure
-      Time.fake_time = nil
-      reset_logger
-    end
-  end
-
-  test "won't fork if ENV['FORK_PER_JOB'] is false" do
-    begin
-      $TESTING = false
-      workerA = Resque::Worker.new(:jobs)
-
-      if workerA.will_fork?
-        begin
-          ENV["FORK_PER_JOB"] = 'false'
-          assert !workerA.will_fork?
-        ensure
-          ENV["FORK_PER_JOB"] = 'true'
-        end
-      end
-    ensure
-      $TESTING = true
-    end
-  end
-
-  test "Will call an after_fork hook if we're forking" do
-    Resque.redis.flushall
-    $AFTER_FORK_CALLED = false
-    Resque.after_fork = Proc.new { $AFTER_FORK_CALLED = true }
-    workerA = Resque::Worker.new(:jobs)
-
-    assert !$AFTER_FORK_CALLED
-    Resque::Job.create(:jobs, SomeJob, 20, '/tmp')
-    workerA.work(0)
-    assert $AFTER_FORK_CALLED == workerA.will_fork?
-  end
-
-  test "Will not call an after_fork hook when the worker can't fork" do
-    Resque.redis.flushall
-    $AFTER_FORK_CALLED = false
-    Resque.after_fork = Proc.new { $AFTER_FORK_CALLED = true }
-    workerA = Resque::Worker.new(:jobs)
-    workerA.cant_fork = true
-
-    assert !$AFTER_FORK_CALLED
-    Resque::Job.create(:jobs, SomeJob, 20, '/tmp')
-    workerA.work(0)
-    assert !$AFTER_FORK_CALLED
-  end
-
-  test "returns PID of running process" do
-    assert_equal @worker.to_s.split(":")[1].to_i, @worker.pid
-  end
-
-  test "requeue failed queue" do
-    queue = 'good_job'
-    Resque::Failure.create(:exception => Exception.new, :worker => Resque::Worker.new(queue), :queue => queue, :payload => {'class' => 'GoodJob'})
-    Resque::Failure.create(:exception => Exception.new, :worker => Resque::Worker.new(queue), :queue => 'some_job', :payload => {'class' => 'SomeJob'})
-    Resque::Failure.requeue_queue(queue)
-    assert Resque::Failure.all(0).has_key?('retried_at')
-    assert !Resque::Failure.all(1).has_key?('retried_at')
-  end
-
-  test "remove failed queue" do
-    queue = 'good_job'
-    queue2 = 'some_job'
-    Resque::Failure.create(:exception => Exception.new, :worker => Resque::Worker.new(queue), :queue => queue, :payload => {'class' => 'GoodJob'})
-    Resque::Failure.create(:exception => Exception.new, :worker => Resque::Worker.new(queue2), :queue => queue2, :payload => {'class' => 'SomeJob'})
-    Resque::Failure.create(:exception => Exception.new, :worker => Resque::Worker.new(queue), :queue => queue, :payload => {'class' => 'GoodJob'})
-    Resque::Failure.remove_queue(queue)
-    assert_equal queue2, Resque::Failure.all(0)['queue']
-    assert_equal 1, Resque::Failure.count
-  end
-
-  test "reconnects to redis after fork" do
-    original_connection = Resque.redis.client.connection.instance_variable_get("@sock")
-    @worker.work(0)
-    assert_not_equal original_connection, Resque.redis.client.connection.instance_variable_get("@sock")
-  end
-
-  test "tries to reconnect three times before giving up and the failure does not unregister the parent" do
-    begin
-      class Redis::Client
-        alias_method :original_reconnect, :reconnect
-
-        def reconnect
-          raise Redis::BaseConnectionError
-        end
-      end
-
-      class Resque::Worker
-        alias_method :original_sleep, :sleep
-
-        def sleep(duration = nil)
-          # noop
-        end
-      end
-
-      stdout, stderr = capture_io do
-        Resque.logger = Logger.new($stdout)
-        @worker.work(0)
-      end
-
-      assert_equal 3, stdout.scan(/retrying/).count
-      assert_equal 1, stdout.scan(/quitting/).count
-      assert_equal 0, stdout.scan(/Failed to start worker/).count
-      assert_equal 1, stdout.scan(/Redis::BaseConnectionError: Redis::BaseConnectionError/).count
-
-    ensure
-      class Redis::Client
-        alias_method :reconnect, :original_reconnect
-      end
-
-      class Resque::Worker
-        alias_method :sleep, :original_sleep
-      end
-    end
-  end
-
-  test "will call before_pause before it is paused" do
-    before_pause_called = false
-    captured_worker = nil
-    begin
-      class Redis::Client
-        alias_method :original_reconnect, :reconnect
-
-        def reconnect
-          raise Redis::BaseConnectionError
-        end
-      end
-
-      class Resque::Worker
-        alias_method :original_sleep, :sleep
-
-        def sleep(duration = nil)
-          # noop
-        end
-      end
-
-      class DummyLogger
-        attr_reader :messages
-
-        def initialize
-          @messages = []
-        end
-
-        def info(message); @messages << message; end
-        alias_method :debug, :info
-        alias_method :warn,  :info
-        alias_method :error, :info
-        alias_method :fatal, :info
-      end
-
-      Resque.logger = DummyLogger.new
-      begin
-        @worker.work(0)
-        messages = Resque.logger.messages
-      ensure
-        reset_logger
-      end
-
-      assert_equal 3, messages.grep(/retrying/).count
-      assert_equal 1, messages.grep(/quitting/).count
-    ensure
-      class Redis::Client
-        alias_method :reconnect, :original_reconnect
-      end
-
-      class Resque::Worker
-        alias_method :sleep, :original_sleep
-      end
-    end
-  end
-
-  if !defined?(RUBY_ENGINE) || defined?(RUBY_ENGINE) && RUBY_ENGINE != "jruby"
-    test "old signal handling is the default" do
-      rescue_time = nil
-
-      begin
-        class LongRunningJob
-          @queue = :long_running_job
-
-          def self.perform( run_time, rescue_time=nil )
-            Resque.redis.client.reconnect # get its own connection
-            Resque.redis.rpush( 'sigterm-test:start', Process.pid )
-            sleep run_time
-            Resque.redis.rpush( 'sigterm-test:result', 'Finished Normally' )
-          rescue Resque::TermException => e
-            Resque.redis.rpush( 'sigterm-test:result', %Q(Caught SignalException: #{e.inspect}))
-            sleep rescue_time unless rescue_time.nil?
-          ensure
-            puts 'fuuuu'
-            Resque.redis.rpush( 'sigterm-test:final', 'exiting.' )
-          end
-        end
-
-        Resque.enqueue( LongRunningJob, 5, rescue_time )
-
-        worker_pid = Kernel.fork do
-          # ensure we actually fork
-          $TESTING = false
-          # reconnect since we just forked
-          Resque.redis.client.reconnect
-
-          worker = Resque::Worker.new(:long_running_job)
-
-          suppress_warnings do
-            worker.work(0)
-          end
-          exit!
-        end
-
-        # ensure the worker is started
-        start_status = Resque.redis.blpop( 'sigterm-test:start', 5 )
-        assert_not_nil start_status
-        child_pid = start_status[1].to_i
-        assert_operator child_pid, :>, 0
-
-        # send signal to abort the worker
-        Process.kill('TERM', worker_pid)
-        Process.waitpid(worker_pid)
-
-        # wait to see how it all came down
-        result = Resque.redis.blpop( 'sigterm-test:result', 5 )
-        assert_nil result
-
-        # ensure that the child pid is no longer running
-        child_not_running = `ps -p #{child_pid.to_s} -o pid=`.empty?
-        assert child_not_running
-      ensure
-        remaining_keys = Resque.redis.keys('sigterm-test:*') || []
-        Resque.redis.del(*remaining_keys) unless remaining_keys.empty?
-      end
-    end
-  end
-
-  if !defined?(RUBY_ENGINE) || defined?(RUBY_ENGINE) && RUBY_ENGINE != "jruby"
-    [SignalException, Resque::TermException].each do |exception|
-      {
-        'cleanup occurs in allotted time' => nil,
-        'cleanup takes too long' => 2
-      }.each do |scenario,rescue_time|
-        test "SIGTERM when #{scenario} while catching #{exception}" do
-          begin
-            eval("class LongRunningJob; @@exception = #{exception}; end")
-            class LongRunningJob
-              @queue = :long_running_job
-
-              def self.perform( run_time, rescue_time=nil )
-                Resque.redis.client.reconnect # get its own connection
-                Resque.redis.rpush( 'sigterm-test:start', Process.pid )
-                sleep run_time
-                Resque.redis.rpush( 'sigterm-test:result', 'Finished Normally' )
-              rescue @@exception => e
-                Resque.redis.rpush( 'sigterm-test:result', %Q(Caught SignalException: #{e.inspect}))
-                sleep rescue_time unless rescue_time.nil?
-              ensure
-                Resque.redis.rpush( 'sigterm-test:final', 'exiting.' )
-              end
-            end
-
-            Resque.enqueue( LongRunningJob, 5, rescue_time )
-
-            worker_pid = Kernel.fork do
-              # ensure we actually fork
-              $TESTING = false
-              # reconnect since we just forked
-              Resque.redis.client.reconnect
-
-              worker = Resque::Worker.new(:long_running_job)
-              worker.term_timeout = 1
-              worker.term_child = 1
-
-              worker.work(0)
-              exit!
-            end
-
-            # ensure the worker is started
-            start_status = Resque.redis.blpop( 'sigterm-test:start', 5 )
-            assert_not_nil start_status
-            child_pid = start_status[1].to_i
-            assert_operator child_pid, :>, 0
-
-            # send signal to abort the worker
-            Process.kill('TERM', worker_pid)
-            Process.waitpid(worker_pid)
-
-            # wait to see how it all came down
-            result = Resque.redis.blpop( 'sigterm-test:result', 5 )
-            assert_not_nil result
-            assert !result[1].start_with?('Finished Normally'), 'Job Finished normally. Sleep not long enough?'
-            assert result[1].start_with? 'Caught SignalException', 'Signal exception not raised in child.'
-
-            # ensure that the child pid is no longer running
-            child_still_running = !(`ps -p #{child_pid.to_s} -o pid=`).empty?
-            assert !child_still_running
-
-            # see if post-cleanup occurred. This should happen IFF the rescue_time is less than the term_timeout
-            post_cleanup_occurred = Resque.redis.lpop( 'sigterm-test:final' )
-            assert post_cleanup_occurred, 'post cleanup did not occur. SIGKILL sent too early?' if rescue_time.nil?
-            assert !post_cleanup_occurred, 'post cleanup occurred. SIGKILL sent too late?' unless rescue_time.nil?
-
-          ensure
-            remaining_keys = Resque.redis.keys('sigterm-test:*') || []
-            Resque.redis.del(*remaining_keys) unless remaining_keys.empty?
-          end
-        end
-      end
-    end
-
-    test "displays warning when not using term_child" do
-      begin
-        $TESTING = false
-        stdout, stderr = capture_io { @worker.work(0) }
-
-        assert stderr.match(/^WARNING:/)
-      ensure
-        $TESTING = true
-      end
-    end
-
-    test "it does not display warning when using term_child" do
-      @worker.term_child = "1"
-      stdout, stderr = capture_io { @worker.work(0) }
-
-      assert !stderr.match(/^WARNING:/)
-    end
-
-    class SuicidalJob
-      @queue = :jobs
-
-      def self.perform
-        Process.kill('KILL', Process.pid)
-      end
-
-      def self.on_failure_store_exception(exc, *args)
-        @@failure_exception = exc
-      end
-    end
-
-    test "will notify failure hooks when a job is killed by a signal" do
-      begin
-        $TESTING = false
-        Resque.enqueue(SuicidalJob)
-        suppress_warnings do
-          @worker.work(0)
-        end
-        assert_equal Resque::DirtyExit, SuicidalJob.send(:class_variable_get, :@@failure_exception).class
-      ensure
-        $TESTING = true
-      end
-    end
-  end
-
-  test "displays warning when using verbose" do
-    begin
-      $TESTING = false
-      stdout, stderr = capture_io { @worker.verbose }
-    ensure
-      $TESTING = true
-    end
-    $warned_logger_severity_deprecation = false
-
-    assert stderr.match(/WARNING:/)
-  end
-
-  test "displays warning when using verbose=" do
-    begin
-      $TESTING = false
-      stdout, stderr = capture_io { @worker.verbose = true }
-    ensure
-      $TESTING = true
-    end
-    $warned_logger_severity_deprecation = false
-
-    assert stderr.match(/WARNING:/)
-  end
-
-  test "displays warning when using very_verbose" do
-    begin
-      $TESTING = false
-      stdout, stderr = capture_io { @worker.very_verbose }
-    ensure
-      $TESTING = true
-    end
-    $warned_logger_severity_deprecation = false
-
-    assert stderr.match(/WARNING:/)
-  end
-
-  test "displays warning when using very_verbose=" do
-    begin
-      $TESTING = false
-      stdout, stderr = capture_io { @worker.very_verbose = true }
-    ensure
-      $TESTING = true
-    end
-    $warned_logger_severity_deprecation = false
-
-    assert stderr.match(/WARNING:/)
-  end
-end