बड़ी मात्रा में डेटा

Question

के लिए समान दावे का परीक्षण कैसे करें मैं कई परीक्षण करने के लिए पाइथन unittest मॉड्यूल का उपयोग कर रहा हूँ; हालांकि, यह बहुत दोहराव है।

मेरे पास बहुत अधिक डेटा है जिसे मैं एक ही परीक्षण के माध्यम से चलाने के लिए चाहता हूं, सही जांच कर रहा हूं। हालांकि, मुझे हर किसी के लिए एक परीक्षण परिभाषित करना है।

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

कोई भी सुझाव अच्छा होगा।

import unittest 

class TestData(unittest.TestCase): 
    def testNumbers(self): 
     numbers = [0,11,222,33,44,555,6,77,8,9999] 
     for i in numbers: 
      self.assertEqual(i, 33) 

Answer 1

एक और पोस्ट में मैं ठोकर खाई Nose Tests करवाते हैं इसे और अधिक प्रेरित परीक्षण डेटा के लिए अनुकूल है।

class Test_data(): 
    def testNumbers(): 
     numbers = [0,11,222,33,44,555,6,77,8,9999] 
     for i in numbers: 
      yield checkNumber, num 

def checkNumber(num): 
    assert num == 33 

उपर्युक्त कोड मेरी पहली पोस्ट के समान ही है। कोई आयात की आवश्यकता नहीं है, बस एक अजगर वर्ग लिखें।

आप टाइप करके परीक्षण निष्पादित करें:

nosetests filename

Answer 2

एक पाश में दावे चल के साथ समस्या यह है कि, अगर दावे में से एक विफल रहता है, तुम नहीं जानते कि जो मूल्य यह कारण (अपने उदाहरण में, यह 0 पर विफल हो जाएगा है, लेकिन भी नहीं पड़ेगी पता है कि जब तक आप डीबग नहीं करते)। दूसरी ओर, self.assertEqual(i, 33) दोहराना एक और भी बुरा विचार है, क्योंकि यह कोड डुप्लिकेशन का परिचय देता है।

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

import unittest 

class TestData(unittest.TestCase): 
    def testNumbers(self): 
     def eq(i): 
      self.assertEqual(i, 33) 
     eq(0) 
     eq(11) 
     eq(222) 
     eq(33) 
     eq(44) 
     eq(555) 
     ... 

इस तरह, जब जोर 0 के लिए विफल रहता है, तो आप तुरंत यह unittest मॉड्यूल द्वारा मुद्रित स्टैक ट्रेस पर देखते हैं।

Answer 3

आप unittest.TestSuite क्लास का उपयोग करने पर विचार करना चाहेंगे, जो आपको गतिशील रूप से unittest के सेट का निर्माण करने की अनुमति देगा। टेस्टकेस उदाहरण जो अलग से चलाए जाएंगे। आपके unittest.TestCase subclass को उस विशेष उदाहरण के विरुद्ध परीक्षण करने के लिए मूल्य में गुजरने वाले निर्माण पैरामीटर को स्वीकार करने वाले वर्ग के साथ केवल एक परीक्षण विधि परिभाषित करनी चाहिए। विधेयक Gribble ने सुझाव दिया ऐसा दिखाई दे सकता समाधान के लिए

Answer 4

नमूना कोड:

import unittest 

class DataTestCase(unittest.TestCase): 
    def __init__(self, number): 
     unittest.TestCase.__init__(self, methodName='testOneNumber') 
     self.number = number 

    def testOneNumber(self): 
     self.assertEqual(self.number, 33) 

    def shortDescription(self): 
     # We need to distinguish between instances of this test case. 
     return 'DataTestCase for number %d' % self.number 


def get_test_data_suite(): 
    numbers = [0,11,222,33,44,555,6,77,8,9999] 
    return unittest.TestSuite([DataTestCase(n) for n in numbers]) 

if __name__ == '__main__': 
    testRunner = unittest.TextTestRunner() 
    testRunner.run(get_test_data_suite()) 

Answer 5

ddt library हल करने के लिए आप वास्तव में क्या कह रहे हैं बनाया गया था।

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

import ddt 
import unittest 

@ddt.ddt 
class EvalTests(unittest.TestCase): 

    @ddt.data(
      ('1', 1), 
      ('1 == 1', True), 
      ('1 == 2', False), 
      ('1 + 2', 4), ## This will fail 
    ) 
    def test_eval_expressions(self, case): 
     expr, exp_value = case 
     self.assertEqual(eval(expr), exp_value) 

और जब आप इसे चलाते हैं, तो आप सिर्फ एक के बजाय 4 testcases मिलती है:

$ python -m unittest -v test_eval.py 
test_eval_expressions_1___1___1_ (test_eval.EvalTests) ... ok 
test_eval_expressions_2___1__1___True_ (test_eval.EvalTests) ... ok 
test_eval_expressions_3___1__2___False_ (test_eval.EvalTests) ... ok 
test_eval_expressions_4___1_2___4_ (test_eval.EvalTests) ... FAIL 

====================================================================== 
FAIL: test_eval_expressions_4___1_2___4_ (test_eval.EvalTests) 
---------------------------------------------------------------------- 
Traceback (most recent call last): 
    File "/usr/lib/python/lib/site-packages/ddt.py", line 129, in wrapper 
    return func(self, *args, **kwargs) 
    File "/Work/test_eval.py", line 15, in test_eval_expressions 
    self.assertEqual(eval(expr), exp_value) 
AssertionError: 3 != 4 

---------------------------------------------------------------------- 
Ran 4 tests in 0.002s 

FAILED (failures=1) 

सूचना है कि डीडीटी की कोशिश करता है उत्पन्न के लिए नामों के साथ आने के लिए टीसीएस।

पिप के साथ इसे स्थापित करें:

pip install ddt 

Answer 6

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

आवश्यकता दोनों अनुकूलन के साथ दोनों परीक्षणों को चलाने की आवश्यकता है।

class Tests(unittest.TestCase): 

    def test_a_uses_b(self): 
     a = create_a() 
     b = create_b() 
     a.b = b 
     self.assertIs(b.a, a) 

    def test_b_uses_a(self): 
     a = create_a() 
     b = create_b() 
     b.a = a 
     self.assertIs(a.b, b) 

अपने आप TestSuite और TestCase instantiating, परीक्षण लोडर को दरकिनार, एक त्रुटि के परिणामस्वरूप यह एक एकल विधि की उम्मीद है क्योंकि, runTest कहा जाता है।

class Tests(unittest.TestCase): 

    def __init__(self, create_a, create_b): 
     super().__init__() 
     self.create_b = create_b 
     self.create_a = create_a 

    def test_a_uses_b(self): 
     a = self.create_a() 
     b = self.create_b() 
     a.b = b 
     self.assertIs(b.a, a) 

    def test_b_uses_a(self): 
     a = self.create_a() 
     b = self.create_b() 
     b.a = a 
     self.assertIs(a.b, b) 


class TestPair1(Tests): 
    def __init__(self): 
     super().__init__(create_a1, create_b1) 


class TestPair2(Tests): 
    def __init__(self): 
     super().__init__(create_a2, create_b2)