Framework UnitTest - API

Questo capitolo discute le classi e i metodi definiti nel modulo unittest. Ci sono cinque classi principali in questo modulo.

Classe TestCase

L'oggetto di questa classe rappresenta la più piccola unità testabile. Contiene le routine di test e fornisce ganci per la preparazione di ciascuna routine e per la successiva pulizia.

I seguenti metodi sono definiti nella classe TestCase:

Sr.No.	Metodo e descrizione
1	setUp() Metodo chiamato per preparare il dispositivo di prova. Questo viene chiamato immediatamente prima di chiamare il metodo di test
2	tearDown() Metodo chiamato immediatamente dopo che il metodo di prova è stato chiamato e il risultato registrato. Viene chiamato anche se il metodo di test ha sollevato un'eccezione,
3	setUpClass() Un metodo di classe chiamato prima dei test in un'esecuzione di una singola classe.
4	tearDownClass() Un metodo di classe chiamato dopo l'esecuzione dei test in una singola classe.
5	run(result = None) Eseguire il test, raccogliendo il risultato nell'oggetto risultato del test passato come risultato .
6	skipTest(reason) Chiamarlo durante un metodo di test o setUp () salta il test corrente.
7	debug() Esegui il test senza raccogliere il risultato.
8	shortDescription() Restituisce una descrizione di una riga del test.

Infissi

Ci possono essere numerosi test scritti all'interno di una classe TestCase. Questi metodi di prova potrebbero richiedere la connessione al database, i file temporanei o altre risorse per essere inizializzati. Questi sono chiamati infissi. TestCase include un gancio speciale per configurare e pulire tutti i dispositivi necessari per i tuoi test. Per configurare le apparecchiature, sovrascrivere setUp (). Per ripulire, sovrascrivi tearDown ().

Nell'esempio seguente, due test vengono scritti all'interno della classe TestCase. Testano il risultato dell'addizione e della sottrazione di due valori. Il metodo setup () inizializza gli argomenti in base a shortDescription () di ogni test. Il metodo teardown () verrà eseguito alla fine di ogni test.

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

Esegui il codice precedente dalla riga di comando. Fornisce il seguente output:

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)

Apparecchio di classe

La classe TestCase ha un metodo setUpClass () che può essere sovrascritto per essere eseguito prima dell'esecuzione dei singoli test all'interno di una classe TestCase. Allo stesso modo, il metodo tearDownClass () verrà eseguito dopo tutti i test nella classe. Entrambi i metodi sono metodi di classe. Quindi, devono essere decorati con la direttiva @classmethod.

Il seguente esempio dimostra l'uso di questi metodi di 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

Il framework di test di Python fornisce un meccanismo utile mediante il quale le istanze dei casi di test possono essere raggruppate in base alle funzionalità che testano. Questo meccanismo è reso disponibile dalla classe TestSuite nel modulo unittest.

I passaggi seguenti sono coinvolti nella creazione e nell'esecuzione di una suite di test.

Step 1 - Crea un'istanza della classe TestSuite.

suite = unittest.TestSuite()

Step 2 - Aggiungi test all'interno di una classe TestCase nella suite.

suite.addTest(testcase class)

Step 3 - Puoi anche usare il metodo makeSuite () per aggiungere test da una classe

suite = unittest.makeSuite(test case class)

Step 4 - È anche possibile aggiungere test individuali alla suite.

suite.addTest(testcaseclass(""testmethod")

Step 5 - Crea un oggetto della classe TestTestRunner.

runner = unittest.TextTestRunner()

Step 6 - Chiama il metodo run () per eseguire tutti i test nella suite

runner.run (suite)

I seguenti metodi sono definiti nella classe TestSuite:

Sr.No.	Metodo e descrizione
1	addTest() Aggiunge un metodo di test nella suite di test.
2	addTests() Aggiunge test da più classi TestCase.
3	run() Esegue i test associati a questa suite, raccogliendo il risultato nell'oggetto risultato del test
4	debug() Esegue i test associati a questa suite senza raccogliere il risultato.
5	countTestCases() Restituisce il numero di test rappresentato da questo oggetto di test

L'esempio seguente mostra come utilizzare la 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)

Puoi sperimentare con il metodo addTest () decommentando le righe e la dichiarazione di commento con il metodo makeSuite ().

Classe TestLoader

Il pacchetto unittest ha la classe TestLoader che viene utilizzata per creare suite di test da classi e moduli. Per impostazione predefinita, l'istanza unittest.defaultTestLoader viene creata automaticamente quando viene chiamato il metodo unittest.main (0. Un'istanza esplicita, tuttavia, consente la personalizzazione di alcune proprietà.

Nel codice seguente, i test di due classi vengono raccolti in un elenco utilizzando l'oggetto 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)

La tabella seguente mostra un elenco di metodi nella classe TestLoader:

Suor n	Metodo e descrizione
1	loadTestsFromTestCase() Restituisce una suite di tutti i casi di test contenuti in una classe TestCase
2	loadTestsFromModule() Restituisce una suite di tutti i casi di test contenuti nel modulo dato.
3	loadTestsFromName() Restituisce una suite di tutti i casi di test dato uno specificatore di stringa.
4	discover() Trova tutti i moduli di test ricorrendo nelle sottodirectory dalla directory di avvio specificata e restituisci un oggetto TestSuite

Classe TestResult

Questa classe viene utilizzata per compilare informazioni sui test che hanno avuto esito positivo e sui test che hanno avuto esito negativo. Un oggetto TestResult archivia i risultati di una serie di test. Un'istanza TestResult viene restituita dal metodo TestRunner.run ().

Le istanze di TestResult hanno i seguenti attributi:

Sr.No.	Attributo e descrizione
1	Errors Un elenco contenente 2 tuple di istanze di TestCase e stringhe contenenti traceback formattati. Ogni tupla rappresenta un test che ha sollevato un'eccezione imprevista.
2	Failures Un elenco contenente 2 tuple di istanze di TestCase e stringhe contenenti traceback formattati. Ogni tupla rappresenta un test in cui un errore è stato esplicitamente segnalato utilizzando i metodi TestCase.assert * ().
3	Skipped Un elenco contenente 2 tuple di istanze di TestCase e stringhe contenenti il motivo per cui si è saltato il test.
4	wasSuccessful() Restituisce True se tutti i test eseguiti finora sono stati superati, altrimenti restituisce False.
5	stop() Questo metodo può essere chiamato per segnalare che il set di test in esecuzione deve essere interrotto.
6	startTestRun() Chiamato una volta prima dell'esecuzione di qualsiasi test.
7	stopTestRun() Chiamato una volta dopo che tutti i test sono stati eseguiti.
8	testsRun Il numero totale di test eseguiti finora.
9	Buffer Se impostato su true, sys.stdout e sys.stderrverrà memorizzato nel buffer tra startTest () e stopTest () in fase di chiamata.

Il codice seguente esegue una suite di test:

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"

Il codice quando viene eseguito mostra il seguente output:

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

↰ Previous page Next page ↱