Mutation Testing in Go: How to Catch What Unit Tests Miss

Introduction: Tests Pass, But Bugs Remain?

Imagine this: you've written a module in Go, covered it with unit tests at 95% according to go test -cover, all tests are green. You're confident the code works perfectly. But a bug appears in production. Sound familiar?

The problem is that the code coverage metric is just the number of lines that were executed. It doesn't tell you what exactly the tests are checking. You can have 100% coverage but never verify that a function returns the correct value, only that it doesn't panic.

This is where mutation testing in Go comes into play — a technique that artificially introduces errors into your code and checks whether the tests can detect them. If tests don't fail on mutated code, it means your tests are useless.

In this article, we'll break down what mutation testing in Go is, how to set it up, and why it's a must-have for projects where reliability is critical. Let's go!

What is Mutation Testing?

Mutation testing is a method for evaluating test quality by introducing small changes (mutations) into the program that simulate typical developer errors. The tests are then run. If at least one test fails, the mutation is "killed" — the test works. If all tests pass, the mutation "survived," and that's a red flag: you have a hole in your tests.

In Go, mutation testing is often called mutation testing golang, and it's especially useful for verifying business logic, validators, parsers, and other critical components.

Example of a Mutation

Suppose you have a simple function:

func IsEven(n int) bool {\n    return n%2 == 0\n}

A typical mutation is replacing == with !=:

func IsEven(n int) bool {\n    return n%2 != 0\n}

If your test only checks that IsEven(2) doesn't panic, but doesn't check that the result is true, the mutation will survive. The test will pass, even though the function now works exactly opposite to how it should.

Why Simple Code Coverage Isn't Enough?

Many Go developers are accustomed to relying on go test -cover. It's a useful metric, but it can be deceptive. Consider this example:

func Divide(a, b int) (int, error) {\n    if b == 0 {\n        return 0, errors.New("division by zero")\n    }\n    return a / b, nil\n}

Test:

func TestDivide(t *testing.T) {\n    result, err := Divide(10, 2)\n    if err != nil {\n        t.Fatal(err)\n    }\n    if result != 5 {\n        t.Errorf("expected 5, got %d", result)\n    }\n}

Coverage? 100% — all lines were executed. But what if someone accidentally replaces a / b with a * b? The test won't notice, because 10 * 2 = 20, and we expected 5. Will the test fail? No, if we don't check the exact value.

Mutation testing in Go will immediately reveal this problem by creating a mutant with multiplication and checking if the test fails.

Tools for Mutation Testing in Go

The primary tool is go-mutesting. This is a popular library that automatically creates mutations and runs tests. Installation:

go get github.com/zimmski/go-mutesting/cmd/go-mutesting

There are also alternatives, such as mutesting from the company "Go Test It", but go-mutesting is the de facto standard.

How to Run It

Basic run:

go-mutesting ./...

This command will find all _test.go files in the project and check which mutations survive. The result is output to the console with a detailed report.

Practical Example: Mutation Testing in Go

Let's create a simple calculator package with addition and