ruby - allow - ¿Cómo puedo validar las salidas y cancelaciones en RSpec?

rspec allow

Question

Estoy tratando de especificar comportamientos para los argumentos de línea de comandos que recibe mi script para garantizar que todas las validaciones pasen. Algunos de mis argumentos de la línea de comandos darán como resultado la abort o la invocación de la exit porque los parámetros suministrados faltan o son incorrectos.

Estoy intentando algo como esto que no funciona:

# something_spec.rb
require ''something''
describe Something do
    before do
        Kernel.stub!(:exit)
    end

    it "should exit cleanly when -h is used" do
        s = Something.new
        Kernel.should_receive(:exit)
        s.process_arguments(["-h"])
    end
end

El método de exit se activa limpiamente impidiendo que RSpec valide la prueba (obtengo "SystemExit: exit").

También traté de mock(Kernel) pero eso tampoco funciona como me gustaría (no veo ninguna diferencia discernible, pero es probable porque no estoy seguro de cómo burlarse de Kernel y asegurarme de que el Kernel se burló se usa en mi clase de Something ).

Answer 1

Después de excavar, encontré esto .

Mi solución terminó luciendo así:

# something.rb
class Something
    def initialize(kernel=Kernel)
        @kernel = kernel
    end

    def process_arguments(args)
        @kernel.exit
    end
end

# something_spec.rb
require ''something''
describe Something do
    before :each do
        @mock_kernel = mock(Kernel)
        @mock_kernel.stub!(:exit)
    end

    it "should exit cleanly" do
        s = Something.new(@mock_kernel)
        @mock_kernel.should_receive(:exit)
        s.process_arguments(["-h"])
    end
end

Answer 2

Gracias por la respuesta Markus. Una vez que tuve esta pista, pude armar un buen comparador para uso futuro.

it "should exit cleanly when -h is used" do
  lambda { ::MyGem::CLI.execute( StringIO.new, ["-h"]) }.should exit_with_code(0)
end
it "should exit with error on unknown option" do
  lambda { ::MyGem::CLI.execute( StringIO.new, ["--bad-option"]) }.should exit_with_code(-1)
end

Para usar este matcher, agregue esto a sus bibliotecas o ayudantes de especificación:

RSpec::Matchers.define :exit_with_code do |exp_code|
  actual = nil
  match do |block|
    begin
      block.call
    rescue SystemExit => e
      actual = e.status
    end
    actual and actual == exp_code
  end
  failure_message_for_should do |block|
    "expected block to call exit(#{exp_code}) but exit" +
      (actual.nil? ? " not called" : "(#{actual}) was called")
  end
  failure_message_for_should_not do |block|
    "expected block not to call exit(#{exp_code})"
  end
  description do
    "expect block to call exit(#{exp_code})"
  end
end

Answer 3

No es bonito, pero he estado usando esto:

begin
  do_something
rescue SystemExit => e
  expect(e.status).to eq 1 # exited with failure status
  # or
  expect(e.status).to eq 0 # exited with success status
else
  expect(true).eq false # this should never happen
end

Answer 4

No hay necesidad de emparejadores personalizados o bloques de rescate, simplemente:

expect { exit 1 }.to raise_error(SystemExit) do |error|
  expect(error.status).to eq(1)
end

Yo diría que esto es superior porque es Rspec explícito y simple.

Answer 5

Tuve que actualizar la solución @Greg proporcionada debido a los nuevos requisitos de sintaxis.

RSpec::Matchers.define :exit_with_code do |exp_code|
  actual = nil
  match do |block|
    begin
      block.call
    rescue SystemExit => e
      actual = e.status
    end
    actual and actual == exp_code
  end
  failure_message do |block|
    "expected block to call exit(#{exp_code}) but exit" +
        (actual.nil? ? " not called" : "(#{actual}) was called")
  end
  failure_message_when_negated do |block|
    "expected block not to call exit(#{exp_code})"
  end
  description do
    "expect block to call exit(#{exp_code})"
  end
  supports_block_expectations
end

Answer 6

Usando la nueva sintaxis de RSpec:

expect { code_that_exits }.to raise_error(SystemExit)

Si se imprime algo en STDOUT y desea probarlo también, puede hacer algo como:

context "when -h or --help option used" do
  it "prints the help and exits" do
    help = %Q(
      Usage: my_app [options]
        -h, --help                       Shows this help message
    )

    ARGV << "-h"
    expect do
      output = capture_stdout { my_app.execute(ARGV) }
      expect(output).to eq(help)
    end.to raise_error(SystemExit)

    ARGV << "--help"
    expect do
      output = capture_stdout { my_app.execute(ARGV) }
      expect(output).to eq(help)
    end.to raise_error(SystemExit)
  end
end

Donde capture_stdout se define como se ve en Prueba de salida a la línea de comando con RSpec .

Actualización: considere usar el matcher de output RSpec en lugar de capture_stdout

Answer 7

prueba esto:

module MyGem
  describe "CLI" do
    context "execute" do

      it "should exit cleanly when -h is used" do
        argv=["-h"]
        out = StringIO.new
        lambda { ::MyGem::CLI.execute( out, argv) }.should raise_error SystemExit
      end

    end
  end
end