2015-12-31 18:33:35 -05:00
|
|
|
# frozen_string_literal: true
|
2014-12-30 15:54:58 -05:00
|
|
|
require_relative 'helper'
|
2018-12-03 17:09:26 -05:00
|
|
|
require 'sidekiq/api'
|
2012-01-21 19:42:21 -05:00
|
|
|
|
2019-02-28 15:43:50 -05:00
|
|
|
describe Sidekiq::Client do
|
2015-09-22 15:48:43 -04:00
|
|
|
describe 'errors' do
|
2012-01-23 15:56:49 -05:00
|
|
|
it 'raises ArgumentError with invalid params' do
|
|
|
|
assert_raises ArgumentError do
|
|
|
|
Sidekiq::Client.push('foo', 1)
|
|
|
|
end
|
|
|
|
|
|
|
|
assert_raises ArgumentError do
|
|
|
|
Sidekiq::Client.push('foo', :class => 'Foo', :noargs => [1, 2])
|
|
|
|
end
|
2012-11-15 15:58:58 -05:00
|
|
|
|
|
|
|
assert_raises ArgumentError do
|
|
|
|
Sidekiq::Client.push('queue' => 'foo', 'class' => MyWorker, 'noargs' => [1, 2])
|
|
|
|
end
|
|
|
|
|
|
|
|
assert_raises ArgumentError do
|
|
|
|
Sidekiq::Client.push('queue' => 'foo', 'class' => 42, 'args' => [1, 2])
|
|
|
|
end
|
|
|
|
|
2013-01-05 04:32:05 -05:00
|
|
|
assert_raises ArgumentError do
|
|
|
|
Sidekiq::Client.push('queue' => 'foo', 'class' => MyWorker, 'args' => 1)
|
|
|
|
end
|
2017-03-23 14:05:20 -04:00
|
|
|
|
|
|
|
assert_raises ArgumentError do
|
|
|
|
Sidekiq::Client.push('queue' => 'foo', 'class' => MyWorker, 'args' => [1], 'at' => Time.now)
|
|
|
|
end
|
2013-10-26 00:07:54 -04:00
|
|
|
end
|
2015-09-22 15:48:43 -04:00
|
|
|
end
|
2013-10-26 00:07:54 -04:00
|
|
|
|
2015-09-22 15:48:43 -04:00
|
|
|
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
|
2013-10-26 00:07:54 -04:00
|
|
|
|
2016-03-16 12:26:07 -04:00
|
|
|
it 'allows middleware to stop bulk jobs' do
|
|
|
|
mware = Class.new do
|
|
|
|
def call(worker_klass,msg,q,r)
|
|
|
|
msg['args'][0] == 1 ? yield : false
|
|
|
|
end
|
|
|
|
end
|
|
|
|
client = Sidekiq::Client.new
|
|
|
|
client.middleware do |chain|
|
|
|
|
chain.add mware
|
|
|
|
end
|
|
|
|
q = Sidekiq::Queue.new
|
|
|
|
q.clear
|
|
|
|
result = client.push_bulk('class' => 'Blah', 'args' => [[1],[2],[3]])
|
|
|
|
assert_equal 1, result.size
|
|
|
|
assert_equal 1, q.size
|
|
|
|
end
|
|
|
|
|
2015-09-22 15:48:43 -04:00
|
|
|
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
|
2013-10-26 00:07:54 -04:00
|
|
|
end
|
2015-09-22 15:48:43 -04:00
|
|
|
client.push('class' => 'Blah', 'args' => [1,2,3])
|
|
|
|
|
|
|
|
assert $called
|
|
|
|
assert client.middleware.exists?(mware)
|
|
|
|
refute Sidekiq.client_middleware.exists?(mware)
|
2012-01-23 15:56:49 -05:00
|
|
|
end
|
2015-09-22 15:48:43 -04:00
|
|
|
end
|
2012-01-23 15:56:49 -05:00
|
|
|
|
2015-09-22 15:48:43 -04:00
|
|
|
describe 'client' do
|
2012-01-23 15:56:49 -05:00
|
|
|
it 'pushes messages to redis' do
|
2015-09-22 15:48:43 -04:00
|
|
|
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
|
2012-01-21 19:42:21 -05:00
|
|
|
end
|
|
|
|
|
2012-11-15 15:58:58 -05:00
|
|
|
it 'pushes messages to redis using a String class' do
|
2015-09-22 15:48:43 -04:00
|
|
|
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
|
2012-11-15 15:58:58 -05:00
|
|
|
end
|
|
|
|
|
2012-01-23 15:56:49 -05:00
|
|
|
class MyWorker
|
2012-01-25 16:53:00 -05:00
|
|
|
include Sidekiq::Worker
|
2012-01-23 15:56:49 -05:00
|
|
|
end
|
|
|
|
|
2012-02-10 23:20:01 -05:00
|
|
|
class QueuedWorker
|
|
|
|
include Sidekiq::Worker
|
2013-04-18 12:11:49 -04:00
|
|
|
sidekiq_options :queue => :flimflam
|
2012-02-10 23:20:01 -05:00
|
|
|
end
|
|
|
|
|
2015-09-22 15:48:43 -04:00
|
|
|
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
|
2018-12-03 17:09:26 -05:00
|
|
|
assert Sidekiq::Client.enqueue_to_in(:custom_queue, 3, MyWorker, 1, 2)
|
|
|
|
assert Sidekiq::Client.enqueue_to_in(:custom_queue, -3, MyWorker, 1, 2)
|
2015-09-22 15:48:43 -04:00
|
|
|
assert_equal 2, Sidekiq::Queue.new('custom_queue').size
|
2018-12-03 17:09:26 -05:00
|
|
|
assert Sidekiq::Client.enqueue_in(3, MyWorker, 1, 2)
|
2015-09-22 15:48:43 -04:00
|
|
|
assert QueuedWorker.perform_async(1, 2)
|
|
|
|
assert_equal 1, Sidekiq::Queue.new('flimflam').size
|
2012-02-15 14:28:19 -05:00
|
|
|
end
|
2012-01-21 19:42:21 -05:00
|
|
|
end
|
2012-06-16 23:56:55 -04:00
|
|
|
|
2012-09-13 20:38:56 -04:00
|
|
|
describe 'bulk' do
|
2013-01-06 00:17:08 -05:00
|
|
|
after do
|
|
|
|
Sidekiq::Queue.new.clear
|
|
|
|
end
|
2012-09-11 23:53:22 -04:00
|
|
|
it 'can push a large set of jobs at once' do
|
2013-11-05 12:17:30 -05:00
|
|
|
jids = Sidekiq::Client.push_bulk('class' => QueuedWorker, 'args' => (1..1_000).to_a.map { |x| Array(x) })
|
|
|
|
assert_equal 1_000, jids.size
|
2012-09-11 23:53:22 -04:00
|
|
|
end
|
2012-11-15 15:58:58 -05:00
|
|
|
it 'can push a large set of jobs at once using a String class' do
|
2013-11-05 12:17:30 -05:00
|
|
|
jids = Sidekiq::Client.push_bulk('class' => 'QueuedWorker', 'args' => (1..1_000).to_a.map { |x| Array(x) })
|
|
|
|
assert_equal 1_000, jids.size
|
|
|
|
end
|
|
|
|
it 'returns the jids for the jobs' do
|
|
|
|
Sidekiq::Client.push_bulk('class' => 'QueuedWorker', 'args' => (1..2).to_a.map { |x| Array(x) }).each do |jid|
|
2014-03-19 20:41:11 -04:00
|
|
|
assert_match(/[0-9a-f]{12}/, jid)
|
2013-11-05 12:17:30 -05:00
|
|
|
end
|
2012-11-15 15:58:58 -05:00
|
|
|
end
|
2016-05-31 13:05:16 -04:00
|
|
|
it 'handles no jobs' do
|
|
|
|
result = Sidekiq::Client.push_bulk('class' => 'QueuedWorker', 'args' => [])
|
|
|
|
assert_equal 0, result.size
|
|
|
|
end
|
2012-09-11 23:53:22 -04:00
|
|
|
end
|
|
|
|
|
2012-06-16 23:56:55 -04:00
|
|
|
class BaseWorker
|
|
|
|
include Sidekiq::Worker
|
|
|
|
sidekiq_options 'retry' => 'base'
|
|
|
|
end
|
|
|
|
class AWorker < BaseWorker
|
|
|
|
end
|
|
|
|
class BWorker < BaseWorker
|
|
|
|
sidekiq_options 'retry' => 'b'
|
|
|
|
end
|
2012-11-08 15:28:50 -05:00
|
|
|
class CWorker < BaseWorker
|
|
|
|
sidekiq_options 'retry' => 2
|
|
|
|
end
|
2012-06-16 23:56:55 -04:00
|
|
|
|
2012-09-13 00:22:13 -04:00
|
|
|
describe 'client middleware' do
|
|
|
|
class Stopper
|
2015-09-22 15:48:43 -04:00
|
|
|
def call(worker_class, job, queue, r)
|
2014-03-26 00:38:17 -04:00
|
|
|
raise ArgumentError unless r
|
2015-09-22 15:48:43 -04:00
|
|
|
yield if job['args'].first.odd?
|
2012-09-13 00:22:13 -04:00
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
it 'can stop some of the jobs from pushing' do
|
2015-09-22 15:48:43 -04:00
|
|
|
client = Sidekiq::Client.new
|
|
|
|
client.middleware do |chain|
|
|
|
|
chain.add Stopper
|
|
|
|
end
|
|
|
|
|
2017-01-02 15:06:02 -05:00
|
|
|
assert_nil client.push('class' => MyWorker, 'args' => [0])
|
2015-09-22 15:48:43 -04:00
|
|
|
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)
|
2012-09-13 00:22:13 -04:00
|
|
|
end
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2012-06-16 23:56:55 -04:00
|
|
|
describe 'inheritance' do
|
2012-11-08 14:34:56 -05:00
|
|
|
it 'inherits sidekiq options' do
|
2012-06-16 23:56:55 -04:00
|
|
|
assert_equal 'base', AWorker.get_sidekiq_options['retry']
|
|
|
|
assert_equal 'b', BWorker.get_sidekiq_options['retry']
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2014-03-25 14:56:15 -04:00
|
|
|
describe 'sharding' do
|
|
|
|
class DWorker < BaseWorker
|
|
|
|
end
|
2015-09-22 15:48:43 -04:00
|
|
|
|
2014-03-25 14:56:15 -04:00
|
|
|
it 'allows sidekiq_options to point to different Redi' do
|
|
|
|
conn = MiniTest::Mock.new
|
|
|
|
conn.expect(:multi, [0, 1])
|
|
|
|
DWorker.sidekiq_options('pool' => ConnectionPool.new(size: 1) { conn })
|
|
|
|
DWorker.perform_async(1,2,3)
|
|
|
|
conn.verify
|
|
|
|
end
|
2015-09-22 15:48:43 -04:00
|
|
|
|
2016-03-29 15:14:07 -04:00
|
|
|
it 'allows #via to point to same Redi' do
|
|
|
|
conn = MiniTest::Mock.new
|
|
|
|
conn.expect(:multi, [0, 1])
|
|
|
|
sharded_pool = ConnectionPool.new(size: 1) { conn }
|
|
|
|
Sidekiq::Client.via(sharded_pool) do
|
|
|
|
Sidekiq::Client.via(sharded_pool) do
|
|
|
|
CWorker.perform_async(1,2,3)
|
|
|
|
end
|
|
|
|
end
|
|
|
|
conn.verify
|
|
|
|
end
|
|
|
|
|
2014-03-26 23:35:57 -04:00
|
|
|
it 'allows #via to point to different Redi' do
|
2014-03-26 23:58:45 -04:00
|
|
|
default = Sidekiq::Client.new.redis_pool
|
2018-01-10 12:53:57 -05:00
|
|
|
|
|
|
|
moo = MiniTest::Mock.new
|
|
|
|
moo.expect(:multi, [0, 1])
|
|
|
|
beef = ConnectionPool.new(size: 1) { moo }
|
|
|
|
|
|
|
|
oink = MiniTest::Mock.new
|
|
|
|
oink.expect(:multi, [0, 1])
|
|
|
|
pork = ConnectionPool.new(size: 1) { oink }
|
|
|
|
|
|
|
|
Sidekiq::Client.via(beef) do
|
2014-03-26 23:35:57 -04:00
|
|
|
CWorker.perform_async(1,2,3)
|
2018-01-10 12:53:57 -05:00
|
|
|
assert_equal beef, Sidekiq::Client.new.redis_pool
|
|
|
|
Sidekiq::Client.via(pork) do
|
|
|
|
assert_equal pork, Sidekiq::Client.new.redis_pool
|
|
|
|
CWorker.perform_async(1,2,3)
|
2014-03-26 23:58:45 -04:00
|
|
|
end
|
2018-01-10 12:53:57 -05:00
|
|
|
assert_equal beef, Sidekiq::Client.new.redis_pool
|
2014-03-26 23:35:57 -04:00
|
|
|
end
|
2014-03-26 23:58:45 -04:00
|
|
|
assert_equal default, Sidekiq::Client.new.redis_pool
|
2018-01-10 12:53:57 -05:00
|
|
|
moo.verify
|
|
|
|
oink.verify
|
2014-03-26 23:35:57 -04:00
|
|
|
end
|
2015-09-22 15:48:43 -04:00
|
|
|
|
2014-03-25 14:56:15 -04:00
|
|
|
it 'allows Resque helpers to point to different Redi' do
|
|
|
|
conn = MiniTest::Mock.new
|
2014-08-31 17:15:06 -04:00
|
|
|
conn.expect(:multi, []) { |*args, &block| block.call }
|
2014-03-25 14:56:15 -04:00
|
|
|
conn.expect(:zadd, 1, [String, Array])
|
|
|
|
DWorker.sidekiq_options('pool' => ConnectionPool.new(size: 1) { conn })
|
|
|
|
Sidekiq::Client.enqueue_in(10, DWorker, 3)
|
|
|
|
conn.verify
|
|
|
|
end
|
|
|
|
end
|
2016-01-18 10:58:58 -05:00
|
|
|
|
2018-10-18 11:27:45 -04:00
|
|
|
describe 'class attribute race conditions' do
|
|
|
|
new_class = -> {
|
|
|
|
Class.new do
|
|
|
|
class_eval('include Sidekiq::Worker')
|
|
|
|
|
|
|
|
define_method(:foo) { get_sidekiq_options }
|
|
|
|
end
|
|
|
|
}
|
|
|
|
|
|
|
|
it 'does not explode when new initializing classes from multiple threads' do
|
2018-10-18 17:35:10 -04:00
|
|
|
100.times do
|
2018-10-18 11:27:45 -04:00
|
|
|
klass = new_class.call
|
|
|
|
|
|
|
|
t1 = Thread.new { klass.sidekiq_options({}) }
|
|
|
|
t2 = Thread.new { klass.sidekiq_options({}) }
|
|
|
|
t1.join
|
|
|
|
t2.join
|
|
|
|
end
|
|
|
|
end
|
|
|
|
end
|
2012-01-21 19:42:21 -05:00
|
|
|
end
|