resque 1.26.pre.0 → 1.26.0

data/test/redis-test.conf

@@ -1,115 +0,0 @@
-# Redis configuration file example
-
-# By default Redis does not run as a daemon. Use 'yes' if you need it.
-# Note that Redis will write a pid file in /var/run/redis.pid when daemonized.
-daemonize yes
-
-# When run as a daemon, Redis write a pid file in /var/run/redis.pid by default.
-# You can specify a custom pid file location here.
-pidfile ./test/redis-test.pid
-
-# Accept connections on the specified port, default is 6379
-port 9736
-
-# If you want you can bind a single interface, if the bind option is not
-# specified all the interfaces will listen for connections.
-#
-# bind 127.0.0.1
-
-# Close the connection after a client is idle for N seconds (0 to disable)
-timeout 300
-
-# Save the DB on disk:
-#
-#   save <seconds> <changes>
-#
-#   Will save the DB if both the given number of seconds and the given
-#   number of write operations against the DB occurred.
-#
-#   In the example below the behaviour will be to save:
-#   after 900 sec (15 min) if at least 1 key changed
-#   after 300 sec (5 min) if at least 10 keys changed
-#   after 60 sec if at least 10000 keys changed
-save 900 1
-save 300 10
-save 60 10000
-
-# The filename where to dump the DB
-dbfilename dump.rdb
-
-# For default save/load DB in/from the working directory
-# Note that you must specify a directory not a file name.
-dir ./test/
-
-# Set server verbosity to 'debug'
-# it can be one of:
-# debug (a lot of information, useful for development/testing)
-# notice (moderately verbose, what you want in production probably)
-# warning (only very important / critical messages are logged)
-loglevel debug
-
-# Specify the log file name. Also 'stdout' can be used to force
-# the demon to log on the standard output. Note that if you use standard
-# output for logging but daemonize, logs will be sent to /dev/null
-logfile stdout
-
-# Set the number of databases. The default database is DB 0, you can select
-# a different one on a per-connection basis using SELECT <dbid> where
-# dbid is a number between 0 and 'databases'-1
-databases 16
-
-################################# REPLICATION #################################
-
-# Master-Slave replication. Use slaveof to make a Redis instance a copy of
-# another Redis server. Note that the configuration is local to the slave
-# so for example it is possible to configure the slave to save the DB with a
-# different interval, or to listen to another port, and so on.
-
-# slaveof <masterip> <masterport>
-
-################################## SECURITY ###################################
-
-# Require clients to issue AUTH <PASSWORD> before processing any other
-# commands.  This might be useful in environments in which you do not trust
-# others with access to the host running redis-server.
-#
-# This should stay commented out for backward compatibility and because most
-# people do not need auth (e.g. they run their own servers).
-
-# requirepass foobared
-
-################################### LIMITS ####################################
-
-# Set the max number of connected clients at the same time. By default there
-# is no limit, and it's up to the number of file descriptors the Redis process
-# is able to open. The special value '0' means no limts.
-# Once the limit is reached Redis will close all the new connections sending
-# an error 'max number of clients reached'.
-
-# maxclients 128
-
-# Don't use more memory than the specified amount of bytes.
-# When the memory limit is reached Redis will try to remove keys with an
-# EXPIRE set. It will try to start freeing keys that are going to expire
-# in little time and preserve keys with a longer time to live.
-# Redis will also try to remove objects from free lists if possible.
-#
-# If all this fails, Redis will start to reply with errors to commands
-# that will use more memory, like SET, LPUSH, and so on, and will continue
-# to reply to most read-only commands like GET.
-#
-# WARNING: maxmemory can be a good idea mainly if you want to use Redis as a
-# 'state' server or cache, not as a real DB. When Redis is used as a real
-# database the memory usage will grow over the weeks, it will be obvious if
-# it is going to use too much memory in the long run, and you'll have the time
-# to upgrade. With maxmemory after the limit is reached you'll start to get
-# errors for write operations, and this may even lead to DB inconsistency.
-
-# maxmemory <bytes>
-
-############################### ADVANCED CONFIG ###############################
-
-# Glue small output buffers together in order to send small replies in a
-# single TCP packet. Uses a bit more CPU but most of the times it is a win
-# in terms of number of queries per second. Use 'yes' if unsure.
-# glueoutputbuf yes

data/test/resque-web_test.rb

@@ -1,59 +0,0 @@
-require 'test_helper'
-require 'resque/server/test_helper'
- 
-# Root path test
-context "on GET to /" do
-  setup { get "/" }
-
-  test "redirect to overview" do
-    follow_redirect!
-  end
-end
-
-# Global overview
-context "on GET to /overview" do
-  setup { get "/overview" }
-
-  test "should at least display 'queues'" do
-    assert last_response.body.include?('Queues')
-  end
-end
-
-# Working jobs
-context "on GET to /working" do
-  setup { get "/working" }
-
-  should_respond_with_success
-end
-
-# Failed
-context "on GET to /failed" do
-  setup { get "/failed" }
-
-  should_respond_with_success
-end
-
-# Stats 
-context "on GET to /stats/resque" do
-  setup { get "/stats/resque" }
-
-  should_respond_with_success
-end
-
-context "on GET to /stats/redis" do
-  setup { get "/stats/redis" }
-
-  should_respond_with_success
-end
-
-context "on GET to /stats/resque" do
-  setup { get "/stats/keys" }
-
-  should_respond_with_success
-end
-
-context "also works with slash at the end" do
-  setup { get "/working/" }
-
-  should_respond_with_success
-end

data/test/resque_failure_redis_test.rb

@@ -1,19 +0,0 @@
-require 'test_helper'
-require 'resque/failure/redis'
-
-context "Resque::Failure::Redis" do
-  setup do
-    @bad_string    = [39, 52, 127, 86, 93, 95, 39].map { |c| c.chr }.join
-    exception      = StandardError.exception(@bad_string)
-    worker         = Resque::Worker.new(:test)
-    queue          = "queue"
-    payload        = { "class" => Object, "args" => 3 }
-    @redis_backend = Resque::Failure::Redis.new(exception, worker, queue, payload)
-  end
-
-  test 'cleans up bad strings before saving the failure, in order to prevent errors on the resque UI' do
-    # test assumption: the bad string should not be able to round trip though JSON
-    @redis_backend.save
-    Resque::Failure::Redis.all # should not raise an error
-  end
-end

data/test/resque_hook_test.rb

@@ -1,165 +0,0 @@
-require 'test_helper'
-require 'tempfile'
-
-describe "Resque Hooks" do
-  before do
-    Resque.redis.flushall
-
-    Resque.before_first_fork = nil
-    Resque.before_fork = nil
-    Resque.after_fork = nil
-
-    @worker = Resque::Worker.new(:jobs)
-
-    $called = false
-
-    class CallNotifyJob
-      def self.perform
-        $called = true
-      end
-    end
-  end
-
-  it 'retrieving hooks if none have been set' do
-    assert_equal [], Resque.before_first_fork
-    assert_equal [], Resque.before_fork
-    assert_equal [], Resque.after_fork
-  end
-
-  it 'it calls before_first_fork once' do
-    counter = 0
-
-    Resque.before_first_fork { counter += 1 }
-    2.times { Resque::Job.create(:jobs, CallNotifyJob) }
-
-    assert_equal(0, counter)
-    @worker.work(0)
-    assert_equal(1, counter)
-  end
-
-  it 'it calls before_fork before each job' do
-    counter = 0
-
-    Resque.before_fork { counter += 1 }
-    2.times { Resque::Job.create(:jobs, CallNotifyJob) }
-
-    assert_equal(0, counter)
-    @worker.work(0)
-    assert_equal(2, counter)
-  end
-
-  it 'it calls after_fork after each job' do
-    skip("TRAAAVIS!!!!") if RUBY_VERSION == "1.8.7"
-    # We have to stub out will_fork? to return true, which is going to cause an actual fork(). As such, the
-    # exit!(true) will be called in Worker#work; to share state, use a tempfile
-    file = Tempfile.new("resque_after_fork")
-
-    begin
-      File.open(file.path, "w") {|f| f.write(0)}
-      Resque.after_fork do
-        val = File.read(file).strip.to_i
-        File.open(file.path, "w") {|f| f.write(val + 1)}
-      end
-      2.times { Resque::Job.create(:jobs, CallNotifyJob) }
-
-      val = File.read(file.path).strip.to_i
-      assert_equal(0, val)
-      @worker.stubs(:will_fork?).returns(true)
-      @worker.work(0)
-      val = File.read(file.path).strip.to_i
-      assert_equal(2, val)
-    ensure
-      file.delete
-    end
-  end
-
-  it 'it calls before_first_fork before forking' do
-    Resque.before_first_fork { assert(!$called) }
-
-    Resque::Job.create(:jobs, CallNotifyJob)
-    @worker.work(0)
-  end
-
-  it 'it calls before_fork before forking' do
-    Resque.before_fork { assert(!$called) }
-
-    Resque::Job.create(:jobs, CallNotifyJob)
-    @worker.work(0)
-  end
-
-  it 'it calls after_fork after forking' do
-    Resque.after_fork { assert($called) }
-
-    Resque::Job.create(:jobs, CallNotifyJob)
-    @worker.work(0)
-  end
-
-  it 'it registers multiple before_first_forks' do
-    first = false
-    second = false
-
-    Resque.before_first_fork { first = true }
-    Resque.before_first_fork { second = true }
-    Resque::Job.create(:jobs, CallNotifyJob)
-
-    assert(!first && !second)
-    @worker.work(0)
-    assert(first && second)
-  end
-
-  it 'it registers multiple before_forks' do
-    first = false
-    second = false
-
-    Resque.before_fork { first = true }
-    Resque.before_fork { second = true }
-    Resque::Job.create(:jobs, CallNotifyJob)
-
-    assert(!first && !second)
-    @worker.work(0)
-    assert(first && second)
-  end
-
-  it 'flattens hooks on assignment' do
-    first = false
-    second = false
-    Resque.before_fork = [Proc.new { first = true }, Proc.new { second = true }]
-    Resque::Job.create(:jobs, CallNotifyJob)
-
-    assert(!first && !second)
-    @worker.work(0)
-    assert(first && second)
-  end
-
-  it 'it registers multiple after_forks' do
-    # We have to stub out will_fork? to return true, which is going to cause an actual fork(). As such, the
-    # exit!(true) will be called in Worker#work; to share state, use a tempfile
-    file = Tempfile.new("resque_after_fork_first")
-    file2 = Tempfile.new("resque_after_fork_second")
-    begin
-      File.open(file.path, "w") {|f| f.write(1)}
-      File.open(file2.path, "w") {|f| f.write(2)}
-
-      Resque.after_fork do
-        val = File.read(file.path).strip.to_i
-        File.open(file.path, "w") {|f| f.write(val + 1)}
-      end
-
-      Resque.after_fork do
-        val = File.read(file2.path).strip.to_i
-        File.open(file2.path, "w") {|f| f.write(val + 1)}
-      end
-      Resque::Job.create(:jobs, CallNotifyJob)
-
-      @worker.stubs(:will_fork?).returns(true)
-      @worker.work(0)
-      val = File.read(file.path).strip.to_i
-      val2 = File.read(file2.path).strip.to_i
-      assert_equal(val, 2)
-      assert_equal(val2, 3)
-    ensure
-      file.delete
-      file2.delete
-    end
-  end
-end

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_equal 1, Resque.dequeue(SomeIvarJob, 30, '/tmp')
-    assert_equal 4, Resque.size(:ivar)
-    assert_equal 3, 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 ).sort, Resque.queues.sort
-  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 ).sort, Resque.queues.sort
-    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