resque_sqs 1.25.2

data/test/resque_test.rb

@@ -0,0 +1,278 @@
+require 'test_helper'
+
+context "Resque" do
+  setup do
+    ResqueSqs.redis.flushall
+
+    ResqueSqs.push(:people, { 'name' => 'chris' })
+    ResqueSqs.push(:people, { 'name' => 'bob' })
+    ResqueSqs.push(:people, { 'name' => 'mark' })
+    @original_redis = ResqueSqs.redis
+  end
+
+  teardown do
+    ResqueSqs.redis = @original_redis
+  end
+
+  test "can set a namespace through a url-like string" do
+    assert ResqueSqs.redis
+    assert_equal :resque, ResqueSqs.redis.namespace
+    ResqueSqs.redis = 'localhost:9736/namespace'
+    assert_equal 'namespace', ResqueSqs.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)
+    ResqueSqs.redis = new_namespace
+    assert_equal new_namespace, ResqueSqs.redis
+
+    ResqueSqs.redis = 'localhost:9736/namespace'
+  end
+
+  test "can put jobs on a queue" do
+    assert ResqueSqs::Job.create(:jobs, 'SomeJob', 20, '/tmp')
+    assert ResqueSqs::Job.create(:jobs, 'SomeJob', 20, '/tmp')
+  end
+
+  test "can grab jobs off a queue" do
+    ResqueSqs::Job.create(:jobs, 'some-job', 20, '/tmp')
+
+    job = ResqueSqs.reserve(:jobs)
+
+    assert_kind_of ResqueSqs::Job, job
+    assert_equal SomeJob, job.payload_class
+    assert_equal 20, job.args[0]
+    assert_equal '/tmp', job.args[1]
+  end
+
+  test "can re-queue jobs" do
+    ResqueSqs::Job.create(:jobs, 'some-job', 20, '/tmp')
+
+    job = ResqueSqs.reserve(:jobs)
+    job.recreate
+
+    assert_equal job, ResqueSqs.reserve(:jobs)
+  end
+
+  test "can put jobs on a queue by way of an ivar" do
+    assert_equal 0, ResqueSqs.size(:ivar)
+    assert ResqueSqs.enqueue(SomeIvarJob, 20, '/tmp')
+    assert ResqueSqs.enqueue(SomeIvarJob, 20, '/tmp')
+
+    job = ResqueSqs.reserve(:ivar)
+
+    assert_kind_of ResqueSqs::Job, job
+    assert_equal SomeIvarJob, job.payload_class
+    assert_equal 20, job.args[0]
+    assert_equal '/tmp', job.args[1]
+
+    assert ResqueSqs.reserve(:ivar)
+    assert_equal nil, ResqueSqs.reserve(:ivar)
+  end
+
+  test "can remove jobs from a queue by way of an ivar" do
+    assert_equal 0, ResqueSqs.size(:ivar)
+    assert ResqueSqs.enqueue(SomeIvarJob, 20, '/tmp')
+    assert ResqueSqs.enqueue(SomeIvarJob, 30, '/tmp')
+    assert ResqueSqs.enqueue(SomeIvarJob, 20, '/tmp')
+    assert ResqueSqs::Job.create(:ivar, 'blah-job', 20, '/tmp')
+    assert ResqueSqs.enqueue(SomeIvarJob, 20, '/tmp')
+    assert_equal 5, ResqueSqs.size(:ivar)
+
+    assert_equal 1, ResqueSqs.dequeue(SomeIvarJob, 30, '/tmp')
+    assert_equal 4, ResqueSqs.size(:ivar)
+    assert_equal 3, ResqueSqs.dequeue(SomeIvarJob)
+    assert_equal 1, ResqueSqs.size(:ivar)
+  end
+
+  test "jobs have a nice #inspect" do
+    assert ResqueSqs::Job.create(:jobs, 'SomeJob', 20, '/tmp')
+    job = ResqueSqs.reserve(:jobs)
+    assert_equal '(Job{jobs} | SomeJob | [20, "/tmp"])', job.inspect
+  end
+
+  test "jobs can be destroyed" do
+    assert ResqueSqs::Job.create(:jobs, 'SomeJob', 20, '/tmp')
+    assert ResqueSqs::Job.create(:jobs, 'BadJob', 20, '/tmp')
+    assert ResqueSqs::Job.create(:jobs, 'SomeJob', 20, '/tmp')
+    assert ResqueSqs::Job.create(:jobs, 'BadJob', 30, '/tmp')
+    assert ResqueSqs::Job.create(:jobs, 'BadJob', 20, '/tmp')
+
+    assert_equal 5, ResqueSqs.size(:jobs)
+    assert_equal 2, ResqueSqs::Job.destroy(:jobs, 'SomeJob')
+    assert_equal 3, ResqueSqs.size(:jobs)
+    assert_equal 1, ResqueSqs::Job.destroy(:jobs, 'BadJob', 30, '/tmp')
+    assert_equal 2, ResqueSqs.size(:jobs)
+  end
+
+  test "jobs can test for equality" do
+    assert ResqueSqs::Job.create(:jobs, 'SomeJob', 20, '/tmp')
+    assert ResqueSqs::Job.create(:jobs, 'some-job', 20, '/tmp')
+    assert_equal ResqueSqs.reserve(:jobs), ResqueSqs.reserve(:jobs)
+
+    assert ResqueSqs::Job.create(:jobs, 'SomeMethodJob', 20, '/tmp')
+    assert ResqueSqs::Job.create(:jobs, 'SomeJob', 20, '/tmp')
+    assert_not_equal ResqueSqs.reserve(:jobs), ResqueSqs.reserve(:jobs)
+
+    assert ResqueSqs::Job.create(:jobs, 'SomeJob', 20, '/tmp')
+    assert ResqueSqs::Job.create(:jobs, 'SomeJob', 30, '/tmp')
+    assert_not_equal ResqueSqs.reserve(:jobs), ResqueSqs.reserve(:jobs)
+  end
+
+  test "can put jobs on a queue by way of a method" do
+    assert_equal 0, ResqueSqs.size(:method)
+    assert ResqueSqs.enqueue(SomeMethodJob, 20, '/tmp')
+    assert ResqueSqs.enqueue(SomeMethodJob, 20, '/tmp')
+
+    job = ResqueSqs.reserve(:method)
+
+    assert_kind_of ResqueSqs::Job, job
+    assert_equal SomeMethodJob, job.payload_class
+    assert_equal 20, job.args[0]
+    assert_equal '/tmp', job.args[1]
+
+    assert ResqueSqs.reserve(:method)
+    assert_equal nil, ResqueSqs.reserve(:method)
+  end
+
+  test "can define a queue for jobs by way of a method" do
+    assert_equal 0, ResqueSqs.size(:method)
+    assert ResqueSqs.enqueue_to(:new_queue, SomeMethodJob, 20, '/tmp')
+
+    job = ResqueSqs.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 ResqueSqs::NoQueueError do
+      ResqueSqs.enqueue(SomeJob, 20, '/tmp')
+    end
+  end
+
+  test "validates job for queue presence" do
+    assert_raises ResqueSqs::NoQueueError do
+      ResqueSqs.validate(SomeJob)
+    end
+  end
+
+  test "can put items on a queue" do
+    assert ResqueSqs.push(:people, { 'name' => 'jon' })
+  end
+
+  test "can pull items off a queue" do
+    assert_equal({ 'name' => 'chris' }, ResqueSqs.pop(:people))
+    assert_equal({ 'name' => 'bob' }, ResqueSqs.pop(:people))
+    assert_equal({ 'name' => 'mark' }, ResqueSqs.pop(:people))
+    assert_equal nil, ResqueSqs.pop(:people)
+  end
+
+  test "knows how big a queue is" do
+    assert_equal 3, ResqueSqs.size(:people)
+
+    assert_equal({ 'name' => 'chris' }, ResqueSqs.pop(:people))
+    assert_equal 2, ResqueSqs.size(:people)
+
+    assert_equal({ 'name' => 'bob' }, ResqueSqs.pop(:people))
+    assert_equal({ 'name' => 'mark' }, ResqueSqs.pop(:people))
+    assert_equal 0, ResqueSqs.size(:people)
+  end
+
+  test "can peek at a queue" do
+    assert_equal({ 'name' => 'chris' }, ResqueSqs.peek(:people))
+    assert_equal 3, ResqueSqs.size(:people)
+  end
+
+  test "can peek multiple items on a queue" do
+    assert_equal({ 'name' => 'bob' }, ResqueSqs.peek(:people, 1, 1))
+
+    assert_equal([{ 'name' => 'bob' }, { 'name' => 'mark' }], ResqueSqs.peek(:people, 1, 2))
+    assert_equal([{ 'name' => 'chris' }, { 'name' => 'bob' }], ResqueSqs.peek(:people, 0, 2))
+    assert_equal([{ 'name' => 'chris' }, { 'name' => 'bob' }, { 'name' => 'mark' }], ResqueSqs.peek(:people, 0, 3))
+    assert_equal({ 'name' => 'mark' }, ResqueSqs.peek(:people, 2, 1))
+    assert_equal nil, ResqueSqs.peek(:people, 3)
+    assert_equal [], ResqueSqs.peek(:people, 3, 2)
+  end
+
+  test "knows what queues it is managing" do
+    assert_equal %w( people ), ResqueSqs.queues
+    ResqueSqs.push(:cars, { 'make' => 'bmw' })
+    assert_equal %w( cars people ).sort, ResqueSqs.queues.sort
+  end
+
+  test "queues are always a list" do
+    ResqueSqs.redis.flushall
+    assert_equal [], ResqueSqs.queues
+  end
+
+  test "can delete a queue" do
+    ResqueSqs.push(:cars, { 'make' => 'bmw' })
+    assert_equal %w( cars people ).sort, ResqueSqs.queues.sort
+    ResqueSqs.remove_queue(:people)
+    assert_equal %w( cars ), ResqueSqs.queues
+    assert_equal nil, ResqueSqs.pop(:people)
+  end
+
+  test "keeps track of resque keys" do
+    assert_equal ["queue:people", "queues"].sort, ResqueSqs.keys.sort
+  end
+
+  test "badly wants a class name, too" do
+    assert_raises ResqueSqs::NoClassError do
+      ResqueSqs::Job.create(:jobs, nil)
+    end
+  end
+
+  test "keeps stats" do
+    ResqueSqs::Job.create(:jobs, SomeJob, 20, '/tmp')
+    ResqueSqs::Job.create(:jobs, BadJob)
+    ResqueSqs::Job.create(:jobs, GoodJob)
+
+    ResqueSqs::Job.create(:others, GoodJob)
+    ResqueSqs::Job.create(:others, GoodJob)
+
+    stats = ResqueSqs.info
+    assert_equal 8, stats[:pending]
+
+    @worker = ResqueSqs::Worker.new(:jobs)
+    @worker.register_worker
+    2.times { @worker.process }
+
+    job = @worker.reserve
+    @worker.working_on job
+
+    stats = ResqueSqs.info
+    assert_equal 1, stats[:working]
+    assert_equal 1, stats[:workers]
+
+    @worker.done_working
+
+    stats = ResqueSqs.info
+    assert_equal 3, stats[:queues]
+    assert_equal 3, stats[:processed]
+    assert_equal 1, stats[:failed]
+    if ENV.key? 'RESQUE_DISTRIBUTED'
+      assert_equal [ResqueSqs.redis.respond_to?(:server) ? 'localhost:9736, localhost:9737' : 'redis://localhost:9736/0, redis://localhost:9737/0'], stats[:servers]
+    else
+      assert_equal [ResqueSqs.redis.respond_to?(:server) ? 'localhost:9736' : 'redis://localhost:9736/0'], stats[:servers]
+    end
+  end
+
+  test "decode bad json" do
+    assert_raises ResqueSqs::Helpers::DecodeException do
+      ResqueSqs.decode("{\"error\":\"Module not found \\u002\"}")
+    end
+  end
+
+  test "inlining jobs" do
+    begin
+      ResqueSqs.inline = true
+      ResqueSqs.enqueue(SomeIvarJob, 20, '/tmp')
+      assert_equal 0, ResqueSqs.size(:ivar)
+    ensure
+      ResqueSqs.inline = false
+    end
+  end
+end

data/test/stdout

@@ -0,0 +1,42 @@
+44230:C 06 Jun 2023 22:35:11.139 # oO0OoO0OoO0Oo Redis is starting oO0OoO0OoO0Oo
+44230:C 06 Jun 2023 22:35:11.139 # Redis version=7.0.4, bits=64, commit=00000000, modified=0, pid=44230, just started
+44230:C 06 Jun 2023 22:35:11.140 # Configuration loaded
+44230:M 06 Jun 2023 22:35:11.141 * monotonic clock: POSIX clock_gettime
+44230:M 06 Jun 2023 22:35:11.142 # Warning: Could not create server TCP listening socket *:9736: bind: Address already in use
+44230:M 06 Jun 2023 22:35:11.142 # Failed listening on port 9736 (TCP), aborting.
+45908:C 06 Jun 2023 22:36:39.405 # oO0OoO0OoO0Oo Redis is starting oO0OoO0OoO0Oo
+45908:C 06 Jun 2023 22:36:39.406 # Redis version=7.0.4, bits=64, commit=00000000, modified=0, pid=45908, just started
+45908:C 06 Jun 2023 22:36:39.406 # Configuration loaded
+45908:M 06 Jun 2023 22:36:39.407 * monotonic clock: POSIX clock_gettime
+45908:M 06 Jun 2023 22:36:39.408 # Warning: Could not create server TCP listening socket *:9736: bind: Address already in use
+45908:M 06 Jun 2023 22:36:39.409 # Failed listening on port 9736 (TCP), aborting.
+47480:C 06 Jun 2023 22:38:34.680 # oO0OoO0OoO0Oo Redis is starting oO0OoO0OoO0Oo
+47480:C 06 Jun 2023 22:38:34.680 # Redis version=7.0.4, bits=64, commit=00000000, modified=0, pid=47480, just started
+47480:C 06 Jun 2023 22:38:34.681 # Configuration loaded
+47480:M 06 Jun 2023 22:38:34.682 * monotonic clock: POSIX clock_gettime
+47480:M 06 Jun 2023 22:38:34.683 # Warning: Could not create server TCP listening socket *:9736: bind: Address already in use
+47480:M 06 Jun 2023 22:38:34.683 # Failed listening on port 9736 (TCP), aborting.
+48049:C 06 Jun 2023 22:39:10.214 # oO0OoO0OoO0Oo Redis is starting oO0OoO0OoO0Oo
+48049:C 06 Jun 2023 22:39:10.214 # Redis version=7.0.4, bits=64, commit=00000000, modified=0, pid=48049, just started
+48049:C 06 Jun 2023 22:39:10.215 # Configuration loaded
+48049:M 06 Jun 2023 22:39:10.216 * monotonic clock: POSIX clock_gettime
+48049:M 06 Jun 2023 22:39:10.217 # Warning: Could not create server TCP listening socket *:9736: bind: Address already in use
+48049:M 06 Jun 2023 22:39:10.218 # Failed listening on port 9736 (TCP), aborting.
+50184:C 06 Jun 2023 22:41:05.634 # oO0OoO0OoO0Oo Redis is starting oO0OoO0OoO0Oo
+50184:C 06 Jun 2023 22:41:05.634 # Redis version=7.0.4, bits=64, commit=00000000, modified=0, pid=50184, just started
+50184:C 06 Jun 2023 22:41:05.635 # Configuration loaded
+50184:M 06 Jun 2023 22:41:05.636 * monotonic clock: POSIX clock_gettime
+50184:M 06 Jun 2023 22:41:05.637 # Warning: Could not create server TCP listening socket *:9736: bind: Address already in use
+50184:M 06 Jun 2023 22:41:05.638 # Failed listening on port 9736 (TCP), aborting.
+64893:C 06 Jun 2023 22:52:57.094 # oO0OoO0OoO0Oo Redis is starting oO0OoO0OoO0Oo
+64893:C 06 Jun 2023 22:52:57.095 # Redis version=7.0.4, bits=64, commit=00000000, modified=0, pid=64893, just started
+64893:C 06 Jun 2023 22:52:57.096 # Configuration loaded
+64893:M 06 Jun 2023 22:52:57.097 * monotonic clock: POSIX clock_gettime
+64893:M 06 Jun 2023 22:52:57.098 # Warning: Could not create server TCP listening socket *:9736: bind: Address already in use
+64893:M 06 Jun 2023 22:52:57.098 # Failed listening on port 9736 (TCP), aborting.
+66616:C 06 Jun 2023 22:54:52.542 # oO0OoO0OoO0Oo Redis is starting oO0OoO0OoO0Oo
+66616:C 06 Jun 2023 22:54:52.543 # Redis version=7.0.4, bits=64, commit=00000000, modified=0, pid=66616, just started
+66616:C 06 Jun 2023 22:54:52.544 # Configuration loaded
+66616:M 06 Jun 2023 22:54:52.545 * monotonic clock: POSIX clock_gettime
+66616:M 06 Jun 2023 22:54:52.546 # Warning: Could not create server TCP listening socket *:9736: bind: Address already in use
+66616:M 06 Jun 2023 22:54:52.547 # Failed listening on port 9736 (TCP), aborting.

data/test/test_helper.rb

@@ -0,0 +1,228 @@
+require 'rubygems'
+require 'bundler/setup'
+require 'minitest/autorun'
+require 'redis/namespace'
+
+require 'mocha/setup'
+
+$dir = File.dirname(File.expand_path(__FILE__))
+$LOAD_PATH.unshift $dir + '/../lib'
+require 'resque_sqs'
+$TESTING = true
+$TEST_PID=Process.pid
+
+begin
+  require 'leftright'
+rescue LoadError
+end
+
+
+#
+# make sure we can run redis
+#
+
+if !system("which redis-server")
+  puts '', "** can't find `redis-server` in your path"
+  puts "** try running `sudo rake install`"
+  abort ''
+end
+
+
+#
+# start our own redis when the tests start,
+# kill it when they end
+#
+
+MiniTest::Unit.after_tests do
+  if Process.pid == $TEST_PID
+    processes = `ps -A -o pid,command | grep [r]edis-test`.split("\n")
+    pids = processes.map { |process| process.split(" ")[0] }
+    puts "Killing test redis server..."
+    pids.each { |pid| Process.kill("TERM", pid.to_i) }
+    system("rm -f #{$dir}/dump.rdb #{$dir}/dump-cluster.rdb")
+  end
+end
+
+if ENV.key? 'RESQUE_DISTRIBUTED'
+  require 'redis/distributed'
+  puts "Starting redis for testing at localhost:9736 and localhost:9737..."
+  `redis-server #{$dir}/redis-test.conf`
+  `redis-server #{$dir}/redis-test-cluster.conf`
+  r = Redis::Distributed.new(['redis://localhost:9736', 'redis://localhost:9737'])
+  ResqueSqs.redis = Redis::Namespace.new :resque, :redis => r
+else
+  puts "Starting redis for testing at localhost:9736..."
+  `redis-server #{$dir}/redis-test.conf`
+  ResqueSqs.redis = 'localhost:9736'
+end
+
+
+##
+# test/spec/mini 3
+# http://gist.github.com/25455
+# chris@ozmm.org
+#
+def context(*args, &block)
+  return super unless (name = args.first) && block
+  require 'test/unit'
+  klass = Class.new(defined?(ActiveSupport::TestCase) ? ActiveSupport::TestCase : Test::Unit::TestCase) do
+    def self.test(name, &block)
+      define_method("test_#{name.gsub(/\W/,'_')}", &block) if block
+    end
+    def self.xtest(*args) end
+    def self.setup(&block) define_method(:setup, &block) end
+    def self.teardown(&block) define_method(:teardown, &block) end
+  end
+  (class << klass; self end).send(:define_method, :name) { name.gsub(/\W/,'_') }
+  klass.class_eval &block
+  # XXX: In 1.8.x, not all tests will run unless anonymous classes are kept in scope.
+  ($test_classes ||= []) << klass
+end
+
+##
+# Helper to perform job classes
+#
+module PerformJob
+  def perform_job(klass, *args)
+    resque_job = ResqueSqs::Job.new(:testqueue, 'class' => klass, 'args' => args)
+    resque_job.perform
+  end
+end
+
+##
+# Helper to make Minitest::Assertion exceptions work properly
+# in the block given to ResqueSqs::Worker#work.
+#
+module AssertInWorkBlock
+  # if a block is given, ensure that it is run, and that any assertion
+  # failures that occur inside it propagate up to the test.
+  def work(*args, &block)
+    return super unless block_given?
+
+    ex = catch(:exception_in_block) do
+      block_called = nil
+      retval = super(*args) do |*bargs|
+        begin
+          block_called = true
+          block.call(*bargs)
+        rescue MiniTest::Assertion => ex
+          throw :exception_in_block, ex
+        end
+      end
+
+      raise "assertion block not called!" unless block_called
+
+      return retval
+    end
+
+    ex && raise(ex)
+  end
+end
+
+#
+# fixture classes
+#
+
+class SomeJob
+  def self.perform(repo_id, path)
+  end
+end
+
+class SomeIvarJob < SomeJob
+  @queue = :ivar
+end
+
+class SomeMethodJob < SomeJob
+  def self.queue
+    :method
+  end
+end
+
+class BadJob
+  def self.perform
+    raise "Bad job!"
+  end
+end
+
+class GoodJob
+  def self.perform(name)
+    "Good job, #{name}"
+  end
+end
+
+class AtExitJob
+  def self.perform(filename)
+    at_exit do
+      File.open(filename, "w") {|file| file.puts "at_exit"}
+    end
+    "at_exit job"
+  end
+end
+
+class BadJobWithSyntaxError
+  def self.perform
+    raise SyntaxError, "Extra Bad job!"
+  end
+end
+
+class BadFailureBackend < ResqueSqs::Failure::Base
+  def save
+    raise Exception.new("Failure backend error")
+  end
+end
+
+def with_failure_backend(failure_backend, &block)
+  previous_backend = ResqueSqs::Failure.backend
+  ResqueSqs::Failure.backend = failure_backend
+  yield block
+ensure
+  ResqueSqs::Failure.backend = previous_backend
+end
+
+require 'time'
+
+class Time
+  # Thanks, Timecop
+  class << self
+    attr_accessor :fake_time
+
+    alias_method :now_without_mock_time, :now
+
+    def now
+      fake_time || now_without_mock_time
+    end
+  end
+
+  self.fake_time = nil
+end
+
+# From minitest/unit
+def capture_io
+  require 'stringio'
+
+  orig_stdout, orig_stderr         = $stdout, $stderr
+  captured_stdout, captured_stderr = StringIO.new, StringIO.new
+  $stdout, $stderr                 = captured_stdout, captured_stderr
+
+  yield
+
+  return captured_stdout.string, captured_stderr.string
+ensure
+  $stdout = orig_stdout
+  $stderr = orig_stderr
+end
+
+# Log to log/test.log
+def reset_logger
+  $test_logger ||= MonoLogger.new(File.open(File.expand_path("../../log/test.log", __FILE__), "w"))
+  ResqueSqs.logger = $test_logger
+end
+
+reset_logger
+
+def suppress_warnings
+  old_verbose, $VERBOSE = $VERBOSE, nil
+  yield
+ensure
+  $VERBOSE = old_verbose
+end