resque 1.23.0 → 2.6.0

data/test/resque_test.rb

@@ -1,278 +0,0 @@
-require 'test_helper'
-
-context "Resque" do
-  setup do
-    Resque.redis.flushall
-
-    Resque.push(:people, { 'name' => 'chris' })
-    Resque.push(:people, { 'name' => 'bob' })
-    Resque.push(:people, { 'name' => 'mark' })
-    @original_redis = Resque.redis
-  end
-
-  teardown do
-    Resque.redis = @original_redis
-  end
-
-  test "can set a namespace through a url-like string" do
-    assert Resque.redis
-    assert_equal :resque, Resque.redis.namespace
-    Resque.redis = 'localhost:9736/namespace'
-    assert_equal 'namespace', Resque.redis.namespace
-  end
-
-  test "redis= works correctly with a Redis::Namespace param" do
-    new_redis = Redis.new(:host => "localhost", :port => 9736)
-    new_namespace = Redis::Namespace.new("namespace", :redis => new_redis)
-    Resque.redis = new_namespace
-    assert_equal new_namespace, Resque.redis
-
-    Resque.redis = 'localhost:9736/namespace'
-  end
-
-  test "can put jobs on a queue" do
-    assert Resque::Job.create(:jobs, 'SomeJob', 20, '/tmp')
-    assert Resque::Job.create(:jobs, 'SomeJob', 20, '/tmp')
-  end
-
-  test "can grab jobs off a queue" do
-    Resque::Job.create(:jobs, 'some-job', 20, '/tmp')
-
-    job = Resque.reserve(:jobs)
-
-    assert_kind_of Resque::Job, job
-    assert_equal SomeJob, job.payload_class
-    assert_equal 20, job.args[0]
-    assert_equal '/tmp', job.args[1]
-  end
-
-  test "can re-queue jobs" do
-    Resque::Job.create(:jobs, 'some-job', 20, '/tmp')
-
-    job = Resque.reserve(:jobs)
-    job.recreate
-
-    assert_equal job, Resque.reserve(:jobs)
-  end
-
-  test "can put jobs on a queue by way of an ivar" do
-    assert_equal 0, Resque.size(:ivar)
-    assert Resque.enqueue(SomeIvarJob, 20, '/tmp')
-    assert Resque.enqueue(SomeIvarJob, 20, '/tmp')
-
-    job = Resque.reserve(:ivar)
-
-    assert_kind_of Resque::Job, job
-    assert_equal SomeIvarJob, job.payload_class
-    assert_equal 20, job.args[0]
-    assert_equal '/tmp', job.args[1]
-
-    assert Resque.reserve(:ivar)
-    assert_equal nil, Resque.reserve(:ivar)
-  end
-
-  test "can remove jobs from a queue by way of an ivar" do
-    assert_equal 0, Resque.size(:ivar)
-    assert Resque.enqueue(SomeIvarJob, 20, '/tmp')
-    assert Resque.enqueue(SomeIvarJob, 30, '/tmp')
-    assert Resque.enqueue(SomeIvarJob, 20, '/tmp')
-    assert Resque::Job.create(:ivar, 'blah-job', 20, '/tmp')
-    assert Resque.enqueue(SomeIvarJob, 20, '/tmp')
-    assert_equal 5, Resque.size(:ivar)
-
-    assert Resque.dequeue(SomeIvarJob, 30, '/tmp')
-    assert_equal 4, Resque.size(:ivar)
-    assert Resque.dequeue(SomeIvarJob)
-    assert_equal 1, Resque.size(:ivar)
-  end
-
-  test "jobs have a nice #inspect" do
-    assert Resque::Job.create(:jobs, 'SomeJob', 20, '/tmp')
-    job = Resque.reserve(:jobs)
-    assert_equal '(Job{jobs} | SomeJob | [20, "/tmp"])', job.inspect
-  end
-
-  test "jobs can be destroyed" do
-    assert Resque::Job.create(:jobs, 'SomeJob', 20, '/tmp')
-    assert Resque::Job.create(:jobs, 'BadJob', 20, '/tmp')
-    assert Resque::Job.create(:jobs, 'SomeJob', 20, '/tmp')
-    assert Resque::Job.create(:jobs, 'BadJob', 30, '/tmp')
-    assert Resque::Job.create(:jobs, 'BadJob', 20, '/tmp')
-
-    assert_equal 5, Resque.size(:jobs)
-    assert_equal 2, Resque::Job.destroy(:jobs, 'SomeJob')
-    assert_equal 3, Resque.size(:jobs)
-    assert_equal 1, Resque::Job.destroy(:jobs, 'BadJob', 30, '/tmp')
-    assert_equal 2, Resque.size(:jobs)
-  end
-
-  test "jobs can test for equality" do
-    assert Resque::Job.create(:jobs, 'SomeJob', 20, '/tmp')
-    assert Resque::Job.create(:jobs, 'some-job', 20, '/tmp')
-    assert_equal Resque.reserve(:jobs), Resque.reserve(:jobs)
-
-    assert Resque::Job.create(:jobs, 'SomeMethodJob', 20, '/tmp')
-    assert Resque::Job.create(:jobs, 'SomeJob', 20, '/tmp')
-    assert_not_equal Resque.reserve(:jobs), Resque.reserve(:jobs)
-
-    assert Resque::Job.create(:jobs, 'SomeJob', 20, '/tmp')
-    assert Resque::Job.create(:jobs, 'SomeJob', 30, '/tmp')
-    assert_not_equal Resque.reserve(:jobs), Resque.reserve(:jobs)
-  end
-
-  test "can put jobs on a queue by way of a method" do
-    assert_equal 0, Resque.size(:method)
-    assert Resque.enqueue(SomeMethodJob, 20, '/tmp')
-    assert Resque.enqueue(SomeMethodJob, 20, '/tmp')
-
-    job = Resque.reserve(:method)
-
-    assert_kind_of Resque::Job, job
-    assert_equal SomeMethodJob, job.payload_class
-    assert_equal 20, job.args[0]
-    assert_equal '/tmp', job.args[1]
-
-    assert Resque.reserve(:method)
-    assert_equal nil, Resque.reserve(:method)
-  end
-
-  test "can define a queue for jobs by way of a method" do
-    assert_equal 0, Resque.size(:method)
-    assert Resque.enqueue_to(:new_queue, SomeMethodJob, 20, '/tmp')
-
-    job = Resque.reserve(:new_queue)
-    assert_equal SomeMethodJob, job.payload_class
-    assert_equal 20, job.args[0]
-    assert_equal '/tmp', job.args[1]
-  end
-
-  test "needs to infer a queue with enqueue" do
-    assert_raises Resque::NoQueueError do
-      Resque.enqueue(SomeJob, 20, '/tmp')
-    end
-  end
-
-  test "validates job for queue presence" do
-    assert_raises Resque::NoQueueError do
-      Resque.validate(SomeJob)
-    end
-  end
-
-  test "can put items on a queue" do
-    assert Resque.push(:people, { 'name' => 'jon' })
-  end
-
-  test "can pull items off a queue" do
-    assert_equal({ 'name' => 'chris' }, Resque.pop(:people))
-    assert_equal({ 'name' => 'bob' }, Resque.pop(:people))
-    assert_equal({ 'name' => 'mark' }, Resque.pop(:people))
-    assert_equal nil, Resque.pop(:people)
-  end
-
-  test "knows how big a queue is" do
-    assert_equal 3, Resque.size(:people)
-
-    assert_equal({ 'name' => 'chris' }, Resque.pop(:people))
-    assert_equal 2, Resque.size(:people)
-
-    assert_equal({ 'name' => 'bob' }, Resque.pop(:people))
-    assert_equal({ 'name' => 'mark' }, Resque.pop(:people))
-    assert_equal 0, Resque.size(:people)
-  end
-
-  test "can peek at a queue" do
-    assert_equal({ 'name' => 'chris' }, Resque.peek(:people))
-    assert_equal 3, Resque.size(:people)
-  end
-
-  test "can peek multiple items on a queue" do
-    assert_equal({ 'name' => 'bob' }, Resque.peek(:people, 1, 1))
-
-    assert_equal([{ 'name' => 'bob' }, { 'name' => 'mark' }], Resque.peek(:people, 1, 2))
-    assert_equal([{ 'name' => 'chris' }, { 'name' => 'bob' }], Resque.peek(:people, 0, 2))
-    assert_equal([{ 'name' => 'chris' }, { 'name' => 'bob' }, { 'name' => 'mark' }], Resque.peek(:people, 0, 3))
-    assert_equal({ 'name' => 'mark' }, Resque.peek(:people, 2, 1))
-    assert_equal nil, Resque.peek(:people, 3)
-    assert_equal [], Resque.peek(:people, 3, 2)
-  end
-
-  test "knows what queues it is managing" do
-    assert_equal %w( people ), Resque.queues
-    Resque.push(:cars, { 'make' => 'bmw' })
-    assert_equal %w( cars people ), Resque.queues
-  end
-
-  test "queues are always a list" do
-    Resque.redis.flushall
-    assert_equal [], Resque.queues
-  end
-
-  test "can delete a queue" do
-    Resque.push(:cars, { 'make' => 'bmw' })
-    assert_equal %w( cars people ), Resque.queues
-    Resque.remove_queue(:people)
-    assert_equal %w( cars ), Resque.queues
-    assert_equal nil, Resque.pop(:people)
-  end
-
-  test "keeps track of resque keys" do
-    assert_equal ["queue:people", "queues"].sort, Resque.keys.sort
-  end
-
-  test "badly wants a class name, too" do
-    assert_raises Resque::NoClassError do
-      Resque::Job.create(:jobs, nil)
-    end
-  end
-
-  test "keeps stats" do
-    Resque::Job.create(:jobs, SomeJob, 20, '/tmp')
-    Resque::Job.create(:jobs, BadJob)
-    Resque::Job.create(:jobs, GoodJob)
-
-    Resque::Job.create(:others, GoodJob)
-    Resque::Job.create(:others, GoodJob)
-
-    stats = Resque.info
-    assert_equal 8, stats[:pending]
-
-    @worker = Resque::Worker.new(:jobs)
-    @worker.register_worker
-    2.times { @worker.process }
-
-    job = @worker.reserve
-    @worker.working_on job
-
-    stats = Resque.info
-    assert_equal 1, stats[:working]
-    assert_equal 1, stats[:workers]
-
-    @worker.done_working
-
-    stats = Resque.info
-    assert_equal 3, stats[:queues]
-    assert_equal 3, stats[:processed]
-    assert_equal 1, stats[:failed]
-    if ENV.key? 'RESQUE_DISTRIBUTED'
-      assert_equal [Resque.redis.respond_to?(:server) ? 'localhost:9736, localhost:9737' : 'redis://localhost:9736/0, redis://localhost:9737/0'], stats[:servers]
-    else
-      assert_equal [Resque.redis.respond_to?(:server) ? 'localhost:9736' : 'redis://localhost:9736/0'], stats[:servers]
-    end
-  end
-
-  test "decode bad json" do
-    assert_raises Resque::Helpers::DecodeException do
-      Resque.decode("{\"error\":\"Module not found \\u002\"}")
-    end
-  end
-
-  test "inlining jobs" do
-    begin
-      Resque.inline = true
-      Resque.enqueue(SomeIvarJob, 20, '/tmp')
-      assert_equal 0, Resque.size(:ivar)
-    ensure
-      Resque.inline = false
-    end
-  end
-end

data/test/test_helper.rb

@@ -1,178 +0,0 @@
-require 'rubygems'
-
-$dir = File.dirname(File.expand_path(__FILE__))
-$LOAD_PATH.unshift $dir + '/../lib'
-$TESTING = true
-require 'test/unit'
-
-require 'redis/namespace'
-require 'resque'
-
-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
-#
-
-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..."
-  pids.each { |pid| Process.kill("TERM", pid.to_i) }
-  system("rm -f #{$dir}/dump.rdb #{$dir}/dump-cluster.rdb")
-  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
-
-
-##
-# 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 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