resque-loner 1.2.1 → 1.3.0

data/test/job_plugins_test.rb

@@ -1,12 +1,13 @@
 require 'test_helper'
 
-context "Multiple plugins with multiple hooks" do
+context 'Multiple plugins with multiple hooks' do
   include PerformJob
 
   module Plugin1
     def before_perform_record_history1(history)
       history << :before1
     end
+
     def after_perform_record_history1(history)
       history << :after1
     end
@@ -16,6 +17,7 @@ context "Multiple plugins with multiple hooks" do
     def before_perform_record_history2(history)
       history << :before2
     end
+
     def after_perform_record_history2(history)
       history << :after2
     end
@@ -29,14 +31,14 @@ context "Multiple plugins with multiple hooks" do
     end
   end
 
-  test "hooks of each type are executed in alphabetical order" do
-    result = perform_job(ManyBeforesJob, history=[])
-    assert_equal true, result, "perform returned true"
+  test 'hooks of each type are executed in alphabetical order' do
+    result = perform_job(ManyBeforesJob, history = [])
+    assert_equal true, result, 'perform returned true'
     assert_equal [:before1, :before2, :perform, :after1, :after2], history
   end
 end
 
-context "Resque::Plugin ordering before_perform" do
+context 'Resque::Plugin ordering before_perform' do
   include PerformJob
 
   module BeforePerformPlugin
@@ -55,14 +57,14 @@ context "Resque::Plugin ordering before_perform" do
     end
   end
 
-  test "before_perform hooks are executed in order" do
-    result = perform_job(JobPluginsTestBeforePerformJob, history=[])
-    assert_equal true, result, "perform returned true"
+  test 'before_perform hooks are executed in order' do
+    result = perform_job(JobPluginsTestBeforePerformJob, history = [])
+    assert_equal true, result, 'perform returned true'
     assert_equal [:before_perform, :before_perform1, :perform], history
   end
 end
 
-context "Resque::Plugin ordering after_perform" do
+context 'Resque::Plugin ordering after_perform' do
   include PerformJob
 
   module AfterPerformPlugin
@@ -81,14 +83,14 @@ context "Resque::Plugin ordering after_perform" do
     end
   end
 
-  test "after_perform hooks are executed in order" do
-    result = perform_job(JobPluginsTestAfterPerformJob, history=[])
-    assert_equal true, result, "perform returned true"
+  test 'after_perform hooks are executed in order' do
+    result = perform_job(JobPluginsTestAfterPerformJob, history = [])
+    assert_equal true, result, 'perform returned true'
     assert_equal [:perform, :after_perform, :after_perform1], history
   end
 end
 
-context "Resque::Plugin ordering around_perform" do
+context 'Resque::Plugin ordering around_perform' do
   include PerformJob
 
   module AroundPerformPlugin1
@@ -105,9 +107,9 @@ context "Resque::Plugin ordering around_perform" do
     end
   end
 
-  test "around_perform hooks are executed before the job" do
-    result = perform_job(AroundPerformJustPerformsJob, history=[])
-    assert_equal true, result, "perform returned true"
+  test 'around_perform hooks are executed before the job' do
+    result = perform_job(AroundPerformJustPerformsJob, history = [])
+    assert_equal true, result, 'perform returned true'
     assert_equal [:around_perform_plugin1, :perform], history
   end
 
@@ -122,9 +124,9 @@ context "Resque::Plugin ordering around_perform" do
     end
   end
 
-  test "around_perform hooks are executed in order" do
-    result = perform_job(JobPluginsTestAroundPerformJob, history=[])
-    assert_equal true, result, "perform returned true"
+  test 'around_perform hooks are executed in order' do
+    result = perform_job(JobPluginsTestAroundPerformJob, history = [])
+    assert_equal true, result, 'perform returned true'
     assert_equal [:around_perform, :around_perform_plugin1, :perform], history
   end
 
@@ -147,9 +149,9 @@ context "Resque::Plugin ordering around_perform" do
     end
   end
 
-  test "many around_perform are executed in order" do
-    result = perform_job(AroundPerformJob2, history=[])
-    assert_equal true, result, "perform returned true"
+  test 'many around_perform are executed in order' do
+    result = perform_job(AroundPerformJob2, history = [])
+    assert_equal true, result, 'perform returned true'
     assert_equal [:around_perform, :around_perform_plugin1, :around_perform_plugin2, :perform], history
   end
 
@@ -172,9 +174,9 @@ context "Resque::Plugin ordering around_perform" do
     end
   end
 
-  test "the job is aborted if an around_perform hook does not yield" do
-    result = perform_job(AroundPerformJob3, history=[])
-    assert_equal false, result, "perform returned false"
+  test 'the job is aborted if an around_perform hook does not yield' do
+    result = perform_job(AroundPerformJob3, history = [])
+    assert_equal false, result, 'perform returned false'
     assert_equal [:around_perform, :around_perform0], history
   end
 
@@ -193,14 +195,14 @@ context "Resque::Plugin ordering around_perform" do
     extend AroundPerformGetsJobResult
   end
 
-  test "the job is aborted if an around_perform hook does not yield" do
+  test 'the job is aborted if an around_perform hook does not yield' do
     result = perform_job(AroundPerformJobWithReturnValue, 'Bob')
-    assert_equal true, result, "perform returned true"
+    assert_equal true, result, 'perform returned true'
     assert_equal 'Good job, Bob', AroundPerformJobWithReturnValue.last_job_result
   end
 end
 
-context "Resque::Plugin ordering on_failure" do
+context 'Resque::Plugin ordering on_failure' do
   include PerformJob
 
   module OnFailurePlugin
@@ -213,18 +215,18 @@ context "Resque::Plugin ordering on_failure" do
     extend OnFailurePlugin
     def self.perform(history)
       history << :perform
-      raise StandardError, "oh no"
+      fail StandardError, 'oh no'
     end
     def self.on_failure(exception, history)
       history << exception.message
     end
   end
 
-  test "on_failure hooks are executed in order" do
+  test 'on_failure hooks are executed in order' do
     history = []
     assert_raises StandardError do
       perform_job(FailureJob, history)
     end
-    assert_equal [:perform, "oh no", "oh no plugin"], history
+    assert_equal [:perform, 'oh no', 'oh no plugin'], history
   end
 end

data/test/plugin_test.rb

@@ -1,41 +1,53 @@
 require 'test_helper'
 
-context "Resque::Plugin finding hooks" do
+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}
+  test 'before_perform hooks are found and sorted' do
+    assert_equal %w(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}
+  test 'after_perform hooks are found and sorted' do
+    assert_equal %w(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}
+  test 'around_perform hooks are found and sorted' do
+    assert_equal %w(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}
+  test 'on_failure hooks are found and sorted' do
+    assert_equal %w(on_failure on_failure1 on_failure2), Resque::Plugin.failure_hooks(SimplePlugin).map { |m| m.to_s }
   end
 end
 
-context "Resque::Plugin linting" do
+context 'Resque::Plugin linting' do
   module ::BadBefore
     def self.before_perform; end
   end
@@ -49,39 +61,39 @@ context "Resque::Plugin linting" do
     def self.on_failure; end
   end
 
-  test "before_perform must be namespaced" do
+  test 'before_perform must be namespaced' do
     begin
       Resque::Plugin.lint(BadBefore)
-      assert false, "should have failed"
+      assert false, 'should have failed'
     rescue Resque::Plugin::LintError => e
-      assert_equal "BadBefore.before_perform is not namespaced", e.message
+      assert_equal 'BadBefore.before_perform is not namespaced', e.message
     end
   end
 
-  test "after_perform must be namespaced" do
+  test 'after_perform must be namespaced' do
     begin
       Resque::Plugin.lint(BadAfter)
-      assert false, "should have failed"
+      assert false, 'should have failed'
     rescue Resque::Plugin::LintError => e
-      assert_equal "BadAfter.after_perform is not namespaced", e.message
+      assert_equal 'BadAfter.after_perform is not namespaced', e.message
     end
   end
 
-  test "around_perform must be namespaced" do
+  test 'around_perform must be namespaced' do
     begin
       Resque::Plugin.lint(BadAround)
-      assert false, "should have failed"
+      assert false, 'should have failed'
     rescue Resque::Plugin::LintError => e
-      assert_equal "BadAround.around_perform is not namespaced", e.message
+      assert_equal 'BadAround.around_perform is not namespaced', e.message
     end
   end
 
-  test "on_failure must be namespaced" do
+  test 'on_failure must be namespaced' do
     begin
       Resque::Plugin.lint(BadFailure)
-      assert false, "should have failed"
+      assert false, 'should have failed'
     rescue Resque::Plugin::LintError => e
-      assert_equal "BadFailure.on_failure is not namespaced", e.message
+      assert_equal 'BadFailure.on_failure is not namespaced', e.message
     end
   end
 
@@ -98,19 +110,19 @@ context "Resque::Plugin linting" do
     def self.on_failure1; end
   end
 
-  test "before_perform1 is an ok name" do
+  test 'before_perform1 is an ok name' do
     Resque::Plugin.lint(GoodBefore)
   end
 
-  test "after_perform1 is an ok name" do
+  test 'after_perform1 is an ok name' do
     Resque::Plugin.lint(GoodAfter)
   end
 
-  test "around_perform1 is an ok name" do
+  test 'around_perform1 is an ok name' do
     Resque::Plugin.lint(GoodAround)
   end
 
-  test "on_failure1 is an ok name" do
+  test 'on_failure1 is an ok name' do
     Resque::Plugin.lint(GoodFailure)
   end
 end

data/{spec/redis-test.conf → test/redis-test-cluster.conf}

@@ -6,10 +6,10 @@ 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 ./spec/redis-test.pid
+pidfile ./test/redis-test-cluster.pid
 
 # Accept connections on the specified port, default is 6379
-port 9736
+port 9737
 
 # If you want you can bind a single interface, if the bind option is not
 # specified all the interfaces will listen for connections.
@@ -35,11 +35,11 @@ save 300 10
 save 60 10000
 
 # The filename where to dump the DB
-dbfilename dump.rdb
+dbfilename dump-cluster.rdb
 
 # For default save/load DB in/from the working directory
 # Note that you must specify a directory not a file name.
-dir ./spec/
+dir ./test/
 
 # Set server verbosity to 'debug'
 # it can be one of:

data/test/resque-web_test.rb

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

data/test/resque_failure_redis_test.rb

@@ -0,0 +1,23 @@
+require 'test_helper'
+require 'resque/failure/redis'
+
+context 'Resque::Failure::Redis' do
+  setup do
+    @bad_string    = [39, 250, 141, 168, 138, 191, 52, 211, 159, 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
+    assert_raises(MultiJson::DecodeError) do
+      MultiJson.decode(MultiJson.encode(@bad_string))
+    end
+
+    @redis_backend.save
+    Resque::Failure::Redis.all # should not raise an error
+  end
+end

data/test/resque_test.rb

@@ -1,36 +1,41 @@
 require 'test_helper'
 
-context "Resque" do
+context 'Resque' do
   setup do
     Resque.redis.flushall
 
-    Resque.push(:people, { 'name' => 'chris' })
-    Resque.push(:people, { 'name' => 'bob' })
-    Resque.push(:people, { 'name' => 'mark' })
+    Resque.push(:people,  'name' => 'chris')
+    Resque.push(:people,  'name' => 'bob')
+    Resque.push(:people,  'name' => 'mark')
+    @original_redis = Resque.redis
   end
 
-  test "can set a namespace through a url-like string" do
+  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)
+  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
+  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
+  test 'can grab jobs off a queue' do
     Resque::Job.create(:jobs, 'some-job', 20, '/tmp')
 
     job = Resque.reserve(:jobs)
@@ -41,7 +46,7 @@ context "Resque" do
     assert_equal '/tmp', job.args[1]
   end
 
-  test "can re-queue jobs" do
+  test 'can re-queue jobs' do
     Resque::Job.create(:jobs, 'some-job', 20, '/tmp')
 
     job = Resque.reserve(:jobs)
@@ -50,7 +55,7 @@ context "Resque" do
     assert_equal job, Resque.reserve(:jobs)
   end
 
-  test "can put jobs on a queue by way of an ivar" do
+  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')
@@ -66,7 +71,7 @@ context "Resque" do
     assert_equal nil, Resque.reserve(:ivar)
   end
 
-  test "can remove jobs from a queue by way of an ivar" do
+  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')
@@ -81,13 +86,13 @@ context "Resque" do
     assert_equal 1, Resque.size(:ivar)
   end
 
-  test "jobs have a nice #inspect" do
+  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
+  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')
@@ -101,7 +106,7 @@ context "Resque" do
     assert_equal 2, Resque.size(:jobs)
   end
 
-  test "jobs can test for equality" do
+  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)
@@ -115,7 +120,7 @@ context "Resque" do
     assert_not_equal Resque.reserve(:jobs), Resque.reserve(:jobs)
   end
 
-  test "can put jobs on a queue by way of a method" do
+  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')
@@ -131,30 +136,40 @@ context "Resque" do
     assert_equal nil, Resque.reserve(:method)
   end
 
-  test "needs to infer a queue with enqueue" do
+  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
+  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' })
+  test 'can put items on a queue' do
+    assert Resque.push(:people,  'name' => 'jon')
   end
 
-  test "can pull items off a queue" do
+  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
+  test 'knows how big a queue is' do
     assert_equal 3, Resque.size(:people)
 
     assert_equal({ 'name' => 'chris' }, Resque.pop(:people))
@@ -165,12 +180,12 @@ context "Resque" do
     assert_equal 0, Resque.size(:people)
   end
 
-  test "can peek at a queue" do
+  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
+  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))
@@ -181,36 +196,36 @@ context "Resque" do
     assert_equal [], Resque.peek(:people, 3, 2)
   end
 
-  test "knows what queues it is managing" do
+  test 'knows what queues it is managing' do
     assert_equal %w( people ), Resque.queues
-    Resque.push(:cars, { 'make' => 'bmw' })
+    Resque.push(:cars,  'make' => 'bmw')
     assert_equal %w( cars people ), Resque.queues
   end
 
-  test "queues are always a list" do
+  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' })
+  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"], Resque.keys
+  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
+  test 'badly wants a class name, too' do
     assert_raises Resque::NoClassError do
       Resque::Job.create(:jobs, nil)
     end
   end
 
-  test "keeps stats" do
+  test 'keeps stats' do
     Resque::Job.create(:jobs, SomeJob, 20, '/tmp')
     Resque::Job.create(:jobs, BadJob)
     Resque::Job.create(:jobs, GoodJob)
@@ -238,16 +253,20 @@ context "Resque" do
     assert_equal 3, stats[:queues]
     assert_equal 3, stats[:processed]
     assert_equal 1, stats[:failed]
-    assert_equal [Resque.redis.respond_to?(:server) ? 'localhost:9736' : 'redis://localhost:9736/0'], stats[:servers]
+    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
+  test 'decode bad json' do
     assert_raises Resque::Helpers::DecodeException do
       Resque.decode("{\"error\":\"Module not found \\u002\"}")
     end
   end
 
-  test "inlining jobs" do
+  test 'inlining jobs' do
     begin
       Resque.inline = true
       Resque.enqueue(SomeIvarJob, 20, '/tmp')