Testify — Go Testing Toolkit with Assertions and Mocks

What it is

Testify is the most widely used Go testing toolkit. It extends Go's standard testing package with three components: assert (soft assertions that log failures and continue), require (hard assertions that stop the test), and mock (interface mocking with expectations and verifications).

It targets Go developers who find the standard if got != want { t.Errorf(...) } pattern too verbose. Testify makes tests more readable and reduces boilerplate without replacing Go's test runner.

How it saves time or tokens

A typical Go test without Testify requires 3-4 lines per assertion (check, format error message, call t.Errorf). Testify reduces this to one line: assert.Equal(t, expected, actual). For a test file with 50 assertions, this saves 100-150 lines of boilerplate.

The mock package generates mock implementations from interfaces, eliminating the need to write manual mock structs.

How to use

1. Install Testify:

go get github.com/stretchr/testify

1. Write assertions:

package mypackage

import (
    "testing"
    "github.com/stretchr/testify/assert"
    "github.com/stretchr/testify/require"
)

func TestUser(t *testing.T) {
    user, err := GetUser(1)
    require.NoError(t, err)          // stops test if err != nil
    assert.Equal(t, "Alice", user.Name)
    assert.NotEmpty(t, user.Email)
    assert.Contains(t, user.Roles, "admin")
}

1. Use mocks for interface dependencies:

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

type MockDB struct { mock.Mock }

func (m *MockDB) GetUser(id int) (*User, error) {
    args := m.Called(id)
    return args.Get(0).(*User), args.Error(1)
}

Example

// Test suite with setup/teardown
package mypackage

import (
    "testing"
    "github.com/stretchr/testify/suite"
)

type UserSuite struct {
    suite.Suite
    db *TestDB
}

func (s *UserSuite) SetupTest() {
    s.db = NewTestDB()
    s.db.Seed()
}

func (s *UserSuite) TearDownTest() {
    s.db.Clean()
}

func (s *UserSuite) TestCreateUser() {
    user, err := s.db.CreateUser("Charlie")
    s.Require().NoError(err)
    s.Equal("Charlie", user.Name)
}

func TestUserSuite(t *testing.T) {
    suite.Run(t, new(UserSuite))
}

Related on TokRepo

• AI Tools for Testing -- Automated testing tools and frameworks
• AI Tools for Coding -- Developer tools and coding assistants

Common pitfalls

• Use require for preconditions (like checking errors) and assert for value checks. Using assert for error checks means the test continues with a nil pointer.
• Testify mock expectations must be verified with mock.AssertExpectations(t) at the end of the test. Forgetting this means unmet expectations pass silently.
• Do not import both assert and require under the same alias. Use their package names as-is to keep test code clear.