sidekiq 2.15.1 → 4.2.10

data/test/test_scheduled.rb

@@ -1,86 +0,0 @@
-require 'helper'
-require 'sidekiq/scheduled'
-
-class TestScheduled < Sidekiq::Test
-  class ScheduledWorker
-    include Sidekiq::Worker
-    def perform(x)
-    end
-  end
-
-  describe 'poller' do
-    before do
-      Sidekiq.redis = REDIS
-      Sidekiq.redis do |conn|
-        conn.flushdb
-      end
-
-      @error_1  = { 'class' => ScheduledWorker.name, 'args' => [0], 'queue' => 'queue_1' }
-      @error_2  = { 'class' => ScheduledWorker.name, 'args' => [1], 'queue' => 'queue_2' }
-      @error_3  = { 'class' => ScheduledWorker.name, 'args' => [2], 'queue' => 'queue_3' }
-      @future_1 = { 'class' => ScheduledWorker.name, 'args' => [3], 'queue' => 'queue_4' }
-      @future_2 = { 'class' => ScheduledWorker.name, 'args' => [4], 'queue' => 'queue_5' }
-      @future_3 = { 'class' => ScheduledWorker.name, 'args' => [5], 'queue' => 'queue_6' }
-
-      @retry = Sidekiq::RetrySet.new
-      @scheduled = Sidekiq::ScheduledSet.new
-      @poller = Sidekiq::Scheduled::Poller.new
-    end
-
-    class Stopper
-      def call(worker_class, message, queue)
-        yield if message['args'].first.odd?
-      end
-    end
-
-    it 'executes client middleware' do
-      Sidekiq.client_middleware.add Stopper
-      begin
-        @retry.schedule (Time.now - 60).to_f, @error_1
-        @retry.schedule (Time.now - 60).to_f, @error_2
-        @scheduled.schedule (Time.now - 60).to_f, @future_2
-        @scheduled.schedule (Time.now - 60).to_f, @future_3
-
-        @poller.poll
-
-        Sidekiq.redis do |conn|
-          assert_equal 0, conn.llen("queue:queue_1")
-          assert_equal 1, conn.llen("queue:queue_2")
-          assert_equal 0, conn.llen("queue:queue_5")
-          assert_equal 1, conn.llen("queue:queue_6")
-        end
-      ensure
-        Sidekiq.client_middleware.remove Stopper
-      end
-    end
-
-    it 'should empty the retry and scheduled queues up to the current time' do
-      enqueued_time = Time.new(2013, 2, 4)
-
-      Time.stub(:now, enqueued_time) do
-        @retry.schedule (Time.now - 60).to_f, @error_1
-        @retry.schedule (Time.now - 50).to_f, @error_2
-        @retry.schedule (Time.now + 60).to_f, @error_3
-        @scheduled.schedule (Time.now - 60).to_f, @future_1
-        @scheduled.schedule (Time.now - 50).to_f, @future_2
-        @scheduled.schedule (Time.now + 60).to_f, @future_3
-
-        @poller.poll
-
-        Sidekiq.redis do |conn|
-          assert_equal 1, conn.llen("queue:queue_1")
-          assert_equal enqueued_time.to_f, Sidekiq.load_json(conn.lrange("queue:queue_1", 0, -1)[0])['enqueued_at']
-          assert_equal 1, conn.llen("queue:queue_2")
-          assert_equal enqueued_time.to_f, Sidekiq.load_json(conn.lrange("queue:queue_2", 0, -1)[0])['enqueued_at']
-          assert_equal 1, conn.llen("queue:queue_4")
-          assert_equal enqueued_time.to_f, Sidekiq.load_json(conn.lrange("queue:queue_4", 0, -1)[0])['enqueued_at']
-          assert_equal 1, conn.llen("queue:queue_5")
-          assert_equal enqueued_time.to_f, Sidekiq.load_json(conn.lrange("queue:queue_5", 0, -1)[0])['enqueued_at']
-        end
-
-        assert_equal 1, @retry.size
-        assert_equal 1, @scheduled.size
-      end
-    end
-  end
-end

data/test/test_scheduling.rb

@@ -1,47 +0,0 @@
-require 'helper'
-require 'sidekiq/scheduled'
-
-class TestScheduling < Sidekiq::Test
-  describe 'middleware' do
-    before do
-      @redis = Minitest::Mock.new
-      # Ugh, this is terrible.
-      Sidekiq.instance_variable_set(:@redis, @redis)
-      def @redis.multi; [yield] * 2 if block_given?; end
-      def @redis.with; yield self; end
-    end
-
-    class ScheduledWorker
-      include Sidekiq::Worker
-      sidekiq_options :queue => :custom_queue
-      def perform(x)
-      end
-    end
-
-    it 'schedules a job via interval' do
-      @redis.expect :zadd, true, ['schedule', Array]
-      assert ScheduledWorker.perform_in(600, 'mike')
-      @redis.verify
-    end
-
-    it 'schedules a job via timestamp' do
-      @redis.expect :zadd, true, ['schedule', Array]
-      assert ScheduledWorker.perform_in(5.days.from_now, 'mike')
-      @redis.verify
-    end
-
-    it 'schedules job right away on negative timestamp/interval' do
-      @redis.expect :sadd,  true, ['queues', :custom_queue]
-      @redis.expect :lpush, true, ['queue:custom_queue', Array]
-      assert ScheduledWorker.perform_in(-300, 'mike')
-      @redis.verify
-    end
-
-    it 'schedules multiple jobs at once' do
-      @redis.expect :zadd, true, ['schedule', Array]
-      assert Sidekiq::Client.push_bulk('class' => ScheduledWorker, 'args' => [['mike'], ['mike']], 'at' => 600)
-      @redis.verify
-    end
-  end
-
-end

data/test/test_sidekiq.rb

@@ -1,37 +0,0 @@
-# encoding: utf-8
-require 'helper'
-
-class TestSidekiq < Sidekiq::Test
-  describe 'json processing' do
-    it 'loads json' do
-      assert_equal ({"foo" => "bar"}), Sidekiq.load_json("{\"foo\":\"bar\"}")
-    end
-
-    it 'dumps json' do
-      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
-      mock = Minitest::Mock.new
-      mock.expect :create, nil #Sidekiq::RedisConnection, create
-  		assert_raises(ArgumentError) {
-  			Sidekiq.redis
-  		}
-      assert_raises(MockExpectationError, "create should not be called") do
-        mock.verify
-      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, bro\n", $stdout.string
-    end
-  end
-end

data/test/test_testing.rb

@@ -1,82 +0,0 @@
-require 'helper'
-require 'sidekiq'
-require 'sidekiq/worker'
-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.rb'
-      end
-
-      after do
-        Sidekiq::Testing.disable!
-      end
-
-      it 'enables fake testing' do
-        Sidekiq::Testing.fake!
-        assert_equal true, Sidekiq::Testing.enabled?
-        assert_equal true, Sidekiq::Testing.fake?
-      end
-
-      it 'enables fake testing in a block' do
-        Sidekiq::Testing.disable!
-        assert_equal true, Sidekiq::Testing.disabled?
-
-        Sidekiq::Testing.fake! do
-          assert_equal true, Sidekiq::Testing.enabled?
-          assert_equal true, Sidekiq::Testing.fake?
-        end
-
-        assert_equal false, Sidekiq::Testing.enabled?
-        assert_equal false, Sidekiq::Testing.fake?
-      end
-
-      it 'disables testing in a block' do
-        Sidekiq::Testing.fake!
-
-        Sidekiq::Testing.disable! do
-          assert_equal true, Sidekiq::Testing.disabled?
-        end
-
-        assert_equal true, Sidekiq::Testing.enabled?
-      end
-    end
-
-    describe 'require/load sidekiq/testing/inline.rb' do
-      before do
-        require 'sidekiq/testing/inline.rb'
-      end
-
-      after do
-        Sidekiq::Testing.disable!
-      end
-
-      it 'enables inline testing' do
-        Sidekiq::Testing.inline!
-        assert_equal true, Sidekiq::Testing.enabled?
-        assert_equal true, Sidekiq::Testing.inline?
-      end
-
-      it 'enables inline testing in a block' do
-        Sidekiq::Testing.disable!
-        assert_equal true, Sidekiq::Testing.disabled?
-
-        Sidekiq::Testing.inline! do
-          assert_equal true, Sidekiq::Testing.enabled?
-          assert_equal true, Sidekiq::Testing.inline?
-        end
-
-        assert_equal false, Sidekiq::Testing.enabled?
-        assert_equal false, Sidekiq::Testing.inline?
-      end
-    end
-  end
-end

data/test/test_testing_fake.rb

@@ -1,265 +0,0 @@
-require 'helper'
-require 'sidekiq'
-require 'sidekiq/worker'
-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.rb'
-      Sidekiq::Testing.fake!
-      EnqueuedWorker.jobs.clear
-      DirectWorker.jobs.clear
-    end
-
-    after do
-      Sidekiq::Testing.disable!
-    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, EnqueuedWorker.jobs.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
-  end
-end