sidekiq 2.14.1 → 2.15.0

data/sidekiq.gemspec

@@ -17,12 +17,12 @@ Gem::Specification.new do |gem|
   gem.add_dependency                  'redis', '>= 3.0.4'
   gem.add_dependency                  'redis-namespace', '>= 1.3.1'
   gem.add_dependency                  'connection_pool', '>= 1.0.0'
-  gem.add_dependency                  'celluloid', '>= 0.14.1'
+  gem.add_dependency                  'celluloid', '>= 0.15.1'
   gem.add_dependency                  'json'
   gem.add_development_dependency      'sinatra'
-  gem.add_development_dependency      'minitest', '~> 5'
+  gem.add_development_dependency      'minitest', '~> 4.2'
   gem.add_development_dependency      'rake'
-  gem.add_development_dependency      'actionmailer', '>= 3.0.0'
-  gem.add_development_dependency      'activerecord', '>= 3.0.0'
+  gem.add_development_dependency      'actionmailer', '>= 4.0.0'
+  gem.add_development_dependency      'activerecord', '>= 4.0.0'
   gem.add_development_dependency      'coveralls'
 end

data/test/helper.rb

@@ -25,6 +25,8 @@ require 'sidekiq'
 require 'sidekiq/util'
 Sidekiq.logger.level = Logger::ERROR
 
+Sidekiq::Test = MiniTest::Unit::TestCase
+
 require 'sidekiq/redis_connection'
 redis_url = ENV['REDIS_URL'] || 'redis://localhost/15'
 REDIS = Sidekiq::RedisConnection.create(:url => redis_url, :namespace => 'testy')
@@ -32,3 +34,9 @@ REDIS = Sidekiq::RedisConnection.create(:url => redis_url, :namespace => 'testy'
 Sidekiq.configure_client do |config|
   config.redis = { :url => redis_url, :namespace => 'testy' }
 end
+
+Celluloid.class_eval do
+  def self.shutdown
+    $stderr.puts "Celluloid shutdown disabled"
+  end
+end

data/test/test_api.rb

@@ -1,6 +1,6 @@
 require 'helper'
 
-class TestApi < Minitest::Test
+class TestApi < Sidekiq::Test
   describe "stats" do
     before do
       Sidekiq.redis {|c| c.flushdb }

data/test/test_cli.rb

@@ -11,7 +11,7 @@ def cli.valid?
   !@code
 end
 
-class TestCli < Minitest::Test
+class TestCli < Sidekiq::Test
   describe 'with cli' do
 
     before do

data/test/test_client.rb

@@ -2,7 +2,7 @@ require 'helper'
 require 'sidekiq/client'
 require 'sidekiq/worker'
 
-class TestClient < Minitest::Test
+class TestClient < Sidekiq::Test
   describe 'with mock redis' do
     before do
       @redis = Minitest::Mock.new
@@ -70,7 +70,7 @@ class TestClient < Minitest::Test
     end
 
     it 'has default options' do
-      assert_equal Sidekiq::Worker::ClassMethods::DEFAULT_OPTIONS, MyWorker.get_sidekiq_options
+      assert_equal Sidekiq.default_worker_options, MyWorker.get_sidekiq_options
     end
 
     it 'handles perform_async' do
@@ -101,6 +101,27 @@ class TestClient < Minitest::Test
       @redis.verify
     end
 
+    it 'enqueues messages to redis (delayed, custom queue)' do
+      @redis.expect :zadd, 1, ['schedule', Array]
+      pushed = Sidekiq::Client.enqueue_to_in(:custom_queue, 3.minutes, MyWorker, 1, 2)
+      assert pushed
+      @redis.verify
+    end
+
+    it 'enqueues messages to redis (delayed into past, custom queue)' do
+      @redis.expect :lpush, 1, ['queue:custom_queue', Array]
+      pushed = Sidekiq::Client.enqueue_to_in(:custom_queue, -3.minutes, MyWorker, 1, 2)
+      assert pushed
+      @redis.verify
+    end
+
+    it 'enqueues messages to redis (delayed)' do
+      @redis.expect :zadd, 1, ['schedule', Array]
+      pushed = Sidekiq::Client.enqueue_in(3.minutes, MyWorker, 1, 2)
+      assert pushed
+      @redis.verify
+    end
+
     class QueuedWorker
       include Sidekiq::Worker
       sidekiq_options :queue => :flimflam

data/test/test_exception_handler.rb

@@ -17,7 +17,7 @@ class Component
   end
 end
 
-class TestExceptionHandler < Minitest::Test
+class TestExceptionHandler < Sidekiq::Test
   describe "with mock logger" do
     before do
       @old_logger = Sidekiq.logger

data/test/test_extensions.rb

@@ -8,7 +8,7 @@ require 'sidekiq/rails'
 
 Sidekiq.hook_rails!
 
-class TestExtensions < Minitest::Test
+class TestExtensions < Sidekiq::Test
   describe 'sidekiq extensions' do
     before do
       Sidekiq.redis = REDIS

data/test/test_fetch.rb

@@ -1,7 +1,7 @@
 require 'helper'
 require 'sidekiq/fetch'
 
-class TestFetcher < Minitest::Test
+class TestFetcher < Sidekiq::Test
   describe 'fetcher' do
     before do
       Sidekiq.redis = { :namespace => 'fuzzy' }

data/test/test_manager.rb

@@ -1,29 +1,13 @@
 require 'helper'
 require 'sidekiq/manager'
 
-class TestManager < Minitest::Test
+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
-      assert mgr.fetcher
-    end
-
-    it 'fetches upon start' do
-      mgr = Sidekiq::Manager.new(options)
-      count = options[:concurrency]
-
-      fetch_mock = Minitest::Mock.new
-      count.times { fetch_mock.expect(:fetch, nil, []) }
-      async_mock = Minitest::Mock.new
-      count.times { async_mock.expect(:async, fetch_mock, []) }
-      mgr.fetcher = async_mock
-      mgr.start
-
-      fetch_mock.verify
-      async_mock.verify
     end
 
     it 'assigns work to a processor' do
@@ -56,11 +40,14 @@ class TestManager < Minitest::Test
 
       assert mgr.busy.empty?
       assert mgr.ready.empty?
-      refute mgr.fetcher.alive?
     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
@@ -68,10 +55,15 @@ class TestManager < Minitest::Test
 
       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
@@ -80,6 +72,7 @@ class TestManager < Minitest::Test
       assert_equal 0, mgr.busy.size
       assert_equal init_size, mgr.ready.size
       refute mgr.ready.include?(processor)
+      fetcher.verify
     end
 
     def options

data/test/test_middleware.rb

@@ -2,7 +2,7 @@ require 'helper'
 require 'sidekiq/middleware/chain'
 require 'sidekiq/processor'
 
-class TestMiddleware < Minitest::Test
+class TestMiddleware < Sidekiq::Test
   describe 'middleware chain' do
     before do
       $errors = []

data/test/test_processor.rb

@@ -1,7 +1,7 @@
 require 'helper'
 require 'sidekiq/processor'
 
-class TestProcessor < Minitest::Test
+class TestProcessor < Sidekiq::Test
   TestException = Class.new(StandardError)
   TEST_EXCEPTION = TestException.new("kerboom!")
 

data/test/test_redis_connection.rb

@@ -1,7 +1,7 @@
 require 'helper'
 require 'sidekiq/redis_connection'
 
-class TestRedisConnection < Minitest::Test
+class TestRedisConnection < Sidekiq::Test
 
   describe ".create" do
 
@@ -14,7 +14,7 @@ class TestRedisConnection < Minitest::Test
       it "sets a custom network_timeout if specified" do
         pool = Sidekiq::RedisConnection.create(:network_timeout => 8)
         redis = pool.checkout
-        
+
         assert_equal 8, redis.client.timeout
       end
 
@@ -42,7 +42,7 @@ class TestRedisConnection < Minitest::Test
     describe "pool_timeout" do
       it "uses a given :timeout over the default of 1" do
         pool = Sidekiq::RedisConnection.create(:pool_timeout => 5)
-        
+
         assert_equal 5, pool.instance_eval{ @timeout }
       end
 

data/test/test_retry.rb

@@ -2,7 +2,7 @@ require 'helper'
 require 'sidekiq/scheduled'
 require 'sidekiq/middleware/server/retry_jobs'
 
-class TestRetry < Minitest::Test
+class TestRetry < Sidekiq::Test
   describe 'middleware' do
     before do
       @redis = Minitest::Mock.new

data/test/test_scheduled.rb

@@ -1,7 +1,7 @@
 require 'helper'
 require 'sidekiq/scheduled'
 
-class TestScheduled < Minitest::Test
+class TestScheduled < Sidekiq::Test
   class ScheduledWorker
     include Sidekiq::Worker
     def perform(x)

data/test/test_scheduling.rb

@@ -1,18 +1,19 @@
 require 'helper'
 require 'sidekiq/scheduled'
 
-class TestScheduling < Minitest::Test
+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
@@ -29,6 +30,13 @@ class TestScheduling < Minitest::Test
       @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)

data/test/test_sidekiq.rb

@@ -1,7 +1,7 @@
 # encoding: utf-8
 require 'helper'
 
-class TestSidekiq < Minitest::Test
+class TestSidekiq < Sidekiq::Test
   describe 'json processing' do
     it 'loads json' do
       assert_equal ({"foo" => "bar"}), Sidekiq.load_json("{\"foo\":\"bar\"}")
@@ -34,4 +34,4 @@ class TestSidekiq < Minitest::Test
       assert_equal "Calm down, bro\n", $stdout.string
     end
   end
-end
+end

data/test/test_testing.rb

@@ -9,261 +9,74 @@ require 'sidekiq/extensions/active_record'
 
 Sidekiq.hook_rails!
 
-class TestTesting < Minitest::Test
+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
+    describe 'require/load sidekiq/testing.rb' do
+      before do
+        require 'sidekiq/testing.rb'
       end
-    end
 
-    class FooModel < ActiveRecord::Base
-      def bar(str)
-        str
+      after do
+        Sidekiq::Testing.disable!
       end
-    end
-
-    before do
-      load 'sidekiq/testing.rb'
-      EnqueuedWorker.jobs.clear
-      DirectWorker.jobs.clear
-    end
 
-    after do
-      # Undo override
-      (class << Sidekiq::Client; self; end).class_eval do
-        remove_method :raw_push
-        alias_method :raw_push, :raw_push_old
-        remove_method :raw_push_old
+      it 'enables fake testing' do
+        Sidekiq::Testing.fake!
+        assert_equal true, Sidekiq::Testing.enabled?
+        assert_equal true, Sidekiq::Testing.fake?
       end
-    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
+      it 'enables fake testing in a block' do
+        Sidekiq::Testing.disable!
+        assert_equal true, Sidekiq::Testing.disabled?
 
-    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)
+        Sidekiq::Testing.fake! do
+          assert_equal true, Sidekiq::Testing.enabled?
+          assert_equal true, Sidekiq::Testing.fake?
+        end
 
-      assert_equal 2, StoredWorker.jobs.size
-      assert_raises PerformError do
-        StoredWorker.drain
+        assert_equal false, Sidekiq::Testing.enabled?
+        assert_equal false, Sidekiq::Testing.fake?
       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 'disables testing in a block' do
+        Sidekiq::Testing.fake!
 
-    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]
+        Sidekiq::Testing.disable! do
+          assert_equal true, Sidekiq::Testing.disabled?
         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
+        assert_equal true, Sidekiq::Testing.enabled?
       end
     end
 
-    class FirstWorker
-      include Sidekiq::Worker
-      class_attribute :count
-      self.count = 0
-      def perform
-        self.class.count += 1
+    describe 'require/load sidekiq/testing/inline.rb' do
+      before do
+        require 'sidekiq/testing/inline.rb'
       end
-    end
 
-    class SecondWorker
-      include Sidekiq::Worker
-      class_attribute :count
-      self.count = 0
-      def perform
-        self.class.count += 1
+      after do
+        Sidekiq::Testing.disable!
       end
-    end
 
-    class ThirdWorker
-      include Sidekiq::Worker
-      class_attribute :count
-      def perform
-        FirstWorker.perform_async
-        SecondWorker.perform_async
+      it 'enables inline testing' do
+        Sidekiq::Testing.inline!
+        assert_equal true, Sidekiq::Testing.enabled?
+        assert_equal true, Sidekiq::Testing.inline?
       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 'enables inline testing in a block' do
+        Sidekiq::Testing.disable!
+        assert_equal true, Sidekiq::Testing.disabled?
 
-    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
+        Sidekiq::Testing.inline! do
+          assert_equal true, Sidekiq::Testing.enabled?
+          assert_equal true, Sidekiq::Testing.inline?
+        end
 
-      assert_equal 1, FirstWorker.count
-      assert_equal 1, SecondWorker.count
+        assert_equal false, Sidekiq::Testing.enabled?
+        assert_equal false, Sidekiq::Testing.inline?
+      end
     end
   end
 end