AssertCalled 总是因 testify 库而失败

Question

我正在使用 testify 来测试我的代码，我想检查是否调用了一个函数。

我正在做以下事情：

type Foo struct {
    mock.Mock
}

func (m Foo) Bar() {

}

func TestFoo(t *testing.T) {
    m := Foo{}
    m.Bar()
    m.AssertCalled(t, "Bar")
}

我得到的错误：

Error:      Should be true
Messages:   The "Bar" method should have been called with 0 argument(s), but was not.

mock.go:419: []

我调用函数 "Bar" 并立即询问它是否被调用但它 returns 错误。我究竟做错了什么？测试一个函数是否被 testify 调用的正确方法是什么？

Answer 1

查看 documentation of testify 我认为您必须显式调用 func (*Mock) Called 来告诉模拟对象已调用一个方法。

func (m *Foo) Bar() {
    m.Called()
}

作证测试有some examples。

Answer 2

我试过这个并且有效：

type Foo struct {                                                                                                                                                    
    mock.Mock                                                                                                                                                          
}                                                                                                                                                                    

func (m *Foo) Bar() {                                                                                                                                                
    m.Called()                                                                                                                                                         
}                                                                                                                                                                    

func TestFoo(t *testing.T) {                                                                                                                                         
    m := &Foo{}                                                                                                                                                        
    m.On("Bar").Return(nil)                                                                                                                                            

    m.Bar()                                                                                                                                                            
    m.AssertCalled(t, "Bar")                                                                                                                                           
}

正如 Chris Drew 所述，您必须在 Bar 方法的声明中使用接收器指针。

此外，您必须将新结构实例化为指针并将该方法模拟为 return 一个值。

Answer 3

确保它是指针接收器而不是值接收器。

这将始终有 零调用

type Foo struct {
    mock.Mock
}

func (m Foo) Bar() 
    m.Called()
}

这将有 N 次调用

type Foo struct {
    mock.Mock
}

func (m *Foo) Bar() 
    m.Called()
}

Answer 4

当您 want/need 使用值接收器时，作为一个额外的解决方案，虽然不是那么干净，但将 Mock 指定为指针字段对我有用。

type Foo struct {
    m *mock.Mock
}

func (f Foo) Bar() {
    f.m.Called()
}

func TestFoo(t *testing.T) {
    f := Foo{m: &mock.Mock{}}
    f.Bar()
    f.m.AssertCalled(t, "Bar")
}

AssertCalled 总是因 testify 库而失败

AssertCalled always fails with testify library

go

testify