Python में यूनिट टेस्टिंग ट्यूटोरियल

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

आम तौर पर, जब विकास प्रक्रिया पूरी हो जाती है, तो डेवलपर टेस्ट स्क्रिप्ट में मानदंड या वे परिणाम कोड करता है जो संभावित रूप से व्यावहारिक और उपयोगी माने जाते हैं, ताकि किसी विशेष यूनिट की शुद्धता सत्यापित की जा सके। टेस्ट केस निष्पादन के दौरान, विभिन्न फ्रेमवर्क उन परीक्षणों को लॉग करते हैं जो किसी भी मानदंड में विफल होते हैं और उन्हें सारांश में रिपोर्ट करते हैं।

डेवलपर्स से अपेक्षा की जाती है कि वे स्वचालित टेस्ट स्क्रिप्ट लिखें, जो सुनिश्चित करती हैं कि प्रत्येक सेक्शन या यूनिट अपने डिज़ाइन के अनुरूप है और अपेक्षित रूप से व्यवहार करता है।

Python यूनिट टेस्टिंग

हालांकि अपने कोड के लिए मैनुअल टेस्ट लिखना निश्चित रूप से थकाऊ और समय लेने वाला कार्य है, Python के बिल्ट-इन यूनिट टेस्टिंग फ्रेमवर्क ने काम को काफी आसान बना दिया है।

Python में यूनिट टेस्ट फ्रेमवर्क को unittest कहा जाता है, जो Python के साथ पैकेज्ड आता है।

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

एक यूनिट को विभिन्न श्रेणियों में बांटा जा सकता है:

• पूरा मॉड्यूल,
• कोई व्यक्तिगत फ़ंक्शन,
• किसी क्लास या मेथड जैसी संपूर्ण इंटरफेस।

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

Python का यूनिट टेस्टिंग फ्रेमवर्क जावा के JUnit से प्रेरित है और अन्य भाषाओं के प्रमुख यूनिट टेस्टिंग फ्रेमवर्क्स जैसी विशेषताएं रखता है। Python का यूनिट टेस्टिंग फ्रेमवर्क कई फीचर्स प्रदान करता है, जिनमें शामिल हैं:

• टेस्ट ऑटोमेशन
• टेस्ट के लिए सेटअप और शटडाउन कोड साझा करना
• टेस्ट्स को संग्रहों में समेकित करना
• टेस्ट्स का रिपोर्टिंग फ्रेमवर्क से स्वतंत्र होना

अब एक उदाहरण लेते हैं और समझते हैं कि आपको अपने कोड के लिए यूनिट टेस्टिंग की आवश्यकता क्यों है।

Python unittest के साथ शुरुआत

नीचे, हमने वे चरण बताए हैं जिनसे आप Python के unittest फ्रेमवर्क का उपयोग कर सकते हैं

क्यूब फ़ंक्शन बनाना

आइए Python में घन का आयतन निकालने के लिए कोड लिखते हैं

def cuboid_volume(l):
    return (l*l*l)
length = [2,1.1, -2.5, 2j, 'two']
for i in range(len(length)):
    print ("The volume of cuboid:",cuboid_volume(length[i]))संचालित द्वारा

The volume of cuboid: 8
The volume of cuboid: 1.3310000000000004
The volume of cuboid: -15.625
The volume of cuboid: (-0-8j)
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-7-67e1c37a435f> in <module>
      1 for i in range(len(length)):
----> 2     print ("The volume of cuboid:",cuboid_volume(length[i]))
<ipython-input-2-f50464fd88da> in cuboid_volume(l)
      1 def cuboid_volume(l):
----> 2     return (l*l*l)
TypeError: can't multiply sequence by non-int of type 'str'संचालित द्वारा

परिणाम विश्लेषण

ऊपर दिया गया आउटपुट आपको अपने कोड के लिए यूनिट टेस्ट होने के महत्व के बारे में कुछ सहज बोध देगा। अब ऊपर दिए गए कोड में तीन बातें निश्चित रूप से गलत हैं:

• पहला, घन का आयतन नकारात्मक होना,
• दूसरा, घन का आयतन एक समिश्र संख्या होना,
• अंत में, कोड में TypeError आना क्योंकि आप किसी स्ट्रिंग, जो non-int है, का गुणन नहीं कर सकते।

तीसरी समस्या तो सौभाग्य से एक त्रुटि के रूप में सामने आ गई, जबकि पहली और दूसरी सफल रहीं, जबकि घन का आयतन न तो नकारात्मक हो सकता है और न ही समिश्र संख्या।

यूनिट टेस्ट आमतौर पर अलग फ़ाइल में अलग कोड के रूप में लिखे जाते हैं, और नामकरण के अलग-अलग कन्वेंशंस अपनाए जा सकते हैं। आप यूनिट टेस्ट फ़ाइल का नाम कोड/यूनिट का नाम + test अंडरस्कोर से अलग कर या test + कोड/यूनिट का नाम अंडरस्कोर से अलग कर रख सकते हैं।

उदाहरण के लिए, मान लें कि ऊपर दिए गए कोड फ़ाइल का नाम cuboid_volume.py है, तो आपके यूनिट टेस्ट कोड का नाम cuboid_volume_test.py हो सकता है

बिना किसी देरी के, आइए ऊपर दिए गए कोड के लिए यूनिट टेस्ट लिखते हैं।

assertAlmostEqual का उपयोग

पहले, volume_cuboid.py नाम की एक Python फ़ाइल बनाते हैं, जिसमें आयतन की गणना का कोड होगा, और दूसरी test_volume_cuboid.py नाम की, जिसमें यूनिट टेस्टिंग कोड होगा।

import unittest

TestCuboid क्लास unittest मॉड्यूल से इनहेरिट करती है, और इस क्लास में आप वे विभिन्न मेथड परिभाषित करेंगे जिन पर आप चाहते हैं कि आपका यूनिट टेस्ट आपके cuboid_volume फ़ंक्शन को जांचे।

पहला फ़ंक्शन जो आप परिभाषित करेंगे, वह है test_volume, जो जांचेगा कि cuboid_volume का आउटपुट आपके अपेक्षित मान के बराबर है या नहीं। यह हासिल करने के लिए आप assertAlmostEqual मेथड का उपयोग करेंगे।

टेस्ट 1

class TestCuboid(unittest.TestCase):
    def test_volume(self):
        self.assertAlmostEqual(cuboid_volume(2),8)
        self.assertAlmostEqual(cuboid_volume(1),1)
        self.assertAlmostEqual(cuboid_volume(0),0)
        self.assertAlmostEqual(cuboid_volume(5.5),166.375)संचालित द्वारा

आइए ऊपर दिए गए स्क्रिप्ट को चलाते हैं। आप unittest मॉड्यूल को एक स्क्रिप्ट के रूप में चलाएंगे और इसे चलाते समय -m निर्दिष्ट करेंगे।

!python -m unittest test_volume_cuboid.pyसंचालित द्वारा

आउटपुट:

.
----------------------------------------------------------------------
Ran 1 test in 0.000s
OKसंचालित द्वारा

बहुत बढ़िया! आपका पहला यूनिट टेस्ट कोड काम कर रहा है।

टेस्ट सफलतापूर्वक चला और OK लौटाया, जिसका अर्थ है कि cuboid_volume फ़ंक्शन अपेक्षा के अनुरूप काम कर रहा है।

टेस्ट 2

आइए देखते हैं कि जब किसी assertAlmostEqual मेथड में विफलता आती है तो क्या होता है।

ध्यान दें कि आखिरी assert स्टेटमेंट को संशोधित किया गया है।

!python -m unittest test_volume_cuboid.pyसंचालित द्वारा

आउटपुट:

F
======================================================================
FAIL: test_volume (test_volume_cuboid.TestCuboid)
----------------------------------------------------------------------
Traceback (most recent call last):
  File "C:\Users\hda3kor\Documents\Unit_Testing_Python\test_volume_cuboid.py", line 15, in test_volume
    self.assertAlmostEqual(cuboid_volume(5.5),0)
AssertionError: 166.375 != 0 within 7 places (166.375 difference)
----------------------------------------------------------------------
Ran 1 test in 0.001s
FAILED (failures=1)संचालित द्वारा

ऊपर दिए गए आउटपुट से स्पष्ट है कि आखिरी assert स्टेटमेंट में AssertionError आया, इसलिए यूनिट टेस्ट विफल हुआ। Python का यूनिट टेस्ट मॉड्यूल विफलता का कारण और आपके कोड में विफलताओं की संख्या दिखाता है।

assertRaises का उपयोग

अब एक और assert मेथड, यानी assertRaises को देखते हैं, जो यह जानने में मदद करेगा कि आपका cuboid_volume फ़ंक्शन इनपुट मानों को सही ढंग से संभाल रहा है या नहीं।

मान लें कि आप यह जांचना चाहते हैं कि आपका cuboid_volume फ़ंक्शन इनपुट के क्लास या टाइप को संभालता है या नहीं। उदाहरण के लिए, यदि आप स्ट्रिंग इनपुट के रूप में पास करते हैं, तो क्या वह इनपुट को अपवाद के रूप में हैंडल करेगा या if कंडीशन से, क्योंकि घन की भुजा कभी भी स्ट्रिंग नहीं हो सकती।

!python -m unittest test_volume_cuboid.pyसंचालित द्वारा

आउटपुट:

F.
======================================================================
FAIL: test_input_value (test_volume_cuboid.TestCuboid)
----------------------------------------------------------------------
Traceback (most recent call last):
  File "C:\Users\hda3kor\Documents\Unit_Testing_Python\test_volume_cuboid.py", line 17, in test_input_value
    self.assertRaises(TypeError, cuboid_volume, True)
AssertionError: TypeError not raised by cuboid_volume
----------------------------------------------------------------------
Ran 2 tests in 0.001s
FAILED (failures=1)संचालित द्वारा

बहुत अच्छा! ऊपर दिए गए आउटपुट से स्पष्ट है कि आपका volume_cuboid.py कोड इनपुट को सही ढंग से हैंडल नहीं कर रहा है।

क्यूब फ़ंक्शन में संशोधन

आइए volume_cuboid.py में एक कंडीशन जोड़ते हैं जिससे यह जांचा जा सके कि घन की भुजा या इनपुट बूलियन है या स्ट्रिंग, और ऐसी स्थिति में त्रुटि उठाई जाए।

!python -m unittest test_volume_cuboid.pyसंचालित द्वारा

आउटपुट:

..
----------------------------------------------------------------------
Ran 2 tests in 0.001s
OKसंचालित द्वारा

Jupyter lab में Python टेस्टिंग स्क्रिप्ट चलाना

अब टेस्टिंग स्क्रिप्ट को jupyter lab के भीतर चलाते हैं। इसके लिए, पहले आप jupyter lab में टेस्टिंग स्क्रिप्ट परिभाषित करेंगे, जैसा कि नीचे दिखाया गया है।

# -*- coding: utf-8 -*-
"""
Created on Sat Apr 25 20:16:58 2020
@author: Aditya
"""
from volume_cuboid import *
import unittest
class TestCuboid(unittest.TestCase):
    def test_volume(self):
        self.assertAlmostEqual(cuboid_volume(2),8)
        self.assertAlmostEqual(cuboid_volume(1),1)
        self.assertAlmostEqual(cuboid_volume(0),1)
    def test_input_value(self):
        self.assertRaises(TypeError, cuboid_volume, True)संचालित द्वारा

फिर, आप टेस्टिंग स्क्रिप्ट चलाने के लिए unittest.main() मेथड का उपयोग करेंगे। आप नीचे दिए गए मेथड को कई आर्गुमेंट्स पास कर सकते हैं, जिनमें से एक है verbosity level।

आइए अलग-अलग verbosity स्तरों के साथ प्रयोग करें और देखें कि आउटपुट विवरण कैसे बदलता है।

Verbosity 0

unittest.main(argv=[''],verbosity=0, exit=False)
Output:
----------------------------------------------------------------------
Ran 2 tests in 0.000s
OK
<unittest.main.TestProgram at 0x1de02774348>संचालित द्वारा

Verbosity 1

unittest.main(argv=[''],verbosity=1, exit=False)
Output:
..
----------------------------------------------------------------------
Ran 2 tests in 0.002s
OK
<unittest.main.TestProgram at 0x1de027a1cc8>संचालित द्वारा

Verbosity 2

unittest.main(argv=[''],verbosity=2, exit=False)
Output:
test_input_value (__main__.TestCuboid) ... ok
test_volume (__main__.TestCuboid) ... ok
----------------------------------------------------------------------
Ran 2 tests in 0.002s
OK
<unittest.main.TestProgram at 0x1de027a8308>संचालित द्वारा

AssertionError का दृश्यावलोकन

अंत में, test_volume मेथड में अंतिम assertAlmostEqual को संशोधित करते हैं और विश्लेषण करते हैं कि verbosity स्तर 2 मेथड की विफलता कैसे दिखाता है।

# -*- coding: utf-8 -*-
"""
Created on Sat Apr 25 20:16:58 2020
@author: Aditya
"""
from volume_cuboid import *
import unittest
class TestCuboid(unittest.TestCase):
    def test_volume(self):
        self.assertAlmostEqual(cuboid_volume(2),8)
        self.assertAlmostEqual(cuboid_volume(1),1)
        self.assertAlmostEqual(cuboid_volume(0),1)
    def test_input_value(self):
        self.assertRaises(TypeError, cuboid_volume, True)
unittest.main(argv=[''],verbosity=2, exit=False)संचालित द्वारा

आउटपुट:

test_input_value (__main__.TestCuboid) ... ok
test_volume (__main__.TestCuboid) ... FAIL
======================================================================
FAIL: test_volume (__main__.TestCuboid)
----------------------------------------------------------------------
Traceback (most recent call last):
  File "<ipython-input-28-46ad33b909ee>", line 14, in test_volume
    self.assertAlmostEqual(cuboid_volume(0),1)
AssertionError: 0 != 1 within 7 places (1 difference)
----------------------------------------------------------------------
Ran 2 tests in 0.003s
FAILED (failures=1)
<unittest.main.TestProgram at 0x1de027b5448>संचालित द्वारा

सारांश

ऊपर दिए गए आउटपुट से निम्न निष्कर्ष निकाले जा सकते हैं:

• Verbosity स्तर 0 केवल यह दिखाता है कि कितने टेस्ट चलाए गए, यानी 2 टेस्ट, और उन्हें चलाने में कितना समय लगा,
• Verbosity स्तर 1 में दो डॉट्स .. जुड़ते हैं, जो दर्शाते हैं कि दो टेस्ट निष्पादित हुए,
• Verbosity स्तर 2 में चलाए गए विस्तृत मेथड नाम और उनकी स्थिति OK या FAIL दिखाई जाती है।

उपलब्ध unittest Assert मेथड

Python के यूनिट टेस्ट मॉड्यूल में कई assert मेथड हैं, जिन्हें आप अपनी टेस्टिंग ज़रूरतों के लिए उपयोग में ला सकते हैं।

आम तौर पर उपयोग किए जाने वाले assert मेथड

स्रोत: unittest प्रलेखन

 प्रोडक्शन जांच

निम्न मेथड्स का उपयोग करके, आप अपवाद, चेतावनियों और लॉग संदेशों का उत्पादन जांच सकते हैं।

स्रोत: unittest प्रलेखन

 कार्य-विशिष्ट मेथड

स्रोत: unittest प्रलेखन

assert मेथड्स के बारे में विस्तार से जानने के लिए, Python के आधिकारिक प्रलेखन देखें।

आप Pydoc मॉड्यूल की मदद से भी इनके बारे में सीख सकते हैं, जो Python के help फ़ंक्शन जैसा है। नीचे दिखाया गया है कि आप assertCountEqual मेथड के प्रलेखन को पढ़ने के लिए Pydoc मॉड्यूल का उपयोग कैसे कर सकते हैं।

!python -m pydoc unittest.TestCase.assertCountEqualसंचालित द्वारा

आउटपुट:

Help on function assertCountEqual in unittest.TestCase:
unittest.TestCase.assertCountEqual = assertCountEqual(self, first, second, msg=None)
    An unordered sequence comparison asserting that the same elements,
    regardless of order.  If the same element occurs more than once,
    it verifies that the elements occur the same number of times.
        self.assertEqual(Counter(list(first)),
                         Counter(list(second)))
     Example:
        - [0, 1, 1] and [1, 0, 1] compare equal.
        - [0, 0, 1] and [0, 1] compare unequal.संचालित द्वारा

निष्कर्ष

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

यदि आप Python में अभी शुरुआत कर रहे हैं और अधिक सीखना चाहते हैं, तो हमारा Introduction to Data Science in Python कोर्स लें।