Marco UnitTest: afirmación
El marco de pruebas de Python utiliza la función assert () incorporada de Python que prueba una condición particular. Si la aserción falla, se generará un AssertionError. El marco de prueba identificará la prueba como Falla. Otras excepciones se tratan como Error.
Los siguientes tres conjuntos de funciones de aserción se definen en el módulo unittest:
- Declaraciones booleanas básicas
- Declaraciones comparativas
- Declaraciones para colecciones
Las funciones de aserción básicas evalúan si el resultado de una operación es Verdadero o Falso. Todos los métodos de aserción aceptan unmsg argumento que, si se especifica, se utiliza como mensaje de error en caso de falla.
| No Señor. | Método y descripción |
|---|---|
| 1 | assertEqual(arg1, arg2, msg = None) Pruebe que arg1 y arg2 sean iguales. Si los valores no son iguales, la prueba fallará. |
| 2 | assertNotEqual(arg1, arg2, msg = None) Pruebe que arg1 y arg2 no sean iguales. Si los valores se comparan igual, la prueba fallará. |
| 3 | assertTrue(expr, msg = None) Prueba que expr sea cierto. Si es falso, la prueba falla |
| 4 | assertFalse(expr, msg = None) Prueba que expr sea falso. Si es cierto, la prueba falla |
| 5 | assertIs(arg1, arg2, msg = None) Pruebe que arg1 y arg2 se evalúan en el mismo objeto. |
| 6 | assertIsNot(arg1, arg2, msg = None) Pruebe que arg1 y arg2 no se evalúan en el mismo objeto. |
| 7 | assertIsNone(expr, msg = None) Pruebe que expr sea None. Si no es Ninguno, la prueba falla |
| 8 | assertIsNotNone(expr, msg = None) Pruebe que expr no sea None. Si ninguno, la prueba falla |
| 9 | assertIn(arg1, arg2, msg = None) Pruebe que arg1 esté en arg2 . |
| 10 | assertNotIn(arg1, arg2, msg = None) Pruebe que arg1 no esté en arg2 . |
| 11 | assertIsInstance(obj, cls, msg = None) Prueba que obj es una instancia de cls |
| 12 | assertNotIsInstance(obj, cls, msg = None) Prueba que obj no es una instancia de cls |
Algunas de las funciones de aserción anteriores se implementan en el siguiente código:
import unittest
class SimpleTest(unittest.TestCase):
def test1(self):
self.assertEqual(4 + 5,9)
def test2(self):
self.assertNotEqual(5 * 2,10)
def test3(self):
self.assertTrue(4 + 5 == 9,"The result is False")
def test4(self):
self.assertTrue(4 + 5 == 10,"assertion fails")
def test5(self):
self.assertIn(3,[1,2,3])
def test6(self):
self.assertNotIn(3, range(5))
if __name__ == '__main__':
unittest.main()Cuando se ejecuta el script anterior, test2, test4 y test6 mostrarán falla y otros se ejecutarán correctamente.
FAIL: test2 (__main__.SimpleTest)
----------------------------------------------------------------------
Traceback (most recent call last):
File "C:\Python27\SimpleTest.py", line 9, in test2
self.assertNotEqual(5*2,10)
AssertionError: 10 == 10
FAIL: test4 (__main__.SimpleTest)
----------------------------------------------------------------------
Traceback (most recent call last):
File "C:\Python27\SimpleTest.py", line 13, in test4
self.assertTrue(4+5==10,"assertion fails")
AssertionError: assertion fails
FAIL: test6 (__main__.SimpleTest)
----------------------------------------------------------------------
Traceback (most recent call last):
File "C:\Python27\SimpleTest.py", line 17, in test6
self.assertNotIn(3, range(5))
AssertionError: 3 unexpectedly found in [0, 1, 2, 3, 4]
----------------------------------------------------------------------
Ran 6 tests in 0.001s
FAILED (failures = 3)El segundo conjunto de funciones de aserción son comparative asserts −
assertAlmostEqual (primero, segundo, lugares = 7, msg = Ninguno, delta = Ninguno)
Pruebe que el primero y el segundo son aproximadamente (o no aproximadamente) iguales calculando la diferencia, redondeando al número dado de lugares decimales (predeterminado 7),
assertNotAlmostEqual (primero, segundo, lugares, mensaje, delta)
Pruebe que el primero y el segundo no sean aproximadamente iguales calculando la diferencia, redondeando al número dado de lugares decimales (predeterminado 7) y comparando con cero.
En ambas funciones anteriores, si se proporciona delta en lugar de lugares, la diferencia entre el primero y el segundo debe ser menor o igual (o mayor que) delta.
Suministrar tanto delta como de lugares genera un TypeError.
assertGreater (primero, segundo, msg = Ninguno)
Pruebe que el primero sea mayor que el segundo según el nombre del método. Si no, la prueba fallará.
assertGreaterEqual (primero, segundo, msg = Ninguno)
Pruebe que el primero sea mayor o igual que el segundo según el nombre del método. Si no, la prueba fallará
assertLess (primero, segundo, msg = Ninguno)
Pruebe que el primero sea menor que el segundo, según el nombre del método. Si no, la prueba fallará
assertLessEqual (primero, segundo, msg = Ninguno)
Pruebe que el primero sea menor o igual que el segundo, según el nombre del método. Si no, la prueba fallará.
assertRegexpMatches (texto, regexp, msg = Ninguno)
Pruebe que una búsqueda de expresiones regulares coincida con el texto. En caso de falla, el mensaje de error incluirá el patrón y el texto. regexp puede ser un objeto de expresión regular o una cadena que contiene una expresión regular adecuada para su uso porre.search().
assertNotRegexpMatches (texto, regexp, msg = Ninguno)
Verifica que una búsqueda de expresiones regulares no coincida con el texto . Falla con un mensaje de error que incluye el patrón y la parte del texto que coincide. regexp puede ser un objeto de expresión regular o una cadena que contenga una expresión regular adecuada para ser utilizada por re.search () .
Las funciones de aserción se implementan en el siguiente ejemplo:
import unittest
import math
import re
class SimpleTest(unittest.TestCase):
def test1(self):
self.assertAlmostEqual(22.0/7,3.14)
def test2(self):
self.assertNotAlmostEqual(10.0/3,3)
def test3(self):
self.assertGreater(math.pi,3)
def test4(self):
self.assertNotRegexpMatches("Tutorials Point (I) Private Limited","Point")
if __name__ == '__main__':
unittest.main()El script anterior informa test1 y test4 como Failure. En test1, la división de 22/7 no está dentro de los 7 lugares decimales de 3,14. De manera similar, dado que el segundo argumento coincide con el texto del primer argumento, test4 da como resultado AssertionError.
=====================================================FAIL: test1 (__main__.SimpleTest)
----------------------------------------------------------------------
Traceback (most recent call last):
File "asserttest.py", line 7, in test1
self.assertAlmostEqual(22.0/7,3.14)
AssertionError: 3.142857142857143 != 3.14 within 7 places
================================================================
FAIL: test4 (__main__.SimpleTest)
----------------------------------------------------------------------
Traceback (most recent call last):
File "asserttest.py", line 13, in test4
self.assertNotRegexpMatches("Tutorials Point (I) Private Limited","Point")
AssertionError: Regexp matched: 'Point' matches 'Point' in 'Tutorials Point (I)
Private Limited'
----------------------------------------------------------------------
Ran 4 tests in 0.001s
FAILED (failures = 2)Afirmar para colecciones
Este conjunto de funciones de aserción está destinado a ser utilizado con tipos de datos de colección en Python, como Lista, Tupla, Diccionario y Conjunto.
| No Señor. | Método y descripción |
|---|---|
| 1 | assertListEqual (list1, list2, msg = None) Comprueba que dos listas son iguales. De lo contrario, se crea un mensaje de error que muestra solo las diferencias entre los dos. |
| 2 | assertTupleEqual (tuple1, tuple2, msg = None) Prueba que dos tuplas son iguales. De lo contrario, se crea un mensaje de error que muestra solo las diferencias entre los dos. |
| 3 | assertSetEqual (set1, set2, msg = None) Prueba que dos conjuntos son iguales. De lo contrario, se crea un mensaje de error que enumera las diferencias entre los conjuntos. |
| 4 | assertDictEqual (expected, actual, msg = None) Prueba que dos diccionarios son iguales. Si no, se crea un mensaje de error que muestra las diferencias en los diccionarios. |
El siguiente ejemplo implementa los métodos anteriores:
import unittest
class SimpleTest(unittest.TestCase):
def test1(self):
self.assertListEqual([2,3,4], [1,2,3,4,5])
def test2(self):
self.assertTupleEqual((1*2,2*2,3*2), (2,4,6))
def test3(self):
self.assertDictEqual({1:11,2:22},{3:33,2:22,1:11})
if __name__ == '__main__':
unittest.main()En el ejemplo anterior, test1 y test3 muestran AssertionError. El mensaje de error muestra las diferencias en los objetos Lista y Diccionario.
FAIL: test1 (__main__.SimpleTest)
----------------------------------------------------------------------
Traceback (most recent call last):
File "asserttest.py", line 5, in test1
self.assertListEqual([2,3,4], [1,2,3,4,5])
AssertionError: Lists differ: [2, 3, 4] != [1, 2, 3, 4, 5]
First differing element 0:
2
1
Second list contains 2 additional elements.
First extra element 3:
4
- [2, 3, 4]
+ [1, 2, 3, 4, 5]
? +++ +++
FAIL: test3 (__main__.SimpleTest)
----------------------------------------------------------------------
Traceback (most recent call last):
File "asserttest.py", line 9, in test3
self.assertDictEqual({1:11,2:22},{3:33,2:22,1:11})
AssertionError: {1: 11, 2: 22} != {1: 11, 2: 22, 3: 33}
- {1: 11, 2: 22}
+ {1: 11, 2: 22, 3: 33}
? +++++++
----------------------------------------------------------------------
Ran 3 tests in 0.001s
FAILED (failures = 2)