sidekiq 2.15.1 → 4.2.10

data/test/test_exception_handler.rb

@@ -1,124 +0,0 @@
-require 'helper'
-require 'sidekiq'
-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
-  end
-
-  describe "with fake Airbrake" do
-    before do
-      ::Airbrake = Minitest::Mock.new
-    end
-
-    after do
-      Object.send(:remove_const, "Airbrake") # HACK should probably inject Airbrake etc into this class in the future
-    end
-
-    it "notifies Airbrake" do
-      ::Airbrake.expect(:notify_or_ignore,nil,[TEST_EXCEPTION,:parameters => { :a => 1 }])
-      Component.new.invoke_exception(:a => 1)
-      ::Airbrake.verify
-    end
-  end
-
-  describe "with fake Honeybadger" do
-    before do
-      ::Honeybadger = Minitest::Mock.new
-    end
-
-    after do
-      Object.send(:remove_const, "Honeybadger") # HACK should probably inject Honeybadger etc into this class in the future
-    end
-
-    it "notifies Honeybadger" do
-      ::Honeybadger.expect(:notify_or_ignore,nil,[TEST_EXCEPTION,:parameters => { :a => 1 }])
-      Component.new.invoke_exception(:a => 1)
-      ::Honeybadger.verify
-    end
-  end
-
-  describe "with fake ExceptionNotifier" do
-    before do
-      ::ExceptionNotifier = MiniTest::Mock.new
-    end
-
-    after do
-      Object.send(:remove_const, "ExceptionNotifier")
-    end
-
-    it "notifies ExceptionNotifier" do
-      ::ExceptionNotifier.expect(:notify_exception,true,[TEST_EXCEPTION, :data => { :message => { :b => 2 } }])
-      Component.new.invoke_exception(:b => 2)
-      ::ExceptionNotifier.verify
-    end
-  end
-
-  describe "with fake Exceptional" do
-    before do
-      ::Exceptional = Class.new do
-
-        def self.context(msg)
-          @msg = msg
-        end
-
-        def self.check_context
-          @msg
-        end
-      end
-
-      ::Exceptional::Config = Minitest::Mock.new
-      ::Exceptional::Remote = Minitest::Mock.new
-      ::Exceptional::ExceptionData = Minitest::Mock.new
-    end
-
-    after do
-      Object.send(:remove_const, "Exceptional")
-    end
-
-    it "notifies Exceptional" do
-      ::Exceptional::Config.expect(:should_send_to_api?,true)
-      exception_data = Object.new
-      ::Exceptional::Remote.expect(:error,nil,[exception_data])
-      ::Exceptional::ExceptionData.expect(:new,exception_data,[TEST_EXCEPTION])
-      Component.new.invoke_exception(:c => 3)
-      assert_equal({:c => 3},::Exceptional.check_context,"did not record arguments properly")
-      ::Exceptional::Config.verify
-      ::Exceptional::Remote.verify
-      ::Exceptional::ExceptionData.verify
-    end
-  end
-end

data/test/test_extensions.rb

@@ -1,105 +0,0 @@
-require '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::Client.registered_queues
-      assert_equal 0, Sidekiq.redis {|c| c.llen('queue:default') }
-      MyModel.delay.long_class_method
-      assert_equal ['default'], Sidekiq::Client.registered_queues
-      assert_equal 1, Sidekiq.redis {|c| c.llen('queue:default') }
-    end
-
-    it 'uses and stringifies specified options' do
-      assert_equal [], Sidekiq::Client.registered_queues
-      assert_equal 0, Sidekiq.redis {|c| c.llen('queue:notdefault') }
-      MyModel.delay(queue: :notdefault).long_class_method
-      assert_equal ['notdefault'], Sidekiq::Client.registered_queues
-      assert_equal 1, Sidekiq.redis {|c| c.llen('queue:notdefault') }
-    end
-
-    it 'allows delayed scheduling of AR class methods' do
-      assert_equal 0, Sidekiq.redis {|c| c.zcard('schedule') }
-      MyModel.delay_for(5.days).long_class_method
-      assert_equal 1, Sidekiq.redis {|c| c.zcard('schedule') }
-    end
-
-    it 'allows until delayed scheduling of AR class methods' do
-      assert_equal 0, Sidekiq.redis {|c| c.zcard('schedule') }
-      MyModel.delay_until(1.day.from_now).long_class_method
-      assert_equal 1, Sidekiq.redis {|c| c.zcard('schedule') }
-    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::Client.registered_queues
-      assert_equal 0, Sidekiq.redis {|c| c.llen('queue:default') }
-      UserMailer.delay.greetings(1, 2)
-      assert_equal ['default'], Sidekiq::Client.registered_queues
-      assert_equal 1, Sidekiq.redis {|c| c.llen('queue:default') }
-    end
-
-    it 'allows delayed scheduling of AM mails' do
-      assert_equal 0, Sidekiq.redis {|c| c.zcard('schedule') }
-      UserMailer.delay_for(5.days).greetings(1, 2)
-      assert_equal 1, Sidekiq.redis {|c| c.zcard('schedule') }
-    end
-
-    it 'allows until delay scheduling of AM mails' do
-      assert_equal 0, Sidekiq.redis {|c| c.zcard('schedule') }
-      UserMailer.delay_until(5.days.from_now).greetings(1, 2)
-      assert_equal 1, Sidekiq.redis {|c| c.zcard('schedule') }
-    end
-
-    class SomeClass
-      def self.doit(arg)
-      end
-    end
-
-    it 'allows delay of any ole class method' do
-      assert_equal 0, queue_size
-      SomeClass.delay.doit(Date.today)
-      assert_equal 1, queue_size
-    end
-
-    module SomeModule
-      def self.doit(arg)
-      end
-    end
-
-    it 'allows delay of any module class method' do
-      assert_equal 0, queue_size
-      SomeModule.delay.doit(Date.today)
-      assert_equal 1, queue_size
-    end
-
-    def queue_size(name='default')
-      Sidekiq::Queue.new(name).size
-    end
-  end
-
-end

data/test/test_fetch.rb

@@ -1,44 +0,0 @@
-require 'helper'
-require 'sidekiq/fetch'
-
-class TestFetcher < Sidekiq::Test
-  describe 'fetcher' do
-    before do
-      Sidekiq.redis = { :namespace => 'fuzzy' }
-      Sidekiq.redis do |conn|
-        conn.flushdb
-        conn.rpush('queue:basic', 'msg')
-      end
-    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')])
-      assert_equal 2, q1.size
-      assert_equal 1, q2.size
-    end
-  end
-end

data/test/test_manager.rb

@@ -1,83 +0,0 @@
-require 'helper'
-require 'sidekiq/manager'
-
-class TestManager < Sidekiq::Test
-
-  describe 'manager' do
-    it 'creates N processor instances' do
-      mgr = Sidekiq::Manager.new(options)
-      assert_equal options[:concurrency], mgr.ready.size
-      assert_equal [], mgr.busy
-    end
-
-    it 'assigns work to a processor' do
-      uow = Minitest::Mock.new
-      processor = Minitest::Mock.new
-      processor.expect(:async, processor, [])
-      processor.expect(:process, nil, [uow])
-
-      mgr = Sidekiq::Manager.new(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 = Sidekiq::Manager.new(options)
-      mgr.stop
-      mgr.assign(uow)
-      uow.verify
-    end
-
-    it 'shuts down the system' do
-      mgr = Sidekiq::Manager.new(options)
-      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 = Sidekiq::Manager.new(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 = Sidekiq::Manager.new(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
-
-    def options
-      { :concurrency => 3, :queues => ['default'] }
-    end
-  end
-
-end

data/test/test_middleware.rb

@@ -1,135 +0,0 @@
-require '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, Celluloid::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 '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'
-      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) { }
-      assert_equal :fr, msg['locale']
-
-      msg['locale'] = 'jp'
-      I18n.locale = nil
-      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
-  end
-end