12 — Interfaces

// ─── Define interfaces for external dependencies to enable mocking ───

// internal/store/store.go
type UserStore interface {
    GetUser(ctx context.Context, id int64) (*User, error)
    SaveUser(ctx context.Context, u *User) error
}

// internal/store/postgres.go (production implementation)
type PostgresStore struct {
    db *sql.DB
}
func (s *PostgresStore) GetUser(ctx context.Context, id int64) (*User, error) {
    // real DB query
    return &User{}, nil
}
func (s *PostgresStore) SaveUser(ctx context.Context, u *User) error {
    // real DB insert
    return nil
}

// internal/service/user_service.go (uses the interface, not the concrete type)
type UserService struct {
    store UserStore  // accepts any UserStore — PostgresStore in prod, MockStore in tests
}

func (s *UserService) GetProfile(ctx context.Context, id int64) (*User, error) {
    return s.store.GetUser(ctx, id)  // testable with a mock
}

// internal/service/user_service_test.go
type MockUserStore struct {
    users map[int64]*User
}
func (m *MockUserStore) GetUser(ctx context.Context, id int64) (*User, error) {
    if u, ok := m.users[id]; ok {
        return u, nil
    }
    return nil, errors.New("not found")
}
func (m *MockUserStore) SaveUser(ctx context.Context, u *User) error {
    m.users[u.ID] = u
    return nil
}

func TestGetProfile(t *testing.T) {
    svc := &UserService{store: &MockUserStore{users: map[int64]*User{1: {ID: 1, Name: "Alice"}}}}
    u, err := svc.GetProfile(context.Background(), 1)
    if err != nil { t.Fatal(err) }
    if u.Name != "Alice" { t.Errorf("expected Alice, got %s", u.Name) }
}

💡 Tips & Tricks

• Idiom: define interfaces where they're USED (consumer-side), not where types are defined — a function that needs io.Reader should declare it locally, not require types to implement a "Readable" interface in their package. Small, consumer-defined interfaces keep code decoupled.
• Idiom: keep interfaces small (1-3 methods) — "the bigger the interface, the weaker the abstraction." io.Reader (one method) is satisfied by hundreds of types; a 20-method interface is satisfied by one. Compose small interfaces.
• Idiom: accept interfaces, return concrete types — functions take interface parameters (flexible, mockable) but return concrete types (clear, inspectable). Returning an interface forces callers into type assertions.
• Idiom: var _ I = T{} as a compile-time assertion — catches breakage when a method is removed from T or added to I, at compile time. Common in library code.
• Debug: the nil-interface trap — var s Speaker = (*Dog)(nil); s == nil is false. To return a nil interface, return nil directly, not a nil pointer of a concrete type. This is the #1 interface bug.
• Idiom: use interfaces for external dependencies (database, HTTP client, email sender) to enable testing with mocks — define the minimal interface the consumer needs, not the full API of the dependency.

⚠️ Edge Cases & Gotchas

• The nil interface trap: var s Speaker = (*Dog)(nil); s == nil is false — the interface has a type (*Dog), so it's non-nil. Calling a method panics. Return nil directly for a nil interface.
• Interfaces satisfied by method set: a value type satisfies only value-receiver methods; a pointer type satisfies all methods. var s Speaker = T{} fails if Speaker requires a pointer-receiver method — use &T{}.
• Interface comparison: interfaces are comparable with == if their dynamic types are comparable. Comparing interfaces holding slices/maps/functions panics at runtime.
• any loses type safety: you must type-assert to use the value. Prefer specific interfaces; reserve any for genuine "any value" cases (fmt, json).
• Interface values are immutable: the interface holds a (type, value) pair; you can reassign the interface variable, but can't mutate the held value through the interface (unless the method mutates via a pointer).
• Embedding an interface in a struct: type S struct { io.Reader } — S has a Reader field (an interface); S satisfies io.Reader via promotion. Useful for decorating/delegating.
• Nil pointer receiver method call: var p *Dog; p.Speak() — if Speak has a value receiver, Go can't dereference p (nil) → panic. If Speak has a pointer receiver, it CAN be called on nil *Dog (the method can check p == nil).
• Interface boxing causes escape: var i any = x moves x to the heap. In hot paths, avoid passing values through any — use concrete types to keep them on the stack.

🧠 Quick Quiz

type MyErr struct{}
func (m *MyErr) Error() string { return "my error" }

func doSomething(fail bool) error {
    if fail {
        var err *MyErr = nil
        return err
    }
    return nil
}

func main() {
    err := doSomething(true)
    fmt.Println(err == nil)
}