sidekiq 3.5.4 → 5.2.7

data/lib/sidekiq/actor.rb

@@ -1,39 +0,0 @@
-module Sidekiq
-  module Actor
-
-    module ClassMethods
-      def trap_exit(*args)
-      end
-      def new_link(*args)
-        new(*args)
-      end
-    end
-
-    module InstanceMethods
-      def current_actor
-        self
-      end
-      def after(interval)
-      end
-      def alive?
-        @dead = false unless defined?(@dead)
-        !@dead
-      end
-      def terminate
-        @dead = true
-      end
-      def defer
-        yield
-      end
-    end
-
-    def self.included(klass)
-      if $TESTING
-        klass.__send__(:include, InstanceMethods)
-        klass.__send__(:extend, ClassMethods)
-      else
-        klass.__send__(:include, Celluloid)
-      end
-    end
-  end
-end

data/lib/sidekiq/middleware/server/logging.rb

@@ -1,40 +0,0 @@
-module Sidekiq
-  module Middleware
-    module Server
-      class Logging
-
-        def call(worker, item, queue)
-          Sidekiq::Logging.with_context(log_context(worker, item)) do
-            begin
-              start = Time.now
-              logger.info { "start" }
-              yield
-              logger.info { "done: #{elapsed(start)} sec" }
-            rescue Exception
-              logger.info { "fail: #{elapsed(start)} sec" }
-              raise
-            end
-          end
-        end
-
-        private
-
-        # If we're using a wrapper class, like ActiveJob, use the "wrapped"
-        # attribute to expose the underlying thing.
-        def log_context(worker, item)
-          klass = item['wrapped'.freeze] || worker.class.to_s
-          "#{klass} JID-#{item['jid'.freeze]}#{" BID-#{item['bid'.freeze]}" if item['bid'.freeze]}"
-        end
-
-        def elapsed(start)
-          (Time.now - start).round(3)
-        end
-
-        def logger
-          Sidekiq.logger
-        end
-      end
-    end
-  end
-end
-

data/lib/sidekiq/middleware/server/retry_jobs.rb

@@ -1,206 +0,0 @@
-require 'sidekiq/scheduled'
-require 'sidekiq/api'
-
-module Sidekiq
-  module Middleware
-    module Server
-      ##
-      # Automatically retry jobs that fail in Sidekiq.
-      # Sidekiq's retry support assumes a typical development lifecycle:
-      #
-      #   0. push some code changes with a bug in it
-      #   1. bug causes job processing to fail, sidekiq's middleware captures
-      #      the job and pushes it onto a retry queue
-      #   2. sidekiq retries jobs in the retry queue multiple times with
-      #      an exponential delay, the job continues to fail
-      #   3. after a few days, a developer deploys a fix.  the job is
-      #      reprocessed successfully.
-      #   4. once retries are exhausted, sidekiq will give up and move the
-      #      job to the Dead Job Queue (aka morgue) where it must be dealt with
-      #      manually in the Web UI.
-      #   5. After 6 months on the DJQ, Sidekiq will discard the job.
-      #
-      # A job looks like:
-      #
-      #     { 'class' => 'HardWorker', 'args' => [1, 2, 'foo'], 'retry' => true }
-      #
-      # The 'retry' option also accepts a number (in place of 'true'):
-      #
-      #     { 'class' => 'HardWorker', 'args' => [1, 2, 'foo'], 'retry' => 5 }
-      #
-      # The job will be retried this number of times before giving up. (If simply
-      # 'true', Sidekiq retries 25 times)
-      #
-      # We'll add a bit more data to the job to support retries:
-      #
-      #  * 'queue' - the queue to use
-      #  * 'retry_count' - number of times we've retried so far.
-      #  * 'error_message' - the message from the exception
-      #  * 'error_class' - the exception class
-      #  * 'failed_at' - the first time it failed
-      #  * 'retried_at' - the last time it was retried
-      #  * 'backtrace' - the number of lines of error backtrace to store
-      #
-      # We don't store the backtrace by default as that can add a lot of overhead
-      # to the job and everyone is using an error service, right?
-      #
-      # The default number of retry attempts is 25 which works out to about 3 weeks
-      # of retries. You can pass a value for the max number of retry attempts when
-      # adding the middleware using the options hash:
-      #
-      #   Sidekiq.configure_server do |config|
-      #     config.server_middleware do |chain|
-      #       chain.add Sidekiq::Middleware::Server::RetryJobs, :max_retries => 7
-      #     end
-      #   end
-      #
-      # or limit the number of retries for a particular worker with:
-      #
-      #    class MyWorker
-      #      include Sidekiq::Worker
-      #      sidekiq_options :retry => 10
-      #    end
-      #
-      class RetryJobs
-        include Sidekiq::Util
-
-        DEFAULT_MAX_RETRY_ATTEMPTS = 25
-
-        def initialize(options = {})
-          @max_retries = options.fetch(:max_retries, DEFAULT_MAX_RETRY_ATTEMPTS)
-        end
-
-        def call(worker, msg, queue)
-          yield
-        rescue Sidekiq::Shutdown
-          # ignore, will be pushed back onto queue during hard_shutdown
-          raise
-        rescue Exception => e
-          # ignore, will be pushed back onto queue during hard_shutdown
-          raise Sidekiq::Shutdown if exception_caused_by_shutdown?(e)
-
-          raise e unless msg['retry']
-          attempt_retry(worker, msg, queue, e)
-        end
-
-        private
-
-        def attempt_retry(worker, msg, queue, exception)
-          max_retry_attempts = retry_attempts_from(msg['retry'], @max_retries)
-
-          msg['queue'] = if msg['retry_queue']
-            msg['retry_queue']
-          else
-            queue
-          end
-
-          # App code can stuff all sorts of crazy binary data into the error message
-          # that won't convert to JSON.
-          m = exception.message.to_s[0, 10_000]
-          if m.respond_to?(:scrub!)
-            m.force_encoding("utf-8")
-            m.scrub!
-          end
-
-          msg['error_message'] = m
-          msg['error_class'] = exception.class.name
-          count = if msg['retry_count']
-            msg['retried_at'] = Time.now.to_f
-            msg['retry_count'] += 1
-          else
-            msg['failed_at'] = Time.now.to_f
-            msg['retry_count'] = 0
-          end
-
-          if msg['backtrace'] == true
-            msg['error_backtrace'] = exception.backtrace
-          elsif !msg['backtrace']
-            # do nothing
-          elsif msg['backtrace'].to_i != 0
-            msg['error_backtrace'] = exception.backtrace[0...msg['backtrace'].to_i]
-          end
-
-          if count < max_retry_attempts
-            delay = delay_for(worker, count, exception)
-            logger.debug { "Failure! Retry #{count} in #{delay} seconds" }
-            retry_at = Time.now.to_f + delay
-            payload = Sidekiq.dump_json(msg)
-            Sidekiq.redis do |conn|
-              conn.zadd('retry', retry_at.to_s, payload)
-            end
-          else
-            # Goodbye dear message, you (re)tried your best I'm sure.
-            retries_exhausted(worker, msg)
-          end
-
-          raise exception
-        end
-
-        def retries_exhausted(worker, msg)
-          logger.debug { "Dropping message after hitting the retry maximum: #{msg}" }
-          begin
-            if worker.sidekiq_retries_exhausted_block?
-              worker.sidekiq_retries_exhausted_block.call(msg)
-            end
-          rescue => e
-            handle_exception(e, { context: "Error calling retries_exhausted for #{worker.class}", job: msg })
-          end
-
-          send_to_morgue(msg) unless msg['dead'] == false
-        end
-
-        def send_to_morgue(msg)
-          Sidekiq.logger.info { "Adding dead #{msg['class']} job #{msg['jid']}" }
-          payload = Sidekiq.dump_json(msg)
-          now = Time.now.to_f
-          Sidekiq.redis do |conn|
-            conn.multi do
-              conn.zadd('dead', now, payload)
-              conn.zremrangebyscore('dead', '-inf', now - DeadSet.timeout)
-              conn.zremrangebyrank('dead', 0, -DeadSet.max_jobs)
-            end
-          end
-        end
-
-        def retry_attempts_from(msg_retry, default)
-          if msg_retry.is_a?(Fixnum)
-            msg_retry
-          else
-            default
-          end
-        end
-
-        def delay_for(worker, count, exception)
-          worker.sidekiq_retry_in_block? && retry_in(worker, count, exception) || seconds_to_delay(count)
-        end
-
-        # delayed_job uses the same basic formula
-        def seconds_to_delay(count)
-          (count ** 4) + 15 + (rand(30)*(count+1))
-        end
-
-        def retry_in(worker, count, exception)
-          begin
-            worker.sidekiq_retry_in_block.call(count, exception).to_i
-          rescue Exception => e
-            handle_exception(e, { context: "Failure scheduling retry using the defined `sidekiq_retry_in` in #{worker.class.name}, falling back to default" })
-            nil
-          end
-        end
-
-        def exception_caused_by_shutdown?(e, checked_causes = [])
-          # In Ruby 2.1.0 only, check if exception is a result of shutdown.
-          return false unless defined?(e.cause)
-
-          # Handle circular causes
-          checked_causes << e.object_id
-          return false if checked_causes.include?(e.cause.object_id)
-
-          e.cause.instance_of?(Sidekiq::Shutdown) ||
-            exception_caused_by_shutdown?(e.cause, checked_causes)
-        end
-
-      end
-    end
-  end
-end

data/test/config.yml

@@ -1,9 +0,0 @@
----
-:verbose:      false
-:require:      ./test/fake_env.rb
-:pidfile:      /tmp/sidekiq-config-test.pid
-:logfile:      /tmp/sidekiq.log
-:concurrency:  50
-:queues:
-  - [<%="very_"%>often, 2]
-  - [seldom, 1]

data/test/env_based_config.yml

@@ -1,11 +0,0 @@
----
-:pidfile:      /tmp/sidekiq-config-test.pid
-:concurrency:  50
-staging:
-  :verbose:      false
-  :require:      ./test/fake_env.rb
-  :logfile:      /tmp/sidekiq.log
-  :concurrency:  5
-  :queues:
-    - [<%="very_"%>often, 2]
-    - [seldom, 1]

data/test/fixtures/en.yml

@@ -1,2 +0,0 @@
-en:
-  translated_text: 'Changed text from add locals'

data/test/helper.rb

@@ -1,49 +0,0 @@
-$CELLULOID_DEBUG = false
-$TESTING = true
-if ENV["COVERAGE"]
-  require 'simplecov'
-  SimpleCov.start do
-    add_filter "/test/"
-    add_filter "/myapp/"
-  end
-end
-ENV['RACK_ENV'] = ENV['RAILS_ENV'] = 'test'
-
-begin
-  require 'pry-byebug'
-rescue LoadError
-end
-
-require 'minitest/autorun'
-require 'minitest/pride'
-
-require 'celluloid/current'
-require 'celluloid/test'
-Celluloid.boot
-require 'sidekiq'
-require 'sidekiq/util'
-Sidekiq.logger.level = Logger::ERROR
-
-Sidekiq::Test = Minitest::Test
-
-require 'sidekiq/redis_connection'
-REDIS_URL = ENV['REDIS_URL'] || 'redis://localhost/15'
-REDIS = Sidekiq::RedisConnection.create(:url => REDIS_URL, :namespace => 'testy')
-
-Sidekiq.configure_client do |config|
-  config.redis = { :url => REDIS_URL, :namespace => 'testy' }
-end
-
-def capture_logging(lvl=Logger::INFO)
-  old = Sidekiq.logger
-  begin
-    out = StringIO.new
-    logger = Logger.new(out)
-    logger.level = lvl
-    Sidekiq.logger = logger
-    yield
-    out.string
-  ensure
-    Sidekiq.logger = old
-  end
-end

data/test/test_api.rb

@@ -1,493 +0,0 @@
-require_relative 'helper'
-
-class TestApi < Sidekiq::Test
-
-  describe "stats" do
-
-    it "is initially zero" do
-      Sidekiq.redis {|c| c.flushdb }
-      s = Sidekiq::Stats.new
-      assert_equal 0, s.processed
-      assert_equal 0, s.failed
-      assert_equal 0, s.enqueued
-    end
-
-    describe "processed" do
-      it "returns number of processed jobs" do
-        Sidekiq.redis { |conn| conn.set("stat:processed", 5) }
-        s = Sidekiq::Stats.new
-        assert_equal 5, s.processed
-      end
-    end
-
-    describe "failed" do
-      it "returns number of failed jobs" do
-        Sidekiq.redis { |conn| conn.set("stat:failed", 5) }
-        s = Sidekiq::Stats.new
-        assert_equal 5, s.failed
-      end
-    end
-
-    describe "reset" do
-      before do
-        Sidekiq.redis do |conn|
-          conn.set('stat:processed', 5)
-          conn.set('stat:failed', 10)
-        end
-      end
-
-      it 'will reset all stats by default' do
-        Sidekiq::Stats.new.reset
-        s = Sidekiq::Stats.new
-        assert_equal 0, s.failed
-        assert_equal 0, s.processed
-      end
-
-      it 'can reset individual stats' do
-        Sidekiq::Stats.new.reset('failed')
-        s = Sidekiq::Stats.new
-        assert_equal 0, s.failed
-        assert_equal 5, s.processed
-      end
-
-      it 'can accept anything that responds to #to_s' do
-        Sidekiq::Stats.new.reset(:failed)
-        s = Sidekiq::Stats.new
-        assert_equal 0, s.failed
-        assert_equal 5, s.processed
-      end
-
-      it 'ignores anything other than "failed" or "processed"' do
-        Sidekiq::Stats.new.reset((1..10).to_a, ['failed'])
-        s = Sidekiq::Stats.new
-        assert_equal 0, s.failed
-        assert_equal 5, s.processed
-      end
-    end
-
-    describe "queues" do
-      before do
-        Sidekiq.redis {|c| c.flushdb }
-      end
-
-      it "is initially empty" do
-        s = Sidekiq::Stats::Queues.new
-        assert_equal 0, s.lengths.size
-      end
-
-      it "returns a hash of queue and size in order" do
-        Sidekiq.redis do |conn|
-          conn.rpush 'queue:foo', '{}'
-          conn.sadd 'queues', 'foo'
-
-          3.times { conn.rpush 'queue:bar', '{}' }
-          conn.sadd 'queues', 'bar'
-        end
-
-        s = Sidekiq::Stats::Queues.new
-        assert_equal ({ "foo" => 1, "bar" => 3 }), s.lengths
-        assert_equal "bar", s.lengths.first.first
-
-        assert_equal Sidekiq::Stats.new.queues, Sidekiq::Stats::Queues.new.lengths
-      end
-    end
-
-    describe "enqueued" do
-      it "returns total enqueued jobs" do
-        Sidekiq.redis do |conn|
-          conn.flushdb
-          conn.rpush 'queue:foo', '{}'
-          conn.sadd 'queues', 'foo'
-
-          3.times { conn.rpush 'queue:bar', '{}' }
-          conn.sadd 'queues', 'bar'
-        end
-
-        s = Sidekiq::Stats.new
-        assert_equal 4, s.enqueued
-      end
-    end
-
-    describe "over time" do
-      before do
-        @before = DateTime::DATE_FORMATS[:default]
-        DateTime::DATE_FORMATS[:default] = "%d/%m/%Y %H:%M:%S"
-      end
-
-      after do
-        DateTime::DATE_FORMATS[:default] = @before
-      end
-
-      describe "processed" do
-        it 'retrieves hash of dates' do
-          Sidekiq.redis do |c|
-            c.incrby("stat:processed:2012-12-24", 4)
-            c.incrby("stat:processed:2012-12-25", 1)
-            c.incrby("stat:processed:2012-12-26", 6)
-            c.incrby("stat:processed:2012-12-27", 2)
-          end
-          Time.stub(:now, Time.parse("2012-12-26 1:00:00 -0500")) do
-            s = Sidekiq::Stats::History.new(2)
-            assert_equal({ "2012-12-26" => 6, "2012-12-25" => 1 }, s.processed)
-
-            s = Sidekiq::Stats::History.new(3)
-            assert_equal({ "2012-12-26" => 6, "2012-12-25" => 1, "2012-12-24" => 4 }, s.processed)
-
-            s = Sidekiq::Stats::History.new(2, Date.parse("2012-12-25"))
-            assert_equal({ "2012-12-25" => 1, "2012-12-24" => 4 }, s.processed)
-          end
-        end
-      end
-
-      describe "failed" do
-        it 'retrieves hash of dates' do
-          Sidekiq.redis do |c|
-            c.incrby("stat:failed:2012-12-24", 4)
-            c.incrby("stat:failed:2012-12-25", 1)
-            c.incrby("stat:failed:2012-12-26", 6)
-            c.incrby("stat:failed:2012-12-27", 2)
-          end
-          Time.stub(:now, Time.parse("2012-12-26 1:00:00 -0500")) do
-            s = Sidekiq::Stats::History.new(2)
-            assert_equal ({ "2012-12-26" => 6, "2012-12-25" => 1 }), s.failed
-
-            s = Sidekiq::Stats::History.new(3)
-            assert_equal ({ "2012-12-26" => 6, "2012-12-25" => 1, "2012-12-24" => 4 }), s.failed
-
-            s = Sidekiq::Stats::History.new(2, Date.parse("2012-12-25"))
-            assert_equal ({ "2012-12-25" => 1, "2012-12-24" => 4 }), s.failed
-          end
-        end
-      end
-    end
-  end
-
-  describe 'with an empty database' do
-    before do
-      Sidekiq.redis {|c| c.flushdb }
-    end
-
-    it 'shows queue as empty' do
-      q = Sidekiq::Queue.new
-      assert_equal 0, q.size
-      assert_equal 0, q.latency
-    end
-
-    class ApiWorker
-      include Sidekiq::Worker
-    end
-
-    it 'can enumerate jobs' do
-      q = Sidekiq::Queue.new
-      Time.stub(:now, Time.new(2012, 12, 26)) do
-        ApiWorker.perform_async(1, 'mike')
-        assert_equal ['TestApi::ApiWorker'], q.map(&:klass)
-
-        job = q.first
-        assert_equal 24, job.jid.size
-        assert_equal [1, 'mike'], job.args
-        assert_equal Time.new(2012, 12, 26), job.enqueued_at
-      end
-
-      assert q.latency > 10_000_000
-
-      q = Sidekiq::Queue.new('other')
-      assert_equal 0, q.size
-    end
-
-    it 'has no enqueued_at time for jobs enqueued in the future' do
-      job_id = ApiWorker.perform_in(100, 1, 'foo')
-      job = Sidekiq::ScheduledSet.new.find_job(job_id)
-      assert_nil job.enqueued_at
-    end
-
-    it 'unwraps delayed jobs' do
-      Sidekiq::Queue.delay.foo(1,2,3)
-      q = Sidekiq::Queue.new
-      x = q.first
-      assert_equal "Sidekiq::Queue.foo", x.display_class
-      assert_equal [1,2,3], x.display_args
-    end
-
-    it 'can delete jobs' do
-      q = Sidekiq::Queue.new
-      ApiWorker.perform_async(1, 'mike')
-      assert_equal 1, q.size
-
-      x = q.first
-      assert_equal "TestApi::ApiWorker", x.display_class
-      assert_equal [1,'mike'], x.display_args
-
-      assert_equal [true], q.map(&:delete)
-      assert_equal 0, q.size
-    end
-
-    it "can move scheduled job to queue" do
-      remain_id = ApiWorker.perform_in(100, 1, 'jason')
-      job_id = ApiWorker.perform_in(100, 1, 'jason')
-      job = Sidekiq::ScheduledSet.new.find_job(job_id)
-      q = Sidekiq::Queue.new
-      job.add_to_queue
-      queued_job = q.find_job(job_id)
-      refute_nil queued_job
-      assert_equal queued_job.jid, job_id
-      assert_nil Sidekiq::ScheduledSet.new.find_job(job_id)
-      refute_nil Sidekiq::ScheduledSet.new.find_job(remain_id)
-    end
-
-    it "handles multiple scheduled jobs when moving to queue" do
-      jids = Sidekiq::Client.push_bulk('class' => ApiWorker,
-                                       'args' => [[1, 'jason'], [2, 'jason']],
-                                       'at' => Time.now.to_f)
-      assert_equal 2, jids.size
-      (remain_id, job_id) = jids
-      job = Sidekiq::ScheduledSet.new.find_job(job_id)
-      q = Sidekiq::Queue.new
-      job.add_to_queue
-      queued_job = q.find_job(job_id)
-      refute_nil queued_job
-      assert_equal queued_job.jid, job_id
-      assert_nil Sidekiq::ScheduledSet.new.find_job(job_id)
-      refute_nil Sidekiq::ScheduledSet.new.find_job(remain_id)
-    end
-
-    it 'can find job by id in sorted sets' do
-      job_id = ApiWorker.perform_in(100, 1, 'jason')
-      job = Sidekiq::ScheduledSet.new.find_job(job_id)
-      refute_nil job
-      assert_equal job_id, job.jid
-      assert_in_delta job.latency, 0.0, 0.1
-    end
-
-    it 'can remove jobs when iterating over a sorted set' do
-      # scheduled jobs must be greater than SortedSet#each underlying page size
-      51.times do
-        ApiWorker.perform_in(100, 'aaron')
-      end
-      set = Sidekiq::ScheduledSet.new
-      set.map(&:delete)
-      assert_equal set.size, 0
-    end
-
-    it 'can remove jobs when iterating over a queue' do
-      # initial queue size must be greater than Queue#each underlying page size
-      51.times do
-        ApiWorker.perform_async(1, 'aaron')
-      end
-      q = Sidekiq::Queue.new
-      q.map(&:delete)
-      assert_equal q.size, 0
-    end
-
-    it 'can find job by id in queues' do
-      q = Sidekiq::Queue.new
-      job_id = ApiWorker.perform_async(1, 'jason')
-      job = q.find_job(job_id)
-      refute_nil job
-      assert_equal job_id, job.jid
-    end
-
-    it 'can clear a queue' do
-      q = Sidekiq::Queue.new
-      2.times { ApiWorker.perform_async(1, 'mike') }
-      q.clear
-
-      Sidekiq.redis do |conn|
-        refute conn.smembers('queues').include?('foo')
-        refute conn.exists('queue:foo')
-      end
-    end
-
-    it 'can fetch by score' do
-      same_time = Time.now.to_f
-      add_retry('bob1', same_time)
-      add_retry('bob2', same_time)
-      r = Sidekiq::RetrySet.new
-      assert_equal 2, r.fetch(same_time).size
-    end
-
-    it 'can fetch by score and jid' do
-      same_time = Time.now.to_f
-      add_retry('bob1', same_time)
-      add_retry('bob2', same_time)
-      r = Sidekiq::RetrySet.new
-      assert_equal 1, r.fetch(same_time, 'bob1').size
-    end
-
-    it 'shows empty retries' do
-      r = Sidekiq::RetrySet.new
-      assert_equal 0, r.size
-    end
-
-    it 'can enumerate retries' do
-      add_retry
-
-      r = Sidekiq::RetrySet.new
-      assert_equal 1, r.size
-      array = r.to_a
-      assert_equal 1, array.size
-
-      retri = array.first
-      assert_equal 'ApiWorker', retri.klass
-      assert_equal 'default', retri.queue
-      assert_equal 'bob', retri.jid
-      assert_in_delta Time.now.to_f, retri.at.to_f, 0.02
-    end
-
-    it 'requires a jid to delete an entry' do
-      start_time = Time.now.to_f
-      add_retry('bob2', Time.now.to_f)
-      assert_raises(ArgumentError) do
-        Sidekiq::RetrySet.new.delete(start_time)
-      end
-    end
-
-    it 'can delete a single retry from score and jid' do
-      same_time = Time.now.to_f
-      add_retry('bob1', same_time)
-      add_retry('bob2', same_time)
-      r = Sidekiq::RetrySet.new
-      assert_equal 2, r.size
-      Sidekiq::RetrySet.new.delete(same_time, 'bob1')
-      assert_equal 1, r.size
-    end
-
-    it 'can retry a retry' do
-      add_retry
-      r = Sidekiq::RetrySet.new
-      assert_equal 1, r.size
-      r.first.retry
-      assert_equal 0, r.size
-      assert_equal 1, Sidekiq::Queue.new('default').size
-      job = Sidekiq::Queue.new('default').first
-      assert_equal 'bob', job.jid
-      assert_equal 1, job['retry_count']
-    end
-
-    it 'can clear retries' do
-      add_retry
-      add_retry('test')
-      r = Sidekiq::RetrySet.new
-      assert_equal 2, r.size
-      r.clear
-      assert_equal 0, r.size
-    end
-
-    it 'can enumerate processes' do
-      identity_string = "identity_string"
-      odata = {
-        'pid' => 123,
-        'hostname' => Socket.gethostname,
-        'key' => identity_string,
-        'identity' => identity_string,
-        'started_at' => Time.now.to_f - 15,
-      }
-
-      time = Time.now.to_f
-      Sidekiq.redis do |conn|
-        conn.multi do
-          conn.sadd('processes', odata['key'])
-          conn.hmset(odata['key'], 'info', Sidekiq.dump_json(odata), 'busy', 10, 'beat', time)
-          conn.sadd('processes', 'fake:pid')
-        end
-      end
-
-      ps = Sidekiq::ProcessSet.new.to_a
-      assert_equal 1, ps.size
-      data = ps.first
-      assert_equal 10, data['busy']
-      assert_equal time, data['beat']
-      assert_equal 123, data['pid']
-      data.quiet!
-      data.stop!
-      signals_string = "#{odata['key']}-signals"
-      assert_equal "TERM", Sidekiq.redis{|c| c.lpop(signals_string) }
-      assert_equal "USR1", Sidekiq.redis{|c| c.lpop(signals_string) }
-    end
-
-    it 'can enumerate workers' do
-      w = Sidekiq::Workers.new
-      assert_equal 0, w.size
-      w.each do
-        assert false
-      end
-
-      hn = Socket.gethostname
-      key = "#{hn}:#{$$}"
-      pdata = { 'pid' => $$, 'hostname' => hn, 'started_at' => Time.now.to_i }
-      Sidekiq.redis do |conn|
-        conn.sadd('processes', key)
-        conn.hmset(key, 'info', Sidekiq.dump_json(pdata), 'busy', 0, 'beat', Time.now.to_f)
-      end
-
-      s = "#{key}:workers"
-      data = Sidekiq.dump_json({ 'payload' => {}, 'queue' => 'default', 'run_at' => Time.now.to_i })
-      Sidekiq.redis do |c|
-        c.hmset(s, '1234', data)
-      end
-
-      w.each do |p, x, y|
-        assert_equal key, p
-        assert_equal "1234", x
-        assert_equal 'default', y['queue']
-        assert_equal Time.now.year, Time.at(y['run_at']).year
-      end
-
-      s = "#{key}:workers"
-      data = Sidekiq.dump_json({ 'payload' => {}, 'queue' => 'default', 'run_at' => (Time.now.to_i - 2*60*60) })
-      Sidekiq.redis do |c|
-        c.multi do
-          c.hmset(s, '5678', data)
-          c.hmset("b#{s}", '5678', data)
-        end
-      end
-
-      assert_equal ['1234', '5678'], w.map { |_, tid, _| tid }
-    end
-
-    it 'can reschedule jobs' do
-      add_retry('foo1')
-      add_retry('foo2')
-
-      retries = Sidekiq::RetrySet.new
-      assert_equal 2, retries.size
-      refute(retries.map { |r| r.score > (Time.now.to_f + 9) }.any?)
-
-      retries.each do |retri|
-        retri.reschedule(Time.now.to_f + 10) if retri.jid == 'foo2'
-      end
-
-      assert_equal 2, retries.size
-      assert(retries.map { |r| r.score > (Time.now.to_f + 9) }.any?)
-    end
-
-    it 'prunes processes which have died' do
-      data = { 'pid' => rand(10_000), 'hostname' => "app#{rand(1_000)}", 'started_at' => Time.now.to_f }
-      key = "#{data['hostname']}:#{data['pid']}"
-      Sidekiq.redis do |conn|
-        conn.sadd('processes', key)
-        conn.hmset(key, 'info', Sidekiq.dump_json(data), 'busy', 0, 'beat', Time.now.to_f)
-      end
-
-      ps = Sidekiq::ProcessSet.new
-      assert_equal 1, ps.size
-      assert_equal 1, ps.to_a.size
-
-      Sidekiq.redis do |conn|
-        conn.sadd('processes', "bar:987")
-        conn.sadd('processes', "bar:986")
-      end
-
-      ps = Sidekiq::ProcessSet.new
-      assert_equal 1, ps.size
-      assert_equal 1, ps.to_a.size
-    end
-
-    def add_retry(jid = 'bob', at = Time.now.to_f)
-      payload = Sidekiq.dump_json('class' => 'ApiWorker', 'args' => [1, 'mike'], 'queue' => 'default', 'jid' => jid, 'retry_count' => 2, 'failed_at' => Time.now.to_f)
-      Sidekiq.redis do |conn|
-        conn.zadd('retry', at.to_s, payload)
-      end
-    end
-  end
-end