resque_sqs 1.25.2

data/test/plugin_test.rb

@@ -0,0 +1,116 @@
+require 'test_helper'
+
+context "ResqueSqs::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"], ResqueSqs::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"], ResqueSqs::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"], ResqueSqs::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"], ResqueSqs::Plugin.failure_hooks(SimplePlugin).map {|m| m.to_s}
+  end
+end
+
+context "ResqueSqs::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
+      ResqueSqs::Plugin.lint(BadBefore)
+      assert false, "should have failed"
+    rescue ResqueSqs::Plugin::LintError => e
+      assert_equal "BadBefore.before_perform is not namespaced", e.message
+    end
+  end
+
+  test "after_perform must be namespaced" do
+    begin
+      ResqueSqs::Plugin.lint(BadAfter)
+      assert false, "should have failed"
+    rescue ResqueSqs::Plugin::LintError => e
+      assert_equal "BadAfter.after_perform is not namespaced", e.message
+    end
+  end
+
+  test "around_perform must be namespaced" do
+    begin
+      ResqueSqs::Plugin.lint(BadAround)
+      assert false, "should have failed"
+    rescue ResqueSqs::Plugin::LintError => e
+      assert_equal "BadAround.around_perform is not namespaced", e.message
+    end
+  end
+
+  test "on_failure must be namespaced" do
+    begin
+      ResqueSqs::Plugin.lint(BadFailure)
+      assert false, "should have failed"
+    rescue ResqueSqs::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
+    ResqueSqs::Plugin.lint(GoodBefore)
+  end
+
+  test "after_perform1 is an ok name" do
+    ResqueSqs::Plugin.lint(GoodAfter)
+  end
+
+  test "around_perform1 is an ok name" do
+    ResqueSqs::Plugin.lint(GoodAround)
+  end
+
+  test "on_failure1 is an ok name" do
+    ResqueSqs::Plugin.lint(GoodFailure)
+  end
+end

data/test/redis-test-cluster.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-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

@@ -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,59 @@
+require 'test_helper'
+require 'resque_sqs/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

@@ -0,0 +1,19 @@
+require 'test_helper'
+require 'resque_sqs/failure/redis'
+
+context "ResqueSqs::Failure::Redis" do
+  setup do
+    @bad_string    = [39, 52, 127, 86, 93, 95, 39].map { |c| c.chr }.join
+    exception      = StandardError.exception(@bad_string)
+    worker         = ResqueSqs::Worker.new(:test)
+    queue          = "queue"
+    payload        = { "class" => Object, "args" => 3 }
+    @redis_backend = ResqueSqs::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
+    ResqueSqs::Failure::Redis.all # should not raise an error
+  end
+end

data/test/resque_hook_test.rb

@@ -0,0 +1,165 @@
+require 'test_helper'
+require 'tempfile'
+
+describe "Resque Hooks" do
+  before do
+    ResqueSqs.redis.flushall
+
+    ResqueSqs.before_first_fork = nil
+    ResqueSqs.before_fork = nil
+    ResqueSqs.after_fork = nil
+
+    @worker = ResqueSqs::Worker.new(:jobs)
+
+    $called = false
+
+    class CallNotifyJob
+      def self.perform
+        $called = true
+      end
+    end
+  end
+
+  it 'retrieving hooks if none have been set' do
+    assert_equal [], ResqueSqs.before_first_fork
+    assert_equal [], ResqueSqs.before_fork
+    assert_equal [], ResqueSqs.after_fork
+  end
+
+  it 'it calls before_first_fork once' do
+    counter = 0
+
+    ResqueSqs.before_first_fork { counter += 1 }
+    2.times { ResqueSqs::Job.create(:jobs, CallNotifyJob) }
+
+    assert_equal(0, counter)
+    @worker.work(0)
+    assert_equal(1, counter)
+  end
+
+  it 'it calls before_fork before each job' do
+    counter = 0
+
+    ResqueSqs.before_fork { counter += 1 }
+    2.times { ResqueSqs::Job.create(:jobs, CallNotifyJob) }
+
+    assert_equal(0, counter)
+    @worker.work(0)
+    assert_equal(2, counter)
+  end
+
+  it 'it calls after_fork after each job' do
+    skip("TRAAAVIS!!!!") if RUBY_VERSION == "1.8.7"
+    # We have to stub out will_fork? to return true, which is going to cause an actual fork(). As such, the
+    # exit!(true) will be called in Worker#work; to share state, use a tempfile
+    file = Tempfile.new("resque_after_fork")
+
+    begin
+      File.open(file.path, "w") {|f| f.write(0)}
+      ResqueSqs.after_fork do
+        val = File.read(file).strip.to_i
+        File.open(file.path, "w") {|f| f.write(val + 1)}
+      end
+      2.times { ResqueSqs::Job.create(:jobs, CallNotifyJob) }
+
+      val = File.read(file.path).strip.to_i
+      assert_equal(0, val)
+      @worker.stubs(:will_fork?).returns(true)
+      @worker.work(0)
+      val = File.read(file.path).strip.to_i
+      assert_equal(2, val)
+    ensure
+      file.delete
+    end
+  end
+
+  it 'it calls before_first_fork before forking' do
+    ResqueSqs.before_first_fork { assert(!$called) }
+
+    ResqueSqs::Job.create(:jobs, CallNotifyJob)
+    @worker.work(0)
+  end
+
+  it 'it calls before_fork before forking' do
+    ResqueSqs.before_fork { assert(!$called) }
+
+    ResqueSqs::Job.create(:jobs, CallNotifyJob)
+    @worker.work(0)
+  end
+
+  it 'it calls after_fork after forking' do
+    ResqueSqs.after_fork { assert($called) }
+
+    ResqueSqs::Job.create(:jobs, CallNotifyJob)
+    @worker.work(0)
+  end
+
+  it 'it registers multiple before_first_forks' do
+    first = false
+    second = false
+
+    ResqueSqs.before_first_fork { first = true }
+    ResqueSqs.before_first_fork { second = true }
+    ResqueSqs::Job.create(:jobs, CallNotifyJob)
+
+    assert(!first && !second)
+    @worker.work(0)
+    assert(first && second)
+  end
+
+  it 'it registers multiple before_forks' do
+    first = false
+    second = false
+
+    ResqueSqs.before_fork { first = true }
+    ResqueSqs.before_fork { second = true }
+    ResqueSqs::Job.create(:jobs, CallNotifyJob)
+
+    assert(!first && !second)
+    @worker.work(0)
+    assert(first && second)
+  end
+
+  it 'flattens hooks on assignment' do
+    first = false
+    second = false
+    ResqueSqs.before_fork = [Proc.new { first = true }, Proc.new { second = true }]
+    ResqueSqs::Job.create(:jobs, CallNotifyJob)
+
+    assert(!first && !second)
+    @worker.work(0)
+    assert(first && second)
+  end
+
+  it 'it registers multiple after_forks' do
+    # We have to stub out will_fork? to return true, which is going to cause an actual fork(). As such, the
+    # exit!(true) will be called in Worker#work; to share state, use a tempfile
+    file = Tempfile.new("resque_after_fork_first")
+    file2 = Tempfile.new("resque_after_fork_second")
+    begin
+      File.open(file.path, "w") {|f| f.write(1)}
+      File.open(file2.path, "w") {|f| f.write(2)}
+
+      ResqueSqs.after_fork do
+        val = File.read(file.path).strip.to_i
+        File.open(file.path, "w") {|f| f.write(val + 1)}
+      end
+
+      ResqueSqs.after_fork do
+        val = File.read(file2.path).strip.to_i
+        File.open(file2.path, "w") {|f| f.write(val + 1)}
+      end
+      ResqueSqs::Job.create(:jobs, CallNotifyJob)
+
+      @worker.stubs(:will_fork?).returns(true)
+      @worker.work(0)
+      val = File.read(file.path).strip.to_i
+      val2 = File.read(file2.path).strip.to_i
+      assert_equal(val, 2)
+      assert_equal(val2, 3)
+    ensure
+      file.delete
+      file2.delete
+    end
+  end
+end