douyakao5308 2018-06-27 14:33
浏览 236
已采纳

如何在Golang中进行单元测试时测试是否已调用goroutine?

suppose that we have a method like this:

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

In unit testing method, we want to assert that inter.exec has been called once and only once; so we can mock it with another mock struct in tests, which will give us functionality to check if it has been called or not:

type mockInterface struct{
    CallCount int
}

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

And in unit tests:

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)
    }
}

Now, the problem is that since intr.exec is being called with go keyword, we can't be sure that when we reach our assertion in tests, it has been called or not.

Possible Solution 1:

Adding a channel to arguments of intr.exec may solve this: we could wait on receiving any object from it in tests, and after receiving an object from it then we could continue to assert it being called. This channel will be completely unused in production (non-test) codes. This will work but it adds unnecessary complexity to non-test codes, and may make large codebases incomprehensible.

Possible Solution 2:

Adding a relatively small sleep to tests before assertion may give us some assurance that the goroutine will be called before sleep is finished:

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)
    }
}

This will leave non-test codes as they are now.
The problem is that it will make tests slower, and will make them flaky, since they may break in some random circumstances.

Possible Solution 3:

Creating a utility function like this:

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

And rewrite method like this:

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

In tests, we could change Go to this:

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

So, when we're running tests, intr.exec will be called synchronously, and we can be sure that our mock method is called before assertion.
The only problem of this solution is that it's overriding a fundamental structure of golang, which is not right thing to do.


These are solutions that I could find, but non are satisfactory as far as I can see. What is best solution?

  • 写回答

3条回答 默认 最新

  • duanqi6274 2018-06-27 14:47
    关注

    Use a sync.WaitGroup inside the mock

    You can extend mockInterface to allow it to wait for the other goroutine to finish

    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
    }
    

    In the tests you can do:

    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
    }
    
    本回答被题主选为最佳回答 , 对您是否有帮助呢?
    评论
查看更多回答(2条)

报告相同问题?

悬赏问题

  • ¥15 数据库数据成问号了,前台查询正常,数据库查询是?号
  • ¥15 算法使用了tf-idf,用手肘图确定k值确定不了,第四轮廓系数又太小才有0.006088746097507285,如何解决?(相关搜索:数据处理)
  • ¥15 彩灯控制电路,会的加我QQ1482956179
  • ¥200 相机拍直接转存到电脑上 立拍立穿无线局域网传
  • ¥15 (关键词-电路设计)
  • ¥15 如何解决MIPS计算是否溢出
  • ¥15 vue中我代理了iframe,iframe却走的是路由,没有显示该显示的网站,这个该如何处理
  • ¥15 操作系统相关算法中while();的含义
  • ¥15 CNVcaller安装后无法找到文件
  • ¥15 visual studio2022中文乱码无法解决