resque-cedar 1.20.0

data/test/redis-test.conf

@@ -0,0 +1,115 @@
+# 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/redis_queue_test.rb

@@ -0,0 +1,133 @@
+require 'test_helper'
+require 'resque/queue'
+
+describe "Resque::Queue" do
+  include Test::Unit::Assertions
+
+  class Thing
+    attr_reader :inside
+
+    def initialize
+      @inside = "x"
+    end
+
+    def == other
+      super || @inside == other.inside
+    end
+  end
+
+  before do
+    Resque.redis.flushall
+  end
+
+  it "generates a redis_name" do
+    assert_equal "queue:foo", q.redis_name
+  end
+
+  it "acts sanely" do
+    queue = q
+    x = Thing.new
+    queue.push x
+    assert_equal x, queue.pop
+  end
+
+  it "blocks on pop" do
+    queue1 = q
+    queue2 = q
+
+    t = Thread.new { queue1.pop }
+    x = Thing.new
+
+    queue2.push x
+    assert_equal x, t.join.value
+  end
+
+  it "nonblocking pop works" do
+    queue1 = q
+    x      = Thing.new
+
+    queue1 << x
+    assert_equal x, queue1.pop
+  end
+
+  it "nonblocking pop doesn't block" do
+    queue1 = q
+
+    assert_raises ThreadError do
+      queue1.pop(true)
+    end
+  end
+
+  it "blocks forever on pop" do
+    queue1 = q
+    assert_raises Timeout::Error do
+      Timeout.timeout(2) { queue1.pop }
+    end
+  end
+
+  it "#size" do
+    queue = q
+
+    begin
+      assert_equal 0, queue.size
+
+      queue << Thing.new
+      assert_equal 1, queue.size
+    ensure
+      queue.pop
+    end
+  end
+
+  it "#empty?" do
+    queue = q
+
+    begin
+      assert queue.empty?
+
+      queue << Thing.new
+      refute queue.empty?
+    ensure
+      queue.pop
+    end
+  end
+
+  it "registers itself with Resque" do
+    q
+
+    assert_equal ["foo"], Resque.queues
+  end
+
+  it "cleans up after itself when destroyed" do
+    queue = q
+    queue << Thing.new
+    q.destroy
+
+    assert_equal [], Resque.queues
+    assert !Resque.redis.exists(queue.redis_name)
+  end
+
+  it "returns false if a queue is not destroyed" do
+    assert !q.destroyed?
+  end
+
+  it "returns true if a queue is destroyed" do
+    queue1 = q
+    queue1.destroy
+    assert queue1.destroyed?
+  end
+
+  it "can't push to queue after destroying it" do
+    queue1 = q
+    x      = Thing.new
+    queue1 << x
+    queue1.destroy
+
+    assert_raise Resque::QueueDestroyed do
+      queue1 << x
+    end
+  end
+
+  def q
+    Resque::Queue.new 'foo', Resque.redis
+  end
+end

data/test/resque-web_test.rb

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

data/test/resque_test.rb

@@ -0,0 +1,284 @@
+require 'test_helper'
+
+describe "Resque" do
+  include Test::Unit::Assertions
+
+  before do
+    Resque.redis.flushall
+
+    Resque.push(:people, { 'name' => 'chris' })
+    Resque.push(:people, { 'name' => 'bob' })
+    Resque.push(:people, { 'name' => 'mark' })
+    @original_redis = Resque.redis
+  end
+
+  after do
+    Resque.redis = @original_redis
+  end
+
+  it "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
+
+  it "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
+
+  it "can put jobs on a queue" do
+    assert Resque::Job.create(:jobs, 'SomeJob', 20, '/tmp')
+    assert Resque::Job.create(:jobs, 'SomeJob', 20, '/tmp')
+  end
+
+  it "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
+
+  it "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
+
+  it "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
+
+  it "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
+
+  it "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
+
+  it "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
+
+  it "jobs can it 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
+
+  it "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
+
+  it "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
+
+  it "needs to infer a queue with enqueue" do
+    assert_raises Resque::NoQueueError do
+      Resque.enqueue(SomeJob, 20, '/tmp')
+    end
+  end
+
+  it "validates job for queue presence" do
+    assert_raises Resque::NoQueueError do
+      Resque.validate(SomeJob)
+    end
+  end
+
+  it "can put items on a queue" do
+    assert Resque.push(:people, { 'name' => 'jon' })
+  end
+
+  it "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
+
+  it "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
+
+  it "can peek at a queue" do
+    assert_equal({ 'name' => 'chris' }, Resque.peek(:people))
+    assert_equal 3, Resque.size(:people)
+  end
+
+  it "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
+
+  it "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
+
+  it "queues are always a list" do
+    Resque.redis.flushall
+    assert_equal [], Resque.queues
+  end
+
+  it "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
+
+  it "keeps track of resque keys" do
+    assert_equal ["queue:people", "queues"].sort, Resque.keys.sort
+  end
+
+  it "badly wants a class name, too" do
+    assert_raises Resque::NoClassError do
+      Resque::Job.create(:jobs, nil)
+    end
+  end
+
+  it "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
+
+  it "decode bad json" do
+    assert_raises Resque::DecodeException do
+      Resque.coder.decode("{\"error\":\"Module not found \\u002\"}")
+    end
+  end
+
+  it "inlining jobs" do
+    begin
+      Resque.inline = true
+      Resque.enqueue(SomeIvarJob, 20, '/tmp')
+      assert_equal 0, Resque.size(:ivar)
+    ensure
+      Resque.inline = false
+    end
+  end
+
+  it 'treats symbols and strings the same' do
+    assert_equal Resque.queue(:people), Resque.queue('people')
+  end
+end