Basit bir Python modülü için bile en yaygın dizin yapısı, birim testlerini kendi testdizinlerine ayırmak gibi görünüyor :

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

örneğin bu Python projesine bakınız .

Benim sorum basitçe Testleri yapmanın olağan yolu nedir? Bunun benden başka herkes için açık olduğundan şüpheleniyorum, ancak modül yolda olmadığı için başarısız olacağı python test_antigravity.pyiçin test dizininden import antigravityçalışamazsınız.

PYTHONPATH ve diğer arama yolu ile ilgili hileleri değiştirebileceğimi biliyorum, ancak bunun en basit yol olduğuna inanamıyorum - geliştiriciyseniz sorun değil, ancak kullanıcılarınızın sadece testleri kontrol etmek istediklerinde kullanmasını beklemek gerçekçi değil geçen.

Diğer alternatif sadece test dosyasını diğer dizine kopyalamaktır, ancak biraz aptal gibi görünür ve başlamak için ayrı bir dizinde bulunma noktasını kaçırır.

Peki, kaynağı yeni projeme indirdiyseniz, birim testlerini nasıl yapardınız? Kullanıcılarıma şunu söylememe izin veren bir cevap tercih ederim: "Birim testlerini yapmak için X yapın."

Bence en iyi çözüm , dizine ekleyeceğiniz unittest komut sınıfını sys.pathkullanmaktır (böylece TestLoadersınıfta yapılır ).

Örneğin, aşağıdaki gibi bir dizin yapısı için:

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

Sadece çalıştırabilirsiniz:

$ cd new_project
$ python -m unittest test_antigravity

Sizinki gibi bir dizin yapısı için:

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

Ve testpaketin içindeki test modüllerinde , antigravitypaketi ve modüllerini her zamanki gibi içe aktarabilirsiniz :

# 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

Tek bir test modülünün çalıştırılması:

Bu durumda tek bir test modülü çalıştırmak için test_antigravity.py:

$ cd new_project
$ python -m unittest test.test_antigravity

Test modülünü içe aktardığınız gibi referans almanız yeterlidir.

Tek bir test senaryosu veya test yöntemi çalıştırma:

Ayrıca, tek TestCaseveya tek bir test yöntemi çalıştırabilirsiniz:

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

Tüm testleri çalıştırma:

Ayrıca , sizin için tüm testleri keşfedecek ve çalıştıracak test keşiflerini de kullanabilirsiniz , bunlar modüller veya paketler olmalıdır test*.py( -p, --patternbayrakla değiştirilebilir ):

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

Bu test*.py, testpaketin içindeki tüm modülleri çalıştıracaktır .

Kullanıcılarınız için en basit çözüm runtests.py, gerektiğinde kök proje dizininizi sys.pathgeçici olarak eklemek de dahil olmak üzere gerekli test ortamını önyükleyen yürütülebilir bir komut dosyası ( veya benzeri) sağlamaktır . Bu, kullanıcıların ortam değişkenlerini ayarlamasını gerektirmez, böyle bir şey bir önyükleme komut dosyasında iyi çalışır:

import sys, os

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

Ardından kullanıcılarınıza verdiğiniz talimatlar " python runtests.py" kadar basit olabilir .

Tabii ki, gerçekten ihtiyacınız olan yol ise os.path.dirname(__file__), o zaman onu eklemenize gerek yoktur sys.path; Python, o anda çalışan komut dosyasının dizinini her zaman başına koyar sys.path, bu nedenle dizin yapınıza bağlı olarak runtests.py, doğru yerde bulmak sadece gerekli olan şey olabilir.

Ayrıca Python 2.7+ içinde unittest modül (aynı backported edilir unittest2 önceki Python 2.6 için ve) artık vardır testi keşif burnun otomatik test keşif istiyorsanız artık gerekli değildir, böylece dahili: Kullanıcı talimatları olarak basit olarak olabilir python -m unittest discover.

Genelde proje dizininde (hem kaynak dizinde ortak olan ve test"Tüm Testler" paketimi yükleyen " testler çalıştır" komut dosyası oluşturuyorum . Bu genellikle ortak koddur, bu yüzden projeden projeye tekrar kullanabilirim.

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 ( bir dizindeki tüm Python birimi testlerini nasıl çalıştırabilirim? )

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

Bu kurulumla, gerçekten sadece include antigravitytest modüllerinizde yapabilirsiniz. Dezavantajı, belirli bir testi yürütmek için daha fazla destek koduna ihtiyaç duyacağınız ... Onları her seferinde çalıştırıyorum.

Bağlantı verdiğiniz makaleden:

Bir test_modulename.py dosyası oluşturun ve unittest testlerinizi içine yerleştirin. Test modülleri kodunuzdan ayrı bir dizinde bulunduğundan, çalıştırmak için modülünüzün üst dizinini PYTHONPATH'ınıza eklemeniz gerekebilir:

$ cd /path/to/googlemaps

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

$ python test/test_googlemaps.py

Son olarak, Python (bu kadar önemli!) Burun için bir popüler birim test çerçevesi daha var. burun yerleşik unittest çerçevesini basitleştirmeye ve genişletmeye yardımcı olur (örneğin, test kodunuzu otomatik olarak bulabilir ve PYTHONPATH'ınızı sizin için ayarlayabilir), ancak standart Python dağıtımına dahil değildir.

Belki de burunun önerdiği gibi bakmalısın ?

Ayrı bir birim test klasörüyle aynı sorunu yaşadım. Sözü önerileri itibaren ben eklemek mutlak kaynak yolu için sys.path.

Aşağıdaki çözümün yararı, dosyayı test/test_yourmodule.pyilk önce test dizinine değiştirmeden çalıştırabilmesidir :

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

"python setup.py develop" komutunu çalıştırırsanız, paket yolda olacaktır. Ancak bunu yapmak istemeyebilirsiniz çünkü sistem python kurulumunuza bulaşabilir, bu yüzden virtualenv ve buildout gibi araçlar mevcuttur.

Çözüm / Python unittest modülü örneği

Aşağıdaki proje yapısı göz önüne alındığında:

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

Projenizi python project_nameçağıran kök dizinden çalıştırabilirsiniz ProjectName/project_name/__main__.py.

Testlerinizi python testetkili bir şekilde çalıştırmak ProjectName/test/__main__.pyiçin aşağıdakileri yapmanız gerekir:

1) senin çevirin test/modelsbir ekleyerek bir paket içine dizin __init__.pydosyasını. Bu, alt dizindeki test senaryolarını üst testdizinden erişilebilir hale getirir .

# ProjectName/test/models/__init__.py

from .test_thing_1 import Thing1TestCase        

2) Dizini test/__main__.pyiçerecek şekilde sistem yolunuzu değiştirin project_name.

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

Artık project_nametestlerinizden bir şeyleri başarıyla içe aktarabilirsiniz .

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

setup.py developÇalışma dizininizi kurulu Python ortamının bir parçası yapmak için kullanın , ardından testleri çalıştırın.

VS Code kullanıyorsanız ve testleriniz projenizle aynı düzeyde bulunuyorsa, kodunuz kutudan çıkar çıkmaz çalışır. Yapabilecekleriniz launch.json dosyanızı değiştirmektir:

{
    "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"
            ]
        }    
    ]
}

Burada anahtar satır envFile

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

Projenizin kök dizinine .env dosyası ekleyin

.Env dosyanızın içine projenizin kök dizinine yol ekleyin. Bu geçici olarak ekleyecek

PYTHONPATH = C: \ SİZİN \ PYTHON \ PROJESİ \ root_directory

ve VS Kodundaki hata ayıklama birimi testlerini kullanabileceksiniz.

Unittest komut satırı arabirimini "src" dizininizden çalıştırırsanız, içe aktarmanın değiştirilmeden doğru şekilde çalıştığını fark ettim.

python -m unittest discover -s ../test

Bunu proje dizininizdeki bir toplu iş dosyasına koymak istiyorsanız, bunu yapabilirsiniz:

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

Uzun zamandır aynı problemi yaşadım. Son zamanlarda seçtiğim aşağıdaki dizin yapısı:

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

ve __init__.pytest klasörünün komut dosyasında aşağıdakileri yazıyorum:

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

Projeyi paylaşmak için çok önemli olan Makefile'dir, çünkü komut dosyalarını düzgün bir şekilde çalıştırmayı zorunlu kılar. İşte Makefile'de koyduğum komut:

run_tests:
    python -m unittest discover .

Makefile sadece çalıştırdığı komuttan değil, aynı zamanda nereden çalıştırdığından da önemlidir . Testlerde cd yaparsanız ve yaparsanız python -m unittest discover ., unit_tests içindeki init betiği os.getcwd () öğesini çağırdığı için çalışmaz, bu da yanlış mutlak yolu işaret eder (sys.path'e eklenir ve eksiksinizdir) kaynak klasörünüz). Keşfet, tüm testleri bulduğundan beri komut dosyaları çalıştırılır, ancak düzgün çalışmazlar. Bu yüzden Makefile bu sorunu hatırlamaktan kaçınmak için var.

Bu yaklaşımı gerçekten seviyorum çünkü src klasörüme, birim testlerime veya ortam değişkenlerime dokunmam gerekmiyor ve her şey düzgün çalışıyor.

Beğendiyseniz bana bildirin.

Umarım yardımcı olur,

Benim proje yapım:

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

SetUp () yönteminde almak daha iyi buldum:

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

Testleri yapmanın olağan yolu nedir

Python 3.6.2 kullanıyorum

cd new_project

pytest test/test_antigravity.py

Pytest kurmak için :sudo pip install pytest

Herhangi bir yol değişkeni belirlemedim ve ithalatlarım aynı "test" proje yapısıyla başarısız olmuyor.

Ben bu şeyler yorum: if __name__ == '__main__'böyle:

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

Seçilen testleri veya tüm testleri çalıştıran sarıcı kullanmak mümkündür.

Örneğin:

./run_tests antigravity/*.py

veya tüm testleri tekrar tekrar çalıştırmak için globbing ( tests/**/*.py) kullanın (tarafından etkinleştirin shopt -s globstar).

Sarıcı temel olarak aşağıdaki argparsegibi bağımsız değişkenleri ayrıştırmak için kullanabilir :

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

Ardından tüm testleri yükleyin:

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

daha sonra bunları test grubunuza ekleyin (kullanarak 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))

ve çalıştırın:

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

Kontrol bu fazla ayrıntı için örnek.

Ayrıca bkz: Tüm Python birim sınamaları bir dizinde nasıl çalıştırılır?

Python 3+

@Pierre'ye ekleniyor

Bunun unittestgibi dizin yapısını kullanarak :

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

Test modülünü çalıştırmak için test_antigravity.py:

$ cd new_project
$ python -m unittest test.test_antigravity

Veya tek TestCase

$ python -m unittest test.test_antigravity.GravityTestCase

Zorunlu__init__.py boş unutmayın bile boş aksi takdirde işe yaramaz.

Bazı voodoo olmadan üst dizinden içe aktaramazsınız. İşte en azından Python 3.6 ile çalışan başka bir yol.

İlk olarak, aşağıdaki içeriğe sahip bir test / context.py dosyasına sahip olun:

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

Ardından test / test_antigravity.py dosyasında aşağıdaki içe aktarma işlemini gerçekleştirin:

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

Bu try-hariç yantümcesinin nedeninin

• "python test_antigravity.py" ile çalıştırıldığında import test.context başarısız oluyor ve
• new_project dizininden "python -m unittest" ile çalıştırıldığında import bağlamı başarısız oluyor.

Bu hile ile ikisi de çalışır.

Artık test dizinindeki tüm test dosyalarını şu şekilde çalıştırabilirsiniz :

$ pwd
/projects/new_project
$ python -m unittest

veya aşağıdakilerle ayrı bir test dosyası çalıştırın:

$ cd test
$ python test_antigravity

Tamam, test_antigravity.py içinde context.py içeriğinden çok daha güzel değil, ama belki biraz. Öneriler bekliyoruz.

Test dizininizde birden çok dizin varsa, her dizine bir __init__.pydosya eklemeniz gerekir .

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

Ardından her testi bir kerede çalıştırmak için şunu çalıştırın:

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

Kaynak: 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)

Bu BASH betiği, hangi çalışma dizininde olursanız olun, dosya sisteminin herhangi bir yerinden python unittest test dizinini yürütür.

Bu, ./srcveya ./exampleçalışma dizininde kalırken yararlıdır ve hızlı bir birim testine ihtiyacınız vardır:

#!/bin/bash

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

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

test/__init__.pyÜretim sırasında paketinizi / bellek yükünüzü yükleyecek bir dosyaya gerek yoktur .

Bu şekilde, komut dosyalarını sistem değişkenleriyle uğraşmadan test komut dosyalarını istediğiniz yerden çalıştırabilirsiniz.

Bu, ana proje klasörünü, geçerli çalışma dizinine göre değil, komut dosyasının kendisine göre bulunan konumla birlikte python yoluna ekler.

import sys, os

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

Bunu tüm test komut dosyalarınızın üstüne ekleyin. Bu, ana proje klasörünü sistem yoluna ekler, böylece oradan çalışan herhangi bir modül içe aktarılır. Ve testleri nereden yaptığınız önemli değil.

Project_path_hack dosyasını ana proje klasörü konumunuzla eşleşecek şekilde değiştirebilirsiniz.

Yalnızca komut satırı çözümü arıyorsanız:

Aşağıdaki dizin yapısına dayanarak (özel bir kaynak dizini ile genelleştirilmiş):

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

Windows : (in new_project)

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

Bunu toplu for-döngüsünde kullanmak istiyorsanız bu soruya bakın .

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

Bu yaklaşımla, gerekirse PYTHONPATH'a daha fazla dizin eklemek de mümkündür.

Gerçekten pip aracını kullanmalısınız.

pip install -e .Paketinizi geliştirme modunda yüklemek için kullanın . Bu, pytest tarafından önerilen çok iyi bir uygulamadır ( takip edilecek iki proje düzenini de bulabileceğiniz iyi uygulama belgelerine bakın ).