PHPUnit और& ने परीक्षणों का आदेश दिया

सभी प्रोग्रामर आलसी हैं। और हर कोई अतिरिक्त कोड लिखना नहीं चाहता है, लेकिन पहले से तैयार एक का उपयोग करना चाहता है। इसके अलावा, यह एक अच्छा अभ्यास है।

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

शर्त लगाना

सिस्टम का एक पहलू है जो किसी भी कार्य को कर सकता है। आश्रित क्रियाएं हैं, लेकिन स्वतंत्र क्रियाएं हैं। आश्रित कार्यों के लिए एक स्वतंत्र कार्रवाई की आवश्यकता होती है (और कभी-कभी एक से अधिक)। इसलिए, अंत में, हमें तथाकथित कार्यों की सूची प्राप्त करनी चाहिए।

चूँकि उन सभी क्रियाओं को जिन्हें परीक्षण करने की आवश्यकता होती है, आपको तदनुसार परीक्षणों की क्रमबद्ध सूची प्राप्त करनी चाहिए। PHPUnit का उपयोग एक परीक्षण ढांचे के रूप में किया गया था, क्योंकि इसकी शर्तें एक निश्चित प्रकार की कार्रवाई के लिए पर्याप्त थीं।

शर्त

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

PHPUnit परीक्षण विधियों के बीच स्पष्ट निर्भरता की घोषणा का समर्थन करता है। इस तरह की निर्भरताएं उस आदेश को परिभाषित नहीं करती हैं जिसमें परीक्षण विधियों को निष्पादित किया जाना है, लेकिन वे एक निर्माता द्वारा परीक्षण स्थिरता के एक उदाहरण की वापसी की अनुमति देते हैं और इसे निर्भर उपभोक्ताओं को दे रहे हैं।

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

Class ParentTestCase extends PHPUnit_Framework_TestCase { public function testOne() { self::assertTrue(true); } /** * @depends testOne */ public function testTwo() { self::assertTrue(true); } } 

 class ChildTestCase extends ParentTestCase { /** * @depends testTwo */ public function testThree() { self::assertTrue(true); } } 

मैं इंगित करता हूं कि प्रतिबिंब के उपयोग के कारण ऐसा होता है, क्योंकि पहले वंश वर्ग से विधियां एकत्र की जाती हैं, और फिर पूर्वज वर्ग से।

इस संबंध में, मैं PHPUnit को संशोधित करने के विचार के साथ आया हूं ताकि यह परीक्षणों के अनुक्रम का समर्थन करे और इस अनुक्रम का आधार परीक्षण के निष्पादन पर निर्भरता को इंगित करने में निहित है।

निर्णय

पहले, आइए निर्धारित करें कि हम परीक्षण निर्भरताओं के क्रम को कहां संग्रहीत करने जा रहे हैं। ऐसा करने के लिए, TestCase का वंशज बनाएं और इस आदेश को नियंत्रित करने के लिए फ़ंक्शन जोड़ें।

 class MagicTestCase extends PHPUnit_Framework_TestCase { /** * @var array */ protected $order = array(); /** * Sets the orderSet of a TestCase. * * @param array $orderSet */ public function setOrderSet(array $orderSet) { $this->order = $orderSet; } /** * Get the orderSet of a TestCase. * * @return array $order */ public function getOrderSet() { return $this->order; } } 

उसके बाद, आपको प्रत्येक परीक्षण के लिए प्रारंभिक निर्भरता को निर्दिष्ट करना होगा। ऐसा करने के लिए, वंशानुगत वर्ग में PHPUnit_Framework_TestSuite वर्ग के लिए addTestMethod विधि को फिर से परिभाषित करें। निर्भरता स्थापित करें:

 $test->setOrderSet(PHPUnit_Util_Test::getDependencies($class->getName(), $name)); 

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

  foreach($this->tests as $test) { $test->setOrderSet( array_unique($this->getRecursiveOrderSet($test, $test->getName())) ); } usort($this->tests, array("MagicUtilTest ", "compareTestOrder")); 

इसके अलावा, addTestSuite फ़ंक्शन स्वयं का एक उदाहरण ( PHPUnit_Framework_TestSuite) बनाता है, और यह आवश्यक है कि यह एक संशोधित TestSuite बनाता है, क्योंकि पहले मामले में, यह संशोधित TestSuite निर्माता का उपयोग नहीं करता है। यह सब एक पंक्ति पर निर्भर करता है, जिसे हम विधि के अंदर परिभाषित करते हैं:

 $this->addTest(new MagicTestSuite($testClass)); 

परिणामी वर्ग:

 class MagicTestSuite extends PHPUnit_Framework_TestSuite { /** * Constructs a new TestSuite: * * @param mixed $theClass * @param string $name * @throws InvalidArgumentException */ public function __construct($theClass = '', $name = '') { parent::__construct($theClass, $name); foreach($this->tests as $test) { $test->setOrderSet( array_unique($this->getRecursiveOrderSet($test, $test->getName())) ); } usort($this->tests, array("MagicUtilTest ", "compareTestOrder")); } /** * @param $object * @param $methodName * @return array */ protected function getRecursiveOrderSet($object, $methodName) { $orderSet = array(); foreach($this->tests as $test) { if ($test->getName() == $methodName && get_class($object) == get_class($test)) { $testOrderSet = $test->getOrderSet(); if (!empty($testOrderSet)) { foreach($testOrderSet as $orderMethodName) { if(!in_array($orderMethodName, $orderSet)) { $orderResult = $this->getRecursiveOrderSet($test, $orderMethodName); $orderSet = array_merge($orderSet, $orderResult); } } } $orderSet = array_merge($orderSet, $testOrderSet); } } return $orderSet; } /** * @param ReflectionClass $class * @param ReflectionMethod $method */ protected function addTestMethod(ReflectionClass $class, ReflectionMethod $method) { $name = $method->getName(); if ($this->isPublicTestMethod($method)) { $test = self::createTest($class, $name); if ($test instanceof PHPUnit_Framework_TestCase || $test instanceof PHPUnit_Framework_TestSuite_DataProvider) { $test->setDependencies( PHPUnit_Util_Test::getDependencies($class->getName(), $name) ); } $test->setOrderSet(PHPUnit_Util_Test::getDependencies($class->getName(), $name)); $this->addTest($test, PHPUnit_Util_Test::getGroups( $class->getName(), $name) ); } else if ($this->isTestMethod($method)) { $this->addTest( self::warning( sprintf( 'Test method "%s" is not public.', $name ) ) ); } /** * Adds the tests from the given class to the suite. * * @param mixed $testClass * @throws InvalidArgumentException */ public function addTestSuite($testClass) { if (is_string($testClass) && class_exists($testClass)) { $testClass = new ReflectionClass($testClass); } if (!is_object($testClass)) { throw PHPUnit_Util_InvalidArgumentHelper::factory( 1, 'class name or object' ); } if ($testClass instanceof PHPUnit_Framework_TestSuite) { $this->addTest($testClass); } else if ($testClass instanceof ReflectionClass) { $suiteMethod = FALSE; if (!$testClass->isAbstract()) { if ($testClass->hasMethod(PHPUnit_Runner_BaseTestRunner::SUITE_METHODNAME)) { $method = $testClass->getMethod( PHPUnit_Runner_BaseTestRunner::SUITE_METHODNAME ); if ($method->isStatic()) { $this->addTest( $method->invoke(NULL, $testClass->getName()) ); $suiteMethod = TRUE; } } } if (!$suiteMethod && !$testClass->isAbstract()) { $this->addTest(new MagicTestSuite($testClass)); } } else { throw new InvalidArgumentException; } } } 

अच्छी तरह से और तदनुसार, एक उपयोगिता फ़ंक्शन जोड़ें जो दो परीक्षणों की तुलना करेगा और इंगित करेगा कि उन्हें किस दिशा में सॉर्ट करना है।

 class MagicUtilTest { /** * @static * @param PHPUnit_Framework_TestCase $object1 * @param PHPUnit_Framework_TestCase $object2 * @return int */ public static function compareTestOrder(PHPUnit_Framework_TestCase $object1, PHPUnit_Framework_TestCase $object2) { if (in_array($object2->getName(), $object1->getOrderSet())) { return 1; } if (in_array($object1->getName(), $object2->getOrderSet())) { return -1; } return 0; } } 

आवेदन

परीक्षण रन फ़ाइल बनाएँ:

 require dirname(__FILE__) . DIRECTORY_SEPARATOR.' runSuite.php'; PHPUnit_Util_Filter::addFileToFilter(__FILE__, 'PHPUNIT'); require_once 'PHPUnit/TextUI/Command.php'; $tests= runSuite::suite(); PHPUnit_TextUI_TestRunner::run($tests); exit; 

हम सामान्य टेस्टसुइट क्लास बनाते हैं जो सीधे परीक्षण लॉन्च करेंगे। हम इसे अपने बनाए हुए से विरासत में लेते हैं:

 require_once 'MagicTestSuite.php'; class runSuite extends MagicTestSuite { public static function suite() { $suite = new self(); $suite->addTestSuite(“ChildTestCase”); } } 

खैर, TestCases, जिसमें परीक्षण और निर्भरता शामिल हैं:

 require_once 'MagicTestCase.php'; class ParentTestCase extends MagicTestCase { public function testOne() { self::assertTrue(true); } /** * @depends testOne */ public function testTwo() { self::assertTrue(true); } } 

 require_once 'ParentTestCase.php'; class ChildTestCase extends ParentTestCase { /** * @depends testTwo */ public function testThree() { self::assertTrue(true); } } 

प्रतिबंध

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

बेशक, परीक्षण निर्भरता के एक पेड़ का निर्माण करना संभव था ... लेकिन ईमानदार होने के लिए मुझे नहीं लगता कि किस मामले में (एक मानवीय त्रुटि के अलावा) आप परीक्षणों के लिए बंद निर्भरता का उपयोग कर सकते हैं।