resque-cedar 1.20.0

data/test/test_helper.rb

@@ -0,0 +1,135 @@
+require 'rubygems'
+
+dir = File.dirname(File.expand_path(__FILE__))
+$LOAD_PATH.unshift dir + '/../lib'
+$TESTING = true
+require 'mocha'
+require 'minitest/unit'
+require 'minitest/spec'
+require 'test/unit'
+
+require 'redis/namespace'
+require 'resque'
+
+#
+# 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
+#
+
+at_exit do
+  next if $!
+
+  if defined?(MiniTest)
+    exit_code = MiniTest::Unit.new.run(ARGV)
+  else
+    exit_code = Test::Unit::AutoRunner.run
+  end
+
+  processes = `ps -A -o pid,command | grep [r]edis-test`.split("\n")
+  pids = processes.map { |process| process.split(" ")[0] }
+  puts "Killing test redis server..."
+  `rm -f #{dir}/dump.rdb #{dir}/dump-cluster.rdb`
+  pids.each { |pid| Process.kill("KILL", pid.to_i) }
+  exit exit_code
+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
+
+
+##
+# 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 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
+
+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

data/test/worker_test.rb

@@ -0,0 +1,443 @@
+require 'test_helper'
+
+describe "Resque::Worker" do
+  include Test::Unit::Assertions
+
+  before do
+    Resque.redis = Resque.redis # reset state in Resque object
+    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
+
+  it "can fail jobs" do
+    Resque::Job.create(:jobs, BadJob)
+    @worker.work(0)
+    assert_equal 1, Resque::Failure.count
+  end
+
+  it "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
+
+  it "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
+
+  it "fails uncompleted jobs 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
+  end
+
+  class ::SimpleJobWithFailureHandling
+    def self.on_failure_record_failure(exception, *job_args)
+      @@exception = exception
+    end
+    
+    def self.exception
+      @@exception
+    end
+  end
+
+  it "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
+
+  it "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
+
+  it "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
+
+  it "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
+
+  it "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
+
+  it "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
+
+  it "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
+
+  it "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
+
+  it "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
+
+  it "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
+
+  it "can work with dynamically added queues when using wildcard" do
+    worker = Resque::Worker.new("*")
+
+    assert_equal ["jobs"], Resque.queues
+
+    Resque::Job.create(:high, GoodJob)
+    Resque::Job.create(:critical, GoodJob)
+    Resque::Job.create(:blahblah, GoodJob)
+
+    processed_queues = []
+
+    worker.work(0) do |job|
+      processed_queues << job.queue
+    end
+
+    assert_equal %w( jobs high critical blahblah ).sort, processed_queues
+  end
+
+  it "has a unique id" do
+    assert_equal "#{`hostname`.chomp}:#{$$}:jobs", @worker.to_s
+  end
+
+  it "complains if no queues are given" do
+    assert_raise Resque::NoQueueError do
+      Resque::Worker.new
+    end
+  end
+
+  it "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
+
+  it "inserts itself into the 'workers' list on startup" do
+    @worker.work(0) do
+      assert_equal @worker, Resque.workers[0]
+    end
+  end
+
+  it "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
+
+  it "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
+
+  it "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
+
+  it "clears its status when not working on anything" do
+    @worker.work(0)
+    assert_equal Hash.new, @worker.job
+  end
+
+  it "knows when it is working" do
+    @worker.work(0) do
+      assert @worker.working?
+    end
+  end
+
+  it "knows when it is idle" do
+    @worker.work(0)
+    assert @worker.idle?
+  end
+
+  it "knows who is working" do
+    @worker.work(0) do
+      assert_equal [@worker], Resque.working
+    end
+  end
+
+  it "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
+
+  it "reserve blocks when the queue is empty" do
+    worker = Resque::Worker.new(:timeout)
+
+    assert_raises Timeout::Error do
+      Timeout.timeout(1) { worker.reserve(5) }
+    end
+  end
+
+  it "reserve returns nil when there is no job and is polling" do
+    worker = Resque::Worker.new(:timeout)
+
+    assert_equal nil, worker.reserve(1)
+  end
+
+  it "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
+
+  it "stats are erased when the worker goes away" do
+    @worker.work(0)
+    assert_equal 0, @worker.processed
+    assert_equal 0, @worker.failed
+  end
+
+  it "knows when it started" do
+    time = Time.now
+    @worker.work(0) do
+      assert_equal time.to_s, @worker.started.to_s
+    end
+  end
+
+  it "knows whether it exists or not" do
+    @worker.work(0) do
+      assert Resque::Worker.exists?(@worker)
+      assert !Resque::Worker.exists?('blah-blah')
+    end
+  end
+
+  it "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
+
+  it "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
+
+  it "doesn't find fakes" do
+    @worker.work(0) do
+      found = Resque::Worker.find('blah-blah')
+      assert_equal nil, found
+    end
+  end
+
+  it "cleans up dead worker info on start (crash recovery)" do
+    # first we fake out two dead workers
+    workerA = Resque::Worker.new(:jobs)
+    workerA.instance_variable_set(:@to_s, "#{`hostname`.chomp}:1:jobs")
+    workerA.register_worker
+
+    workerB = Resque::Worker.new(:high, :low)
+    workerB.instance_variable_set(:@to_s, "#{`hostname`.chomp}:2:high,low")
+    workerB.register_worker
+
+    assert_equal 2, Resque.workers.size
+
+    # then we prune them
+    @worker.work(0) do
+      assert_equal 1, Resque.workers.size
+    end
+  end
+
+  it "worker_pids returns pids" do
+    known_workers = @worker.worker_pids
+    assert !known_workers.empty?
+  end
+
+  it "Processed jobs count" do
+    @worker.work(0)
+    assert_equal 1, Resque.info[:processed]
+  end
+
+  it "Will call a before_first_fork hook only once" do
+    $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
+
+  it "Will call a before_fork hook before forking" do
+    $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
+
+  it "very verbose works in the afternoon" do
+    begin
+      require 'time'
+      last_puts = ""
+      Time.fake_time = Time.parse("15:44:33 2011-03-02")
+
+      @worker.extend(Module.new {
+        define_method(:puts) { |thing| last_puts = thing }
+      })
+
+      @worker.very_verbose = true
+      @worker.log("some log text")
+
+      assert_match /\*\* \[15:44:33 2011-03-02\] \d+: some log text/, last_puts
+    ensure
+      Time.fake_time = nil
+    end
+  end
+
+  it "Will call an after_fork hook after forking" do
+    $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
+  end
+
+  it "returns PID of running process" do
+    assert_equal @worker.to_s.split(":")[1].to_i, @worker.pid
+  end
+  
+  it "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
+
+  it "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
+end