sidekiq 3.5.0 → 3.5.1

data/test/test_cli.rb

@@ -168,35 +168,14 @@ class TestCli < Sidekiq::Test
         @cli.parse(['sidekiq', '-C', './test/config.yml'])
       end
 
-      it 'takes a path' do
+      it 'parses as expected' do
         assert_equal './test/config.yml', Sidekiq.options[:config_file]
-      end
-
-      it 'sets verbose' do
         refute Sidekiq.options[:verbose]
-      end
-
-      it 'sets require file' do
         assert_equal './test/fake_env.rb', Sidekiq.options[:require]
-      end
-
-      it 'does not set environment' do
         assert_equal nil, Sidekiq.options[:environment]
-      end
-
-      it 'sets concurrency' do
         assert_equal 50, Sidekiq.options[:concurrency]
-      end
-
-      it 'sets pid file' do
         assert_equal '/tmp/sidekiq-config-test.pid', Sidekiq.options[:pidfile]
-      end
-
-      it 'sets logfile' do
         assert_equal '/tmp/sidekiq.log', Sidekiq.options[:logfile]
-      end
-
-      it 'sets queues' do
         assert_equal 2, Sidekiq.options[:queues].count { |q| q == 'very_often' }
         assert_equal 1, Sidekiq.options[:queues].count { |q| q == 'seldom' }
       end
@@ -207,35 +186,14 @@ class TestCli < Sidekiq::Test
         @cli.parse(['sidekiq', '-e', 'staging', '-C', './test/env_based_config.yml'])
       end
 
-      it 'takes a path' do
+      it 'parses as expected' do
         assert_equal './test/env_based_config.yml', Sidekiq.options[:config_file]
-      end
-
-      it 'sets verbose' do
         refute Sidekiq.options[:verbose]
-      end
-
-      it 'sets require file' do
         assert_equal './test/fake_env.rb', Sidekiq.options[:require]
-      end
-
-      it 'sets environment' do
         assert_equal 'staging', Sidekiq.options[:environment]
-      end
-
-      it 'sets concurrency' do
         assert_equal 5, Sidekiq.options[:concurrency]
-      end
-
-      it 'sets pid file' do
         assert_equal '/tmp/sidekiq-config-test.pid', Sidekiq.options[:pidfile]
-      end
-
-      it 'sets logfile' do
         assert_equal '/tmp/sidekiq.log', Sidekiq.options[:logfile]
-      end
-
-      it 'sets queues' do
         assert_equal 2, Sidekiq.options[:queues].count { |q| q == 'very_often' }
         assert_equal 1, Sidekiq.options[:queues].count { |q| q == 'seldom' }
       end
@@ -297,23 +255,11 @@ class TestCli < Sidekiq::Test
         File.unlink @tmp_path if File.exist? @tmp_path
       end
 
-      it 'uses concurrency flag' do
+      it 'gives the expected options' do
         assert_equal 100, Sidekiq.options[:concurrency]
-      end
-
-      it 'uses require file flag' do
         assert_equal @tmp_lib_path, Sidekiq.options[:require]
-      end
-
-      it 'uses environment flag' do
         assert_equal 'snoop', Sidekiq.options[:environment]
-      end
-
-      it 'uses pidfile flag' do
         assert_equal @tmp_path, Sidekiq.options[:pidfile]
-      end
-
-      it 'sets queues' do
         assert_equal 7, Sidekiq.options[:queues].count { |q| q == 'often' }
         assert_equal 3, Sidekiq.options[:queues].count { |q| q == 'seldom' }
       end

data/test/test_client.rb

@@ -1,33 +1,7 @@
 require_relative 'helper'
-require 'sidekiq/client'
-require 'sidekiq/worker'
 
 class TestClient < Sidekiq::Test
-  describe 'with mock redis' do
-    before do
-      @redis = Minitest::Mock.new
-      def @redis.multi; [yield] * 2 if block_given?; end
-      def @redis.set(*); true; end
-      def @redis.sadd(*); true; end
-      def @redis.srem(*); true; end
-      def @redis.get(*); nil; end
-      def @redis.del(*); nil; end
-      def @redis.incrby(*); nil; end
-      def @redis.setex(*); true; end
-      def @redis.expire(*); true; end
-      def @redis.watch(*); true; end
-      def @redis.with_connection; yield self; end
-      def @redis.with; yield self; end
-      def @redis.exec; true; end
-      Sidekiq.instance_variable_set(:@redis, @redis)
-      Sidekiq::Client.instance_variable_set(:@default, nil)
-    end
-
-    after do
-      Sidekiq.redis = REDIS
-      Sidekiq::Client.instance_variable_set(:@default, nil)
-    end
-
+  describe 'errors' do
     it 'raises ArgumentError with invalid params' do
       assert_raises ArgumentError do
         Sidekiq::Client.push('foo', 1)
@@ -49,112 +23,71 @@ class TestClient < Sidekiq::Test
         Sidekiq::Client.push('queue' => 'foo', 'class' => MyWorker, 'args' => 1)
       end
     end
+  end
 
-    describe 'as instance' do
-      it 'can push' do
-        @redis.expect :lpush, 1, ['queue:default', Array]
-        client = Sidekiq::Client.new
-        jid = client.push('class' => 'Blah', 'args' => [1,2,3])
-        assert_equal 24, jid.size
-      end
-
-      it 'allows local middleware modification' do
-        @redis.expect :lpush, 1, ['queue:default', Array]
-        $called = false
-        mware = Class.new { def call(worker_klass,msg,q,r); $called = true; msg;end }
-        client = Sidekiq::Client.new
-        client.middleware do |chain|
-          chain.add mware
-        end
-        client.push('class' => 'Blah', 'args' => [1,2,3])
+  describe 'as instance' do
+    it 'can push' do
+      client = Sidekiq::Client.new
+      jid = client.push('class' => 'Blah', 'args' => [1,2,3])
+      assert_equal 24, jid.size
+    end
 
-        assert $called
-        assert client.middleware.exists?(mware)
-        refute Sidekiq.client_middleware.exists?(mware)
+    it 'allows local middleware modification' do
+      $called = false
+      mware = Class.new { def call(worker_klass,msg,q,r); $called = true; msg;end }
+      client = Sidekiq::Client.new
+      client.middleware do |chain|
+        chain.add mware
       end
+      client.push('class' => 'Blah', 'args' => [1,2,3])
+
+      assert $called
+      assert client.middleware.exists?(mware)
+      refute Sidekiq.client_middleware.exists?(mware)
     end
+  end
 
+  describe 'client' do
     it 'pushes messages to redis' do
-      @redis.expect :lpush, 1, ['queue:foo', Array]
-      pushed = Sidekiq::Client.push('queue' => 'foo', 'class' => MyWorker, 'args' => [1, 2])
-      assert pushed
-      assert_equal 24, pushed.size
-      @redis.verify
+      q = Sidekiq::Queue.new('foo')
+      pre = q.size
+      jid = Sidekiq::Client.push('queue' => 'foo', 'class' => MyWorker, 'args' => [1, 2])
+      assert jid
+      assert_equal 24, jid.size
+      assert_equal pre + 1, q.size
     end
 
     it 'pushes messages to redis using a String class' do
-      @redis.expect :lpush, 1, ['queue:foo', Array]
-      pushed = Sidekiq::Client.push('queue' => 'foo', 'class' => 'MyWorker', 'args' => [1, 2])
-      assert pushed
-      assert_equal 24, pushed.size
-      @redis.verify
+      q = Sidekiq::Queue.new('foo')
+      pre = q.size
+      jid = Sidekiq::Client.push('queue' => 'foo', 'class' => 'MyWorker', 'args' => [1, 2])
+      assert jid
+      assert_equal 24, jid.size
+      assert_equal pre + 1, q.size
     end
 
     class MyWorker
       include Sidekiq::Worker
     end
 
-    it 'has default options' do
-      assert_equal Sidekiq.default_worker_options, MyWorker.get_sidekiq_options
-    end
-
-    it 'handles perform_async' do
-      @redis.expect :lpush, 1, ['queue:default', Array]
-      pushed = MyWorker.perform_async(1, 2)
-      assert pushed
-      @redis.verify
-    end
-
-    it 'enqueues messages to redis' do
-      @redis.expect :lpush, 1, ['queue:default', Array]
-      pushed = Sidekiq::Client.enqueue(MyWorker, 1, 2)
-      assert pushed
-      @redis.verify
-    end
-
-    it 'enqueues messages to redis' do
-      @redis.expect :lpush, 1, ['queue:custom_queue', Array]
-      pushed = Sidekiq::Client.enqueue_to(:custom_queue, MyWorker, 1, 2)
-      assert pushed
-      @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
     end
 
-    it 'enqueues to the named queue' do
-      @redis.expect :lpush, 1, ['queue:flimflam', Array]
-      pushed = QueuedWorker.perform_async(1, 2)
-      assert pushed
-      @redis.verify
-    end
-
-    it 'retrieves queues' do
-      @redis.expect :smembers, ['bob'], ['queues']
-      assert_equal ['bob'], Sidekiq::Queue.all.map(&:name)
+    it 'enqueues' do
+      Sidekiq.redis {|c| c.flushdb }
+      assert_equal Sidekiq.default_worker_options, MyWorker.get_sidekiq_options
+      assert MyWorker.perform_async(1, 2)
+      assert Sidekiq::Client.enqueue(MyWorker, 1, 2)
+      assert Sidekiq::Client.enqueue_to(:custom_queue, MyWorker, 1, 2)
+      assert_equal 1, Sidekiq::Queue.new('custom_queue').size
+      assert Sidekiq::Client.enqueue_to_in(:custom_queue, 3.minutes, MyWorker, 1, 2)
+      assert Sidekiq::Client.enqueue_to_in(:custom_queue, -3.minutes, MyWorker, 1, 2)
+      assert_equal 2, Sidekiq::Queue.new('custom_queue').size
+      assert Sidekiq::Client.enqueue_in(3.minutes, MyWorker, 1, 2)
+      assert QueuedWorker.perform_async(1, 2)
+      assert_equal 1, Sidekiq::Queue.new('flimflam').size
     end
   end
 
@@ -191,24 +124,23 @@ class TestClient < Sidekiq::Test
   end
 
   describe 'client middleware' do
-
     class Stopper
-      def call(worker_class, message, queue, r)
+      def call(worker_class, job, queue, r)
         raise ArgumentError unless r
-        yield if message['args'].first.odd?
+        yield if job['args'].first.odd?
       end
     end
 
     it 'can stop some of the jobs from pushing' do
-      Sidekiq.client_middleware.add Stopper
-      begin
-        assert_equal nil, Sidekiq::Client.push('class' => MyWorker, 'args' => [0])
-        assert_match(/[0-9a-f]{12}/, Sidekiq::Client.push('class' => MyWorker, 'args' => [1]))
-        Sidekiq::Client.push_bulk('class' => MyWorker, 'args' => [[0], [1]]).each do |jid|
-          assert_match(/[0-9a-f]{12}/, jid)
-        end
-      ensure
-        Sidekiq.client_middleware.remove Stopper
+      client = Sidekiq::Client.new
+      client.middleware do |chain|
+        chain.add Stopper
+      end
+
+      assert_equal nil, client.push('class' => MyWorker, 'args' => [0])
+      assert_match(/[0-9a-f]{12}/, client.push('class' => MyWorker, 'args' => [1]))
+      client.push_bulk('class' => MyWorker, 'args' => [[0], [1]]).each do |jid|
+        assert_match(/[0-9a-f]{12}/, jid)
       end
     end
   end
@@ -220,19 +152,10 @@ class TestClient < Sidekiq::Test
     end
   end
 
-  describe 'item normalization' do
-    it 'defaults retry to true' do
-      assert_equal true, Sidekiq::Client.new.__send__(:normalize_item, 'class' => QueuedWorker, 'args' => [])['retry']
-    end
-
-    it "does not normalize numeric retry's" do
-      assert_equal 2, Sidekiq::Client.new.__send__(:normalize_item, 'class' => CWorker, 'args' => [])['retry']
-    end
-  end
-
   describe 'sharding' do
     class DWorker < BaseWorker
     end
+
     it 'allows sidekiq_options to point to different Redi' do
       conn = MiniTest::Mock.new
       conn.expect(:multi, [0, 1])
@@ -240,6 +163,7 @@ class TestClient < Sidekiq::Test
       DWorker.perform_async(1,2,3)
       conn.verify
     end
+
     it 'allows #via to point to different Redi' do
       conn = MiniTest::Mock.new
       conn.expect(:multi, [0, 1])
@@ -257,6 +181,7 @@ class TestClient < Sidekiq::Test
       assert_equal default, Sidekiq::Client.new.redis_pool
       conn.verify
     end
+
     it 'allows Resque helpers to point to different Redi' do
       conn = MiniTest::Mock.new
       conn.expect(:multi, []) { |*args, &block| block.call }

data/test/test_extensions.rb

@@ -23,30 +23,34 @@ class TestExtensions < Sidekiq::Test
 
     it 'allows delayed execution of ActiveRecord class methods' do
       assert_equal [], Sidekiq::Queue.all.map(&:name)
-      assert_equal 0, Sidekiq.redis {|c| c.llen('queue:default') }
+      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, Sidekiq.redis {|c| c.llen('queue:default') }
+      assert_equal 1, q.size
     end
 
     it 'uses and stringifies specified options' do
       assert_equal [], Sidekiq::Queue.all.map(&:name)
-      assert_equal 0, Sidekiq.redis {|c| c.llen('queue:notdefault') }
+      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, Sidekiq.redis {|c| c.llen('queue:notdefault') }
+      assert_equal 1, q.size
     end
 
     it 'allows delayed scheduling of AR class methods' do
-      assert_equal 0, Sidekiq.redis {|c| c.zcard('schedule') }
+      ss = Sidekiq::ScheduledSet.new
+      assert_equal 0, ss.size
       MyModel.delay_for(5.days).long_class_method
-      assert_equal 1, Sidekiq.redis {|c| c.zcard('schedule') }
+      assert_equal 1, ss.size
     end
 
     it 'allows until delayed scheduling of AR class methods' do
-      assert_equal 0, Sidekiq.redis {|c| c.zcard('schedule') }
+      ss = Sidekiq::ScheduledSet.new
+      assert_equal 0, ss.size
       MyModel.delay_until(1.day.from_now).long_class_method
-      assert_equal 1, Sidekiq.redis {|c| c.zcard('schedule') }
+      assert_equal 1, ss.size
     end
 
     class UserMailer < ActionMailer::Base
@@ -57,22 +61,25 @@ class TestExtensions < Sidekiq::Test
 
     it 'allows delayed delivery of ActionMailer mails' do
       assert_equal [], Sidekiq::Queue.all.map(&:name)
-      assert_equal 0, Sidekiq.redis {|c| c.llen('queue:default') }
+      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, Sidekiq.redis {|c| c.llen('queue:default') }
+      assert_equal 1, q.size
     end
 
     it 'allows delayed scheduling of AM mails' do
-      assert_equal 0, Sidekiq.redis {|c| c.zcard('schedule') }
+      ss = Sidekiq::ScheduledSet.new
+      assert_equal 0, ss.size
       UserMailer.delay_for(5.days).greetings(1, 2)
-      assert_equal 1, Sidekiq.redis {|c| c.zcard('schedule') }
+      assert_equal 1, ss.size
     end
 
     it 'allows until delay scheduling of AM mails' do
-      assert_equal 0, Sidekiq.redis {|c| c.zcard('schedule') }
+      ss = Sidekiq::ScheduledSet.new
+      assert_equal 0, ss.size
       UserMailer.delay_until(5.days.from_now).greetings(1, 2)
-      assert_equal 1, Sidekiq.redis {|c| c.zcard('schedule') }
+      assert_equal 1, ss.size
     end
 
     class SomeClass
@@ -81,9 +88,10 @@ class TestExtensions < Sidekiq::Test
     end
 
     it 'allows delay of any ole class method' do
-      assert_equal 0, queue_size
+      q = Sidekiq::Queue.new
+      assert_equal 0, q.size
       SomeClass.delay.doit(Date.today)
-      assert_equal 1, queue_size
+      assert_equal 1, q.size
     end
 
     module SomeModule
@@ -92,18 +100,16 @@ class TestExtensions < Sidekiq::Test
     end
 
     it 'allows delay of any module class method' do
-      assert_equal 0, queue_size
+      q = Sidekiq::Queue.new
+      assert_equal 0, q.size
       SomeModule.delay.doit(Date.today)
-      assert_equal 1, queue_size
-    end
-
-    def queue_size(name='default')
-      Sidekiq::Queue.new(name).size
+      assert_equal 1, q.size
     end
 
     it 'allows removing of the #delay methods' do
+      q = Sidekiq::Queue.new
       Sidekiq.remove_delay!
-      assert_equal 0, queue_size
+      assert_equal 0, q.size
       assert_raises NoMethodError do
         SomeModule.delay.doit(Date.today)
       end