Python Unit Testing: Automatyczne uruchamianie debuggera, gdy test się nie powiedzie

Myślę, że to, czego szukasz, to nos . Działa jak biegacz testowy dla unittest .

Możesz wpaść do debuggera w przypadku błędów, za pomocą następującego polecenia:

nosetests --pdb

Prostą opcją jest po prostu Uruchamianie testów bez zbierania wyników i pozwalanie, aby pierwszy wyjątek spadł ze stosu (dla arbitralnej obsługi post mortem) przez np.

try: unittest.findTestCases(__main__).debug()
except:
    pdb.post_mortem(sys.exc_info()[2])

Inna opcja: Zastąp unittest.TextTestResult'S addError i addFailure w testowym biegaczu debugowania do natychmiastowego debugowania post_mortem (przed tearDown()) - lub do zbierania i obsługi błędów i tracebacków w zaawansowany sposób.

(nie wymaga dodatkowych ram ani dodatkowego dekoratora dla metod badawczych)

Podstawowe przykład:

import unittest, pdb

class TC(unittest.TestCase):
    def testZeroDiv(self):
        1 / 0

def debugTestRunner(post_mortem=None):
    """unittest runner doing post mortem debugging on failing tests"""
    if post_mortem is None:
        post_mortem = pdb.post_mortem
    class DebugTestResult(unittest.TextTestResult):
        def addError(self, test, err):
            # called before tearDown()
            traceback.print_exception(*err)
            post_mortem(err[2])
            super(DebugTestResult, self).addError(test, err)
        def addFailure(self, test, err):
            traceback.print_exception(*err)
            post_mortem(err[2])
            super(DebugTestResult, self).addFailure(test, err)
    return unittest.TextTestRunner(resultclass=DebugTestResult)

if __name__ == '__main__':
    ##unittest.main()
    unittest.main(testRunner=debugTestRunner())
    ##unittest.main(testRunner=debugTestRunner(pywin.debugger.post_mortem))
    ##unittest.findTestCases(__main__).debug()

Zewnętrzne ulepszenia frameworku testowego wydają się na ogół obejmować tę funkcję (nose i nose2 były już wspomniane w innych odpowiedziach). Trochę więcej:

Pytest go wspiera.

pytest --pdb

Lub jeśli używasz absl-py ' S absltest zamiast unittest module:

name_of_test.py --pdb_post_mortem

Aby zastosować odpowiedź@cmcginty do następcy nos 2 (zalecane przez nose dostępne na systemach opartych na Debianie przez apt-get install nose2), możesz wpaść do debugera na awarie i błędy, wywołując

nose2

W katalogu testów.

W tym celu musisz mieć odpowiedni .unittest.cfg w katalogu domowym lub unittest.cfg w katalogu projektu; musi on zawierać linie

[debugger]
always-on = True
errors-only = False

Oto wbudowane, bez dodatkowych modułów rozwiązanie:

import unittest
import sys
import pdb

####################################
def ppdb(e=None):
    """conditional debugging
       use with:  `if ppdb(): pdb.set_trace()` 
    """
    return ppdb.enabled

ppdb.enabled = False
###################################


class SomeTest(unittest.TestCase):

    def test_success(self):
        try:
            pass
        except Exception, e:
            if ppdb(): pdb.set_trace()
            raise

    def test_fail(self):
        try:
            res = 1/0
            #note:  a `nosetests --pdb` run will stop after any exception
            #even one without try/except and ppdb() does not not modify that.
        except Exception, e:
            if ppdb(): pdb.set_trace()
            raise


if __name__ == '__main__':
    #conditional debugging, but not in nosetests
    if "--pdb" in sys.argv:
        print "pdb requested"
        ppdb.enabled = not sys.argv[0].endswith("nosetests")
        sys.argv.remove("--pdb")

    unittest.main()

Zadzwoń z {[1] } i się zatrzyma. W przeciwnym razie nie będzie.