sr-sidekiq 4.1.6

data/test/test_cli.rb

@@ -0,0 +1,406 @@
+# frozen_string_literal: true
+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 existent 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 existent/, 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 'parses as expected' do
+        assert_equal './test/config.yml', Sidekiq.options[:config_file]
+        refute Sidekiq.options[:verbose]
+        assert_equal './test/fake_env.rb', Sidekiq.options[:require]
+        assert_equal nil, Sidekiq.options[:environment]
+        assert_equal 50, Sidekiq.options[:concurrency]
+        assert_equal '/tmp/sidekiq-config-test.pid', Sidekiq.options[:pidfile]
+        assert_equal '/tmp/sidekiq.log', Sidekiq.options[:logfile]
+        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 'parses as expected' do
+        assert_equal './test/env_based_config.yml', Sidekiq.options[:config_file]
+        refute Sidekiq.options[:verbose]
+        assert_equal './test/fake_env.rb', Sidekiq.options[:require]
+        assert_equal 'staging', Sidekiq.options[:environment]
+        assert_equal 5, Sidekiq.options[:concurrency]
+        assert_equal '/tmp/sidekiq-config-test.pid', Sidekiq.options[:pidfile]
+        assert_equal '/tmp/sidekiq.log', Sidekiq.options[:logfile]
+        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 'gives the expected options' do
+        assert_equal 100, Sidekiq.options[:concurrency]
+        assert_equal @tmp_lib_path, Sidekiq.options[:require]
+        assert_equal 'snoop', Sidekiq.options[:environment]
+        assert_equal @tmp_path, Sidekiq.options[:pidfile]
+        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
+
+  describe 'misc' do
+    before do
+      @cli = Sidekiq::CLI.new
+    end
+
+    it 'handles interrupts' do
+      assert_raises Interrupt do
+        @cli.handle_signal('INT')
+      end
+      assert_raises Interrupt do
+        @cli.handle_signal('TERM')
+      end
+    end
+
+    describe 'handles USR1 and USR2' do
+      before do
+        @tmp_log_path = '/tmp/sidekiq.log'
+        @cli.parse(['sidekiq', '-L', @tmp_log_path, '-r', './test/fake_env.rb'])
+      end
+
+      after do
+        File.unlink @tmp_log_path if File.exists? @tmp_log_path
+      end
+
+      it 'shuts down the worker' do
+        count = 0
+        Sidekiq.options[:lifecycle_events][:quiet] = [proc {
+          count += 1
+        }]
+        @cli.launcher = Sidekiq::Launcher.new(Sidekiq.options)
+        @cli.handle_signal('USR1')
+
+        assert_equal 1, count
+      end
+
+      it 'reopens logs' do
+        mock = MiniTest::Mock.new
+        # reopen_logs returns number of files reopened so mock that
+        mock.expect(:call, 1)
+
+        Sidekiq::Logging.stub(:reopen_logs, mock) do
+          @cli.handle_signal('USR2')
+        end
+        mock.verify
+      end
+    end
+
+    describe 'handles TTIN' do
+      before do
+        @tmp_log_path = '/tmp/sidekiq.log'
+        @cli.parse(['sidekiq', '-L', @tmp_log_path, '-r', './test/fake_env.rb'])
+        @mock_thread = MiniTest::Mock.new
+        @mock_thread.expect(:[], 'interrupt_test', ['label'])
+      end
+
+      after do
+        File.unlink @tmp_log_path if File.exists? @tmp_log_path
+      end
+
+      describe 'with backtrace' do
+        it 'logs backtrace' do
+          2.times { @mock_thread.expect(:backtrace, ['something went wrong']) }
+
+          Thread.stub(:list, [@mock_thread]) do
+            @cli.handle_signal('TTIN')
+            assert_match(/something went wrong/, File.read(@tmp_log_path), "didn't include the log message")
+          end
+        end
+      end
+
+      describe 'without backtrace' do
+        it 'logs no backtrace available' do
+          @mock_thread.expect(:backtrace, nil)
+
+          Thread.stub(:list, [@mock_thread]) do
+            @cli.handle_signal('TTIN')
+            assert_match(/no backtrace available/, File.read(@tmp_log_path), "didn't include the log message")
+          end
+        end
+      end
+    end
+
+
+    it 'can fire events' do
+      count = 0
+      Sidekiq.options[:lifecycle_events][:startup] = [proc {
+        count += 1
+      }]
+      cli = Sidekiq::CLI.new
+      cli.fire_event(:startup)
+      assert_equal 1, count
+    end
+  end
+
+end

data/test/test_client.rb

@@ -0,0 +1,262 @@
+# frozen_string_literal: true
+require_relative 'helper'
+
+class TestClient < Sidekiq::Test
+  describe 'errors' do
+    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
+  end
+
+  describe 'as instance' do
+    it 'can push' do
+      client = Sidekiq::Client.new
+      jid = client.push('class' => 'Blah', 'args' => [1,2,3])
+      assert_equal 24, jid.size
+    end
+
+    it 'allows middleware to stop bulk jobs' do
+      mware = Class.new do
+        def call(worker_klass,msg,q,r)
+          msg['args'][0] == 1 ? yield : false
+        end
+      end
+      client = Sidekiq::Client.new
+      client.middleware do |chain|
+        chain.add mware
+      end
+      q = Sidekiq::Queue.new
+      q.clear
+      result = client.push_bulk('class' => 'Blah', 'args' => [[1],[2],[3]])
+      assert_equal 1, result.size
+      assert_equal 1, q.size
+    end
+
+    it 'allows local middleware modification' do
+      $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
+
+  describe 'client' do
+    it 'pushes messages to redis' do
+      q = Sidekiq::Queue.new('foo')
+      pre = q.size
+      jid = Sidekiq::Client.push('queue' => 'foo', 'class' => MyWorker, 'args' => [1, 2])
+      assert jid
+      assert_equal 24, jid.size
+      assert_equal pre + 1, q.size
+    end
+
+    it 'pushes messages to redis using a String class' do
+      q = Sidekiq::Queue.new('foo')
+      pre = q.size
+      jid = Sidekiq::Client.push('queue' => 'foo', 'class' => 'MyWorker', 'args' => [1, 2])
+      assert jid
+      assert_equal 24, jid.size
+      assert_equal pre + 1, q.size
+    end
+
+    class MyWorker
+      include Sidekiq::Worker
+    end
+
+    class QueuedWorker
+      include Sidekiq::Worker
+      sidekiq_options :queue => :flimflam
+    end
+
+    it 'enqueues' do
+      Sidekiq.redis {|c| c.flushdb }
+      assert_equal Sidekiq.default_worker_options, MyWorker.get_sidekiq_options
+      assert MyWorker.perform_async(1, 2)
+      assert Sidekiq::Client.enqueue(MyWorker, 1, 2)
+      assert Sidekiq::Client.enqueue_to(:custom_queue, MyWorker, 1, 2)
+      assert_equal 1, Sidekiq::Queue.new('custom_queue').size
+      assert Sidekiq::Client.enqueue_to_in(:custom_queue, 3.minutes, MyWorker, 1, 2)
+      assert Sidekiq::Client.enqueue_to_in(:custom_queue, -3.minutes, MyWorker, 1, 2)
+      assert_equal 2, Sidekiq::Queue.new('custom_queue').size
+      assert Sidekiq::Client.enqueue_in(3.minutes, MyWorker, 1, 2)
+      assert QueuedWorker.perform_async(1, 2)
+      assert_equal 1, Sidekiq::Queue.new('flimflam').size
+    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, job, queue, r)
+        raise ArgumentError unless r
+        yield if job['args'].first.odd?
+      end
+    end
+
+    it 'can stop some of the jobs from pushing' do
+      client = Sidekiq::Client.new
+      client.middleware do |chain|
+        chain.add Stopper
+      end
+
+      assert_equal nil, client.push('class' => MyWorker, 'args' => [0])
+      assert_match(/[0-9a-f]{12}/, client.push('class' => MyWorker, 'args' => [1]))
+      client.push_bulk('class' => MyWorker, 'args' => [[0], [1]]).each do |jid|
+        assert_match(/[0-9a-f]{12}/, jid)
+      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 '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 same Redi' do
+      conn = MiniTest::Mock.new
+      conn.expect(:multi, [0, 1])
+      sharded_pool = ConnectionPool.new(size: 1) { conn }
+      Sidekiq::Client.via(sharded_pool) do
+        Sidekiq::Client.via(sharded_pool) do
+          CWorker.perform_async(1,2,3)
+        end
+      end
+      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
+
+  describe 'Sidekiq::Worker#set' do
+    class SetWorker
+      include Sidekiq::Worker
+      sidekiq_options :queue => :foo, 'retry' => 12
+    end
+
+    def setup
+      Sidekiq.redis {|c| c.flushdb }
+    end
+
+    it 'allows option overrides' do
+      q = Sidekiq::Queue.new('bar')
+      assert_equal 0, q.size
+      assert SetWorker.set(queue: :bar).perform_async(1)
+      job = q.first
+      assert_equal 'bar', job['queue']
+      assert_equal 12, job['retry']
+    end
+
+    it 'handles symbols and strings' do
+      q = Sidekiq::Queue.new('bar')
+      assert_equal 0, q.size
+      assert SetWorker.set('queue' => 'bar', :retry => 11).perform_async(1)
+      job = q.first
+      assert_equal 'bar', job['queue']
+      assert_equal 11, job['retry']
+
+      q.clear
+      assert SetWorker.perform_async(1)
+      assert_equal 0, q.size
+
+      q = Sidekiq::Queue.new('foo')
+      job = q.first
+      assert_equal 'foo', job['queue']
+      assert_equal 12, job['retry']
+    end
+  end
+end