sidekiq 4.2.4 → 5.2.0

data/test/test_retry.rb

@@ -1,326 +0,0 @@
-# frozen_string_literal: true
-# encoding: utf-8
-require_relative 'helper'
-require 'sidekiq/scheduled'
-require 'sidekiq/middleware/server/retry_jobs'
-
-class TestRetry < Sidekiq::Test
-  describe 'middleware' do
-    class SomeWorker
-      include Sidekiq::Worker
-    end
-
-    before do
-      Sidekiq.redis {|c| c.flushdb }
-    end
-
-    def worker
-      @worker ||= SomeWorker.new
-    end
-
-    def handler(options={})
-      @handler ||= Sidekiq::Middleware::Server::RetryJobs.new(options)
-    end
-
-    def job(options={})
-      @job ||= { 'class' => 'Bob', 'args' => [1,2,'foo'], 'retry' => true }.merge(options)
-    end
-
-    it 'allows disabling retry' do
-      assert_raises RuntimeError do
-        handler.call(worker, job('retry' => false), 'default') do
-          raise "kerblammo!"
-        end
-      end
-      assert_equal 0, Sidekiq::RetrySet.new.size
-    end
-
-    it 'allows a numeric retry' do
-      assert_raises RuntimeError do
-        handler.call(worker, job('retry' => 2), 'default') do
-          raise "kerblammo!"
-        end
-      end
-      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'
-
-      assert_raises RuntimeError do
-        handler.call(worker, job, 'default') do
-          raise "kerblammo! #{195.chr}"
-        end
-      end
-      assert_equal "kerblammo! �", job["error_message"]
-    end
-
-
-    it 'allows a max_retries option in initializer' do
-      max_retries = 7
-      1.upto(max_retries + 1) do
-        assert_raises RuntimeError do
-          handler(:max_retries => max_retries).call(worker, job, 'default') do
-            raise "kerblammo!"
-          end
-        end
-      end
-
-      assert_equal max_retries, Sidekiq::RetrySet.new.size
-      assert_equal 1, Sidekiq::DeadSet.new.size
-    end
-
-    it 'saves backtraces' do
-      c = nil
-      assert_raises RuntimeError do
-        handler.call(worker, job('backtrace' => true), 'default') do
-          c = caller(0); raise "kerblammo!"
-        end
-      end
-      assert job["error_backtrace"]
-      assert_equal c[0], job["error_backtrace"][0]
-    end
-
-    it 'saves partial backtraces' do
-      c = nil
-      assert_raises RuntimeError do
-        handler.call(worker, job('backtrace' => 3), 'default') do
-          c = caller(0)[0...3]; raise "kerblammo!"
-        end
-      end
-      assert job["error_backtrace"]
-      assert_equal c, job["error_backtrace"]
-      assert_equal 3, c.size
-    end
-
-    it 'handles a new failed message' do
-      assert_raises RuntimeError do
-        handler.call(worker, job, 'default') do
-          raise "kerblammo!"
-        end
-      end
-      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
-      rs = Sidekiq::RetrySet.new
-      assert_equal 0, rs.size
-      msg = { 'class' => 'Bob', 'args' => [1,2,'foo'], 'retry' => true }
-      assert_raises Sidekiq::Shutdown do
-        handler.call(worker, msg, 'default') do
-          raise Sidekiq::Shutdown
-        end
-      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'
-
-      rs = Sidekiq::RetrySet.new
-      assert_equal 0, rs.size
-      msg = { 'class' => 'Bob', 'args' => [1,2,'foo'], 'retry' => true }
-      assert_raises Sidekiq::Shutdown do
-        handler.call(worker, msg, 'default') do
-          begin
-            raise Sidekiq::Shutdown
-          rescue Interrupt
-            raise "kerblammo!"
-          end
-        end
-      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'
-
-      rs = Sidekiq::RetrySet.new
-      assert_equal 0, rs.size
-      assert_raises Sidekiq::Shutdown do
-        handler.call(worker, job, 'default') do
-          begin
-            raise Sidekiq::Shutdown
-          rescue Interrupt
-            begin
-              raise "kerblammo!"
-            rescue
-              raise "kablooie!"
-            end
-          end
-        end
-      end
-      assert_equal 0, rs.size
-    end
-
-    it 'allows a retry queue' do
-      assert_raises RuntimeError do
-        handler.call(worker, job("retry_queue" => 'retryx'), 'default') do
-          raise "kerblammo!"
-        end
-      end
-      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
-      now = Time.now.to_f
-      msg = {"queue"=>"default", "error_message"=>"kerblammo!", "error_class"=>"RuntimeError", "failed_at"=>now, "retry_count"=>10}
-      assert_raises RuntimeError do
-        handler.call(worker, job(msg), 'default') do
-          raise "kerblammo!"
-        end
-      end
-      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 = {"queue"=>"default", "error_message"=>"kerblammo!", "error_class"=>"RuntimeError", "failed_at"=>now, "retry_count"=>25}
-      assert_raises RuntimeError do
-        handler.call(worker, job(msg), 'default') do
-          raise "kerblammo!"
-        end
-      end
-      assert_equal 0, q.size
-      assert_equal 0, rs.size
-      assert_equal 1, ds.size
-    end
-
-    describe "custom retry delay" do
-      before do
-        @old_logger    = Sidekiq.logger
-        @tmp_log_path  = '/tmp/sidekiq-retries.log'
-        Sidekiq.logger = Logger.new(@tmp_log_path)
-      end
-
-      after do
-        Sidekiq.logger = @old_logger
-        Sidekiq.options.delete(:logfile)
-        File.unlink @tmp_log_path if File.exist?(@tmp_log_path)
-      end
-
-      class CustomWorkerWithoutException
-        include Sidekiq::Worker
-
-        sidekiq_retry_in do |count|
-          count * 2
-        end
-      end
-
-      class CustomWorkerWithException
-        include Sidekiq::Worker
-
-        sidekiq_retry_in do |count, exception|
-          case exception
-          when ArgumentError
-            count * 4
-          else
-            count * 2
-          end
-        end
-      end
-
-      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, 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 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, 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
-    end
-
-    describe 'handles errors withouth cause' do
-      before do
-        @error = nil
-        begin
-          raise ::StandardError, 'Error'
-        rescue ::StandardError => e
-          @error = e
-        end
-      end
-
-      it "does not recurse infinitely checking if it's a shutdown" do
-        assert(!Sidekiq::Middleware::Server::RetryJobs.new.send(
-          :exception_caused_by_shutdown?, @error))
-      end
-    end
-
-    describe 'handles errors with circular causes' do
-      before do
-        @error = nil
-        begin
-          begin
-            raise ::StandardError, 'Error 1'
-          rescue ::StandardError => e1
-            begin
-              raise ::StandardError, 'Error 2'
-            rescue ::StandardError
-              raise e1
-            end
-          end
-        rescue ::StandardError => e
-          @error = e
-        end
-      end
-
-      it "does not recurse infinitely checking if it's a shutdown" do
-        assert(!Sidekiq::Middleware::Server::RetryJobs.new.send(
-          :exception_caused_by_shutdown?, @error))
-      end
-    end
-  end
-
-end

data/test/test_retry_exhausted.rb

@@ -1,149 +0,0 @@
-# encoding: utf-8
-require_relative 'helper'
-require 'sidekiq/middleware/server/retry_jobs'
-
-class TestRetryExhausted < Sidekiq::Test
-  describe 'sidekiq_retries_exhausted' do
-    class NewWorker
-      include Sidekiq::Worker
-
-      class_attribute :exhausted_called, :exhausted_job, :exhausted_exception
-
-      sidekiq_retries_exhausted do |job, e|
-        self.exhausted_called = true
-        self.exhausted_job = job
-        self.exhausted_exception = e
-      end
-    end
-
-    class OldWorker
-      include Sidekiq::Worker
-
-      class_attribute :exhausted_called, :exhausted_job, :exhausted_exception
-
-      sidekiq_retries_exhausted do |job|
-        self.exhausted_called = true
-        self.exhausted_job = job
-      end
-    end
-
-    def cleanup
-      [NewWorker, OldWorker].each do |worker_class|
-        worker_class.exhausted_called = nil
-        worker_class.exhausted_job = nil
-        worker_class.exhausted_exception = nil
-      end
-    end
-
-    before do
-      cleanup
-    end
-
-    after do
-      cleanup
-    end
-
-    def new_worker
-      @new_worker ||= NewWorker.new
-    end
-
-    def old_worker
-      @old_worker ||= OldWorker.new
-    end
-
-    def handler(options={})
-      @handler ||= Sidekiq::Middleware::Server::RetryJobs.new(options)
-    end
-
-    def job(options={})
-      @job ||= {'class' => 'Bob', 'args' => [1, 2, 'foo']}.merge(options)
-    end
-
-    it 'does not run exhausted block when job successful on first run' do
-      handler.call(new_worker, job('retry' => 2), 'default') do
-        # successful
-      end
-
-      refute NewWorker.exhausted_called?
-    end
-
-    it 'does not run exhausted block when job successful on last retry' do
-      handler.call(new_worker, job('retry_count' => 0, 'retry' => 1), 'default') do
-        # successful
-      end
-
-      refute NewWorker.exhausted_called?
-    end
-
-    it 'does not run exhausted block when retries not exhausted yet' do
-      assert_raises RuntimeError do
-        handler.call(new_worker, job('retry' => 1), 'default') do
-          raise 'kerblammo!'
-        end
-      end
-
-      refute NewWorker.exhausted_called?
-    end
-
-    it 'runs exhausted block when retries exhausted' do
-      assert_raises RuntimeError do
-        handler.call(new_worker, job('retry_count' => 0, 'retry' => 1), 'default') do
-          raise 'kerblammo!'
-        end
-      end
-
-      assert NewWorker.exhausted_called?
-    end
-
-
-    it 'passes job and exception to retries exhausted block' do
-      raised_error = assert_raises RuntimeError do
-        handler.call(new_worker, job('retry_count' => 0, 'retry' => 1), 'default') do
-          raise 'kerblammo!'
-        end
-      end
-
-      assert new_worker.exhausted_called?
-      assert_equal raised_error.message, new_worker.exhausted_job['error_message']
-      assert_equal raised_error, new_worker.exhausted_exception
-    end
-
-    it 'passes job to retries exhausted block' do
-      raised_error = assert_raises RuntimeError do
-        handler.call(old_worker, job('retry_count' => 0, 'retry' => 1), 'default') do
-          raise 'kerblammo!'
-        end
-      end
-
-      assert old_worker.exhausted_called?
-      assert_equal raised_error.message, old_worker.exhausted_job['error_message']
-      assert_equal nil, new_worker.exhausted_exception
-    end
-
-    it 'allows a global default handler' do
-      begin
-        class Foobar
-          include Sidekiq::Worker
-        end
-
-        exhausted_job = nil
-        exhausted_exception = nil
-        Sidekiq.default_retries_exhausted = lambda do |job, ex|
-          exhausted_job = job
-          exhausted_exception = ex
-        end
-        f = Foobar.new
-        raised_error = assert_raises RuntimeError do
-          handler.call(f, job('retry_count' => 0, 'retry' => 1), 'default') do
-            raise 'kerblammo!'
-          end
-        end
-
-        assert exhausted_job
-        assert_equal raised_error, exhausted_exception
-      ensure
-        Sidekiq.default_retries_exhausted = nil
-      end
-    end
-  end
-end

data/test/test_scheduled.rb

@@ -1,115 +0,0 @@
-# frozen_string_literal: true
-require_relative 'helper'
-require 'sidekiq/scheduled'
-
-class TestScheduled < Sidekiq::Test
-  class ScheduledWorker
-    include Sidekiq::Worker
-    def perform(x)
-    end
-  end
-
-  describe 'poller' do
-    before do
-      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' }
-      @future_1 = { 'class' => ScheduledWorker.name, 'args' => [3], 'queue' => 'queue_4' }
-      @future_2 = { 'class' => ScheduledWorker.name, 'args' => [4], 'queue' => 'queue_5' }
-      @future_3 = { 'class' => ScheduledWorker.name, 'args' => [5], 'queue' => 'queue_6' }
-
-      @retry = Sidekiq::RetrySet.new
-      @scheduled = Sidekiq::ScheduledSet.new
-      @poller = Sidekiq::Scheduled::Poller.new
-    end
-
-    class Stopper
-      def call(worker_class, job, queue, r)
-        yield if job['args'].first.odd?
-      end
-    end
-
-    it 'executes client middleware' do
-      Sidekiq.client_middleware.add Stopper
-      begin
-        @retry.schedule (Time.now - 60).to_f, @error_1
-        @retry.schedule (Time.now - 60).to_f, @error_2
-        @scheduled.schedule (Time.now - 60).to_f, @future_2
-        @scheduled.schedule (Time.now - 60).to_f, @future_3
-
-        @poller.enqueue
-
-        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
-    end
-
-    it 'should empty the retry and scheduled queues up to the current time' do
-      created_time  = Time.new(2013, 2, 3)
-      enqueued_time = Time.new(2013, 2, 4)
-
-      Time.stub(:now, created_time) do
-        @retry.schedule (enqueued_time - 60).to_f, @error_1.merge!('created_at' => created_time.to_f)
-        @retry.schedule (enqueued_time - 50).to_f, @error_2.merge!('created_at' => created_time.to_f)
-        @retry.schedule (enqueued_time + 60).to_f, @error_3.merge!('created_at' => created_time.to_f)
-        @scheduled.schedule (enqueued_time - 60).to_f, @future_1.merge!('created_at' => created_time.to_f)
-        @scheduled.schedule (enqueued_time - 50).to_f, @future_2.merge!('created_at' => created_time.to_f)
-        @scheduled.schedule (enqueued_time + 60).to_f, @future_3.merge!('created_at' => created_time.to_f)
-      end
-
-      Time.stub(:now, enqueued_time) do
-        @poller.enqueue
-
-        Sidekiq.redis do |conn|
-          %w(queue:queue_1 queue:queue_2 queue:queue_4 queue:queue_5).each do |queue_name|
-            assert_equal 1, conn.llen(queue_name)
-            job = Sidekiq.load_json(conn.lrange(queue_name, 0, -1)[0])
-            assert_equal enqueued_time.to_f, job['enqueued_at']
-            assert_equal created_time.to_f,  job['created_at']
-          end
-        end
-
-        assert_equal 1, @retry.size
-        assert_equal 1, @scheduled.size
-      end
-    end
-
-    def with_sidekiq_option(name, value)
-      _original, Sidekiq.options[name] = Sidekiq.options[name], value
-      begin
-        yield
-      ensure
-        Sidekiq.options[name] = _original
-      end
-    end
-
-    it 'generates random intervals that target a configured average' do
-      with_sidekiq_option(:poll_interval_average, 10) do
-        i = 500
-        intervals = Array.new(i){ @poller.send(:random_poll_interval) }
-
-        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
-
-    it 'calculates an average poll interval based on the number of known Sidekiq processes' do
-      with_sidekiq_option(:average_scheduled_poll_interval, 10) do
-        3.times do |i|
-          Sidekiq.redis do |conn|
-            conn.sadd("processes", "process-#{i}")
-            conn.hset("process-#{i}", "info", nil)
-          end
-        end
-
-        assert_equal 30, @poller.send(:scaled_poll_interval)
-      end
-    end
-  end
-end

data/test/test_scheduling.rb

@@ -1,58 +0,0 @@
-# frozen_string_literal: true
-require_relative 'helper'
-require 'sidekiq/scheduled'
-
-class TestScheduling < Sidekiq::Test
-  describe 'middleware' do
-    class ScheduledWorker
-      include Sidekiq::Worker
-      sidekiq_options :queue => :custom_queue
-      def perform(x)
-      end
-    end
-
-    # Assume we can pass any class as time to perform_in
-    class TimeDuck
-      def to_f; 42.0 end
-    end
-
-    it 'schedules jobs' do
-      ss = Sidekiq::ScheduledSet.new
-      ss.clear
-
-      assert_equal 0, ss.size
-
-      assert ScheduledWorker.perform_in(600, 'mike')
-      assert_equal 1, ss.size
-
-      assert ScheduledWorker.perform_in(1.month, 'mike')
-      assert_equal 2, ss.size
-
-      assert ScheduledWorker.perform_in(5.days.from_now, 'mike')
-      assert_equal 3, ss.size
-
-      q = Sidekiq::Queue.new("custom_queue")
-      qs = q.size
-      assert ScheduledWorker.perform_in(-300, 'mike')
-      assert_equal 3, ss.size
-      assert_equal qs+1, q.size
-
-      assert Sidekiq::Client.push_bulk('class' => ScheduledWorker, 'args' => [['mike'], ['mike']], 'at' => 600)
-      assert_equal 5, ss.size
-
-      assert ScheduledWorker.perform_in(TimeDuck.new, 'samwise')
-      assert_equal 6, ss.size
-    end
-
-    it 'removes the enqueued_at field when scheduling' do
-      ss = Sidekiq::ScheduledSet.new
-      ss.clear
-
-      assert ScheduledWorker.perform_in(1.month, 'mike')
-      job = ss.first
-      assert job['created_at']
-      refute job['enqueued_at']
-    end
-  end
-
-end