Come utilizzare pytest per controllare che l'errore non viene generato

Question

Supponiamo che abbiamo dovrebbe occupare del genere:

import py, pytest 

ERROR1 = ' --- Error : value < 5! ---' 
ERROR2 = ' --- Error : value > 10! ---' 

class MyError(Exception): 
    def __init__(self, m): 
     self.m = m 

    def __str__(self): 
     return self.m 

def foo(i): 
    if i < 5: 
     raise MyError(ERROR1) 
    elif i > 10: 
     raise MyError(ERROR2) 
    return i 


# ---------------------- TESTS ------------------------- 
def test_foo1(): 
    with pytest.raises(MyError) as e: 
     foo(3) 
    assert ERROR1 in str(e) 

def test_foo2(): 
    with pytest.raises(MyError) as e: 
     foo(11) 
    assert ERROR2 in str(e) 

def test_foo3(): 
     .... 
     foo(7) 
     .... 

D: Come posso fare test_foo3() per testare, che nessuna MyError è sollevata? E 'ovvio, che ho potuto solo prova:

def test_foo3(): 
    assert foo(7) == 7 

ma voglio provare che via pytest.raises(). È possibile in qualche modo? Ad esempio: in un caso, tale funzione "foo" non ha alcun ritorno valore,

def foo(i): 
    if i < 5: 
     raise MyError(ERROR1) 
    elif i > 10: 
     raise MyError(ERROR2) 

potrebbe avere senso per testare questo modo, imho.

Answer 1

Un test avrà esito negativo se solleva qualsiasi tipo di Eccezione imprevista. Puoi semplicemente invocare foo (7) e avrai verificato che nessun MyError viene generato. Così, dopo sarà sufficiente:

def test_foo3(): 
    foo(7) 

Se davvero si vuole scrivere un assert per questo, si può provare:

def test_foo3(): 
    try: 
     foo(7) 
    except MyError: 
     pytest.fail("Unexpected MyError ..") 

Answer 2

ero curioso di vedere se un not_raises avrebbe funzionato. Un rapido test di questo è (test_notraises.py):

from contextlib import contextmanager 

@contextmanager 
def not_raises(ExpectedException): 
    try: 
     yield 

    except ExpectedException, err: 
     raise AssertionError(
      "Did raise exception {0} when it should not!".format(
       repr(ExpectedException) 
      ) 
     ) 

    except Exception, err: 
     raise AssertionError(
      "An unexpected exception {0} raised.".format(repr(err)) 
     ) 

def good_func(): 
    print "hello" 


def bad_func(): 
    raise ValueError("BOOM!") 


def ugly_func(): 
    raise IndexError("UNEXPECTED BOOM!") 


def test_ok(): 
    with not_raises(ValueError): 
     good_func() 


def test_bad(): 
    with not_raises(ValueError): 
     bad_func() 


def test_ugly(): 
    with not_raises(ValueError): 
     ugly_func() 

Non sembra funzionare. Tuttavia non sono sicuro che sia davvero valido nel test .

Answer 3

Basandosi sulla cima di quello che Oisin menzionato ..

È possibile effettuare una semplice funzione not_raises che agisce simile a quella di pytest raises:

from contextlib import contextmanager 

@contextmanager 
def not_raises(exception): 
    try: 
    yield 
    except exception: 
    raise pytest.fail("DID RAISE {0}".format(exception)) 

Questo va bene se si vuole attaccare ad avere raises avere una controparte e quindi i tuoi test sono più leggibili. In sostanza, tuttavia, non è necessario nulla oltre al semplice esecuzione del blocco di codice che si desidera testare sulla propria linea - pytest fallirà comunque non appena quel blocco genera un errore.