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


315

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

मेरे पहले बहादुर प्रयास के लिए, मैंने सोचा कि "अगर मैं फ़ाइल में अपने सभी परीक्षण मॉड्यूल आयात करता हूं, और फिर इस unittest.main()डूडड को कॉल करता हूं, तो यह काम करेगा, है ना?" खैर, पता चला कि मैं गलत था।

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

यह काम नहीं किया, मुझे जो परिणाम मिला वह था:

$ python all_test.py 

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

OK

मेरी दूसरी कोशिश के लिए, मैं हालांकि, ठीक है, शायद मैं इस पूरी परीक्षण चीज़ को अधिक "मैनुअल" फैशन में करने की कोशिश करूंगा। इसलिए मैंने नीचे ऐसा करने का प्रयास किया:

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

यह भी काम नहीं किया, लेकिन यह इतना करीब लगता है!

$ 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

मुझे लगता है कि किसी प्रकार का एक सूट है, और मैं परिणाम को निष्पादित कर सकता हूं। मैं इस तथ्य के बारे में थोड़ा चिंतित हूं कि यह कहता है कि मेरे पास केवल run=1ऐसा है, ऐसा लगता है कि ऐसा होना चाहिए run=2, लेकिन यह प्रगति है। लेकिन मैं मुख्य परिणाम कैसे पास और प्रदर्शित करूं? या मैं मूल रूप से इसे कैसे काम करूं, इसलिए मैं सिर्फ इस फ़ाइल को चला सकता हूं, और ऐसा करने में, इस निर्देशिका में सभी यूनिट परीक्षण चलाएं?


1
यदि आप पायथन 2.7+
रॉकी

क्या तुमने कभी एक परीक्षण उदाहरण वस्तु से परीक्षण चलाने की कोशिश की?
पिनोचियो

एक उदाहरण फ़ाइल संरचना के साथ समाधान के लिए इस उत्तर को देखें ।
डेरेक सोइक

जवाबों:


477

पायथन 2.7 और उच्चतर के साथ आपको ऐसा करने के लिए नया कोड लिखने या तीसरे पक्ष के टूल का उपयोग करने की आवश्यकता नहीं है; कमांड लाइन के माध्यम से पुनरावर्ती परीक्षण निष्पादन अंतर्निहित है। __init__.pyअपने परीक्षण निर्देशिका में एक रखो और:

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

आप अजगर 2.7 या अजगर 3.x unittest प्रलेखन में अधिक पढ़ सकते हैं ।


11
समस्याओं में शामिल हैं: ImportError: प्रारंभ निर्देशिका आयात करने योग्य नहीं है:
zinking

6
कम से कम लिनक्स पर पायथन 2.7.8 के साथ न तो कमांड लाइन आह्वान मुझे पुनरावृत्ति देता है। मेरी परियोजना में कई उपप्रोजेक्ट हैं जिनकी इकाई परीक्षण संबंधित "Unit_tests / <subproject> / python" निर्देशिका में रहते हैं। यदि मैं ऐसे पथ को निर्दिष्ट करता हूं तो उस उपप्रोजेक्ट के लिए इकाई परीक्षण चलाए जाते हैं, लेकिन परीक्षण निर्देशिका के तर्क के रूप में सिर्फ "Unit_tests" के साथ कोई परीक्षण नहीं मिलते हैं (सभी उपप्रकारों के लिए सभी परीक्षणों के बजाय, जैसा कि मुझे आशा थी)। कोई संकेत?
user686249

6
पुनरावर्तन के बारे में: <test_directory> के बिना "के बिना" पहली कमांड। और submodules को पुन: पेश करता है । यही कारण है कि, आपके द्वारा खोजे गए सभी परीक्षण निर्देशिकाओं में एक init .py होना चाहिए। यदि वे करते हैं, तो वे खोज कमांड द्वारा मिल जाएंगे। बस कोशिश की, यह काम किया।
एमिल स्टेनस्ट्रॉम

इसने मेरे लिए काम किया। मेरे पास चार फ़ाइलों के साथ एक परीक्षण फ़ोल्डर है, इसे मेरे लिनक्स टर्मिनल, महान सामान से चलाएं।
जस्सोन्चैर

5
धन्यवाद! यह स्वीकृत उत्तर क्यों नहीं है? मेरे विचार में, बेहतर उत्तर हमेशा वह होता है जिसे किसी बाहरी निर्भरता की आवश्यकता नहीं होती है ...
जोनाथन बेने

108

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

अपडेट किया गया:

यहाँ मेरे पूर्व-नाक दिनों से कुछ कोड है। आप शायद मॉड्यूल नामों की स्पष्ट सूची नहीं चाहते हैं, लेकिन शायद बाकी सभी आपके लिए उपयोगी होंगे।

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)

2
क्या इस दृष्टिकोण का लाभ केवल अपने सभी परीक्षण मॉड्यूल को स्पष्ट रूप से एक test_all.py मॉड्यूल में आयात करने और unittest.main () को कॉल करने से है कि आप वैकल्पिक रूप से कुछ मॉड्यूल में टेस्ट सूट की घोषणा कर सकते हैं और दूसरों में नहीं?
कोरी पोर्टर

1
मैंने नाक बाहर करने की कोशिश की और यह पूरी तरह से काम करता है। मेरी परियोजना को स्थापित करना और चलाना आसान था। मैं इसे स्क्रिप्ट की कुछ पंक्तियों के साथ स्वचालित करने में सक्षम था, जो एक वर्चुअन के अंदर चल रहा था। नाक के लिए +1!
जेसी वेब

हमेशा करने योग्य नहीं: कभी-कभी परियोजना की संरचना को आयात करने से नाक भ्रमित हो सकती है अगर यह मॉड्यूल पर आयात चलाने की कोशिश करता है।
शिफ़ा

4
ध्यान दें कि नाक "पिछले कई वर्षों से रखरखाव मोड में है" और वर्तमान में नई परियोजनाओं के लिए nose2 , pytest , या सिर्फ सादे unittest / unittest2 का उपयोग करने की सलाह दी जाती है ।
कर्ट पीक

क्या तुमने कभी एक परीक्षण उदाहरण वस्तु से परीक्षण चलाने की कोशिश की?
पिनोचियो

95

अजगर 3 में, यदि आप उपयोग कर रहे हैं unittest.TestCase:

  • __init__.pyआपकी testनिर्देशिका में एक खाली (या अन्यथा) फ़ाइल होनी चाहिए ( नाम होना चाहिए test/)
  • आपकी परीक्षण फ़ाइलें test/पैटर्न से मेल खाती हैं test_*.py। वे एक उपनिर्देशिका के अंदर हो सकते हैं test/, और उन उप- अध्यक्षों को कुछ भी नाम दिया जा सकता है।

उसके बाद, आप सभी परीक्षण चला सकते हैं:

python -m unittest

किया हुआ! 100 लाइनों से कम का हल। उम्मीद है कि एक और अजगर शुरुआत यह पता लगाकर समय बचाता है।


3
ध्यान दें कि डिफ़ॉल्ट रूप से यह केवल "परीक्षण" से शुरू होने वाले फ़ाइलनामों में परीक्षण के लिए खोज करता है
शावाबावा

3
यह सही है, मूल प्रश्न इस तथ्य को संदर्भित करता है कि "प्रत्येक इकाई परीक्षण मॉड्यूल फॉर्म टेस्ट _ *। Py" का है, इसलिए यह उत्तर सीधे उत्तर में है। मैंने अब उत्तर को अधिक स्पष्ट होने के लिए अपडेट किया है
tmck-code

1
धन्यवाद, जो मुझे ट्रैविस बियर के उत्तर का उपयोग करने के लिए याद आ रहा था।
जेरेमी कोचोय

65

यह अब सीधे unittest से संभव है: 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)

3
मैंने इस पद्धति को भी आजमाया है, कुछ परीक्षण किए हैं, लेकिन पूरी तरह से काम करता है। अति उत्कृष्ट!!! लेकिन मैं उत्सुक हूं कि मेरे पास केवल 4 परीक्षण हैं। साथ में वे 0.032s चलाते हैं, लेकिन जब मैं उन सभी को चलाने के लिए इस पद्धति का उपयोग करता हूं, तो मुझे परिणाम मिलता है .... ---------------------------------------------------------------------- Ran 4 tests in 0.000s OKक्यों? अंतर, यह कहां से आता है?
सिमुकस

मुझे कमांड लाइन से इस तरह दिखने वाली फाइल को चलाने में परेशानी हो रही है। इसे कैसे लागू किया जाना चाहिए?
डस्टिन मिशेल्स

python file.py
slaughter98

1
निर्दोष रूप से काम किया! बस इसे अपने टेस्ट / डायर में सेट करें और फिर start_id = "./" पर सेट करें। IMHO, यह उत्तर अब (अजगर 3.7) स्वीकृत तरीका है!
jjwdesign

आप अंतिम पंक्ति को =res = runner.run (सुइट) में बदल सकते हैं; sys.exit (0 if res.wasSuccessful () और 1) ex यदि आप एक सही निकास कोड चाहते हैं
Sadap

32

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

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)

हाँ, ऐसा करने की तुलना में सिर्फ नाक का उपयोग करना आसान है, लेकिन यह बिंदु के अलावा है।


अच्छा, यह वर्तमान निर्देशिका के लिए ठीक काम करता है, उप-सीधे कैसे आमंत्रित करें?
लैरी कै

लैरी, पुनरावर्ती परीक्षण खोज के लिए नया उत्तर ( stackoverflow.com/a/24562019/104143 ) देखें
पीटर कॉफ़लर

क्या तुमने कभी एक परीक्षण उदाहरण वस्तु से परीक्षण चलाने की कोशिश की?
पिनोचियो

25

यदि आप विभिन्न परीक्षण केस कक्षाओं से सभी परीक्षण चलाना चाहते हैं और आप उन्हें स्पष्ट रूप से निर्दिष्ट करने में प्रसन्न हैं तो आप इसे इस तरह कर सकते हैं:

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)

uclidमेरा प्रोजेक्ट कहाँ है TestSymbolsऔरTestPatterns की उपवर्गों हैं TestCase


से unittest.TestLoader डॉक्स : "आम तौर पर, इस वर्ग का एक उदाहरण बनाने के लिए कोई जरूरत नहीं है; unittest मॉड्यूल एक उदाहरण है कि unittest.defaultTestLoader के रूप में साझा किया जा सकता प्रदान करता है।" चूंकि एक तर्क के रूप में TestSuiteएक चलने योग्य को स्वीकार करता है, इसलिए आप दोहराए जाने से बचने के लिए कहा जा सकता है कि लूप में चलने योग्य है loader.loadTestsFromTestCase
दो-बिट अल्केमिस्ट

@ दो-बिट अल्केमिस्ट आपका दूसरा बिंदु विशेष रूप से अच्छा है। मैं शामिल करने के लिए कोड बदलूंगा, लेकिन मैं इसका परीक्षण नहीं कर सकता। (पहला मॉड यह मेरी पसंद के लिए जावा की तरह बहुत ज्यादा दिखाई देगा .. हालांकि मुझे एहसास है कि मैं तर्कहीन हो रहा हूं (उन्हें अपने ऊंट मामले चर नामों को स्क्रू करें)।
हेजहोग

यह मेरा फेव है, बहुत साफ है। इसे पैकेज करने और इसे मेरी नियमित कमांड लाइन में तर्क देने में सक्षम था।
MarkII

15

मैंने discoverविधि का उपयोग किया है और load_testsइस परिणाम को प्राप्त करने के लिए एक अधिभार (न्यूनतम, मुझे लगता है) कोड की संख्या रेखाएं हैं:

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

पत्नियों पर ज़ुल्म कुछ इस तरह

Ran 27 tests in 0.187s
OK

यह केवल python2.7 के लिए उपलब्ध है, मुझे लगता है
लैरी कै

@larrycai हो सकता है, मैं आमतौर पर पायथन 3 पर हूं, कभी-कभी पायथन 2.7। प्रश्न एक विशिष्ट संस्करण से बंधा नहीं था।
आरडीएस

मैं Python 3.4 पर हूं और एक सूट की खोज करता हूं, जिससे लूप बेमानी हो जाता है।
टिब्बा

भविष्य के लैरी के लिए: "टेस्ट डिस्कवरी सहित पायथन 2.7 में कई नई विशेषताओं को एकसाथ जोड़ा गया था। unittest2 आपको पायथन के पुराने संस्करणों के साथ इन सुविधाओं का उपयोग करने की अनुमति देता है।"
दो-बिट अल्केमिस्ट

8

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

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

और सबसे महत्वपूर्ण बात, यह निश्चित रूप से काम करता है।


7

पैकेज्ड लाइब्रेरी या एप्लिकेशन के मामले में , आप ऐसा नहीं करना चाहते हैं। setuptools आपके लिए करेंगे

इस कमांड का उपयोग करने के लिए, आपकी परियोजना के परीक्षणों को unittestएक फ़ंक्शन, टेस्टकेस क्लास या विधि, या एक मॉड्यूल या पैकेज युक्त TestCaseकक्षाओं द्वारा टेस्ट सूट में लपेटा जाना चाहिए । यदि नामित सुइट एक मॉड्यूल है, और मॉड्यूल में एक additional_tests()फ़ंक्शन है, तो इसे कहा जाता है और परिणाम (जो होना चाहिए unittest.TestSuite) को चलाने के लिए परीक्षणों में जोड़ा जाता है। यदि नामित सूट एक पैकेज है, तो किसी भी सबमॉड्यूल्स और उपपैकेज को पुन: समग्र परीक्षण सूट में जोड़ा जाता है

बस यह बताएं कि आपका रूट टेस्ट पैकेज कहां है:

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

और दौड़ो python setup.py test

पायथन 3 में फ़ाइल-आधारित खोज समस्याग्रस्त हो सकती है, जब तक कि आप अपने परीक्षण सूट में सापेक्ष आयात से बचें, क्योंकि discoverफ़ाइल आयात का उपयोग करता है। भले ही यह वैकल्पिक का समर्थन करता है top_level_dir, लेकिन मेरे पास कुछ अनंत पुनरावृत्ति त्रुटियां थीं। तो एक गैर-पैकेज्ड कोड के लिए एक सरल उपाय यह है कि आप __init__.pyअपने टेस्ट पैकेज को देखें ( load_tests प्रोटोकॉल देखें )।

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

अच्छा जवाब है, और यह तैनात करने से पहले परीक्षण को स्वचालित करने के लिए इस्तेमाल किया जा सकता है! धन्यवाद
आर्थर Clerc-Gherardi

4

मैं PyDev / LiClipse का उपयोग करता हूं और वास्तव में यह पता नहीं लगाया है कि GUI से एक बार में सभी परीक्षण कैसे चलाएं। (संपादित करें: आप सही रूट परीक्षण फ़ोल्डर पर क्लिक करें और चुनेंRun as -> Python unit-test

यह मेरा वर्तमान समाधान है:

import unittest

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

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

मैंने इस कोड को एक मॉड्यूल में बुलाया है all को अपनी परीक्षण निर्देशिका । यदि मैं इस मॉड्यूल को LiClipse से यूनीटेस्ट के रूप में चलाता हूं तो सभी परीक्षण चलाए जाते हैं। अगर मैं केवल विशिष्ट या असफल परीक्षणों को दोहराने के लिए कहता हूं तो केवल उन परीक्षणों को चलाया जाता है। यह मेरे कमांडलाइन टेस्ट रनर के साथ हस्तक्षेप नहीं करता है (या nosetests) - इसे अनदेखा किया गया है।

आपको discoverअपने प्रोजेक्ट सेटअप के आधार पर तर्क बदलने की आवश्यकता हो सकती है ।


सभी परीक्षण फ़ाइलों और परीक्षण विधियों के नाम "test_" से शुरू होने चाहिए। अन्यथा कमांड "रन के रूप में -> पायथन यूनिट टेस्ट" उन्हें नहीं मिलेगा।
स्टीफन

2

स्टीफन कैगल के उत्तर के आधार पर मैंने नेस्टेड टेस्ट मॉड्यूल के लिए समर्थन जोड़ा।

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)

कोड उन फ़ाइलों के .लिए सभी उपनिर्देशिका खोजता है *Tests.pyजो तब भरी हुई हैं। यह उम्मीद करता है कि प्रत्येक *Tests.pyमें एक एकल वर्ग शामिल होगा *Tests(unittest.TestCase)जो बदले में लोड होता है और एक के बाद एक निष्पादित होता है।

यह निर्देशिका / मॉड्यूल के मनमाने ढंग से गहरे घोंसले के शिकार के साथ काम करता है, लेकिन बीच में प्रत्येक निर्देशिका में __init__.pyकम से कम एक खाली फ़ाइल शामिल करने की आवश्यकता होती है । यह परीक्षण डॉट्स (देखें replace_slash_by_dot) द्वारा स्लैश (या बैकस्लैश) की जगह नेस्टेड मॉड्यूल को लोड करने की अनुमति देता है ।


2

यह एक पुराना सवाल है, लेकिन मेरे लिए अब (2019 में) क्या काम किया गया है:

python -m unittest *_test.py

मेरी सभी परीक्षण फाइलें स्रोत फ़ाइलों के समान फ़ोल्डर में हैं और वे समाप्त होती हैं _test



1

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

सभी TESTS, स्वतंत्र $ PWD

जब तक आप यह न बताएं कि जब तक आप इसका उपयोग नहीं करते हैं, तब तक आपके मौजूदा निर्देशिका के लिए सबसे संवेदनशील पायथन मॉड्यूल संवेदनशील है discover -s विकल्प विकल्प है) ।

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

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

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

चयनित TESTS, स्वतंत्र $ PWD

मैं इस उपयोगिता फ़ाइल को नाम देता हूं: runone.pyऔर इसे इस तरह उपयोग करें:

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)

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


-3

कमांड लाइन से परीक्षण चलाने के लिए रैपर बनाकर यहां मेरा दृष्टिकोण है :

#!/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())

सादगी के लिए, कृपया मेरे गैर- PEP8 कोडिंग मानकों का उपयोग करें।

तब आप अपने सभी परीक्षणों के लिए सामान्य घटकों के लिए बेसटेस्ट क्लास बना सकते हैं, इसलिए आपका प्रत्येक परीक्षण सरलता से दिखेगा:

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

चलाने के लिए, आप बस कमांड लाइन के तर्कों के भाग के रूप में परीक्षणों को निर्दिष्ट कर रहे हैं, जैसे:

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

2
इस उत्तर का अधिकांश परीक्षण खोज (यानी लॉगिंग, आदि) से कोई लेना-देना नहीं है। स्टैक ओवरफ्लो सवालों के जवाब देने के लिए है, असंबंधित कोड नहीं दिखा रहा है।
कोरी गोल्डबर्ग
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.