🧜 👩🏻‍🤝‍👨🏾 🚣🏽 PHPUnit। "मैं अपने लानत नियंत्रक का परीक्षण कैसे करूं", या संदेहियों के लिए परीक्षण 🤷🏻 ☀️ 🙏🏻

हाय, हैब्र।

हां, यह परीक्षण के विषय पर एक और पोस्ट है। ऐसा लगता है कि यहां चर्चा करना पहले से ही संभव है? सभी को इसकी आवश्यकता है - परीक्षण लिखें, जिन्हें इसकी आवश्यकता नहीं है - वे नहीं लिखते हैं, हर कोई खुश है! तथ्य यह है कि यूनिट परीक्षण के बारे में अधिकांश पोस्ट हैं ... किसी को कैसे अपमानित करना है ... मूर्खतापूर्ण उदाहरण! नहीं, सच में! आज मैं इसे ठीक करने की कोशिश करूंगा। मैं बिल्ली माँगता हूँ।

और इसलिए, परीक्षणों के विषय पर त्वरित गुगली करने से बहुत सारे लेख मिलते हैं, जिन्हें उनके बल्क में दो श्रेणियों में विभाजित किया गया है:

1) एक कॉपीराइटर की खुशी। पहले हम एक लंबा परिचय देखते हैं, फिर प्राचीन रूस में इकाई परीक्षण का इतिहास, फिर दस जीवन परीक्षण के साथ हैक करते हैं, और अंत में एक उदाहरण। इस तरह कोड परीक्षण के साथ:

<?php class Calculator { public function plus($a, $b) { return $a + $b; } }

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

2) अत्यधिक परिष्कृत उदाहरण। और चलो एक परीक्षण लिखते हैं, और इसे Gitlab CI में रटना करते हैं, और फिर हम परीक्षण को पास कर देते हैं, और हम परीक्षण में PHP संक्रमण लागू करते हैं, लेकिन हम सब कुछ हडसन से जोड़ देंगे। और इस तरह से उस शैली में। यह उपयोगी प्रतीत होता है, लेकिन ऐसा लगता है कि यह बिल्कुल नहीं है कि आप क्या देख रहे हैं। लेकिन आप बस अपने प्रोजेक्ट की स्थिरता को थोड़ा बढ़ाना चाहते हैं। और ये सभी निरंतरता - ठीक है, फिर एक बार में नहीं।

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

प्रश्न-उत्तर प्रारूप में एक छोटा शैक्षिक कार्यक्रम शुरू करने के लिए:

प्रश्न: क्या मुझे किसी प्रकार के ढांचे का उपयोग करना है? यदि मेरे पास Yii है तो क्या होगा? क्या होगा अगर कोहना? क्या होगा यदि% one_more_framework_name%?
एक: नहीं, PHPUnit एक स्वतंत्र परीक्षण ढांचा है, आप इसे स्व-निर्मित ढांचे पर विरासत कोड पर भी पेंच कर सकते हैं।

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

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

प्रश्न: मेरे पास बहुत सरल तरीके (कार्य) हैं, परीक्षण करने के लिए क्या है? वहां सब कुछ विश्वसनीय है, गलती के लिए कोई जगह नहीं है!
ए: यह समझा जाना चाहिए कि आप फ़ंक्शन के सही कार्यान्वयन (यदि आपके पास टीडीडी नहीं है) का परीक्षण नहीं करते हैं, तो आप बस कार्य की वर्तमान स्थिति को "ठीक" करते हैं। भविष्य में, जब आपको इसे बदलने की आवश्यकता होती है, तो आप यह निर्धारित कर सकते हैं कि क्या आपने परीक्षण का उपयोग करके इसके व्यवहार को तोड़ दिया है। उदाहरण: एक फ़ंक्शन है जो ईमेल को मान्य करता है। वह इसे नियमित बनाती है।

 function isValid($email) { $regex = "very_complex_regex_here"; if (is_array($email)) { $result = true; foreach ($email as $item) { if (preg_match($regex, $item) === 0) { $result = false; } } } else { $result = preg_match($regex, $emai) ==! 0; } return $result; }

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

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

प्रश्न: ठीक है, मेरे पास लार्वा पर एक वेबसाइट है। साइट एक फ़ंक्शन नहीं है, साइट कोड का एक चमकदार पहाड़ है। यहां कैसे टेस्ट करें?
A: यह बाद में चर्चा की जाएगी। संक्षेप में: हम अलग से कंट्रोलर के तरीकों का परीक्षण करते हैं, अलग से मिडलवेयर, अलग से सेवाओं आदि का।

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

 <?php class Controller { public function __construct($userService, $emailService) { $this->userService = $userService; $this->emailService = $emailService; } public function login($request) { if (empty($request->login) || empty($request->password)) { return "Auth error"; } $password = $this->userService->getPasswordFor($request->login); if (empty($password)) { return "Auth error - no password"; } if ($password !== $request->password) { return "Incorrect password"; } $this->emailService->sendEmail($request->login); return "Success"; } } // .... /* somewhere in project core */ $controller = new Controller($userService, $emailService); $controller->login($request);

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

वस्तुओं का प्रतिस्थापन, प्रतिस्थापन को मोकनेम (अंग्रेजी से। नकली वस्तु, शाब्दिक अर्थ: "ऑब्जेक्ट-पैरोडी") कहा जाता है। कोई भी इस तरह की वस्तुओं को मैन्युअल रूप से लिखने के लिए परेशान नहीं करता है, लेकिन हमारे सामने सब कुछ पहले से ही आविष्कार किया गया है, इसलिए मॉकरी बचाव के लिए एक अद्भुत पुस्तकालय है। आइए सेवाओं के लिए मोक बनाएँ।

 $userService = Mockery::mock('user_service'); $emailService = Mockery::mock('email_service');

अब $ रिक्वेस्ट ऑब्जेक्ट बनाएं। शुरू करने के लिए, हम लॉगिन और पासवर्ड फ़ील्ड की जाँच के तर्क का परीक्षण करेंगे। हम यह सुनिश्चित करना चाहते हैं कि अगर कोई नहीं है, तो हमारा तरीका इस मामले को सही ढंग से संभाल लेगा और वांछित (!) संदेश लौटा देगा।

 function testEmptyLogin() { $userService = Mockery::mock('user_service'); $emailService = Mockery::mock('email_service'); $controller = new Controller($userService, $emailService); $request = (object) []; $result = $controller->login($request); }

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

 function testEmptyLogin() { $userService = Mockery::mock('user_service'); $emailService = Mockery::mock('email_service'); $controller = new Controller($userService, $emailService); $request = (object) []; $result = $controller->login($request); // vv assertion here! vv $this->assertEquals("Auth error", $result); }

यह परीक्षण निम्नलिखित की गारंटी देता है - यदि लॉगिन तर्क उस विधि ऑब्जेक्ट पर आता है जिसमें लॉगिन या पासवर्ड फ़ील्ड नहीं है, तो विधि स्ट्रिंग "प्रामाणिक त्रुटि" लौटाएगी। यह, सामान्य तौर पर, सभी है। इतना सरल - लेकिन इतना उपयोगी, क्योंकि अब हम कुछ तोड़ने के डर के बिना लॉगिन विधि को संपादित कर सकते हैं। हमारा उद्देश्य यह सुनिश्चित कर सकता है कि अगर कुछ होता है - तो उसे ऐसी त्रुटि मिलेगी। और अगर कोई इस व्यवहार को तोड़ता है (उदाहरण के लिए, त्रुटि पाठ को बदलने का फैसला करता है), तो परीक्षण तुरंत इस पर संकेत देगा! हम संभव के रूप में कई संभावित परिदृश्यों को कवर करने के लिए शेष चेक जोड़ते हैं।

 function testEmptyPassword() { $userService = Mockery::mock('user_service'); // $userService->getPasswordFor(__any__arg__); // '' $userService->shouldReceive('getPasswordFor')->andReturn(''); $emailService = Mockery::mock('email_service'); $request = (object) [ 'login' => 'john', 'pass' => '1234' ]; $result = (new Controller($userService, $emailService))->login($request); $this->assertEquals("Auth error - no password", $result); } function testUncorrectPassword() { $userService = Mockery::mock('user_service'); // $userService->getPasswordFor(__any__arg__); // '4321' $userService->shouldReceive('getPasswordFor')->andReturn('4321'); $emailService = Mockery::mock('email_service'); $request = (object) [ 'login' => 'john', 'pass' => '1234' ]; $result = (new Controller($userService, $emailService))->login($request); $this->assertEquals("Incorrect password", $result); } function testSuccessfullLogin() { $userService = Mockery::mock('user_service'); // $userService->getPasswordFor(__any__arg__); // '1234' $userService->shouldReceive('getPasswordFor')->andReturn('1234'); $emailService = Mockery::mock('email_service'); $request = (object) [ 'login' => 'john', 'pass' => '1234' ]; $result = (new Controller($userService, $emailService))->login($request); $this->assertEquals("Success", $result); }

कंधे और नोटिस के तरीकों पर ध्यान दें? वे हमें उन स्टब्स में विधियाँ बनाने की अनुमति देते हैं जो हमें केवल वही चाहिए जो हमें चाहिए। गलत पासवर्ड त्रुटि का परीक्षण करने की आवश्यकता है? हम एक स्टब $ userService लिखते हैं जो हमेशा गलत पासवर्ड देता है। और वह यह है।

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

- सभी परीक्षण सफल रहे। या ऐसा कुछ

सात में से एक दावा विफल रहा।

"यह, निश्चित रूप से, अच्छा है, लेकिन इसमें से मेरे हाथ क्या लग सकते हैं?" आप पूछते हैं। और इसके लिए निम्नलिखित कोड की कल्पना करते हैं

 <?php function getInfo($infoApi, $userName) { $response = $infoApi->getInfo($userName); if ($response->status === "API Error") { return null; } return $response->result; } // ... somewhere in system $api = new ExternalApi(); $info = getInfo($api, 'John'); if ($info === null) { die('Api is down'); } echo $info;

हम बाहरी एपीआई के साथ काम करने का एक सरलीकृत मॉडल देखते हैं। एपीआई के साथ काम करने के लिए फ़ंक्शन कुछ वर्ग का उपयोग करता है, और त्रुटि के मामले में, अशक्त देता है। यदि, इस फ़ंक्शन का उपयोग करते समय, हम अशक्त हो जाते हैं, तो हमें "घबराहट" उठानी चाहिए (सुस्त को संदेश भेजें, या डेवलपर को ईमेल करें, या किबाना में एक त्रुटि फेंकें। हां, विकल्पों का एक गुच्छा)। सब कुछ सरल लगता है, है ना? लेकिन कल्पना कीजिए कि कुछ समय बाद एक अन्य डेवलपर ने इस फ़ंक्शन को "ठीक" करने का फैसला किया। उन्होंने फैसला किया कि वापसी करना अंतिम शताब्दी है, और उन्हें एक अपवाद फेंक देना चाहिए।

 function getInfo($infoApi, $userName): string { $response = $infoApi->getInfo($userName); if ($response->status === "API Error") { throw new ApiException($response); } return $response->result; }

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

 function testApiFail() { $api = Mockery::mock('api'); $api->shouldReceive('getInfo')->andReturn((object) [ 'status' => 'API Error' ]); $result = getInfo($api, 'name'); $this->assertNull($result); }

यह जानकारी वास्तव में पर्याप्त है। यदि आपके पास लिगेसी नूडल्स नहीं हैं, तो 20-30 मिनट के बाद आप अपना पहला टेस्ट लिख सकते हैं। और कुछ हफ़्ते बाद - इस पोस्ट के तहत टिप्पणियों में कुछ नया, ठंडा, जानने के लिए वापस लौटें, और लिखें कि कौन सा लेखक govnokoder% फ्रेमवर्क_name% के बारे में नहीं जानता है, और खराब परीक्षण लिखता है, लेकिन आपको %__% करने की आवश्यकता है। और मैं उस मामले में बहुत खुश रहूंगा। इसका मतलब यह होगा कि मेरा लक्ष्य हासिल कर लिया गया है: किसी और ने अपने लिए परीक्षण की खोज की, और हमारे क्षेत्र में व्यावसायिकता के सामान्य स्तर को थोड़ा बढ़ाया!

यथोचित आलोचना का स्वागत है।

PHPUnit। "मैं अपने लानत नियंत्रक का परीक्षण कैसे करूं", या संदेहियों के लिए परीक्षण

More articles: