sidekiq 5.0.0.beta1 → 5.0.0.beta2

data/test/test_exception_handler.rb

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

@@ -1,115 +0,0 @@
-# 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

@@ -1,50 +0,0 @@
-# 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

@@ -1,92 +0,0 @@
-# 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

@@ -1,35 +0,0 @@
-# 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

@@ -1,50 +0,0 @@
-# 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

@@ -1,158 +0,0 @@
-# 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