ruby on rails - tests - ¿Cuál es la mejor práctica cuando se trata de probar “bucles infinitos”?

rspec rails tutorial

Question

Mi lógica básica es tener un bucle infinito corriendo en algún lugar y probarlo lo mejor posible. La razón para tener un bucle infinito no es importante (bucle principal para juegos, lógica tipo demonio ...) y estoy preguntando más acerca de las mejores prácticas en una situación como esa.

Tomemos este código por ejemplo:

module Blah
extend self
def run
some_initializer_method
loop do
some_other_method
yet_another_method
end
end
end

Quiero probar el método Blah.run usando Rspec (también uso RR , pero rspec simple sería una respuesta aceptable).

Creo que la mejor manera de hacerlo sería descomponer un poco más, como separar el bucle en otro método o algo así:

module Blah
extend self
def run
some_initializer_method
do_some_looping
end
def do_some_looping
loop do
some_other_method
yet_another_method
end
end
end

... esto nos permite probar la run y simular el bucle ... pero en algún punto es necesario probar el código dentro del bucle.

Entonces, ¿qué harías en tal situación?

¿Simplemente no está probando esta lógica, lo que significa probar un poco de otro some_other_method y yet_another_method some_other_method yet_another_method pero no un do_some_looping ?

¿Se ha roto el bucle en algún momento a través de un simulacro?

... ¿algo más?

Answer 1

¿Qué hay de burlarse del bucle para que se ejecute solo el número de veces que especifique?

Module Object
private
def loop
3.times { yield }
end
end

Por supuesto, te burlas de esto solo en tus especificaciones.

Answer 2

¿Qué tal si tenemos el cuerpo del bucle en un método separado, como la calculateOneWorldIteration ? De esa manera, puedes hacer el bucle en la prueba según sea necesario. Y no daña la API, es un método bastante natural para tener en la interfaz pública.

Answer 3

:) Tuve esta consulta hace unos meses.

La respuesta corta es que no hay una manera fácil de probar eso. Usted prueba la unidad interna del bucle. Luego lo colocas en un método de bucle y haces una prueba manual de que el bucle funciona hasta que se produce la condición de terminación.

Answer 4

Casi siempre uso una construcción catch / throw para probar bucles infinitos.

El aumento de un error también puede funcionar, pero eso no es ideal, especialmente si el bloqueo de su bucle rescata todos los errores, incluidas las excepciones. Si su bloque no recupera la Excepción (o alguna otra clase de error), puede subclase de Excepción (u otra clase no rescatada) y rescatar su subclase:

Ejemplo de excepción

Preparar

class RspecLoopStop < Exception; end

Prueba

blah.stub!(:some_initializer_method)
blah.should_receive(:some_other_method)
blah.should_receive(:yet_another_method)
# make sure it repeats
blah.should_receive(:some_other_method).and_raise RspecLoopStop
begin
blah.run
rescue RspecLoopStop
# all done
end

Ejemplo de captura / lanzamiento:

blah.stub!(:some_initializer_method)
blah.should_receive(:some_other_method)
blah.should_receive(:yet_another_method)
blah.should_receive(:some_other_method).and_throw :rspec_loop_stop
catch :rspec_loop_stop
blah.run
end

Cuando intenté esto por primera vez, me preocupaba que el uso de should_receive por segunda vez :some_other_method "sobrescribiera" el primero, pero este no es el caso. Si quieres verlo por ti mismo, agrega bloques a should_receive para ver si se llama el número esperado de veces:

blah.should_receive(:some_other_method) { puts ''received some_other_method'' }

Answer 5

La solución más fácil que encontré es producir el bucle una vez y luego regresar. He usado mocha aquí.

require ''spec_helper''
require ''blah''
describe Blah do
it ''loops'' do
Blah.stubs(:some_initializer_method)
Blah.stubs(:some_other_method)
Blah.stubs(:yet_another_method)
Blah.expects(:loop).yields().then().returns()
Blah.run
end
end

Esperamos que el bucle se ejecute realmente y se garantice que saldrá después de una iteración.

Sin embargo, como se indicó anteriormente, es una buena práctica mantener el método de bucle lo más pequeño y estúpido posible.

¡Espero que esto ayude!

Answer 6

Lo que podría ser más práctico es ejecutar el bucle en un hilo separado, afirmar que todo funciona correctamente y luego terminar el hilo cuando ya no sea necesario.

thread = Thread.new do
Blah.run
end
assert_equal 0, Blah.foo
thread.kill

Answer 7

No se puede probar que algo que se ejecuta para siempre.

Cuando te enfrentas a una sección de código que es difícil (o imposible) de probar, debes:

• Refactorizar para aislar la parte difícil de probar del código. Haga las partes no probables pequeñas y triviales. Comenta para asegurarte de que no se expandan más tarde para que no sean triviales.
• Haga una prueba unitaria de las otras partes, que ahora están separadas de la sección difícil de probar
• La parte difícil de probar estaría cubierta por una prueba de integración o aceptación

Si el bucle principal en tu juego solo gira una vez, esto será inmediatamente obvio cuando lo ejecutes.

Answer 8

Nuestra solución para probar un bucle que solo sale de las señales fue detener el método de condición de salida para que devuelva false la primera vez, pero la segunda vez, asegurando que el bucle solo se ejecute una vez.

Clase con bucle infinito:

class Scheduling::Daemon
def run
loop do
if daemon_received_stop_signal?
break
end
# do stuff
end
end
end

Especificaciones que prueban el comportamiento del bucle:

describe Scheduling::Daemon do
describe "#run" do
before do
Scheduling::Daemon.should_receive(:daemon_received_stop_signal?).
and_return(false, true) # execute loop once then exit
end
it "does stuff" do
Scheduling::Daemon.run
# assert stuff was done
end
end
end

Answer 9

Sé que esto es un poco viejo, pero también puedes usar el método de rendimientos para simular un bloque y pasar una única iteración a un método de bucle. Esto debería permitirle probar los métodos a los que está llamando dentro de su bucle sin ponerlo realmente en un bucle infinito.

require ''test/unit''
require ''mocha''
class Something
def test_method
puts "test_method"
loop do
puts String.new("frederick")
end
end
end
class LoopTest < Test::Unit::TestCase
def test_loop_yields
something = Something.new
something.expects(:loop).yields.with() do
String.expects(:new).returns("samantha")
end
something.test_method
end
end
# Started
# test_method
# samantha
# .
# Finished in 0.005 seconds.
#
# 1 tests, 2 assertions, 0 failures, 0 errors

Answer 10

en rspec 3.3, agregue esta línea

allow(subject).to receive(:loop).and_yield

a su gancho anterior se cederá fácilmente al bloque sin ningún bucle