如何通过Mock同结构体的另一个方法来单元测试结构体方法？

下面提供几种无需迁移方法即可Mock结构体内部方法的实用方案：

方案1：嵌入结构体重写目标方法 #

利用Go的结构体嵌入特性，创建测试用的Mock结构体，嵌入原Domain并重写需要Mock的B方法。原结构体的其他方法会被继承，测试时使用Mock结构体实例调用A方法即可。

示例代码：

// 原结构体及方法
type Domain struct{}

func (d *Domain) A() {
    d.B()
}

func (d *Domain) B() {
    // 原业务逻辑
    d.C()
    d.D()
}

func (d *Domain) C() { /* ... */ }
func (d *Domain) D() { /* ... */ }

// 测试用Mock结构体
type MockDomain struct {
    Domain // 嵌入原结构体，继承所有方法
    BCalled bool // 用于验证B是否被调用
}

// 重写B方法
func (m *MockDomain) B() {
    m.BCalled = true // Mock逻辑，比如记录调用状态
}

// 测试函数
func TestDomain_A(t *testing.T) {
    mock := &MockDomain{}
    mock.A() // 调用A，此时会触发Mock的B方法
    
    if !mock.BCalled {
        t.Error("B方法未被调用")
    }
}

优点：无需修改原结构体代码，实现简单；原结构体的其他方法可正常复用。

方案2：将目标方法抽象为结构体字段 #

如果允许对原结构体做微小改动，可以把B方法的逻辑抽象为一个函数字段，默认绑定原B方法的逻辑，测试时替换为Mock函数。

示例代码：

// 修改后的原结构体
type Domain struct {
    bFunc func() // 存储B方法的逻辑
}

// 初始化方法，设置默认的bFunc
func NewDomain() *Domain {
    d := &Domain{}
    d.bFunc = d.defaultB
    return d
}

// 原B方法的逻辑封装为defaultB
func (d *Domain) defaultB() {
    d.C()
    d.D()
}

// 原A方法改为调用bFunc
func (d *Domain) A() {
    d.bFunc()
}

// 保留原B方法对外接口（如果需要）
func (d *Domain) B() {
    d.bFunc()
}

func (d *Domain) C() { /* ... */ }
func (d *Domain) D() { /* ... */ }

// 测试函数
func TestDomain_A(t *testing.T) {
    d := NewDomain()
    called := false
    // 替换bFunc为Mock逻辑
    d.bFunc = func() {
        called = true
    }
    
    d.A()
    
    if !called {
        t.Error("B方法逻辑未被执行")
    }
}

优点：对外部调用者无影响，Mock逻辑灵活；适合需要自定义Mock行为的场景。

方案3：使用接口隔离（最小化修改） #

定义一个仅包含B方法的小接口，调整A方法的实现使其依赖该接口（而非直接调用结构体自身的B）。原结构体自然实现该接口，测试时使用Mock实现替代。

示例代码：

// 定义仅包含B方法的接口
type BInterface interface {
    B()
}

// 原结构体不变，自动实现BInterface
type Domain struct{}

// 修改A方法，使其接收BInterface参数（或作为结构体字段）
func (d *Domain) A(b BInterface) {
    b.B()
}

func (d *Domain) B() {
    d.C()
    d.D()
}

func (d *Domain) C() { /* ... */ }
func (d *Domain) D() { /* ... */ }

// Mock实现BInterface
type MockB struct {
    Called bool
}

func (m *MockB) B() {
    m.Called = true
}

// 测试函数
func TestDomain_A(t *testing.T) {
    d := &Domain{}
    mock := &MockB{}
    d.A(mock)
    
    if !mock.Called {
        t.Error("B方法未被调用")
    }
}

优点：符合依赖倒置原则，代码耦合度更低；如果后续需要扩展B的逻辑，灵活性更强。

内容的提问来源于stack exchange，提问作者Kaushal28