sidekiq 3.5.4 → 7.2.0

data/test/test_extensions.rb

@@ -1,126 +0,0 @@
-require_relative 'helper'
-require 'sidekiq'
-require 'active_record'
-require 'action_mailer'
-require 'sidekiq/extensions/action_mailer'
-require 'sidekiq/extensions/active_record'
-require 'sidekiq/rails'
-
-Sidekiq.hook_rails!
-
-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 '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
-
-    it 'allows removing of the #delay methods' do
-      q = Sidekiq::Queue.new
-      Sidekiq.remove_delay!
-      assert_equal 0, q.size
-      assert_raises NoMethodError do
-        SomeModule.delay.doit(Date.today)
-      end
-
-      Sidekiq.instance_eval { remove_instance_variable :@delay_removed }
-      # Reload modified modules
-      load 'sidekiq/extensions/action_mailer.rb'
-      load 'sidekiq/extensions/active_record.rb'
-      load 'sidekiq/extensions/generic_proxy.rb'
-      load 'sidekiq/extensions/class_methods.rb'
-    end
-  end
-
-end

data/test/test_fetch.rb

@@ -1,104 +0,0 @@
-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.message
-      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', 1]
-    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
-
-    describe 'fetching' do
-      before do
-        Sidekiq::Fetcher.reset
-      end
-
-      it 'instantiates' do
-        begin
-          Sidekiq.options[:fetch] = NullFetch
-          mgr = Minitest::Mock.new
-          fetch = Sidekiq::Fetcher.new(mgr, {})
-          fetch.fetch
-          Sidekiq::Fetcher.done!
-        ensure
-          Sidekiq.options[:fetch] = Sidekiq::BasicFetch
-        end
-      end
-
-      class NullFetch
-        def initialize(opts)
-        end
-        def retrieve_work
-        end
-        def self.bulk_requeue(*args)
-        end
-      end
-
-      it 'handles redis network errors' do
-        begin
-          Sidekiq.logger.level = Logger::FATAL
-          Sidekiq.options[:fetch] = ErrorFetch
-          mgr = Minitest::Mock.new
-          fetch = Sidekiq::Fetcher.new(mgr, {})
-          def fetch.pause
-          end
-          refute fetch.down
-          fetch.fetch
-          Sidekiq::Fetcher.done!
-          assert fetch.down
-        ensure
-          Sidekiq.options[:fetch] = Sidekiq::BasicFetch
-          Sidekiq.logger.level = Logger::ERROR
-        end
-      end
-
-      class ErrorFetch
-        def initialize(opts)
-        end
-        def retrieve_work
-          raise IOError, "ker-BOOM"
-        end
-        def self.bulk_requeue(*args)
-        end
-      end
-    end
-
-  end
-end

data/test/test_logging.rb

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

data/test/test_manager.rb

@@ -1,168 +0,0 @@
-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)
-      condvar = Minitest::Mock.new
-      condvar.expect(:signal, nil, [])
-      Sidekiq::Manager.new(condvar, opts)
-    end
-
-    it 'creates N processor instances' do
-      mgr = new_manager(options)
-      assert_equal options[:concurrency], mgr.ready.size
-      assert_equal [], mgr.busy
-    end
-
-    it 'assigns work to a processor' do
-      uow = Object.new
-      processor = Minitest::Mock.new
-      processor.expect(:async, processor, [])
-      processor.expect(:process, nil, [uow])
-
-      mgr = new_manager(options)
-      mgr.ready << processor
-      mgr.assign(uow)
-      assert_equal 1, mgr.busy.size
-
-      processor.verify
-    end
-
-    it 'requeues work if stopping' do
-      uow = Minitest::Mock.new
-      uow.expect(:requeue, nil, [])
-
-      mgr = new_manager(options)
-      mgr.fetcher = Sidekiq::BasicFetch.new({:queues => []})
-      mgr.stop
-      mgr.assign(uow)
-      uow.verify
-    end
-
-    it 'shuts down the system' do
-      mgr = new_manager(options)
-      mgr.fetcher = Sidekiq::BasicFetch.new({:queues => []})
-      mgr.stop
-
-      assert mgr.busy.empty?
-      assert mgr.ready.empty?
-    end
-
-    it 'returns finished processors to the ready pool' do
-      fetcher = MiniTest::Mock.new
-      fetcher.expect :async, fetcher, []
-      fetcher.expect :fetch, nil, []
-      mgr = new_manager(options)
-      mgr.fetcher = fetcher
-      init_size = mgr.ready.size
-      processor = mgr.ready.pop
-      mgr.busy << processor
-      mgr.processor_done(processor)
-
-      assert_equal 0, mgr.busy.size
-      assert_equal init_size, mgr.ready.size
-      fetcher.verify
-    end
-
-    it 'throws away dead processors' do
-      fetcher = MiniTest::Mock.new
-      fetcher.expect :async, fetcher, []
-      fetcher.expect :fetch, nil, []
-      mgr = new_manager(options)
-      mgr.fetcher = fetcher
-      init_size = mgr.ready.size
-      processor = mgr.ready.pop
-      mgr.busy << processor
-      mgr.processor_died(processor, 'ignored')
-
-      assert_equal 0, mgr.busy.size
-      assert_equal init_size, mgr.ready.size
-      refute mgr.ready.include?(processor)
-      fetcher.verify
-    end
-
-    it 'does not support invalid concurrency' do
-      assert_raises(ArgumentError) { new_manager(concurrency: 0) }
-      assert_raises(ArgumentError) { new_manager(concurrency: -1) }
-    end
-
-    describe 'heartbeat' do
-      before do
-        uow = Object.new
-
-        @processor = Minitest::Mock.new
-        @processor.expect(:async, @processor, [])
-        @processor.expect(:process, nil, [uow])
-
-        @mgr = new_manager(options)
-        @mgr.ready << @processor
-        @mgr.assign(uow)
-
-        @processor.verify
-        @proctitle = $0
-      end
-
-      after do
-        $0 = @proctitle
-      end
-
-      describe 'when manager is active' do
-        before do
-          Sidekiq::Manager::PROCTITLES << proc { "xyz" }
-          @mgr.heartbeat('identity', heartbeat_data, Sidekiq.dump_json(heartbeat_data))
-          Sidekiq::Manager::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('identity', 'busy') }
-          assert_equal ["1"], info
-          expires = Sidekiq.redis { |c| c.pttl('identity') }
-          assert_in_delta 60000, expires, 500
-        end
-      end
-
-      describe 'when manager is stopped' do
-        before do
-          @processor.expect(:alive?, [])
-          @processor.expect(:terminate, [])
-
-          @mgr.stop
-          @mgr.processor_done(@processor)
-          @mgr.heartbeat('identity', heartbeat_data, Sidekiq.dump_json(heartbeat_data))
-
-          @processor.verify
-        end
-
-        it 'indicates stopping status in proctitle' do
-          assert_equal "sidekiq #{Sidekiq::VERSION} myapp [0 of 3 busy] stopping", $0
-        end
-
-        it 'stores process info in redis' do
-          info = Sidekiq.redis { |c| c.hmget('identity', 'busy') }
-          assert_equal ["0"], info
-          expires = Sidekiq.redis { |c| c.pttl('identity') }
-          assert_in_delta 60000, expires, 50
-        end
-      end
-    end
-
-    def options
-      { :concurrency => 3, :queues => ['default'] }
-    end
-
-    def heartbeat_data
-      { 'concurrency' => 3, 'tag' => 'myapp' }
-    end
-  end
-
-end

data/test/test_middleware.rb

@@ -1,159 +0,0 @@
-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
-      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(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 Sidekiq::Middleware::Server::RetryJobs
-      chain.add Sidekiq::Middleware::Server::RetryJobs, {:max_retries => 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_equal 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