在Golang进行单元测试时，如何测试是否调用了goroutine？

Question

假设我们有这样一种方法：

func method(intr MyInterface) {
    go intr.exec()
} 

在单元测试方法中，我们希望断言相互作用。exec被调用过一次，而且只有一次；因此，我们可以在测试中使用另一个模拟结构来模拟它，这将为我们提供检查它是否已被调用的功能：

type mockInterface struct{
    CallCount int
}

func (m *mockInterface) exec() {
    m.CallCount += 1
}

在单元测试中：

func TestMethod(t *testing.T) {
    var mock mockInterface{}
    method(mock)
    if mock.CallCount != 1 {
        t.Errorf("Expected exec to be called only once but it ran %d times", mock.CallCount)
    }
}

现在，问题是，由于intr.exec是用go关键字调用的，我们不能确定当我们在测试中到达断言时，它是否被调用过。

向intr的参数添加通道。exec可以解决这个问题：我们可以在测试中等待从它接收任何对象，然后在从它接收对象之后，我们可以继续断言它正在被调用。在生产（非测试）代码中，此通道将完全未使用。这会起作用，但会给非测试代码增加不必要的复杂性，并可能使大型代码库变得不可理解。

在断言之前向测试中添加一个相对较小的睡眠可能会给我们一些保证，在睡眠完成之前会调用goroutine：

func TestMethod(t *testing.T) {
    var mock mockInterface{}
    method(mock)

    time.sleep(100 * time.Millisecond)

    if mock.CallCount != 1 {
        t.Errorf("Expected exec to be called only once but it ran %d times", mock.CallCount)
    }
}


问题是它会使测试变慢，并且会使测试变得不稳定，因为它们可能会在一些随机的情况下中断。

创建这样的实用程序函数：

var Go = func(function func()) {
    go function()
} 

然后像这样重写方法：

func method(intr MyInterface) {
    Go(intr.exec())
} 

在测试中，我们可以将Go更改为：

var Go = func(function func()) {
    function()
} 

所以，当我们运行测试时，intr。exec将被同步调用，我们可以确保在断言之前调用我们的mock方法<这个解决方案的唯一问题是，它凌驾于golang的基本结构之上，这是不正确的。

这些都是我能找到的解决方案，但就我所见，这些都是令人满意的。什么是最好的解决方案？




Answer 1

首先，我会使用模拟生成器，即github.com/gojuno/minimock而不是自己写模拟：

例如minimock-f。go-i MyInterface-o my_interface_mock_测试。去

然后你的测试可以看起来像这样（顺便说一句，测试存根也是用github.com/hexdigest/gounit生成的）

func Test_method(t *testing.T) {
    type args struct {
        intr MyInterface
    }
    tests := []struct {
        name string
        args func(t minimock.Tester) args
    }{
        {
            name: "check if exec is called",
            args: func(t minimock.Tester) args {
                return args{
                    intr: NewMyInterfaceMock(t).execMock.Return(),
                }
            },
        },
    }

    for _, tt := range tests {
        t.Run(tt.name, func(t *testing.T) {
            mc := minimock.NewController(t)
            defer mc.Wait(time.Second)

            tArgs := tt.args(mc)

            method(tArgs.intr)
        })
    }
}

在这次测试中

defer mc.Wait(time.Second)

等待调用所有模拟的方法。

Answer 2

这个测试不会像同步一样永远挂起。上面提出的WaitGroup解决方案。它将挂起一秒钟（在这个特定的例子中），以防没有调用mock.exec：

package main

import (
    "testing"
    "time"
)

type mockInterface struct {
    closeCh chan struct{}
}

func (m *mockInterface) exec() {
    close(closeCh)
}

func TestMethod(t *testing.T) {
    mock := mockInterface{
        closeCh: make(chan struct{}),
    }

    method(mock)

    select {
    case <-closeCh:
    case <-time.After(time.Second):
        t.Fatalf("expected call to mock.exec method")
    }
}

这基本上就是mc。在我上面的回答中等待（时间。秒）。

Answer 3

在mock中使用sync. WaitGroup

您可以扩展mockInterface以允许它等待其他goroutine完成

type mockInterface struct{
    wg sync.WaitGroup // create a wait group, this will allow you to block later
    CallCount int
}

func (m *mockInterface) exec() {
    m.wg.Done() // record the fact that you've got a call to exec
    m.CallCount += 1
}

func (m *mockInterface) currentCount() int {
    m.wg.Wait() // wait for all the call to happen. This will block until wg.Done() is called.
    return m.CallCount
}

在测试中，您可以执行以下操作：

mock := &mockInterface{}
mock.wg.Add(1) // set up the fact that you want it to block until Done is called once.

method(mock)

if mock.currentCount() != 1 {  // this line with block
    // trimmed
}