如何检查是否在单元测试中调用了 sync.WaitGroup.Done()

Question

Let's say I have a function if that is executed asynchronous as a go routine:

func f(wg *sync.WaitGroup){
    defer wg.Done()
    // Do sth
}

main(){
    var wg sync.WaitGroup
    wg.Add(1)
    go f(&wg)
    wg.Wait() // Wait until f is done
    // ...
}

How would I create a unit test for f that makes sure wg.Done() is called?

One option is to call wg.Done() in the test directly after the f is called. If f fails to call wg.Done() the test will panic which is not nice. Another option would be to create an interface for sync.WaitGroup but that seems a bit weird.

Answer 1

How would I create a unit test for f that makes sure wg.Done() is called?

Something like this:

func TestF(t *testing.T) {
    wg := &sync.WaitGroup{}
    wg.Add(1)

    // run the task asynchronously
    go f(wg)

    // wait for the WaitGroup to be done, or timeout
    select {
    case <-wrapWait(wg):
        // all good
    case <-time.NewTimer(500 * time.Millisecond).C:
        t.Fail()
    }
}

// helper function to allow using WaitGroup in a select
func wrapWait(wg *sync.WaitGroup) <-chan struct{} {
    out := make(chan struct{})
    go func() {
        wg.Wait()
        out <- struct{}{}
    }()
    return out
}

You don't inspect the WaitGroup directly, which you can't do anyway. Instead you assert that the function behaves as expected , given the expected input.

In this case, the expected input is the WaitGroup argument and the expected behavior is that wg.Done() gets called eventually. What does that mean, in practice? It means that if the function is successful a WaitGroup with count 1 will reach 0 and allow wg.Wait() to proceed.

The statement defer wg.Done() at the beginning of f already makes sure that the test is resilient to errors or crashes. The addition of a timeout is simply to make sure the test will complete within a reasonable time, ie that it doesn't stall your test suite for too long. Personally, I prefer using explicit timeouts, either with timers or with contexts, to avoid problems if someone forgets to set timeouts at the CI level.