गो यूनिट टेस्टिंग: संरचना और सर्वोत्तम प्रथाएँ

package calculator

import "testing"
// अनेक्स्पोर्टेड फ़ंक्शन्स और चरांकों तक पहुंच सकते हैं

package calculator_test

import (
    "testing"
    "myproject/calculator"
)
// केवल एक्स्पोर्टेड फ़ंक्शन्स तक पहुंच सकते हैं (पब्लिक APIs के लिए अनुशंसित)

package calculator

import "testing"

// टेस्ट फ़ंक्शन "Test" से शुरू होना चाहिए
func TestAdd(t *testing.T) {
    result := Add(2, 3)
    expected := 5

    if result != expected {
        t.Errorf("Add(2, 3) = %d; want %d", result, expected)
    }
}

func TestCalculate(t *testing.T) {
    tests := []struct {
        name     string
        a, b     int
        op       string
        expected int
        wantErr  bool
    }{
        {"जोड़", 2, 3, "+", 5, false},
        {"घटाना", 5, 3, "-", 2, false},
        {"गुणा", 4, 3, "*", 12, false},
        {"भाग", 10, 2, "/", 5, false},
        {"शून्य से भाग", 10, 0, "/", 0, true},
    }

    for _, tt := range tests {
        t.Run(tt.name, func(t *testing.T) {
            result, err := Calculate(tt.a, tt.b, tt.op)

            if (err != nil) != tt.wantErr {
                t.Errorf("Calculate() error = %v, wantErr %v", err, tt.wantErr)
                return
            }

            if result != tt.expected {
                t.Errorf("Calculate(%d, %d, %q) = %d; want %d",
                    tt.a, tt.b, tt.op, result, tt.expected)
            }
        })
    }
}

# वर्तमान डायरेक्टरी में टेस्ट चलाएं
go test

# वर्बोज़ आउटपुट के साथ टेस्ट चलाएं
go test -v

# सभी सबडायरेक्टरी में टेस्ट चलाएं
go test ./...

# विशिष्ट टेस्ट चलाएं
go test -run TestAdd

# पैटर्न मैचिंग टेस्ट चलाएं
go test -run TestCalculate/जोड़

# समांतर में टेस्ट चलाएं (डिफ़ॉल्ट GOMAXPROCS है)
go test -parallel 4

# टाइमआउट के साथ टेस्ट चलाएं
go test -timeout 30s

# कवरेज के साथ टेस्ट चलाएं
go test -cover

# कवरेज प्रोफ़ाइल जनरेट करें
go test -coverprofile=coverage.out

# ब्राउज़र में कवरेज देखें
go tool cover -html=coverage.out

# फ़ंक्शन द्वारा कवरेज दिखाएं
go tool cover -func=coverage.out

# कवरेज मोड सेट करें (set, count, atomic)
go test -covermode=count -coverprofile=coverage.out

func assertEqual(t *testing.T, got, want int) {
    t.Helper() // यह पंक्ति कोलर के रूप में रिपोर्ट की जाती है
    if got != want {
        t.Errorf("got %d, want %d", got, want)
    }
}

func TestMath(t *testing.T) {
    result := Add(2, 3)
    assertEqual(t, result, 5) // त्रुटि पंक्ति यहां इंगित करती है
}

func TestMain(m *testing.M) {
    // सेटअप कोड यहां
    setup()

    // टेस्ट चलाएं
    code := m.Run()

    // टीयरडाउन कोड यहां
    teardown()

    os.Exit(code)
}

func setupTestCase(t *testing.T) func(t *testing.T) {
    t.Log("सेटअप टेस्ट केस")
    return func(t *testing.T) {
        t.Log("टीयरडाउन टेस्ट केस")
    }
}

func TestSomething(t *testing.T) {
    teardown := setupTestCase(t)
    defer teardown(t)

    // टेस्ट कोड यहां
}

// उत्पादन कोड
type Database interface {
    GetUser(id int) (*User, error)
}

type UserService struct {
    db Database
}

func (s *UserService) GetUserName(id int) (string, error) {
    user, err := s.db.GetUser(id)
    if err != nil {
        return "", err
    }
    return user.Name, nil
}

// टेस्ट कोड
type MockDatabase struct {
    users map[int]*User
}

func (m *MockDatabase) GetUser(id int) (*User, error) {
    if user, ok := m.users[id]; ok {
        return user, nil
    }
    return nil, errors.New("उपयोगकर्ता नहीं मिला")
}

func TestGetUserName(t *testing.T) {
    mockDB := &MockDatabase{
        users: map[int]*User{
            1: {ID: 1, Name: "Alice"},
        },
    }

    service := &UserService{db: mockDB}
    name, err := service.GetUserName(1)

    if err != nil {
        t.Fatalf("अपेक्षित त्रुटि: %v", err)
    }
    if name != "Alice" {
        t.Errorf("got %s, want Alice", name)
    }
}

import (
    "github.com/stretchr/testify/assert"
    "github.com/stretchr/testify/mock"
)

func TestWithTestify(t *testing.T) {
    result := Add(2, 3)
    assert.Equal(t, 5, result, "वे बराबर होने चाहिए")
    assert.NotNil(t, result)
}

// मॉक उदाहरण
type MockDB struct {
    mock.Mock
}

func (m *MockDB) GetUser(id int) (*User, error) {
    args := m.Called(id)
    return args.Get(0).(*User), args.Error(1)
}

func BenchmarkAdd(b *testing.B) {
    for i := 0; i < b.N; i++ {
        Add(2, 3)
    }
}

// बेंचमार्क चलाएं
// go test -bench=. -benchmem

package user

import (
    "errors"
    "testing"
)

type User struct {
    ID    int
    Name  string
    Email string
}

func ValidateUser(u *User) error {
    if u.Name == "" {
        return errors.New("name cannot be empty")
    }
    if u.Email == "" {
        return errors.New("email cannot be empty")
    }
    return nil
}

// Test file: user_test.go
func TestValidateUser(t *testing.T) {
    tests := []struct {
        name    string
        user    *User
        wantErr bool
        errMsg  string
    }{
        {
            name:    "valid user",
            user:    &User{ID: 1, Name: "Alice", Email: "alice@example.com"},
            wantErr: false,
        },
        {
            name:    "empty name",
            user:    &User{ID: 1, Name: "", Email: "alice@example.com"},
            wantErr: true,
            errMsg:  "name cannot be empty",
        },
        {
            name:    "empty email",
            user:    &User{ID: 1, Name: "Alice", Email: ""},
            wantErr: true,
            errMsg:  "email cannot be empty",
        },
    }

    for _, tt := range tests {
        t.Run(tt.name, func(t *testing.T) {
            err := ValidateUser(tt.user)

            if (err != nil) != tt.wantErr {
                t.Errorf("ValidateUser() error = %v, wantErr %v", err, tt.wantErr)
                return
            }

            if err != nil && err.Error() != tt.errMsg {
                t.Errorf("ValidateUser() error message = %v, want %v", err.Error(), tt.errMsg)
            }
        })
    }
}