sidekiq 3.4.1 → 7.3.0

data/test/test_cli.rb

@@ -1,365 +0,0 @@
-require_relative 'helper'
-require 'sidekiq/cli'
-require 'tempfile'
-
-class Sidekiq::CLI
-  def die(code)
-    @code = code
-  end
-
-  def valid?
-    !@code
-  end
-end
-
-class TestCli < Sidekiq::Test
-  describe 'CLI#parse' do
-
-    before do
-      @cli = Sidekiq::CLI.new
-      @opts = Sidekiq.options.dup
-    end
-
-    after do
-      Sidekiq.options = @opts
-    end
-
-    it 'does not require the specified Ruby code' do
-      @cli.parse(['sidekiq', '-r', './test/fake_env.rb'])
-      refute($LOADED_FEATURES.any? { |x| x =~ /fake_env/ })
-      assert @cli.valid?
-    end
-
-    it 'does not boot rails' do
-      refute defined?(::Rails::Application)
-      @cli.parse(['sidekiq', '-r', './myapp'])
-      refute defined?(::Rails::Application)
-    end
-
-    it 'changes concurrency' do
-      @cli.parse(['sidekiq', '-c', '60', '-r', './test/fake_env.rb'])
-      assert_equal 60, Sidekiq.options[:concurrency]
-    end
-
-    it 'changes queues' do
-      @cli.parse(['sidekiq', '-q', 'foo', '-r', './test/fake_env.rb'])
-      assert_equal ['foo'], Sidekiq.options[:queues]
-    end
-
-    it 'accepts a process index' do
-      @cli.parse(['sidekiq', '-i', '7', '-r', './test/fake_env.rb'])
-      assert_equal 7, Sidekiq.options[:index]
-    end
-
-    it 'accepts a stringy process index' do
-      @cli.parse(['sidekiq', '-i', 'worker.7', '-r', './test/fake_env.rb'])
-      assert_equal 7, Sidekiq.options[:index]
-    end
-
-    it 'sets strictly ordered queues if weights are not present' do
-      @cli.parse(['sidekiq', '-q', 'foo', '-q', 'bar', '-r', './test/fake_env.rb'])
-      assert_equal true, !!Sidekiq.options[:strict]
-    end
-
-    it 'does not set strictly ordered queues if weights are present' do
-      @cli.parse(['sidekiq', '-q', 'foo,3', '-r', './test/fake_env.rb'])
-      assert_equal false, !!Sidekiq.options[:strict]
-    end
-
-    it 'does not set strictly ordered queues if weights are present with multiple queues' do
-      @cli.parse(['sidekiq', '-q', 'foo,3', '-q', 'bar', '-r', './test/fake_env.rb'])
-      assert_equal false, !!Sidekiq.options[:strict]
-    end
-
-    it 'changes timeout' do
-      @cli.parse(['sidekiq', '-t', '30', '-r', './test/fake_env.rb'])
-      assert_equal 30, Sidekiq.options[:timeout]
-    end
-
-    it 'handles multiple queues with weights' do
-      @cli.parse(['sidekiq', '-q', 'foo,3', '-q', 'bar', '-r', './test/fake_env.rb'])
-      assert_equal %w(foo foo foo bar), Sidekiq.options[:queues]
-    end
-
-    it 'handles queues with multi-word names' do
-      @cli.parse(['sidekiq', '-q', 'queue_one', '-q', 'queue-two', '-r', './test/fake_env.rb'])
-      assert_equal %w(queue_one queue-two), Sidekiq.options[:queues]
-    end
-
-    it 'handles queues with dots in the name' do
-      @cli.parse(['sidekiq', '-q', 'foo.bar', '-r', './test/fake_env.rb'])
-      assert_equal ['foo.bar'], Sidekiq.options[:queues]
-    end
-
-    it 'sets verbose' do
-      old = Sidekiq.logger.level
-      @cli.parse(['sidekiq', '-v', '-r', './test/fake_env.rb'])
-      assert_equal Logger::DEBUG, Sidekiq.logger.level
-      # If we leave the logger at DEBUG it'll add a lot of noise to the test output
-      Sidekiq.options.delete(:verbose)
-      Sidekiq.logger.level = old
-    end
-
-    describe 'with logfile' do
-      before do
-        @old_logger = Sidekiq.logger
-        @tmp_log_path = '/tmp/sidekiq.log'
-      end
-
-      after do
-        Sidekiq.logger = @old_logger
-        Sidekiq.options.delete(:logfile)
-        File.unlink @tmp_log_path if File.exist?(@tmp_log_path)
-      end
-
-      it 'sets the logfile path' do
-        @cli.parse(['sidekiq', '-L', @tmp_log_path, '-r', './test/fake_env.rb'])
-
-        assert_equal @tmp_log_path, Sidekiq.options[:logfile]
-      end
-
-      it 'creates and writes to a logfile' do
-        @cli.parse(['sidekiq', '-L', @tmp_log_path, '-r', './test/fake_env.rb'])
-
-        Sidekiq.logger.info('test message')
-
-        assert_match(/test message/, File.read(@tmp_log_path), "didn't include the log message")
-      end
-
-      it 'appends messages to a logfile' do
-        File.open(@tmp_log_path, 'w') do |f|
-          f.puts 'already existant log message'
-        end
-
-        @cli.parse(['sidekiq', '-L', @tmp_log_path, '-r', './test/fake_env.rb'])
-
-        Sidekiq.logger.info('test message')
-
-        log_file_content = File.read(@tmp_log_path)
-        assert_match(/already existant/, log_file_content, "didn't include the old message")
-        assert_match(/test message/, log_file_content, "didn't include the new message")
-      end
-    end
-
-    describe 'with pidfile' do
-      before do
-        @tmp_file = Tempfile.new('sidekiq-test')
-        @tmp_path = @tmp_file.path
-        @tmp_file.close!
-
-        @cli.parse(['sidekiq', '-P', @tmp_path, '-r', './test/fake_env.rb'])
-      end
-
-      after do
-        File.unlink @tmp_path if File.exist? @tmp_path
-      end
-
-      it 'sets pidfile path' do
-        assert_equal @tmp_path, Sidekiq.options[:pidfile]
-      end
-
-      it 'writes pidfile' do
-        assert_equal File.read(@tmp_path).strip.to_i, Process.pid
-      end
-    end
-
-    describe 'with config file' do
-      before do
-        @cli.parse(['sidekiq', '-C', './test/config.yml'])
-      end
-
-      it 'takes a path' do
-        assert_equal './test/config.yml', Sidekiq.options[:config_file]
-      end
-
-      it 'sets verbose' do
-        refute Sidekiq.options[:verbose]
-      end
-
-      it 'sets require file' do
-        assert_equal './test/fake_env.rb', Sidekiq.options[:require]
-      end
-
-      it 'does not set environment' do
-        assert_equal nil, Sidekiq.options[:environment]
-      end
-
-      it 'sets concurrency' do
-        assert_equal 50, Sidekiq.options[:concurrency]
-      end
-
-      it 'sets pid file' do
-        assert_equal '/tmp/sidekiq-config-test.pid', Sidekiq.options[:pidfile]
-      end
-
-      it 'sets logfile' do
-        assert_equal '/tmp/sidekiq.log', Sidekiq.options[:logfile]
-      end
-
-      it 'sets queues' do
-        assert_equal 2, Sidekiq.options[:queues].count { |q| q == 'very_often' }
-        assert_equal 1, Sidekiq.options[:queues].count { |q| q == 'seldom' }
-      end
-    end
-
-    describe 'with env based config file' do
-      before do
-        @cli.parse(['sidekiq', '-e', 'staging', '-C', './test/env_based_config.yml'])
-      end
-
-      it 'takes a path' do
-        assert_equal './test/env_based_config.yml', Sidekiq.options[:config_file]
-      end
-
-      it 'sets verbose' do
-        refute Sidekiq.options[:verbose]
-      end
-
-      it 'sets require file' do
-        assert_equal './test/fake_env.rb', Sidekiq.options[:require]
-      end
-
-      it 'sets environment' do
-        assert_equal 'staging', Sidekiq.options[:environment]
-      end
-
-      it 'sets concurrency' do
-        assert_equal 5, Sidekiq.options[:concurrency]
-      end
-
-      it 'sets pid file' do
-        assert_equal '/tmp/sidekiq-config-test.pid', Sidekiq.options[:pidfile]
-      end
-
-      it 'sets logfile' do
-        assert_equal '/tmp/sidekiq.log', Sidekiq.options[:logfile]
-      end
-
-      it 'sets queues' do
-        assert_equal 2, Sidekiq.options[:queues].count { |q| q == 'very_often' }
-        assert_equal 1, Sidekiq.options[:queues].count { |q| q == 'seldom' }
-      end
-    end
-
-    describe 'with an empty config file' do
-      before do
-        @tmp_file = Tempfile.new('sidekiq-test')
-        @tmp_path = @tmp_file.path
-        @tmp_file.close!
-      end
-
-      after do
-        File.unlink @tmp_path if File.exist? @tmp_path
-      end
-
-      it 'takes a path' do
-        @cli.parse(['sidekiq', '-C', @tmp_path])
-        assert_equal @tmp_path, Sidekiq.options[:config_file]
-      end
-
-      it 'should have an identical options hash, except for config_file' do
-        @cli.parse(['sidekiq'])
-        old_options = Sidekiq.options.clone
-
-        @cli.parse(['sidekiq', '-C', @tmp_path])
-        new_options = Sidekiq.options.clone
-        refute_equal old_options, new_options
-
-        new_options.delete(:config_file)
-        assert_equal old_options, new_options
-      end
-    end
-
-    describe 'with config file and flags' do
-      before do
-        # We need an actual file here.
-        @tmp_lib_path = '/tmp/require-me.rb'
-        File.open(@tmp_lib_path, 'w') do |f|
-          f.puts "# do work"
-        end
-
-        @tmp_file = Tempfile.new('sidekiqr')
-        @tmp_path = @tmp_file.path
-        @tmp_file.close!
-
-        @cli.parse(['sidekiq',
-                    '-C', './test/config.yml',
-                    '-e', 'snoop',
-                    '-c', '100',
-                    '-r', @tmp_lib_path,
-                    '-P', @tmp_path,
-                    '-q', 'often,7',
-                    '-q', 'seldom,3'])
-      end
-
-      after do
-        File.unlink @tmp_lib_path if File.exist? @tmp_lib_path
-        File.unlink @tmp_path if File.exist? @tmp_path
-      end
-
-      it 'uses concurrency flag' do
-        assert_equal 100, Sidekiq.options[:concurrency]
-      end
-
-      it 'uses require file flag' do
-        assert_equal @tmp_lib_path, Sidekiq.options[:require]
-      end
-
-      it 'uses environment flag' do
-        assert_equal 'snoop', Sidekiq.options[:environment]
-      end
-
-      it 'uses pidfile flag' do
-        assert_equal @tmp_path, Sidekiq.options[:pidfile]
-      end
-
-      it 'sets queues' do
-        assert_equal 7, Sidekiq.options[:queues].count { |q| q == 'often' }
-        assert_equal 3, Sidekiq.options[:queues].count { |q| q == 'seldom' }
-      end
-    end
-
-    describe 'Sidekiq::CLI#parse_queues' do
-      describe 'when weight is present' do
-        it 'concatenates queues by factor of weight and sets strict to false' do
-          opts = { strict: true }
-          @cli.__send__ :parse_queues, opts, [['often', 7], ['repeatedly', 3]]
-          @cli.__send__ :parse_queues, opts, [['once']]
-          assert_equal (%w[often] * 7 + %w[repeatedly] * 3 + %w[once]), opts[:queues]
-          assert !opts[:strict]
-        end
-      end
-
-      describe 'when weight is not present' do
-        it 'returns queues and sets strict' do
-          opts = { strict: true }
-          @cli.__send__ :parse_queues, opts, [['once'], ['one_time']]
-          @cli.__send__ :parse_queues, opts, [['einmal']]
-          assert_equal %w[once one_time einmal], opts[:queues]
-          assert opts[:strict]
-        end
-      end
-    end
-
-    describe 'Sidekiq::CLI#parse_queue' do
-      describe 'when weight is present' do
-        it 'concatenates queue to opts[:queues] weight number of times and sets strict to false' do
-          opts = { strict: true }
-          @cli.__send__ :parse_queue, opts, 'often', 7
-          assert_equal %w[often] * 7, opts[:queues]
-          assert !opts[:strict]
-        end
-      end
-
-      describe 'when weight is not present' do
-        it 'concatenates queue to opts[:queues] once and leaves strict true' do
-          opts = { strict: true }
-          @cli.__send__ :parse_queue, opts, 'once', nil
-          assert_equal %w[once], opts[:queues]
-          assert opts[:strict]
-        end
-      end
-    end
-  end
-
-end

data/test/test_client.rb

@@ -1,269 +0,0 @@
-require_relative 'helper'
-require 'sidekiq/client'
-require 'sidekiq/worker'
-
-class TestClient < Sidekiq::Test
-  describe 'with mock redis' do
-    before do
-      @redis = Minitest::Mock.new
-      def @redis.multi; [yield] * 2 if block_given?; end
-      def @redis.set(*); true; end
-      def @redis.sadd(*); true; end
-      def @redis.srem(*); true; end
-      def @redis.get(*); nil; end
-      def @redis.del(*); nil; end
-      def @redis.incrby(*); nil; end
-      def @redis.setex(*); true; end
-      def @redis.expire(*); true; end
-      def @redis.watch(*); true; end
-      def @redis.with_connection; yield self; end
-      def @redis.with; yield self; end
-      def @redis.exec; true; end
-      Sidekiq.instance_variable_set(:@redis, @redis)
-      Sidekiq::Client.instance_variable_set(:@default, nil)
-    end
-
-    after do
-      Sidekiq.redis = REDIS
-      Sidekiq::Client.instance_variable_set(:@default, nil)
-    end
-
-    it 'raises ArgumentError with invalid params' do
-      assert_raises ArgumentError do
-        Sidekiq::Client.push('foo', 1)
-      end
-
-      assert_raises ArgumentError do
-        Sidekiq::Client.push('foo', :class => 'Foo', :noargs => [1, 2])
-      end
-
-      assert_raises ArgumentError do
-        Sidekiq::Client.push('queue' => 'foo', 'class' => MyWorker, 'noargs' => [1, 2])
-      end
-
-      assert_raises ArgumentError do
-        Sidekiq::Client.push('queue' => 'foo', 'class' => 42, 'args' => [1, 2])
-      end
-
-      assert_raises ArgumentError do
-        Sidekiq::Client.push('queue' => 'foo', 'class' => MyWorker, 'args' => 1)
-      end
-    end
-
-    describe 'as instance' do
-      it 'can push' do
-        @redis.expect :lpush, 1, ['queue:default', Array]
-        client = Sidekiq::Client.new
-        jid = client.push('class' => 'Blah', 'args' => [1,2,3])
-        assert_equal 24, jid.size
-      end
-
-      it 'allows local middleware modification' do
-        @redis.expect :lpush, 1, ['queue:default', Array]
-        $called = false
-        mware = Class.new { def call(worker_klass,msg,q,r); $called = true; msg;end }
-        client = Sidekiq::Client.new
-        client.middleware do |chain|
-          chain.add mware
-        end
-        client.push('class' => 'Blah', 'args' => [1,2,3])
-
-        assert $called
-        assert client.middleware.exists?(mware)
-        refute Sidekiq.client_middleware.exists?(mware)
-      end
-    end
-
-    it 'pushes messages to redis' do
-      @redis.expect :lpush, 1, ['queue:foo', Array]
-      pushed = Sidekiq::Client.push('queue' => 'foo', 'class' => MyWorker, 'args' => [1, 2])
-      assert pushed
-      assert_equal 24, pushed.size
-      @redis.verify
-    end
-
-    it 'pushes messages to redis using a String class' do
-      @redis.expect :lpush, 1, ['queue:foo', Array]
-      pushed = Sidekiq::Client.push('queue' => 'foo', 'class' => 'MyWorker', 'args' => [1, 2])
-      assert pushed
-      assert_equal 24, pushed.size
-      @redis.verify
-    end
-
-    class MyWorker
-      include Sidekiq::Worker
-    end
-
-    it 'has default options' do
-      assert_equal Sidekiq.default_worker_options, MyWorker.get_sidekiq_options
-    end
-
-    it 'handles perform_async' do
-      @redis.expect :lpush, 1, ['queue:default', Array]
-      pushed = MyWorker.perform_async(1, 2)
-      assert pushed
-      @redis.verify
-    end
-
-    it 'enqueues messages to redis' do
-      @redis.expect :lpush, 1, ['queue:default', Array]
-      pushed = Sidekiq::Client.enqueue(MyWorker, 1, 2)
-      assert pushed
-      @redis.verify
-    end
-
-    it 'enqueues messages to redis' do
-      @redis.expect :lpush, 1, ['queue:custom_queue', Array]
-      pushed = Sidekiq::Client.enqueue_to(:custom_queue, MyWorker, 1, 2)
-      assert pushed
-      @redis.verify
-    end
-
-    it 'enqueues messages to redis (delayed, custom queue)' do
-      @redis.expect :zadd, 1, ['schedule', Array]
-      pushed = Sidekiq::Client.enqueue_to_in(:custom_queue, 3.minutes, MyWorker, 1, 2)
-      assert pushed
-      @redis.verify
-    end
-
-    it 'enqueues messages to redis (delayed into past, custom queue)' do
-      @redis.expect :lpush, 1, ['queue:custom_queue', Array]
-      pushed = Sidekiq::Client.enqueue_to_in(:custom_queue, -3.minutes, MyWorker, 1, 2)
-      assert pushed
-      @redis.verify
-    end
-
-    it 'enqueues messages to redis (delayed)' do
-      @redis.expect :zadd, 1, ['schedule', Array]
-      pushed = Sidekiq::Client.enqueue_in(3.minutes, MyWorker, 1, 2)
-      assert pushed
-      @redis.verify
-    end
-
-    class QueuedWorker
-      include Sidekiq::Worker
-      sidekiq_options :queue => :flimflam
-    end
-
-    it 'enqueues to the named queue' do
-      @redis.expect :lpush, 1, ['queue:flimflam', Array]
-      pushed = QueuedWorker.perform_async(1, 2)
-      assert pushed
-      @redis.verify
-    end
-
-    it 'retrieves queues' do
-      @redis.expect :smembers, ['bob'], ['queues']
-      assert_equal ['bob'], Sidekiq::Queue.all.map(&:name)
-    end
-  end
-
-  describe 'bulk' do
-    after do
-      Sidekiq::Queue.new.clear
-    end
-    it 'can push a large set of jobs at once' do
-      jids = Sidekiq::Client.push_bulk('class' => QueuedWorker, 'args' => (1..1_000).to_a.map { |x| Array(x) })
-      assert_equal 1_000, jids.size
-    end
-    it 'can push a large set of jobs at once using a String class' do
-      jids = Sidekiq::Client.push_bulk('class' => 'QueuedWorker', 'args' => (1..1_000).to_a.map { |x| Array(x) })
-      assert_equal 1_000, jids.size
-    end
-    it 'returns the jids for the jobs' do
-      Sidekiq::Client.push_bulk('class' => 'QueuedWorker', 'args' => (1..2).to_a.map { |x| Array(x) }).each do |jid|
-        assert_match(/[0-9a-f]{12}/, jid)
-      end
-    end
-  end
-
-  class BaseWorker
-    include Sidekiq::Worker
-    sidekiq_options 'retry' => 'base'
-  end
-  class AWorker < BaseWorker
-  end
-  class BWorker < BaseWorker
-    sidekiq_options 'retry' => 'b'
-  end
-  class CWorker < BaseWorker
-    sidekiq_options 'retry' => 2
-  end
-
-  describe 'client middleware' do
-
-    class Stopper
-      def call(worker_class, message, queue, r)
-        raise ArgumentError unless r
-        yield if message['args'].first.odd?
-      end
-    end
-
-    it 'can stop some of the jobs from pushing' do
-      Sidekiq.client_middleware.add Stopper
-      begin
-        assert_equal nil, Sidekiq::Client.push('class' => MyWorker, 'args' => [0])
-        assert_match(/[0-9a-f]{12}/, Sidekiq::Client.push('class' => MyWorker, 'args' => [1]))
-        Sidekiq::Client.push_bulk('class' => MyWorker, 'args' => [[0], [1]]).each do |jid|
-          assert_match(/[0-9a-f]{12}/, jid)
-        end
-      ensure
-        Sidekiq.client_middleware.remove Stopper
-      end
-    end
-  end
-
-  describe 'inheritance' do
-    it 'inherits sidekiq options' do
-      assert_equal 'base', AWorker.get_sidekiq_options['retry']
-      assert_equal 'b', BWorker.get_sidekiq_options['retry']
-    end
-  end
-
-  describe 'item normalization' do
-    it 'defaults retry to true' do
-      assert_equal true, Sidekiq::Client.new.__send__(:normalize_item, 'class' => QueuedWorker, 'args' => [])['retry']
-    end
-
-    it "does not normalize numeric retry's" do
-      assert_equal 2, Sidekiq::Client.new.__send__(:normalize_item, 'class' => CWorker, 'args' => [])['retry']
-    end
-  end
-
-  describe 'sharding' do
-    class DWorker < BaseWorker
-    end
-    it 'allows sidekiq_options to point to different Redi' do
-      conn = MiniTest::Mock.new
-      conn.expect(:multi, [0, 1])
-      DWorker.sidekiq_options('pool' => ConnectionPool.new(size: 1) { conn })
-      DWorker.perform_async(1,2,3)
-      conn.verify
-    end
-    it 'allows #via to point to different Redi' do
-      conn = MiniTest::Mock.new
-      conn.expect(:multi, [0, 1])
-      default = Sidekiq::Client.new.redis_pool
-      sharded_pool = ConnectionPool.new(size: 1) { conn }
-      Sidekiq::Client.via(sharded_pool) do
-        CWorker.perform_async(1,2,3)
-        assert_equal sharded_pool, Sidekiq::Client.new.redis_pool
-        assert_raises RuntimeError do
-          Sidekiq::Client.via(default) do
-            # nothing
-          end
-        end
-      end
-      assert_equal default, Sidekiq::Client.new.redis_pool
-      conn.verify
-    end
-    it 'allows Resque helpers to point to different Redi' do
-      conn = MiniTest::Mock.new
-      conn.expect(:multi, []) { |*args, &block| block.call }
-      conn.expect(:zadd, 1, [String, Array])
-      DWorker.sidekiq_options('pool' => ConnectionPool.new(size: 1) { conn })
-      Sidekiq::Client.enqueue_in(10, DWorker, 3)
-      conn.verify
-    end
-  end
-end

data/test/test_exception_handler.rb

@@ -1,55 +0,0 @@
-require_relative 'helper'
-require 'sidekiq/exception_handler'
-require 'stringio'
-require 'logger'
-
-ExceptionHandlerTestException = Class.new(StandardError)
-TEST_EXCEPTION = ExceptionHandlerTestException.new("Something didn't work!")
-
-class Component
-  include Sidekiq::ExceptionHandler
-
-  def invoke_exception(args)
-    raise TEST_EXCEPTION
-  rescue ExceptionHandlerTestException => e
-    handle_exception(e,args)
-  end
-end
-
-class TestExceptionHandler < Sidekiq::Test
-  describe "with mock logger" do
-    before do
-      @old_logger = Sidekiq.logger
-      @str_logger = StringIO.new
-      Sidekiq.logger = Logger.new(@str_logger)
-    end
-
-    after do
-      Sidekiq.logger = @old_logger
-    end
-
-    it "logs the exception to Sidekiq.logger" do
-      Component.new.invoke_exception(:a => 1)
-      @str_logger.rewind
-      log = @str_logger.readlines
-      assert_match(/a=>1/, log[0], "didn't include the context")
-      assert_match(/Something didn't work!/, log[1], "didn't include the exception message")
-      assert_match(/test\/test_exception_handler.rb/, log[2], "didn't include the backtrace")
-    end
-
-    describe "when the exception does not have a backtrace" do
-      it "does not fail" do
-        exception = ExceptionHandlerTestException.new
-        assert_nil exception.backtrace
-
-        begin
-          Component.new.handle_exception exception
-          pass
-        rescue StandardError
-          flunk "failed handling a nil backtrace"
-        end
-      end
-    end
-  end
-
-end