Estrutura UnitTest - Asserção

A estrutura de teste Python usa a função assert () embutida do Python, que testa uma condição particular. Se a declaração falhar, um AssertionError será gerado. A estrutura de teste irá então identificar o teste como Falha. Outras exceções são tratadas como Erro.

Os três conjuntos de funções de asserção a seguir são definidos no módulo unittest -

Asserts booleanos básicos
Declarações Comparativas
Afirmações para coleções

As funções de declaração básicas avaliam se o resultado de uma operação é Verdadeiro ou Falso. Todos os métodos de declaração aceitam ummsg argumento que, se especificado, é usado como a mensagem de erro em caso de falha.

Sr. Não.	Método e Descrição
1	assertEqual(arg1, arg2, msg = None) Teste se arg1 e arg2 são iguais. Se os valores não forem iguais, o teste falhará.
2	assertNotEqual(arg1, arg2, msg = None) Teste se arg1 e arg2 não são iguais. Se os valores forem iguais, o teste falhará.
3	assertTrue(expr, msg = None) Teste se expr é verdadeiro. Se falso, o teste falha
4	assertFalse(expr, msg = None) Teste se expr é falso. Se verdadeiro, o teste falha
5	assertIs(arg1, arg2, msg = None) Teste se arg1 e arg2 são avaliados para o mesmo objeto.
6	assertIsNot(arg1, arg2, msg = None) Teste se arg1 e arg2 não são avaliados para o mesmo objeto.
7	assertIsNone(expr, msg = None) Teste se expr é Nenhum. Se não for nenhum, o teste falha
8	assertIsNotNone(expr, msg = None) Teste se expr não é Nenhum. Se nenhum, o teste falha
9	assertIn(arg1, arg2, msg = None) Teste se arg1 está em arg2 .
10	assertNotIn(arg1, arg2, msg = None) Teste se arg1 não está em arg2 .
11	assertIsInstance(obj, cls, msg = None) Teste se obj é uma instância de cls
12	assertNotIsInstance(obj, cls, msg = None) Teste se obj não é uma instância de cls

Algumas das funções de asserção acima são implementadas no código a seguir -

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()

Quando o script acima é executado, test2, test4 e test6 mostrarão falha e outros serão executados com sucesso.

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)

O segundo conjunto de funções de asserção são comparative asserts −

assertAlmostEqual (primeiro, segundo, casas = 7, msg = Nenhum, delta = Nenhum)

Teste que primeiro e segundo são aproximadamente (ou não aproximadamente) igual a pelo cálculo da diferença, o arredondamento para um dado número de decimais lugares (padrão 7),
assertNotAlmostEqual (primeiro, segundo, lugares, msg, delta)

Teste se a primeira e a segunda não são aproximadamente iguais, calculando a diferença, arredondando para o número de casas decimais fornecido (padrão 7) e comparando com zero.

Em ambas as funções acima, se delta for fornecido em vez de lugares, a diferença entre o primeiro e o segundo deve ser menor ou igual a (ou maior que) delta.

Fornecer delta e locais gera um TypeError.
assertGreater (primeiro, segundo, msg = Nenhum)

Teste se o primeiro é maior que o segundo, dependendo do nome do método. Caso contrário, o teste falhará.
assertGreaterEqual (primeiro, segundo, msg = Nenhum)

Teste se o primeiro é maior ou igual ao segundo, dependendo do nome do método. Caso contrário, o teste irá falhar
assertLess (primeiro, segundo, msg = Nenhum)

Teste se o primeiro é menor que o segundo, dependendo do nome do método. Caso contrário, o teste irá falhar
assertLessEqual (primeiro, segundo, msg = Nenhum)

Teste se o primeiro é menor ou igual ao segundo, dependendo do nome do método. Caso contrário, o teste falhará.
assertRegexpMatches (texto, regexp, msg = Nenhum)

Teste se uma pesquisa regexp corresponde ao texto. Em caso de falha, a mensagem de erro incluirá o padrão e o texto. regexp pode ser um objeto de expressão regular ou uma string contendo uma expressão regular adequada para uso porre.search().
assertNotRegexpMatches (texto, regexp, msg = Nenhum)

Verifica se uma pesquisa regexp não corresponde ao texto . Falha com uma mensagem de erro incluindo o padrão e a parte do texto correspondente. regexp pode ser um objeto de expressão regular ou uma string contendo uma expressão regular adequada para uso por re.search () .

As funções de asserção são implementadas no exemplo a seguir -

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()

O script acima relata test1 e test4 como falha. No teste 1, a divisão de 22/7 não está dentro de 7 casas decimais de 3,14. Da mesma forma, como o segundo argumento corresponde ao texto no primeiro argumento, test4 resulta em 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 coleções

Esse conjunto de funções de declaração deve ser usado com tipos de dados de coleção em Python, como Lista, Tupla, Dicionário e Conjunto.

Sr. Não.	Método e Descrição
1	assertListEqual (list1, list2, msg = None) Testa se duas listas são iguais. Caso contrário, uma mensagem de erro é construída mostrando apenas as diferenças entre os dois.
2	assertTupleEqual (tuple1, tuple2, msg = None) Testa se duas tuplas são iguais. Caso contrário, uma mensagem de erro é construída mostrando apenas as diferenças entre os dois.
3	assertSetEqual (set1, set2, msg = None) Testa se dois conjuntos são iguais. Caso contrário, uma mensagem de erro é construída listando as diferenças entre os conjuntos.
4	assertDictEqual (expected, actual, msg = None) Teste se dois dicionários são iguais. Caso contrário, é construída uma mensagem de erro que mostra as diferenças nos dicionários.

O exemplo a seguir implementa os métodos acima -

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()

No exemplo acima, test1 e test3 mostram AssertionError. A mensagem de erro exibe as diferenças nos objetos Lista e Dicionário.

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)

↰ Previous page Next page ↱