टीडीडी का उपयोग करके एक PHP वर्ग विकसित करने का केस स्टडी

यह पोस्ट एक PHP वर्ग विकसित करने का एक प्रशिक्षण उदाहरण प्रदान करता है जो उपनाम से उपयोगकर्ता की स्थिति का चयन करने के लिए Twitter API से अनुरोध करता है। इसके अलावा, ट्विटर वर्ग एक अन्य PHP वर्ग का उपयोग करके प्राप्त डेटा को कैश करता है, जो फाइलों में डेटा की सरल कैशिंग प्रदान करता है।

पोस्ट का उद्देश्य कुछ पुस्तकों, लेखों को पढ़ने के परिणामस्वरूप प्राप्त अपने स्वयं के ज्ञान को समेकित करना है, साथ ही अनुभवी TDD चिकित्सकों से टिप्पणियां प्राप्त करने का अवसर है, जो विकास प्रक्रिया में या परीक्षणों में सकल त्रुटियों का संकेत देता है।

समस्या और आवश्यकताओं का विवरण

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

हम प्रत्येक वर्ग के लिए आवश्यकताओं का वर्णन करने के लिए आगे बढ़ते हैं, जिसके आधार पर परीक्षण संकलित किए जाएंगे।

FileCache कैशिंग क्लास:

1. वर्ग को CacheInterface इंटरफ़ेस को लागू करना चाहिए।
2. निर्देशिका को सेट करना संभव होना चाहिए जहां कैश्ड डेटा संग्रहीत किया जाएगा।
3. कैश जीवनकाल को सेट करना संभव होना चाहिए।
4. गैर-मौजूद डेटा का चयन करने की कोशिश करते समय, झूठे को लौटाया जाना चाहिए।

मैं कुछ स्पष्टीकरण दूंगा। चूंकि कई कैशिंग विकल्प हो सकते हैं, इसलिए आपको इस तरह के प्रत्येक मामले के लिए अग्रिम में एक इंटरफ़ेस घोषित करने की आवश्यकता है, इस मामले में CacheInterface। मेरी राय में अन्य आवश्यकताएं बिल्कुल स्पष्ट हैं।

ट्विटर वर्ग:

1. ऑब्जेक्ट को सही URL के साथ क्लाइंट के HTTP तरीके को कॉल करना होगा।
2. यदि ऐसी संभावना मौजूद है (यदि कोई कैशिंग ऑब्जेक्ट निर्दिष्ट किया गया है) तो ऑब्जेक्ट को अपने डेटा को कैश करना होगा।

HTTP क्लाइंट को एक तृतीय-पक्ष ऑब्जेक्ट होना चाहिए, क्योंकि यह ट्विटर वर्ग से जुड़ा नहीं होना चाहिए, इसलिए इसे केवल पारित URL पर प्राप्त डेटा को वापस करना चाहिए। चूंकि HTTP क्लाइंट बाहरी कारकों पर निर्भर है, और मुझे अभी भी नहीं पता है कि ऐसी वस्तुओं का परीक्षण कैसे किया जाता है, इसलिए परीक्षण के उपयोग के बिना इस वर्ग को आदिम विकसित किया जाएगा।

विकसित करना शुरू करें

चलिए FileCache क्लास के साथ विकास शुरू करते हैं, पहला टेस्ट लिखते हैं:

public function testFileCacheClassShouldImplementCacheInterface() { $fileCache = new FileCache(); $this->assertInstanceOf('CacheInterface', $fileCache); } 

परीक्षण काफी सरल है, और यह इंटरफ़ेस विवरण के बाद सफलतापूर्वक निष्पादित करना शुरू कर देता है:

 interface CacheInterface { /** * @abstract * @param string $id * @param mixed $data * @return bool */ public function save($id, $data); /** * @abstract * @param string $id * @return mixed */ public function load($id); } 

... और FileCache वर्ग के प्रारंभिक विवरण के बाद:

 class FileCache implements CacheInterface { public function save($id, $data){} public function load($id) {} } 

आगे के दो परीक्षणों को कार्यान्वित करने के लिए, फिक्सेशन तैयारी के तरीकों को प्रोग्राम करना आवश्यक है, अर्थात्, कैश फ़ाइलों के साथ निर्देशिका बनाना और साफ़ करना:

 class FileCacheTest extends PHPUnit_Framework_TestCase { protected $cacheDir = './cache_data'; protected function setUp() { //Create cache dir if (file_exists($this->cacheDir)) { $this->_removeCacheDir(); } mkdir($this->cacheDir); } public function tearDown() { //remove cache dir $this->_removeCacheDir(); } protected function _removeCacheDir() { $dir = opendir($this->cacheDir); if ($dir) { while ($file = readdir($dir)) { if ($file != '.' && $file != '..') { unlink($this->cacheDir . '/' . $file); } } } closedir($dir); rmdir($this->cacheDir); } } 

और परीक्षण:

 public function testSettingCacheDir() { $beforeFilesCount = count(scandir($this->cacheDir)); $fileCache = new FileCache($this->cacheDir); $fileCache->save('data_name', 'some data'); $afterFilesCount = count(scandir($this->cacheDir)); $this->assertTrue($afterFilesCount > $beforeFilesCount); } 

यह परीक्षण जाँचता है कि क्या कैश फ़ाइल वास्तव में उस निर्देशिका में दिखाई दी थी जो निर्दिष्ट की गई थी जब फ़ाइल कैश ऑब्जेक्ट बनाया गया था।

परीक्षण को सफलतापूर्वक काम करने के लिए, मैंने FileCache वर्ग में न्यूनतम परिवर्तन किए:

 class FileCache implements CacheInterface { /** * @var string */ protected $cacheDir; /** * @param string $cacheDir */ public function __construct($cacheDir = '.') { $this->cacheDir = $cacheDir; } /** * @param string $id * @param mixed $data * @return bool */ public function save($id, $data) { $filename = $this->cacheDir . '/' . $id . '.dat'; $f = fopen($filename, 'w'); fwrite($f, serialize($data)); fclose($f); return true; } } 

निम्न परीक्षण जो कैश जीवनकाल जाँच को लागू करता है:

 public function testSettingCacheLifetime() { $lifetime = 2; $cacheData = 'data'; $cacheId = 'expires'; $fileCache = new FileCache($this->cacheDir, $lifetime); $fileCache->save($cacheId, $cacheData); $this->assertEquals($cacheData, $fileCache->load($cacheId)); sleep(3); $this->assertFalse($fileCache->load($cacheId)); } 

परीक्षण उनके "क्षय" से पहले और बाद में कैश डेटा की उपस्थिति के लिए जाँच करता है। मेरी राय में इस परीक्षण का कार्यान्वयन एक बड़ी परियोजना को विकसित करने के लिए अस्वीकार्य है, क्योंकि नींद (3) ऑपरेटर 3 सेकंड के लिए परीक्षण के निष्पादन में देरी करता है। सबसे उपयुक्त विकल्प मैन्युअल रूप से एक्सेस समय को फ़ाइल में बदलना है।

क्लास कंस्ट्रक्टर को कैश लाइफटाइम असाइनमेंट जोड़ें:

 /** * @param string $cacheDir * @param int $lifetime */ public function __construct($cacheDir = '.', $lifetime = 3600) { $this->cacheDir = $cacheDir; $this->lifetime = $lifetime; } 

और लोड विधि जोड़ें:

 /** * @param string $id * @return mixed */ public function load($id) { $filename = $this->cacheDir . '/' . $id . '.dat'; if (time() - fileatime($filename) > $this->lifetime) { return false; } return unserialize(file_get_contents($filename)); } 

इस स्तर पर, पहले से ही कोड को री-कोड करना संभव है ताकि डुप्लीकेट कोड को डुप्लिकेट कोड को हटाने के लिए, अर्थात् लोड और सेव विधि में एक फ़ाइल नाम बनाया जा सके। ऐसा करने के लिए, निजी विधि _createFilename जोड़ें। कोड का यह टुकड़ा पहले ही परीक्षण किया जा चुका है, इसलिए आपको डर नहीं हो सकता कि निजी पद्धति का परीक्षण नहीं किया जाएगा (स्रोत: blog.byndyu.ru , मुझे सटीक पोस्ट याद नहीं है, लेकिन सभी लेख समान रूप से उपयोगी और दिलचस्प हैं)।

 protected function _createFilename($id) { return $this->cacheDir . '/' . $id . '.dat'; } 

अंतिम परीक्षण:

 public function testLoadShouldReturnFalseOnNonexistId() { $fileCache = new FileCache($this->cacheDir); $fileCache->save('id', 'some data'); $this->assertFalse($fileCache->load('non_exist')); } 

काम करने के लिए परीक्षण के लिए, आपको बस लोड विधि में एक कोड जोड़ना होगा:

 public function load($id) { $filename = $this->_createFilename($id); if (!file_exists($filename)) { return false; } if (time() - fileatime($filename) > $this->lifetime) { return false; } return unserialize(file_get_contents($filename)); } 

तो, FileCache वर्ग के काम के लिए सभी परीक्षण, आप ट्विटर वर्ग के कार्यान्वयन के लिए आगे बढ़ सकते हैं।

हम और विकास करते हैं

हम पहली आवश्यकता के लिए एक परीक्षण लिखकर शुरू करते हैं:

 public function testTwitterShouldCallHttpClientWithCorrectUrl() { $httpClient = $this->getMock('HttpClientInterface'); $nickname = 'test_nick'; $twitter = new Twitter($httpClient); $httpClient ->expects($this->once()) ->method('get') ->with($this->equalTo('http://api.twitter.com/1/statuses/user_timeline.json?screen_name=' . $nickname)); $twitter->getStatuses($nickname); } 

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

 public function testTwitterShouldLoadDataFromCacheIfIsPossible() { $cache = $this->getMock('CacheInterface'); $httpClient = $this->getMock('HttpClientInterface'); $nickname = 'test_nick'; $twitter = new Twitter($httpClient); $url = 'http://api.twitter.com/1/statuses/user_timeline.json?screen_name=' . $nickname; $urlMd5 = md5($url); $resultCached = array('status1', 'status2', 'status3'); $resultNotCached = array('save_to_cache'); $twitter->setCache($cache); $cache->expects($this->at(0))->method('load')->with($this->equalTo($urlMd5))->will($this->returnValue($resultCached)); $cache->expects($this->at(1))->method('load')->with($this->equalTo($urlMd5))->will($this->returnValue(false)); $httpClient->expects($this->once())->method('get')->with($this->equalTo($url))->will($this->returnValue($resultNotCached)); $cache->expects($this->once())->method('save')->with($this->equalTo($urlMd5), $this->equalTo($resultNotCached)); $this->assertEquals($resultCached, $twitter->getStatuses($nickname)); $this->assertEquals($resultNotCached, $twitter->getStatuses($nickname)); } 

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

 class Twitter { /** * @var HttpClientInterface */ protected $httpClient; /** * @var string */ protected $methodUrl = 'http://api.twitter.com/1/statuses/user_timeline.json'; /** * @var CacheInterface */ protected $cache = null; /** * @param HttpClientInterface $httpClient */ public function __construct(HttpClientInterface $httpClient) { $this->httpClient = $httpClient; } /** * @param CacheInterface $cache * @return Twitter */ public function setCache(CacheInterface $cache) { $this->cache = $cache; return $this; } /** * @param string $nickname * @return mixed */ public function getStatuses($nickname) { $url = $this->methodUrl . '?screen_name=' . $nickname; $cache = $this->cache; $cacheId = md5($url); $data = false; if ($cache !== null) { $data = $cache->load($cacheId); } if ($data === false) { $data = $this->httpClient->get($url); if ($cache !== null) { $cache->save($cacheId, $data); } } return $data; } } 

हो गया!

दोनों वर्गों को परीक्षण के माध्यम से डिज़ाइन किया गया है, वे उम्मीद के मुताबिक काम करते हैं। वास्तविक कार्य की जांच करने के लिए, मैंने एक साधारण HTTP क्लाइंट लिखा है जो file_get_contents फ़ंक्शन का परिणाम देता है, और एक साधारण php स्क्रिप्ट भी लिखी है जो काम के परिणाम प्रदर्शित करती है, लेकिन यह लेख के दायरे से परे है।
परियोजना GitHub: github.com/xstupidkidzx/tddttl पर भी पोस्ट की गई है
आपकी टिप्पणियों में, मैं इस लेख पर टिप्पणी देखना चाहूंगा। समस्यात्मक मुद्दे जो मुझे सोचते हुए मिले, और जिन्हें मैं टिप्पणियों में पढ़ना चाहूंगा:

1. एक अलग परीक्षण में कार्यक्षमता को व्यापक रूप से कैसे कवर किया जाना चाहिए? क्या एक परीक्षा में केवल एक विधि का परीक्षण करना होता है? या वह कई विधियों या एक विधि के एक टुकड़े का परीक्षण कर सकता है?
2. क्या हर पहलू का पूरी तरह से परीक्षण करना आवश्यक है (उदाहरण के लिए, किसी विधि या निर्माणकर्ता को दिए गए मापदंडों की शुद्धता)? यदि CacheInterface इंटरफ़ेस में FileCache वर्ग से संबंधित परीक्षण शामिल है, तो क्या यह कहने लायक है?

आपका ध्यान के लिए धन्यवाद!