pruebas - test en python

Prueba de unidad Python: ¿Generar pruebas múltiples programáticamente?

Question

Posible duplicado:
¿Cómo generar pruebas de unidades dinámicas (parametrizadas) en python?

Tengo una función para probar, under_test y un conjunto de pares de entrada / salida esperados:

[
(2, 332),
(234, 99213),
(9, 3),
# ...
]

Me gustaría que cada uno de estos pares de entrada / salida se pruebe en su propio método test_* . ¿Es eso posible?

Esto es algo así como lo que quiero, pero forzando cada par de entrada / salida en una sola prueba:

class TestPreReqs(unittest.TestCase):
def setUp(self):
self.expected_pairs = [(23, 55), (4, 32)]
def test_expected(self):
for exp in self.expected_pairs:
self.assertEqual(under_test(exp[0]), exp[1])
if __name__ == ''__main__'':
unittest.main()

(Además, ¿realmente quiero poner esa definición de self.expected_pairs en setUp ?)

ACTUALIZACIÓN: Probar el consejo de DoubleP :

class TestPreReqs(unittest.TestCase):
def setUp(self):
expected_pairs = [
(2, 3),
(42, 11),
(3, None),
(31, 99),
]
for k, pair in expected_pairs:
setattr(TestPreReqs, ''test_expected_%d'' % k, create_test(pair))
def create_test (pair):
def do_test_expected(self):
self.assertEqual(get_pre_reqs(pair[0]), pair[1])
return do_test_expected
if __name__ == ''__main__'':
unittest.main()

Esto no funciona. 0 pruebas se ejecutan. ¿He adaptado el ejemplo incorrectamente?

Answer 1

nariz (sugerida por @Paul Hankin )

#!/usr/bin/env python
# file: test_pairs_nose.py
from nose.tools import eq_ as eq
from mymodule import f
def test_pairs():
for input, output in [ (2, 332), (234, 99213), (9, 3), ]:
yield _test_f, input, output
def _test_f(input, output):
try:
eq(f(input), output)
except AssertionError:
if input == 9: # expected failure
from nose.exc import SkipTest
raise SkipTest("expected failure")
else:
raise
if __name__=="__main__":
import nose; nose.main()

Ejemplo:

$ nosetests test_pairs_nose -v
test_pairs_nose.test_pairs(2, 332) ... ok
test_pairs_nose.test_pairs(234, 99213) ... ok
test_pairs_nose.test_pairs(9, 3) ... SKIP: expected failure
----------------------------------------------------------------------
Ran 3 tests in 0.001s
OK (SKIP=1)

unittest (enfoque similar al de @ doublep )

#!/usr/bin/env python
import unittest2 as unittest
from mymodule import f
def add_tests(generator):
def class_decorator(cls):
"""Add tests to `cls` generated by `generator()`."""
for f, input, output in generator():
test = lambda self, i=input, o=output, f=f: f(self, i, o)
test.__name__ = "test_%s(%r, %r)" % (f.__name__, input, output)
setattr(cls, test.__name__, test)
return cls
return class_decorator
def _test_pairs():
def t(self, input, output):
self.assertEqual(f(input), output)
for input, output in [ (2, 332), (234, 99213), (9, 3), ]:
tt = t if input != 9 else unittest.expectedFailure(t)
yield tt, input, output
class TestCase(unittest.TestCase):
pass
TestCase = add_tests(_test_pairs)(TestCase)
if __name__=="__main__":
unittest.main()

Ejemplo:

$ python test_pairs_unit2.py -v
test_t(2, 332) (__main__.TestCase) ... ok
test_t(234, 99213) (__main__.TestCase) ... ok
test_t(9, 3) (__main__.TestCase) ... expected failure
----------------------------------------------------------------------
Ran 3 tests in 0.000s
OK (expected failures=1)

Si no desea instalar unittest2 , agregue:

try:
import unittest2 as unittest
except ImportError:
import unittest
if not hasattr(unittest, ''expectedFailure''):
import functools
def _expectedFailure(func):
@functools.wraps(func)
def wrapper(*args, **kwargs):
try:
func(*args, **kwargs)
except AssertionError:
pass
else:
raise AssertionError("UnexpectedSuccess")
return wrapper
unittest.expectedFailure = _expectedFailure

Answer 2

Algunas de las herramientas disponibles para realizar pruebas parametrizadas en Python son:

• Generadores de prueba de nariz (solo para pruebas funcionales, no para clases TestCase)
• nose-parametrized en la nose-parametrized por David Wolever (también para las clases de TestCase)
• Plantilla Unittest de Boris Feld
• Pruebas parametrizadas en py.test
• parametrized-testcase de parametrized-testcase por Austin Bingham

Vea también la pregunta 1676269 para obtener más respuestas a esta pregunta.

Answer 3

Como ocurre a menudo con Python, existe una forma complicada de proporcionar una solución simple.

En ese caso, podemos usar metaprogramación, decoradores y varios ingeniosos trucos de Python para lograr un buen resultado. Así es como se verá la prueba final:

import unittest
# some magic code will be added here later
class DummyTest(unittest.TestCase):
@for_examples(1, 2)
@for_examples(3, 4)
def test_is_smaller_than_four(self, value):
self.assertTrue(value < 4)
@for_examples((1,2),(2,4),(3,7))
def test_double_of_X_is_Y(self, x, y):
self.assertEqual(2 * x, y)
if __name__ == "__main__":
unittest.main()

Al ejecutar este script, el resultado es:

..F...F
======================================================================
FAIL: test_double_of_X_is_Y(3,7)
----------------------------------------------------------------------
Traceback (most recent call last):
File "/Users/xdecoret/Documents/foo.py", line 22, in method_for_example
method(self, *example)
File "/Users/xdecoret/Documents/foo.py", line 41, in test_double_of_X_is_Y
self.assertEqual(2 * x, y)
AssertionError: 6 != 7
======================================================================
FAIL: test_is_smaller_than_four(4)
----------------------------------------------------------------------
Traceback (most recent call last):
File "/Users/xdecoret/Documents/foo.py", line 22, in method_for_example
method(self, *example)
File "/Users/xdecoret/Documents/foo.py", line 37, in test_is_smaller_than_four
self.assertTrue(value < 4)
AssertionError
----------------------------------------------------------------------
Ran 7 tests in 0.001s
FAILED (failures=2)

que logra nuestro objetivo:

• es discreto: derivamos de TestCase como de costumbre
• escribimos pruebas parametrizadas solo una vez
• cada valor de ejemplo se considera una prueba individual
• el decorador se puede apilar, por lo que es fácil usar conjuntos de ejemplos (por ejemplo, usar una función para compilar la lista de valores de archivos de ejemplo o directorios)
• guinda del pastel, funciona por ariedad arbitraria de la firma

Entonces, cómo funciona. Básicamente, el decorador almacena los ejemplos en un atributo de la función. Usamos metaclass para reemplazar cada función decorada con una lista de funciones. Y reemplazamos el unittest.TestCase con nuestro nuevo El código mágico (que se pegará en el comentario "mágico" anterior) es:

__examples__ = "__examples__"
def for_examples(*examples):
def decorator(f, examples=examples):
setattr(f, __examples__, getattr(f, __examples__,()) + examples)
return f
return decorator
class TestCaseWithExamplesMetaclass(type):
def __new__(meta, name, bases, dict):
def tuplify(x):
if not isinstance(x, tuple):
return (x,)
return x
for methodname, method in dict.items():
if hasattr(method, __examples__):
dict.pop(methodname)
examples = getattr(method, __examples__)
delattr(method, __examples__)
for example in (tuplify(x) for x in examples):
def method_for_example(self, method = method, example = example):
method(self, *example)
methodname_for_example = methodname + "(" + ", ".join(str(v) for v in example) + ")"
dict[methodname_for_example] = method_for_example
return type.__new__(meta, name, bases, dict)
class TestCaseWithExamples(unittest.TestCase):
__metaclass__ = TestCaseWithExamplesMetaclass
pass
unittest.TestCase = TestCaseWithExamples

Si alguien quiere empaquetarlo bien, o proponer un parche para la prueba de unidad, ¡siéntase libre! Una cita de mi nombre será apreciada.

- Editar --------

El código puede simplificarse mucho y encapsularse por completo en el decorador si está listo para usar la introspección de cuadros (importar el módulo sys)

def for_examples(*parameters):
def tuplify(x):
if not isinstance(x, tuple):
return (x,)
return x
def decorator(method, parameters=parameters):
for parameter in (tuplify(x) for x in parameters):
def method_for_parameter(self, method=method, parameter=parameter):
method(self, *parameter)
args_for_parameter = ",".join(repr(v) for v in parameter)
name_for_parameter = method.__name__ + "(" + args_for_parameter + ")"
frame = sys._getframe(1) # pylint: disable-msg=W0212
frame.f_locals[name_for_parameter] = method_for_parameter
return None
return decorator

Answer 4

Con las pruebas de nariz, entonces sí. Ver esto: https://nose.readthedocs.org/en/latest/writing_tests.html#test-generators

Answer 5

Creo que la solución de Rory es la más limpia y la más corta. Sin embargo, esta variación de "crear funciones sintéticas en un TestCase" de DoubleP también funciona:

from functools import partial
class TestAllReports(unittest.TestCase):
pass
def test_spamreport(name):
assert classify(getSample(name))==''spamreport'', name
for rep in REPORTS:
testname = ''test_''+rep
testfunc = partial(test_spamreport, rep)
testfunc.__doc__ = testname
setattr( TestAllReports, testname, testfunc )
if __name__==''__main__'':
unittest.main(argv=sys.argv + [''--verbose''])

Answer 6

No probado:

class TestPreReqs(unittest.TestCase):
...
def create_test (pair):
def do_test_expected(self):
self.assertEqual(under_test(pair[0]), pair[1])
return do_test_expected
for k, pair in enumerate ([(23, 55), (4, 32)]):
test_method = create_test (pair)
test_method.__name__ = ''test_expected_%d'' % k
setattr (TestPreReqs, test_method.__name__, test_method)

Si usa esto a menudo, podría embellecer esto usando funciones de utilidad y / o decoradores, supongo. Tenga en cuenta que los pares no son un atributo del objeto TestPreReqs en este ejemplo (y por eso setUp se ha ido). Por el contrario, están "cableados" en cierto sentido en la clase TestPreReqs .

Answer 7

Tenía que hacer algo similar. TestCase subclases simples de TestCase que tomaron un valor en su __init__ , así:

class KnownGood(unittest.TestCase):
def __init__(self, input, output):
super(KnownGood, self).__init__()
self.input = input
self.output = output
def runTest(self):
self.assertEqual(function_to_test(self.input), self.output)

Luego hice un banco de pruebas con estos valores:

def suite():
suite = unittest.TestSuite()
suite.addTests(KnownGood(input, output) for input, output in known_values)
return suite

Luego puede ejecutarlo desde su método principal:

if __name__ == ''__main__'':
unittest.TextTestRunner().run(suite())

Las ventajas de esto son:

• A medida que agrega más valores, la cantidad de pruebas informadas aumenta, lo que le hace sentir que está haciendo más.
• Cada caso de prueba individual puede fallar individualmente
• Es conceptualmente simple, ya que cada valor de entrada / salida se convierte en un TestCase