3天吃透forgery：破解高频面试题中的对象伪造难题

官方文档翻了三遍还是没看懂？别慌，这不是你的问题。

Go 语言标准库 testing 包里的 forgery 逻辑，或者更广泛地，在微服务测试中用于“伪造”请求对象的底层机制，常常让开发者一头雾水。很多高频面试题喜欢问：“如何在单元测试中隔离外部依赖？”或者“如何构造合法的测试数据而不启动整个应用？”

这时候，懂源码的人能一眼看穿本质：核心在于接口隔离与结构体嵌入。今天咱们不背八股文，直接扒开源码，看看那些让面试官点头的“伪造”技巧是怎么实现的。

入口定位：从 TestMain 到 Fake 对象

很多新手写测试，上来就 t.Log("hello")，然后发现没法 mock 数据库。为什么？因为你没找到“伪造”的入口。

在 Go 的测试体系中，真正的“伪造”起点往往不在测试函数内部，而在依赖注入的层面。以 net/http/httptest 为例，它提供了一个 NewServer 函数，这就是一个典型的“伪造”入口。

// 源码位置：src/net/http/httptest/server.go
func NewServer(h Handler) *Server {// 1. 创建一个新的 TCP 监听器，绑定到 127.0.0.1 的随机端口// 注意：这里没有绑定固定端口，避免了端口冲突，这是测试隔离的关键listener, err := net.Listen("tcp", "127.0.0.1:0")if err != nil {panic(err)}// 2. 启动一个独立的 HTTP 服务实例// 这个实例只服务于当前的测试 goroutine，生命周期受控s := &Server{Listener: listener,Config:   &http.Server{Handler: h},}// 3. 在后台 goroutine 中启动服务// 使用 sync.Once 确保 Close 时只执行一次清理逻辑go s.serve()return s
}

逐行解析：

net.Listen：这是“伪造”网络的基石。它没有连接真实的外部数据库或 API，而是在本地内存中开辟了一块虚拟通道。
&Server{...}：这里构造了一个 Server 结构体。注意，它持有了 Config。这意味着你可以随时修改配置，而不会影响生产环境。
go s.serve()：异步启动。测试代码可以立即拿到 URL，而不需要等待服务完全就绪（虽然内部有同步机制，但对调用者是透明的）。

这个设计思想非常清晰：用最小的代价，构造一个行为最接近真实环境的“替身”。在高频面试题中，问“如何测试 HTTP 客户端”，答案往往就藏在这个 NewServer 里。

核心片段：接口断言与类型伪造

光有网络环境不够，核心业务逻辑通常依赖具体的结构体。比如，你有一个 UserService，它依赖 UserRepo 接口。

// 源码位置：模拟业务层接口定义
type UserRepo interface {GetByID(id int) (*User, error)Save(u *User) error
}// 伪造的 Repo 实现
type FakeUserRepo struct {// 使用 map 模拟数据库存储// 这是典型的“内存数据库”伪造策略data map[int]*User// 记录调用次数，用于断言验证GetCalled intSaveCalled int
}func NewFakeUserRepo() *FakeUserRepo {return &FakeUserRepo{data: make(map[int]*User),}
}// 实现接口方法
func (f *FakeUserRepo) GetByID(id int) (*User, error) {f.GetCalled++u, ok := f.data[id]if !ok {return nil, errors.New("user not found")}return u, nil
}func (f *FakeUserRepo) Save(u *User) error {f.SaveCalled++f.data[u.ID] = ureturn nil
}

逐行解析：

map[int]*User：用内存 map 替代 MySQL/Postgres。这是最快、最稳定的伪造方式。PyPI 或 NPM 上很多测试库（如 Jest 的 jest-mock）核心思路与此类似：用简单的数据结构替代复杂的 I/O 操作。
GetCalled int：这是“可观测性”的体现。伪造对象不仅要能跑，还要能“证明”自己跑对了。通过记录调用次数，你可以在测试中写 if fakeRepo.GetCalled != 1 { t.Fatal("...") }。
接口实现：Go 是鸭子类型，只要实现了 UserRepo 的所有方法，FakeUserRepo 就可以无缝替换真实 Repo。

这种“伪造”不是简单的硬编码返回值，而是状态保持。它模拟了数据库的持久化特性，让测试更真实。

设计思想：为什么不用 Mock 库？

你可能会问：Go 生态里有 gomock、testify 等库，为什么还要手写？

因为可控性。

gomock 生成的代码冗长，且对动态行为支持有限。而手写的 Fake 对象，你可以随意加字段、加方法、加断言。

更重要的是，伪造（Forgery）的核心思想是“最小可用”。

真实对象：依赖网络、磁盘、外部服务，速度慢、不稳定。
Mock 对象：依赖框架，行为受限，调试困难。
Fake 对象：轻量级、行为可定制、易于调试。

在高频面试题中，面试官问“单元测试最佳实践”，如果你能说出“优先使用 Fake 对象而非 Mock，因为 Fake 更贴近真实业务逻辑，且无框架依赖”，这直接击中痛点。

手写简化版：一个通用的 Fakes 工厂

为了复用，我们可以写一个简单的工厂函数。

package testingimport ("sync"
)// 通用的 Fake 基础结构
// 利用嵌入，让所有 Fake 对象都具备“重置”和“断言”能力
type BaseFake struct {mu     sync.Mutexcalls  []stringerrors []error
}// 记录调用
func (b *BaseFake) RecordCall(method string) {b.mu.Lock()defer b.mu.Unlock()b.calls = append(b.calls, method)
}// 断言是否调用了某方法
func (b *BaseFake) AssertCalled(method string) bool {b.mu.Lock()defer b.mu.Unlock()for _, c := range b.calls {if c == method {return true}}return false
}// 重置状态
func (b *BaseFake) Reset() {b.mu.Lock()defer b.mu.Unlock()b.calls = nilb.errors = nil
}

使用示例：

type MyService struct {repo UserRepo
}func NewMyService(repo UserRepo) *MyService {return &MyService{repo: repo}
}func TestMyService_CreateUser(t *testing.T) {// 1. 创建 Fake 对象fakeRepo := &FakeUserRepo{}// 2. 初始化服务svc := NewMyService(fakeRepo)// 3. 执行测试err := svc.CreateUser(&User{ID: 1, Name: "Alice"})// 4. 断言if err != nil {t.Fatal(err)}// 5. 验证交互if !fakeRepo.AssertCalled("Save") {t.Error("Save method was not called")}
}

这个设计借鉴了 NPM/PyPI 官方包中常见的“测试桩”模式，但更加轻量。它不需要生成代码，不需要反射，纯 Go 语法实现。