पायथन, यूनिट टेस्ट - पास कमांड लाइन तर्कों को सेट करने के लिए unittest.TestCase

Question

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

unittest.TestLoader().loadTestsFromTestCase() 

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

मुझे एहसास है कि मैं टेस्टकेस की सेटअप विधि में OptionParser जोड़ सकता हूं, लेकिन मैं इसके बजाय विकल्प को setUp पर भेजना चाहता हूं। क्या यह loadTestsFromTestCase() का उपयोग कर संभव है? मैं लौटा TestSuite के TestCases पर पुन: सक्रिय कर सकता हूं, लेकिन क्या मैं मैन्युअल रूप से TestCases पर सेटअप को कॉल कर सकता हूं?

** संपादित करें ** मैं कहना है कि मैं अगर मैं परीक्षणों पर पुनरावृति setUp तर्क गुजरती हैं और तरह मैन्युअल setUp फोन करने में सक्षम हूँ चाहता था:

(options, args) = op.parse_args() 
suite = unittest.TestLoader().loadTestsFromTestCase(MyTests.TestSOAPFunctions) 
for test in suite: 
    test.setUp(options.soap_uri) 

हालांकि, मैं xmlrunner उपयोग कर रहा हूँ इसके लिए और इसकी रन विधि TestSuite को तर्क के रूप में लेती है। मुझे लगता है कि यह सेटअप विधि स्वयं चलाएगा, इसलिए मुझे XMLTestRunner के भीतर उपलब्ध पैरामीटर की आवश्यकता होगी।

मुझे उम्मीद है कि यह समझ में आता है।

Answer 1

ठीक है, मैं वही काम करना चाहता हूं और खुद से यह प्रश्न पूछने जा रहा था। मैं निम्नलिखित कोड में सुधार करना चाहता था क्योंकि इसमें नकल है। यह मेरे तर्कों में भेज तथापि testcase परीक्षण करने के लिए करते हैं करता है:

import unittest 
import helpspot 

class TestHelpSpot(unittest.TestCase): 
    "A few simple tests for HelpSpot" 

    def __init__(self, testname, path, user, pword): 
     super(TestHelpSpot, self).__init__(testname) 
     self.hs = helpspot.HelpSpot(path, user, pword) 

    def test_version(self): 
     a = self.hs.version() 
     b = self.hs.private_version() 
     self.assertEqual(a, b) 

    def test_get_with_param(self): 
     a = self.hs.filter_get(xFilter=1) 

    def test_unknown_method(self): 
     self.assertRaises(helpspot.HelpSpotError, self.hs.private_wuggienorple) 

if __name__ == '__main__': 
    import sys 
    user = sys.argv[1] 
    pword = sys.argv[2] 
    path = sys.argv[3] 

    test_loader = unittest.TestLoader() 
    test_names = test_loader.getTestCaseNames(TestHelpSpot) 

    suite = unittest.TestSuite() 
    for test_name in test_names: 
     suite.addTest(TestHelpSpot(test_name, path, user, pword)) 

    result = unittest.TextTestRunner().run(suite) 
    sys.exit(not result.wasSuccessful()) 

Answer 2

मैं निश्चित रूप से इस तरह सेट अप करने के लिए तर्क पारित करने के खिलाफ सलाह दूंगा; एक परीक्षण चलाने के दौरान सेटअप को पूरी तरह से बुलाया जाना है, इसलिए आपको इसे स्पष्ट रूप से इस तरह से कॉल नहीं करना चाहिए।

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

Answer 3

आप init विधि में विशेषताओं निर्धारित करते हैं तो आप बस उन सब को इस तरह निर्माता में पारित कर सकते हैं ..

import unittest 
import helpspot 

class TestHelpSpot(unittest.TestCase): 
    "A few simple tests for HelpSpot" 

    def __init__(self, testname, path, user, pword): 
     super(TestHelpSpot, self).__init__(testname) 
     self.path = path 
     self.user = user 
     self.pword = pword 
.... 
.... 
.... 


if __name__ == '__main__': 
    True 

    suite = unittest.TestSuite() 
    suite.addTest(TestHelpSpot("test_version", path, user, pword))  

    unittest.TextTestRunner().run(suite) 

Answer 4

if __name__ == '__main__': 
    from optparse import OptionParser 
    parser = OptionParser() 
    parser.add_option("-z", "--zebra", 
         action="store_true", dest="zebra", default=False, 
         help="run like a zebra")  


    (options, args) = parser.parse_args() 

    if options.zebra: 
     zebrafy() 


    # remove our args because we don't want to send them to unittest 
    for x in sum([h._long_opts+h._short_opts for h in parser.option_list],[]): 
     if x in sys.argv: 
      sys.argv.remove(x) 


    unittest.main()