पाइथन

Question

में स्वचालित रूप से परीक्षण सूट में दर्जन परीक्षण मामलों को जोड़ने के लिए मेरे पास विभिन्न फ़ोल्डरों में दर्जन परीक्षण केस हैं। मूल निर्देशिका में एक परीक्षण धावक होता है।

unittest\ 
    package1\ 
    test1.py 
    test2.py 
    package2\ 
    test3.py 
    test4.py 
    testrunner.py 

वर्तमान में मैं टेस्ट स्वीट

import unittest 
from package1.test1 import Test1 
from package1.test2 import Test2 
from package2.test3 import Test3 
from package2.test4 import Test4 

suite = unittest.TestSuite() 
suite.addTests(unittest.makeSuite(Test1)) 
suite.addTests(unittest.makeSuite(Test2)) 
suite.addTests(unittest.makeSuite(Test3)) 
suite.addTests(unittest.makeSuite(Test4)) 

result = unittest.TextTestRunner(verbosity=2).run(suite) 
if not result.wasSuccessful(): 
    sys.exit(1) 

परीक्षण धावक परीक्षण सभी प्रकार के परीक्षण स्वचालित रूप से जाने के लिए कैसे में मैन्युअल रूप से चार टेस्ट केस जोड़ा? जैसे:

for testCase in findTestCases(): 
    suite.addTests(testCase) 

Answer 1

उपर्युक्त मॉड्यूल अच्छे हैं लेकिन पैरामीटर में प्रवेश करने का प्रयास करते समय नाकटेस्ट मजाकिया हो सकते हैं और यह भी तेज और फिट है और अन्य मॉड्यूल में फिट है।

class SomeTestSuite(unittest.TestSuite): 

    # Tests to be tested by test suite 
    def makeRemoveAudioSource(): 
     suite = unittest.TestSuite() 
     suite.AddTest(TestSomething("TestSomeClass")) 

     return suite 

    def suite(): 
     return unittest.makeSuite(TestSomething) 

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

:

if __name__ == '__main__': 
    MyTests = Tests() 
    log_file = 'log_file.txt' 
    f = open(log_file, "w") 
    runner = unittest.TextTestRunner(f) 
    unittest.main(defaultTest='MyTests.suite', testRunner=runner) 

मॉड्यूल आप इस तरह जगह कोड का परीक्षण करते के तल पर

इसके अलावा:

import os, unittest 

class Tests(): 

    def suite(self): #Function stores all the modules to be tested 


     modules_to_test = [] 
     test_dir = os.listdir('.') 
     for test in test_dir: 
      if test.startswith('test') and test.endswith('.py'): 
       modules_to_test.append(test.rstrip('.py')) 

     alltests = unittest.TestSuite() 
     for module in map(__import__, modules_to_test): 
      module.testvars = ["variables you want to pass through"] 
      alltests.addTest(unittest.findTestCases(module)) 
     return alltests 

if __name__ == '__main__': 
    MyTests = Tests() 
    unittest.main(defaultTest='MyTests.suite') 

आप के बजाय अंत में इस ऐड एक लॉग फ़ाइल के लिए परिणामों को जोड़ना चाहते हैं

Answer 2

मेरी राय में आप खोज सुविधाओं के साथ unittest2 या अन्य परीक्षण चौखटे के लिए स्विच करना चाहिए। डिस्कवरी परीक्षण उन्हें चलाने के लिए वास्तव में एक रास्ता है।

अधिकांश जाना जाता है:

• nosetests
• py.test

nosetest साथ उदाहरण के लिए परियोजना रूट निर्देशिका से nosetests चलाने के लिए पर्याप्त है और यह पता चलता है और सभी इकाई परीक्षण यह चलेंगे पाते हैं। बहुत साधारण।

ध्यान दें कि unittest2 को अजगर 2.7 में शामिल किया जाएगा (और मुझे लगता है कि 2.4 तक अनुमानित)।

Answer 3

मैंने जो किया वह एक रैपर स्क्रिप्ट है जो अलग-अलग परीक्षण फ़ाइलों को चलाती है:

मुख्य रैपर run_tests.py:

#!/usr/bin/env python3 
# Usage: ./run_tests.py -h http://example.com/ tests/**/*.py 
import sys, unittest, argparse, inspect, logging 

if __name__ == '__main__': 
    # Parse arguments. 
    parser = argparse.ArgumentParser(add_help=False) 
    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('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") and len(name) > len("FooTest"): 
      alltests.addTest(make_suite(obj)) 

    # Run tests. 
    result = unittest.TextTestRunner(verbosity=2).run(alltests) 
    sys.exit(not result.wasSuccessful()) 

फिर परीक्षण के लिए एक और आवरण:

:

import sys, os, unittest 
from FooTest import FooTest 

class FooTest1(FooTest): 

    def test_homepage(self): 
     self.site.get(self.base_url + "/") 
     log.debug("Home page loaded.") 

तो आप आसानी से चला सकते हैं परीक्षण की तरह खोल से:

class FooTest(unittest.TestCase): 
    def __init__(self, *args, cargs=None, **kwargs): 
     super().__init__(*args, **kwargs) 
     self.vdisplay = Xvfb(width=1280, height=720) 
     self.vdisplay.start() 
     self.args=cargs 
     self.log=logging 

    def setUp(self): 
     self.site = webdriver.Firefox() 

    def kill(self): 
     self.vdisplay.stop() 

फिर अलग फ़ाइलों में प्रत्येक परीक्षा कैसा लगेगा

$ ./run_tests.py -h http://example.com/ test1.py test2.py 

आप कुछ परीक्षणों के भीतर सभी फ़ाइलों को निर्दिष्ट करने के लिए वाइल्डकार्ड का उपयोग कर सकते हैं, या a new globbing option (**) का उपयोग सभी परीक्षणों को पुन: क्रमबद्ध करने के लिए कर सकते हैं (shopt -s globstar द्वारा सक्षम)।