Interview Series: Writing Unit Tests in Go

Nov 11

How do you write unit tests in Go? Can you give an example of a table-driven test?

Unit testing is a fundamental aspect of software development, ensuring that individual units of code function as expected. In the world of Go, writing unit tests is streamlined and integrated into the language's standard library, making it a seamless part of the development process. In this blog post, we'll explore how to write unit tests in Go, with a specific focus on table-driven tests.

Understanding Unit Tests in Go

Go has a built-in testing framework, which is part of its standard library. This framework provides a simple yet powerful way to write and run tests. To create a test in Go, you need to:

Create a file that ends with _test.go.
Write test functions that start with Test followed by a name (e.g., TestFunctionName).
Use the testing package to write test cases.

A typical test function in Go looks like this:

func TestFunctionName(t *testing.T) {
    // test cases
}

What is Table-Driven Testing?

Table-driven testing is a pattern where test cases are stored in a table (usually as a slice of structs) and a single test function iterates over this table to test different scenarios. This approach is particularly useful for testing functions with various input-output combinations. It makes tests easier to read and maintain.

Implementing a Table-Driven Test in Go

Let's consider an example. Suppose we have a function Add that takes two integers and returns their sum. We want to test this function using a table-driven approach.

First, we define the Add function in a file named math.go:

package math

// Add returns the sum of two integers.
func Add(a, b int) int {
    return a + b
}

Now, we write the test in a file named math_test.go:

package math

import "testing"

func TestAdd(t *testing.T) {
    // Define the test table
    tests := []struct {
        name   string
        inputA int
        inputB int
        want   int
    }{
        {"Add 1 and 2", 1, 2, 3},
        {"Add -1 and 1", -1, 1, 0},
        // Add more test cases here
    }

    // Iterate over the test table
    for _, tc := range tests {
        t.Run(tc.name, func(t *testing.T) {
            got := Add(tc.inputA, tc.inputB)
            if got != tc.want {
                t.Errorf("Add(%d, %d) = %d; want %d", tc.inputA, tc.inputB, got, tc.want)
            }
        })
    }
}

In this example, we define a slice of structs, each representing a test case with inputs and the expected output. We then iterate over this slice, running the Add function with each set of inputs and checking if the result matches our expectations.

Benefits of Table-Driven Tests in Go

Table-driven tests in Go offer several advantages:

Clarity: Tests are clear and concise, making them easier to understand and maintain.
Scalability: It's easy to add more test cases simply by adding to the table.
Organization: Grouping similar test cases together improves readability and organization.

Table-driven tests in Go are a powerful way to write clear, concise, and maintainable tests, especially when dealing with functions that require multiple different input-output combinations. By integrating these tests into your Go development workflow, you can ensure your code behaves as expected in a variety of scenarios.

Remember, good testing practices are crucial for maintaining high-quality, reliable software. Happy coding and testing in Go!

gogolangtestinginterview

Noah Parker