ठेठ परीक्षण निर्देशिका संरचना के साथ एकतरफा चल रहा है

Question

यहां तक ​​कि एक साधारण पायथन मॉड्यूल के लिए बहुत ही सामान्य निर्देशिका संरचना इकाई परीक्षणों को अपनी testनिर्देशिका में अलग करती प्रतीत होती है :

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

उदाहरण के लिए इस पायथन प्रोजेक्ट को कैसे देखें ।

मेरा सवाल बस यह है कि वास्तव में परीक्षण चलाने का सामान्य तरीका क्या है? मुझे संदेह है कि यह मेरे अलावा सभी के लिए स्पष्ट है, लेकिन आप python test_antigravity.pyपरीक्षण निर्देशिका से नहीं चला सकते हैंimport antigravity विफल हो जाएगा क्योंकि मॉड्यूल पथ पर नहीं है।

मुझे पता है कि मैं PYTHONPATH और अन्य खोज पथ से संबंधित ट्रिक्स को संशोधित कर सकता हूं, लेकिन मैं विश्वास नहीं कर सकता कि यह सबसे सरल तरीका है - यदि आप डेवलपर हैं, लेकिन यथार्थवादी हैं तो अपने उपयोगकर्ताओं से इसका उपयोग करने की अपेक्षा करना उचित नहीं है यदि वे परीक्षण की जांच करना चाहते हैं गुजर।

अन्य विकल्प केवल परीक्षण फ़ाइल को अन्य निर्देशिका में कॉपी करने के लिए है, लेकिन यह थोड़ा गूंगा लगता है और उनके साथ शुरू करने के लिए एक अलग निर्देशिका में होने की बात याद आती है।

तो, अगर आपने अभी-अभी स्रोत को मेरी नई परियोजना में डाउनलोड किया है तो आप यूनिट परीक्षण कैसे चलाएंगे? मैं एक जवाब पसंद करूंगा जो मुझे अपने उपयोगकर्ताओं से कहने देगा: "यूनिट टेस्ट चलाने के लिए एक्स।"

Comments

@EMP खोज पथ सेट करने की आवश्यकता होने पर उचित समाधान ... खोज पथ सेट करना है। आप किस तरह के समाधान की उम्मीद कर रहे थे?

— कार्ल मेयर

@CarlMeyer एक और बेहतर समाधान है unittestकमांड लाइन इंटरफ़ेस का उपयोग करें जैसा कि नीचे दिए गए मेरे उत्तर में दिया गया है ताकि आपको निर्देशिका को पथ में जोड़ना न पड़े।

— पियरे

मुझे भी। मैंने अभी हाल ही में एक छोटे पायथन प्रोजेक्ट के लिए अपनी पहली यूनिट परीक्षण लिखने पर विचार किया और कई दिनों तक इस तथ्य के साथ तर्क देने की कोशिश की कि मैं अपने स्रोतों को एक src डायरेक्टरी और टेस्ट डायरेक्टरी में परीक्षण करते हुए आसानी से नहीं चला सकता। किसी भी मौजूदा परीक्षण ढांचे के साथ प्रतीत होता है। मैं अंततः चीजों को स्वीकार करूंगा, एक तरीका समझूंगा; लेकिन यह बहुत निराशाजनक परिचय रहा है। (और मैं पाइथन के बाहर एक परीक्षण करने वाला पशु हूं।)

— एतेस गोरल

Answer 1

मेरी राय में सबसे अच्छा समाधान unittest कमांड लाइन इंटरफ़ेस का उपयोग करना है जो निर्देशिका को जोड़ देगा sys.pathताकि आपको ( TestLoaderकक्षा में किया गया ) न हो।

इस तरह एक निर्देशिका संरचना के लिए उदाहरण के लिए:

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

आप बस चला सकते हैं:

$ cd new_project
$ python -m unittest test_antigravity

तुम्हारी जैसी निर्देशिका संरचना के लिए:

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

और testपैकेज के अंदर परीक्षण मॉड्यूल में , आप antigravityहमेशा की तरह पैकेज और उसके मॉड्यूल को आयात कर सकते हैं :

# 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

एकल परीक्षण मॉड्यूल चलाना:

इस मामले में एकल परीक्षण मॉड्यूल चलाने के लिए test_antigravity.py:

$ cd new_project
$ python -m unittest test.test_antigravity

जिस तरह से आप इसे आयात करते हैं ठीक उसी तरह परीक्षण मॉड्यूल को देखें।

एकल परीक्षण केस या परीक्षण विधि चलाना:

इसके अलावा आप एकल TestCaseया एकल परीक्षण विधि चला सकते हैं :

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

सभी परीक्षण चल रहे हैं:

आप परीक्षण खोज का भी उपयोग कर सकते हैं जो आपके लिए सभी परीक्षणों की खोज और उन्हें चलाएंगे, उनके नाम मॉड्यूल या पैकेज होने चाहिए test*.py( -p, --patternध्वज के साथ बदला जा सकता है ):

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

यह पैकेज के test*.pyअंदर सभी मॉड्यूल चलाएगा test।

Comments

python -m unittest discovertestनिर्देशिका में परीक्षण खोजने और चलाने के लिए यदि वे नामित हैं test*.py। यदि आपने उपनिर्देशिका का नाम दिया है tests, का उपयोग करें python -m unittest discover -s tests, और यदि आपने परीक्षण फ़ाइलों का नाम दिया है antigravity_test.py, तो python -m unittest discover -s tests -p '*test.py' फ़ाइल नाम का उपयोग अंडरस्कोर का उपयोग कर सकते हैं लेकिन डैश नहीं।

— माइक

यह मेरे लिए पायथन 3 पर ImportError: No module named 'test.test_antigravity'असफलता के कारण असफलता का कारण है, जो कि एकतरफा लाइब्रेरी के टेस्ट सब-मॉड्यूल के साथ संघर्ष के कारण है। हो सकता है कि कोई विशेषज्ञ उत्तर उप-निर्देशिका के नाम की पुष्टि और परिवर्तन कर सकता है, जैसे 'परीक्षण' (बहुवचन)।

— एक्सपोज़

मेरा test_antigravity.pyअभी भी import antigravityऔर दोनों के लिए एक आयात त्रुटि फेंकता है from antigravity import antigravity। मेरे पास दोनों __init_.pyफाइलें हैं और मैं निर्देशिका python3 -m unittest discoverसे कॉल कर रहा हूं new project। और क्या गलत हो सकता था?

— imrek

फ़ाइल test/__init__.pyयहाँ महत्वपूर्ण है, भले ही खाली हो

— फ्रेंकोइस

@ Mike3d0g सुनिश्चित नहीं है कि अगर आप का मतलब है कि निर्देशिका नाम testविशेष है ... लेकिन रिकॉर्ड के लिए, यह नहीं है। : पी python -m unittest discoverमें परीक्षण फाइलों के साथ काम करता है tests/बस के रूप में अच्छी तरह से test/।

— रयान

Answer 2

आपके उपयोगकर्ताओं के लिए सबसे सरल समाधान एक निष्पादन योग्य स्क्रिप्ट ( runtests.pyया कुछ ऐसे) प्रदान करना है जो आवश्यक परीक्षण वातावरण को बूटस्ट्रैप करता है, यदि आवश्यक हो, तो आपके रूट प्रोजेक्ट निर्देशिका को sys.pathअस्थायी रूप से जोड़ना । इसके लिए उपयोगकर्ताओं को पर्यावरण चर सेट करने की आवश्यकता नहीं है, कुछ इस तरह से बूटस्ट्रैप स्क्रिप्ट में ठीक काम करता है:

import sys, os

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

तब आपके उपयोगकर्ताओं को आपके निर्देश "" के रूप में सरल हो सकते हैंpython runtests.py " के ।

बेशक, अगर आपको जिस रास्ते की ज़रूरत है वह वास्तव में है os.path.dirname(__file__), तो आपको इसे जोड़ने की ज़रूरत नहीं है sys.path; पायथन हमेशा की शुरुआत में वर्तमान में चल रही स्क्रिप्ट की निर्देशिका डालता है sys.path, इसलिए आपकी निर्देशिका संरचना के आधार पर, बस आपका पता लगाने मेंruntests.py सही स्थान पर स्थान बनाना सभी की आवश्यकता हो सकती है।

इसके अलावा, Python 2.7+ में सबसे पुराना मॉड्यूल (जिसे Python 2.6 और उससे पहले के unittest2 के रूप में बैकपोर्ट किया गया है) की अब टेस्ट डिस्कवरी बिल्ट-इन है, इसलिए नाक अब आवश्यक नहीं है यदि आप स्वचालित टेस्ट डिस्कवरी चाहते हैं: तो आपके उपयोगकर्ता के निर्देश उतने ही सरल हो सकते हैं python -m unittest discover।

Comments

मैंने कुछ परीक्षणों को "मेजर मेजर" जैसे सबफ़ोल्डर में रखा। वे अजगर के साथ दौड़ सकते हैं -मैं बिना खोज के, लेकिन मैं उनमें से केवल एक को कैसे चुन सकता हूं। अगर मैं पायथन -m को बिना परीक्षण / testxxxxx के चलाता हूं तो यह पथ समस्या के लिए विफल हो जाता है। चूँकि डिकोवरी मोड सब कुछ हल करता है जिससे मैं उम्मीद करूँगा कि बिना किसी समस्या के हल करने के लिए एक और चाल है, जो आपको पहले बिंदु में सुझाए गए रास्ते को ठीक करने के लिए है

— फ्रेडेरिक

@FredericBazin यदि आप केवल एक परीक्षण या परीक्षण फ़ाइल चाहते हैं, तो खोज का उपयोग न करें, बस उस मॉड्यूल का नाम बताएं जिसे आप चलाना चाहते हैं। यदि आप इसे एक मॉड्यूल डॉटेड-पथ (एक फ़ाइल पथ के बजाय) के रूप में नाम देते हैं, तो यह खोज पथ को सही ढंग से समझ सकता है। अधिक विवरण के लिए पीटर का उत्तर देखें।

— कार्ल मेयर

यह हैक एक ऐसे परिदृश्य में उपयोगी था जहां मुझे कुछ ऐसा चलाना था python -m pdb tests\test_antigravity.py। Pdb के अंदर, मैंने निष्पादित किया sys.path.insert(0, "antigravity")जो आयात विवरण को हल करने की अनुमति देता है जैसे कि मैं मॉड्यूल चला रहा था।

— ixe013

Answer 3

मैं आमतौर पर प्रोजेक्ट डायरेक्टरी में एक "रन टेस्ट" स्क्रिप्ट बनाता हूं (वह जो सोर्स डायरेक्टरी और दोनों के लिए कॉमन है test ) जो मेरे "ऑल टेस्ट" सूट को लोड करता है। यह आमतौर पर बॉयलरप्लेट कोड है, इसलिए मैं इसे परियोजना से परियोजना में पुन: उपयोग कर सकता हूं।

run_tests.py:

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

परीक्षण / all_tests.py ( मैं निर्देशिका में सभी पायथन यूनिट परीक्षण कैसे चलाऊँ ? )

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

इस सेटअप के साथ, आप वास्तव में सिर्फ include antigravityअपने परीक्षण मॉड्यूल में कर सकते हैं । नकारात्मक पक्ष यह है कि आपको किसी विशेष परीक्षा को निष्पादित करने के लिए अधिक समर्थन कोड की आवश्यकता होगी ... मैं हर बार बस उन्हें चलाता हूं।

Comments

मैं भी चाहता था एक run testsपरियोजना निर्देशिका में स्क्रिप्ट और पाया एक बहुत क्लीनर तरीका यह करने के लिए। अत्यधिक सिफारिशित।

— z33k

Answer 4

आपके द्वारा जुड़े लेख से:

एक test_modulename.py फ़ाइल बनाएं और उसमें अपने परीक्षण रद्द करें। चूंकि परीक्षण मॉड्यूल आपके कोड से अलग निर्देशिका में हैं, इसलिए आपको उन्हें चलाने के लिए अपने मॉड्यूल की मूल निर्देशिका को अपने PYTHONPATH में जोड़ना होगा:

$ cd /path/to/googlemaps

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

$ python test/test_googlemaps.py

अंत में, पायथन के लिए एक और लोकप्रिय इकाई परीक्षण रूपरेखा है (यह महत्वपूर्ण है!), नाक। नाक बिल्टिन यूनीटेस्ट फ्रेमवर्क को सरल और विस्तारित करने में मदद करता है (उदाहरण के लिए, यह आपके परीक्षण कोड को स्वचालित रूप से ढूंढ सकता है और आपके लिए अपना PYTHONPATH सेटअप कर सकता है), लेकिन यह मानक पायथन वितरण के साथ शामिल नहीं है।

शायद आपको नाक को देखना चाहिए जैसा कि यह सुझाव देता है?

Comments

हां यह काम करता है (मेरे लिए), लेकिन मैं वास्तव में सबसे सरल निर्देशों के लिए कह रहा हूं जो मैं अपने मॉड्यूल को परीक्षण चलाने के लिए प्राप्त करने के लिए उपयोगकर्ताओं को दे सकता हूं। पथ को संशोधित करना वास्तव में यह हो सकता है, लेकिन मैं कुछ और सीधे आगे के लिए मछली पकड़ रहा हूं।

— प्रमुख मेजर

सौ परियोजनाओं पर काम करने के बाद आपका अजगर मार्ग कैसा दिखता है? क्या मैं मैन्युअल रूप से अंदर जाने और अपना रास्ता साफ करने वाला हूं? यदि ऐसा है तो यह एक विचित्र डिजाइन है!

— jeremyjjbrown

Answer 5

मुझे एक ही समस्या थी, एक अलग इकाई परीक्षण फ़ोल्डर के साथ। उल्लेख सुझाव से मैं जोड़ने के पूर्ण स्रोत पथ के लिए sys.path।

निम्नलिखित समाधान का लाभ यह है, कि कोई भी test/test_yourmodule.pyपहली बार परीक्षण-निर्देशिका में बदले बिना फ़ाइल को चला सकता है :

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

Answer 6

अगर आप "python setup.py develop" चलाते हैं तो पैकेज पथ में होगा। लेकिन आप ऐसा नहीं करना चाहते हैं क्योंकि आप अपने सिस्टम अजगर इंस्टॉलेशन को संक्रमित कर सकते हैं, यही कारण है कि वर्चुअन और बिल्डआउट जैसे उपकरण मौजूद हैं।

Answer 7

समाधान / उदाहरण पायथन unittest मॉड्यूल के लिए

निम्नलिखित परियोजना संरचना को देखते हुए:

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

आप अपने प्रोजेक्ट को रूट डाइरेक्टरी से चला सकते हैं python project_name, जो कॉल करता है ProjectName/project_name/__main__.py।

---

अपने परीक्षणों को python testप्रभावी ढंग से चलाने के लिए ProjectName/test/__main__.py, आपको निम्नलिखित कार्य करने होंगे:

1)test/models एक __init__.pyफ़ाइल को जोड़कर अपनी निर्देशिका को एक पैकेज में बदलें । यह माता-पिता से उप निर्देशिका के भीतर परीक्षण के मामलों को सुलभ बनाता हैtest निर्देशिका ।

# ProjectName/test/models/__init__.py

from .test_thing_1 import Thing1TestCase        

2) निर्देशिका test/__main__.pyको शामिल करने के लिए अपने सिस्टम पथ को संशोधित करें 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)

---

अब आप project_nameअपने परीक्षणों में से चीजों को सफलतापूर्वक आयात कर सकते हैं ।

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

Answer 8

setup.py developअपनी कामकाजी निर्देशिका को स्थापित पायथन पर्यावरण का हिस्सा बनाने के लिए उपयोग करें , फिर परीक्षण चलाएं।

Comments

यह मेरे लिए हो जाता है invalid command 'develop'और अगर मैं पूछूं तो इस विकल्प का उल्लेख नहीं किया गया है setup.py --help-commands। क्या setup.pyइस काम के लिए अपने आप में कुछ होना आवश्यक है ?

— प्रमुख मेजर

यह ठीक है - समस्या यह थी कि मैं import setuptoolsअपनी setup.pyफाइल से गायब था । लेकिन मुझे लगता है कि यह दिखाने के लिए कि यह अन्य लोगों के मॉड्यूल के लिए हर समय काम नहीं करेगा।

— प्रमुख मेजर

यदि आपके पास पाइप है , तो आप अपने पैकेज को "संपादन योग्य" मोड में स्थापित करने के लिए उपयोग कर सकते हैं : pip install -e .यह इसी तरह पैकेज को स्रोत की नकल के बिना पायथन वातावरण में जोड़ता है, जिससे आप इसे संपादित करने के लिए जारी रख सकते हैं जहां यह निहित है।

— एरिक स्मिथ

pip install -e .यह ठीक वैसी ही बात है python setup.py develop, जैसे यह सेटअपूल setup.pyका उपयोग करने के लिए आपके बंदर को पकड़ता है, भले ही यह वास्तव में न हो, इसलिए यह किसी भी तरह से काम करता है।

— कार्ल मेयर

Answer 9

यदि आप VS कोड का उपयोग करते हैं और आपके परीक्षण आपकी परियोजना के समान स्तर पर स्थित हैं, तो आपका कोड चलाना और डीबग करना बॉक्स से बाहर काम नहीं करता है। आप क्या कर सकते हैं अपने लॉन्च को बदलें। json फ़ाइल:

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

यहाँ की प्रमुख पंक्ति एनविले है

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

अपनी परियोजना की जड़ में .env फ़ाइल जोड़ें

आपकी .env फ़ाइल के अंदर अपने प्रोजेक्ट के रूट में पथ जोड़ें। यह अस्थायी रूप से जोड़ देगा

PYTHONPATH = C: \ अपने \ अजगर \ परियोजना \ ROOT_DIRECTORY

आपके प्रोजेक्ट का पथ और आप VS कोड से डिबग यूनिट परीक्षणों का उपयोग करने में सक्षम होंगे

Answer 10

मैंने देखा है कि यदि आप अपने "src" निर्देशिका से सबसे आसान कमांड लाइन इंटरफेस चलाते हैं, तो बिना संशोधन के सही ढंग से काम करता है।

python -m unittest discover -s ../test

यदि आप अपनी परियोजना निर्देशिका में एक बैच फ़ाइल में रखना चाहते हैं, तो आप यह कर सकते हैं:

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

Answer 11

मैं लंबे समय से एक ही समस्या है। मैंने हाल ही में जो चुना वह निम्नलिखित निर्देशिका संरचना है:

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

और __init__.pyपरीक्षण फ़ोल्डर की स्क्रिप्ट में, मैं निम्नलिखित लिखता हूं:

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

परियोजना को साझा करने के लिए सुपर महत्वपूर्ण मेकफाइल है, क्योंकि यह स्क्रिप्ट को ठीक से चलाने में सक्षम है। यहाँ वह आदेश है जो मैंने मेकफाइल में रखा है:

run_tests:
    python -m unittest discover .

मेकफाइल केवल इसलिए नहीं चलता है क्योंकि यह कमांड चलाता है बल्कि यह भी है कि यह इसे कहां से चलाता है । यदि आप परीक्षणों में cd करते हैं और करते हैं python -m unittest discover ., तो यह काम नहीं करेगा क्योंकि init Unit_tests में स्क्रिप्ट os.getcwd () को कॉल करती है, जो तब गलत निरपेक्ष पथ को इंगित करता है (जो कि sys.path पर जोड़ा जाएगा और आपको याद नहीं होगा; आपका स्रोत फ़ोल्डर)। स्क्रिप्ट तब से चलेगी जब खोज को सभी परीक्षण मिल जाएंगे, लेकिन वे ठीक से नहीं चलेंगे। तो इस मुद्दे को याद रखने से बचने के लिए मेकफाइल है।

मैं वास्तव में इस दृष्टिकोण को पसंद करता हूं क्योंकि मुझे अपने src फ़ोल्डर, मेरी इकाई परीक्षण या मेरे पर्यावरण चर को छूने की ज़रूरत नहीं है और सब कुछ सुचारू रूप से चलता है।

अगर आप लोग इसे पसंद करते हैं तो मुझे बताएं।

उम्मीद है की वो मदद करदे,

Answer 12

मेरी परियोजना संरचना निम्नलिखित है:

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

मुझे सेटअप () विधि में आयात करना बेहतर लगा:

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

Answer 13

वास्तव में परीक्षण चलाने का सामान्य तरीका क्या है

मैं पाइथन 3.6.2 का उपयोग करता हूं

cd new_project

pytest test/test_antigravity.py

पाइस्टेस्ट स्थापित करने के लिए :sudo pip install pytest

मैंने कोई भी पथ चर सेट नहीं किया और मेरे आयात समान "परीक्षण" प्रोजेक्ट संरचना के साथ विफल नहीं हो रहे हैं।

मैंने इस सामग्री पर टिप्पणी की: if __name__ == '__main__'इस तरह:

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

Answer 14

रैपर का उपयोग करना संभव है जो चयनित या सभी परीक्षणों को चलाता है।

उदाहरण के लिए:

./run_tests antigravity/*.py

या सभी परीक्षणों को पुनः चलाने के लिए ग्लोबिंग ( tests/**/*.py) सक्षम करेंshopt -s globstar )।

रैपर मूल रूप argparseसे तर्कों को पार्स करने के लिए उपयोग कर सकते हैं:

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

फिर सभी परीक्षण लोड करें:

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

फिर उन्हें अपने परीक्षण सूट में जोड़ें (उपयोग करके 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))

और उन्हें चलाएं:

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

अधिक जानकारी के लिए इस उदाहरण की जाँच करें ।

यह भी देखें: एक निर्देशिका में सभी पायथन यूनिट परीक्षण कैसे चलाएं?

Answer 15

अजगर 3+

@Pierre में जोड़ना

unittestइस तरह निर्देशिका संरचना का उपयोग करना :

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

परीक्षण मॉड्यूल चलाने के लिए test_antigravity.py:

$ cd new_project
$ python -m unittest test.test_antigravity

या एक ही TestCase

$ python -m unittest test.test_antigravity.GravityTestCase

अनिवार्य भूलकर __init__.pyभी खाली जगह से काम नहीं चलेगा।

Answer 16

आप कुछ वूडू के बिना मूल निर्देशिका से आयात नहीं कर सकते। यहाँ अभी तक एक और तरीका है जो कम से कम पायथन 3.6 के साथ काम करता है।

सबसे पहले, निम्नलिखित सामग्री के साथ एक फ़ाइल परीक्षण / रेफ़रेंडम करें:

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

फिर फ़ाइल परीक्षण / test_antigravity.py में निम्नलिखित आयात करें:

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

ध्यान दें कि इस कोशिश को छोड़कर कारण क्लॉज है

• "python test_antigravity.py" और के साथ चलने पर आयात test.context विफल हो जाता है
• आयात प्रसंग विफल रहता है जब new_project डायरेक्टरी से "पायथन -म अनिटेस्ट" के साथ चलाया जाता है।

इस चालाकी से वे दोनों काम करते हैं।

अब आप परीक्षण निर्देशिका के भीतर सभी परीक्षण फ़ाइलें चला सकते हैं :

$ pwd
/projects/new_project
$ python -m unittest

या इसके साथ एक व्यक्तिगत परीक्षण फ़ाइल चलाएँ:

$ cd test
$ python test_antigravity

ठीक है, यह test_antigravity.py के संदर्भ के संदर्भ की सामग्री होने की तुलना में बहुत कम नहीं है, लेकिन शायद थोड़ा सा। सुझावों का स्वागत है।

Answer 17

यदि आपकी परीक्षण निर्देशिका में कई निर्देशिकाएं हैं, तो आपको प्रत्येक निर्देशिका में जोड़ना होगा a __init__.py फ़ाइल में ।

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

फिर हर परीक्षा को एक साथ चलाने के लिए, दौड़ें:

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

स्रोत: 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)

Answer 18

यह BASH स्क्रिप्ट फ़ाइल सिस्टम में कहीं से भी अजगर परीक्षण योग्य निर्देशिका को निष्पादित करेगी, चाहे आप किसी भी कार्यशील निर्देशिका में हों।

यह काम करने ./srcया ./exampleनिर्देशिका में रहने के दौरान उपयोगी है और आपको एक त्वरित इकाई परीक्षण की आवश्यकता है:

#!/bin/bash

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

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

test/__init__.pyउत्पादन के दौरान अपने पैकेज / मेमोरी-ओवरहेड को बोझ करने के लिए फ़ाइल की आवश्यकता नहीं है ।

Answer 19

इस तरह आप कमांड लाइन से सिस्टम चर के साथ खिलवाड़ के बिना जहाँ भी आप चाहते हैं से परीक्षण स्क्रिप्ट चलाने देंगे।

यह मुख्य प्रोजेक्ट फ़ोल्डर को अजगर पथ में जोड़ता है, स्थान स्क्रिप्ट के सापेक्ष पाया जाता है, वर्तमान कार्य निर्देशिका के सापेक्ष नहीं।

import sys, os

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

अपने सभी परीक्षण स्क्रिप्ट के शीर्ष पर उसे जोड़ें। यह मुख्य प्रोजेक्ट फ़ोल्डर को सिस्टम पथ में जोड़ देगा, इसलिए कोई भी मॉड्यूल जो वहां से काम करता है अब काम करेगा। और इससे कोई फर्क नहीं पड़ता कि आप परीक्षण कहां से चलाते हैं।

आप स्पष्ट रूप से अपने मुख्य प्रोजेक्ट फ़ोल्डर स्थान से मिलान करने के लिए project_path_hack फ़ाइल बदल सकते हैं।

Answer 20

यदि आप एक कमांड लाइन केवल समाधान के लिए देख रहे हैं:

निम्नलिखित निर्देशिका संरचना के आधार पर (एक समर्पित स्रोत निर्देशिका के साथ सामान्यीकृत):

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

विंडोज : (में new_project)

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

इस प्रश्न को देखें यदि आप इसे किसी बैच के लिए लूप में उपयोग करना चाहते हैं।

लिनक्स : (में 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

इस दृष्टिकोण के साथ, यदि आवश्यक हो तो PYTHONPATH में अधिक निर्देशिकाओं को जोड़ना संभव है।

Answer 21

आपको वास्तव में पाइप टूल का उपयोग करना चाहिए।

pip install -e .अपने पैकेज को विकास मोड में स्थापित करने के लिए उपयोग करें । यह एक बहुत अच्छा अभ्यास है, जिसे पाइस्टेस्ट द्वारा अनुशंसित किया गया है (उनके अच्छे अभ्यास दस्तावेज देखें , जहां आप अनुसरण करने के लिए दो प्रोजेक्ट लेआउट भी पा सकते हैं)।

Comments

क्यों इस जवाब को नीचा दिखाना? मैंने स्वीकार किए गए उत्तर को पढ़ा और जबकि यह खराब नहीं था, pytestपरीक्षणों को चलाने के लिए बेहतर तरीका है, क्योंकि आपके द्वारा प्राप्त कंसोल आउटपुट, रंग में, स्टैक ट्रेस जानकारी और विस्तृत अभिकथन त्रुटि जानकारी के साथ।

— एलोपी