sidekiq 3.4.1 → 4.0.2

data/test/test_retry.rb

@@ -5,158 +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 }
-      msg2 = msg.dup
-      handler = Sidekiq::Middleware::Server::RetryJobs.new
       assert_raises RuntimeError do
-        handler.call(worker, msg2, 'default') do
+        handler.call(worker, job('retry' => 2), 'default') do
           raise "kerblammo!"
         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 1, Sidekiq::RetrySet.new.size
+      assert_equal 0, Sidekiq::DeadSet.new.size
+    end
+
+    it 'allows 0 retry => no retry and dead queue' do
+      assert_raises RuntimeError do
+        handler.call(worker, job('retry' => 0), 'default') do
+          raise "kerblammo!"
+        end
+      end
+      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
@@ -166,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
@@ -190,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
-      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 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
+      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 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
@@ -292,38 +229,53 @@ 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 CustomWorkerWithoutException
+        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 CustomWorkerWithException
+        include Sidekiq::Worker
 
-          sidekiq_retry_in do |count|
-            count / 0
+        sidekiq_retry_in do |count, exception|
+          case exception
+          when ArgumentError
+            count * 4
+          else
+            count * 2
           end
         end
       end
 
-      let(:handler) { Sidekiq::Middleware::Server::RetryJobs.new }
+      class ErrorWorker
+        include Sidekiq::Worker
+
+        sidekiq_retry_in do |count|
+          count / 0
+        end
+      end
 
       it "retries with a default delay" do
-        refute_equal 4, handler.__send__(:delay_for, worker, 2)
+        refute_equal 4, handler.__send__(:delay_for, worker, 2, StandardError.new)
+      end
+
+      it "retries with a custom delay and exception 1" do
+        assert_equal 8, handler.__send__(:delay_for, CustomWorkerWithException, 2, ArgumentError.new)
+      end
+
+      it "retries with a custom delay and exception 2" do
+        assert_equal 4, handler.__send__(:delay_for, CustomWorkerWithException, 2, StandardError.new)
       end
 
-      it "retries with a custom delay" do
-        assert_equal 4, handler.__send__(:delay_for, custom_worker, 2)
+      it "retries with a custom delay without exception" do
+        assert_equal 4, handler.__send__(:delay_for, CustomWorkerWithoutException, 2, StandardError.new)
       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, StandardError.new)
         assert_match(/Failure scheduling retry using the defined `sidekiq_retry_in`/,
                      File.read(@tmp_log_path), 'Log entry missing for sidekiq_retry_in')
       end
@@ -354,7 +306,7 @@ class TestRetry < Sidekiq::Test
           rescue ::StandardError => e1
             begin
               raise ::StandardError, 'Error 2'
-            rescue ::StandardError => e2
+            rescue ::StandardError
               raise e1
             end
           end

data/test/test_scheduled.rb

@@ -10,11 +10,7 @@ class TestScheduled < Sidekiq::Test
 
   describe 'poller' do
     before do
-      Sidekiq.redis = REDIS
-      Sidekiq.redis do |conn|
-        conn.flushdb
-      end
-
+      Sidekiq.redis{|c| c.flushdb}
       @error_1  = { 'class' => ScheduledWorker.name, 'args' => [0], 'queue' => 'queue_1' }
       @error_2  = { 'class' => ScheduledWorker.name, 'args' => [1], 'queue' => 'queue_2' }
       @error_3  = { 'class' => ScheduledWorker.name, 'args' => [2], 'queue' => 'queue_3' }
@@ -28,8 +24,8 @@ class TestScheduled < Sidekiq::Test
     end
 
     class Stopper
-      def call(worker_class, message, queue, r)
-        yield if message['args'].first.odd?
+      def call(worker_class, job, queue, r)
+        yield if job['args'].first.odd?
       end
     end
 
@@ -41,14 +37,12 @@ class TestScheduled < Sidekiq::Test
         @scheduled.schedule (Time.now - 60).to_f, @future_2
         @scheduled.schedule (Time.now - 60).to_f, @future_3
 
-        @poller.poll
+        @poller.enqueue
 
-        Sidekiq.redis do |conn|
-          assert_equal 0, conn.llen("queue:queue_1")
-          assert_equal 1, conn.llen("queue:queue_2")
-          assert_equal 0, conn.llen("queue:queue_5")
-          assert_equal 1, conn.llen("queue:queue_6")
-        end
+        assert_equal 0, Sidekiq::Queue.new("queue_1").size
+        assert_equal 1, Sidekiq::Queue.new("queue_2").size
+        assert_equal 0, Sidekiq::Queue.new("queue_5").size
+        assert_equal 1, Sidekiq::Queue.new("queue_6").size
       ensure
         Sidekiq.client_middleware.remove Stopper
       end
@@ -68,7 +62,7 @@ class TestScheduled < Sidekiq::Test
       end
 
       Time.stub(:now, enqueued_time) do
-        @poller.poll
+        @poller.enqueue
 
         Sidekiq.redis do |conn|
           %w(queue:queue_1 queue:queue_2 queue:queue_4 queue:queue_5).each do |queue_name|
@@ -98,8 +92,8 @@ class TestScheduled < Sidekiq::Test
         i = 500
         intervals = i.times.map{ @poller.send(:random_poll_interval) }
 
-        assert intervals.all?{|i| i >= 5}
-        assert intervals.all?{|i| i <= 15}
+        assert intervals.all?{|x| x >= 5}
+        assert intervals.all?{|x| x <= 15}
         assert_in_delta 10, intervals.reduce(&:+).to_f / i, 0.5
       end
     end

data/test/test_scheduling.rb

@@ -3,20 +3,6 @@ require 'sidekiq/scheduled'
 
 class TestScheduling < Sidekiq::Test
   describe 'middleware' do
-    before do
-      Sidekiq::Client.instance_variable_set(:@default, nil)
-      @redis = Minitest::Mock.new
-      # Ugh, this is terrible.
-      Sidekiq.instance_variable_set(:@redis, @redis)
-      def @redis.multi; [yield] * 2 if block_given?; end
-      def @redis.with; yield self; end
-    end
-
-    after do
-      Sidekiq::Client.instance_variable_set(:@default, nil)
-      Sidekiq.instance_variable_set(:@redis, REDIS)
-    end
-
     class ScheduledWorker
       include Sidekiq::Worker
       sidekiq_options :queue => :custom_queue
@@ -24,47 +10,39 @@ class TestScheduling < Sidekiq::Test
       end
     end
 
-    it 'schedules a job via interval' do
-      @redis.expect :zadd, true, ['schedule', Array]
+    it 'schedules jobs' do
+      ss = Sidekiq::ScheduledSet.new
+      ss.clear
+
+      assert_equal 0, ss.size
+
       assert ScheduledWorker.perform_in(600, 'mike')
-      @redis.verify
-    end
+      assert_equal 1, ss.size
 
-    it 'schedules a job in one month' do
-      @redis.expect :zadd, true do |key, args|
-        assert_equal 'schedule', key
-        assert_in_delta 1.month.since.to_f, args[0][0].to_f, 1
-      end
       assert ScheduledWorker.perform_in(1.month, 'mike')
-      @redis.verify
-    end
+      assert_equal 2, ss.size
 
-    it 'schedules a job via timestamp' do
-      @redis.expect :zadd, true, ['schedule', Array]
       assert ScheduledWorker.perform_in(5.days.from_now, 'mike')
-      @redis.verify
-    end
+      assert_equal 3, ss.size
 
-    it 'schedules job right away on negative timestamp/interval' do
-      @redis.expect :sadd,  true, ['queues', 'custom_queue']
-      @redis.expect :lpush, true, ['queue:custom_queue', Array]
+      q = Sidekiq::Queue.new("custom_queue")
+      qs = q.size
       assert ScheduledWorker.perform_in(-300, 'mike')
-      @redis.verify
-    end
+      assert_equal 3, ss.size
+      assert_equal qs+1, q.size
 
-    it 'schedules multiple jobs at once' do
-      @redis.expect :zadd, true, ['schedule', Array]
       assert Sidekiq::Client.push_bulk('class' => ScheduledWorker, 'args' => [['mike'], ['mike']], 'at' => 600)
-      @redis.verify
+      assert_equal 5, ss.size
     end
 
     it 'removes the enqueued_at field when scheduling' do
-      @redis.expect :zadd, true do |key, args|
-        job = Sidekiq.load_json(args.first.last)
-        job.key?('created_at') && !job.key?('enqueued_at')
-      end
+      ss = Sidekiq::ScheduledSet.new
+      ss.clear
+
       assert ScheduledWorker.perform_in(1.month, 'mike')
-      @redis.verify
+      job = ss.first
+      assert job['created_at']
+      refute job['enqueued_at']
     end
   end
 

data/test/test_sidekiq.rb

@@ -3,24 +3,16 @@ require_relative 'helper'
 
 class TestSidekiq < Sidekiq::Test
   describe 'json processing' do
-    it 'loads json' do
-      assert_equal ({"foo" => "bar"}), Sidekiq.load_json("{\"foo\":\"bar\"}")
-    end
-
-    it 'dumps json' do
+    it 'handles json' do
+      assert_equal({"foo" => "bar"}, Sidekiq.load_json("{\"foo\":\"bar\"}"))
       assert_equal "{\"foo\":\"bar\"}", Sidekiq.dump_json({ "foo" => "bar" })
     end
   end
 
   describe "redis connection" do
   	it "returns error without creating a connection if block is not given" do
-      mock = Minitest::Mock.new
-      mock.expect :create, nil #Sidekiq::RedisConnection, create
-  		assert_raises(ArgumentError) {
+  		assert_raises(ArgumentError) do
   			Sidekiq.redis
-  		}
-      assert_raises(MockExpectationError, "create should not be called") do
-        mock.verify
       end
   	end
   end
@@ -56,14 +48,52 @@ class TestSidekiq < Sidekiq::Test
   end
 
   describe 'default_worker_options' do
-    before do
+    it 'stringifies keys' do
       @old_options = Sidekiq.default_worker_options
+      begin
+        Sidekiq.default_worker_options = { queue: 'cat'}
+        assert_equal 'cat', Sidekiq.default_worker_options['queue']
+      ensure
+        Sidekiq.default_worker_options = @old_options
+      end
+    end
+  end
+
+  describe 'error handling' do
+    it 'deals with user-specified error handlers which raise errors' do
+      output = capture_logging do
+        begin
+          Sidekiq.error_handlers << proc {|x, hash|
+            raise 'boom'
+          }
+          cli = Sidekiq::CLI.new
+          cli.handle_exception(RuntimeError.new("hello"))
+        ensure
+          Sidekiq.error_handlers.pop
+        end
+      end
+      assert_includes output, "boom"
+      assert_includes output, "ERROR"
+    end
+  end
+
+  describe 'redis connection' do
+    it 'does not continually retry' do
+      assert_raises Redis::CommandError do
+        Sidekiq.redis do |c|
+          raise Redis::CommandError, "READONLY You can't write against a read only slave."
+        end
+      end
     end
-    after  { Sidekiq.default_worker_options = @old_options }
 
-    it 'stringify keys' do
-      Sidekiq.default_worker_options = { queue: 'cat'}
-      assert_equal 'cat', Sidekiq.default_worker_options['queue']
+    it 'reconnects if connection is flagged as readonly' do
+      counts = []
+      Sidekiq.redis do |c|
+        counts << c.info['total_connections_received'].to_i
+        raise Redis::CommandError, "READONLY You can't write against a read only slave." if counts.size == 1
+      end
+      assert_equal 2, counts.size
+      assert_equal counts[0] + 1, counts[1]
     end
   end
 end