अनुक्रमिक रूप से गोलांग परीक्षण कैसे चलाएं?

Question

जब मैं go test चलाने के लिए, मेरी उत्पादन:

--- FAIL: TestGETSearchSuccess (0.00s) 
     Location:  drivers_api_test.go:283 
     Error:   Not equal: 200 (expected) 
           != 204 (actual) 

--- FAIL: TestGETCOSearchSuccess (0.00s) 
     Location:  drivers_api_test.go:391 
     Error:   Not equal: 200 (expected) 
           != 204 (actual) 

लेकिन उसके बाद मैं go test फिर से चलाने के लिए, अपने सभी परीक्षण पास।

टेस्ट केवल तभी विफल होते हैं जब मैं अपना mysql डेटाबेस रीसेट करता हूं, और फिर पहली बार go test चलाता हूं।

प्रत्येक GET अनुरोध के लिए, मैं यह सुनिश्चित करने से पहले POST अनुरोध करता हूं कि डीबी में डेटा बनाया गया हो।

क्या कोई यह सुनिश्चित करने के लिए मेरी सहायता कर सकता है कि परीक्षण अनुक्रमिक रूप से चल रहे हैं? POST अनुरोध GET अनुरोध से पहले चलाए गए हैं?

Answer 1

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

go test -run W 

भी ध्यान रखें कि कुछ परीक्षण कार्यों के लिए खुद को समानांतर निष्पादन T.Parallel() विधि का उपयोग करने के लिए पात्र चिह्नित करते हैं, जाने उपकरण को पुन: व्यवस्थित होगा:

उदाहरण के लिए निम्न आदेश केवल चलेंगे परीक्षण जिसका नाम एक 'W' पत्र शामिल पहले गैर-समांतर परीक्षण चलाने के लिए परीक्षण, और फिर कुछ परिस्थितियों में समानांतर में समांतर परीक्षण चलाते हैं (-p जैसे परीक्षण झंडे द्वारा नियंत्रित)। आप इस उत्तर में इसके उदाहरण देख सकते हैं: Are tests executed in parallel in Go or one by one?

टेस्ट स्वतंत्र एक दूसरे से होना चाहिए। यदि किसी टेस्ट फ़ंक्शन की आवश्यकता होती है, जिसे किसी अन्य परीक्षण फ़ंक्शन में नहीं किया जा सकता/कार्यान्वित नहीं किया जा सकता है।

विकल्प से पहले एक परीक्षण समारोह चलाया जाता है अतिरिक्त कार्य करने के लिए:

• आप परीक्षण समारोह अपने आप में यह डाल सकता है
• आप एक पैकेज init() समारोह में रख सकता है _test.go फ़ाइल में, अपने आप। परीक्षण कार्यों के निष्पादन से पहले यह एक बार चलाएगा।
• आप TestMain() फ़ंक्शन को कार्यान्वित करना चुन सकते हैं जिसे पहले कॉल किया जाएगा और जिसमें आप परीक्षण कार्यों के निष्पादन को ट्रिगर करने के लिए M.Run() पर कॉल करने से पहले अतिरिक्त सेटअप कर सकते हैं।
• आप उपरोक्त विकल्पों को मिश्रित कर सकते हैं।

पैकेज init() में

आपके मामले में या TestMain() अगर आपके डीबी आरंभ नहीं हो जाता आप की जाँच करनी चाहिए (वहाँ परीक्षण रिकॉर्ड डाला जाता है), और यदि नहीं, परीक्षण अभिलेख सम्मिलित करें।

ध्यान दें कि गो 1.7 से शुरू होने पर, आप उप-सूचियों का उपयोग कर सकते हैं जिसमें आप उप-प्रदर्शनों के निष्पादन आदेश को परिभाषित करते हैं।विवरण के लिए ब्लॉग पोस्ट देखें: Using Subtests and Sub-benchmarks, और testing पैकेज का पैकेज दस्तावेज़।

Answer 2

here प्रस्तुत किए गए TestMain को प्राप्त करने का सबसे अच्छा तरीका है।

import (
    "testing" 
    "os" 
) 

func TestMain(m *testing.M) { 
    // Do your stuff here 
    os.Exit(m.Run()) 
} 

Answer 3

सादा गोलांग 1.7 के साथ Convey और Ginkgo जैसे तृतीय पक्ष पुस्तकालयों के अलावा, आप अनुक्रमिक रूप से परीक्षण चला सकते हैं। आप और अधिक here

func TestFoo(t *testing.T) { 
    // <setup code> 
    t.Run("A=1", func(t *testing.T) { ... }) 
    t.Run("A=2", func(t *testing.T) { ... }) 
    t.Run("B=1", func(t *testing.T) { ... }) 
    // <tear-down code> 
} 

पढ़ सकते हैं और आप उन लोगों के साथ सशर्त चला सकते हैं:

go test -run ''  # Run all tests. 
go test -run Foo  # Run top-level tests matching "Foo", such as "TestFooBar". 
go test -run Foo/A= # For top-level tests matching "Foo", run subtests matching "A=". 
go test -run /A=1 # For all top-level tests, run subtests matching "A=1". 

तो कहते हैं कि तुम एक REST API आप परीक्षण करना चाहते हैं से एक user पैकेज मिला देता है। लॉगिन हैंडलर का परीक्षण करने में सक्षम होने के लिए आपको बनाने हैंडलर का परीक्षण करने की आवश्यकता है। आम तौर पर मैं user_test.go

type UserTests struct { Test *testing.T} 
func TestRunner(t *testing.T) { 

    t.Run("A=create", func(t *testing.T) { 
     test:= UserTests{Test: t} 
     test.TestCreateRegularUser() 
     test.TestCreateConfirmedUser() 
     test.TestCreateMasterUser() 
     test.TestCreateUserTwice() 
    }) 
    t.Run("A=login", func(t *testing.T) { 
     test:= UserTests{Test: t} 
     test.TestLoginRegularUser() 
     test.TestLoginConfirmedUser() 
     test.TestLoginMasterUser() 
    }) 

} 

पर इस के लिए होता है तो मैं UserTest प्रकार है कि अभ्यस्त किसी भी _test.go फ़ाइल में go test आदेश द्वारा निष्पादित की जाने तरीकों जोड़ सकते हैं

func (t *UserTests) TestCreateRegularUser() { 
    registerRegularUser := util.TableTest{ 
     Method:  "POST", 
     Path:  "/iot/users", 
     Status:  http.StatusOK, 
     Name:  "registerRegularUser", 
     Description: "register Regular User has to return 200", 
     Body: SerializeUser(RegularUser), 
    } 
    response := util.SpinSingleTableTests(t.Test, registerRegularUser) 
    util.LogIfVerbose(color.BgCyan, "IOT/USERS/TEST", response) 
}