How to Mock Struct Method Calls in Go without Interfaces?

Mocking Struct Method Calls in Go

In Go, mocking method calls of a struct without introducing interfaces can be achieved through a technique known as the "double" pattern. Here's how to implement it:

1. Create a Performer Interface:

Define an interface that encapsulates the method you want to mock.

type Performer interface {
    perform()
}

2. Implement the Interface with Mocks and Real Implementation:

Create two structs, one for the real implementation (A) and another for the mock (AMock) that both implement the Performer interface.

type A struct{}

func (a *A) perform() {
    fmt.Println("real method")
}

type AMock struct{}

func (a *AMock) perform() {
    fmt.Println("mocked method")
}

3. Use Dependency Injection:

In your invoke() function, use dependency injection to pass the Performer interface, rather than directly accessing a global variable.

func invoke(p Performer) {
    p.perform()
}

4. Inject Mocks in Tests:

In your test cases, inject the AMock instance into the invoke() function. This will allow you to simulate the behavior of the mocked method.

// Create a mock performer
m := &AMock{}

// Inject the mock into invoke
invoke(m)

5. Verify Mock Calls (Optional):

If you're using a mocking library like testify/mock, you can further verify that the mocked method was called with the expected arguments and frequency.

// Assert that the mocked method was called
mock.AssertCalled(t, "perform", "argument1", "argument2")

By utilizing the double pattern, you can effectively mock the method calls of a struct in Go, providing the flexibility and isolation needed for thorough testing.

The above is the detailed content of How to Mock Struct Method Calls in Go without Interfaces?. For more information, please follow other related articles on the PHP Chinese website!