Go में परीक्षण: यूनिट, इंटीग्रेशन, e2e आरंभ से अंत तक

परिचय: Go में परीक्षण क्यों आवश्यक है?

Go (Golang) एक आधुनिक प्रोग्रामिंग भाषा है जो विश्वसनीय और स्केलेबल सिस्टम बनाने के लिए बनाई गई है। हालांकि, सबसे सुंदर कोड भी त्रुटियों से मुक्त नहीं है। यही कारण है कि परीक्षण Go में विकास का एक अनिवार्य हिस्सा है। अंतर्निहित पैकेज testing यूनिट-टेस्ट, इंटीग्रेशन टेस्ट और यहां तक कि end-to-end (e2e) जांच लिखने के लिए शक्तिशाली टूलकिट प्रदान करता है।

इस लेख में, हम Go में परीक्षण के सभी स्तरों को कवर करेंगे: सरल यूनिट-टेस्ट से लेकर जटिल e2e-परिदृश्यों तक। आप सीखेंगे कि टेस्ट को सही तरीके से कैसे संरचित करें, मॉक का उपयोग कैसे करें, table-driven टेस्ट कैसे लिखें और वास्तविक निर्भरताओं के साथ इंटीग्रेशन टेस्टिंग कैसे सेट करें। यह सामग्री शुरुआती और अनुभवी डेवलपर्स दोनों के लिए उपयोगी होगी जो अपने ज्ञान को व्यवस्थित करना चाहते हैं।

1. Go में यूनिट-टेस्टिंग: मूलभूत आधार

यूनिट-टेस्ट बाहरी निर्भरताओं से अलग करके अलग-अलग फ़ंक्शन या विधियों के काम की जांच करते हैं। Go में इसके लिए मानक पैकेज testing का उपयोग किया जाता है। मुख्य नियम: टेस्ट फ़ाइलों का नाम *_test.go होना चाहिए, और टेस्ट फ़ंक्शन Test से शुरू होने चाहिए।

1.1. सरल यूनिट-टेस्ट

दो संख्याओं को जोड़ने वाले फ़ंक्शन पर विचार करें:

// math.go\npackage math\n\nfunc Add(a, b int) int {\n    return a + b\n}

इसके लिए टेस्ट:

// math_test.go\npackage math\n\nimport "testing"\n\nfunc TestAdd(t *testing.T) {\n    result := Add(2, 3)\n    expected := 5\n    if result != expected {\n        t.Errorf("Add(2, 3) = %d; want %d", result, expected)\n    }\n}

टेस्ट चलाना: go test ./... या विस्तृत आउटपुट के लिए go test -v।

1.2. Table-driven टेस्ट (सारणीबद्ध टेस्ट)

Go समुदाय कई मामलों की जांच के लिए table-driven दृष्टिकोण का सक्रिय रूप से उपयोग करता है:

func TestAddTableDriven(t *testing.T) {\n    tests := []struct {\n        name string\n        a, b int\n        want int\n    }{\n        {"positive", 2, 3, 5},\n        {"negative", -1, -2, -3},\n        {"zero", 0, 0, 0},\n    }\n    for _, tt := range tests {\n        t.Run(tt.name, func(t *testing.T) {\n            if got := Add(tt.a, tt.b); got != tt.want {\n                t.Errorf("Add() = %d, want %d", got, tt.want)\n            }\n        })\n    }\n}

यह दृष्टिकोण टेस्ट को आसानी से पढ़ने योग्य और विस्तार योग्य बनाता है।

1.3. त्रुटियों के साथ परीक्षण

त्रुटियाँ लौटाने वाले फ़ंक्शन के लिए, t.Fatal या t.Errorf का उपयोग करें:

func TestDivide(t *testing.T) {\n    _, err := Divide(10, 0)\n    if err == nil {\n        t.Fatal("expected error for division by zero")\n    }\n}

2. इंटीग्रेशन टेस्टिंग: निर्भरताओं के साथ काम करना

इंटीग्रेशन टेस्ट घटकों के बीच बातचीत की जांच करते हैं: डेटाबेस, API, फ़ाइल सिस्टम। Go में, उन्हें build-टैग या अलग पैकेज संरचना का उपयोग करके यूनिट-टेस्ट से अलग करने की प्रथा है।

2.1. Build-टैग का उपयोग

शुरुआत में टैग //go:build integration के साथ एक फ़ाइल बनाएं:

//go:build integration\n\npackage db\n\nimport (\n    "testing"\n    "database/sql"\n    _ "github.com/lib/pq"\n)\n\nfunc TestPostgresConnection(t *testing.T) {\n    dsn := "host=localhost port=5432 user=test password=test dbname=test sslmode=disable"\n    db, err := sql.Open("postgres", dsn)\n    if err != nil {\n        t.Fatalf("failed to open db: %v", err)\n    }\n    defer db.Close()\n    \n    if err := db.Ping(); err != nil {\n        t.Fatalf("failed to ping db: %v", err)\n    }\n}

केवल इंटीग्रेशन टेस्ट चलाना: go test -tags=integration ./...

2.2. मॉक और स्टब

टेस्ट को अलग करने के लिए इंटरफ़ेस और मॉक का उपयोग करें। लोकप्रिय लाइब्रेरी gomock के साथ उदाहरण:

// user.go\ntype UserRepository interface {\n    GetUser(id int) (*Us