उत्परिवर्तन परीक्षण: परीक्षण परीक्षण

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

उत्परिवर्तन परीक्षण

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

संक्रामक फ्रेमवर्क

आज PHP में, सबसे लोकप्रिय उत्परिवर्तन परीक्षण ढांचा संक्रमण है । यह PHPUnit और PHPSpec का समर्थन करता है, और इसके लिए काम करने के लिए PHP 7.1+ और Xdebug या phpdbg की आवश्यकता होती है।

पहला लॉन्च और कॉन्फ़िगरेशन

पहली शुरुआत में, हम फ्रेमवर्क के इंटरैक्टिव कॉन्फ़िगरेशन को देखते हैं, जो सेटिंग्स के साथ एक विशेष फ़ाइल बनाता है - संक्रमण। json.dist। यह कुछ इस तरह दिखता है:

{ "timeout": 10, "source": { "directories": [ "src" }, "logs": { "text": "infection.log", "perMutator": "per-mutator.md" }, "mutators": { "@default": true } 

Timeout - एक विकल्प जिसका मूल्य एक परीक्षण की अधिकतम अवधि के बराबर होना चाहिए। source हम उन निर्देशिकाओं को निर्दिष्ट करते हैं जिनसे हम कोड को म्यूट करेंगे, आप अपवाद सेट कर सकते हैं। logs में एक text विकल्प होता है, जिसे हम केवल गलत परीक्षणों पर आँकड़े एकत्र करने के लिए निर्धारित करते हैं, जो हमारे लिए सबसे दिलचस्प है। perMutator विकल्प आपको इस्तेमाल किए गए perMutator को बचाने की अनुमति देता है। प्रलेखन में इसके बारे में और पढ़ें।

उदाहरण

 final class Calculator { public function add(int $a, int $b): int { return $a + $b; } } 

मान लीजिए कि हमारे पास उपरोक्त वर्ग है। आइए PHPUnit में एक परीक्षण लिखें:

 final class CalculatorTest extends TestCase { /** * @var Calculator */ private $calculator; public function setUp(): void { $this->calculator = new Calculator(); } /** * @dataProvider additionProvider */ public function testAdd(int $a, int $b, int $expected): void { $this->assertEquals($expected, $this->calculator->add($a, $b)); } public function additionProvider(): array { return [ [0, 0, 0], [6, 4, 10], [-1, -2, -3], [-2, 2, 0] ]; } } 

बेशक, यह परीक्षण add() पद्धति को लागू करने से पहले लिखा जाना चाहिए। जब निष्पादित हो ./vendor/bin/phpunit हमें मिलता है:

 PHPUnit 8.2.2 by Sebastian Bergmann and contributors. .... 4 / 4 (100%) Time: 39 ms, Memory: 4.00 MB OK (4 tests, 4 assertions) 

अब चलाएं ./vendor/bin/infection :

 You are running Infection with Xdebug enabled. ____ ____ __ _ / _/___ / __/__ _____/ /_(_)___ ____ / // __ \/ /_/ _ \/ ___/ __/ / __ \/ __ \ _/ // / / / __/ __/ /__/ /_/ / /_/ / / / / /___/_/ /_/_/ \___/\___/\__/_/\____/_/ /_/ Running initial test suite... PHPUnit version: 8.2.2 9 [============================] 1 sec Generate mutants... Processing source code files: 1/1Creating mutated files and processes: 0/2 Creating mutated files and processes: 2/2 .: killed, M: escaped, S: uncovered, E: fatal error, T: timed out .. (2 / 2) 2 mutations were generated: 2 mutants were killed 0 mutants were not covered by tests 0 covered mutants were not detected 0 errors were encountered 0 time outs were encountered Metrics: Mutation Score Indicator (MSI): 100% Mutation Code Coverage: 100% Covered Code MSI: 100% Please note that some mutants will inevitably be harmless (ie false positives). Time: 1s. Memory: 10.00MB 

संक्रमण के अनुसार, हमारे परीक्षण सटीक हैं। Per-mutator.md फ़ाइल में , हम देख सकते हैं कि क्या म्यूटेशन का उपयोग किया गया था:

 # Effects per Mutator | Mutator | Mutations | Killed | Escaped | Errors | Timed Out | MSI | Covered MSI | | ------- | --------- | ------ | ------- |------- | --------- | --- | ----------- | | Plus | 1 | 1 | 0 | 0 | 0 | 100| 100| | PublicVisibility | 1 | 1 | 0 | 0 | 0 | 100| 100| 

म्यूटेटर प्लस प्लस से माइनस तक साइन का एक सरल परिवर्तन है, जो परीक्षणों को तोड़ना चाहिए। और PublicVisibility उत्परिवर्ती इस पद्धति के एक्सेस संशोधक को बदल देता है, जिसे परीक्षणों को भी तोड़ना चाहिए, और इस मामले में यह काम करता है।

अब एक और अधिक जटिल विधि जोड़ते हैं।

 /** * @param int[] $numbers */ public function findGreaterThan(array $numbers, int $threshold): array { return \array_values(\array_filter($numbers, static function (int $number) use ($threshold) { return $number > $threshold; })); } /** * @dataProvider findGreaterThanProvider */ public function testFindGreaterThan(array $numbers, int $threshold, array $expected): void { $this->assertEquals($expected, $this->calculator->findGreaterThan($numbers, $threshold)); } public function findGreaterThanProvider(): array { return [ [[1, 2, 3], -1, [1, 2, 3]], [[-2, -3, -4], 0, []] ]; } 

निष्पादन के बाद, हम निम्नलिखित परिणाम देखेंगे:

 You are running Infection with Xdebug enabled. ____ ____ __ _ / _/___ / __/__ _____/ /_(_)___ ____ / // __ \/ /_/ _ \/ ___/ __/ / __ \/ __ \ _/ // / / / __/ __/ /__/ /_/ / /_/ / / / / /___/_/ /_/_/ \___/\___/\__/_/\____/_/ /_/ Running initial test suite... PHPUnit version: 8.2.2 11 [============================] < 1 sec Generate mutants... Processing source code files: 1/1Creating mutated files and processes: 0/7 Creating mutated files and processes: 7/7 .: killed, M: escaped, S: uncovered, E: fatal error, T: timed out ..M..M. (7 / 7) 7 mutations were generated: 5 mutants were killed 0 mutants were not covered by tests 2 covered mutants were not detected 0 errors were encountered 0 time outs were encountered Metrics: Mutation Score Indicator (MSI): 71% Mutation Code Coverage: 100% Covered Code MSI: 71% Please note that some mutants will inevitably be harmless (ie false positives). Time: 1s. Memory: 10.00MB 

हमारे परीक्षण ठीक नहीं हैं। सबसे पहले, infection.log फ़ाइल की जाँच करें:

 Escaped mutants: ================ 1) /home/sarven/projects/infection-playground/infection-playground/src/Calculator.php:19 [M] UnwrapArrayValues --- Original +++ New @@ @@ */ public function findGreaterThan(array $numbers, int $threshold) : array { - return \array_values(\array_filter($numbers, static function (int $number) use($threshold) { + return \array_filter($numbers, static function (int $number) use($threshold) { return $number > $threshold; - })); + }); } 2) /home/sarven/projects/infection-playground/infection-playground/src/Calculator.php:20 [M] GreaterThan --- Original +++ New @@ @@ public function findGreaterThan(array $numbers, int $threshold) : array { return \array_values(\array_filter($numbers, static function (int $number) use($threshold) { - return $number > $threshold; + return $number >= $threshold; })); } Timed Out mutants: ================== Not Covered mutants: ==================== 

पहली अनसुलझी समस्या array_values फ़ंक्शन का उपयोग है। इसका उपयोग कुंजियों को रीसेट करने के लिए किया जाता है, क्योंकि array_filter मानों को पिछली सरणी से कुंजियों के साथ लौटाता है। इसके अलावा, हमारे परीक्षणों में ऐसा कोई मामला नहीं है जब array_values का उपयोग करना आवश्यक हो, क्योंकि अन्यथा एक ही मान के साथ एक सरणी लेकिन विभिन्न कुंजियों को वापस कर दिया जाता है।

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

 public function findGreaterThanProvider(): array { return [ [[1, 2, 3], -1, [1, 2, 3]], [[-2, -3, -4], 0, []], [[4, 5, 6], 4, [5, 6]] ]; } 

और अब संक्रमण सब कुछ से खुश है:

 You are running Infection with Xdebug enabled. ____ ____ __ _ / _/___ / __/__ _____/ /_(_)___ ____ / // __ \/ /_/ _ \/ ___/ __/ / __ \/ __ \ _/ // / / / __/ __/ /__/ /_/ / /_/ / / / / /___/_/ /_/_/ \___/\___/\__/_/\____/_/ /_/ Running initial test suite... PHPUnit version: 8.2.2 12 [============================] < 1 sec Generate mutants... Processing source code files: 1/1Creating mutated files and processes: 0/7 Creating mutated files and processes: 7/7 .: killed, M: escaped, S: uncovered, E: fatal error, T: timed out ....... (7 / 7) 7 mutations were generated: 7 mutants were killed 0 mutants were not covered by tests 0 covered mutants were not detected 0 errors were encountered 0 time outs were encountered Metrics: Mutation Score Indicator (MSI): 100% Mutation Code Coverage: 100% Covered Code MSI: 100% Please note that some mutants will inevitably be harmless (ie false positives). Time: 1s. Memory: 10.00MB 

Calculator वर्ग में एक subtract विधि जोड़ें, लेकिन PHPUnit में एक अलग परीक्षण के बिना:

 public function subtract(int $a, int $b): int { return $a - $b; } 

और इन्फेक्शन चलने के बाद हम देखते हैं:

 You are running Infection with Xdebug enabled. ____ ____ __ _ / _/___ / __/__ _____/ /_(_)___ ____ / // __ \/ /_/ _ \/ ___/ __/ / __ \/ __ \ _/ // / / / __/ __/ /__/ /_/ / /_/ / / / / /___/_/ /_/_/ \___/\___/\__/_/\____/_/ /_/ Running initial test suite... PHPUnit version: 8.2.2 11 [============================] < 1 sec Generate mutants... Processing source code files: 1/1Creating mutated files and processes: 0/9 Creating mutated files and processes: 9/9 .: killed, M: escaped, S: uncovered, E: fatal error, T: timed out .......SS (9 / 9) 9 mutations were generated: 7 mutants were killed 2 mutants were not covered by tests 0 covered mutants were not detected 0 errors were encountered 0 time outs were encountered Metrics: Mutation Score Indicator (MSI): 77% Mutation Code Coverage: 77% Covered Code MSI: 100% Please note that some mutants will inevitably be harmless (ie false positives). Time: 1s. Memory: 10.00MB 

इस बार, टूल ने दो खुला म्यूटेशन लौटा दिए।

 Escaped mutants: ================ Timed Out mutants: ================== Not Covered mutants: ==================== 1) /home/sarven/projects/infection-playground/infection-playground/src/Calculator.php:24 [M] PublicVisibility --- Original +++ New @@ @@ return $number > $threshold; })); } - public function subtract(int $a, int $b) : int + protected function subtract(int $a, int $b) : int { return $a - $b; } 2) /home/sarven/projects/infection-playground/infection-playground/src/Calculator.php:26 [M] Minus --- Original +++ New @@ @@ public function subtract(int $a, int $b) : int { - return $a - $b; + return $a + $b; } 

मैट्रिक्स

प्रत्येक निष्पादन के बाद, उपकरण तीन मैट्रिक्स लौटाता है:

 Metrics: Mutation Score Indicator (MSI): 47% Mutation Code Coverage: 67% Covered Code MSI: 70% 

Mutation Score Indicator - परीक्षणों द्वारा पता चला म्यूटेशन का प्रतिशत।

मीट्रिक की गणना इस प्रकार की जाती है:

 TotalDefeatedMutants = KilledCount + TimedOutCount + ErrorCount; MSI = (TotalDefeatedMutants / TotalMutantsCount) * 100; 

Mutation Code Coverage - उत्परिवर्तन द्वारा कवर कोड का अनुपात।

मीट्रिक की गणना इस प्रकार की जाती है:

 TotalCoveredByTestsMutants = TotalMutantsCount - NotCoveredByTestsCount; CoveredRate = (TotalCoveredByTestsMutants / TotalMutantsCount) * 100; 

Covered Code Mutation Score Indicator - परीक्षणों द्वारा कवर किए गए कोड के लिए परीक्षणों की प्रभावशीलता को निर्धारित करता है।

मीट्रिक की गणना इस प्रकार की जाती है:

 TotalCoveredByTestsMutants = TotalMutantsCount - NotCoveredByTestsCount; TotalDefeatedMutants = KilledCount + TimedOutCount + ErrorCount; CoveredCodeMSI = (TotalDefeatedMutants / TotalCoveredByTestsMutants) * 100; 

अधिक जटिल परियोजनाओं में उपयोग करें

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

 ./vendor/bin/infection --filter=Calculator.php 

झूठी सकारात्मकता

कुछ उत्परिवर्तन कोड प्रदर्शन को प्रभावित नहीं करते हैं, और संक्रमण 100% से कम एमएसआई देता है। लेकिन हम हमेशा इसके साथ कुछ नहीं कर सकते हैं, इसलिए हमें ऐसी स्थितियों के साथ आना होगा। ऐसा ही कुछ इस उदाहरण में दिखाया गया है:

 public function calcNumber(int $a): int { return $a / $this->getRatio(); } private function getRatio(): int { return 1; } 

बेशक, यहाँ getRatio पद्धति का getRatio नहीं है, एक सामान्य परियोजना में, संभवतः इसके बजाय किसी प्रकार की गणना होगी। लेकिन परिणाम 1 हो सकता है। संक्रमण रिटर्न:

 Escaped mutants: ================ 1) /home/sarven/projects/infection-playground/infection-playground/src/Calculator.php:26 [M] Division --- Original +++ New @@ @@ public function calcNumber(int $a) : int { - return $a / $this->getRatio(); + return $a * $this->getRatio(); } private function getRatio() : int 

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

बड़ी परियोजनाओं के लिए अनुकूलन

बड़ी परियोजनाओं के मामले में, संक्रमण बहुत समय ले सकता है। यदि आप केवल संशोधित फ़ाइलों को संसाधित करते हैं तो आप CI के दौरान निष्पादन को अनुकूलित कर सकते हैं। अधिक जानकारी के लिए, दस्तावेज़ देखें: https://infection.imtqy.com/guide/how-to.html

इसके अलावा, आप समानांतर में संशोधित कोड पर परीक्षण चला सकते हैं। हालांकि, यह केवल तभी संभव है जब सभी परीक्षण स्वतंत्र हों। अर्थात्, ऐसे परीक्षण अच्छे होने चाहिए। इस विकल्प को सक्षम करने के लिए –threads उपयोग करें:

 ./vendor/bin/infection --threads=4 

यह कैसे काम करता है?

Infection ढांचे में AST (Abstract Syntax Tree) का उपयोग किया जाता है, जो एक सार डेटा संरचना के रूप में कोड का प्रतिनिधित्व करता है। इसके लिए, PHP ( php-parser ) के रचनाकारों में से एक द्वारा लिखे गए पार्सर का उपयोग किया जाता है।

उपकरण के सरलीकृत संचालन को निम्नानुसार दर्शाया जा सकता है:

1. कोड आधारित एएसटी पीढ़ी।
   
2. उपयुक्त उत्परिवर्तन (पूर्ण सूची यहां है ) का उपयोग।
   
3. एएसटी आधारित संशोधित कोड बनाएँ।
   
4. परिवर्तित कोड के संबंध में परीक्षण चलाएं।
   

उदाहरण के लिए, आप माइनस प्रतिस्थापन म्यूटेटर प्लस की जांच कर सकते हैं:

 <?php declare(strict_types=1); namespace Infection\Mutator\Arithmetic; use Infection\Mutator\Util\Mutator; use PhpParser\Node; use PhpParser\Node\Expr\Array_; /** * @internal */ final class Plus extends Mutator { /** * Replaces "+" with "-" * @param Node&Node\Expr\BinaryOp\Plus $node * @return Node\Expr\BinaryOp\Minus */ public function mutate(Node $node) { return new Node\Expr\BinaryOp\Minus($node->left, $node->right, $node->getAttributes()); } protected function mutatesNode(Node $node): bool { if (!($node instanceof Node\Expr\BinaryOp\Plus)) { return false; } if ($node->left instanceof Array_ || $node->right instanceof Array_) { return false; } return true; } } 

mutate() विधि एक नया तत्व बनाती है, जिसे एक प्लस द्वारा बदल दिया जाता है। Node वर्ग php-parser पैकेज से लिया गया है; इसका उपयोग एएसटी परिचालनों के लिए और PHP कोड को संशोधित करने के लिए किया जाता है। हालाँकि, यह परिवर्तन कहीं भी लागू नहीं किया जा सकता है, इसलिए mutatesNode() विधि में अतिरिक्त शर्तें हैं। यदि प्लस के बाईं ओर या माइनस के दाईं ओर एक सरणी है, तो परिवर्तन अस्वीकार्य है। इस कोड के कारण इस स्थिति का उपयोग किया जाता है:

 $tab = [0] + [1]; is correct, but the following one isn't correct. $tab = [0] - [1]; 

परिणाम

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