Bir kütüphane veya uygulama yazıyorsanız, birim test dosyaları nereye gider?

Test dosyalarını ana uygulama kodundan ayırmak güzeldir, ancak bunları uygulama kök dizininin içindeki bir "testler" alt dizinine koymak gariptir, çünkü test edeceğiniz modülleri içe aktarmayı zorlaştırır.

Burada en iyi uygulama var mı?

Bir dosya için module.py, test_module.pyPythonic adlandırma kurallarına göre birim testi normal olarak çağrılmalıdır .

Koymak için yaygın olarak kabul edilen birkaç yer vardır test_module.py:

1. İle aynı dizinde module.py.
2. In ../tests/test_module.py(kod dizini ile aynı düzeyde).
3. In tests/test_module.py(kod dizininin altında bir seviye).

Testleri bulma ve içe aktarma kolaylığı için # 1'i tercih ediyorum. Hangi yapı sistemini kullanırsanız kullanın, başlayarak dosyaları çalıştıracak şekilde kolayca yapılandırılabilir test_. Aslında, test keşfi için kullanılan varsayılan unittestörüntüdürtest*.py .

Sadece 1 test dosyası

Yalnızca 1 test dosyası varsa, üst düzey bir dizine koymanız önerilir:

module/
    lib/
        __init__.py
        module.py
    test.py

Testi CLI'de çalıştırın

python test.py

Birçok test dosyası

Çok sayıda test dosyası varsa, bir testsklasöre koyun :

module/
    lib/
        __init__.py
        module.py
    tests/
        test_module.py
        test_module_function.py

# test_module.py

import unittest
from lib import module

class TestModule(unittest.TestCase):
    def test_module(self):
        pass

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

Testi CLI'de çalıştırın

# In top-level /module/ folder
python -m tests.test_module
python -m tests.test_module_function

kullanım unittest discovery

unittest discovery tüm testi paket klasöründe bulacaktır.

Bir oluşturma __init__.pyiçinde tests/klasörün

module/
    lib/
        __init__.py
        module.py
    tests/
        __init__.py
        test_module.py
        test_module_function.py

Testi CLI'de çalıştırın

# In top-level /module/ folder

# -s, --start-directory (default current directory)
# -p, --pattern (default test*.py)

python -m unittest discover

Referans

• pytestTest düzeni için iyi uygulamalar
• unittest

Birim test çerçevesi

• burun
• nose2
• pytest

Yaygın bir uygulama, test dizinini modül / paketinizle aynı üst dizine koymaktır. Modülünüz foo.py olarak adlandırılmışsa, dizin düzeniniz şöyle görünür:

parent_dir/
  foo.py
  tests/

Tabii ki bunu yapmanın tek bir yolu yok. Ayrıca, bir test alt dizini oluşturabilir ve mutlak içe aktarmayı kullanarak modülü içe aktarabilirsiniz .

Testlerinizi nereye koyarsanız yapın, onları çalıştırmak için burun kullanmanızı tavsiye ederim . Burun , testleriniz için dizinlerinizde arama yapar. Bu şekilde, organizasyon açısından en anlamlı oldukları yere testler koyabilirsiniz.

Python programları için birim testleri oluşturan Pythoscope ( https://pypi.org/project/pythoscope/ ) yazarken de aynı soruyu sorduk . Bir dizin seçmeden önce insanları python listesindeki testlerle sorguladık, birçok farklı görüş vardı. Sonunda kaynak kod ile aynı dizine bir "test" dizini koymayı seçtik. Bu dizinde, üst dizindeki her modül için bir test dosyası oluştururuz.

Ayrıca, test fonksiyonlarını ana gövdeye koymamaya, ancak her şeyi bir

if __name__ == '__main__':
   do tests...

blok. Bu, test ettiğiniz python dosyasının nasıl kullanılacağına dair dosyaya 'örnek kod' olarak dokümantasyon ekler.

Eklemeliyim, çok sıkı modüller / sınıflar yazma eğilimindeyim. Modülleriniz çok sayıda test gerektiriyorsa, bunları başka bir teste koyabilirsiniz, ancak o zaman bile yine de ekleyeceğim:

if __name__ == '__main__':
   import tests.thisModule
   tests.thisModule.runtests

Bu, kaynak kodunuzu okuyan herkesin test kodunu nerede arayacağını bilmesini sağlar.

Her seferinde kendimi test yerleştirme konusunu kontrol ederken buluyorum ve çoğunluk kütüphane kodunun yanında ayrı bir klasör yapısı önerdiğinde, ancak argümanların her seferinde aynı ve ikna edici olmadığını görüyorum. Sonunda test modülümü çekirdek modüllerin yanında bir yere koyuyorum.

Bunu yapmanın ana nedeni: yeniden düzenleme .

Bir şeyleri hareket ettirdiğimde test modüllerinin kodla birlikte hareket etmesini istiyorum; ayrı bir ağaçtalarsa testleri kaybetmek kolaydır. Dürüst olalım, er ya da geç django , flask ve diğerleri gibi tamamen farklı bir klasör yapısı ile sonuçlanırsınız . Umursamıyorsan iyi olur.

Kendinize sormanız gereken ana soru şudur:

Yazıyor muyum:

• a) yeniden kullanılabilir kütüphane veya
• b) Bazı yarı ayrılmış modülleri bir araya getirerek bir proje oluşturmak?

Eğer bir:

Ayrı bir klasör ve yapısını korumak için fazladan çaba daha uygun olabilir. Hiç kimse testlerin üretime alınmasından şikayet etmeyecek .

Ancak, çekirdek klasörlerle karıştırıldığında testlerin dağıtılmasını engellemek de kolaydır; bunu setup.py dosyasına koyun :

find_packages("src", exclude=["*.tests", "*.tests.*", "tests.*", "tests"]) 

B ise:

Her birimizin yaptığı gibi, yeniden kullanılabilir kütüphaneler yazmanızı isteyebilirsiniz, ancak çoğu zaman yaşamları projenin hayatına bağlıdır. Projenizi kolayca devam ettirebilmek bir öncelik olmalıdır.

Daha sonra iyi bir iş yaptıysanız ve modülünüz başka bir proje için uygunsa, muhtemelen bu yeni projeye kopyalanır - çatallanamaz veya ayrı bir kütüphaneye dönüştürülmez ve aynı klasör yapısında yan yana duran testler taşınır. ayrı bir test klasörü haline gelmiş bir karmaşa içinde balıkçılık kadar kıyasla kolaydır. (İlk etapta karışıklık olmaması gerektiğini savunabiliriz, ama burada gerçekçi olalım).

Bu yüzden seçim hala sizindir, ancak karışık testlerle ayrı bir klasörle aynı şeyleri elde ettiğinizi, ancak işleri düzenli tutmak için daha az çaba harcadığınızı iddia ediyorum.

Bir tests/dizin kullanın ve sonra göreli ithalatları kullanarak ana uygulama modülleri almak. Uygulamam / testler / foo.py'de şunlar olabilir:

from .. import foo

MyApp.foomodülü almak için .

Yerleşik bir "en iyi uygulama" olduğuna inanmıyorum.

Testlerimi uygulama kodunun dışındaki başka bir dizine koydum. Daha sonra tüm testleri çalıştırmadan önce test çalıştırıcısı komut dosyamda (bu da başka şeyler de yapıyor) sys.path'e (modülleri herhangi bir yerden içe aktarmanıza izin veriyor) ana uygulama dizinini ekledim. Bu şekilde, test dizinini serbest bıraktığımda ana koddan kaldırmak zorunda kalmam, bana çok az miktarda zaman ve çaba kazandırır.

Python'da Test çerçeveleri geliştirme deneyimimden, python birim testlerini ayrı bir dizine koymanızı öneririm. Simetrik dizin yapısını koruyun. Bu, yalnızca çekirdek kütüphanelerin paketlenmesinde yardımcı olur ve birim testlerini paketlemez. Aşağıda şematik bir diyagram ile uygulanmaktadır.

                              <Main Package>
                               /          \
                              /            \
                            lib           tests
                            /                \
             [module1.py, module2.py,  [ut_module1.py, ut_module2.py,
              module3.py  module4.py,   ut_module3.py, ut_module.py]
              __init__.py]

Bu şekilde, bu kütüphaneleri bir rpm kullanarak paketlediğinizde, sadece ana kütüphane modüllerini paketleyebilirsiniz (sadece). Bu, özellikle çevik ortamda korunmaya yardımcı olur.

GitHub'daki bazı ana Python projelerini kontrol etmenizi ve bazı fikirler edinmenizi öneririm.

Kodunuz büyüdükçe ve daha fazla kitaplık eklediğinizde, setup.py ile aynı dizinde bir test klasörü oluşturmak ve her bir test türü (proje testi, entegrasyon, ...) için proje dizini yapınızı yansıtmak daha iyidir.

Örneğin, aşağıdaki gibi bir dizin yapınız varsa:

myPackage/
    myapp/
       moduleA/
          __init__.py
          module_A.py
       moduleB/
          __init__.py
          module_B.py
setup.py

Test klasörü ekledikten sonra aşağıdaki gibi bir dizin yapınız olacaktır:

myPackage/
    myapp/
       moduleA/
          __init__.py
          module_A.py
       moduleB/
          __init__.py
          module_B.py
test/
   unit/
      myapp/
         moduleA/
            module_A_test.py
         moduleB/
            module_B_test.py
   integration/
          myapp/
             moduleA/
                module_A_test.py
             moduleB/
                module_B_test.py
setup.py

Düzgün yazılmış birçok Python paketi aynı yapıyı kullanır. Çok iyi bir örnek Boto paketidir. Https://github.com/boto/boto adresini kontrol edin

Nasıl yaparım...

Klasör yapısı:

project/
    src/
        code.py
    tests/
    setup.py

Setup.py, projeler modüllerini içeren konum olarak src / işaretini gösterir, sonra çalıştırırım:

setup.py develop

Bu da projemi site paketlerine ekleyerek çalışma kopyamı işaret ediyor. Testlerimi çalıştırmak için şunu kullanıyorum:

setup.py tests

Hangi test çalıştırıcısını yapılandırdığımı kullanarak.

Üst düzey testler dizinini tercih ederim. Bu, ithalatın biraz daha zor hale geldiği anlamına gelir. Bunun için iki çözümüm var:

1. Kurulum araçlarını kullanın. Sonra geçebilir test_suite='tests.runalltests.suite'içine setup()ve sadece testleri çalıştırabilirsiniz:python setup.py test
2. Testleri çalıştırırken PYTHONPATH ayarlayın: PYTHONPATH=. python tests/runalltests.py

Bu şeyler M2Crypto'daki kod tarafından nasıl desteklenir:

• http://svn.osafoundation.org/m2crypto/trunk/setup.py
• http://svn.osafoundation.org/m2crypto/trunk/tests/alltests.py

Nosetestlerle test yapmayı tercih ederseniz, biraz farklı bir şey yapmanız gerekebilir.

Kullanırız

app/src/code.py
app/testing/code_test.py 
app/docs/..

Her test dosyasında biz eklemek ../src/içinde sys.path. En güzel çözüm değil ama işe yarıyor. Birisinin Java'da maven gibi bir şey bulması, hangi projede çalışırsanız çalışın, sadece çalışan standart sözleşmeler veren harika olacağını düşünüyorum.

Testler basitse, bunları doktora yerleştirin - Python için test çerçevelerinin çoğu bunu kullanabilecek:

>>> import module
>>> module.method('test')
'testresult'

Daha fazla dahil olan diğer testler için, bunları içeri ../tests/test_module.pyveya içeri koyardım tests/test_module.py.

C #, genellikle testleri ayrı bir derleme ayırdım.

Python'da - şimdiye kadar - testin bir fonksiyonun öğretisinde olduğu doctests yazma ya if __name__ == "__main__"da modülün altındaki bloğa koyma eğilimindeydim .

"Foo" adlı bir paket yazarken, birim testlerini ayrı bir "foo_test" paketine koyacağım. Modüller ve alt paketler SUT paket modülü ile aynı ada sahip olacaktır. Örneğin foo.xy modülü için testler foo_test.xy'de bulunur. Her test paketinin __init__.py dosyaları, paketin tüm test paketlerini içeren bir AllTests paketi içerir. setuptools, ana test paketini belirtmek için uygun bir yol sağlar, böylece "python setup.py geliştirildikten" sonra "python setup.py testi" veya "python setup.py test -s foo_test.x.SomeTestSuite" sadece belirli bir süit.

Testlerimi test edilen kodla aynı dizine koydum (CUT); çünkü foo.pytestler içinde foo_ut.pyveya benzeri olacaktır. (Bunları bulmak için test keşif işlemini değiştirdim.)

Bu, testleri bir dizin listesindeki kodun hemen yanına yerleştirerek testlerin orada olduğunu açıkça gösterir ve testleri ayrı bir dosyadayken olabildiğince kolay açmayı sağlar. (Komut satırı editörleri için,vim foo* ve bir grafik dosya sistemi tarayıcısı kullanırken, önce CUT dosyasını ve ardından hemen bitişikteki test dosyasını tıklamanız yeterlidir.)

Diğerlerinin işaret ettiği gibi , bu, gerektiğinde başka bir yerde kullanım için kodu yeniden düzenlemeyi ve çıkarmayı da kolaylaştırır.

Testleri tamamen farklı bir dizin ağacına koyma fikrinden gerçekten hoşlanmıyorum; neden geliştiricilerin CUT ile dosyayı açtıklarında testleri açmasını zorlaştırıyorsunuz? Geliştiricilerin büyük çoğunluğu, testleri yazmak veya ayarlamak için çok istekli değiller, bariyeri bir bahane olarak kullanmak yerine herhangi bir engeli görmezden geleceklerdir. (Tam tersi, deneyimlerime göre; mümkün olduğunca kolay hale getirdiğinizde bile, test yazma zahmetine giremeyen birçok geliştirici biliyorum.)

Yakın zamanda Python'da program yapmaya başladım, bu yüzden henüz en iyi uygulamayı bulma şansım olmadı. Ancak, tüm testleri bulan ve çalıştıran bir modül yazdım.

Yani, var:

Uygulamanın /
 appfile.py
Ölçek/
 appfileTest.py

Daha büyük projelere ilerlerken nasıl gittiğini görmek zorundayım.