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

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

कुछ शोध और कुछ अलग-अलग समाधानों के संयोजन के बाद जो मुझे ऑनलाइन मिले, मैं साझा करना चाहता हूं कि मैं कक्षाओं का नकल करने में कैसे कामयाब रहा।

समाधान

यहां उस कक्षा का एक उदाहरण दिया गया है जिसका मैंने उपहास करने का प्रयास किया था:

class ClassA:
    def __init__(self):
        self.class_b = ClassB()
        self.class_c = ClassC()
        self.count = 0

हम परीक्षणों के दौरान इस वर्ग के प्रत्येक क्षेत्र के लिए एक मान निर्धारित करना चाहते हैं। यह मान कोई नहीं या क्लास मॉक हो सकता है, लेकिन हम क्लास बी और क्लास सी की शुरुआत नहीं चाहते हैं।

हमारे मामले में, आइए तय करें कि self.class_b और self.class_c नकली होने चाहिए:

@pytest.fixture
def mock_class_b():
    class_b = Mock(spec=ClassB)
    return class_b

@pytest.fixture
def mock_class_c():
    class_c = Mock(spec=ClassC)
    return class_c

तो इस वर्ग के लिए एक स्थिरता जो हमारे लक्ष्य को पूरा करती है वह इस तरह दिखती है:

@pytest.fixture
def class_a_mock(mock_class_b, mock_class_c):
    with patch.object(target=ClassA, attribute="__init__", return_value=None) as mock_init:
        class_a = ClassA()
        class_a.class_b = mock_class_b
        class_a.class_c = mock_class_c
        class_b.count = 0
        return class_a

महत्वपूर्ण हिस्सा यह है कि patch.object फ़ंक्शन का उपयोग कैसे करें, जो Python में Unittest.mock मॉड्यूल से है। इसका उपयोग परीक्षण में किसी दिए गए ऑब्जेक्ट की विशेषता को मॉक या किसी अन्य मान से अस्थायी रूप से बदलने के लिए किया जाता है।

तर्क

1. लक्ष्य=क्लासए: ऑब्जेक्ट (आमतौर पर एक क्लास) जिसकी विशेषता हम पैच करना चाहते हैं।
2. विशेषता = "__init__": उस विशेषता का नाम जिसे हम पैच करना चाहते हैं।
3. return_value=None: __init__ विधि को ऐसे फ़ंक्शन से बदलना जो कुछ नहीं करता

इस तरह से हम अपने फिक्सचर में नकली वेरिएबल बना सकते हैं।
patch.object

परीक्षण युक्तियाँ

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

कक्षा ए को और अधिक परीक्षण योग्य बनाने के लिए इसे संशोधित करने के कुछ उदाहरण यहां दिए गए हैं:

विकल्प 1: क्लास बी और क्लास सी के उदाहरणों को पैरामीटर के रूप में पास करें।
इस तरह, जब हम फिक्स्चर लिखते हैं, तो हम उदाहरणों के बजाय मॉक पास कर सकते हैं।

class ClassA:
    def __init__(self, class_b_instance, class_c_instance):
        self.class_b = class_b_instance
        self.class_c = class_c_instance
        self.count = 0

विकल्प 2: एक बूलियन वैरिएबल बनाएं जो परीक्षण मोड को इंगित करता है।
इस तरह से हम यह तय कर सकते हैं कि कक्षा ए के आरंभ होने पर उसके किन क्षेत्रों को मूल्य मिलेगा या नहीं मिलेगा।

class ClassA:
    def __init__(self, test_mode=False):
        if not test_mode:
            self.class_b = ClassB()
            self.class_c = ClassC()
        self.count = 0

विकल्प 3: कक्षा की शुरुआत एक अलग तरीके से करें।
यह दृष्टिकोण हमें परीक्षण मॉड्यूल में set_class_variables को कॉल करने से बचने का विकल्प देता है।

class ClassA:
    def __init__(self):
        self.class_b = None
        self.class_c = None
        self.count = None

    def set_class_variables(self):
        self.class_b = ClassB()
        self.class_c = ClassC()
        self.count = 0

उम्मीद है ये मदद करेगा! :)