Wie führe ich alle Python-Komponententests in einem Verzeichnis aus?

Ich habe ein Verzeichnis, das meine Python-Unit-Tests enthält. Jedes Unit-Test-Modul hat die Form test _ *. Py . Ich versuche, eine Datei mit dem Namen all_test.py zu erstellen , die, wie Sie es erraten haben, alle Dateien in der oben genannten Testform ausführt und das Ergebnis zurückgibt . Ich habe bisher zwei Methoden ausprobiert; beide sind gescheitert. Ich werde die beiden Methoden zeigen, und ich hoffe, jemand da draußen weiß, wie man das tatsächlich richtig macht.

Bei meinem ersten tapferen Versuch dachte ich: "Wenn ich nur alle meine unittest.main()Testmodule in die Datei importiere und dann diesen Doodad aufrufe, funktioniert es, oder?" Es stellte sich heraus, dass ich falsch lag.

import glob
import unittest

testSuite = unittest.TestSuite()
test_file_strings = glob.glob('test_*.py')
module_strings = [str[0:len(str)-3] for str in test_file_strings]

if __name__ == "__main__":
     unittest.main()

Das hat nicht funktioniert, das Ergebnis war:

$ python all_test.py 

----------------------------------------------------------------------
Ran 0 tests in 0.000s

OK

Für meinen zweiten Versuch werde ich allerdings versuchen, diese ganze Testsache "manueller" zu machen. Also habe ich versucht, das unten zu tun:

import glob
import unittest

testSuite = unittest.TestSuite()
test_file_strings = glob.glob('test_*.py')
module_strings = [str[0:len(str)-3] for str in test_file_strings]
[__import__(str) for str in module_strings]
suites = [unittest.TestLoader().loadTestsFromName(str) for str in module_strings]
[testSuite.addTest(suite) for suite in suites]
print testSuite 

result = unittest.TestResult()
testSuite.run(result)
print result

#Ok, at this point I have a result
#How do I display it as the normal unit test command line output?
if __name__ == "__main__":
    unittest.main()

Das hat auch nicht funktioniert, aber es scheint so nah!

$ python all_test.py 
<unittest.TestSuite tests=[<unittest.TestSuite tests=[<unittest.TestSuite tests=[<test_main.TestMain testMethod=test_respondes_to_get>]>]>]>
<unittest.TestResult run=1 errors=0 failures=0>

----------------------------------------------------------------------
Ran 0 tests in 0.000s

OK

Ich habe anscheinend eine Suite, und ich kann das Ergebnis ausführen. Ich bin ein wenig besorgt über die Tatsache, dass es heißt, ich habe nur run=1, scheint so zu sein run=2, aber es ist Fortschritt. Aber wie übergebe ich das Ergebnis und zeige es an main an? Oder wie kann ich es im Grunde zum Laufen bringen, damit ich diese Datei einfach ausführen und dabei alle Komponententests in diesem Verzeichnis ausführen kann?

Mit Python 2.7 und höher müssen Sie keinen neuen Code schreiben oder Tools von Drittanbietern verwenden, um dies zu tun. Die rekursive Testausführung über die Befehlszeile ist integriert. Legen Sie ein __init__.pyin Ihr Testverzeichnis und:

python -m unittest discover <test_directory>
# or
python -m unittest discover -s <directory> -p '*_test.py'

Weitere Informationen finden Sie in der unittest-Dokumentation zu Python 2.7 oder Python 3.x.

Sie könnten einen Testläufer verwenden, der dies für Sie erledigt. Nase ist zum Beispiel sehr gut. Beim Ausführen werden Tests im aktuellen Baum gefunden und ausgeführt.

Aktualisiert:

Hier ist ein Code aus meiner Zeit vor der Nase. Sie möchten wahrscheinlich nicht die explizite Liste der Modulnamen, aber vielleicht ist der Rest für Sie nützlich.

testmodules = [
    'cogapp.test_makefiles',
    'cogapp.test_whiteutils',
    'cogapp.test_cogapp',
    ]

suite = unittest.TestSuite()

for t in testmodules:
    try:
        # If the module defines a suite() function, call it to get the suite.
        mod = __import__(t, globals(), locals(), ['suite'])
        suitefn = getattr(mod, 'suite')
        suite.addTest(suitefn())
    except (ImportError, AttributeError):
        # else, just load all the test cases from the module.
        suite.addTest(unittest.defaultTestLoader.loadTestsFromName(t))

unittest.TextTestRunner().run(suite)

Wenn Sie in Python 3 Folgendes verwenden unittest.TestCase:

• Sie müssen eine leere (oder anderweitige) __init__.pyDatei in Ihrem testVerzeichnis haben ( muss benannt werden test/)
• Ihre darin enthaltenen Testdateien test/stimmen mit dem Muster überein test_*.py. Sie können sich in einem Unterverzeichnis unter befinden test/, und diese Unterverzeichnisse können wie alles benannt werden.

Anschließend können Sie alle Tests ausführen mit:

python -m unittest

Erledigt! Eine Lösung mit weniger als 100 Zeilen. Hoffentlich spart ein anderer Python-Anfänger Zeit, indem er dies findet.

Dies ist jetzt direkt von unittest aus möglich: unittest.TestLoader.discover .

import unittest
loader = unittest.TestLoader()
start_dir = 'path/to/your/test/files'
suite = loader.discover(start_dir)

runner = unittest.TextTestRunner()
runner.run(suite)

Nun, indem ich den obigen Code ein wenig studierte (speziell mit TextTestRunnerund defaultTestLoader), konnte ich ziemlich nahe kommen. Schließlich habe ich meinen Code behoben, indem ich auch alle Testsuiten an einen einzelnen Suites-Konstruktor übergeben habe, anstatt sie "manuell" hinzuzufügen, wodurch meine anderen Probleme behoben wurden. Also hier ist meine Lösung.

import glob
import unittest

test_files = glob.glob('test_*.py')
module_strings = [test_file[0:len(test_file)-3] for test_file in test_files]
suites = [unittest.defaultTestLoader.loadTestsFromName(test_file) for test_file in module_strings]
test_suite = unittest.TestSuite(suites)
test_runner = unittest.TextTestRunner().run(test_suite)

Ja, es ist wahrscheinlich einfacher, nur die Nase zu benutzen, als dies zu tun, aber das ist nicht der Punkt.

Wenn Sie alle Tests aus verschiedenen Testfallklassen ausführen möchten und diese gerne explizit angeben, können Sie dies folgendermaßen tun:

from unittest import TestLoader, TextTestRunner, TestSuite
from uclid.test.test_symbols import TestSymbols
from uclid.test.test_patterns import TestPatterns

if __name__ == "__main__":

    loader = TestLoader()
    tests = [
        loader.loadTestsFromTestCase(test)
        for test in (TestSymbols, TestPatterns)
    ]
    suite = TestSuite(tests)

    runner = TextTestRunner(verbosity=2)
    runner.run(suite)

Wo uclidist mein Projekt und TestSymbolsund TestPatternssind Unterklassen von TestCase.

Ich habe die discoverMethode und eine Überladung von verwendet load_tests, um dieses Ergebnis in einer (meiner Meinung nach minimalen) Anzahl von Codezeilen zu erzielen:

def load_tests(loader, tests, pattern):
''' Discover and load all unit tests in all files named ``*_test.py`` in ``./src/``
'''
    suite = TestSuite()
    for all_test_suite in unittest.defaultTestLoader.discover('src', pattern='*_tests.py'):
        for test_suite in all_test_suite:
            suite.addTests(test_suite)
    return suite

if __name__ == '__main__':
    unittest.main()

Hinrichtung auf fünf so etwas wie

Ran 27 tests in 0.187s
OK

Ich habe verschiedene Ansätze ausprobiert, aber alle scheinen fehlerhaft zu sein, oder ich muss Code erstellen, das ist ärgerlich. Aber unter Linux gibt es einen bequemen Weg, einfach jeden Test anhand eines bestimmten Musters zu finden und ihn dann einzeln aufzurufen.

find . -name 'Test*py' -exec python '{}' \;

und vor allem funktioniert es definitiv.

Im Falle einer gepackten Bibliothek oder Anwendung möchten Sie dies nicht tun. setuptools werde es für dich tun .

Um diesen Befehl verwenden zu können, müssen die Tests Ihres Projekts unittestentweder von einer Funktion, einer TestCase-Klasse oder -Methode oder einem Modul oder Paket mit TestCaseKlassen in eine Testsuite eingeschlossen werden. Wenn die benannte Suite ein Modul ist und das Modul eine additional_tests()Funktion hat, wird sie aufgerufen und das Ergebnis (das a sein muss unittest.TestSuite) zu den auszuführenden Tests hinzugefügt. Wenn die genannte Suite ein Paket ist, werden alle Submodule und Unterpakete rekursiv zur gesamten Testsuite hinzugefügt .

Sagen Sie einfach, wo sich Ihr Root-Testpaket befindet, wie:

setup(
    # ...
    test_suite = 'somepkg.test'
)

Und renn python setup.py test.

Die discoverdateibasierte Erkennung kann in Python 3 problematisch sein, es sei denn, Sie vermeiden relative Importe in Ihre Testsuite, da der Dateiimport verwendet wird. Obwohl es optional unterstützt top_level_dir, hatte ich einige unendliche Rekursionsfehler. Eine einfache Lösung für einen nicht gepackten Code besteht darin, Folgendes in __init__.pyIhr Testpaket einzufügen (siehe load_tests-Protokoll ).

import unittest

from . import foo, bar


def load_tests(loader, tests, pattern):
    suite = unittest.TestSuite()
    suite.addTests(loader.loadTestsFromModule(foo))
    suite.addTests(loader.loadTestsFromModule(bar))

    return suite

Ich verwende PyDev / LiClipse und habe nicht wirklich herausgefunden, wie alle Tests gleichzeitig über die GUI ausgeführt werden können. (Bearbeiten: Sie klicken mit der rechten Maustaste auf den Stammtestordner und wählenRun as -> Python unit-test

Dies ist meine aktuelle Problemumgehung:

import unittest

def load_tests(loader, tests, pattern):
    return loader.discover('.')

if __name__ == '__main__':
    unittest.main()

Ich habe diesen Code in ein Modul eingefügt, das allin meinem Testverzeichnis aufgerufen wird . Wenn ich dieses Modul als Unittest von LiClipse aus starte, werden alle Tests ausgeführt. Wenn ich nur bestimmte oder fehlgeschlagene Tests wiederholen möchte, werden nur diese Tests ausgeführt. Es stört auch meinen Befehlszeilentestläufer nicht (Nosetests) - es wird ignoriert.

Möglicherweise müssen Sie die Argumente discoverbasierend auf Ihrem Projekt-Setup ändern .

Basierend auf der Antwort von Stephen Cagle habe ich Unterstützung für verschachtelte Testmodule hinzugefügt.

import fnmatch
import os
import unittest

def all_test_modules(root_dir, pattern):
    test_file_names = all_files_in(root_dir, pattern)
    return [path_to_module(str) for str in test_file_names]

def all_files_in(root_dir, pattern):
    matches = []

    for root, dirnames, filenames in os.walk(root_dir):
        for filename in fnmatch.filter(filenames, pattern):
            matches.append(os.path.join(root, filename))

    return matches

def path_to_module(py_file):
    return strip_leading_dots( \
        replace_slash_by_dot(  \
            strip_extension(py_file)))

def strip_extension(py_file):
    return py_file[0:len(py_file) - len('.py')]

def replace_slash_by_dot(str):
    return str.replace('\\', '.').replace('/', '.')

def strip_leading_dots(str):
    while str.startswith('.'):
       str = str[1:len(str)]
    return str

module_names = all_test_modules('.', '*Tests.py')
suites = [unittest.defaultTestLoader.loadTestsFromName(mname) for mname 
    in module_names]

testSuite = unittest.TestSuite(suites)
runner = unittest.TextTestRunner(verbosity=1)
runner.run(testSuite)

Der Code durchsucht alle Unterverzeichnisse von .nach *Tests.pyDateien, die dann geladen werden. Es wird erwartet, dass jede *Tests.pyKlasse eine einzelne Klasse enthält, *Tests(unittest.TestCase)die nacheinander geladen und nacheinander ausgeführt wird.

Dies funktioniert mit einer willkürlichen tiefen Verschachtelung von Verzeichnissen / Modulen, aber jedes Verzeichnis dazwischen muss __init__.pymindestens eine leere Datei enthalten . Auf diese Weise kann der Test die verschachtelten Module laden, indem Schrägstriche (oder Backslashes) durch Punkte ersetzt werden (siehe replace_slash_by_dot).

Dies ist eine alte Frage, aber was jetzt (2019) für mich funktioniert hat, ist:

python -m unittest *_test.py

Alle meine Testdateien befinden sich im selben Ordner wie die Quelldateien und enden mit _test.

Da die Testerkennung ein vollständiges Thema zu sein scheint, gibt es einen speziellen Rahmen für die Testerkennung:

• Nase
• Py.Test

Weitere Informationen finden Sie hier: https://wiki.python.org/moin/PythonTestingToolsTaxonomy

Dieses BASH-Skript führt das Python-Unittest-Testverzeichnis von ANYWHERE im Dateisystem aus, unabhängig davon, in welchem ​​Arbeitsverzeichnis Sie sich befinden: Das Arbeitsverzeichnis testbefindet sich immer dort, wo sich dieses Verzeichnis befindet.

ALLE TESTS, unabhängig $ PWD

Das unittest Python-Modul reagiert empfindlich auf Ihr aktuelles Verzeichnis, es sei denn, Sie geben an, wo (mit der discover -sOption).

Dies ist nützlich, wenn Sie im ./srcoder ./exampleArbeitsverzeichnis bleiben und einen schnellen Gesamttest benötigen:

#!/bin/bash
this_program="$0"
dirname="`dirname $this_program`"
readlink="`readlink -e $dirname`"

python -m unittest discover -s "$readlink"/test -v

AUSGEWÄHLTE TESTS, unabhängige $ PWD

Ich benenne diese Dienstprogrammdatei: runone.pyund benutze sie wie folgt:

runone.py <test-python-filename-minus-dot-py-fileextension>

#!/bin/bash
this_program="$0"
dirname="`dirname $this_program`"
readlink="`readlink -e $dirname`"

(cd "$dirname"/test; python -m unittest $1)

Es ist keine test/__init__.pyDatei erforderlich, um den Paket- / Speicheraufwand während der Produktion zu belasten.

Hier ist mein Ansatz, indem ich einen Wrapper erstelle , um Tests über die Befehlszeile auszuführen:

#!/usr/bin/env python3
import os, sys, unittest, argparse, inspect, logging

if __name__ == '__main__':
    # Parse arguments.
    parser = argparse.ArgumentParser(add_help=False)
    parser.add_argument("-?", "--help",     action="help",                        help="show this help message and exit" )
    parser.add_argument("-v", "--verbose",  action="store_true", dest="verbose",  help="increase output verbosity" )
    parser.add_argument("-d", "--debug",    action="store_true", dest="debug",    help="show debug messages" )
    parser.add_argument("-h", "--host",     action="store",      dest="host",     help="Destination host" )
    parser.add_argument("-b", "--browser",  action="store",      dest="browser",  help="Browser driver.", choices=["Firefox", "Chrome", "IE", "Opera", "PhantomJS"] )
    parser.add_argument("-r", "--reports-dir", action="store",   dest="dir",      help="Directory to save screenshots.", default="reports")
    parser.add_argument('files', nargs='*')
    args = parser.parse_args()

    # Load files from the arguments.
    for filename in args.files:
        exec(open(filename).read())

    # See: http://codereview.stackexchange.com/q/88655/15346
    def make_suite(tc_class):
        testloader = unittest.TestLoader()
        testnames = testloader.getTestCaseNames(tc_class)
        suite = unittest.TestSuite()
        for name in testnames:
            suite.addTest(tc_class(name, cargs=args))
        return suite

    # Add all tests.
    alltests = unittest.TestSuite()
    for name, obj in inspect.getmembers(sys.modules[__name__]):
        if inspect.isclass(obj) and name.startswith("FooTest"):
            alltests.addTest(make_suite(obj))

    # Set-up logger
    verbose = bool(os.environ.get('VERBOSE', args.verbose))
    debug   = bool(os.environ.get('DEBUG', args.debug))
    if verbose or debug:
        logging.basicConfig( stream=sys.stdout )
        root = logging.getLogger()
        root.setLevel(logging.INFO if verbose else logging.DEBUG)
        ch = logging.StreamHandler(sys.stdout)
        ch.setLevel(logging.INFO if verbose else logging.DEBUG)
        ch.setFormatter(logging.Formatter('%(asctime)s %(levelname)s: %(name)s: %(message)s'))
        root.addHandler(ch)
    else:
        logging.basicConfig(stream=sys.stderr)

    # Run tests.
    result = unittest.TextTestRunner(verbosity=2).run(alltests)
    sys.exit(not result.wasSuccessful())

Entschuldigen Sie der Einfachheit halber meine Nicht- PEP8- Codierungsstandards.

Dann können Sie für alle Ihre Tests eine BaseTest-Klasse für allgemeine Komponenten erstellen, sodass jeder Ihrer Tests einfach so aussehen würde:

from BaseTest import BaseTest
class FooTestPagesBasic(BaseTest):
    def test_foo(self):
        driver = self.driver
        driver.get(self.base_url + "/")

Zum Ausführen geben Sie einfach Tests als Teil der Befehlszeilenargumente an, z.

./run_tests.py -h http://example.com/ tests/**/*.py