assert_called_once() or assert_called_xyz().... equivalent?

It is important to me to be able to assert how many times a fake / mocked method is called in my tests and I'm wondering what is the best way to do this without using something like testify. In my case, the call to the mocked method is the result of some recursive call.

Lets say I have table driven tests with various animals, I want to assert that Hello is actually called for some tests but not for others. In some cases, it should be called more than once for given test (iterating over a slice).

Is it appropriate to just add a counter and make an assertion on that in my table driven test? It seems to me like maybe there is a better way to do this.

If I do add a counter to the hello method... where is it appropriate to deal with and check this. In the fake method itself or in the test etc?

<!-- begin snippet: js hide: false console: false babel: false -->

<!-- language: lang-html -->

type fakeFarmService struct {
	abc.someFarmServiceInterface
}

func (f *fakeFarmService) Hello(ctx context.Context, in *abc.FarmRequest) (*abc.FarmResponse, error) {
	if in.GetAnimal() == Monkey {
		return &abc.HelloResponse{}, nil
	}
	return nil, errors.New("an error")
}

<!-- end snippet -->

I've used the approach of counter on the struct and then asserting it inside the package level unit test multiple times in the past. Still, it's probably only until the level of package, when you would like to test such an internal assertions. I believe it's an accepted way of doing this in Go. Just be careful about properly synchronizing the access to the counter, if you decide to use a global variable or run the tests concurrently.

package main

import (
	"fmt"
	"sync"
	"testing"
)

type fakeable interface {
	Hello()
}

type fakeFarmService struct {
	mu      sync.Mutex
	counter int
}

func (f *fakeFarmService) Hello() {
	f.mu.Lock()
	f.counter++
	f.mu.Unlock()
}

func helloCaller(callee fakeable) {
	callee.Hello()
}

func TestCallingTheHello(t *testing.T) {
	fakeSvc := &fakeFarmService{}
	helloCaller(fakeSvc)
	helloCaller(fakeSvc)

	// we expect that Hello method of fakeable was called 2 times
	fakeSvc.mu.Lock()
	defer fakeSvc.mu.Unlock()
	if c := fakeSvc.counter; c != 2 {
		t.Errorf("unexpected call count, want 2, got %d", c)
	}
}

func main() {
	TestCallingTheHello(&testing.T{})
}

https://play.golang.org/p/RXKuLKIZwc (test error won't work inside the playground)

Some good material on advanced testing in Go

1. [Testing Techniques by Andrew Gerrand][1]
2. [NewStore TechTalk - Advanced Testing with Go by Mitchell Hashimoto][2]

[1]: https://www.youtube.com/watch?v=ndmB0bj7eyw "Testing Techniques by Andrew Gerrand"
[2]: https://www.youtube.com/watch?v=yszygk1cpEc "NewStore TechTalk - Advanced Testing with Go by Mitchell Hashimoto"