Wie pytest verwenden, die Fehler überprüfen NICHT

Question

angehoben

Nehmen wir an, wir haben smth wie folgt aus:

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

Q: Wie kann ich test_foo3() machen zu testen, dass kein MyError erhoben wird? Es ist offensichtlich, dass ich konnte einfach Test:

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

, aber ich, dass über pytest.raises testen möchten(). Ist das irgendwie möglich? Zum Beispiel: in einem Fall, dass die Funktion „foo“ haben keinen Rückgabewert überhaupt,

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

es Sinn machen könnte auf diese Weise zu testen, imho.

Answer 1

Ein Test wird fehlschlagen, wenn er irgendeine unerwartete Ausnahme auslöst. Sie können einfach foo (7) aufrufen und Sie werden getestet haben, dass kein MyError ausgelöst wird. So genügt folgendes:

def test_foo3(): 
    foo(7) 

Wenn Sie wirklich eine assert-Anweisung für diese schreiben möchten, können Sie versuchen:

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

Answer 2

Ich war neugierig zu sehen, ob ein not_raises funktionieren würde. Ein schneller Test dafür ist (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() 

Es zu funktionieren scheint. Allerdings bin ich mir nicht sicher, ob es im Test wirklich gut liest.

Answer 3

Gebäude auf, was Oisin erwähnt ..

Sie können eine einfache not_raises Funktion machen, die ähnlich wirkt pytest des raises:

from contextlib import contextmanager 

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

Das ist in Ordnung, wenn Sie mit raises haften möchten mit ein Gegenstück und somit sind Ihre Tests besser lesbar. Im Wesentlichen benötigen Sie jedoch nichts, als nur den zu testenden Code-Block in einer eigenen Zeile auszuführen - pytest wird trotzdem fehlschlagen, sobald dieser Block einen Fehler auslöst.