Getting Started with Unit Testing in Go

Table of Contents

1. Introduction
2. Prerequisites
3. Setting Up Go
4. Creating Your First Unit Test
5. Running Unit Tests
6. Assertions and Test Cases
7. Testing Conventions
8. Table-Driven Tests
9. Test Coverage
10. Conclusion

Introduction

Welcome to the tutorial on getting started with unit testing in Go! Unit testing is an essential part of building robust and reliable software. In this tutorial, you will learn the fundamentals of unit testing in Go and how to write effective test cases.

By the end of this tutorial, you will be able to:

• Understand the importance of unit testing
• Set up Go for unit testing
• Write test functions and assertions
• Run unit tests and interpret results
• Implement table-driven tests for different scenarios
• Measure test coverage for your code

Let’s get started!

Prerequisites

Before you start this tutorial, you should have a basic understanding of the Go programming language and its syntax. Familiarity with concepts like functions, variables, and control flow will be helpful.

Setting Up Go

To follow along with this tutorial, you need to have Go installed on your machine. You can download the latest version of Go from the official website (https://golang.org/dl/) and follow the installation instructions for your operating system.

Once installed, you can verify the installation by opening a terminal or command prompt and running the following command:

go version

If Go is installed correctly, you will see the version number printed on the screen.

Creating Your First Unit Test

In Go, unit tests are written in the same package as the code they test, but in separate files suffixed with _test. Let’s create a simple example to demonstrate this.

Create a new directory named myapp and navigate into it:

mkdir myapp
cd myapp

Now, create two files: myapp.go and myapp_test.go. The myapp.go file will contain the code we want to test, and the myapp_test.go file will contain our unit tests.

Open myapp.go in a text editor and add the following code:

package main

func Add(a, b int) int {
	return a + b
}

In myapp_test.go, add the following code:

package main

import "testing"

func TestAdd(t *testing.T) {
	result := Add(2, 3)
	expected := 5
	if result != expected {
		t.Errorf("Add(2, 3) = %d; expected %d", result, expected)
	}
}

We have defined a test function TestAdd that calls the Add function from myapp.go and checks if the result is as expected. If the result is different, we use t.Errorf to report an error.

Running Unit Tests

To run the unit tests for your Go code, navigate to the directory containing the test files (myapp in our case) using the terminal or command prompt.

Run the following command to execute the tests:

go test

If the tests pass, you should see an output similar to:

PASS
ok      myapp   0.001s

Congratulations! You have successfully run your first unit test in Go.

Assertions and Test Cases

In Go, we use the testing package to write assertions within our test functions. The testing package provides various assertion functions like Errorf, Fail, FailNow, and more.

Let’s modify our previous example to include multiple test cases and use different assertion functions.

In myapp_test.go, replace the existing test function with the following code:

func TestAdd(t *testing.T) {
	t.Run("Positive numbers", func(t *testing.T) {
		result := Add(2, 3)
		expected := 5
		if result != expected {
			t.Errorf("Add(2, 3) = %d; expected %d", result, expected)
		}
	})

	t.Run("Negative numbers", func(t *testing.T) {
		result := Add(-5, -3)
		expected := -8
		if result != expected {
			t.Errorf("Add(-5, -3) = %d; expected %d", result, expected)
		}
	})
}

We have now split our test function into two sub-tests, each representing a different test case. Within each sub-test, we perform the related assertions.

To run the updated test, use the same go test command as before.

Testing Conventions

Go has some conventions for writing test functions and organizing test files.

• Test functions should be named starting with “Test” followed by a descriptive name, like TestAdd in our example.
• Test files should be suffixed with _test and belong to the same package as the code they test.
• Use sub-tests, indicated by t.Run, to group related test cases together.
• Use meaningful names for your test cases and sub-tests to make failures easier to understand.

Following these conventions ensures that your tests are organized and readable.

Table-Driven Tests

Table-driven tests are a powerful technique in Go that allow you to test multiple inputs and expected outputs using a table structure. Let’s modify our example to use table-driven tests.

Replace the existing TestAdd function with the following code:

func TestAdd(t *testing.T) {
	testCases := []struct {
		a, b     int
		expected int
	}{
		{2, 3, 5},
		{-5, -3, -8},
		{0, 0, 0},
	}

	for _, tc := range testCases {
		result := Add(tc.a, tc.b)
		if result != tc.expected {
			t.Errorf("Add(%d, %d) = %d; expected %d", tc.a, tc.b, result, tc.expected)
		}
	}
}

In the updated code, we define a slice of struct literals representing our test cases. Each test case contains inputs a and b, and an expected output expected. We then iterate over these test cases and perform the assertions.

Run the tests again using go test to see that they still pass.

Table-driven tests make it easy to add or modify test cases without changing the test function’s structure. This technique is particularly useful when dealing with a large number of test cases.

Test Coverage

Go provides built-in support for measuring test coverage, which helps you assess how much of your code is covered by tests. The coverage report indicates which parts of your code are executed during the tests.

To generate a coverage report, run the following command:

go test -cover

You will see an output like:

PASS
coverage: 100.0% of statements
ok      myapp   0.001s

The coverage value indicates the percentage of lines of code that were executed during the tests. Aim for high coverage to increase confidence in the reliability of your code.

Congratulations! You have completed the tutorial on getting started with unit testing in Go. You now have a solid foundation for writing effective unit tests and ensuring the quality of your Go code.

Conclusion

In this tutorial, you learned the basics of unit testing in Go. You set up Go on your machine, created your first unit test, ran tests, and explored various testing techniques like assertions, test cases, and table-driven tests. Additionally, you learned about the testing conventions in Go and how to measure test coverage.

Unit testing is a crucial part of software development, and Go’s testing package provides an excellent framework for writing tests. By leveraging the techniques covered in this tutorial, you can write comprehensive and reliable unit tests for your Go projects.

Remember to strive for high test coverage and follow best practices to maintain the quality and stability of your codebase. Happy testing!

Published: 25 December 2020

Related Articles

• Getting Started Guide: Introduction to Go Programming on Linux
• Writing Idiomatic and Effective Go Code
• Mastering Array Manipulation in Go
• A Practical Guide to Go's Minimal Version Selection
• Writing a Go-Based CLI Tool for IP Address Lookup
• Working with File Metadata in Go
• How to Use the os.FileInfo Interface in Go
• Understanding Channel Types in Go
• Mastering the Use of Go's fmt.Stringer Interface
• Troubleshooting Common Go Testing Problems
• Reading and Writing to a Text File in Go
• Understanding Map Operations in Go
• Writing a CLI for Log Parsing in Go
• Debugging Go Modules: A Step-by-Step Guide
• Go Design Patterns and Idiomatic Practices
• Understanding Standard Input and Standard Output in Go
• Understanding Function Signatures in Go
• Debugging Go Code with Print Statements
• Go Design Patterns: Understanding and Implementing Them
• How to Handle Pointer Errors in Go