Designing for Testability — Find the Bug¶

type Clock interface{ Now() time.Time }

type Subscription struct {
    ExpiresAt time.Time
}

func (s Subscription) IsActive(clock Clock) bool {
    today := startOfDay(clock.Now())
    expiry := startOfDay(s.ExpiresAt)
    return !expiry.Before(today)
}

// startOfDay truncates in the value's own location — local midnight, not UTC epoch.
func startOfDay(t time.Time) time.Time {
    y, m, d := t.Date()
    return time.Date(y, m, d, 0, 0, 0, 0, t.Location())
}

type fixedClock struct{ t time.Time }
func (f fixedClock) Now() time.Time { return f.t }

func TestIsActive_LocalMidnightBoundary(t *testing.T) {
    tashkent, _ := time.LoadLocation("Asia/Tashkent")
    now := time.Date(2026, 6, 10, 23, 59, 59, 0, tashkent)
    sub := Subscription{ExpiresAt: time.Date(2026, 6, 10, 0, 0, 0, 0, tashkent)}
    if !sub.IsActive(fixedClock{now}) {
        t.Fatal("subscription expiring today must be active at 23:59 local")
    }
}

import "sync/atomic"

type IDGenerator struct {
    last atomic.Int64
}

func (g *IDGenerator) Next() int64 {
    return g.last.Add(1)
}

func TestNext_NoDuplicatesUnderConcurrency(t *testing.T) {
    g := &IDGenerator{}
    const n = 10000
    seen := make([]int64, n)
    var wg sync.WaitGroup
    for i := 0; i < n; i++ {
        wg.Add(1)
        go func(i int) { defer wg.Done(); seen[i] = g.Next() }(i)
    }
    wg.Wait()

    unique := map[int64]bool{}
    for _, id := range seen {
        if unique[id] {
            t.Fatalf("duplicate id %d", id)
        }
        unique[id] = true
    }
}

type OverdueRepo interface {
    OverdueEmails() ([]string, error)   // returns only valid, non-null emails
}

type Sender interface {
    Send(to, body string) error
}

type Notifier struct {
    repo   OverdueRepo
    sender Sender
}

func (n *Notifier) NotifyOverdue() (int, error) {
    emails, err := n.repo.OverdueEmails()
    if err != nil {
        return 0, err
    }
    sent := 0
    for _, email := range emails {
        if email == "" {
            continue   // defensive; repo should already exclude these
        }
        if err := n.sender.Send(email, "Your invoice is overdue"); err != nil {
            return sent, fmt.Errorf("send to %s: %w", email, err)
        }
        sent++
    }
    return sent, nil
}

type fakeRepo struct{ emails []string }
func (f fakeRepo) OverdueEmails() ([]string, error) { return f.emails, nil }

type fakeSender struct{ sent []string }
func (f *fakeSender) Send(to, body string) error { f.sent = append(f.sent, to); return nil }

func TestNotifyOverdue_SkipsEmptyEmails(t *testing.T) {
    sender := &fakeSender{}
    n := &Notifier{repo: fakeRepo{[]string{"a@x.com", "", "b@x.com"}}, sender: sender}
    sent, _ := n.NotifyOverdue()
    if sent != 2 || len(sender.sent) != 2 {
        t.Fatalf("empty email must not be sent or counted: sent=%d, calls=%v", sent, sender.sent)
    }
}

type Product struct {
    SKU   string
    Price float64
    Qty   int
}

// pure core: no I/O, exhaustive error handling, trivially testable
func inventoryValue(products []Product) float64 {
    total := 0.0
    for _, p := range products {
        total += p.Price * float64(p.Qty)
    }
    return total
}

func parseRow(rec []string) (Product, error) {
    if len(rec) < 4 {
        return Product{}, fmt.Errorf("row has %d columns, need 4", len(rec))
    }
    price, err := strconv.ParseFloat(rec[2], 64)
    if err != nil {
        return Product{}, fmt.Errorf("bad price %q: %w", rec[2], err)
    }
    qty, err := strconv.Atoi(rec[3])
    if err != nil {
        return Product{}, fmt.Errorf("bad qty %q: %w", rec[3], err)
    }
    return Product{SKU: rec[1], Price: price, Qty: qty}, nil
}

// humble shell: only wiring — open, decode, delegate
func ImportProducts(path string) (float64, error) {
    f, err := os.Open(path)
    if err != nil {
        return 0, err
    }
    defer f.Close()
    records, err := csv.NewReader(f).ReadAll()
    if err != nil {
        return 0, err
    }
    products := make([]Product, 0, len(records))
    for i, rec := range records[1:] {
        p, err := parseRow(rec)
        if err != nil {
            return 0, fmt.Errorf("row %d: %w", i+2, err)
        }
        products = append(products, p)
    }
    return inventoryValue(products), nil
}

func TestParseRow_MalformedPriceIsError(t *testing.T) {
    _, err := parseRow([]string{"Widget", "W1", "$9.99", "3"})
    if err == nil {
        t.Fatal("malformed price must be an error, not a silent zero")
    }
}

func TestParseRow_ShortRowIsError(t *testing.T) {
    _, err := parseRow([]string{"Widget", "W1"})
    if err == nil {
        t.Fatal("short row must be an error, not a panic")
    }
}

func TestInventoryValue(t *testing.T) {
    got := inventoryValue([]Product{{Price: 9.99, Qty: 3}, {Price: 2.00, Qty: 5}})
    if got != 39.97 {
        t.Fatalf("got %v", got)
    }
}