David's Blog

Using Testify in Golang A Comprehensive Guide

By David Li on 2024-04-29T08:21:13.000Z

Using Testify in Golang: A Comprehensive Guide

Testify is a popular testing framework for the Go programming language. It provides a rich set of assertions and utilities that make it easier to write and maintain tests. In this article, we’ll explore the key features of Testify, and see how to use them effectively in your Golang projects.

Table of Contents


Testify is a library that extends the standard Go testing package. It is designed to provide a more expressive and convenient API for writing tests. Some of the main features of Testify include:

  • A rich set of assertions for common testing scenarios
  • Test suites for organizing and running related tests
  • Mocking support for isolating and testing components

Getting Started

To use Testify in your project, you need to install the package first. You can do this using the go get command:

go get -u github.com/stretchr/testify

This will install Testify and its dependencies in your Go workspace. Now you can import the package in your test files and start using its features.


Assertions are the foundation of any test framework. They allow you to compare the actual output of your code with the expected output, and fail the test if they don’t match. Testify provides a rich set of assertions that cover most common testing scenarios.

You can use assertions from the github.com/stretchr/testify/assert package. Here’s an example of a simple test function that uses Testify assertions:

package main

import (

func TestAdd(t *testing.T) {
	result := Add(2, 3)

	assert.Equal(t, 5, result, "Add(2, 3) should be 5")

In this example, we’re testing the Add() function, which takes two integers as input and returns their sum. We use the Equal assertion from Testify to check if the result of Add(2, 3) is equal to 5.

If the assertion fails, the test will fail, and Testify will print a helpful error message with the expected and actual values.


Test suites are a way to organize and run related tests. They can be particularly useful for large projects with many tests, as they allow you to group tests by functionality, and run them in a specific order.

To create a test suite, you need to define a struct that embeds the github.com/stretchr/testify/suite.Suite type:

package main

import (

type AddSuite struct {

// Test suite setup and teardown methods, if needed

func (s *AddSuite) TestAdd() {
	result := Add(2, 3)

	s.Equal(5, result, "Add(2, 3) should be 5")

func TestRunAddSuite(t *testing.T) {
	suite.Run(t, new(AddSuite))

Notice that we’ve moved the TestAdd() function inside the AddSuite struct, and changed its receiver from *testing.T to *AddSuite. We can now use the Equal() method from the embedded Suite type, just like we used the Equal() function from the assert package earlier.

To run the test suite, you need to call the suite.Run() function in a separate test function. This function takes a *testing.T argument, and an instance of your test suite.


Mocks are a powerful feature of Testify that allows you to isolate components and test them independently. They are particularly useful when you’re dealing with external dependencies, such as databases or APIs, which can be hard or expensive to set up for tests.

Testify provides a github.com/stretchr/testify/mock package for creating and using mocks in your tests. Here’s an example of a test that uses a mock object to simulate a database query:

package main

import (

// UserRepository is a mock implementation of a database repository
type UserRepositoryMock struct {

// FindUserByID is a method that simulates a database query
func (m *UserRepositoryMock) FindUserByID(id int) (*User, error) {
	args := m.Called(id)

	if args.Get(0) == nil {
		return nil, args.Error(1)

	return args.Get(0).(*User), args.Error(1)

func TestFindUserByID(t *testing.T) {
	userRepo := new(UserRepositoryMock)
	userRepo.On("FindUserByID", 1).Return(&User{ID: 1, Name: "Alice"}, nil)

userService := NewUserService(userRepo)
user, err := userService.FindUserByID(1)

assert.NoError(t, err, "FindUserByID should not return an error")
assert.NotNil(t, user, "FindUserByID should return a user")
assert.Equal(t, 1, user.ID, "User ID should be 1")
assert.Equal(t, "Alice", user.Name, "User name should be Alice")


In this example, we’re testing a UserService that depends on a UserRepository interface for fetching users from a database. We create a UserRepositoryMock struct that implements the UserRepository interface, and use the mock.Mock type from Testify to handle method calls and return values.

The FindUserByID() method in our mock implementation uses the Called() method from mock.Mock to record the call and return the specified values. In our test function, we set up the mock to expect a call to FindUserByID() with the argument 1, and return a user object with the same ID.

Finally, we create an instance of UserService with our mock repository, and call the FindUserByID() method on it. We use Testify assertions to check the result of the method, and the AssertExpectations() method from mock.Mock to verify that the expected calls to the mock were made.


Testify is a powerful and expressive testing framework for Go that provides a rich set of features for writing and maintaining tests. With its comprehensive support for assertions, test suites, and mocks, it can help make your tests more robust, readable, and maintainable.

In this article, we covered the basics of using Testify in your Golang projects, including how to get started, use assertions, create test suites, and work with mocks. With these building blocks, you can start leveraging Testify in your own projects and improve the quality of your tests.

© Copyright 2024 by FriendlyUsers Tech Blog. Built with ♥ by FriendlyUser. Last updated on 2024-05-06.