sr-sidekiq 4.1.6

data/test/test_retry_exhausted.rb

@@ -0,0 +1,149 @@
+# 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

@@ -0,0 +1,115 @@
+# 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

@@ -0,0 +1,50 @@
+# 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
+
+    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
+    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

data/test/test_sidekiq.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+# encoding: utf-8
+require_relative 'helper'
+
+class TestSidekiq < Sidekiq::Test
+  describe 'json processing' 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
+  		assert_raises(ArgumentError) do
+  			Sidekiq.redis
+      end
+  	end
+  end
+
+  describe "❨╯°□°❩╯︵┻━┻" do
+    before { $stdout = StringIO.new }
+    after  { $stdout = STDOUT }
+
+    it "allows angry developers to express their emotional constitution and remedies it" do
+      Sidekiq.❨╯°□°❩╯︵┻━┻
+      assert_equal "Calm down, yo.\n", $stdout.string
+    end
+  end
+
+  describe 'lifecycle events' do
+    it 'handles invalid input' do
+      Sidekiq.options[:lifecycle_events][:startup].clear
+
+      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
+
+  describe 'default_worker_options' 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
+
+    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
+
+  describe 'redis info' do
+    it 'calls the INFO command which returns at least redis_version' do
+      output = Sidekiq.redis_info
+      assert_includes output.keys, "redis_version"
+    end
+  end
+end

data/test/test_testing.rb

@@ -0,0 +1,143 @@
+# frozen_string_literal: true
+require_relative 'helper'
+
+require 'active_record'
+require 'action_mailer'
+require 'sidekiq/rails'
+require 'sidekiq/extensions/action_mailer'
+require 'sidekiq/extensions/active_record'
+
+Sidekiq.hook_rails!
+
+class TestTesting < Sidekiq::Test
+  describe 'sidekiq testing' do
+    describe 'require/load sidekiq/testing.rb' do
+      before do
+        require 'sidekiq/testing'
+      end
+
+      after do
+        Sidekiq::Testing.disable!
+      end
+
+      it 'enables fake testing' do
+        Sidekiq::Testing.fake!
+        assert Sidekiq::Testing.enabled?
+        assert Sidekiq::Testing.fake?
+        refute Sidekiq::Testing.inline?
+      end
+
+      it 'enables fake testing in a block' do
+        Sidekiq::Testing.disable!
+        assert Sidekiq::Testing.disabled?
+        refute Sidekiq::Testing.fake?
+
+        Sidekiq::Testing.fake! do
+          assert Sidekiq::Testing.enabled?
+          assert Sidekiq::Testing.fake?
+          refute Sidekiq::Testing.inline?
+        end
+
+        refute Sidekiq::Testing.enabled?
+        refute Sidekiq::Testing.fake?
+      end
+
+      it 'disables testing in a block' do
+        Sidekiq::Testing.fake!
+        assert Sidekiq::Testing.fake?
+
+        Sidekiq::Testing.disable! do
+          refute Sidekiq::Testing.fake?
+          assert Sidekiq::Testing.disabled?
+        end
+
+        assert Sidekiq::Testing.fake?
+        assert Sidekiq::Testing.enabled?
+      end
+    end
+
+    describe 'require/load sidekiq/testing/inline.rb' do
+      before do
+        require 'sidekiq/testing/inline'
+      end
+
+      after do
+        Sidekiq::Testing.disable!
+      end
+
+      it 'enables inline testing' do
+        Sidekiq::Testing.inline!
+        assert Sidekiq::Testing.enabled?
+        assert Sidekiq::Testing.inline?
+        refute Sidekiq::Testing.fake?
+      end
+
+      it 'enables inline testing in a block' do
+        Sidekiq::Testing.disable!
+        assert Sidekiq::Testing.disabled?
+        refute Sidekiq::Testing.fake?
+
+        Sidekiq::Testing.inline! do
+          assert Sidekiq::Testing.enabled?
+          assert Sidekiq::Testing.inline?
+        end
+
+        refute Sidekiq::Testing.enabled?
+        refute Sidekiq::Testing.inline?
+        refute Sidekiq::Testing.fake?
+      end
+    end
+  end
+
+  describe 'with middleware' do
+    before do
+      require 'sidekiq/testing'
+    end
+
+    after do
+      Sidekiq::Testing.disable!
+    end
+
+    class AttributeWorker
+      include Sidekiq::Worker
+      class_attribute :count
+      self.count = 0
+      attr_accessor :foo
+
+      def perform
+        self.class.count += 1 if foo == :bar
+      end
+    end
+
+    class AttributeMiddleware
+      def call(worker, msg, queue)
+        worker.foo = :bar if worker.respond_to?(:foo=)
+        yield
+      end
+    end
+
+    it 'wraps the inlined worker with middleware' do
+      Sidekiq::Testing.server_middleware do |chain|
+        chain.add AttributeMiddleware
+      end
+
+      begin
+        Sidekiq::Testing.fake! do
+          AttributeWorker.perform_async
+          assert_equal 0, AttributeWorker.count
+        end
+
+        AttributeWorker.perform_one
+        assert_equal 1, AttributeWorker.count
+
+        Sidekiq::Testing.inline! do
+          AttributeWorker.perform_async
+          assert_equal 2, AttributeWorker.count
+        end
+      ensure
+        Sidekiq::Testing.server_middleware.clear
+      end
+    end
+  end
+
+end