python - skipif - ¿Cómo puedo simular la entrada a stdin para pyunit?

unittest python 3

Question

Estoy tratando de probar una función que toma entrada de stdin , que actualmente estoy probando con algo como esto:

cat /usr/share/dict/words | ./spellchecker.py

En el nombre de la automatización de prueba, ¿hay alguna manera en que pyunit pueda falsificar la entrada a raw_input() ?

Answer 1

Actualización - utilizando unittest.mock.patch

Desde Python 3.3, hay un nuevo submódulo para unittest llamado mock que hace exactamente lo que necesita hacer. Para aquellos que usan Python 2.6 o superior hay un backport de mock encuentra here .

import unittest
from unittest.mock import patch
import module_under_test
class MyTestCase(unittest.TestCase):
def setUp(self):
# raw_input is untouched before test
assert module_under_test.raw_input is __builtins__.raw_input
def test_using_with(self):
input_data = "123"
expected = int(input_data)
with patch.object(module_under_test, "raw_input", create=True,
return_value=expected):
# create=True is needed as raw_input is not in the globals of
# module_under_test, but actually found in __builtins__ .
actual = module_under_test.function()
self.assertEqual(expected, actual)
@patch.object(module_under_test, "raw_input", create=True)
def test_using_decorator(self, raw_input):
raw_input.return_value = input_data = "123"
expected = int(input_data)
actual = module_under_test.function()
self.assertEqual(expected, actual)
def tearDown(self):
# raw input is restored after test
assert module_under_test.raw_input is __builtins__.raw_input
if __name__ == "__main__":
unittest.main()
# where module_under_test.function is:
def function():
return int(raw_input("prompt> "))

Respuesta anterior - reemplazando sys.stdin

Creo que el módulo sys podría ser lo que estás buscando.

Puedes hacer algo como

import sys
# save actual stdin in case we need it again later
stdin = sys.stdin
sys.stdin = open(''simulatedInput.txt'',''r'')
# or whatever else you want to provide the input eg. StringIO

raw_input ahora leerá desde simulatedInput.txt cada vez que se llame. Si los contenidos de simulatedInput fueran

hello
bob

luego la primera llamada a raw_input devolvería "hola", la segunda "bob" y la tercera lanzaría un EOFError ya que no había más texto para leer.

Answer 2

La respuesta corta es mono patch raw_input() .

Hay algunos buenos ejemplos en la respuesta a ¿Cómo mostrar la entrada estándar redirigida en Python?

Este es un ejemplo simple y trivial que utiliza un lambda que desecha la solicitud y devuelve lo que queremos.

Sistema bajo prueba

cat ./name_getter.py
#!/usr/bin/env python
class NameGetter(object):
def get_name(self):
self.name = raw_input(''What is your name? '')
def greet(self):
print ''Hello, '', self.name, ''!''
def run(self):
self.get_name()
self.greet()
if __name__ == ''__main__'':
ng = NameGetter()
ng.run()
$ echo Derek | ./name_getter.py
What is your name? Hello, Derek !

Caso de prueba:

$ cat ./t_name_getter.py
#!/usr/bin/env python
import unittest
import name_getter
class TestNameGetter(unittest.TestCase):
def test_get_alice(self):
name_getter.raw_input = lambda _: ''Alice''
ng = name_getter.NameGetter()
ng.get_name()
self.assertEquals(ng.name, ''Alice'')
def test_get_bob(self):
name_getter.raw_input = lambda _: ''Bob''
ng = name_getter.NameGetter()
ng.get_name()
self.assertEquals(ng.name, ''Bob'')
if __name__ == ''__main__'':
unittest.main()
$ ./t_name_getter.py -v
test_get_alice (__main__.TestNameGetter) ... ok
test_get_bob (__main__.TestNameGetter) ... ok
----------------------------------------------------------------------
Ran 2 tests in 0.000s
OK

Answer 3

No describiste qué tipo de código está en spellchecker.py , lo que me da libertad para especular.

Supongamos que es algo como esto:

import sys
def check_stdin():
# some code that uses sys.stdin

Para mejorar la check_stdin de check_stdin función check_stdin , propongo refactorizarla así:

def check_stdin():
return check(sys.stdin)
def check(input_stream):
# same as original code, but instead of
# sys.stdin it is written it terms of input_stream.

Ahora, la mayor parte de su lógica está en la función de check , y puede elaborar manualmente cualquier entrada que pueda imaginar para probarla correctamente, sin necesidad de lidiar con la stdin .

Mis 2 centavos.

Answer 4

Reemplace sys.stdin con una instancia de StringIO y cargue la instancia de StringIO con los datos que desea que se devuelvan a través de sys.stdin . Además, sys.__stdin__ contiene el objeto sys.stdin original, por lo que restaurar sys.stdin después de su prueba es tan simple como sys.stdin = sys.__stdin__ .

Fudge es un excelente módulo simulado de python, con decoradores convenientes para hacer parches de este tipo, con limpieza automática. Usted deberia comprobar esto.

Answer 5

Si está utilizando un módulo simulado (escrito por Michael Foord), para simular la función raw_input puede usar una sintaxis como:

@patch(''src.main.raw_input'', create=True, new=MagicMock(return_value=''y''))
def test_1(self):
method_we_try_to_test(); # method or function that calls **raw_input**