ruby on rails - sleep_delay - ¿Cómo probar los reintentos y los fallos en el reintento de reintento y en Rails 4?

rails job work

Question

Estoy tratando de escribir una especificación que pruebe la funcionalidad de reintento del reintento de reintento y parece que no puedo hacer que las pruebas alcancen el enlace .pry correctamente. ¿Hay alguna forma de probar esta funcionalidad utilizando rspec 3 para que pueda verificar que funcionan como es debido?

Esta es una especificación de solicitud y estoy tratando de simular una solicitud en vivo a través de dispositivos, pero no importa lo que intente, parece que no puedo volver a intentar el trabajo.

gem ''resque'', require: ''resque/server''
gem ''resque-web'', require: ''resque_web''
gem ''resque-scheduler''
gem ''resque-retry''
gem ''resque-lock-timeout''

Estoy usando resque_rspec y probando esta estrategia de prueba .

Especificaciones parciales

it ''retries it'' do
stub_request(:any, /.*api.bigcartel.*/).to_return(body: ''{}'', status: 200)
@order_shipped_json[''order''][''originator_id''] = @provider_order
post "/hook/shops/#{@shop.id}", @order_shipped_json.to_json, format: :json
ResqueSpec.perform_all(queue_name)
???
end

Trabajo en cola

class QueueHook
extend Resque::Plugins::LockTimeout
extend Resque::Plugins::Retry
extend QueueLock
extend QueueLogger
@queue = AppSettings.queues[:hook_queue_name].to_sym
@lock_timeout = 600
@retry_exceptions = [QueueError::LockFailed]
@retry_limit = 600
@retry_delay = 1
class << self
def perform(web_hook_payload_id, _whiplash_customer_id)
ActiveRecord::Base.clear_active_connections!
@web_hook_payload = WebHookPayload.find(web_hook_payload_id)
klass_constructor
@hook.process_event
end
def identifier(_web_hook_payload_id, whiplash_customer_id)
"lock:integration_hook:#{whiplash_customer_id}"
end
def after_perform_delete_webhook(_web_hook_payload_id, _whiplash_customer_id)
@web_hook_payload.destroy
end
private
...
end
end

Módulos de trabajo de cola

module QueueLogger
def before_perform_log_job(*args)
Rails.logger.info "[Resque][#{self}] running with #{args.inspect}..."
end
def on_failure_log_job(*args)
message = "[Resque][#{self}] failed with #{args.inspect}..."
run_counters
Rails.logger.info message_builder(message)
end
private
def run_counters
@num_attempts += retry_attempt
@all_attempts += retry_limit
end
def message_builder(message)
return message unless @num_attempts
return message += " Retrying (attempt ##{@num_attempts + 1})" if @num_attempts < @all_attempts
message += '' Giving up.''
message
end
end
module QueueLock
def loner_enqueue_failed(*args)
Rails.logger.info "[Resque][#{self}] is already enqueued: #{args.inspect}..."
end
def lock_failed(*)
raise QueueError::LockFailed
end
end

Answer 1

Por lo tanto, la falla específica por la que desea probar los reintentos proviene de este enlace que implementó.

def lock_failed(*)
raise QueueError::LockFailed
end

Necesitamos desencadenar esto. Here es donde se usa en el plugin. Ya que estás usando un tiempo de espera de bloqueo, parece que queremos .acquire_lock_algorithm! . Esto es peligroso ya que este método es parte de la API interna del complemento. Téngalo en cuenta cuando actualice el complemento.

it ''retries it'' do
stub_request(:any, /.*api.bigcartel.*/).to_return(body: ''{}'', status: 200)
allow(QueueHook).to receive(:acquire_lock_algorithm!).and_return(false, true)
@order_shipped_json[''order''][''originator_id''] = @provider_order
post "/hook/shops/#{@shop.id}", @order_shipped_json.to_json, format: :json
ResqueSpec.perform_all(queue_name)
end

Esta especificación ahora debería estar fallando con Failure/Error: raise QueueError::LockFailed . Como eso se espera podemos establecer una expectativa.

it ''retries it'' do
stub_request(:any, /.*api.bigcartel.*/).to_return(body: ''{}'', status: 200)
allow(QueueHook).to receive(:acquire_lock_algorithm!).and_return(false, true)
@order_shipped_json[''order''][''originator_id''] = @provider_order
post "/hook/shops/#{@shop.id}", @order_shipped_json.to_json, format: :json
expect {
ResqueSpec.perform_all(queue_name)
}.to raise_error(QueueError::LockFailed)
end

La especificación debería pasar ahora a menos que haya establecido ResqueSpec.inline = true . Si lo has hecho, configúralo en falso para esta especificación. Será más fácil de seguir.

Si el reintento de reintento está funcionando, la falla del trabajo debería haber dado como resultado que el trabajo se haya vuelto a poner en cola en ResqueSpec. Podemos agregar una expectativa para eso. expect(ResqueSpec.queues[queue_name]).to be_present . No podemos volver a ejecutar los trabajos. ¡Nos burlamos del segundo valor de retorno de acquire_lock_algorithm! para ser verdad por lo que el trabajo debe tener éxito esta vez.

Como queremos probar los contadores, vamos a agregar lectores para ellos.

module QueueLogger
attr_reader :all_attempts, :num_attempts
end

Y luego terminar la especificación ...

it ''retries it'' do
stub_request(:any, /.*api.bigcartel.*/).to_return(body: ''{}'', status: 200)
allow(QueueHook).to receive(:acquire_lock_algorithm!).and_return(false, true)
@order_shipped_json[''order''][''originator_id''] = @provider_order
post "/hook/shops/#{@shop.id}", @order_shipped_json.to_json, format: :json
# Failing
expect {
ResqueSpec.perform_all(queue_name)
}.to raise_error(QueueError::LockFailed)
expect(ResqueSpec.queues[queue_name]).to be_present
# Retrying
ResqueSpec.perform_all(queue_name)
expect(QueueHook.num_attempts).to eq(2)
... # Whatever else you want to test.
end

Si desea probar el registro específicamente, los apaga y establece expectativas con respecto a cómo se les llama. Eso debería hacerlo, tengo una versión simplificada que se ejecuta en mi propia máquina. Si no, podríamos tener que entrar en los detalles de su prueba y Resque Configs.

Answer 2

Unas pocas notas

1) Como lo mencionaron otros, es probable que desee separar las devoluciones de llamada de resque de su funcionalidad. Es decir, compruebe que los retries están activando, pero también pruebe por separado que funcionan como se espera. Es posible que desee separarlos en dos pruebas separadas.

2) Para verificar que están disparando, creo que está buscando dobles de clase en RSpec 3.

Deberá incluir el doble y luego generar una excepción ( docs ). Esto le permitirá ver si se están llamando sus retries y cuántas veces se han llamado ( docs ).

Así por ejemplo,

it "retries on exception n number of times" do
queue_hook = class_double("QueueHook")
expect(queue_hook).to have_received(:on_failure_log_job).exactly(n).times
allow(queue_hook).to receive(:perform).and_raise(ExceptionClass, "Exception message")
queue_hook.perform(payload_id, customer_id)
end

Hay un poco en juego, por lo que no puedo implementar localmente, pero espero que esto pueda ayudarlo a avanzar en la dirección correcta.