sidekiq 4.2.7 → 5.2.8

data/test/test_processor.rb

@@ -1,249 +0,0 @@
-# frozen_string_literal: true
-require_relative 'helper'
-require 'sidekiq/fetch'
-require 'sidekiq/cli'
-require 'sidekiq/processor'
-
-class TestProcessor < Sidekiq::Test
-  TestException = Class.new(StandardError)
-  TEST_EXCEPTION = TestException.new("kerboom!")
-
-  describe 'processor' do
-    before do
-      $invokes = 0
-      @mgr = Minitest::Mock.new
-      @mgr.expect(:options, {:queues => ['default']})
-      @mgr.expect(:options, {:queues => ['default']})
-      @processor = ::Sidekiq::Processor.new(@mgr)
-    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'] })
-      @processor.process(work(msg))
-      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 're-raises exceptions after handling' do
-      msg = Sidekiq.dump_json({ 'class' => MockWorker.to_s, 'args' => ['boom'] })
-      re_raise = false
-
-      begin
-        @processor.process(work(msg))
-        flunk "Expected exception"
-      rescue TestException
-        re_raise = true
-      end
-
-      assert_equal 0, $invokes
-      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)
-      @mgr.expect(:processor_done, nil, [@processor])
-      @processor.process(work(msgstr))
-      assert_equal [['myarg']], msg['args']
-    end
-
-    describe 'exception handling' do
-      let(:errors) { [] }
-      let(:error_handler) do
-        proc do |exception, context|
-          errors << { exception: exception, context: context }
-        end
-      end
-
-      before do
-        Sidekiq.error_handlers << error_handler
-      end
-
-      after do
-        Sidekiq.error_handlers.pop
-      end
-
-      it 'handles exceptions raised by the job' do
-        job_hash = { 'class' => MockWorker.to_s, 'args' => ['boom'] }
-        msg = Sidekiq.dump_json(job_hash)
-        job = work(msg)
-        begin
-          @processor.instance_variable_set(:'@job', job)
-          @processor.process(job)
-        rescue TestException
-        end
-        assert_equal 1, errors.count
-        assert_instance_of TestException, errors.first[:exception]
-        assert_equal msg, errors.first[:context][:jobstr]
-        assert_equal job_hash, errors.first[:context][:job]
-      end
-
-      it 'handles exceptions raised by the reloader' do
-        job_hash = { 'class' => MockWorker.to_s, 'args' => ['boom'] }
-        msg = Sidekiq.dump_json(job_hash)
-        @processor.instance_variable_set(:'@reloader', proc { raise TEST_EXCEPTION })
-        job = work(msg)
-        begin
-          @processor.instance_variable_set(:'@job', job)
-          @processor.process(job)
-        rescue TestException
-        end
-        assert_equal 1, errors.count
-        assert_instance_of TestException, errors.first[:exception]
-        assert_equal msg, errors.first[:context][:jobstr]
-        assert_equal job_hash, errors.first[:context][:job]
-      end
-    end
-
-    describe 'acknowledgement' do
-      class ExceptionRaisingMiddleware
-        def initialize(raise_before_yield, raise_after_yield, skip)
-          @raise_before_yield = raise_before_yield
-          @raise_after_yield = raise_after_yield
-          @skip = skip
-        end
-
-        def call(worker, item, queue)
-          raise TEST_EXCEPTION if @raise_before_yield
-          yield unless @skip
-          raise TEST_EXCEPTION if @raise_after_yield
-        end
-      end
-
-      let(:raise_before_yield) { false }
-      let(:raise_after_yield) { false }
-      let(:skip_job) { false }
-      let(:worker_args) { ['myarg'] }
-      let(:work) { MiniTest::Mock.new }
-
-      before do
-        work.expect(:queue_name, 'queue:default')
-        work.expect(:job, Sidekiq.dump_json({ 'class' => MockWorker.to_s, 'args' => worker_args }))
-        Sidekiq.server_middleware do |chain|
-          chain.prepend ExceptionRaisingMiddleware, raise_before_yield, raise_after_yield, skip_job
-        end
-      end
-
-      after do
-        Sidekiq.server_middleware do |chain|
-          chain.remove ExceptionRaisingMiddleware
-        end
-        work.verify
-      end
-
-      describe 'middleware throws an exception before processing the work' do
-        let(:raise_before_yield) { true }
-
-        it 'does not ack' do
-          begin
-            @processor.process(work)
-            flunk "Expected #process to raise exception"
-          rescue TestException
-          end
-        end
-      end
-
-      describe 'middleware throws an exception after processing the work' do
-        let(:raise_after_yield) { true }
-
-        it 'acks the job' do
-          work.expect(:acknowledge, nil)
-          begin
-            @processor.process(work)
-            flunk "Expected #process to raise exception"
-          rescue TestException
-          end
-        end
-      end
-
-      describe 'middleware decides to skip work' do
-        let(:skip_job) { true }
-
-        it 'acks the job' do
-          work.expect(:acknowledge, nil)
-          @mgr.expect(:processor_done, nil, [@processor])
-          @processor.process(work)
-        end
-      end
-
-      describe 'worker raises an exception' do
-        let(:worker_args) { ['boom'] }
-
-        it 'acks the job' do
-          work.expect(:acknowledge, nil)
-          begin
-            @processor.process(work)
-            flunk "Expected #process to raise exception"
-          rescue TestException
-          end
-        end
-      end
-
-      describe 'everything goes well' do
-        it 'acks the job' do
-          work.expect(:acknowledge, nil)
-          @mgr.expect(:processor_done, nil, [@processor])
-          @processor.process(work)
-        end
-      end
-    end
-
-    describe 'stats' do
-      before do
-        Sidekiq.redis {|c| c.flushdb }
-      end
-
-      describe 'when successful' do
-        let(:processed_today_key) { "stat:processed:#{Time.now.utc.strftime("%Y-%m-%d")}" }
-
-        def successful_job
-          msg = Sidekiq.dump_json({ 'class' => MockWorker.to_s, 'args' => ['myarg'] })
-          @mgr.expect(:processor_done, nil, [@processor])
-          @processor.process(work(msg))
-        end
-
-        it 'increments processed stat' do
-          Sidekiq::Processor::PROCESSED.value = 0
-          successful_job
-          assert_equal 1, Sidekiq::Processor::PROCESSED.value
-        end
-      end
-
-      describe 'when failed' do
-        let(:failed_today_key) { "stat:failed:#{Time.now.utc.strftime("%Y-%m-%d")}" }
-
-        def failed_job
-          msg = Sidekiq.dump_json({ 'class' => MockWorker.to_s, 'args' => ['boom'] })
-          begin
-            @processor.process(work(msg))
-          rescue TestException
-          end
-        end
-
-        it 'increments failed stat' do
-          Sidekiq::Processor::FAILURE.value = 0
-          failed_job
-          assert_equal 1, Sidekiq::Processor::FAILURE.value
-        end
-      end
-    end
-  end
-end

data/test/test_rails.rb

@@ -1,22 +0,0 @@
-# frozen_string_literal: true
-require_relative 'helper'
-
-$HAS_AJ = true
-begin
-  require 'active_job'
-rescue LoadError
-  $HAS_AJ = false
-end
-
-class TestRails < Sidekiq::Test
-
-  describe 'ActiveJob' do
-    it 'does not allow Sidekiq::Worker in AJ::Base classes' do
-      ex = assert_raises ArgumentError do
-        c = Class.new(ActiveJob::Base)
-        c.send(:include, Sidekiq::Worker)
-      end
-      assert_includes ex.message, "cannot include"
-    end if $HAS_AJ
-  end
-end

data/test/test_redis_connection.rb

@@ -1,132 +0,0 @@
-# frozen_string_literal: true
-require_relative 'helper'
-
-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 set by a symbol key" do
-        pool = Sidekiq::RedisConnection.create(:namespace => "xxx")
-        assert_equal "xxx", pool.checkout.namespace
-      end
-
-      it "uses a given :namespace set by a string key" 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