nfo-resque-mongo 1.15.0

data/test/plugin_test.rb

@@ -0,0 +1,116 @@
+require 'test_helper'
+
+context "Resque::Plugin finding hooks" do
+  module SimplePlugin
+    extend self
+    def before_perform1; end
+    def before_perform; end
+    def before_perform2; end
+    def after_perform1; end
+    def after_perform; end
+    def after_perform2; end
+    def perform; end
+    def around_perform1; end
+    def around_perform; end
+    def around_perform2; end
+    def on_failure1; end
+    def on_failure; end
+    def on_failure2; end
+  end
+
+  test "before_perform hooks are found and sorted" do
+    assert_equal ["before_perform", "before_perform1", "before_perform2"], Resque::Plugin.before_hooks(SimplePlugin).map {|m| m.to_s}
+  end
+
+  test "after_perform hooks are found and sorted" do
+    assert_equal ["after_perform", "after_perform1", "after_perform2"], Resque::Plugin.after_hooks(SimplePlugin).map {|m| m.to_s}
+  end
+
+  test "around_perform hooks are found and sorted" do
+    assert_equal ["around_perform", "around_perform1", "around_perform2"], Resque::Plugin.around_hooks(SimplePlugin).map {|m| m.to_s}
+  end
+
+  test "on_failure hooks are found and sorted" do
+    assert_equal ["on_failure", "on_failure1", "on_failure2"], Resque::Plugin.failure_hooks(SimplePlugin).map {|m| m.to_s}
+  end
+end
+
+context "Resque::Plugin linting" do
+  module ::BadBefore
+    def self.before_perform; end
+  end
+  module ::BadAfter
+    def self.after_perform; end
+  end
+  module ::BadAround
+    def self.around_perform; end
+  end
+  module ::BadFailure
+    def self.on_failure; end
+  end
+
+  test "before_perform must be namespaced" do
+    begin
+      Resque::Plugin.lint(BadBefore)
+      assert false, "should have failed"
+    rescue Resque::Plugin::LintError => e
+      assert_equal "BadBefore.before_perform is not namespaced", e.message
+    end
+  end
+
+  test "after_perform must be namespaced" do
+    begin
+      Resque::Plugin.lint(BadAfter)
+      assert false, "should have failed"
+    rescue Resque::Plugin::LintError => e
+      assert_equal "BadAfter.after_perform is not namespaced", e.message
+    end
+  end
+
+  test "around_perform must be namespaced" do
+    begin
+      Resque::Plugin.lint(BadAround)
+      assert false, "should have failed"
+    rescue Resque::Plugin::LintError => e
+      assert_equal "BadAround.around_perform is not namespaced", e.message
+    end
+  end
+
+  test "on_failure must be namespaced" do
+    begin
+      Resque::Plugin.lint(BadFailure)
+      assert false, "should have failed"
+    rescue Resque::Plugin::LintError => e
+      assert_equal "BadFailure.on_failure is not namespaced", e.message
+    end
+  end
+
+  module GoodBefore
+    def self.before_perform1; end
+  end
+  module GoodAfter
+    def self.after_perform1; end
+  end
+  module GoodAround
+    def self.around_perform1; end
+  end
+  module GoodFailure
+    def self.on_failure1; end
+  end
+
+  test "before_perform1 is an ok name" do
+    Resque::Plugin.lint(GoodBefore)
+  end
+
+  test "after_perform1 is an ok name" do
+    Resque::Plugin.lint(GoodAfter)
+  end
+
+  test "around_perform1 is an ok name" do
+    Resque::Plugin.lint(GoodAround)
+  end
+
+  test "on_failure1 is an ok name" do
+    Resque::Plugin.lint(GoodFailure)
+  end
+end

data/test/queue_stats_test.rb

@@ -0,0 +1,57 @@
+require File.expand_path(File.dirname(__FILE__)) + '/test_helper'
+
+context "Queue Statistics" do  
+  setup do
+    Resque.flushall
+  end
+  
+  test "Creating a queue named 'test' and check it exists in the queues list" do
+    queue_stats = Resque::QueueStats.new(:test)
+    list = Resque::QueueStats.list
+    assert list.include?('test')
+  end
+  
+  test "Creating queues and check it can be filtered in the queues list" do
+    queue_stats = Resque::QueueStats.new(:abc)
+    queue_stats = Resque::QueueStats.new(:abd)
+    queue_stats = Resque::QueueStats.new(:xyz)
+    
+    list = Resque::QueueStats.list('ab*')
+    assert list.include?('abc')
+    assert list.include?('abd')
+    assert !list.include?('xyz')
+    
+    list = Resque::QueueStats.list(['x*', 'abc'])
+    assert list.include?('abc')
+    assert !list.include?('abd')
+    assert list.include?('xyz')
+  end
+  
+  test "We can add an remove queues" do
+    test_1 = Resque::QueueStats.new(:test1)
+    list = Resque::QueueStats.list
+    assert list.include?('test1')
+    Resque::QueueStats.remove(:test1)
+    list = Resque::QueueStats.list
+    assert !list.include?('test1')
+  end
+  
+  test "both add_job, remove_job and work" do
+    ## test class methods 
+    Resque::QueueStats.add_job(:test)
+    assert_equal 1,Resque::QueueStats.size(:test)
+    Resque::QueueStats.remove_job(:test)
+    assert_equal 0,Resque::QueueStats.size(:test)
+  end
+  
+  
+  test "job counter in QueueStats works" do
+    assert Resque::Job.create(:stats, 'SomeJob', 20, '/tmp')
+    ## same for the class method version
+    assert_equal 1,Resque::QueueStats.size(:stats)
+    assert Resque::Job.create(:stats, 'SomeJob', 22, '/tmp')
+    assert_equal 2,Resque::QueueStats.size(:stats)
+    job = Resque.pop(:stats)
+    assert_equal 1,Resque::QueueStats.size(:stats)
+  end
+end

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/resque-web_test.rb

@@ -0,0 +1,48 @@
+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
+
+# Search failed jobs
+context "on GET to /failed with a search query" do
+  setup {get "/failed?q=toto"}
+  
+  should_respond_with_success
+end
+
+# Stats 
+context "on GET to /stats/resque" do
+  setup { get "/stats/resque" }
+
+  should_respond_with_success
+end

data/test/resque_test.rb

@@ -0,0 +1,256 @@
+require 'test_helper'
+
+context "Resque" do
+  setup do
+    Resque.flushall
+
+    Resque.push(:people, { 'name' => 'chris' })
+    Resque.push(:people, { 'name' => 'bob' })
+    Resque.push(:people, { 'name' => 'mark' })
+  end
+  
+  test "there is a queue named people" do
+    #STDERR.puts Resque.queues.inspect
+    assert Resque.queues.include? 'people'
+  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')
+    assert_equal 2, Resque.size(:jobs)
+  end
+
+  test "can grab jobs off a queue" do
+    Resque::Job.create(:jobs, 'some-job', 20, '/tmp')
+    Resque::Job.create(:jobs, 'some-other-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]
+    assert_equal 1, Resque.size(:jobs)
+  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_equal 1, Resque.size(:ivar)
+    assert Resque.enqueue(SomeIvarJob, 20, '/tmp')
+    assert_equal 2, Resque.size(:ivar)
+    assert Resque.enqueue(SomeIvarJob, 20, '/tmp')
+    assert_equal 3, Resque.size(:ivar)
+    
+    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 "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' => 'chris' }, Resque.peek(:people, 0, 1))
+    assert_equal({ 'name' => 'bob' }, Resque.peek(:people, 1, 1))
+    assert_equal({ 'name' => 'mark' }, Resque.peek(:people, 2, 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 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.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 ["people"], Resque.keys
+  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]
+    assert_equal "localhost:27017/monque/monque", stats[:servers]
+  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