resque 1.26.pre.0 → 1.26.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/logging_test.rb

@@ -1,24 +0,0 @@
-require 'test_helper'
-require 'minitest/mock'
-
-context "Resque::Logging" do
-  teardown { reset_logger }
-
-  test "sets and receives the active logger" do
-    my_logger = Object.new
-    Resque.logger = my_logger
-    assert_equal my_logger, Resque.logger
-  end
-
-  %w(debug info error fatal).each do |severity|
-    test "logs #{severity} messages" do
-      message       = "test message"
-      mock_logger   = MiniTest::Mock.new
-      mock_logger.expect severity.to_sym, nil, [message]
-      Resque.logger = mock_logger
-
-      Resque::Logging.send severity, message
-      mock_logger.verify
-    end
-  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