Framework UnitTest - Asserzione

Il framework di test Python utilizza la funzione assert () incorporata di Python che verifica una particolare condizione. Se l'asserzione fallisce, verrà sollevata un'eccezione AssertionError. Il framework di test identificherà quindi il test come Fallimento. Altre eccezioni vengono trattate come Errore.

I seguenti tre set di funzioni di asserzione sono definiti nel modulo unittest:

Asserzioni booleane di base
Affermazioni comparative
Afferma per le raccolte

Le funzioni di asserzione di base valutano se il risultato di un'operazione è Vero o Falso. Tutti i metodi di asserzione accettano amsg argomento che, se specificato, viene utilizzato come messaggio di errore in caso di fallimento.

Sr.No.	Metodo e descrizione
1	assertEqual(arg1, arg2, msg = None) Verifica che arg1 e arg2 siano uguali. Se i valori non sono uguali, il test fallirà.
2	assertNotEqual(arg1, arg2, msg = None) Verifica che arg1 e arg2 non siano uguali. Se i valori sono uguali, il test fallirà.
3	assertTrue(expr, msg = None) Verifica che expr sia vero. Se falso, il test fallisce
4	assertFalse(expr, msg = None) Verifica che espr sia falso. Se è vero, il test fallisce
5	assertIs(arg1, arg2, msg = None) Verifica che arg1 e arg2 valutino lo stesso oggetto.
6	assertIsNot(arg1, arg2, msg = None) Verifica che arg1 e arg2 non restituiscano lo stesso oggetto.
7	assertIsNone(expr, msg = None) Verifica che espr sia Nessuno. Se non è Nessuno, il test fallisce
8	assertIsNotNone(expr, msg = None) Verifica che espr non sia None. Se Nessuno, il test fallisce
9	assertIn(arg1, arg2, msg = None) Verifica che arg1 sia in arg2 .
10	assertNotIn(arg1, arg2, msg = None) Verifica che arg1 non sia in arg2 .
11	assertIsInstance(obj, cls, msg = None) Verifica che obj sia un'istanza di cls
12	assertNotIsInstance(obj, cls, msg = None) Verifica che obj non sia un'istanza di cls

Alcune delle funzioni di asserzione precedenti sono implementate nel codice seguente:

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 lo script precedente viene eseguito, test2, test4 e test6 mostreranno un errore e altri verranno eseguiti correttamente.

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)

La seconda serie di funzioni di asserzione sono comparative asserts −

assertAlmostEqual (primo, secondo, posizioni = 7, msg = Nessuno, delta = Nessuno)

Test che prima e seconda sono approssimativamente (o meno circa) uguale calcolando la differenza, arrotondamento al numero specificato di decimali posti (default 7),
assertNotAlmostEqual (primo, secondo, luoghi, msg, delta)

Verifica che il primo e il secondo non siano approssimativamente uguali calcolando la differenza, arrotondando al numero di cifre decimali specificato (predefinito 7) e confrontando a zero.

In entrambe le funzioni di cui sopra, se delta viene fornito al posto dei posti, la differenza tra il primo e il secondo deve essere minore o uguale a (o maggiore di) delta.

Fornire sia delta che posti solleva un'eccezione TypeError.
assertGreater (primo, secondo, msg = Nessuno)

Verificare che il primo sia maggiore del secondo a seconda del nome del metodo. In caso contrario, il test fallirà.
assertGreaterEqual (primo, secondo, msg = Nessuno)

Verificare che il primo sia maggiore o uguale al secondo a seconda del nome del metodo. In caso contrario, il test fallirà
assertLess (primo, secondo, msg = Nessuno)

Verifica che il primo sia inferiore al secondo a seconda del nome del metodo. In caso contrario, il test fallirà
assertLessEqual (primo, secondo, msg = Nessuno)

Verificare che il primo sia minore o uguale al secondo a seconda del nome del metodo. In caso contrario, il test fallirà.
assertRegexpMatches (testo, regexp, msg = Nessuno)

Verifica che una ricerca regexp corrisponda al testo. In caso di errore, il messaggio di errore includerà il modello e il testo. regexp può essere un oggetto espressione regolare o una stringa contenente un'espressione regolare adatta all'uso da parte dire.search().
assertNotRegexpMatches (testo, regexp, msg = Nessuno)

Verifica che una ricerca regexp non corrisponda al testo . Non riesce con un messaggio di errore che include il modello e la parte di testo che corrisponde. regexp può essere un oggetto espressione regolare o una stringa contenente un'espressione regolare adatta all'uso da parte di re.search () .

Le funzioni di asserzione sono implementate nel seguente esempio:

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

Lo script precedente riporta test1 e test4 come Fallimento. In test1, la divisione di 22/7 non è entro 7 cifre decimali di 3,14. Allo stesso modo, poiché il secondo argomento corrisponde al testo nel primo argomento, test4 restituisce 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)

Affermare per le raccolte

Questo set di funzioni di asserzione è pensato per essere utilizzato con i tipi di dati di raccolta in Python, come List, Tuple, Dictionary e Set.

Sr.No.	Metodo e descrizione
1	assertListEqual (list1, list2, msg = None) Verifica che due elenchi siano uguali. In caso contrario, viene creato un messaggio di errore che mostra solo le differenze tra i due.
2	assertTupleEqual (tuple1, tuple2, msg = None) Verifica che due tuple siano uguali. In caso contrario, viene creato un messaggio di errore che mostra solo le differenze tra i due.
3	assertSetEqual (set1, set2, msg = None) Verifica che due set sono uguali. In caso contrario, viene creato un messaggio di errore che elenca le differenze tra i set.
4	assertDictEqual (expected, actual, msg = None) Verifica che due dizionari siano uguali. In caso contrario, viene creato un messaggio di errore che mostra le differenze nei dizionari.

Il seguente esempio implementa i metodi precedenti:

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

Nell'esempio precedente, test1 e test3 mostrano AssertionError. Il messaggio di errore visualizza le differenze negli oggetti Elenco e Dizionario.

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 ↱

Framework UnitTest - Asserzione

Affermare per le raccolte

Tutorial di UnitTest Framework