sidekiq 3.5.4 → 5.2.7

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

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