GOLANG TESTING WITH STRETCHR/TESTIFY AND MOCKERY

Let's go through a comprehensive example that covers common features of the stretchr/testify library and mockery for mocking in Golang. This example will include testing with assertions, using the require package for strict assertions, testing HTTP handlers, and mocking dependencies using mockery.

Scenario

Imagine we have a service that fetches user information from an external API. We want to test:

• The service's functionality.
• Its integration with an external client.
• Mocking the external client.

Project Structure

/project
│
├── main.go
├── service.go
├── service_test.go
├── user_client.go
├── mocks/
│   └── UserClient.go (generated by mockery)
└── go.mod

Code Overview

1. user_client.go
   This file defines an interface for interacting with an external user API.

   package project
   
   type User struct {
       ID   int
       Name string
   }
   
   type UserClient interface {
       GetUserByID(id int) (*User, error)
   }
   

2. service.go
   This file contains a service that uses the UserClient to fetch user details.

   package project
   
   import "fmt"
   
   type UserService struct {
       client UserClient
   }
   
   func NewUserService(client UserClient) *UserService {
       return &UserService{client: client}
   }
   
   func (s *UserService) GetUserDetails(id int) (string, error) {
       user, err := s.client.GetUserByID(id)
       if err != nil {
           return "", fmt.Errorf("failed to get user: %w", err)
       }
   
       return fmt.Sprintf("User: %s (ID: %d)", user.Name, user.ID), nil
   }
   

3. Generating Mocks with mockery
   You can generate mocks for the UserClient using mockery:

   mockery --name=UserClient --output=./mocks
   

   This will generate a mock in mocks/UserClient.go.

4. service_test.go
   Now, let's write a test for the UserService using testify assertions and the mockery-generated mock.

   package project_test
   
   import (
       "errors"
       "testing"
   
       "github.com/stretchr/testify/assert"
       "github.com/stretchr/testify/require"
       "github.com/stretchr/testify/mock"
       "project"
       "project/mocks"
   )
   
   func TestUserService_GetUserDetails_Success(t *testing.T) {
       // Create a new mock client
       mockClient := new(mocks.UserClient)
   
       // Define what the mock should return when `GetUserByID` is called
       mockClient.On("GetUserByID", 1).Return(&project.User{
           ID:   1,
           Name: "John Doe",
       }, nil)
   
       // Create the UserService with the mock client
       service := project.NewUserService(mockClient)
   
       // Test the GetUserDetails method
       result, err := service.GetUserDetails(1)
   
       // Use `require` for error checks
       require.NoError(t, err)
       require.NotEmpty(t, result)
   
       // Use `assert` for value checks
       assert.Equal(t, "User: John Doe (ID: 1)", result)
   
       // Ensure that the `GetUserByID` method was called exactly once
       mockClient.AssertExpectations(t)
   }
   
   func TestUserService_GetUserDetails_Error(t *testing.T) {
       // Create a new mock client
       mockClient := new(mocks.UserClient)
   
       // Define what the mock should return when `GetUserByID` is called with an error
       mockClient.On("GetUserByID", 2).Return(nil, errors.New("user not found"))
   
       // Create the UserService with the mock client
       service := project.NewUserService(mockClient)
   
       // Test the GetUserDetails method
       result, err := service.GetUserDetails(2)
   
       // Use `require` for error checks
       require.Error(t, err)
       assert.Contains(t, err.Error(), "user not found")
   
       // Ensure that the result is empty
       assert.Empty(t, result)
   
       // Ensure that the `GetUserByID` method was called exactly once
       mockClient.AssertExpectations(t)
   }
   
   

Key Points of This Example

1. Assertions with testify:

• assert and require packages are used for different types of checks.
  • require is used for checks that should fail the test immediately if they fail (e.g., checking for nil errors).
  • assert is used for checks that can continue even if they fail (e.g., comparing values).

2. Mocking with mockery:

• mockery generates a mock of the UserClient interface.
  • In the test, the mock is configured with.On() to specify expected inputs and .Return() to specify the outputs.
  • AssertExpectations verifies that the mocked method was called with the expected inputs.

3. Testing Error Handling:

• One test checks the successful scenario, while the other tests how the service handles an error from the UserClient.

This setup covers the basic functionality of stretchr/testify for assertions and mocking with mockery, providing a structured and maintainable approach to unit testing in Golang.

If you found this helpful, let me know by leaving a 👍 or a comment!, or if you think this post could help someone, feel free to share it! Thank you very much! 😃