Go 中的接口驱动测试：轻松实现依赖 mock-Golang-PHP中文网

Go 中的接口驱动测试：轻松实现依赖 mock

go 语言没有内置的 mocking 框架，但通过面向接口的设计和组合，可以简洁、安全、零依赖地实现高效单元测试——核心在于将外部依赖抽象为接口，并在测试中注入可控的模拟实现。

go 语言没有内置的 mocking 框架，但通过面向接口的设计和组合，可以简洁、安全、零依赖地实现高效单元测试——核心在于将外部依赖抽象为接口，并在测试中注入可控的模拟实现。

在 Go 中，“mocking” 并非依赖代码生成或运行时反射，而是一种设计即测试友好的实践：你不是“绕过”依赖，而是提前约定行为契约。关键在于两点：依赖抽象（用接口）和依赖注入（通过字段或参数传入）。

✅ 正确姿势：用接口解耦，用结构体组合注入

以问题中的 SMTP 发送为例：

// 定义抽象接口 —— 只暴露你真正需要的行为
type Mailer interface {
    Send(from, to string, msg []byte) error
}

// 业务逻辑结构体显式持有接口（而非具体 smtp.Client）
type Processor struct {
    Mailer Mailer // 注意：这里不嵌入，而是显式命名字段，更清晰、更易维护
}

func (p *Processor) ProcessOrder(order Order) error {
    // ... 处理订单逻辑
    email := buildEmail(order)
    return p.Mailer.Send("no-reply@example.com", order.Email, email)
}

测试时，只需实现该接口的轻量模拟体：

type mockMailer struct {
    sent     int
    lastFrom string
    lastTo   string
    err      error // 可控失败场景
}

func (m *mockMailer) Send(from, to string, msg []byte) error {
    m.sent++
    m.lastFrom = from
    m.lastTo = to
    return m.err
}

// 测试函数
func TestProcessor_ProcessOrder(t *testing.T) {
    mock := &mockMailer{err: nil}
    p := &Processor{Mailer: mock}

    err := p.ProcessOrder(Order{Email: "user@test.com"})
    if err != nil {
        t.Fatal(err)
    }

    if mock.sent != 1 {
        t.Error("expected 1 email sent")
    }
    if mock.lastTo != "user@test.com" {
        t.Error("email not sent to expected recipient")
    }
}

? 同理处理 HTTP API + ioutil.ReadAll（已弃用，推荐 `io.ReadAll`）

对于调用外部 API 的场景，不要直接使用 http.DefaultClient.Get()，而是抽象出一个 HTTPClient 接口：

type HTTPClient interface {
    Do(*http.Request) (*http.Response, error)
}

type APIClient struct {
    Client HTTPClient
}

func (c *APIClient) FetchData(ctx context.Context, url string) ([]byte, error) {
    req, _ := http.NewRequestWithContext(ctx, "GET", url, nil)
    resp, err := c.Client.Do(req)
    if err != nil {
        return nil, err
    }
    defer resp.Body.Close()

    return io.ReadAll(resp.Body) // 注意：Go 1.16+ 推荐用 io.ReadAll，非 ioutil
}

测试时可注入 &http.Client{Transport: &mockRoundTripper{...}}，或更简单地——直接实现 HTTPClient：

type mockHTTPClient struct {
    Response *http.Response
    Err      error
}

func (m *mockHTTPClient) Do(req *http.Request) (*http.Response, error) {
    if m.Err != nil {
        return nil, m.Err
    }
    return m.Response, nil
}

// 构造带预设 body 的响应
body := io.NopCloser(strings.NewReader(`{"status":"ok"}`))
mockResp := &http.Response{
    StatusCode: 200,
    Body:       body,
    Header:     make(http.Header),
}

client := &APIClient{
    Client: &mockHTTPClient{Response: mockResp},
}
data, err := client.FetchData(context.Background(), "https://api.example.com")
if err != nil {
    t.Fatal(err)
}
if string(data) != `{"status":"ok"}` {
    t.Error("unexpected response body")
}

⚠️ 注意事项与最佳实践

避免过度抽象：只为真正需要替换/控制的依赖定义接口（如 Mailer, HTTPClient），不要为 time.Now 或 rand.Intn 等标准库函数盲目封装——除非你明确需要可控时间/随机性。
接口粒度宜小：一个接口只包含 2–4 个相关方法（如 Reader, Writer, Closer），符合接口隔离原则。
不推荐第三方 mock 工具（如 gomock、mockgen）：它们增加构建复杂度、生成冗余代码、且常破坏接口即契约的 Go 哲学；手写 mock 通常仅需 5–10 行，更直观、更易调试。
测试可读性 > 行数节省：mockMailer 不必复用全项目，每个测试包内按需定义专属 mock 类型，语义清晰（如 brokenMailer, delayedMailer）。