sidekiq 2.17.8 → 3.0.0

data/test/test_cli.rb

@@ -109,7 +109,7 @@ class TestCli < Sidekiq::Test
       after do
         Sidekiq.logger = @old_logger
         Sidekiq.options.delete(:logfile)
-        File.unlink @tmp_log_path if File.exists?(@tmp_log_path)
+        File.unlink @tmp_log_path if File.exist?(@tmp_log_path)
       end
 
       it 'sets the logfile path' do

data/test/test_client.rb

@@ -20,10 +20,12 @@ class TestClient < Sidekiq::Test
       def @redis.with; yield self; end
       def @redis.exec; true; end
       Sidekiq.instance_variable_set(:@redis, @redis)
+      Sidekiq::Client.instance_variable_set(:@default, nil)
     end
 
     after do
       Sidekiq.instance_variable_set(:@redis, REDIS)
+      Sidekiq::Client.instance_variable_set(:@default, nil)
     end
 
     it 'raises ArgumentError with invalid params' do
@@ -59,7 +61,7 @@ class TestClient < Sidekiq::Test
       it 'allows local middleware modification' do
         @redis.expect :lpush, 1, ['queue:default', Array]
         $called = false
-        mware = Class.new { def call(worker_klass,msg,q); $called = true; msg;end }
+        mware = Class.new { def call(worker_klass,msg,q,r); $called = true; msg;end }
         client = Sidekiq::Client.new
         client.middleware do |chain|
           chain.add mware
@@ -177,7 +179,7 @@ class TestClient < Sidekiq::Test
     end
     it 'returns the jids for the jobs' do
       Sidekiq::Client.push_bulk('class' => 'QueuedWorker', 'args' => (1..2).to_a.map { |x| Array(x) }).each do |jid|
-        assert_match /[0-9a-f]{12}/, jid
+        assert_match(/[0-9a-f]{12}/, jid)
       end
     end
   end
@@ -198,7 +200,8 @@ class TestClient < Sidekiq::Test
   describe 'client middleware' do
 
     class Stopper
-      def call(worker_class, message, queue)
+      def call(worker_class, message, queue, r)
+        raise ArgumentError unless r
         yield if message['args'].first.odd?
       end
     end
@@ -207,9 +210,9 @@ class TestClient < Sidekiq::Test
       Sidekiq.client_middleware.add Stopper
       begin
         assert_equal nil, Sidekiq::Client.push('class' => MyWorker, 'args' => [0])
-        assert_match /[0-9a-f]{12}/, Sidekiq::Client.push('class' => MyWorker, 'args' => [1])
+        assert_match(/[0-9a-f]{12}/, Sidekiq::Client.push('class' => MyWorker, 'args' => [1]))
         Sidekiq::Client.push_bulk('class' => MyWorker, 'args' => [[0], [1]]).each do |jid|
-          assert_match /[0-9a-f]{12}/, jid
+          assert_match(/[0-9a-f]{12}/, jid)
         end
       ensure
         Sidekiq.client_middleware.remove Stopper
@@ -233,4 +236,40 @@ class TestClient < Sidekiq::Test
       assert_equal 2, Sidekiq::Client.new.__send__(:normalize_item, 'class' => CWorker, 'args' => [])['retry']
     end
   end
+
+  describe 'sharding' do
+    class DWorker < BaseWorker
+    end
+    it 'allows sidekiq_options to point to different Redi' do
+      conn = MiniTest::Mock.new
+      conn.expect(:multi, [0, 1])
+      DWorker.sidekiq_options('pool' => ConnectionPool.new(size: 1) { conn })
+      DWorker.perform_async(1,2,3)
+      conn.verify
+    end
+    it 'allows #via to point to different Redi' do
+      conn = MiniTest::Mock.new
+      conn.expect(:multi, [0, 1])
+      default = Sidekiq::Client.new.redis_pool
+      sharded_pool = ConnectionPool.new(size: 1) { conn }
+      Sidekiq::Client.via(sharded_pool) do
+        CWorker.perform_async(1,2,3)
+        assert_equal sharded_pool, Sidekiq::Client.new.redis_pool
+        assert_raises RuntimeError do
+          Sidekiq::Client.via(default) do
+            # nothing
+          end
+        end
+      end
+      assert_equal default, Sidekiq::Client.new.redis_pool
+      conn.verify
+    end
+    it 'allows Resque helpers to point to different Redi' do
+      conn = MiniTest::Mock.new
+      conn.expect(:zadd, 1, [String, Array])
+      DWorker.sidekiq_options('pool' => ConnectionPool.new(size: 1) { conn })
+      Sidekiq::Client.enqueue_in(10, DWorker, 3)
+      conn.verify
+    end
+  end
 end

data/test/test_exception_handler.rb

@@ -1,5 +1,4 @@
 require 'helper'
-require 'sidekiq'
 require 'sidekiq/exception_handler'
 require 'stringio'
 require 'logger'
@@ -33,9 +32,9 @@ class TestExceptionHandler < Sidekiq::Test
       Component.new.invoke_exception(:a => 1)
       @str_logger.rewind
       log = @str_logger.readlines
-      assert_match /a=>1/, log[0], "didn't include the context"
-      assert_match /Something didn't work!/, log[1], "didn't include the exception message"
-      assert_match /test\/test_exception_handler.rb/, log[2], "didn't include the backtrace"
+      assert_match(/a=>1/, log[0], "didn't include the context")
+      assert_match(/Something didn't work!/, log[1], "didn't include the exception message")
+      assert_match(/test\/test_exception_handler.rb/, log[2], "didn't include the backtrace")
     end
 
     describe "when the exception does not have a backtrace" do
@@ -46,93 +45,11 @@ class TestExceptionHandler < Sidekiq::Test
         begin
           Component.new.handle_exception exception
           pass
-        rescue => e
+        rescue StandardError
           flunk "failed handling a nil backtrace"
         end
       end
     end
   end
 
-  describe "with fake Airbrake" do
-    before do
-      ::Airbrake = Minitest::Mock.new
-    end
-
-    after do
-      Object.__send__(:remove_const, "Airbrake") # HACK should probably inject Airbrake etc into this class in the future
-    end
-
-    it "notifies Airbrake" do
-      ::Airbrake.expect(:notify_or_ignore,nil,[TEST_EXCEPTION,:parameters => { :a => 1 }])
-      Component.new.invoke_exception(:a => 1)
-      ::Airbrake.verify
-    end
-  end
-
-  describe "with fake Honeybadger" do
-    before do
-      ::Honeybadger = Minitest::Mock.new
-    end
-
-    after do
-      Object.__send__(:remove_const, "Honeybadger") # HACK should probably inject Honeybadger etc into this class in the future
-    end
-
-    it "notifies Honeybadger" do
-      ::Honeybadger.expect(:notify_or_ignore,nil,[TEST_EXCEPTION,:parameters => { :a => 1 }])
-      Component.new.invoke_exception(:a => 1)
-      ::Honeybadger.verify
-    end
-  end
-
-  describe "with fake ExceptionNotifier" do
-    before do
-      ::ExceptionNotifier = MiniTest::Mock.new
-    end
-
-    after do
-      Object.__send__(:remove_const, "ExceptionNotifier")
-    end
-
-    it "notifies ExceptionNotifier" do
-      ::ExceptionNotifier.expect(:notify_exception,true,[TEST_EXCEPTION, :data => { :message => { :b => 2 } }])
-      Component.new.invoke_exception(:b => 2)
-      ::ExceptionNotifier.verify
-    end
-  end
-
-  describe "with fake Exceptional" do
-    before do
-      ::Exceptional = Class.new do
-
-        def self.context(msg)
-          @msg = msg
-        end
-
-        def self.check_context
-          @msg
-        end
-      end
-
-      ::Exceptional::Config = Minitest::Mock.new
-      ::Exceptional::Remote = Minitest::Mock.new
-      ::Exceptional::ExceptionData = Minitest::Mock.new
-    end
-
-    after do
-      Object.__send__(:remove_const, "Exceptional")
-    end
-
-    it "notifies Exceptional" do
-      ::Exceptional::Config.expect(:should_send_to_api?,true)
-      exception_data = Object.new
-      ::Exceptional::Remote.expect(:error,nil,[exception_data])
-      ::Exceptional::ExceptionData.expect(:new,exception_data,[TEST_EXCEPTION])
-      Component.new.invoke_exception(:c => 3)
-      assert_equal({:c => 3},::Exceptional.check_context,"did not record arguments properly")
-      ::Exceptional::Config.verify
-      ::Exceptional::Remote.verify
-      ::Exceptional::ExceptionData.verify
-    end
-  end
 end

data/test/test_middleware.rb

@@ -112,6 +112,7 @@ class TestMiddleware < Sidekiq::Test
   describe 'i18n' do
     before do
       require 'i18n'
+      I18n.enforce_available_locales = false
       require 'sidekiq/middleware/i18n'
     end
 
@@ -119,7 +120,7 @@ class TestMiddleware < Sidekiq::Test
       I18n.locale = 'fr'
       msg = {}
       mw = Sidekiq::Middleware::I18n::Client.new
-      mw.call(nil, msg, nil) { }
+      mw.call(nil, msg, nil, nil) { }
       assert_equal :fr, msg['locale']
 
       msg['locale'] = 'jp'
@@ -142,7 +143,7 @@ class TestMiddleware < Sidekiq::Test
         assert_equal :jp, I18n.locale
       end
 
-      I18n.enforce_available_locales = nil
+      I18n.enforce_available_locales = false
       I18n.available_locales = nil
     end
   end

data/test/test_redis_connection.rb

@@ -81,12 +81,6 @@ class TestRedisConnection < Sidekiq::Test
       ENV[var] = nil
     end
 
-    describe "with REDISTOGO_URL set" do
-      it "sets connection URI to RedisToGo" do
-        with_env_var 'REDISTOGO_URL', 'redis://redis-to-go:6379/0'
-      end
-    end
-
     describe "with REDISTOGO_URL and a parallel REDIS_PROVIDER set" do
       it "sets connection URI to the provider" do
         uri = 'redis://sidekiq-redis-provider:6379/0'

data/test/test_retry.rb

@@ -10,6 +10,7 @@ class TestRetry < Sidekiq::Test
       Sidekiq.instance_variable_set(:@redis, @redis)
 
       def @redis.with; yield self; end
+      def @redis.multi; yield self; end
     end
 
     let(:worker) do
@@ -50,6 +51,9 @@ class TestRetry < Sidekiq::Test
       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
@@ -166,90 +170,31 @@ class TestRetry < Sidekiq::Test
     it 'throws away old messages after too many retries (using the default)' 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"=>true, "retry_count"=>25}
-      @redis.expect :zadd, 1, [ 'retry', String, String ]
+      @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
-      # Minitest can't assert that a method call did NOT happen!?
-      assert_raises(MockExpectationError) { @redis.verify }
+      @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, [ 'retry', String, String ]
+      @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
-      # Minitest can't assert that a method call did NOT happen!?
-      assert_raises(MockExpectationError) { @redis.verify }
-    end
-
-    describe "retry exhaustion" do
-      let(:handler){ Sidekiq::Middleware::Server::RetryJobs.new }
-      let(:worker) { Minitest::Mock.new }
-      let(:msg){ {"class"=>"Bob", "args"=>[1, 2, "foo"], "queue"=>"default", "error_message"=>"kerblammo!", "error_class"=>"RuntimeError", "failed_at"=>Time.now.to_f, "retry"=>3, "retry_count"=>3} }
-
-      describe "worker method" do
-        let(:worker) do
-          klass = Class.new do
-            include Sidekiq::Worker
-
-            def self.name; "Worker"; end
-
-            def retries_exhausted(*args)
-              args << "retried_method"
-            end
-          end
-        end
-
-        it 'calls worker.retries_exhausted after too many retries' do
-          assert_equal [1,2, "foo", "retried_method"], handler.__send__(:retries_exhausted, worker.new, msg)
-        end
-      end
-
-      describe "worker block" do
-        let(:worker) do
-          Class.new do
-            include Sidekiq::Worker
-
-            sidekiq_retries_exhausted do |msg|
-              msg.tap {|m| m['called_by_callback'] = true }
-            end
-          end
-        end
-
-        it 'calls worker sidekiq_retries_exhausted_block after too many retries' do
-          new_msg      = handler.__send__(:retries_exhausted, worker.new, msg)
-          expected_msg = msg.merge('called_by_callback' => true)
-
-          assert_equal expected_msg, new_msg, "sidekiq_retries_exhausted block not called"
-        end
-      end
-
-      it 'handles and logs retries_exhausted failures gracefully (drops them)' do
-        def worker.retries_exhausted(*args)
-          raise 'bam!'
-        end
-
-        e = task_misbehaving_worker
-        assert_equal e.message, "kerblammo!"
-        worker.verify
-      end
-
-      def task_misbehaving_worker
-        assert_raises RuntimeError do
-          handler.call(worker, msg, 'default') do
-            raise 'kerblammo!'
-          end
-        end
-      end
+      @redis.verify
     end
 
     describe "custom retry delay" do
@@ -262,7 +207,7 @@ class TestRetry < Sidekiq::Test
       after do
         Sidekiq.logger = @old_logger
         Sidekiq.options.delete(:logfile)
-        File.unlink @tmp_log_path if File.exists?(@tmp_log_path)
+        File.unlink @tmp_log_path if File.exist?(@tmp_log_path)
       end
 
       let(:custom_worker) do

data/test/test_scheduled.rb

@@ -28,7 +28,7 @@ class TestScheduled < Sidekiq::Test
     end
 
     class Stopper
-      def call(worker_class, message, queue)
+      def call(worker_class, message, queue, r)
         yield if message['args'].first.odd?
       end
     end

data/test/test_scheduling.rb

@@ -4,6 +4,7 @@ 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)
@@ -11,6 +12,10 @@ class TestScheduling < Sidekiq::Test
       def @redis.with; yield self; end
     end
 
+    after do
+      Sidekiq::Client.instance_variable_set(:@default, nil)
+    end
+
     class ScheduledWorker
       include Sidekiq::Worker
       sidekiq_options :queue => :custom_queue

data/test/test_sidekiq.rb

@@ -34,4 +34,22 @@ class TestSidekiq < Sidekiq::Test
       assert_equal "Calm down, bro\n", $stdout.string
     end
   end
+
+  describe 'lifecycle events' do
+    it 'handles invalid input' do
+      e = assert_raises ArgumentError do
+        Sidekiq.on(:startp)
+      end
+      assert_match(/Invalid event name/, e.message)
+      e = assert_raises ArgumentError do
+        Sidekiq.on('startup')
+      end
+      assert_match(/Symbols only/, e.message)
+      Sidekiq.on(:startup) do
+        1 + 1
+      end
+
+      assert_equal 2, Sidekiq.options[:lifecycle_events][:startup].first.call
+    end
+  end
 end

data/test/test_web.rb

@@ -4,6 +4,7 @@ require 'sidekiq/web'
 require 'rack/test'
 
 class TestWeb < Sidekiq::Test
+
   describe 'sidekiq web' do
     include Rack::Test::Methods
 
@@ -30,18 +31,20 @@ class TestWeb < Sidekiq::Test
 
     it 'can display workers' do
       Sidekiq.redis do |conn|
-        identity = 'foo:1234-123abc:default'
-        conn.sadd('workers', identity)
-        conn.setex("worker:#{identity}:started", 10, Time.now.to_s)
+        conn.incr('busy')
+        conn.sadd('processes', 'foo:1234')
+        conn.hmset('foo:1234', 'info', Sidekiq.dump_json('hostname' => 'foo', 'started_at' => Time.now.to_f), 'at', Time.now.to_f, 'busy', 4)
+        identity = 'foo:1234:workers'
         hash = {:queue => 'critical', :payload => { 'class' => WebWorker.name, 'args' => [1,'abc'] }, :run_at => Time.now.to_i }
-        conn.setex("worker:#{identity}", 10, Sidekiq.dump_json(hash))
+        conn.hmset(identity, 1001, Sidekiq.dump_json(hash))
       end
+      assert_equal ['1001'], Sidekiq::Workers.new.map { |pid, tid, data| tid }
 
-      get '/workers'
+      get '/busy'
       assert_equal 200, last_response.status
-      assert_match /status-active/, last_response.body
-      assert_match /critical/, last_response.body
-      assert_match /WebWorker/, last_response.body
+      assert_match(/status-active/, last_response.body)
+      assert_match(/critical/, last_response.body)
+      assert_match(/WebWorker/, last_response.body)
     end
 
     it 'can display queues' do
@@ -49,8 +52,8 @@ class TestWeb < Sidekiq::Test
 
       get '/queues'
       assert_equal 200, last_response.status
-      assert_match /foo/, last_response.body
-      refute_match /HardWorker/, last_response.body
+      assert_match(/foo/, last_response.body)
+      refute_match(/HardWorker/, last_response.body)
     end
 
     it 'handles queue view' do
@@ -76,26 +79,6 @@ class TestWeb < Sidekiq::Test
       end
     end
 
-    it 'can clear an empty worker list' do
-      post '/reset'
-      assert_equal 302, last_response.status
-    end
-
-    it 'can clear a non-empty worker list' do
-      Sidekiq.redis do |conn|
-        identity = 'foo'
-        conn.sadd('workers', identity)
-      end
-
-      post '/reset'
-
-      assert_equal 302, last_response.status
-
-      Sidekiq.redis do |conn|
-        refute conn.smembers('workers').any?
-      end
-    end
-
     it 'can delete a job' do
       Sidekiq.redis do |conn|
         conn.rpush('queue:foo', "{}")
@@ -117,15 +100,15 @@ class TestWeb < Sidekiq::Test
     it 'can display retries' do
       get '/retries'
       assert_equal 200, last_response.status
-      assert_match /found/, last_response.body
-      refute_match /HardWorker/, last_response.body
+      assert_match(/found/, last_response.body)
+      refute_match(/HardWorker/, last_response.body)
 
       add_retry
 
       get '/retries'
       assert_equal 200, last_response.status
-      refute_match /found/, last_response.body
-      assert_match /HardWorker/, last_response.body
+      refute_match(/found/, last_response.body)
+      assert_match(/HardWorker/, last_response.body)
     end
 
     it 'can display a single retry' do
@@ -134,7 +117,7 @@ class TestWeb < Sidekiq::Test
       assert_equal 302, last_response.status
       get "/retries/#{job_params(*params)}"
       assert_equal 200, last_response.status
-      assert_match /HardWorker/, last_response.body
+      assert_match(/HardWorker/, last_response.body)
     end
 
     it 'handles missing retry' do
@@ -150,7 +133,7 @@ class TestWeb < Sidekiq::Test
 
       get "/retries"
       assert_equal 200, last_response.status
-      refute_match /#{params.first['args'][2]}/, last_response.body
+      refute_match(/#{params.first['args'][2]}/, last_response.body)
     end
 
     it 'can delete all retries' do
@@ -170,21 +153,21 @@ class TestWeb < Sidekiq::Test
 
       get '/queues/default'
       assert_equal 200, last_response.status
-      assert_match /#{params.first['args'][2]}/, last_response.body
+      assert_match(/#{params.first['args'][2]}/, last_response.body)
     end
 
     it 'can display scheduled' do
       get '/scheduled'
       assert_equal 200, last_response.status
-      assert_match /found/, last_response.body
-      refute_match /HardWorker/, last_response.body
+      assert_match(/found/, last_response.body)
+      refute_match(/HardWorker/, last_response.body)
 
       add_scheduled
 
       get '/scheduled'
       assert_equal 200, last_response.status
-      refute_match /found/, last_response.body
-      assert_match /HardWorker/, last_response.body
+      refute_match(/found/, last_response.body)
+      assert_match(/HardWorker/, last_response.body)
     end
 
     it 'can display a single scheduled job' do
@@ -193,7 +176,7 @@ class TestWeb < Sidekiq::Test
       assert_equal 302, last_response.status
       get "/scheduled/#{job_params(*params)}"
       assert_equal 200, last_response.status
-      assert_match /HardWorker/, last_response.body
+      assert_match(/HardWorker/, last_response.body)
     end
 
     it 'handles missing scheduled job' do
@@ -209,7 +192,7 @@ class TestWeb < Sidekiq::Test
 
       get '/queues/default'
       assert_equal 200, last_response.status
-      assert_match /#{params.first['args'][2]}/, last_response.body
+      assert_match(/#{params.first['args'][2]}/, last_response.body)
     end
 
     it 'can delete a single scheduled job' do
@@ -220,7 +203,7 @@ class TestWeb < Sidekiq::Test
 
       get "/scheduled"
       assert_equal 200, last_response.status
-      refute_match /#{params.first['args'][2]}/, last_response.body
+      refute_match(/#{params.first['args'][2]}/, last_response.body)
     end
 
     it 'can delete scheduled' do
@@ -247,12 +230,12 @@ class TestWeb < Sidekiq::Test
         assert_equal 1, q.size
         get '/queues/default'
         assert_equal 200, last_response.status
-        assert_match /#{params[0]['args'][2]}/, last_response.body
+        assert_match(/#{params[0]['args'][2]}/, last_response.body)
       end
     end
 
     it 'can retry all retries' do
-      msg, score = add_retry
+      msg = add_retry.first
       add_retry
 
       post "/retries/all/retry", 'retry' => 'Retry'
@@ -270,7 +253,7 @@ class TestWeb < Sidekiq::Test
       params = add_xss_retry
       get '/retries'
       assert_equal 200, last_response.status
-      assert_match /FailWorker/, last_response.body
+      assert_match(/FailWorker/, last_response.body)
 
       assert last_response.body.include?( "fail message: &lt;a&gt;hello&lt;&#x2F;a&gt;" )
       assert !last_response.body.include?( "fail message: <a>hello</a>" )
@@ -278,19 +261,20 @@ class TestWeb < Sidekiq::Test
       assert last_response.body.include?( "args\">&quot;&lt;a&gt;hello&lt;&#x2F;a&gt;&quot;<" )
       assert !last_response.body.include?( "args\"><a>hello</a><" )
 
-
       # on /workers page
       Sidekiq.redis do |conn|
-        identity = 'foo:1234-123abc:default'
-        conn.sadd('workers', identity)
-        conn.setex("worker:#{identity}:started", 10, Time.now.to_s)
+        pro = 'foo:1234'
+        conn.sadd('processes', pro)
+        conn.hmset(pro, 'info', Sidekiq.dump_json('started_at' => Time.now.to_f), 'busy', 1, 'beat', Time.now.to_f)
+        identity = "#{pro}:workers"
         hash = {:queue => 'critical', :payload => { 'class' => "FailWorker", 'args' => ["<a>hello</a>"] }, :run_at => Time.now.to_i }
-        conn.setex("worker:#{identity}", 10, Sidekiq.dump_json(hash))
+        conn.hmset(identity, 100001, Sidekiq.dump_json(hash))
+        conn.incr('busy')
       end
 
-      get '/workers'
+      get '/busy'
       assert_equal 200, last_response.status
-      assert_match /FailWorker/, last_response.body
+      assert_match(/FailWorker/, last_response.body)
       assert last_response.body.include?( "&lt;a&gt;hello&lt;&#x2F;a&gt;" )
       assert !last_response.body.include?( "<a>hello</a>" )
 
@@ -332,7 +316,7 @@ class TestWeb < Sidekiq::Test
         end
 
         get '/custom'
-        assert_match /Changed text/, last_response.body
+        assert_match(/Changed text/, last_response.body)
 
       ensure
         Sidekiq::Web.tabs.delete 'Custom Tab'
@@ -340,6 +324,8 @@ class TestWeb < Sidekiq::Test
     end
 
     describe 'stats' do
+      include Sidekiq::Util
+
       before do
         Sidekiq.redis do |conn|
           conn.set("stat:processed", 5)
@@ -394,6 +380,41 @@ class TestWeb < Sidekiq::Test
       end
     end
 
+    describe 'dead jobs' do
+      it 'shows empty index' do
+        get 'morgue'
+        assert_equal 200, last_response.status
+      end
+
+      it 'shows index with jobs' do
+        (_, score) = add_dead
+        get 'morgue'
+        assert_equal 200, last_response.status
+        assert_match(/#{score}/, last_response.body)
+      end
+
+      it 'can delete all dead' do
+        3.times { add_dead }
+
+        assert_equal 3, Sidekiq::DeadSet.new.size
+        post "/morgue/all/delete", 'delete' => 'Delete'
+        assert_equal 0, Sidekiq::DeadSet.new.size
+        assert_equal 302, last_response.status
+        assert_equal 'http://example.org/morgue', last_response.header['Location']
+      end
+
+      it 'can retry a dead job' do
+        params = add_dead
+        post "/morgue/#{job_params(*params)}", 'retry' => 'Retry'
+        assert_equal 302, last_response.status
+        assert_equal 'http://example.org/morgue', last_response.header['Location']
+
+        get '/queues/foo'
+        assert_equal 200, last_response.status
+        assert_match(/#{params.first['args'][2]}/, last_response.body)
+      end
+    end
+
     def add_scheduled
       score = Time.now.to_f
       msg = { 'class' => 'HardWorker',
@@ -421,6 +442,22 @@ class TestWeb < Sidekiq::Test
       [msg, score]
     end
 
+    def add_dead
+      msg = { 'class' => 'HardWorker',
+              'args' => ['bob', 1, Time.now.to_f],
+              'queue' => 'foo',
+              'error_message' => 'Some fake message',
+              'error_class' => 'RuntimeError',
+              'retry_count' => 0,
+              'failed_at' => Time.now.utc,
+              'jid' => SecureRandom.hex(12) }
+      score = Time.now.to_f
+      Sidekiq.redis do |conn|
+        conn.zadd('dead', score, Sidekiq.dump_json(msg))
+      end
+      [msg, score]
+    end
+
     def add_xss_retry
       msg = { 'class' => 'FailWorker',
               'args' => ['<a>hello</a>'],
@@ -438,11 +475,14 @@ class TestWeb < Sidekiq::Test
     end
 
     def add_worker
-      process_id = rand(1000)
+      key = "#{hostname}:#{$$}"
       msg = "{\"queue\":\"default\",\"payload\":{\"retry\":true,\"queue\":\"default\",\"timeout\":20,\"backtrace\":5,\"class\":\"HardWorker\",\"args\":[\"bob\",10,5],\"jid\":\"2b5ad2b016f5e063a1c62872\"},\"run_at\":1361208995}"
       Sidekiq.redis do |conn|
-        conn.sadd("workers", "mercury.home:#{process_id}-70215157189060:started")
-        conn.set("worker:mercury.home:#{process_id}-70215157189060:started", msg)
+        conn.multi do
+          conn.sadd("processes", key)
+          conn.hmset(key, 'busy', 4)
+          conn.hmset("#{key}:workers", Time.now.to_f, msg)
+        end
       end
     end
   end