resque 1.23.0 → 2.6.0

data/test/job_plugins_test.rb

@@ -1,230 +0,0 @@
-require 'test_helper'
-
-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
-  end
-
-  module Plugin2
-    def before_perform_record_history2(history)
-      history << :before2
-    end
-    def after_perform_record_history2(history)
-      history << :after2
-    end
-  end
-
-  class ::ManyBeforesJob
-    extend Plugin1
-    extend Plugin2
-    def self.perform(history)
-      history << :perform
-    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"
-    assert_equal [:before1, :before2, :perform, :after1, :after2], history
-  end
-end
-
-context "Resque::Plugin ordering before_perform" do
-  include PerformJob
-
-  module BeforePerformPlugin
-    def before_perform1(history)
-      history << :before_perform1
-    end
-  end
-
-  class ::JobPluginsTestBeforePerformJob
-    extend BeforePerformPlugin
-    def self.perform(history)
-      history << :perform
-    end
-    def self.before_perform(history)
-      history << :before_perform
-    end
-  end
-
-  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
-  include PerformJob
-
-  module AfterPerformPlugin
-    def after_perform_record_history(history)
-      history << :after_perform1
-    end
-  end
-
-  class ::JobPluginsTestAfterPerformJob
-    extend AfterPerformPlugin
-    def self.perform(history)
-      history << :perform
-    end
-    def self.after_perform(history)
-      history << :after_perform
-    end
-  end
-
-  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
-  include PerformJob
-
-  module AroundPerformPlugin1
-    def around_perform1(history)
-      history << :around_perform_plugin1
-      yield
-    end
-  end
-
-  class ::AroundPerformJustPerformsJob
-    extend AroundPerformPlugin1
-    def self.perform(history)
-      history << :perform
-    end
-  end
-
-  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
-
-  class ::JobPluginsTestAroundPerformJob
-    extend AroundPerformPlugin1
-    def self.perform(history)
-      history << :perform
-    end
-    def self.around_perform(history)
-      history << :around_perform
-      yield
-    end
-  end
-
-  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
-
-  module AroundPerformPlugin2
-    def around_perform2(history)
-      history << :around_perform_plugin2
-      yield
-    end
-  end
-
-  class ::AroundPerformJob2
-    extend AroundPerformPlugin1
-    extend AroundPerformPlugin2
-    def self.perform(history)
-      history << :perform
-    end
-    def self.around_perform(history)
-      history << :around_perform
-      yield
-    end
-  end
-
-  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
-
-  module AroundPerformDoesNotYield
-    def around_perform0(history)
-      history << :around_perform0
-    end
-  end
-
-  class ::AroundPerformJob3
-    extend AroundPerformPlugin1
-    extend AroundPerformPlugin2
-    extend AroundPerformDoesNotYield
-    def self.perform(history)
-      history << :perform
-    end
-    def self.around_perform(history)
-      history << :around_perform
-      yield
-    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"
-    assert_equal [:around_perform, :around_perform0], history
-  end
-
-  module AroundPerformGetsJobResult
-    @@result = nil
-    def last_job_result
-      @@result
-    end
-
-    def around_perform_gets_job_result(*args)
-      @@result = yield
-    end
-  end
-
-  class ::AroundPerformJobWithReturnValue < GoodJob
-    extend AroundPerformGetsJobResult
-  end
-
-  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 'Good job, Bob', AroundPerformJobWithReturnValue.last_job_result
-  end
-end
-
-context "Resque::Plugin ordering on_failure" do
-  include PerformJob
-
-  module OnFailurePlugin
-    def on_failure1(exception, history)
-      history << "#{exception.message} plugin"
-    end
-  end
-
-  class ::FailureJob
-    extend OnFailurePlugin
-    def self.perform(history)
-      history << :perform
-      raise StandardError, "oh no"
-    end
-    def self.on_failure(exception, history)
-      history << exception.message
-    end
-  end
-
-  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
-  end
-end

data/test/plugin_test.rb

@@ -1,116 +0,0 @@
-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/redis-test-cluster.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-cluster.pid
-
-# Accept connections on the specified port, default is 6379
-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.
-#
-# 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-cluster.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-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, 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
-    @redis_backend.save
-    Resque::Failure::Redis.all # should not raise an error
-  end
-end