Die sehr verbreitete Verzeichnisstruktur selbst für ein einfaches Python-Modul scheint darin zu bestehen, die Komponententests in ein eigenes testVerzeichnis zu unterteilen:

new_project/
    antigravity/
        antigravity.py
    test/
        test_antigravity.py
    setup.py
    etc.

Sehen Sie sich zum Beispiel dieses Python-Projekt-Howto an .

Meine Frage ist einfach: Wie werden die Tests normalerweise ausgeführt? Ich vermute, dass dies für alle außer mir offensichtlich ist, aber Sie können nicht einfach vom Testverzeichnis python test_antigravity.pyaus ausführen, da dies import antigravityfehlschlagen wird, da sich das Modul nicht auf dem Pfad befindet.

Ich weiß, dass ich PYTHONPATH und andere Tricks im Zusammenhang mit Suchpfaden ändern könnte, aber ich kann nicht glauben, dass dies der einfachste Weg ist - es ist in Ordnung, wenn Sie der Entwickler sind, aber nicht realistisch, von Ihren Benutzern zu erwarten, dass sie sie verwenden, wenn sie nur die Tests überprüfen möchten Vorbeigehen.

Die andere Alternative besteht darin, die Testdatei nur in das andere Verzeichnis zu kopieren, aber es scheint ein bisschen dumm zu sein und es fehlt der Sinn, sie zunächst in einem separaten Verzeichnis zu haben.

Wenn Sie also gerade die Quelle in mein neues Projekt heruntergeladen hätten, wie würden Sie die Komponententests durchführen? Ich würde eine Antwort bevorzugen, mit der ich meinen Benutzern sagen könnte: "Um die Komponententests auszuführen, machen Sie X."

Die beste Lösung ist meiner Meinung nach, die unittest Befehlszeilenschnittstelle zu verwenden, die das Verzeichnis zu dem hinzufügt, sys.pathdamit Sie es nicht müssen (in der TestLoaderKlasse erledigt ).

Zum Beispiel für eine Verzeichnisstruktur wie diese:

new_project
├── antigravity.py
└── test_antigravity.py

Sie können einfach ausführen:

$ cd new_project
$ python -m unittest test_antigravity

Für eine Verzeichnisstruktur wie Ihre:

new_project
├── antigravity
│   ├── __init__.py         # make it a package
│   └── antigravity.py
└── test
    ├── __init__.py         # also make test a package
    └── test_antigravity.py

Und in den Testmodulen innerhalb des testPakets können Sie das antigravityPaket und seine Module wie gewohnt importieren :

# import the package
import antigravity

# import the antigravity module
from antigravity import antigravity

# or an object inside the antigravity module
from antigravity.antigravity import my_object

Ausführen eines einzelnen Testmoduls:

So führen Sie ein einzelnes Testmodul aus test_antigravity.py:

$ cd new_project
$ python -m unittest test.test_antigravity

Referenzieren Sie das Testmodul genauso wie Sie es importieren.

Ausführen eines einzelnen Testfalls oder einer Testmethode:

Sie können auch eine einzelne TestCaseoder eine einzelne Testmethode ausführen :

$ python -m unittest test.test_antigravity.GravityTestCase
$ python -m unittest test.test_antigravity.GravityTestCase.test_method

Alle Tests ausführen:

Sie können auch mit Test Entdeckung , die alle Tests für Sie entdecken und ausführen können , müssen sie benannt Module oder Pakete sein test*.py(kann mit der geändert werden -p, --patternflag):

$ cd new_project
$ python -m unittest discover
$ # Also works without discover for Python 3
$ # as suggested by @Burrito in the comments
$ python -m unittest

Dadurch werden alle test*.pyModule im testPaket ausgeführt.

Die einfachste Lösung für Ihre Benutzer besteht darin, ein ausführbares Skript ( runtests.pyoder ein solches) bereitzustellen, das die erforderliche Testumgebung bootet und bei Bedarf Ihr Stammprojektverzeichnis sys.pathvorübergehend hinzufügt . Dies erfordert nicht, dass Benutzer Umgebungsvariablen festlegen. So etwas funktioniert in einem Bootstrap-Skript einwandfrei:

import sys, os

sys.path.insert(0, os.path.dirname(__file__))

Dann können Ihre Anweisungen an Ihre Benutzer so einfach wie " python runtests.py" sein.

Wenn der Pfad, den Sie wirklich benötigen, wirklich ist os.path.dirname(__file__), müssen Sie ihn natürlich überhaupt nicht hinzufügen sys.path. Python setzt das Verzeichnis des aktuell ausgeführten Skripts immer an den Anfang von sys.path. Abhängig von Ihrer Verzeichnisstruktur ist runtests.pyes möglicherweise alles, was Sie benötigen , um Ihr Verzeichnis an der richtigen Stelle zu finden.

Auch das Unittest - Modul in Python 2.7+ (die als zurückportiert wird unittest2 für Python 2.6 und früher) hat nun Test Entdeckung eingebaut, so Nase ist nicht mehr erforderlich , wenn Sie automatisierte Test Entdeckung wollen: Ihre Benutzeranweisungen können so einfach wie python -m unittest discover.

Im Allgemeinen erstelle ich im Projektverzeichnis ein Skript zum Ausführen von Tests (das sowohl für das Quellverzeichnis als auch für das Quellverzeichnis gilt test), das meine Suite "Alle Tests" lädt. Dies ist normalerweise Boilerplate-Code, sodass ich ihn von Projekt zu Projekt wiederverwenden kann.

run_tests.py:

import unittest
import test.all_tests
testSuite = test.all_tests.create_test_suite()
text_runner = unittest.TextTestRunner().run(testSuite)

test / all_tests.py (von Wie führe ich alle Python- Komponententests in einem Verzeichnis aus? )

import glob
import unittest

def create_test_suite():
    test_file_strings = glob.glob('test/test_*.py')
    module_strings = ['test.'+str[5:len(str)-3] for str in test_file_strings]
    suites = [unittest.defaultTestLoader.loadTestsFromName(name) \
              for name in module_strings]
    testSuite = unittest.TestSuite(suites)
    return testSuite

Mit diesem Setup können Sie in der Tat nur include antigravityin Ihren Testmodulen. Der Nachteil ist, dass Sie mehr Support-Code benötigen, um einen bestimmten Test auszuführen ... Ich führe sie jedes Mal aus.

Aus dem Artikel, den Sie verlinkt haben:

Erstellen Sie eine Datei test_modulename.py und fügen Sie Ihre unittest Tests darin ein. Da sich die Testmodule in einem von Ihrem Code getrennten Verzeichnis befinden, müssen Sie möglicherweise das übergeordnete Verzeichnis Ihres Moduls zu Ihrem PYTHONPATH hinzufügen, um sie auszuführen:

$ cd /path/to/googlemaps

$ export PYTHONPATH=$PYTHONPATH:/path/to/googlemaps/googlemaps

$ python test/test_googlemaps.py

Schließlich gibt es ein weiteres beliebtes Unit-Testing-Framework für Python (so wichtig!), Die Nase. Mit der Nase können Sie das integrierte Framework vereinfachen und erweitern (es kann beispielsweise Ihren Testcode automatisch finden und Ihren PYTHONPATH für Sie einrichten), ist jedoch nicht in der Standard-Python-Distribution enthalten.

Vielleicht sollten Sie sich die Nase ansehen, wie es nahelegt?

Ich hatte das gleiche Problem mit einem separaten Ordner für Komponententests. Aus den genannten Vorschlägen füge ich den absoluten Source - Pfad zu sys.path.

Der Vorteil der folgenden Lösung besteht darin, dass die Datei ausgeführt werden kann, test/test_yourmodule.pyohne zunächst in das Testverzeichnis zu wechseln:

import sys, os
testdir = os.path.dirname(__file__)
srcdir = '../antigravity'
sys.path.insert(0, os.path.abspath(os.path.join(testdir, srcdir)))

import antigravity
import unittest

Wenn Sie "python setup.py Develop" ausführen, befindet sich das Paket im Pfad. Möglicherweise möchten Sie dies jedoch nicht tun, da Sie Ihre Systempython- Installation infizieren könnten. Aus diesem Grund gibt es Tools wie virtualenv und buildout .

Lösung / Beispiel für Python unittest Modul

Bei folgender Projektstruktur:

ProjectName
 ├── project_name
 |    ├── models
 |    |    └── thing_1.py
 |    └── __main__.py
 └── test
      ├── models
      |    └── test_thing_1.py
      └── __main__.py

Sie können Ihr Projekt aus dem Stammverzeichnis ausführen, mit python project_namedem aufgerufen wird ProjectName/project_name/__main__.py.

Um Ihre Tests python testeffektiv auszuführen ProjectName/test/__main__.py, müssen Sie Folgendes tun:

1) Verwandeln Sie Ihr test/modelsVerzeichnis in ein Paket, indem Sie eine __init__.pyDatei hinzufügen . Dadurch können Sie auf die Testfälle im Unterverzeichnis über das übergeordnete testVerzeichnis zugreifen .

# ProjectName/test/models/__init__.py

from .test_thing_1 import Thing1TestCase        

2) Ändern Sie Ihren Systempfad so test/__main__.py, dass er das project_nameVerzeichnis enthält.

# ProjectName/test/__main__.py

import sys
import unittest

sys.path.append('../project_name')

loader = unittest.TestLoader()
testSuite = loader.discover('test')
testRunner = unittest.TextTestRunner(verbosity=2)
testRunner.run(testSuite)

Jetzt können Sie erfolgreich Dinge aus project_nameIhren Tests importieren .

# ProjectName/test/models/test_thing_1.py    

import unittest
from project_name.models import Thing1  # this doesn't work without 'sys.path.append' per step 2 above

class Thing1TestCase(unittest.TestCase):

    def test_thing_1_init(self):
        thing_id = 'ABC'
        thing1 = Thing1(thing_id)
        self.assertEqual(thing_id, thing.id)

Verwenden setup.py developSie diese Option , um Ihr Arbeitsverzeichnis Teil der installierten Python-Umgebung zu machen, und führen Sie dann die Tests aus.

Wenn Sie VS-Code verwenden und sich Ihre Tests auf derselben Ebene wie Ihr Projekt befinden, funktioniert das Ausführen und Debuggen Ihres Codes nicht sofort. Sie können Ihre Datei launch.json ändern:

{
    "version": "0.2.0",
    "configurations": [
        {
            "name": "Python",
            "type": "python",
            "request": "launch",
            "stopOnEntry": false,
            "pythonPath": "${config:python.pythonPath}",
            "program": "${file}",
            "cwd": "${workspaceRoot}",
            "env": {},
            "envFile": "${workspaceRoot}/.env",
            "debugOptions": [
                "WaitOnAbnormalExit",
                "WaitOnNormalExit",
                "RedirectOutput"
            ]
        }    
    ]
}

Die Schlüsselzeile hier ist envFile

"envFile": "${workspaceRoot}/.env",

Fügen Sie im Stammverzeichnis Ihres Projekts die ENV-Datei hinzu

Fügen Sie innerhalb Ihrer .env-Datei einen Pfad zum Stammverzeichnis Ihres Projekts hinzu. Dies wird vorübergehend hinzugefügt

PYTHONPATH = C: \ IHR \ PYTHON \ PROJECT \ ROOT_DIRECTORY

Wenn Sie den Pfad zu Ihrem Projekt eingeben, können Sie Debug-Unit-Tests aus VS Code verwenden

Ich habe festgestellt, dass Importe ohne Änderungen korrekt funktionieren, wenn Sie die unittest-Befehlszeilenschnittstelle von Ihrem "src" -Verzeichnis aus ausführen.

python -m unittest discover -s ../test

Wenn Sie dies in eine Batchdatei in Ihrem Projektverzeichnis einfügen möchten, können Sie dies tun:

setlocal & cd src & python -m unittest discover -s ../test

Ich habe seit langer Zeit das gleiche Problem. Was ich kürzlich gewählt habe, ist die folgende Verzeichnisstruktur:

project_path
├── Makefile
├── src
│   ├── script_1.py
│   ├── script_2.py
│   └── script_3.py
└── tests
    ├── __init__.py
    ├── test_script_1.py
    ├── test_script_2.py
    └── test_script_3.py

und im __init__.pySkript des Testordners schreibe ich Folgendes:

import os
import sys
PROJECT_PATH = os.getcwd()
SOURCE_PATH = os.path.join(
    PROJECT_PATH,"src"
)
sys.path.append(SOURCE_PATH)

Super wichtig für die Freigabe des Projekts ist das Makefile, da es die ordnungsgemäße Ausführung der Skripte erzwingt. Hier ist der Befehl, den ich in das Makefile eingefügt habe:

run_tests:
    python -m unittest discover .

Das Makefile ist nicht nur wegen des ausgeführten Befehls wichtig, sondern auch, weil es von dort aus ausgeführt wird . Wenn Sie in Tests cd und tun würden python -m unittest discover ., würde es nicht funktionieren, weil der init ausführen Skript in unit_tests os.getcwd () aufruft, das dann auf den falschen absoluten Pfad verweist (der an sys.path angehängt wird und Sie fehlen würden Ihr Quellordner). Die Skripte würden ausgeführt, da Discovery alle Tests findet, aber sie würden nicht ordnungsgemäß ausgeführt. Das Makefile soll also verhindern, dass Sie sich an dieses Problem erinnern müssen.

Ich mag diesen Ansatz wirklich, weil ich meinen src-Ordner, meine Unit-Tests oder meine Umgebungsvariablen nicht berühren muss und alles reibungslos läuft.

Lass es mich wissen, wenn es euch gefällt.

Ich hoffe, das hilft,

Folgendes ist meine Projektstruktur:

ProjectFolder:
 - project:
     - __init__.py
     - item.py
 - tests:
     - test_item.py

Ich fand es besser, in die setUp () -Methode zu importieren:

import unittest
import sys    

class ItemTest(unittest.TestCase):

    def setUp(self):
        sys.path.insert(0, "../project")
        from project import item
        # further setup using this import

    def test_item_props(self):
        # do my assertions

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

Was ist die übliche Art, die Tests tatsächlich auszuführen?

Ich benutze Python 3.6.2

cd new_project

pytest test/test_antigravity.py

So installieren Sie pytest :sudo pip install pytest

Ich habe keine Pfadvariable festgelegt und meine Importe schlagen nicht mit derselben "Test" -Projektstruktur fehl.

Ich habe dieses Zeug auskommentiert: if __name__ == '__main__'so:

test_antigravity.py

import antigravity

class TestAntigravity(unittest.TestCase):

    def test_something(self):

        # ... test stuff here


# if __name__ == '__main__':
# 
#     if __package__ is None:
# 
#         import something
#         sys.path.append(path.dirname(path.dirname(path.abspath(__file__))))
#         from .. import antigravity
# 
#     else:
# 
#         from .. import antigravity
# 
#     unittest.main()

Es ist möglich, einen Wrapper zu verwenden, der ausgewählte oder alle Tests ausführt.

Zum Beispiel:

./run_tests antigravity/*.py

oder um alle Tests rekursiv auszuführen, verwenden Sie globbing ( tests/**/*.py) (enable by shopt -s globstar).

Der Wrapper kann grundsätzlich argparsedie folgenden Argumente analysieren:

parser = argparse.ArgumentParser()
parser.add_argument('files', nargs='*')

Laden Sie dann alle Tests:

for filename in args.files:
    exec(open(filename).read())

Fügen Sie sie dann Ihrer Testsuite hinzu (mit inspect):

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

und führen Sie sie:

result = unittest.TextTestRunner(verbosity=2).run(alltests)

Überprüfen Sie dieses Beispiel für weitere Details.

Siehe auch: Wie werden alle Python-Komponententests in einem Verzeichnis ausgeführt?

Python 3+

Hinzufügen zu @Pierre

Verwenden Sie die unittestVerzeichnisstruktur wie folgt:

new_project
├── antigravity
│   ├── __init__.py         # make it a package
│   └── antigravity.py
└── test
    ├── __init__.py         # also make test a package
    └── test_antigravity.py

So führen Sie das Testmodul aus test_antigravity.py:

$ cd new_project
$ python -m unittest test.test_antigravity

Oder eine einzelne TestCase

$ python -m unittest test.test_antigravity.GravityTestCase

Obligatorisch nicht vergessen, __init__.pyauch wenn leer, sonst funktioniert es nicht.

Sie können nicht ohne Voodoo aus dem übergeordneten Verzeichnis importieren. Hier ist noch eine andere Möglichkeit, die mit mindestens Python 3.6 funktioniert.

Erstellen Sie zunächst eine Datei test / context.py mit folgendem Inhalt:

import sys
import os
sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), '..')))

Führen Sie dann den folgenden Import in die Datei test / test_antigravity.py durch:

import unittest
try:
    import context
except ModuleNotFoundError:
    import test.context    
import antigravity

Beachten Sie, dass der Grund für diese Try-Except-Klausel der folgende ist

• Der Import von test.context schlägt fehl, wenn er mit "python test_antigravity.py" und ausgeführt wird
• Der Importkontext schlägt fehl, wenn er mit "python -m unittest" aus dem Verzeichnis new_project ausgeführt wird.

Mit diesem Trick arbeiten beide.

Jetzt können Sie alle Testdateien im Testverzeichnis ausführen mit:

$ pwd
/projects/new_project
$ python -m unittest

oder führen Sie eine einzelne Testdatei aus mit:

$ cd test
$ python test_antigravity

Ok, es ist nicht viel schöner als den Inhalt von context.py in test_antigravity.py zu haben, aber vielleicht ein bisschen. Vorschläge sind willkommen.

Wenn Ihr Testverzeichnis mehrere Verzeichnisse enthält, müssen Sie jedem Verzeichnis eine __init__.pyDatei hinzufügen .

/home/johndoe/snakeoil
└── test
    ├── __init__.py        
    └── frontend
        └── __init__.py
        └── test_foo.py
    └── backend
        └── __init__.py
        └── test_bar.py

Um dann jeden Test auf einmal auszuführen, führen Sie Folgendes aus:

python -m unittest discover -s /home/johndoe/snakeoil/test -t /home/johndoe/snakeoil

Quelle: python -m unittest -h

  -s START, --start-directory START
                        Directory to start discovery ('.' default)
  -t TOP, --top-level-directory TOP
                        Top level directory of project (defaults to start
                        directory)

Dieses BASH-Skript führt das Python-Unittest-Testverzeichnis von einer beliebigen Stelle im Dateisystem aus, unabhängig davon, in welchem ​​Arbeitsverzeichnis Sie sich befinden.

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

#!/bin/bash

this_program="$0"
dirname="`dirname $this_program`"
readlink="`readlink -e $dirname`"

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

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

Auf diese Weise können Sie die Testskripte von jedem beliebigen Ort aus ausführen, ohne mit Systemvariablen über die Befehlszeile herumzuspielen.

Dadurch wird der Hauptprojektordner zum Python-Pfad hinzugefügt, wobei der Speicherort relativ zum Skript selbst und nicht relativ zum aktuellen Arbeitsverzeichnis gefunden wird.

import sys, os

sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.realpath(__file__))))

Fügen Sie das oben in all Ihren Testskripten hinzu. Dadurch wird der Hauptprojektordner zum Systempfad hinzugefügt, sodass alle Modulimporte, die von dort aus funktionieren, jetzt funktionieren. Und es spielt keine Rolle, von wo aus Sie die Tests ausführen.

Sie können die Datei project_path_hack natürlich so ändern, dass sie dem Speicherort Ihres Hauptprojektordners entspricht.

Wenn Sie nach einer Nur-Befehlszeilenlösung suchen:

Basierend auf der folgenden Verzeichnisstruktur (verallgemeinert mit einem dedizierten Quellverzeichnis):

new_project/
    src/
        antigravity.py
    test/
        test_antigravity.py

Windows : (in new_project)

$ set PYTHONPATH=%PYTHONPATH%;%cd%\src
$ python -m unittest discover -s test

Siehe diese Frage, wenn Sie diese in einer Batch-for-Schleife verwenden möchten.

Linux : (in new_project)

$ export PYTHONPATH=$PYTHONPATH:$(pwd)/src  [I think - please edit this answer if you are a Linux user and you know this]
$ python -m unittest discover -s test

Mit diesem Ansatz ist es auch möglich, dem PYTHONPATH bei Bedarf weitere Verzeichnisse hinzuzufügen.

Sie sollten das Pip-Tool wirklich verwenden.

Verwenden Sie pip install -e .diese Option, um Ihr Paket im Entwicklungsmodus zu installieren. Dies ist eine sehr gute Vorgehensweise, die von pytest empfohlen wird (siehe die Dokumentation zu bewährten Vorgehensweisen , in der Sie auch zwei Projektlayouts finden, denen Sie folgen können).