10 Golang Testing Best Practices

Go is a great language for writing tests. The language has excellent support for writing unit tests, and the community has produced a number of high-quality testing tools.

In this article, we will discuss 10 best practices for writing tests in Go. These practices will help you write more maintainable and reliable tests.

1. Use the testing package

The testing package provides a rich set of features that are essential for writing high-quality tests. These features include:

Assertions: The testing package provides many assertions that you can use to check the behavior of your code.

Benchmarks: The testing package can run benchmarks to help you optimize your code.

Coverage: The testing package can generate coverage reports to help you identify areas of your code that are not being tested.

Mocking: The testing package provides a mock object library that you can use to mock dependencies in your code.

The testing package is an essential tool for writing high-quality Golang tests, so make sure you are using it.

2. Write tests for all public functions and methods

When other developers or users use your code, they will most likely only interact with the public functions and methods. This means that if there are any bugs in the private functions or methods, they will never be found or fixed.

Writing tests for all public functions and methods ensures that the code you write is of the highest quality and that any bugs will be found and fixed quickly.

3. Test one thing at a time

When you’re testing multiple things at once, it’s difficult to pinpoint which part of the code is causing a test to fail. This can lead to frustration and wasted time trying to debug the code.

It’s much easier to test one thing at a time and then move on to the next thing. This way, you can be confident that the code you’re testing is working as expected.

4. Avoid using global variables in tests

When you use global variables in tests, it’s difficult to reset them to their original state after each test. This can lead to problems where one test is relying on the state set by a previous test, which can cause tests to fail unexpectedly.

It’s much better to create a new instance of the variable for each test, so that each test is isolated from the others. This will make your tests more reliable and easier to debug.

5. Make your test code readable

Your test code is just as important as your production code, and for the same reasons. It needs to be maintainable, it needs to be understandable, and it needs to be correct.

One of the best ways to make your test code readable is to use clear and descriptive names for your tests and your test functions. For example, instead of using a name like “test1”, use a name that describes what the test is actually testing, like “test_user_can_login”.

It’s also important to use clear and concise assertions in your tests. Assertions should describe what you’re expecting to happen, and they should fail with a clear and helpful error message if that expectation isn’t met.

Finally, don’t be afraid to add comments to your test code. Comments can help explain why a particular test is necessary, or how it relates to other tests in the suite.

6. Run tests continuously on CI/CD

When you’re developing software, it’s important to have a feedback loop so you can catch errors as early as possible. By running tests on CI/CD, you can find out about errors almost immediately after they’re introduced, which makes them much easier to fix.

Not only that, but running tests continuously also helps ensure that your tests are always up-to-date. If a new feature is introduced, or an existing feature is changed, your tests will be run against the new code, ensuring that everything still works as expected.

Finally, running tests continuously on CI/CD can also help improve your team’s workflow. When developers know that their code will be automatically tested before it’s deployed, they’re more likely to write better tests and pay more attention to the quality of their code.

7. Use table-driven tests

Table-driven tests make your code more readable and easier to maintain. They also allow you to DRY up your test code, which is important for keeping your tests concise and easy to understand.

To write a table-driven test, simply create a table with all of the input values and expected output values for your test. Then, write a single test function that iterates over the table and runs the test for each row.

This may seem like a lot of work upfront, but it will pay off in the long run. Your tests will be easier to read and maintain, and you’ll be able to catch errors more quickly.

8. Don’t use sleep() to wait for goroutines

When you use sleep() in a test, it’s hard to know how long to sleep for. If the goroutine is slow, your test will be slow. If the goroutine is fast, your test might fail because it didn’t have enough time to finish.

A better way to wait for a goroutine to finish is to use a sync.WaitGroup. With a WaitGroup, you can tell the goroutine to wait for the WaitGroup to be done before it finishes. This way, you can be sure that the goroutine has finished before your test ends.

9. Isolate dependencies from tests

When you’re testing code that depends on other packages, if those dependencies change, your tests might break even though the code you’re testing hasn’t changed. This makes it difficult to know whether a test is failing because of a change in the code or because of a change in a dependency.

To avoid this problem, you can use the “double import” technique. When you import a package for the second time in a test file, Golang will give you an error. However, you can use a blank identifier to ignore that error:

import (
“testing”

“github.com/stretchr/testify/assert”
)

func TestSomething(t *testing.T) {
// Import the package we’re testing, using a blank identifier to ignore the error.
_ “github.com/my/package”

// Import the package again, this time without a blank identifier.
// We’ll get an error if the package has already been imported.
import “github.com/my/package”

// …
}

This technique ensures that your tests only depend on the code in the package you’re testing, and not on any of its dependencies.

10. Mock external APIs

When your code makes an HTTP request to an external API, it’s important to mock that request in your tests. Mocking the request ensures that your test is not dependent on the response from the external API, which could change at any time.

Mocking the request also allows you to control the response from the external API, so you can test different scenarios. For example, you might want to test what happens when your code receives a 404 error from the external API.

There are many Golang libraries that allow you to mock HTTP requests, such as github.com/golang/mock/gomock and github.com/stretchr/testify/mock.