sidekiq 4.2.4 → 5.2.10

data/test/test_sidekiq.rb

@@ -1,107 +0,0 @@
-# frozen_string_literal: true
-# encoding: utf-8
-require_relative 'helper'
-
-class TestSidekiq < Sidekiq::Test
-  describe 'json processing' do
-    it 'handles json' do
-      assert_equal({"foo" => "bar"}, Sidekiq.load_json("{\"foo\":\"bar\"}"))
-      assert_equal "{\"foo\":\"bar\"}", Sidekiq.dump_json({ "foo" => "bar" })
-    end
-  end
-
-  describe "redis connection" do
-  	it "returns error without creating a connection if block is not given" do
-  		assert_raises(ArgumentError) do
-  			Sidekiq.redis
-      end
-  	end
-  end
-
-  describe "❨╯°□°❩╯︵┻━┻" do
-    before { $stdout = StringIO.new }
-    after  { $stdout = STDOUT }
-
-    it "allows angry developers to express their emotional constitution and remedies it" do
-      Sidekiq.❨╯°□°❩╯︵┻━┻
-      assert_equal "Calm down, yo.\n", $stdout.string
-    end
-  end
-
-  describe 'lifecycle events' do
-    it 'handles invalid input' do
-      Sidekiq.options[:lifecycle_events][:startup].clear
-
-      e = assert_raises ArgumentError do
-        Sidekiq.on(:startp)
-      end
-      assert_match(/Invalid event name/, e.message)
-      e = assert_raises ArgumentError do
-        Sidekiq.on('startup')
-      end
-      assert_match(/Symbols only/, e.message)
-      Sidekiq.on(:startup) do
-        1 + 1
-      end
-
-      assert_equal 2, Sidekiq.options[:lifecycle_events][:startup].first.call
-    end
-  end
-
-  describe 'default_worker_options' do
-    it 'stringifies keys' do
-      @old_options = Sidekiq.default_worker_options
-      begin
-        Sidekiq.default_worker_options = { queue: 'cat'}
-        assert_equal 'cat', Sidekiq.default_worker_options['queue']
-      ensure
-        Sidekiq.default_worker_options = @old_options
-      end
-    end
-  end
-
-  describe 'error handling' do
-    it 'deals with user-specified error handlers which raise errors' do
-      output = capture_logging do
-        begin
-          Sidekiq.error_handlers << proc {|x, hash|
-            raise 'boom'
-          }
-          cli = Sidekiq::CLI.new
-          cli.handle_exception(RuntimeError.new("hello"))
-        ensure
-          Sidekiq.error_handlers.pop
-        end
-      end
-      assert_includes output, "boom"
-      assert_includes output, "ERROR"
-    end
-  end
-
-  describe 'redis connection' do
-    it 'does not continually retry' do
-      assert_raises Redis::CommandError do
-        Sidekiq.redis do |c|
-          raise Redis::CommandError, "READONLY You can't write against a read only slave."
-        end
-      end
-    end
-
-    it 'reconnects if connection is flagged as readonly' do
-      counts = []
-      Sidekiq.redis do |c|
-        counts << c.info['total_connections_received'].to_i
-        raise Redis::CommandError, "READONLY You can't write against a read only slave." if counts.size == 1
-      end
-      assert_equal 2, counts.size
-      assert_equal counts[0] + 1, counts[1]
-    end
-  end
-
-  describe 'redis info' do
-    it 'calls the INFO command which returns at least redis_version' do
-      output = Sidekiq.redis_info
-      assert_includes output.keys, "redis_version"
-    end
-  end
-end

data/test/test_testing.rb

@@ -1,143 +0,0 @@
-# frozen_string_literal: true
-require_relative 'helper'
-
-require 'active_record'
-require 'action_mailer'
-require 'sidekiq/rails'
-require 'sidekiq/extensions/action_mailer'
-require 'sidekiq/extensions/active_record'
-
-Sidekiq.hook_rails!
-
-class TestTesting < Sidekiq::Test
-  describe 'sidekiq testing' do
-    describe 'require/load sidekiq/testing.rb' do
-      before do
-        require 'sidekiq/testing'
-      end
-
-      after do
-        Sidekiq::Testing.disable!
-      end
-
-      it 'enables fake testing' do
-        Sidekiq::Testing.fake!
-        assert Sidekiq::Testing.enabled?
-        assert Sidekiq::Testing.fake?
-        refute Sidekiq::Testing.inline?
-      end
-
-      it 'enables fake testing in a block' do
-        Sidekiq::Testing.disable!
-        assert Sidekiq::Testing.disabled?
-        refute Sidekiq::Testing.fake?
-
-        Sidekiq::Testing.fake! do
-          assert Sidekiq::Testing.enabled?
-          assert Sidekiq::Testing.fake?
-          refute Sidekiq::Testing.inline?
-        end
-
-        refute Sidekiq::Testing.enabled?
-        refute Sidekiq::Testing.fake?
-      end
-
-      it 'disables testing in a block' do
-        Sidekiq::Testing.fake!
-        assert Sidekiq::Testing.fake?
-
-        Sidekiq::Testing.disable! do
-          refute Sidekiq::Testing.fake?
-          assert Sidekiq::Testing.disabled?
-        end
-
-        assert Sidekiq::Testing.fake?
-        assert Sidekiq::Testing.enabled?
-      end
-    end
-
-    describe 'require/load sidekiq/testing/inline.rb' do
-      before do
-        require 'sidekiq/testing/inline'
-      end
-
-      after do
-        Sidekiq::Testing.disable!
-      end
-
-      it 'enables inline testing' do
-        Sidekiq::Testing.inline!
-        assert Sidekiq::Testing.enabled?
-        assert Sidekiq::Testing.inline?
-        refute Sidekiq::Testing.fake?
-      end
-
-      it 'enables inline testing in a block' do
-        Sidekiq::Testing.disable!
-        assert Sidekiq::Testing.disabled?
-        refute Sidekiq::Testing.fake?
-
-        Sidekiq::Testing.inline! do
-          assert Sidekiq::Testing.enabled?
-          assert Sidekiq::Testing.inline?
-        end
-
-        refute Sidekiq::Testing.enabled?
-        refute Sidekiq::Testing.inline?
-        refute Sidekiq::Testing.fake?
-      end
-    end
-  end
-
-  describe 'with middleware' do
-    before do
-      require 'sidekiq/testing'
-    end
-
-    after do
-      Sidekiq::Testing.disable!
-    end
-
-    class AttributeWorker
-      include Sidekiq::Worker
-      class_attribute :count
-      self.count = 0
-      attr_accessor :foo
-
-      def perform
-        self.class.count += 1 if foo == :bar
-      end
-    end
-
-    class AttributeMiddleware
-      def call(worker, msg, queue)
-        worker.foo = :bar if worker.respond_to?(:foo=)
-        yield
-      end
-    end
-
-    it 'wraps the inlined worker with middleware' do
-      Sidekiq::Testing.server_middleware do |chain|
-        chain.add AttributeMiddleware
-      end
-
-      begin
-        Sidekiq::Testing.fake! do
-          AttributeWorker.perform_async
-          assert_equal 0, AttributeWorker.count
-        end
-
-        AttributeWorker.perform_one
-        assert_equal 1, AttributeWorker.count
-
-        Sidekiq::Testing.inline! do
-          AttributeWorker.perform_async
-          assert_equal 2, AttributeWorker.count
-        end
-      ensure
-        Sidekiq::Testing.server_middleware.clear
-      end
-    end
-  end
-
-end

data/test/test_testing_fake.rb

@@ -1,357 +0,0 @@
-# frozen_string_literal: true
-require_relative 'helper'
-
-require 'active_record'
-require 'action_mailer'
-require 'sidekiq/rails'
-require 'sidekiq/extensions/action_mailer'
-require 'sidekiq/extensions/active_record'
-
-Sidekiq.hook_rails!
-
-class TestTesting < Sidekiq::Test
-  describe 'sidekiq testing' do
-    class PerformError < RuntimeError; end
-
-    class DirectWorker
-      include Sidekiq::Worker
-      def perform(a, b)
-        a + b
-      end
-    end
-
-    class EnqueuedWorker
-      include Sidekiq::Worker
-      def perform(a, b)
-        a + b
-      end
-    end
-
-    class StoredWorker
-      include Sidekiq::Worker
-      def perform(error)
-        raise PerformError if error
-      end
-    end
-
-    class FooMailer < ActionMailer::Base
-      def bar(str)
-        str
-      end
-    end
-
-    class FooModel < ActiveRecord::Base
-      def bar(str)
-        str
-      end
-    end
-
-    before do
-      require 'sidekiq/testing'
-      Sidekiq::Testing.fake!
-      EnqueuedWorker.jobs.clear
-      DirectWorker.jobs.clear
-    end
-
-    after do
-      Sidekiq::Testing.disable!
-      Sidekiq::Queues.clear_all
-    end
-
-    it 'stubs the async call' do
-      assert_equal 0, DirectWorker.jobs.size
-      assert DirectWorker.perform_async(1, 2)
-      assert_equal 1, DirectWorker.jobs.size
-      assert DirectWorker.perform_in(10, 1, 2)
-      assert_equal 2, DirectWorker.jobs.size
-      assert DirectWorker.perform_at(10, 1, 2)
-      assert_equal 3, DirectWorker.jobs.size
-      assert_in_delta 10.seconds.from_now.to_f, DirectWorker.jobs.last['at'], 0.01
-    end
-
-    it 'stubs the delay call on mailers' do
-      assert_equal 0, Sidekiq::Extensions::DelayedMailer.jobs.size
-      FooMailer.delay.bar('hello!')
-      assert_equal 1, Sidekiq::Extensions::DelayedMailer.jobs.size
-    end
-
-    class Something
-      def self.foo(x)
-      end
-    end
-
-    it 'stubs the delay call on models' do
-      assert_equal 0, Sidekiq::Extensions::DelayedClass.jobs.size
-      Something.delay.foo(Date.today)
-      assert_equal 1, Sidekiq::Extensions::DelayedClass.jobs.size
-    end
-
-    it 'stubs the enqueue call' do
-      assert_equal 0, EnqueuedWorker.jobs.size
-      assert Sidekiq::Client.enqueue(EnqueuedWorker, 1, 2)
-      assert_equal 1, EnqueuedWorker.jobs.size
-    end
-
-    it 'stubs the enqueue_to call' do
-      assert_equal 0, EnqueuedWorker.jobs.size
-      assert Sidekiq::Client.enqueue_to('someq', EnqueuedWorker, 1, 2)
-      assert_equal 1, Sidekiq::Queues['someq'].size
-    end
-
-    it 'executes all stored jobs' do
-      assert StoredWorker.perform_async(false)
-      assert StoredWorker.perform_async(true)
-
-      assert_equal 2, StoredWorker.jobs.size
-      assert_raises PerformError do
-        StoredWorker.drain
-      end
-      assert_equal 0, StoredWorker.jobs.size
-    end
-
-    class SpecificJidWorker
-      include Sidekiq::Worker
-      class_attribute :count
-      self.count = 0
-      def perform(worker_jid)
-        return unless worker_jid == self.jid
-        self.class.count += 1
-      end
-    end
-
-    it 'execute only jobs with assigned JID' do
-      4.times do |i|
-        jid = SpecificJidWorker.perform_async(nil)
-        if i % 2 == 0
-          SpecificJidWorker.jobs[-1]["args"] = ["wrong_jid"]
-        else
-          SpecificJidWorker.jobs[-1]["args"] = [jid]
-        end
-      end
-
-      SpecificJidWorker.perform_one
-      assert_equal 0, SpecificJidWorker.count
-
-      SpecificJidWorker.perform_one
-      assert_equal 1, SpecificJidWorker.count
-
-      SpecificJidWorker.drain
-      assert_equal 2, SpecificJidWorker.count
-    end
-
-    it 'round trip serializes the job arguments' do
-      assert StoredWorker.perform_async(:mike)
-      job = StoredWorker.jobs.first
-      assert_equal "mike", job['args'].first
-      StoredWorker.clear
-    end
-
-    it 'perform_one runs only one job' do
-      DirectWorker.perform_async(1, 2)
-      DirectWorker.perform_async(3, 4)
-      assert_equal 2, DirectWorker.jobs.size
-
-      DirectWorker.perform_one
-      assert_equal 1, DirectWorker.jobs.size
-
-      DirectWorker.clear
-    end
-
-    it 'perform_one raise error upon empty queue' do
-      DirectWorker.clear
-      assert_raises Sidekiq::EmptyQueueError do
-        DirectWorker.perform_one
-      end
-    end
-
-    class FirstWorker
-      include Sidekiq::Worker
-      class_attribute :count
-      self.count = 0
-      def perform
-        self.class.count += 1
-      end
-    end
-
-    class SecondWorker
-      include Sidekiq::Worker
-      class_attribute :count
-      self.count = 0
-      def perform
-        self.class.count += 1
-      end
-    end
-
-    class ThirdWorker
-      include Sidekiq::Worker
-      class_attribute :count
-      def perform
-        FirstWorker.perform_async
-        SecondWorker.perform_async
-      end
-    end
-
-    it 'clears jobs across all workers' do
-      Sidekiq::Worker.jobs.clear
-      FirstWorker.count = 0
-      SecondWorker.count = 0
-
-      assert_equal 0, FirstWorker.jobs.size
-      assert_equal 0, SecondWorker.jobs.size
-
-      FirstWorker.perform_async
-      SecondWorker.perform_async
-
-      assert_equal 1, FirstWorker.jobs.size
-      assert_equal 1, SecondWorker.jobs.size
-
-      Sidekiq::Worker.clear_all
-
-      assert_equal 0, FirstWorker.jobs.size
-      assert_equal 0, SecondWorker.jobs.size
-
-      assert_equal 0, FirstWorker.count
-      assert_equal 0, SecondWorker.count
-    end
-
-    it 'drains jobs across all workers' do
-      Sidekiq::Worker.jobs.clear
-      FirstWorker.count = 0
-      SecondWorker.count = 0
-
-      assert_equal 0, FirstWorker.jobs.size
-      assert_equal 0, SecondWorker.jobs.size
-
-      assert_equal 0, FirstWorker.count
-      assert_equal 0, SecondWorker.count
-
-      FirstWorker.perform_async
-      SecondWorker.perform_async
-
-      assert_equal 1, FirstWorker.jobs.size
-      assert_equal 1, SecondWorker.jobs.size
-
-      Sidekiq::Worker.drain_all
-
-      assert_equal 0, FirstWorker.jobs.size
-      assert_equal 0, SecondWorker.jobs.size
-
-      assert_equal 1, FirstWorker.count
-      assert_equal 1, SecondWorker.count
-    end
-
-    it 'drains jobs across all workers even when workers create new jobs' do
-      Sidekiq::Worker.jobs.clear
-      FirstWorker.count = 0
-      SecondWorker.count = 0
-
-      assert_equal 0, ThirdWorker.jobs.size
-
-      assert_equal 0, FirstWorker.count
-      assert_equal 0, SecondWorker.count
-
-      ThirdWorker.perform_async
-
-      assert_equal 1, ThirdWorker.jobs.size
-
-      Sidekiq::Worker.drain_all
-
-      assert_equal 0, ThirdWorker.jobs.size
-
-      assert_equal 1, FirstWorker.count
-      assert_equal 1, SecondWorker.count
-    end
-
-    it 'drains jobs of workers with symbolized queue names' do
-      Sidekiq::Worker.jobs.clear
-
-      AltQueueWorker.perform_async(5,6)
-      assert_equal 1, AltQueueWorker.jobs.size
-
-      Sidekiq::Worker.drain_all
-      assert_equal 0, AltQueueWorker.jobs.size
-    end
-
-    it 'can execute a job' do
-      DirectWorker.execute_job(DirectWorker.new, [2, 3])
-    end
-  end
-
-  describe 'queue testing' do
-    before do
-      require 'sidekiq/testing'
-      Sidekiq::Testing.fake!
-    end
-
-    after do
-      Sidekiq::Testing.disable!
-      Sidekiq::Queues.clear_all
-    end
-
-    class QueueWorker
-      include Sidekiq::Worker
-      def perform(a, b)
-        a + b
-      end
-    end
-
-    class AltQueueWorker
-      include Sidekiq::Worker
-      sidekiq_options queue: :alt
-      def perform(a, b)
-        a + b
-      end
-    end
-
-    it 'finds enqueued jobs' do
-      assert_equal 0, Sidekiq::Queues["default"].size
-
-      QueueWorker.perform_async(1, 2)
-      QueueWorker.perform_async(1, 2)
-      AltQueueWorker.perform_async(1, 2)
-
-      assert_equal 2, Sidekiq::Queues["default"].size
-      assert_equal [1, 2], Sidekiq::Queues["default"].first["args"]
-
-      assert_equal 1, Sidekiq::Queues["alt"].size
-    end
-
-    it 'clears out all queues' do
-      assert_equal 0, Sidekiq::Queues["default"].size
-
-      QueueWorker.perform_async(1, 2)
-      QueueWorker.perform_async(1, 2)
-      AltQueueWorker.perform_async(1, 2)
-
-      Sidekiq::Queues.clear_all
-
-      assert_equal 0, Sidekiq::Queues["default"].size
-      assert_equal 0, QueueWorker.jobs.size
-      assert_equal 0, Sidekiq::Queues["alt"].size
-      assert_equal 0, AltQueueWorker.jobs.size
-    end
-
-    it 'finds jobs enqueued by client' do
-      Sidekiq::Client.push(
-        'class' => 'NonExistentWorker',
-        'queue' => 'missing',
-        'args' => [1]
-      )
-
-      assert_equal 1, Sidekiq::Queues["missing"].size
-    end
-
-    it 'respects underlying array changes' do
-      # Rspec expect change() syntax saves a reference to
-      # an underlying array. When the array containing jobs is
-      # derived, Rspec test using `change(QueueWorker.jobs, :size).by(1)`
-      # won't pass. This attempts to recreate that scenario
-      # by saving a reference to the jobs array and ensuring
-      # it changes properly on enqueueing
-      jobs = QueueWorker.jobs
-      assert_equal 0, jobs.size
-      QueueWorker.perform_async(1, 2)
-      assert_equal 1, jobs.size
-    end
-  end
-end

data/test/test_testing_inline.rb

@@ -1,94 +0,0 @@
-# frozen_string_literal: true
-require_relative 'helper'
-
-require 'active_record'
-require 'action_mailer'
-require 'sidekiq/rails'
-require 'sidekiq/extensions/action_mailer'
-require 'sidekiq/extensions/active_record'
-
-Sidekiq.hook_rails!
-
-class TestInline < Sidekiq::Test
-  describe 'sidekiq inline testing' do
-    class InlineError < RuntimeError; end
-    class ParameterIsNotString < RuntimeError; end
-
-    class InlineWorker
-      include Sidekiq::Worker
-      def perform(pass)
-        raise ArgumentError, "no jid" unless jid
-        raise InlineError unless pass
-      end
-    end
-
-    class InlineWorkerWithTimeParam
-      include Sidekiq::Worker
-      def perform(time)
-        raise ParameterIsNotString unless time.is_a?(String) || time.is_a?(Numeric)
-      end
-    end
-
-    class InlineFooMailer < ActionMailer::Base
-      def bar(str)
-        raise InlineError
-      end
-    end
-
-    class InlineFooModel < ActiveRecord::Base
-      def self.bar(str)
-        raise InlineError
-      end
-    end
-
-    before do
-      require 'sidekiq/testing/inline'
-      Sidekiq::Testing.inline!
-    end
-
-    after do
-      Sidekiq::Testing.disable!
-    end
-
-    it 'stubs the async call when in testing mode' do
-      assert InlineWorker.perform_async(true)
-
-      assert_raises InlineError do
-        InlineWorker.perform_async(false)
-      end
-    end
-
-    it 'stubs the delay call on mailers' do
-      assert_raises InlineError do
-        InlineFooMailer.delay.bar('three')
-      end
-    end
-
-    it 'stubs the delay call on models' do
-      assert_raises InlineError do
-        InlineFooModel.delay.bar('three')
-      end
-    end
-
-    it 'stubs the enqueue call when in testing mode' do
-      assert Sidekiq::Client.enqueue(InlineWorker, true)
-
-      assert_raises InlineError do
-        Sidekiq::Client.enqueue(InlineWorker, false)
-      end
-    end
-
-    it 'stubs the push_bulk call when in testing mode' do
-      assert Sidekiq::Client.push_bulk({'class' => InlineWorker, 'args' => [[true], [true]]})
-
-      assert_raises InlineError do
-        Sidekiq::Client.push_bulk({'class' => InlineWorker, 'args' => [[true], [false]]})
-      end
-    end
-
-    it 'should relay parameters through json' do
-      assert Sidekiq::Client.enqueue(InlineWorkerWithTimeParam, Time.now.to_f)
-    end
-
-  end
-end

data/test/test_util.rb

@@ -1,13 +0,0 @@
-# frozen_string_literal: true
-require_relative 'helper'
-
-class TestUtil < Sidekiq::Test
-
-  class Helpers
-    include Sidekiq::Util
-  end
-
-  def test_nothing_atm
-    assert true
-  end
-end