परीक्षण के लिए कोड और कोड के लिए टेस्ट

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

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

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

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

अधूरा कार्यक्रम

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

package main import ( "encoding/json" "fmt" "io/ioutil" "net/http" "net/url" ) const token = "token here" func main() { //     var requestURL = fmt.Sprintf( "https://api.vk.com/method/%s?&access_token=%s&v=5.95", "users.get", token, ) //   resp, err := http.PostForm(requestURL, nil) //   if err != nil { fmt.Println(err) return } //       defer resp.Body.Close() //     body, err := ioutil.ReadAll(resp.Body) //   if err != nil { fmt.Println(err) return } //      var result struct { Response []struct { ID int `json:"id"` FirstName string `json:"first_name"` LastName string `json:"last_name"` } `json:"response"` } //        err = json.Unmarshal(body, &result) //   if err != nil { fmt.Println(err) return } // ,    if len(result.Response) < 1 { fmt.Println("No values in response array") return } //    fmt.Printf( "Your id: %d\nYour full name: %s %s\n", result.Response[0].ID, result.Response[0].FirstName, result.Response[0].LastName, ) } 

हमारे क्षेत्र में पेशेवरों के रूप में, हमने तय किया कि हमारे आवेदन के लिए परीक्षण लिखना आवश्यक है। एक परीक्षण फ़ाइल बनाएं ...

 package main import ( "testing" ) func Test_Main(t *testing.T) { main() } 

यह बहुत आकर्षक नहीं लगेगा। यह चेक एक एप्लिकेशन का एक सरल लॉन्च है जिसे हम प्रभावित नहीं कर सकते हैं। हम नेटवर्क के साथ काम को बाहर नहीं कर सकते हैं, विभिन्न त्रुटियों के लिए संचालन की जांच कर सकते हैं, और यहां तक ​​कि सत्यापन के लिए टोकन की जगह विफल हो जाएगी। आइए जानने की कोशिश करते हैं कि इस कार्यक्रम को कैसे बेहतर बनाया जाए।

निर्भरता इंजेक्शन पैटर्न

पहले आपको "निर्भरता इंजेक्शन" पैटर्न को लागू करने की आवश्यकता है।

 type VKClient struct { Token string } func (client VKClient) ShowUserInfo() { var requestURL = fmt.Sprintf( "https://api.vk.com/method/%s?&access_token=%s&v=5.95", "users.get", client.Token, ) // ... } 

एक संरचना को जोड़कर, हमने आवेदन के लिए एक निर्भरता (एक्सेस कुंजी) बनाई, जिसे विभिन्न स्रोतों से स्थानांतरित किया जा सकता है, जो "वायर्ड" मूल्यों से बचा जाता है और परीक्षण को सरल करता है।

 package example import ( "testing" ) const workingToken = "workingToken" func Test_ShowUserInfo_Successful(t *testing.T) { client := VKClient{workingToken} client.ShowUserInfo() } func Test_ShowUserInfo_EmptyToken(t *testing.T) { client := VKClient{""} client.ShowUserInfo() } 

सूचना और इसके आउटपुट प्राप्त करने का पृथक्करण

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

आइए GetUserInfo() विधि बनाएं, जो उपयोगकर्ता जानकारी और एक त्रुटि (यदि ऐसा हुआ) के साथ एक संरचना लौटाएगा। चूंकि यह विधि कुछ भी आउटपुट नहीं करती है, इसलिए होने वाली त्रुटियों को आउटपुट के बिना आगे प्रेषित किया जाएगा, ताकि डेटा की आवश्यकता वाले कोड स्थिति का पता लगा सकें।

 type UserInfo struct { ID int `json:"id"` FirstName string `json:"first_name"` LastName string `json:"last_name"` } func (client VKClient) GetUserInfo() (UserInfo, error) { var requestURL = fmt.Sprintf( "https://api.vk.com/method/%s?&access_token=%s&v=5.95", "users.get", client.Token, ) resp, err := http.PostForm(requestURL, nil) if err != nil { return UserInfo{}, err } // ... var result struct { Response []UserInfo `json:"response"` } // ... return result.Response[0], nil } 

ShowUserInfo() बदलें ताकि वह GetUserInfo() का उपयोग GetUserInfo() और त्रुटियों को हैंडल करे।

 func (client VKClient) ShowUserInfo() { userInfo, err := client.GetUserInfo() if err != nil { fmt.Println(err) return } fmt.Printf( "Your id: %d\nYour full name: %s %s\n", userInfo.ID, userInfo.FirstName, userInfo.LastName, ) } 

अब, परीक्षणों में, आप सत्यापित कर सकते हैं कि सर्वर से सही उत्तर प्राप्त हुआ है, और यदि टोकन गलत है, तो एक त्रुटि वापस आ जाती है।

 func Test_GetUserInfo_Successful(t *testing.T) { client := VKClient{workingToken} userInfo, err := client.GetUserInfo() if err != nil { t.Fatal(err) } if userInfo.ID == 0 { t.Fatal("ID is empty") } if userInfo.FirstName == "" { t.Fatal("FirstName is empty") } if userInfo.LastName == "" { t.Fatal("LastName is empty") } } func Test_ShowUserInfo_EmptyToken(t *testing.T) { client := VKClient{""} _, err := client.GetUserInfo() if err == nil { t.Fatal("Expected error but found <nil>") } if err.Error() != "No values in response array" { t.Fatalf(`Expected "No values in response array", but found "%s"`, err) } } 

मौजूदा परीक्षणों को अपडेट करने के अलावा, आपको ShowUserInfo() विधि के लिए नए परीक्षण जोड़ने होंगे।

 func Test_ShowUserInfo(t *testing.T) { client := VKClient{workingToken} client.ShowUserInfo() } func Test_ShowUserInfo_WithError(t *testing.T) { client := VKClient{""} client.ShowUserInfo() } 

कस्टम विकल्प

ShowUserInfo() लिए टेस्ट जो हम शुरू से दूर करने की कोशिश करते हैं जैसा दिखता है। इस मामले में, विधि का एकमात्र बिंदु मानक आउटपुट स्ट्रीम को जानकारी आउटपुट करना है। एक तरफ, आप os.Stdout को फिर से परिभाषित करने की कोशिश कर सकते हैं और आउटपुट की जांच कर सकते हैं, यह बहुत अधिक निरर्थक समाधान की तरह दिखता है जब आप अधिक सुरुचिपूर्ण ढंग से कार्य कर सकते हैं।

fmt.Printf का उपयोग करने के बजाय, आप fmt.Printf का उपयोग कर सकते हैं, जो आपको किसी भी io.Writer आउटपुट के लिए अनुमति देता है। os.Stdout इस इंटरफ़ेस को लागू करता है, जो हमें fmt.Printf(text) को fmt.Fprintf(os.Stdout, text) से बदलने की अनुमति देता है। उसके बाद, हम os.Stdout को एक अलग फ़ील्ड में रख सकते हैं, जिसे वांछित मानों पर सेट किया जा सकता है (परीक्षणों के लिए - एक स्ट्रिंग, काम के लिए - एक मानक आउटपुट स्ट्रीम)।

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

 type vkClient struct { Token string OutputWriter io.Writer } func CreateVKClient(token string) vkClient { return vkClient{ token, os.Stdout, } } 

ShowUserInfo() फ़ंक्शन में, हम Print कॉल को Fprintf साथ Fprintf ।

 func (client vkClient) ShowUserInfo() { userInfo, err := client.GetUserInfo() if err != nil { fmt.Fprintf(client.OutputWriter, err.Error()) return } fmt.Fprintf( client.OutputWriter, "Your id: %d\nYour full name: %s %s\n", userInfo.ID, userInfo.FirstName, userInfo.LastName, ) } 

अब आपको परीक्षणों को अपडेट करने की आवश्यकता है ताकि वे कंस्ट्रक्टर का उपयोग करके ग्राहक बनाएं और जहां आवश्यक हो, एक और लेखक स्थापित करें।

 func Test_ShowUserInfo(t *testing.T) { client := CreateVKClient(workingToken) buffer := bytes.NewBufferString("") client.OutputWriter = buffer client.ShowUserInfo() result, _ := ioutil.ReadAll(buffer) matched, err := regexp.Match( `Your id: \d+\nYour full name: [^\n]+\n`, result, ) if err != nil { t.Fatal(err) } if !matched { t.Fatalf(`Expected match but failed with "%s"`, result) } } func Test_ShowUserInfo_WithError(t *testing.T) { client := CreateVKClient("") buffer := bytes.NewBufferString("") client.OutputWriter = buffer client.ShowUserInfo() result, _ := ioutil.ReadAll(buffer) if string(result) != "No values in response array" { t.Fatal("Wrong error") } } 

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

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

निर्भरता इंजेक्शन पैटर्न - 2

फिलहाल, कार्यक्रम में 86.4% का कवरेज है। 100% क्यों नहीं? हम http.PostForm() , ioutil.ReadAll() और json.Unmarshal() से त्रुटियों को नहीं भड़का सकते हैं, जिसका अर्थ है कि हम प्रत्येक " return UserInfo, err ioutil.ReadAll() , ioutil.ReadAll() " की जांच नहीं कर सकते हैं।

स्थिति पर खुद को और भी अधिक नियंत्रण देने के लिए, आपको एक इंटरफ़ेस बनाने की आवश्यकता है जिसके तहत http.Client फिट होगा, जिसका कार्यान्वयन vkClient में होगा, और नेटवर्क संचालन के लिए उपयोग किया जाएगा। हमारे लिए, इंटरफ़ेस में, केवल एक विधि PostForm - PostForm ।

 type Networker interface { PostForm(string, url.Values) (*http.Response, error) } type vkClient struct { Token string OutputWriter io.Writer Networker Networker } func CreateVKClient(token string) vkClient { return vkClient{ token, os.Stdout, &http.Client{}, } } 

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

हम नकली Networker और Reader लिए कार्यान्वयन बनाएंगे, ताकि हम प्रत्येक मामले में त्रुटियों का परीक्षण कर सकें - अनुरोध पर, जब शरीर को पढ़ने और deserialization के दौरान। यदि हम PostForm को कॉल करते समय एक त्रुटि चाहते हैं, तो हम इसे इस विधि में वापस कर देते हैं। अगर हम गलती चाहते हैं
प्रतिक्रिया बॉडी को पढ़ते समय - एक नकली Reader को वापस करना आवश्यक है, जो एक त्रुटि फेंक देगा। और अगर हमें deserialization के दौरान स्वयं को प्रकट करने के लिए त्रुटि की आवश्यकता होती है, तो हम शरीर में एक खाली स्ट्रिंग के साथ उत्तर देते हैं। यदि हम कोई त्रुटि नहीं चाहते हैं, तो हम केवल निर्दिष्ट सामग्रियों के साथ शरीर को वापस करते हैं।

 type fakeReader struct{} func (fakeReader) Read(p []byte) (n int, err error) { return 0, errors.New("Error on read") } type fakeNetworker struct { ErrorOnPostForm bool ErrorOnBodyRead bool ErrorOnUnmarchal bool RawBody string } func (fn *fakeNetworker) PostForm(string, url.Values) (*http.Response, error) { if fn.ErrorOnPostForm { return nil, fmt.Errorf("Error on PostForm") } if fn.ErrorOnBodyRead { return &http.Response{Body: ioutil.NopCloser(fakeReader{})}, nil } if fn.ErrorOnUnmarchal { fakeBody := ioutil.NopCloser(bytes.NewBufferString("")) return &http.Response{Body: fakeBody}, nil } fakeBody := ioutil.NopCloser(bytes.NewBufferString(fn.RawBody)) return &http.Response{Body: fakeBody}, nil } 

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

 func Test_GetUserInfo_ErrorOnPostForm(t *testing.T) { client := CreateVKClient(workingToken) client.Networker = &fakeNetworker{ErrorOnPostForm: true} _, err := client.GetUserInfo() if err == nil { t.Fatal("Expected error but none found") } if err.Error() != "Error on PostForm" { t.Fatalf(`Expected "Error on PostForm" but got "%s"`, err.Error()) } } func Test_GetUserInfo_ErrorOnBodyRead(t *testing.T) { client := CreateVKClient(workingToken) client.Networker = &fakeNetworker{ErrorOnBodyRead: true} _, err := client.GetUserInfo() if err == nil { t.Fatal("Expected error but none found") } if err.Error() != "Error on read" { t.Fatalf(`Expected "Error on read" but got "%s"`, err.Error()) } } func Test_GetUserInfo_ErrorOnUnmarchal(t *testing.T) { client := CreateVKClient(workingToken) client.Networker = &fakeNetworker{ErrorOnUnmarchal: true} _, err := client.GetUserInfo() if err == nil { t.Fatal("Expected error but none found") } const expectedError = "unexpected end of JSON input" if err.Error() != expectedError { t.Fatalf(`Expected "%s" but got "%s"`, expectedError, err.Error()) } } 

RawBody फ़ील्ड का उपयोग करके, RawBody नेटवर्क अनुरोधों से छुटकारा पा सकते हैं (बस हम जो VKontakte से प्राप्त करने की उम्मीद करते हैं) लौटाएं। परीक्षण के दौरान या परीक्षण की गति बढ़ाने के लिए क्वेरी की सीमाओं से बचने के लिए यह आवश्यक हो सकता है।

परिणाम

परियोजना के सभी संचालन के बाद, हमें 91 लाइनों की लंबी (परीक्षणों की io.Writer लाइनें) का पैकेज मिला, जो किसी भी io.Writer को आउटपुट का समर्थन करता है, आपको नेटवर्क के साथ काम करने के वैकल्पिक तरीकों (हमारे इंटरफेस के लिए एडेप्टर का उपयोग करके) का उपयोग करने की अनुमति देता है, जिसमें एक तरीका है आउटपुट डेटा के लिए, और उन्हें प्राप्त करने के लिए। परियोजना में 100% कवरेज है। टेस्ट पूरी तरह से हर पंक्ति और हर संभावित त्रुटि के लिए आवेदन प्रतिक्रिया की जांच करते हैं।

100% कवरेज के लिए सड़क पर प्रत्येक कदम ने आवेदन की प्रतिरूपकता, स्थिरता और विश्वसनीयता को बढ़ाया, इसलिए इस तथ्य के साथ कुछ भी गलत नहीं है कि परीक्षणों ने पैकेज की संरचना को निर्धारित किया।

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