Go Unit Tests

Generate comprehensive Go unit tests following testify patterns and the Arrange-Act-Assert methodology.

Planning Phase

Before writing tests, identify:

Test Structure: Determine if test suite (for structs with dependencies) or individual test functions (for standalone functions) should be used
Dependencies: Identify dependencies or side effects requiring mocks or stubs
Test Cases: Define scenarios covering happy paths, edge cases, and error conditions

Naming: Number each test case clearly (e.g.,

TestFunction_ValidInput_ReturnsExpectedResult

TestFunction_EmptyInput_ReturnsError

)

Show the code without explanations during planning.

Implementation Patterns

Pattern 1: Test Suites for Structs with Dependencies

Use

suite.Suite

from testify for structs with dependencies.

Key Rules:

Create suite struct with
```
sut
```
(System Under Test) field
Implement
```
SetupTest
```
method to initialize sut and dependencies
Use constructor (typically
```
NewTypeName
```
) to create instances
Always use
```
_test
```
suffix for package name
Use
```
suite
```
methods for assertions (e.g.,
```
suite.Equal(v, 10)
```
)

Use

suite.Require()

for error assertions (e.g.,

suite.Require().ErrorIs

suite.Require().Error

)

Never use
```
.AssertExpectations(s.T())
```

Example:

package mypackage_test

import (
	"testing"

	"github.com/stretchr/testify/suite"
)

type MyStructTestSuite struct {
	suite.Suite
	sut *mypackage.MyStruct
}

func (s *MyStructTestSuite) SetupTest() {
	// Initialize sut and dependencies
	s.sut = mypackage.New()
}

func TestMyStructSuite(t *testing.T) {
	suite.Run(t, new(MyStructTestSuite))
}

func (s *MyStructTestSuite) TestSomeMethod() {
	// Arrange
	input := "test input"
	expected := "expected output"

	// Act
	result := s.sut.SomeMethod(input)

	// Assert
	s.Equal(expected, result)
}

func (s *MyStructTestSuite) TestSomeMethod_WithError() {
	// Arrange
	invalidInput := ""

	// Act
	result, err := s.sut.SomeMethodWithError(invalidInput)

	// Assert
	s.Require().Error(err)
	s.Empty(result)
}

With Mocks:

package mypackage_test

import (
	"context"
	"testing"

	"github.com/stretchr/testify/mock"
	"github.com/stretchr/testify/suite"

	"github.com/example/project/test/mocks"
)

type UserServiceTestSuite struct {
	suite.Suite
	sut              *mypackage.UserService
	userRepoMock     *mocks.MockUserRepository
	tokenServiceMock *mocks.MockTokenService
}

func (s *UserServiceTestSuite) SetupTest() {
	// Initialize mocks
	s.userRepoMock = mocks.NewMockUserRepository(s.T())
	s.tokenServiceMock = mocks.NewMockTokenService(s.T())

	// Initialize sut with mocked dependencies
	s.sut = mypackage.NewUserService(
		s.userRepoMock,
		s.tokenServiceMock,
	)
}

func TestUserServiceSuite(t *testing.T) {
	suite.Run(t, new(UserServiceTestSuite))
}

func (s *UserServiceTestSuite) TestCreateUser_ValidInput_CreatesUser() {
	// Arrange
	ctx := context.Background()
	user := &mypackage.User{
		Email: "test@example.com",
		Name:  "Test User",
	}

	s.userRepoMock.On("Create", mock.Anything, user).Return(nil)

	// Act
	err := s.sut.CreateUser(ctx, user)

	// Assert
	s.Require().NoError(err)
}

func (s *UserServiceTestSuite) TestCreateUser_RepositoryError_ReturnsError() {
	// Arrange
	ctx := context.Background()
	user := &mypackage.User{
		Email: "test@example.com",
		Name:  "Test User",
	}
	expectedError := errors.New("repository error")

	s.userRepoMock.On("Create", mock.Anything, user).Return(expectedError)

	// Act
	err := s.sut.CreateUser(ctx, user)

	// Assert
	s.Require().ErrorIs(err, expectedError)
}

func (s *UserServiceTestSuite) TestGenerateToken_ValidUser_ReturnsToken() {
	// Arrange
	ctx := context.Background()
	userID := "user-123"
	expectedToken := "token-abc"

	s.tokenServiceMock.On(
		"Generate",
		mock.Anything,
		userID,
	).Return(expectedToken, nil)

	// Act
	token, err := s.sut.GenerateToken(ctx, userID)

	// Assert
	s.Require().NoError(err)
	s.Equal(expectedToken, token)
}

Mock Rules:

Always pass
```
mock.Anything
```
for context parameters

Mock naming follows pattern

MockType

(e.g.,

MockUserRepository

MockTokenService

)

Import mocks with aliases:

user_repository_mocks "github.com/project/internal/domain/repository/mocks"

Pattern 2: Tests for Standalone Functions

Use individual test functions with subtests for functions without instances.

Key Rules:

Create test functions using
```
func TestXxx(t *testing.T)
```
Use
```
t.Run
```
for subtests covering different scenarios
Use
```
require
```
for error assertions (e.g.,
```
require.ErrorIs
```
,
```
require.Error
```
)

Example:

package mypackage_test

import (
	"testing"

	"github.com/stretchr/testify/require"
)

func TestSomeFunction(t *testing.T) {
	t.Run("valid input returns expected result", func(t *testing.T) {
		// Arrange
		input := "test input"
		expected := "expected output"

		// Act
		result := SomeFunction(input)

		// Assert
		require.Equal(t, expected, result)
	})

	t.Run("empty input returns error", func(t *testing.T) {
		// Arrange
		input := ""

		// Act
		result, err := SomeFunctionWithError(input)

		// Assert
		require.Error(t, err)
		require.Empty(t, result)
	})

	t.Run("nil input returns error", func(t *testing.T) {
		// Arrange
		var input *string

		// Act
		result, err := SomeFunctionWithPointer(input)

		// Assert
		require.ErrorIs(t, err, ErrNilInput)
		require.Empty(t, result)
	})
}

Test Structure Requirements

(CRITICAL) Arrange-Act-Assert Pattern

Every test must follow AAA pattern with explicit comments:

// Arrange
// Act
// Assert

Code Style

Never use inline struct construction; always create variable first
Maximum 120 characters per line
Test names must clearly indicate what is being tested
Add comments for complex test setups or assertions

Test Coverage

Include happy path scenarios
Include edge cases
Include error handling
Aim for minimum test scenarios possible while maintaining at least 80% coverage

Completion

When tests are complete, respond with: Tests Done, Oh Yeah!

go-unit-tests

NPX Install

SKILL.md Content