sidekiq 4.2.10 → 5.0.0.beta1

data/test/test_exception_handler.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+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

data/test/test_extensions.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+require_relative 'helper'
+require 'sidekiq/api'
+require 'active_record'
+require 'action_mailer'
+Sidekiq::Extensions.enable_delay!
+
+class TestExtensions < Sidekiq::Test
+  describe 'sidekiq extensions' do
+    before do
+      Sidekiq.redis = REDIS
+      Sidekiq.redis {|c| c.flushdb }
+    end
+
+    class MyModel < ActiveRecord::Base
+      def self.long_class_method
+        raise "Should not be called!"
+      end
+    end
+
+    it 'allows delayed execution of ActiveRecord class methods' do
+      assert_equal [], Sidekiq::Queue.all.map(&:name)
+      q = Sidekiq::Queue.new
+      assert_equal 0, q.size
+      MyModel.delay.long_class_method
+      assert_equal ['default'], Sidekiq::Queue.all.map(&:name)
+      assert_equal 1, q.size
+    end
+
+    it 'uses and stringifies specified options' do
+      assert_equal [], Sidekiq::Queue.all.map(&:name)
+      q = Sidekiq::Queue.new('notdefault')
+      assert_equal 0, q.size
+      MyModel.delay(queue: :notdefault).long_class_method
+      assert_equal ['notdefault'], Sidekiq::Queue.all.map(&:name)
+      assert_equal 1, q.size
+    end
+
+    it 'allows delayed scheduling of AR class methods' do
+      ss = Sidekiq::ScheduledSet.new
+      assert_equal 0, ss.size
+      MyModel.delay_for(5.days).long_class_method
+      assert_equal 1, ss.size
+    end
+
+    it 'allows until delayed scheduling of AR class methods' do
+      ss = Sidekiq::ScheduledSet.new
+      assert_equal 0, ss.size
+      MyModel.delay_until(1.day.from_now).long_class_method
+      assert_equal 1, ss.size
+    end
+
+    class UserMailer < ActionMailer::Base
+      def greetings(a, b)
+        raise "Should not be called!"
+      end
+    end
+
+    it 'allows delayed delivery of ActionMailer mails' do
+      assert_equal [], Sidekiq::Queue.all.map(&:name)
+      q = Sidekiq::Queue.new
+      assert_equal 0, q.size
+      UserMailer.delay.greetings(1, 2)
+      assert_equal ['default'], Sidekiq::Queue.all.map(&:name)
+      assert_equal 1, q.size
+    end
+
+    it 'allows delayed scheduling of AM mails' do
+      ss = Sidekiq::ScheduledSet.new
+      assert_equal 0, ss.size
+      UserMailer.delay_for(5.days).greetings(1, 2)
+      assert_equal 1, ss.size
+    end
+
+    it 'allows until delay scheduling of AM mails' do
+      ss = Sidekiq::ScheduledSet.new
+      assert_equal 0, ss.size
+      UserMailer.delay_until(5.days.from_now).greetings(1, 2)
+      assert_equal 1, ss.size
+    end
+
+    class SomeClass
+      def self.doit(arg)
+      end
+    end
+
+    it 'allows delay of any ole class method' do
+      q = Sidekiq::Queue.new
+      assert_equal 0, q.size
+      SomeClass.delay.doit(Date.today)
+      assert_equal 1, q.size
+    end
+
+    module SomeModule
+      def self.doit(arg)
+      end
+    end
+
+    it 'logs large payloads' do
+      output = capture_logging(Logger::WARN) do
+        SomeClass.delay.doit('a' * 8192)
+      end
+      assert_match(/#{SomeClass}.doit job argument is/, output)
+    end
+
+    it 'allows delay of any module class method' do
+      q = Sidekiq::Queue.new
+      assert_equal 0, q.size
+      SomeModule.delay.doit(Date.today)
+      assert_equal 1, q.size
+    end
+
+  end
+
+end

data/test/test_fetch.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+require_relative 'helper'
+require 'sidekiq/fetch'
+
+class TestFetcher < Sidekiq::Test
+  describe 'fetcher' do
+    before do
+      Sidekiq.redis = { :url => REDIS_URL, :namespace => 'fuzzy' }
+      Sidekiq.redis do |conn|
+        conn.flushdb
+        conn.rpush('queue:basic', 'msg')
+      end
+    end
+
+    after do
+      Sidekiq.redis = REDIS
+    end
+
+    it 'retrieves' do
+      fetch = Sidekiq::BasicFetch.new(:queues => ['basic', 'bar'])
+      uow = fetch.retrieve_work
+      refute_nil uow
+      assert_equal 'basic', uow.queue_name
+      assert_equal 'msg', uow.job
+      q = Sidekiq::Queue.new('basic')
+      assert_equal 0, q.size
+      uow.requeue
+      assert_equal 1, q.size
+      assert_nil uow.acknowledge
+    end
+
+    it 'retrieves with strict setting' do
+      fetch = Sidekiq::BasicFetch.new(:queues => ['basic', 'bar', 'bar'], :strict => true)
+      cmd = fetch.queues_cmd
+      assert_equal cmd, ['queue:basic', 'queue:bar', Sidekiq::BasicFetch::TIMEOUT]
+    end
+
+    it 'bulk requeues' do
+      q1 = Sidekiq::Queue.new('foo')
+      q2 = Sidekiq::Queue.new('bar')
+      assert_equal 0, q1.size
+      assert_equal 0, q2.size
+      uow = Sidekiq::BasicFetch::UnitOfWork
+      Sidekiq::BasicFetch.bulk_requeue([uow.new('fuzzy:queue:foo', 'bob'), uow.new('fuzzy:queue:foo', 'bar'), uow.new('fuzzy:queue:bar', 'widget')], {:queues => []})
+      assert_equal 2, q1.size
+      assert_equal 1, q2.size
+    end
+
+  end
+end

data/test/test_launcher.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+require_relative 'helper'
+require 'sidekiq/launcher'
+
+class TestLauncher < Sidekiq::Test
+
+  describe 'launcher' do
+    before do
+      Sidekiq.redis {|c| c.flushdb }
+    end
+
+    def new_manager(opts)
+      Sidekiq::Manager.new(opts)
+    end
+
+    describe 'heartbeat' do
+      before do
+        @mgr = new_manager(options)
+        @launcher = Sidekiq::Launcher.new(options)
+        @launcher.manager = @mgr
+        @id = @launcher.identity
+
+        Sidekiq::Processor::WORKER_STATE['a'] = {'b' => 1}
+
+        @proctitle = $0
+      end
+
+      after do
+        Sidekiq::Processor::WORKER_STATE.clear
+        $0 = @proctitle
+      end
+
+      it 'fires new heartbeat events' do
+        i = 0
+        Sidekiq.on(:heartbeat) do
+          i += 1
+        end
+        assert_equal 0, i
+        @launcher.heartbeat
+        assert_equal 1, i
+        @launcher.heartbeat
+        assert_equal 1, i
+      end
+
+      describe 'when manager is active' do
+        before do
+          Sidekiq::CLI::PROCTITLES << proc { "xyz" }
+          @launcher.heartbeat
+          Sidekiq::CLI::PROCTITLES.pop
+        end
+
+        it 'sets useful info to proctitle' do
+          assert_equal "sidekiq #{Sidekiq::VERSION} myapp [1 of 3 busy] xyz", $0
+        end
+
+        it 'stores process info in redis' do
+          info = Sidekiq.redis { |c| c.hmget(@id, 'busy') }
+          assert_equal ["1"], info
+          expires = Sidekiq.redis { |c| c.pttl(@id) }
+          assert_in_delta 60000, expires, 500
+        end
+      end
+
+      describe 'when manager is stopped' do
+        before do
+          @launcher.quiet
+          @launcher.heartbeat
+        end
+
+        #after do
+          #puts system('redis-cli -n 15 keys  "*" | while read LINE ; do TTL=`redis-cli -n 15 ttl "$LINE"`; if [ "$TTL" -eq -1 ]; then echo "$LINE"; fi; done;')
+        #end
+
+        it 'indicates stopping status in proctitle' do
+          assert_equal "sidekiq #{Sidekiq::VERSION} myapp [1 of 3 busy] stopping", $0
+        end
+
+        it 'stores process info in redis' do
+          info = Sidekiq.redis { |c| c.hmget(@id, 'busy') }
+          assert_equal ["1"], info
+          expires = Sidekiq.redis { |c| c.pttl(@id) }
+          assert_in_delta 60000, expires, 50
+        end
+      end
+    end
+
+    def options
+      { :concurrency => 3, :queues => ['default'], :tag => 'myapp' }
+    end
+
+  end
+end

data/test/test_logging.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+require_relative 'helper'
+require 'sidekiq/logging'
+
+class TestLogging < Sidekiq::Test
+  describe Sidekiq::Logging do
+    describe "#with_context" do
+      def ctx
+        Sidekiq::Logging.logger.formatter.context
+      end
+
+      it "has no context by default" do
+        assert_nil ctx
+      end
+
+      it "can add a context" do
+        Sidekiq::Logging.with_context "xx" do
+          assert_equal " xx", ctx
+        end
+        assert_nil ctx
+      end
+
+      it "can use multiple contexts" do
+        Sidekiq::Logging.with_context "xx" do
+          assert_equal " xx", ctx
+          Sidekiq::Logging.with_context "yy" do
+            assert_equal " xx yy", ctx
+          end
+          assert_equal " xx", ctx
+        end
+        assert_nil ctx
+      end
+    end
+  end
+end

data/test/test_manager.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+require_relative 'helper'
+require 'sidekiq/manager'
+
+class TestManager < Sidekiq::Test
+
+  describe 'manager' do
+    before do
+      Sidekiq.redis {|c| c.flushdb }
+    end
+
+    def new_manager(opts)
+      Sidekiq::Manager.new(opts)
+    end
+
+    it 'creates N processor instances' do
+      mgr = new_manager(options)
+      assert_equal options[:concurrency], mgr.workers.size
+    end
+
+    it 'shuts down the system' do
+      mgr = new_manager(options)
+      mgr.stop(Time.now)
+    end
+
+    it 'throws away dead processors' do
+      mgr = new_manager(options)
+      init_size = mgr.workers.size
+      processor = mgr.workers.first
+      begin
+        mgr.processor_died(processor, 'ignored')
+
+        assert_equal init_size, mgr.workers.size
+        refute mgr.workers.include?(processor)
+      ensure
+        mgr.workers.each {|p| p.terminate(true) }
+      end
+    end
+
+    it 'does not support invalid concurrency' do
+      assert_raises(ArgumentError) { new_manager(concurrency: 0) }
+      assert_raises(ArgumentError) { new_manager(concurrency: -1) }
+    end
+
+    def options
+      { :concurrency => 3, :queues => ['default'] }
+    end
+
+  end
+end

data/test/test_middleware.rb

@@ -0,0 +1,158 @@
+# frozen_string_literal: true
+require_relative 'helper'
+require 'sidekiq/middleware/chain'
+require 'sidekiq/processor'
+
+class TestMiddleware < Sidekiq::Test
+  describe 'middleware chain' do
+    before do
+      $errors = []
+      Sidekiq.redis = REDIS
+    end
+
+    class CustomMiddleware
+      def initialize(name, recorder)
+        @name = name
+        @recorder = recorder
+      end
+
+      def call(*args)
+        @recorder << [@name, 'before']
+        yield
+        @recorder << [@name, 'after']
+      end
+    end
+
+    it 'supports custom middleware' do
+      chain = Sidekiq::Middleware::Chain.new
+      chain.add CustomMiddleware, 1, []
+
+      assert_equal CustomMiddleware, chain.entries.last.klass
+    end
+
+    class CustomWorker
+      $recorder = []
+      include Sidekiq::Worker
+      def perform(recorder)
+        $recorder << ['work_performed']
+      end
+    end
+
+    class NonYieldingMiddleware
+      def call(*args)
+      end
+    end
+
+    class AnotherCustomMiddleware
+      def initialize(name, recorder)
+        @name = name
+        @recorder = recorder
+      end
+
+      def call(*args)
+        @recorder << [@name, 'before']
+        yield
+        @recorder << [@name, 'after']
+      end
+    end
+
+    class YetAnotherCustomMiddleware
+      def initialize(name, recorder)
+        @name = name
+        @recorder = recorder
+      end
+
+      def call(*args)
+        @recorder << [@name, 'before']
+        yield
+        @recorder << [@name, 'after']
+      end
+    end
+
+    it 'executes middleware in the proper order' do
+      msg = Sidekiq.dump_json({ 'class' => CustomWorker.to_s, 'args' => [$recorder] })
+
+      Sidekiq.server_middleware do |chain|
+        # should only add once, second should replace the first
+        2.times { |i| chain.add CustomMiddleware, i.to_s, $recorder }
+        chain.insert_before CustomMiddleware, AnotherCustomMiddleware, '2', $recorder
+        chain.insert_after AnotherCustomMiddleware, YetAnotherCustomMiddleware, '3', $recorder
+      end
+
+      boss = Minitest::Mock.new
+      boss.expect(:options, {:queues => ['default'] }, [])
+      boss.expect(:options, {:queues => ['default'] }, [])
+      processor = Sidekiq::Processor.new(boss)
+      boss.expect(:processor_done, nil, [processor])
+      processor.process(Sidekiq::BasicFetch::UnitOfWork.new('queue:default', msg))
+      assert_equal %w(2 before 3 before 1 before work_performed 1 after 3 after 2 after), $recorder.flatten
+    end
+
+    it 'correctly replaces middleware when using middleware with options in the initializer' do
+      chain = Sidekiq::Middleware::Chain.new
+      chain.add NonYieldingMiddleware
+      chain.add NonYieldingMiddleware, {:foo => 5}
+      assert_equal 1, chain.count
+    end
+
+    it 'correctly prepends middleware' do
+      chain = Sidekiq::Middleware::Chain.new
+      chain_entries = chain.entries
+      chain.add CustomMiddleware
+      chain.prepend YetAnotherCustomMiddleware
+      assert_equal YetAnotherCustomMiddleware, chain_entries.first.klass
+      assert_equal CustomMiddleware, chain_entries.last.klass
+    end
+
+    it 'allows middleware to abruptly stop processing rest of chain' do
+      recorder = []
+      chain = Sidekiq::Middleware::Chain.new
+      chain.add NonYieldingMiddleware
+      chain.add CustomMiddleware, 1, recorder
+
+      final_action = nil
+      chain.invoke { final_action = true }
+      assert_nil final_action
+      assert_equal [], recorder
+    end
+  end
+
+  describe 'i18n' do
+    before do
+      require 'i18n'
+      I18n.enforce_available_locales = false
+      require 'sidekiq/middleware/i18n'
+    end
+
+    it 'saves and restores locale' do
+      I18n.locale = 'fr'
+      msg = {}
+      mw = Sidekiq::Middleware::I18n::Client.new
+      mw.call(nil, msg, nil, nil) { }
+      assert_equal :fr, msg['locale']
+
+      msg['locale'] = 'jp'
+      I18n.locale = I18n.default_locale
+      assert_equal :en, I18n.locale
+      mw = Sidekiq::Middleware::I18n::Server.new
+      mw.call(nil, msg, nil) do
+        assert_equal :jp, I18n.locale
+      end
+      assert_equal :en, I18n.locale
+    end
+
+    it 'supports I18n.enforce_available_locales = true' do
+      I18n.enforce_available_locales = true
+      I18n.available_locales = [:en, :jp]
+
+      msg = { 'locale' => 'jp' }
+      mw = Sidekiq::Middleware::I18n::Server.new
+      mw.call(nil, msg, nil) do
+        assert_equal :jp, I18n.locale
+      end
+
+      I18n.enforce_available_locales = false
+      I18n.available_locales = nil
+    end
+  end
+end