CKTIS / Python
Verificare le eccezioni con assertRaises
Usa `unittest.TestCase.assertRaises` con un oggetto invocabile o in un blocco `with` per verificare che un’operazione sollevi l’eccezione attesa.
Versione: Python 3.12
Sintassi
self.assertRaises(exception, callable, *args, **kwds)
with self.assertRaises(exception, msg=None) as cm:
operation()
# After a matching exception, inspect cm.exception.In Python 3.12, assertRaises è un metodo di unittest.TestCase. Passa una classe di eccezione, non un’istanza, oppure una tupla di classi se sono ammessi più tipi. Anche una sottoclasse di una classe attesa corrisponde. Un’eccezione corrispondente viene intercettata e l’asserzione riesce. Se non viene sollevata alcuna eccezione, l’asserzione fallisce. Un’eccezione non corrispondente si propaga e di norma viene segnalata come errore del test.
Nella forma con un oggetto invocabile, scrivi self.assertRaises(ValueError, parse_port, "0"). Passa parse_port senza chiamarla e fornisci separatamente i suoi argomenti posizionali e per nome. Non passare il risultato di parse_port("0"): la chiamata avverrebbe prima che l’asserzione possa intercettare l’eccezione.
Nella forma con un gestore di contesto, scrivi with self.assertRaises(ValueError) as cm: e inserisci nel blocco solo l’operazione che deve sollevare l’eccezione. Un’altra operazione che solleva lo stesso tipo potrebbe far riuscire l’asserzione per il motivo sbagliato. Dopo il blocco, cm.exception contiene l’istanza intercettata. In questa forma, msg= è facoltativo e fornisce un messaggio per il fallimento dell’asserzione, non un motivo da cercare nel testo dell’eccezione. Per verificare il testo con un’espressione regolare, usa assertRaisesRegex.
setUp() prepara i dati prima di ogni metodo di test, non prima di ogni blocco subTest(). assertEqual verifica i risultati dei casi validi e può anche confrontare il testo dell’eccezione intercettata. subTest(invalid=invalid) identifica ogni iterazione con il valore che comparirà nel rapporto se il sottotest fallisce.
Esempi
import io
import unittest
def parse_port(text):
port = int(text)
if not 1 <= port <= 65535:
raise ValueError("port must be between 1 and 65535")
return port
class PortTests(unittest.TestCase):
def setUp(self):
self.default_port = "80"
self.highest_port = "65535"
def test_context_form(self):
self.assertEqual(parse_port(self.default_port), 80)
self.assertEqual(parse_port(self.highest_port), 65535)
with self.assertRaises(ValueError) as cm:
parse_port("0")
self.assertEqual(str(cm.exception), "port must be between 1 and 65535")
def test_callable_form(self):
for invalid, valid, expected in (("0", "1", 1), ("65536", self.highest_port, 65535)):
with self.subTest(invalid=invalid):
self.assertEqual(parse_port(valid), expected)
self.assertRaises(ValueError, parse_port, invalid)
if __name__ == "__main__":
log = io.StringIO()
suite = unittest.defaultTestLoader.loadTestsFromTestCase(PortTests)
result = unittest.TextTestRunner(stream=log).run(suite)
if not result.wasSuccessful():
raise SystemExit(log.getvalue())
print(f"OK ({result.testsRun} tests)")
Risultato
OK (2 tests)
L’esempio verifica le porte valide, intercetta l’eccezione per `"0"` e ne confronta il testo. Poi verifica in sottotest identificati che `"0"` e `"65536"` vengano rifiutati. Il riepilogo personalizzato conta i due metodi di test, non le iterazioni dei sottotest.
Lezioni correlate
- Python · Lezione 37 · Avanzato · Versione: 5
- Python · Lezione 34 · Intermedio · Versione: 3
Fonti
- unittest — Unit testing framework: TestCase.assertRaises (Python 3.12)
- unittest — Unit testing framework: TestCase.assertRaisesRegex (Python 3.12)
- unittest — Unit testing framework: TestCase.setUp (Python 3.12)
- unittest — Unit testing framework: TestCase.assertEqual (Python 3.12)
- unittest — Unit testing framework: TestCase.subTest (Python 3.12)
- unittest — Unit testing framework: TextTestRunner (Python 3.12)