sidekiq 3.5.0 → 3.5.1

data/test/test_logging.rb

@@ -1,7 +1,7 @@
 require_relative 'helper'
 require 'sidekiq/logging'
 
-class TestFetcher < Sidekiq::Test
+class TestLogging < Sidekiq::Test
   describe Sidekiq::Logging do
     describe "#with_context" do
       def context

data/test/test_manager.rb

@@ -5,7 +5,6 @@ class TestManager < Sidekiq::Test
 
   describe 'manager' do
     before do
-      Sidekiq.redis = REDIS
       Sidekiq.redis {|c| c.flushdb }
     end
 

data/test/test_processor.rb

@@ -10,8 +10,6 @@ class TestProcessor < Sidekiq::Test
       $invokes = 0
       @boss = Minitest::Mock.new
       @processor = ::Sidekiq::Processor.new(@boss)
-      Celluloid.logger = nil
-      Sidekiq.redis = REDIS
     end
 
     class MockWorker
@@ -88,23 +86,112 @@ class TestProcessor < Sidekiq::Test
       assert_equal [['myarg']], msg['args']
     end
 
-    describe 'stats' do
+    describe 'acknowledgement' do
+      class ExceptionRaisingMiddleware
+        def initialize(raise_before_yield, raise_after_yield, skip)
+          @raise_before_yield = raise_before_yield
+          @raise_after_yield = raise_after_yield
+          @skip = skip
+        end
+
+        def call(worker, item, queue)
+          raise TEST_EXCEPTION if @raise_before_yield
+          yield unless @skip
+          raise TEST_EXCEPTION if @raise_after_yield
+        end
+      end
+
+      let(:raise_before_yield) { false }
+      let(:raise_after_yield) { false }
+      let(:skip_job) { false }
+      let(:worker_args) { ['myarg'] }
+      let(:work) { MiniTest::Mock.new }
+      let(:actor) { Minitest::Mock.new }
+
       before do
-        Sidekiq.redis {|c| c.flushdb }
+        work.expect(:queue_name, 'queues:default')
+        work.expect(:message, Sidekiq.dump_json({ 'class' => MockWorker.to_s, 'args' => worker_args }))
+        Sidekiq.server_middleware do |chain|
+          chain.prepend ExceptionRaisingMiddleware, raise_before_yield, raise_after_yield, skip_job
+        end
+
+        actor.expect(:real_thread, nil, [nil, Thread])
+        @boss.expect(:async, actor, [])
+      end
+
+      after do
+        Sidekiq.server_middleware do |chain|
+          chain.remove ExceptionRaisingMiddleware
+        end
+        work.verify
+      end
+
+      describe 'middleware throws an exception before processing the work' do
+        let(:raise_before_yield) { true }
+
+        it 'does not ack' do
+          begin
+            @processor.process(work)
+            flunk "Expected #process to raise exception"
+          rescue TestException
+          end
+        end
+      end
+
+      describe 'middleware throws an exception after processing the work' do
+        let(:raise_after_yield) { true }
+
+        it 'acks the job' do
+          work.expect(:acknowledge, nil)
+          begin
+            @processor.process(work)
+            flunk "Expected #process to raise exception"
+          rescue TestException
+          end
+        end
+      end
+
+      describe 'middleware decides to skip work' do
+        let(:skip_job) { true }
+
+        it 'acks the job' do
+          work.expect(:acknowledge, nil)
+          @boss.expect(:async, actor, [])
+          actor.expect(:processor_done, nil, [@processor])
+          @processor.process(work)
+        end
       end
 
-      def with_expire(time)
-        begin
-          old = Sidekiq::Processor::STATS_TIMEOUT
-          silence_warnings { Sidekiq::Processor.const_set(:STATS_TIMEOUT, time) }
-          yield
-        ensure
-          silence_warnings { Sidekiq::Processor.const_set(:STATS_TIMEOUT, old) }
+      describe 'worker raises an exception' do
+        let(:worker_args) { ['boom'] }
+
+        it 'acks the job' do
+          work.expect(:acknowledge, nil)
+          begin
+            @processor.process(work)
+            flunk "Expected #process to raise exception"
+          rescue TestException
+          end
         end
       end
 
+      describe 'everything goes well' do
+        it 'acks the job' do
+          work.expect(:acknowledge, nil)
+          @boss.expect(:async, actor, [])
+          actor.expect(:processor_done, nil, [@processor])
+          @processor.process(work)
+        end
+      end
+    end
+
+    describe 'stats' do
+      before do
+        Sidekiq.redis {|c| c.flushdb }
+      end
+
       describe 'when successful' do
-        let(:processed_today_key) { "stat:processed:#{Time.now.utc.to_date}" }
+        let(:processed_today_key) { "stat:processed:#{Time.now.utc.strftime("%Y-%m-%d")}" }
 
         def successful_job
           msg = Sidekiq.dump_json({ 'class' => MockWorker.to_s, 'args' => ['myarg'] })
@@ -117,23 +204,15 @@ class TestProcessor < Sidekiq::Test
         end
 
         it 'increments processed stat' do
+          assert_equal 0, Sidekiq::Stats.new.processed
           successful_job
           assert_equal 1, Sidekiq::Stats.new.processed
-        end
-
-        it 'expires processed stat' do
-          successful_job
           assert_equal Sidekiq::Processor::STATS_TIMEOUT, Sidekiq.redis { |conn| conn.ttl(processed_today_key) }
         end
-
-        it 'increments date processed stat' do
-          successful_job
-          assert_equal 1, Sidekiq.redis { |conn| conn.get(processed_today_key) }.to_i
-        end
       end
 
       describe 'when failed' do
-        let(:failed_today_key) { "stat:failed:#{Time.now.utc.to_date}" }
+        let(:failed_today_key) { "stat:failed:#{Time.now.utc.strftime("%Y-%m-%d")}" }
 
         def failed_job
           actor = Minitest::Mock.new
@@ -147,17 +226,9 @@ class TestProcessor < Sidekiq::Test
         end
 
         it 'increments failed stat' do
+          assert_equal 0, Sidekiq::Stats.new.failed
           failed_job
           assert_equal 1, Sidekiq::Stats.new.failed
-        end
-
-        it 'increments date failed stat' do
-          failed_job
-          assert_equal 1, Sidekiq.redis { |conn| conn.get(failed_today_key) }.to_i
-        end
-
-        it 'expires failed stat' do
-          failed_job
           assert_equal Sidekiq::Processor::STATS_TIMEOUT, Sidekiq.redis { |conn| conn.ttl(failed_today_key) }
         end
       end

data/test/test_rails.rb

@@ -1,6 +1,4 @@
 require_relative 'helper'
-require 'sidekiq'
-require 'sidekiq/web_helpers'
 
 $HAS_AJ = true
 begin

data/test/test_redis_connection.rb

@@ -1,5 +1,4 @@
 require_relative 'helper'
-require 'sidekiq/redis_connection'
 
 class TestRedisConnection < Sidekiq::Test
 

data/test/test_retry.rb

@@ -5,175 +5,136 @@ require 'sidekiq/middleware/server/retry_jobs'
 
 class TestRetry < Sidekiq::Test
   describe 'middleware' do
+    class SomeWorker
+      include Sidekiq::Worker
+    end
+
     before do
-      @redis = Minitest::Mock.new
-      # Ugh, this is terrible.
-      Sidekiq.instance_variable_set(:@redis, @redis)
+      Sidekiq.redis {|c| c.flushdb }
+    end
 
-      def @redis.with; yield self; end
-      def @redis.multi; yield self; end
+    def worker
+      @worker ||= SomeWorker.new
     end
 
-    after do
-      Sidekiq.redis = REDIS
+    def handler(options={})
+      @handler ||= Sidekiq::Middleware::Server::RetryJobs.new(options)
     end
 
-    let(:worker) do
-      Class.new do
-        include ::Sidekiq::Worker
-      end
+    def job(options={})
+      @job ||= { 'class' => 'Bob', 'args' => [1,2,'foo'], 'retry' => true }.merge(options)
     end
 
     it 'allows disabling retry' do
-      msg = { 'class' => 'Bob', 'args' => [1,2,'foo'], 'retry' => false }
-      msg2 = msg.dup
-      handler = Sidekiq::Middleware::Server::RetryJobs.new
       assert_raises RuntimeError do
-        handler.call(worker, msg2, 'default') do
+        handler.call(worker, job('retry' => false), 'default') do
           raise "kerblammo!"
         end
       end
-      assert_equal msg, msg2
+      assert_equal 0, Sidekiq::RetrySet.new.size
     end
 
     it 'allows a numeric retry' do
-      @redis.expect :zadd, 1, ['retry', String, String]
-      msg = { 'class' => 'Bob', 'args' => [1,2,'foo'], 'retry' => 2 }
-      handler = Sidekiq::Middleware::Server::RetryJobs.new
       assert_raises RuntimeError do
-        handler.call(worker, msg, 'default') do
+        handler.call(worker, job('retry' => 2), 'default') do
           raise "kerblammo!"
         end
       end
-      msg.delete('failed_at')
-      assert_equal({"class"=>"Bob", "args"=>[1, 2, "foo"], "retry"=>2, "queue"=>"default", "error_message"=>"kerblammo!", "error_class"=>"RuntimeError", "retry_count"=>0}, msg)
-      @redis.verify
+      assert_equal 1, Sidekiq::RetrySet.new.size
+      assert_equal 0, Sidekiq::DeadSet.new.size
     end
 
     it 'allows 0 retry => no retry and dead queue' do
-      @redis.expect :zadd, 1, ['dead', Float, String]
-      @redis.expect :zremrangebyscore, 0, ['dead', String, Float]
-      @redis.expect :zremrangebyrank, 0, ['dead', Numeric, Numeric]
-      msg = { 'class' => 'Bob', 'args' => [1,2,'foo'], 'retry' => 0 }
-      msg2 = msg.dup
-      handler = Sidekiq::Middleware::Server::RetryJobs.new
       assert_raises RuntimeError do
-        handler.call(worker, msg, 'default') do
+        handler.call(worker, job('retry' => 0), 'default') do
           raise "kerblammo!"
         end
       end
-      msg.delete('failed_at')
-      expected = msg2.merge "queue"=>"default", "error_message"=>"kerblammo!", "error_class"=>"RuntimeError", "retry_count"=>0
-      assert_equal expected, msg
-      @redis.verify # not called
+      assert_equal 0, Sidekiq::RetrySet.new.size
+      assert_equal 1, Sidekiq::DeadSet.new.size
     end
 
     it 'handles zany characters in error message, #1705' do
       skip 'skipped! test requires ruby 2.1+' if RUBY_VERSION <= '2.1.0'
-      @redis.expect :zadd, 1, ['retry', String, String]
-      msg = { 'class' => 'Bob', 'args' => [1,2,'foo'], 'retry' => 2 }
-      msg2 = msg.dup
-      handler = Sidekiq::Middleware::Server::RetryJobs.new
+
       assert_raises RuntimeError do
-        handler.call(worker, msg2, 'default') do
+        handler.call(worker, job, 'default') do
           raise "kerblammo! #{195.chr}"
         end
       end
-      msg2.delete('failed_at')
-      assert_equal({"class"=>"Bob", "args"=>[1, 2, "foo"], "retry"=>2, "queue"=>"default", "error_message"=>"kerblammo! �", "error_class"=>"RuntimeError", "retry_count"=>0}, msg2)
-      @redis.verify
+      assert_equal "kerblammo! �", job["error_message"]
     end
 
 
     it 'allows a max_retries option in initializer' do
       max_retries = 7
-      1.upto(max_retries) do
-        @redis.expect :zadd, 1, ['retry', String, String]
-      end
-      @redis.expect :zadd, 1, ['dead', Float, String]
-      @redis.expect :zremrangebyscore, 0, ['dead', String, Float]
-      @redis.expect :zremrangebyrank, 0, ['dead', Numeric, Numeric]
-      msg = { 'class' => 'Bob', 'args' => [1,2,'foo'], 'retry' => true }
-      handler = Sidekiq::Middleware::Server::RetryJobs.new({:max_retries => max_retries})
       1.upto(max_retries + 1) do
         assert_raises RuntimeError do
-          handler.call(worker, msg, 'default') do
+          handler(:max_retries => max_retries).call(worker, job, 'default') do
             raise "kerblammo!"
           end
         end
       end
-      @redis.verify
+
+      assert_equal max_retries, Sidekiq::RetrySet.new.size
+      assert_equal 1, Sidekiq::DeadSet.new.size
     end
 
     it 'saves backtraces' do
-      @redis.expect :zadd, 1, ['retry', String, String]
-      msg = { 'class' => 'Bob', 'args' => [1,2,'foo'], 'retry' => true, 'backtrace' => true }
-      handler = Sidekiq::Middleware::Server::RetryJobs.new
       c = nil
       assert_raises RuntimeError do
-        handler.call(worker, msg, 'default') do
+        handler.call(worker, job('backtrace' => true), 'default') do
           c = caller(0); raise "kerblammo!"
         end
       end
-      assert msg["error_backtrace"]
-      assert_equal c[0], msg["error_backtrace"][0]
-      @redis.verify
+      assert job["error_backtrace"]
+      assert_equal c[0], job["error_backtrace"][0]
     end
 
     it 'saves partial backtraces' do
-      @redis.expect :zadd, 1, ['retry', String, String]
-      msg = { 'class' => 'Bob', 'args' => [1,2,'foo'], 'retry' => true, 'backtrace' => 3 }
-      handler = Sidekiq::Middleware::Server::RetryJobs.new
       c = nil
       assert_raises RuntimeError do
-        handler.call(worker, msg, 'default') do
+        handler.call(worker, job('backtrace' => 3), 'default') do
           c = caller(0)[0...3]; raise "kerblammo!"
         end
       end
-      assert msg["error_backtrace"]
-      assert_equal c, msg["error_backtrace"]
+      assert job["error_backtrace"]
+      assert_equal c, job["error_backtrace"]
       assert_equal 3, c.size
-      assert_equal 3, msg["error_backtrace"].size
     end
 
     it 'handles a new failed message' do
-      @redis.expect :zadd, 1, ['retry', String, String]
-      msg = { 'class' => 'Bob', 'args' => [1,2,'foo'], 'retry' => true }
-      handler = Sidekiq::Middleware::Server::RetryJobs.new
       assert_raises RuntimeError do
-        handler.call(worker, msg, 'default') do
+        handler.call(worker, job, 'default') do
           raise "kerblammo!"
         end
       end
-      assert_equal 'default', msg["queue"]
-      assert_equal 'kerblammo!', msg["error_message"]
-      assert_equal 'RuntimeError', msg["error_class"]
-      assert_equal 0, msg["retry_count"]
-      refute msg["error_backtrace"]
-      assert msg["failed_at"]
-      @redis.verify
+      assert_equal 'default', job["queue"]
+      assert_equal 'kerblammo!', job["error_message"]
+      assert_equal 'RuntimeError', job["error_class"]
+      assert_equal 0, job["retry_count"]
+      refute job["error_backtrace"]
+      assert job["failed_at"]
     end
 
     it 'shuts down without retrying work-in-progress, which will resume' do
-      @redis.expect :zadd, 1, ['retry', String, String]
+      rs = Sidekiq::RetrySet.new
+      assert_equal 0, rs.size
       msg = { 'class' => 'Bob', 'args' => [1,2,'foo'], 'retry' => true }
-      handler = Sidekiq::Middleware::Server::RetryJobs.new
       assert_raises Sidekiq::Shutdown do
         handler.call(worker, msg, 'default') do
           raise Sidekiq::Shutdown
         end
       end
-      assert_raises(MockExpectationError, "zadd should not be called") do
-        @redis.verify
-      end
+      assert_equal 0, rs.size
     end
 
     it 'shuts down cleanly when shutdown causes exception' do
       skip('Not supported in Ruby < 2.1.0') if RUBY_VERSION < '2.1.0'
 
-      @redis.expect :zadd, 1, ['retry', String, String]
+      rs = Sidekiq::RetrySet.new
+      assert_equal 0, rs.size
       msg = { 'class' => 'Bob', 'args' => [1,2,'foo'], 'retry' => true }
-      handler = Sidekiq::Middleware::Server::RetryJobs.new
       assert_raises Sidekiq::Shutdown do
         handler.call(worker, msg, 'default') do
           begin
@@ -183,19 +144,16 @@ class TestRetry < Sidekiq::Test
           end
         end
       end
-      assert_raises(MockExpectationError, "zadd should not be called") do
-        @redis.verify
-      end
+      assert_equal 0, rs.size
     end
 
     it 'shuts down cleanly when shutdown causes chained exceptions' do
       skip('Not supported in Ruby < 2.1.0') if RUBY_VERSION < '2.1.0'
 
-      @redis.expect :zadd, 1, ['retry', String, String]
-      msg = { 'class' => 'Bob', 'args' => [1,2,'foo'], 'retry' => true }
-      handler = Sidekiq::Middleware::Server::RetryJobs.new
+      rs = Sidekiq::RetrySet.new
+      assert_equal 0, rs.size
       assert_raises Sidekiq::Shutdown do
-        handler.call(worker, msg, 'default') do
+        handler.call(worker, job, 'default') do
           begin
             raise Sidekiq::Shutdown
           rescue Interrupt
@@ -207,93 +165,55 @@ class TestRetry < Sidekiq::Test
           end
         end
       end
-      assert_raises(MockExpectationError, "zadd should not be called") do
-        @redis.verify
-      end
+      assert_equal 0, rs.size
     end
 
     it 'allows a retry queue' do
-      @redis.expect :zadd, 1, ['retry', String, String]
-      msg = { 'class' => 'Bob', 'args' => [1,2,'foo'], 'retry' => true, 'retry_queue' => 'retry' }
-      handler = Sidekiq::Middleware::Server::RetryJobs.new
       assert_raises RuntimeError do
-        handler.call(worker, msg, 'default') do
+        handler.call(worker, job("retry_queue" => 'retryx'), 'default') do
           raise "kerblammo!"
         end
       end
-      assert_equal 'retry', msg["queue"]
-      assert_equal 'kerblammo!', msg["error_message"]
-      assert_equal 'RuntimeError', msg["error_class"]
-      assert_equal 0, msg["retry_count"]
-      refute msg["error_backtrace"]
-      assert msg["failed_at"]
-      @redis.verify
+      assert_equal 'retryx', job["queue"]
+      assert_equal 'kerblammo!', job["error_message"]
+      assert_equal 'RuntimeError', job["error_class"]
+      assert_equal 0, job["retry_count"]
+      refute job["error_backtrace"]
+      assert job["failed_at"]
     end
 
     it 'handles a recurring failed message' do
-      @redis.expect :zadd, 1, ['retry', String, String]
       now = Time.now.to_f
-      msg = {"class"=>"Bob", "args"=>[1, 2, "foo"], 'retry' => true, "queue"=>"default", "error_message"=>"kerblammo!", "error_class"=>"RuntimeError", "failed_at"=>now, "retry_count"=>10}
-      handler = Sidekiq::Middleware::Server::RetryJobs.new
+      msg = {"queue"=>"default", "error_message"=>"kerblammo!", "error_class"=>"RuntimeError", "failed_at"=>now, "retry_count"=>10}
       assert_raises RuntimeError do
-        handler.call(worker, msg, 'default') do
+        handler.call(worker, job(msg), 'default') do
           raise "kerblammo!"
         end
       end
-      assert_equal 'default', msg["queue"]
-      assert_equal 'kerblammo!', msg["error_message"]
-      assert_equal 'RuntimeError', msg["error_class"]
-      assert_equal 11, msg["retry_count"]
-      assert msg["failed_at"]
-      @redis.verify
-    end
-
-    it 'handles a recurring failed message before reaching user-specifed max' do
-      @redis.expect :zadd, 1, ['retry', String, String]
-      now = Time.now.to_f
-      msg = {"class"=>"Bob", "args"=>[1, 2, "foo"], 'retry' => 10, "queue"=>"default", "error_message"=>"kerblammo!", "error_class"=>"RuntimeError", "failed_at"=>now, "retry_count"=>8}
-      handler = Sidekiq::Middleware::Server::RetryJobs.new
-      assert_raises RuntimeError do
-        handler.call(worker, msg, 'default') do
-          raise "kerblammo!"
-        end
-      end
-      assert_equal 'default', msg["queue"]
-      assert_equal 'kerblammo!', msg["error_message"]
-      assert_equal 'RuntimeError', msg["error_class"]
-      assert_equal 9, msg["retry_count"]
-      assert msg["failed_at"]
-      @redis.verify
+      assert_equal 'default', job["queue"]
+      assert_equal 'kerblammo!', job["error_message"]
+      assert_equal 'RuntimeError', job["error_class"]
+      assert_equal 11, job["retry_count"]
+      assert job["failed_at"]
     end
 
     it 'throws away old messages after too many retries (using the default)' do
+      q = Sidekiq::Queue.new
+      rs = Sidekiq::RetrySet.new
+      ds = Sidekiq::DeadSet.new
+      assert_equal 0, q.size
+      assert_equal 0, rs.size
+      assert_equal 0, ds.size
       now = Time.now.to_f
-      msg = {"class"=>"Bob", "args"=>[1, 2, "foo"], "queue"=>"default", "error_message"=>"kerblammo!", "error_class"=>"RuntimeError", "failed_at"=>now, "retry"=>true, "retry_count"=>25}
-      @redis.expect :zadd, 1, ['dead', Float, String]
-      @redis.expect :zremrangebyscore, 0, ['dead', String, Float]
-      @redis.expect :zremrangebyrank, 0, ['dead', Numeric, Numeric]
-      handler = Sidekiq::Middleware::Server::RetryJobs.new
-      assert_raises RuntimeError do
-        handler.call(worker, msg, 'default') do
-          raise "kerblammo!"
-        end
-      end
-      @redis.verify
-    end
-
-    it 'throws away old messages after too many retries (using user-specified max)' do
-      now = Time.now.to_f
-      msg = {"class"=>"Bob", "args"=>[1, 2, "foo"], "queue"=>"default", "error_message"=>"kerblammo!", "error_class"=>"RuntimeError", "failed_at"=>now, "retry"=>3, "retry_count"=>3}
-      @redis.expect :zadd, 1, ['dead', Float, String]
-      @redis.expect :zremrangebyscore, 0, ['dead', String, Float]
-      @redis.expect :zremrangebyrank, 0, ['dead', Numeric, Numeric]
-      handler = Sidekiq::Middleware::Server::RetryJobs.new
+      msg = {"queue"=>"default", "error_message"=>"kerblammo!", "error_class"=>"RuntimeError", "failed_at"=>now, "retry_count"=>25}
       assert_raises RuntimeError do
-        handler.call(worker, msg, 'default') do
+        handler.call(worker, job(msg), 'default') do
           raise "kerblammo!"
         end
       end
-      @redis.verify
+      assert_equal 0, q.size
+      assert_equal 0, rs.size
+      assert_equal 1, ds.size
     end
 
     describe "custom retry delay" do
@@ -309,38 +229,32 @@ class TestRetry < Sidekiq::Test
         File.unlink @tmp_log_path if File.exist?(@tmp_log_path)
       end
 
-      let(:custom_worker) do
-        Class.new do
-          include ::Sidekiq::Worker
+      class CustomWorker
+        include Sidekiq::Worker
 
-          sidekiq_retry_in do |count|
-            count * 2
-          end
+        sidekiq_retry_in do |count|
+          count * 2
         end
       end
 
-      let(:error_worker) do
-        Class.new do
-          include ::Sidekiq::Worker
+      class ErrorWorker
+        include Sidekiq::Worker
 
-          sidekiq_retry_in do |count|
-            count / 0
-          end
+        sidekiq_retry_in do |count|
+          count / 0
         end
       end
 
-      let(:handler) { Sidekiq::Middleware::Server::RetryJobs.new }
-
       it "retries with a default delay" do
         refute_equal 4, handler.__send__(:delay_for, worker, 2)
       end
 
       it "retries with a custom delay" do
-        assert_equal 4, handler.__send__(:delay_for, custom_worker, 2)
+        assert_equal 4, handler.__send__(:delay_for, CustomWorker, 2)
       end
 
       it "falls back to the default retry on exception" do
-        refute_equal 4, handler.__send__(:delay_for, error_worker, 2)
+        refute_equal 4, handler.__send__(:delay_for, ErrorWorker, 2)
         assert_match(/Failure scheduling retry using the defined `sidekiq_retry_in`/,
                      File.read(@tmp_log_path), 'Log entry missing for sidekiq_retry_in')
       end