Estrutura UnitTest - API

Este capítulo discute as classes e métodos definidos no módulo unittest. Existem cinco classes principais neste módulo.

Classe TestCase

O objeto desta classe representa a menor unidade testável. Ele mantém as rotinas de teste e fornece ganchos para preparar cada rotina e para limpar depois disso.

Os seguintes métodos são definidos na classe TestCase -

Sr. Não. Método e Descrição
1

setUp()

Método chamado para preparar o dispositivo de teste. Isso é chamado imediatamente antes de chamar o método de teste
2

tearDown()

Método chamado imediatamente após o método de teste ter sido chamado e o resultado registrado. Isso é chamado mesmo se o método de teste gerou uma exceção,
3

setUpClass()

Um método de classe chamado antes dos testes em uma execução de classe individual.
4

tearDownClass()

Um método de classe chamado após a execução de testes em uma classe individual.
5

run(result = None)

Execute o teste, coletando o resultado no objeto de resultado do teste aprovado como resultado .
6

skipTest(reason)

Chamar isso durante um método de teste ou setUp () ignora o teste atual.
7

debug()

Execute o teste sem coletar o resultado.
8

shortDescription()

Retorna uma descrição de uma linha do teste.

Luminárias

Pode haver vários testes escritos dentro de uma classe TestCase. Esses métodos de teste podem precisar de conexão de banco de dados, arquivos temporários ou outros recursos para serem inicializados. Estes são chamados de acessórios. TestCase inclui um gancho especial para configurar e limpar quaisquer acessórios necessários para seus testes. Para configurar os aparelhos, substitua setUp (). Para limpar, substitua tearDown ().

No exemplo a seguir, dois testes são escritos dentro da classe TestCase. Eles testam o resultado da adição e subtração de dois valores. O método setup () inicializa os argumentos com base em shortDescription () de cada teste. O método teardown () será executado no final de cada teste.

import unittest

class simpleTest2(unittest.TestCase):
   def setUp(self):
      self.a = 10
      self.b = 20
      name = self.shortDescription()
      if name == "Add":
         self.a = 10
         self.b = 20
         print name, self.a, self.b
      if name == "sub":
         self.a = 50
         self.b = 60
         print name, self.a, self.b
   def tearDown(self):
      print '\nend of test',self.shortDescription()

   def testadd(self):
      """Add"""
      result = self.a+self.b
      self.assertTrue(result == 100)
   def testsub(self):
      """sub"""
      result = self.a-self.b
      self.assertTrue(result == -10)
      
if __name__ == '__main__':
   unittest.main()

Execute o código acima na linha de comando. Ele fornece a seguinte saída -

C:\Python27>python test2.py
Add 10 20
F
end of test Add
sub 50 60
end of test sub
.
================================================================
FAIL: testadd (__main__.simpleTest2)
Add
----------------------------------------------------------------------
Traceback (most recent call last):
   File "test2.py", line 21, in testadd
      self.assertTrue(result == 100)
AssertionError: False is not true
----------------------------------------------------------------------
Ran 2 tests in 0.015s

FAILED (failures = 1)

Fixture da classe

A classe TestCase tem um método setUpClass () que pode ser sobrescrito para executar antes da execução de testes individuais dentro de uma classe TestCase. Da mesma forma, o método tearDownClass () será executado após todos os testes da classe. Ambos os métodos são métodos de classe. Portanto, eles devem ser decorados com a diretiva @classmethod.

O exemplo a seguir demonstra o uso desses métodos de classe -

import unittest

class TestFixtures(unittest.TestCase):

   @classmethod
   def setUpClass(cls):
      print 'called once before any tests in class'

   @classmethod
   def tearDownClass(cls):
      print '\ncalled once after all tests in class'

   def setUp(self):
      self.a = 10
      self.b = 20
      name = self.shortDescription()
      print '\n',name
   def tearDown(self):
      print '\nend of test',self.shortDescription()

   def test1(self):
      """One"""
      result = self.a+self.b
      self.assertTrue(True)
   def test2(self):
      """Two"""
      result = self.a-self.b
      self.assertTrue(False)
      
if __name__ == '__main__':
unittest.main()

Classe TestSuite

A estrutura de teste do Python fornece um mecanismo útil pelo qual as instâncias de caso de teste podem ser agrupadas de acordo com os recursos que testam. Este mecanismo é disponibilizado pela classe TestSuite no módulo unittest.

As etapas a seguir estão envolvidas na criação e execução de um conjunto de testes.

Step 1 - Crie uma instância da classe TestSuite.

suite = unittest.TestSuite()

Step 2 - Adicionar testes dentro de uma classe TestCase na suíte.

suite.addTest(testcase class)

Step 3 - Você também pode usar o método makeSuite () para adicionar testes de uma classe

suite = unittest.makeSuite(test case class)

Step 4 - Testes individuais também podem ser adicionados na suíte.

suite.addTest(testcaseclass(""testmethod")

Step 5 - Crie um objeto da classe TestTestRunner.

runner = unittest.TextTestRunner()

Step 6 - Chame o método run () para executar todos os testes no pacote

runner.run (suite)

Os seguintes métodos são definidos na classe TestSuite -

Sr. Não. Método e Descrição
1

addTest()

Adiciona um método de teste no conjunto de testes.
2

addTests()

Adiciona testes de várias classes TestCase.
3

run()

Executa os testes associados a este pacote, coletando o resultado no objeto de resultado do teste
4

debug()

Executa os testes associados a este pacote sem coletar o resultado.
5

countTestCases()

Retorna o número de testes representados por este objeto de teste

O exemplo a seguir mostra como usar a classe TestSuite -

import unittest
class suiteTest(unittest.TestCase):
   def setUp(self):
      self.a = 10
      self.b = 20
      
   def testadd(self):
      """Add"""
      result = self.a+self.b
      self.assertTrue(result == 100)
   def testsub(self):
      """sub"""
      result = self.a-self.b
      self.assertTrue(result == -10)
      
def suite():
   suite = unittest.TestSuite()
##   suite.addTest (simpleTest3("testadd"))
##   suite.addTest (simpleTest3("testsub"))
   suite.addTest(unittest.makeSuite(simpleTest3))
   return suite
   
if __name__ == '__main__':
   runner = unittest.TextTestRunner()
   test_suite = suite()
   runner.run (test_suite)

Você pode experimentar o método addTest () removendo o comentário das linhas e da instrução de comentário com o método makeSuite ().

Classe TestLoader

O pacote unittest possui a classe TestLoader que é usada para criar suítes de teste a partir de classes e módulos. Por padrão, a instância unittest.defaultTestLoader é criada automaticamente quando o método unittest.main (0 é chamado. Uma instância explícita, no entanto, permite a personalização de certas propriedades.

No código a seguir, os testes de duas classes são coletados em uma Lista usando o objeto TestLoader.

import unittest
testList = [Test1, Test2]
testLoad = unittest.TestLoader()

TestList = []
for testCase in testList:
   testSuite = testLoad.loadTestsFromTestCase(testCase)
   TestList.append(testSuite)
   
newSuite = unittest.TestSuite(TestList)
runner = unittest.TextTestRunner()
runner.run(newSuite)

A tabela a seguir mostra uma lista de métodos na classe TestLoader -

Sr. Não Método e Descrição
1

loadTestsFromTestCase()

Retorna um conjunto de todos os casos de teste contidos em uma classe TestCase
2

loadTestsFromModule()

Retorne um conjunto de todos os casos de teste contidos no módulo fornecido.
3

loadTestsFromName()

Retorna um conjunto de todos os casos de teste dado um especificador de string.
4

discover()

Encontre todos os módulos de teste recorrendo aos subdiretórios do diretório inicial especificado e retorne um objeto TestSuite

Classe TestResult

Esta classe é usada para compilar informações sobre os testes que tiveram sucesso e os testes que falharam. Um objeto TestResult armazena os resultados de um conjunto de testes. Uma instância de TestResult é retornada pelo método TestRunner.run ().

As instâncias de TestResult têm os seguintes atributos -

Sr. Não. Atributo e descrição
1

Errors

Uma lista contendo 2 tuplas de instâncias do TestCase e strings contendo rastreamentos formatados. Cada tupla representa um teste que gerou uma exceção inesperada.
2

Failures

Uma lista contendo 2 tuplas de instâncias do TestCase e strings contendo rastreamentos formatados. Cada tupla representa um teste em que uma falha foi explicitamente sinalizada usando os métodos TestCase.assert * ().
3

Skipped

Uma lista contendo 2 tuplas de instâncias do TestCase e strings contendo o motivo para pular o teste.
4

wasSuccessful()

Retorna True se todos os testes executados até agora foram aprovados, caso contrário retorna False.
5

stop()

Este método pode ser chamado para sinalizar que o conjunto de testes em execução deve ser abortado.
6

startTestRun()

Chamado uma vez antes de qualquer teste ser executado.
7

stopTestRun()

Chamado uma vez depois que todos os testes são executados.
8

testsRun

O número total de testes executados até agora.
9

Buffer

Se definido como verdadeiro, sys.stdout e sys.stderrserá armazenado em buffer entre startTest () e stopTest () sendo chamado.

O código a seguir executa um conjunto de testes -

if __name__ == '__main__':
   runner = unittest.TextTestRunner()
   test_suite = suite()
   result = runner.run (test_suite)
   
   print "---- START OF TEST RESULTS"
   print result

   print "result::errors"
   print result.errors

   print "result::failures"
   print result.failures

   print "result::skipped"
   print result.skipped

   print "result::successful"
   print result.wasSuccessful()
   
   print "result::test-run"
   print result.testsRun
   print "---- END OF TEST RESULTS"

O código quando executado exibe a seguinte saída -

---- START OF TEST RESULTS
<unittest.runner.TextTestResult run = 2 errors = 0 failures = 1>
result::errors
[]
result::failures
[(<__main__.suiteTest testMethod = testadd>, 'Traceback (most recent call last):\n
   File "test3.py", line 10, in testadd\n 
   self.assertTrue(result == 100)\nAssert
   ionError: False is not true\n')]
result::skipped
[]
result::successful
False
result::test-run
2
---- END OF TEST RESULTS