Unit testing is one of the most underrated skills in Go.
The language was designed with testing in mind — simple, fast, tool-built, and clean.

In this post, you will learn:

✅ Basic Go testing
✅ Table-driven tests
✅ Setup & teardown
✅ Parallel tests & benchmarks
✅ Mocks — when & how
✅ Stubs — when & how
✅ Full production-style example (Repository + Email service)
✅ Best practices + folder structure

Let’s start 👇

🧱 What Is Unit Testing?

Unit tests validate the smallest piece of code (a function).
They give confidence when:

• Refactoring

• Releasing to production

• Fixing bugs

• Working in large codebases

In Go, testing needs no extra framework — just:

go test ./...

✨ Basic Test in Go

mathutil.go

package mathutil
func Add(a, b int) int { return a + b }

mathutil_test.go

package mathutil
import "testing"

func TestAdd(t *testing.T) {
    if Add(2, 3) != 5 {
        t.Error("expected 5")
    }
}

Run:

go test

✅ Table-Driven Testing (Go-idiomatic)

func TestAddTable(t *testing.T) {
    tests := []struct {
        name string
        a, b int
        want int
    }{
        {"positive", 2, 3, 5},
        {"with zero", 10, 0, 10},
        {"negative", -2, -3, -5},
    }

    for _, tc := range tests {
        t.Run(tc.name, func(t *testing.T) {
            if Add(tc.a, tc.b) != tc.want {
                t.Errorf("expected %d", tc.want)
            }
        })
    }
}

🔧 Setup & Teardown Example

func createTestFile() string {
    f := "/tmp/data.txt"
    os.WriteFile(f, []byte("hello"), 0644)
    return f
}

func TestFile(t *testing.T) {
    f := createTestFile()
    defer os.Remove(f)

    b, _ := os.ReadFile(f)
    if string(b) != "hello" {
        t.Fatal("file content mismatch")
    }
}

🚀 Parallel Tests & Benchmarks

Run tests in parallel:

func TestParallel(t *testing.T) {
    values := []int{1, 2, 3}
    for _, v := range values {
        v := v
        t.Run(fmt.Sprint(v), func(t *testing.T) {
            t.Parallel()
        })
    }
}

Benchmark example:

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

🧪 What Are Mocks & Stubs?

🧩 Stub Example (simple dependency)

payment.go

type Gateway interface { 
    Pay(amount float64) string 
}

func Charge(g Gateway, amt float64) string {
    return "result:" + g.Pay(amt)
}

payment_test.go

type stubGateway struct{}
func (s stubGateway) Pay(a float64) string { return "OK" }

func TestCharge(t *testing.T) {
    res := Charge(stubGateway{}, 10)
    if res != "result:OK" { t.Errorf("unexpected %s", res) }
}

🎯 Full Real-World Example: Service + Repository + Email

✅ Code Under Test

registration_service.go

package registration

import "errors"

type Repo interface { 
    Save(email string) error 
}

type Mailer interface { 
    Send(email string) error 
}

type Service struct {
    repo Repo
    mail Mailer
}

func New(r Repo, m Mailer) *Service { return &Service{r, m} }

func (s *Service) Register(email string) error {
    if email == "" {
        return errors.New("invalid email")
    }

    if err := s.repo.Save(email); err != nil {
        return err
    }
    return s.mail.Send(email)
}

✅ Test with Mocks

registration_service_test.go

package registration

import (
    "errors"
    "testing"
)

type mockRepo struct {
    saved     string
    shouldErr bool
}

func (m *mockRepo) Save(e string) error {
    if m.shouldErr { return errors.New("db error") }
    m.saved = e
    return nil
}

type mockMailer struct {
    sent string
    err  bool
}

func (m *mockMailer) Send(e string) error {
    if m.err { return errors.New("smtp error") }
    m.sent = e
    return nil
}

func TestRegisterSuccess(t *testing.T) {
    r := &mockRepo{}
    m := &mockMailer{}
    svc := New(r, m)

    if err := svc.Register("a@b.com"); err != nil {
        t.Fatal(err)
    }

    if r.saved != "a@b.com" { t.Error("not saved") }
    if m.sent != "a@b.com" { t.Error("email not sent") }
}

func TestRegisterRepoFail(t *testing.T) {
    r := &mockRepo{shouldErr: true}
    m := &mockMailer{}
    svc := New(r, m)

    if err := svc.Register("a@b.com"); err == nil {
        t.Error("expected error")
    }
}

📊 Code Coverage

go test -cover
go test -coverprofile=cover.out
go tool cover -html=cover.out

📂 Recommended Project Layout

/internal
    /mathutil
    /registration
/mocks (generated mocks)
go.mod

🧠 Best Practices

✅ Table-driven tests
✅ Test positive + negative cases + edge cases
✅ Mock external systems (DB, MQ, API)
✅ Fail fast on unexpected errors
✅ Keep test functions short
✅ Run tests in CI pipeline

🎉 Conclusion

Testing in Go is:

• Simple

• Fast

• Powerful

• Real-world friendly

When you combine table tests + mocks + coverage, you gain:

🚀 Refactoring freedom
🛡️ Safety in production
🧠 Clearer architecture

Real engineers don’t trust “it works on my machine.”
They write tests.