sidekiq 3.4.1 → 7.3.0

data/test/test_processor.rb

@@ -1,166 +0,0 @@
-require_relative 'helper'
-require 'sidekiq/processor'
-
-class TestProcessor < Sidekiq::Test
-  TestException = Class.new(StandardError)
-  TEST_EXCEPTION = TestException.new("kerboom!")
-
-  describe 'with mock setup' do
-    before do
-      $invokes = 0
-      @boss = Minitest::Mock.new
-      @processor = ::Sidekiq::Processor.new(@boss)
-      Celluloid.logger = nil
-      Sidekiq.redis = REDIS
-    end
-
-    class MockWorker
-      include Sidekiq::Worker
-      def perform(args)
-        raise TEST_EXCEPTION if args == 'boom'
-        args.pop if args.is_a? Array
-        $invokes += 1
-      end
-    end
-
-    def work(msg, queue='queue:default')
-      Sidekiq::BasicFetch::UnitOfWork.new(queue, msg)
-    end
-
-    it 'processes as expected' do
-      msg = Sidekiq.dump_json({ 'class' => MockWorker.to_s, 'args' => ['myarg'] })
-      actor = Minitest::Mock.new
-      actor.expect(:processor_done, nil, [@processor])
-      actor.expect(:real_thread, nil, [nil, Thread])
-      @boss.expect(:async, actor, [])
-      @boss.expect(:async, actor, [])
-      @processor.process(work(msg))
-      @boss.verify
-      assert_equal 1, $invokes
-    end
-
-    it 'executes a worker as expected' do
-      worker = Minitest::Mock.new
-      worker.expect(:perform, nil, [1, 2, 3])
-      @processor.execute_job(worker, [1, 2, 3])
-    end
-
-    it 'passes exceptions to ExceptionHandler' do
-      actor = Minitest::Mock.new
-      actor.expect(:real_thread, nil, [nil, Thread])
-      @boss.expect(:async, actor, [])
-      msg = Sidekiq.dump_json({ 'class' => MockWorker.to_s, 'args' => ['boom'] })
-      begin
-        @processor.process(work(msg))
-        flunk "Expected #process to raise exception"
-      rescue TestException
-      end
-
-      assert_equal 0, $invokes
-    end
-
-    it 're-raises exceptions after handling' do
-      msg = Sidekiq.dump_json({ 'class' => MockWorker.to_s, 'args' => ['boom'] })
-      re_raise = false
-      actor = Minitest::Mock.new
-      actor.expect(:real_thread, nil, [nil, Thread])
-      @boss.expect(:async, actor, [])
-
-      begin
-        @processor.process(work(msg))
-      rescue TestException
-        re_raise = true
-      end
-
-      assert re_raise, "does not re-raise exceptions after handling"
-    end
-
-    it 'does not modify original arguments' do
-      msg = { 'class' => MockWorker.to_s, 'args' => [['myarg']] }
-      msgstr = Sidekiq.dump_json(msg)
-      processor = ::Sidekiq::Processor.new(@boss)
-      actor = Minitest::Mock.new
-      actor.expect(:processor_done, nil, [processor])
-      actor.expect(:real_thread, nil, [nil, Thread])
-      @boss.expect(:async, actor, [])
-      @boss.expect(:async, actor, [])
-      processor.process(work(msgstr))
-      assert_equal [['myarg']], msg['args']
-    end
-
-    describe 'stats' do
-      before do
-        Sidekiq.redis {|c| c.flushdb }
-      end
-
-      def with_expire(time)
-        begin
-          old = Sidekiq::Processor::STATS_TIMEOUT
-          silence_warnings { Sidekiq::Processor.const_set(:STATS_TIMEOUT, time) }
-          yield
-        ensure
-          silence_warnings { Sidekiq::Processor.const_set(:STATS_TIMEOUT, old) }
-        end
-      end
-
-      describe 'when successful' do
-        let(:processed_today_key) { "stat:processed:#{Time.now.utc.to_date}" }
-
-        def successful_job
-          msg = Sidekiq.dump_json({ 'class' => MockWorker.to_s, 'args' => ['myarg'] })
-          actor = Minitest::Mock.new
-          actor.expect(:real_thread, nil, [nil, Thread])
-          actor.expect(:processor_done, nil, [@processor])
-          @boss.expect(:async, actor, [])
-          @boss.expect(:async, actor, [])
-          @processor.process(work(msg))
-        end
-
-        it 'increments processed stat' do
-          successful_job
-          assert_equal 1, Sidekiq::Stats.new.processed
-        end
-
-        it 'expires processed stat' do
-          successful_job
-          assert_equal Sidekiq::Processor::STATS_TIMEOUT, Sidekiq.redis { |conn| conn.ttl(processed_today_key) }
-        end
-
-        it 'increments date processed stat' do
-          successful_job
-          assert_equal 1, Sidekiq.redis { |conn| conn.get(processed_today_key) }.to_i
-        end
-      end
-
-      describe 'when failed' do
-        let(:failed_today_key) { "stat:failed:#{Time.now.utc.to_date}" }
-
-        def failed_job
-          actor = Minitest::Mock.new
-          actor.expect(:real_thread, nil, [nil, Thread])
-          @boss.expect(:async, actor, [])
-          msg = Sidekiq.dump_json({ 'class' => MockWorker.to_s, 'args' => ['boom'] })
-          begin
-            @processor.process(work(msg))
-          rescue TestException
-          end
-        end
-
-        it 'increments failed stat' do
-          failed_job
-          assert_equal 1, Sidekiq::Stats.new.failed
-        end
-
-        it 'increments date failed stat' do
-          failed_job
-          assert_equal 1, Sidekiq.redis { |conn| conn.get(failed_today_key) }.to_i
-        end
-
-        it 'expires failed stat' do
-          failed_job
-          assert_equal Sidekiq::Processor::STATS_TIMEOUT, Sidekiq.redis { |conn| conn.ttl(failed_today_key) }
-        end
-      end
-    end
-  end
-end

data/test/test_redis_connection.rb

@@ -1,127 +0,0 @@
-require_relative 'helper'
-require 'sidekiq/redis_connection'
-
-class TestRedisConnection < Sidekiq::Test
-
-  describe ".create" do
-
-    it "creates a pooled redis connection" do
-      pool = Sidekiq::RedisConnection.create
-      assert_equal Redis, pool.checkout.class
-    end
-
-    describe "network_timeout" do
-      it "sets a custom network_timeout if specified" do
-        pool = Sidekiq::RedisConnection.create(:network_timeout => 8)
-        redis = pool.checkout
-
-        assert_equal 8, redis.client.timeout
-      end
-
-      it "uses the default network_timeout if none specified" do
-        pool = Sidekiq::RedisConnection.create
-        redis = pool.checkout
-
-        assert_equal 5, redis.client.timeout
-      end
-    end
-
-    describe "namespace" do
-      it "uses a given :namespace" do
-        pool = Sidekiq::RedisConnection.create(:namespace => "xxx")
-        assert_equal "xxx", pool.checkout.namespace
-      end
-
-      it "uses given :namespace over :namespace from Sidekiq.options" do
-        Sidekiq.options[:namespace] = "xxx"
-        pool = Sidekiq::RedisConnection.create(:namespace => "yyy")
-        assert_equal "yyy", pool.checkout.namespace
-      end
-    end
-
-    describe "socket path" do
-      it "uses a given :path" do
-        pool = Sidekiq::RedisConnection.create(:path => "/var/run/redis.sock")
-        assert_equal "unix", pool.checkout.client.scheme
-        assert_equal "redis:///var/run/redis.sock/0", pool.checkout.client.id
-      end
-
-      it "uses a given :path and :db" do
-        pool = Sidekiq::RedisConnection.create(:path => "/var/run/redis.sock", :db => 8)
-        assert_equal "unix", pool.checkout.client.scheme
-        assert_equal "redis:///var/run/redis.sock/8", pool.checkout.client.id
-      end
-    end
-
-    describe "pool_timeout" do
-      it "uses a given :timeout over the default of 1" do
-        pool = Sidekiq::RedisConnection.create(:pool_timeout => 5)
-
-        assert_equal 5, pool.instance_eval{ @timeout }
-      end
-
-      it "uses the default timeout of 1 if no override" do
-        pool = Sidekiq::RedisConnection.create
-
-        assert_equal 1, pool.instance_eval{ @timeout }
-      end
-    end
-  end
-
-  describe ".determine_redis_provider" do
-
-    before do
-      @old_env = ENV.to_hash
-    end
-
-    after do
-      ENV.update(@old_env)
-    end
-
-    def with_env_var(var, uri, skip_provider=false)
-      vars = ['REDISTOGO_URL', 'REDIS_PROVIDER', 'REDIS_URL'] - [var]
-      vars.each do |v|
-        next if skip_provider
-        ENV[v] = nil
-      end
-      ENV[var] = uri
-      assert_equal uri, Sidekiq::RedisConnection.__send__(:determine_redis_provider)
-      ENV[var] = nil
-    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'
-        provider = 'SIDEKIQ_REDIS_PROVIDER'
-
-        ENV['REDIS_PROVIDER'] = provider
-        ENV[provider] = uri
-        ENV['REDISTOGO_URL'] = 'redis://redis-to-go:6379/0'
-        with_env_var provider, uri, true
-
-        ENV[provider] = nil
-      end
-    end
-
-    describe "with REDIS_PROVIDER set" do
-      it "sets connection URI to the provider" do
-        uri = 'redis://sidekiq-redis-provider:6379/0'
-        provider = 'SIDEKIQ_REDIS_PROVIDER'
-
-        ENV['REDIS_PROVIDER'] = provider
-        ENV[provider] = uri
-
-        with_env_var provider, uri, true
-
-        ENV[provider] = nil
-      end
-    end
-
-    describe "with REDIS_URL set" do
-      it "sets connection URI to custom uri" do
-        with_env_var 'REDIS_URL', 'redis://redis-uri:6379/0'
-      end
-    end
-
-  end
-end

data/test/test_retry.rb

@@ -1,373 +0,0 @@
-# encoding: utf-8
-require_relative 'helper'
-require 'sidekiq/scheduled'
-require 'sidekiq/middleware/server/retry_jobs'
-
-class TestRetry < Sidekiq::Test
-  describe 'middleware' do
-    before do
-      @redis = Minitest::Mock.new
-      # Ugh, this is terrible.
-      Sidekiq.instance_variable_set(:@redis, @redis)
-
-      def @redis.with; yield self; end
-      def @redis.multi; yield self; end
-    end
-
-    after do
-      Sidekiq.redis = REDIS
-    end
-
-    let(:worker) do
-      Class.new do
-        include ::Sidekiq::Worker
-      end
-    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
-          raise "kerblammo!"
-        end
-      end
-      assert_equal msg, msg2
-    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
-          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
-    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
-          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
-    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
-            raise "kerblammo!"
-          end
-        end
-      end
-      @redis.verify
-    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
-          c = caller(0); raise "kerblammo!"
-        end
-      end
-      assert msg["error_backtrace"]
-      assert_equal c[0], msg["error_backtrace"][0]
-      @redis.verify
-    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
-          c = caller(0)[0...3]; raise "kerblammo!"
-        end
-      end
-      assert msg["error_backtrace"]
-      assert_equal c, msg["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
-          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
-    end
-
-    it 'shuts down without retrying work-in-progress, which will resume' 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 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
-    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]
-      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
-            raise Sidekiq::Shutdown
-          rescue Interrupt
-            raise "kerblammo!"
-          end
-        end
-      end
-      assert_raises(MockExpectationError, "zadd should not be called") do
-        @redis.verify
-      end
-    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
-      assert_raises Sidekiq::Shutdown do
-        handler.call(worker, msg, 'default') do
-          begin
-            raise Sidekiq::Shutdown
-          rescue Interrupt
-            begin
-              raise "kerblammo!"
-            rescue
-              raise "kablooie!"
-            end
-          end
-        end
-      end
-      assert_raises(MockExpectationError, "zadd should not be called") do
-        @redis.verify
-      end
-    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
-          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
-    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
-      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 9, msg["retry_count"]
-      assert msg["failed_at"]
-      @redis.verify
-    end
-
-    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, ['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
-      assert_raises RuntimeError do
-        handler.call(worker, msg, 'default') do
-          raise "kerblammo!"
-        end
-      end
-      @redis.verify
-    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
-
-      let(:custom_worker) do
-        Class.new do
-          include ::Sidekiq::Worker
-
-          sidekiq_retry_in do |count|
-            count * 2
-          end
-        end
-      end
-
-      let(:error_worker) do
-        Class.new do
-          include ::Sidekiq::Worker
-
-          sidekiq_retry_in do |count|
-            count / 0
-          end
-        end
-      end
-
-      let(:handler) { Sidekiq::Middleware::Server::RetryJobs.new }
-
-      it "retries with a default delay" do
-        refute_equal 4, handler.__send__(:delay_for, worker, 2)
-      end
-
-      it "retries with a custom delay" do
-        assert_equal 4, handler.__send__(:delay_for, custom_worker, 2)
-      end
-
-      it "falls back to the default retry on exception" do
-        refute_equal 4, handler.__send__(:delay_for, error_worker, 2)
-        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 => e2
-              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