1
0
Fork 0
mirror of https://github.com/mperham/sidekiq.git synced 2022-11-09 13:52:34 -05:00
mperham--sidekiq/lib/sidekiq/testing.rb

293 lines
7.5 KiB
Ruby
Raw Normal View History

require 'securerandom'
require 'sidekiq'
module Sidekiq
class Testing
class << self
attr_accessor :__test_mode
2014-10-09 09:55:07 -04:00
def __set_test_mode(mode)
if block_given?
current_mode = self.__test_mode
begin
self.__test_mode = mode
2014-10-09 09:55:07 -04:00
yield
ensure
self.__test_mode = current_mode
end
else
self.__test_mode = mode
end
end
def disable!(&block)
__set_test_mode(:disable, &block)
end
def fake!(&block)
__set_test_mode(:fake, &block)
end
def inline!(&block)
__set_test_mode(:inline, &block)
end
def enabled?
self.__test_mode != :disable
end
def disabled?
self.__test_mode == :disable
end
def fake?
self.__test_mode == :fake
end
def inline?
self.__test_mode == :inline
end
2015-09-04 18:35:33 -04:00
def server_middleware
@server_chain ||= Middleware::Chain.new
yield @server_chain if block_given?
@server_chain
end
end
end
# Default to fake testing to keep old behavior
Sidekiq::Testing.fake!
2013-05-30 14:39:01 -04:00
class EmptyQueueError < RuntimeError; end
class Client
alias_method :raw_push_real, :raw_push
def raw_push(payloads)
if Sidekiq::Testing.fake?
payloads.each do |job|
Queues.push(job['queue'], job['class'], Sidekiq.load_json(Sidekiq.dump_json(job)))
end
true
elsif Sidekiq::Testing.inline?
payloads.each do |job|
klass = job['class'].constantize
job['id'] ||= SecureRandom.hex(12)
job_hash = Sidekiq.load_json(Sidekiq.dump_json(job))
klass.process_job(job_hash)
end
true
else
raw_push_real(payloads)
end
end
end
module Queues
##
# The Queues class is only for testing the fake queue implementation.
# The data is structured as a hash with queue name as hash key and array
# of job data as the value.
#
# {
# "default"=>[
# {
# "class"=>"TestTesting::QueueWorker",
# "args"=>[1, 2],
# "retry"=>true,
# "queue"=>"default",
# "jid"=>"abc5b065c5c4b27fc1102833",
# "created_at"=>1447445554.419934
# }
# ]
# }
#
# Example:
#
# require 'sidekiq/testing'
#
# assert_equal 0, Sidekiq::Queues["default"].size
# HardWorker.perform_async(:something)
# assert_equal 1, Sidekiq::Queues["default"].size
# assert_equal :something, Sidekiq::Queues["default"].first['args'][0]
#
# You can also clear all workers' jobs:
#
# assert_equal 0, Sidekiq::Queues["default"].size
# HardWorker.perform_async(:something)
# Sidekiq::Queues.clear_all
# assert_equal 0, Sidekiq::Queues["default"].size
#
# This can be useful to make sure jobs don't linger between tests:
#
# RSpec.configure do |config|
# config.before(:each) do
# Sidekiq::Queues.clear_all
# end
# end
#
class << self
def [](queue)
jobs_by_queue[queue]
end
def push(queue, klass, job)
jobs_by_queue[queue] << job
jobs_by_worker[klass] << job
end
def jobs_by_queue
@jobs_by_queue ||= Hash.new { |hash, key| hash[key] = [] }
end
def jobs_by_worker
@jobs_by_worker ||= Hash.new { |hash, key| hash[key] = [] }
end
def delete_for(jid, queue, klass)
jobs_by_queue[queue].delete_if { |job| job["jid"] == jid }
jobs_by_worker[klass].delete_if { |job| job["jid"] == jid }
end
def clear_for(queue, klass)
jobs_by_queue[queue].clear
jobs_by_worker[klass].clear
end
def clear_all
jobs_by_queue.clear
jobs_by_worker.clear
end
end
end
module Worker
2012-02-10 23:30:14 -05:00
##
# The Sidekiq testing infrastructure overrides perform_async
2012-02-10 23:30:14 -05:00
# so that it does not actually touch the network. Instead it
# stores the asynchronous jobs in a per-class array so that
2012-02-10 23:30:14 -05:00
# their presence/absence can be asserted by your tests.
#
# This is similar to ActionMailer's :test delivery_method and its
# ActionMailer::Base.deliveries array.
#
# Example:
#
# require 'sidekiq/testing'
#
# assert_equal 0, HardWorker.jobs.size
# HardWorker.perform_async(:something)
# assert_equal 1, HardWorker.jobs.size
# assert_equal :something, HardWorker.jobs[0]['args'][0]
#
2012-04-05 23:06:47 -04:00
# assert_equal 0, Sidekiq::Extensions::DelayedMailer.jobs.size
2012-10-19 00:16:28 -04:00
# MyMailer.delay.send_welcome_email('foo@example.com')
# assert_equal 1, Sidekiq::Extensions::DelayedMailer.jobs.size
#
# You can also clear and drain all workers' jobs:
#
# assert_equal 0, Sidekiq::Extensions::DelayedMailer.jobs.size
# assert_equal 0, Sidekiq::Extensions::DelayedModel.jobs.size
#
# MyMailer.delay.send_welcome_email('foo@example.com')
# MyModel.delay.do_something_hard
#
2012-04-05 23:06:47 -04:00
# assert_equal 1, Sidekiq::Extensions::DelayedMailer.jobs.size
2012-10-19 00:16:28 -04:00
# assert_equal 1, Sidekiq::Extensions::DelayedModel.jobs.size
#
# Sidekiq::Worker.clear_all # or .drain_all
#
# assert_equal 0, Sidekiq::Extensions::DelayedMailer.jobs.size
# assert_equal 0, Sidekiq::Extensions::DelayedModel.jobs.size
#
# This can be useful to make sure jobs don't linger between tests:
#
# RSpec.configure do |config|
# config.before(:each) do
# Sidekiq::Worker.clear_all
# end
# end
#
# or for acceptance testing, i.e. with cucumber:
#
# AfterStep do
# Sidekiq::Worker.drain_all
# end
#
# When I sign up as "foo@example.com"
# Then I should receive a welcome email to "foo@example.com"
2012-04-05 23:06:47 -04:00
#
module ClassMethods
2012-02-10 23:30:14 -05:00
# Queue for this worker
def queue
self.sidekiq_options["queue"]
end
2012-10-19 00:16:28 -04:00
# Jobs queued for this worker
2012-02-10 23:30:14 -05:00
def jobs
Queues.jobs_by_worker[self.to_s]
end
2012-10-19 00:16:28 -04:00
# Clear all jobs for this worker
def clear
Queues.clear_for(queue, self.to_s)
2012-10-19 00:16:28 -04:00
end
# Drain and run all jobs for this worker
def drain
while jobs.any?
next_job = jobs.first
Queues.delete_for(next_job["jid"], queue, self.to_s)
process_job(next_job)
end
end
2013-05-30 01:06:08 -04:00
# Pop out a single job and perform it
def perform_one
2013-05-31 00:16:56 -04:00
raise(EmptyQueueError, "perform_one called with empty job queue") if jobs.empty?
next_job = jobs.first
Queues.delete_for(next_job["jid"], queue, self.to_s)
process_job(next_job)
2015-09-04 18:35:33 -04:00
end
def process_job(job)
worker = new
worker.jid = job['jid']
worker.bid = job['bid'] if worker.respond_to?(:bid=)
2015-09-04 18:35:33 -04:00
Sidekiq::Testing.server_middleware.invoke(worker, job, job['queue']) do
execute_job(worker, job['args'])
end
end
def execute_job(worker, args)
worker.perform(*args)
2013-05-30 01:06:08 -04:00
end
end
2012-10-19 00:16:28 -04:00
class << self
def jobs # :nodoc:
Queues.jobs_by_queue.values.flatten
2012-10-19 00:16:28 -04:00
end
# Clear all queued jobs across all workers
def clear_all
Queues.clear_all
2012-10-19 00:16:28 -04:00
end
# Drain all queued jobs across all workers
def drain_all
while jobs.any?
worker_classes = jobs.map { |job| job["class"] }.uniq
worker_classes.each do |worker_class|
worker_class.constantize.drain
end
end
2012-10-19 00:16:28 -04:00
end
end
end
end