Go语言如何mock结构体私有step方法以测试DoSmthLogic入口逻辑

Go本身不支持Python那种动态替换实例私有方法的能力，要实现类似的测试需求，通常有以下三种可选方案：

方案1：抽离step逻辑为接口依赖（最符合Go设计哲学） #

将step相关逻辑抽为独立接口，SomeObject依赖该接口，测试时直接替换为mock实现即可校验调用行为：

代码改造示例 #

// 定义step行为接口
type StepHandler interface {
    step1() int
    step2(int)
    step3()
}

type SomeObject struct {
    user *models.User
    handler StepHandler // 注入step实现
}

func (obj *SomeObject) DoSmthLogic(val1 int, val2 int) error {
    result := obj.handler.step1()
    obj.handler.step2(result)
    obj.handler.step3()
    return nil
}

// 生产环境的真实step实现
type RealStepHandler struct {
    user *models.User
}

func (h *RealStepHandler) step1() int {
    // 原有step1逻辑
}
func (h *RealStepHandler) step2(res int) {
    // 原有step2逻辑
}
func (h *RealStepHandler) step3() {
    // 原有step3逻辑
}

// 生产环境初始化方法，注入真实实现
func NewSomeObject(user *models.User) *SomeObject {
    return &SomeObject{
        user: user,
        handler: &RealStepHandler{user: user},
    }
}

测试用例示例 #

// 测试用mock实现
type MockStepHandler struct {
    Step1CallCnt int
    Step2CallCnt int
    Step3CallCnt int
    Step2Arg     int
}

func (m *MockStepHandler) step1() int {
    m.Step1CallCnt++
    return 123 // 测试需要的返回值
}
func (m *MockStepHandler) step2(arg int) {
    m.Step2CallCnt++
    m.Step2Arg = arg
}
func (m *MockStepHandler) step3() {
    m.Step3CallCnt++
}

func TestDoSmthLogic(t *testing.T) {
    mockH := &MockStepHandler{}
    testObj := &SomeObject{
        handler: mockH,
    }

    err := testObj.DoSmthLogic(1, 2)
    if err != nil {
        t.Fatalf("unexpected err: %v", err)
    }

    // 校验调用情况
    if mockH.Step1CallCnt != 1 {
        t.Errorf("step1 expected call 1 time, actual %d", mockH.Step1CallCnt)
    }
    if mockH.Step2CallCnt != 1 || mockH.Step2Arg != 123 {
        t.Errorf("step2 call not match expected")
    }
    if mockH.Step3CallCnt != 1 {
        t.Errorf("step3 expected call 1 time, actual %d", mockH.Step3CallCnt)
    }
}

方案2：使用函数字段（轻量化改造） #

如果不想引入额外接口，可以将step方法改为结构体的函数字段，测试时直接替换为mock函数即可：

代码改造示例 #

type SomeObject struct {
    user *models.User
    step1 func() int
    step2 func(int)
    step3 func()
}

// 真实step逻辑
func (obj *SomeObject) realStep1() int {
    // 原有step1逻辑
}
func (obj *SomeObject) realStep2(res int) {
    // 原有step2逻辑
}
func (obj *SomeObject) realStep3() {
    // 原有step3逻辑
}

// 生产环境初始化
func NewSomeObject(user *models.User) *SomeObject {
    obj := &SomeObject{user: user}
    obj.step1 = obj.realStep1
    obj.step2 = obj.realStep2
    obj.step3 = obj.realStep3
    return obj
}

func (obj *SomeObject) DoSmthLogic(val1 int, val2 int) error {
    result := obj.step1()
    obj.step2(result)
    obj.step3()
    return nil
}

测试用例示例 #

func TestDoSmthLogic(t *testing.T) {
    step1CallCnt := 0
    step2CallCnt := 0
    step3CallCnt := 0
    var step2Arg int

    testObj := &SomeObject{
        step1: func() int {
            step1CallCnt++
            return 123
        },
        step2: func(arg int) {
            step2CallCnt++
            step2Arg = arg
        },
        step3: func() {
            step3CallCnt++
        },
    }

    _ = testObj.DoSmthLogic(1, 2)

    if step1CallCnt != 1 {
        t.Error("step1 not called once")
    }
    if step2CallCnt != 1 || step2Arg != 123 {
        t.Error("step2 call not match expected")
    }
    if step3CallCnt != 1 {
        t.Error("step3 not called once")
    }
}

方案3：直接验证最终行为（无侵入改造） #

如果你已经单独覆盖了所有step方法的单测，也可以不对原有代码做任何改造，直接测试DoSmthLogic执行后的最终输出、返回值、副作用是否符合预期即可，不需要校验每个step的调用情况，这种方案的测试用例更稳定，不会和内部实现逻辑耦合。

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