Mocking a struct's method call in go tests - go

Question

I am looking to mock a method of a struct in tests to improve code coverage.
There are a few posts regarding this, none of them are working for me. I might have gotten this completely wrong.
main/file1.go
type application struct {
Name string
}
func (app *application) find() error {
// perform function logic
return nil
}
func main() {
app := &application{
Name: "Main Application",
}
err := app.find()
if err != nil {
fmt.Printf("Error in find call: %s\n", err)
}
}
I need to be able to mock test for find() and return an error (I would not want to generate a test case that could result in an error as this is not under my control and I am not sure how to generate one by passing acceptable params).
I tried to follow the second answer from this post and the compiler is not liking it.
main/file1_test.go
func Test_application_find(t *testing.T) {
tests := []struct {
name string
app *application
wantErr string
}{
{
name: "generate error",
app: &application{
Name: "Mock Application",
},
wantErr: true,
},
}
for _, tt := range tests {
mockCaller := tt.app.find // this works fine
tt.app.find = func() error { // this assignment errors out
return fmt.Errorf("Mock Error Message")
}
defer func() {
tt.app.find = mockCaller // this assignment errors out
}()
t.Run(tt.name, func(t *testing.T) {
if err := tt.app.find(); (err != nil) && (err.Error() != "Mock Error Message") {
t.Errorf("error = %s, wantErr %s", err.Error(), tt.wantErr)
}
}
}
}
What am I doing wrong here? Please suggest.

Answer 1

There are several ways to mock a method. They all have situations they are good for.
Composition
For the tests you create a new struct on top of the original.
struct testApp struct{
application
}
Now teststruct behaves almost the same way as app, but you can overwrite the find function:
func (app *testApp) find() error {
return errors.New("some error")
}
In the test you initialize the testApp with a proper app given to it:
app := testApp{
application: &application{
Name: "Mock Application",
}
}
Now you can write your tests on the app variable.
Note that this will not work for all use cases since composition is not inheritance. Calling a function on the original application will not call the new find function in testApp.
Interface
You can also mock the entire application struct / the parts you need for your tests. This mostly makes sense if you want to test another struct with a dependency on application.
The struct to be tested should not use application directly but an interface of the functionality it needs. (This might mean refactoring your code to do so.)
Then create a mock with the mocked find function and pass the mock to the struct to be tested:
type app interface{
find() error
}
type mockApp struct{
Name string
}
(s *mockApp) find() error {
return errors.New("some error")
}
Struct Field
You could also make the find function a struct field. Then you can overwrite it for test purposes. That however has the downside of having to change the code.
type application struct {
Name string
find func() error
}
Write a creator to be able to still initialize the struct in a reasonable fashion:
func newApplication() *application {
return &application{
Name: "Main Application",
find: func() error {
// perform function logic
return nil
}
}
}
Now you can overwrite the find method (actually it is a field now) in your tests:
app := newApplication()
app.find = func() error {
return errors.New("some error")
}