Pinpoint: A virtual user conference Register today
Smarty

Let's build an xUnit-style test runner for Go!

Smarty header pin graphic
Michael Whatcott
Michael Whatcott
 | 
July 2, 2018
Tags
Smarty header pin graphic

Writing test functions in Go is easy:

package stuff

import "testing"

func TestStuff(t *testing.T) {
    t.Log("Hello, World!")
}

Running test functions is also easy:

$ go test -v
=== RUN   TestStuff
--- PASS: TestStuff (0.00s)
	stuff_test.go:6: Hello, World!
PASS
ok  	github.com/smartystreets/stuff	0.006s

Preparing shared state for multiple test functions is problematic. The usual recommendation is to use table-drive tests. But this approach has its limits. For us, xUnit is the ideal solution. It's simple, lightweight, and flexible. Wouldn't it be nice if we could define test methods on struct types and leverage common xUnit conventions like setups/teardowns, skipped tests, etc..? I'm thinking along these imaginary lines:

package stuff

import "testing"

// Define fields to manage system-under-test here (the fixture state).
type TestCase struct {
	*testing.T // Embedding *testing.T seems like a good idea for defining a test suite.
	sut *SystemUnderTest
}

// Perform setup actions here (instantiate test fixture state).
func (t *TestCase) Setup() {
	t.sut = NewSystemUnderTest()
}

func (t *TestCase) Test42() {
	if result := t.sut.Computation(42); result != 42 {
		t.Errorf("Got: [%d] Want: [%d]", result, 42)
	}
}

func (t *TestCase) Test43() {
	if result := t.sut.Computation(43); result != 43 {
		t.Errorf("Got: [%d] Want: [%d]", result, 43)
	}
}

The only problem is that the go test tool expects top-level functions, not methods on a struct type. And that's not going to change.

$ go test -v
testing: warning: no tests to run
PASS
ok  	github.com/smartystreets/stuff	0.006s

So, we need a way to connect a test function to methods on a struct type. And ideally, we could instantiate new instances of that type (with freshly initialized state) for each test method. Maybe a variation that leverages subtests would be closer to reality?

package stuff

import "testing"

func TestStuff(t *testing.T) {
	t.Run("Test42", new(TestCase).Test42)
	t.Run("Test43", new(TestCase).Test43)
}

// Define fields to manage system-under-test here (the fixture state).
type TestCase struct {
	sut *SystemUnderTest
}

// Perform setup actions here (instantiate test fixture state).
func (test *TestCase) Setup() {
	test.sut = NewSystemUnderTest()
}

func (test *TestCase) Test42(t *testing.T) {
    test.Setup()
	if result := test.sut.Computation(42); result != 42 {
		t.Errorf("Got: [%d] Want: [%d]", result, 42)
	}
}

func (test *TestCase) Test43(t *testing.T) {
    test.Setup()
	if result := test.sut.Computation(43); result != 43 {
		t.Errorf("Got: [%d] Want: [%d]", result, 43)
	}
}

That was certainly more effective:

$ go test -v
=== RUN   TestStuff
=== RUN   TestStuff/Test42
=== RUN   TestStuff/Test43
--- PASS: TestStuff (0.00s)
    --- PASS: TestStuff/Test42 (0.00s)
    --- PASS: TestStuff/Test43 (0.00s)
PASS
ok  	github.com/smartystreets/stuff	0.006s

But there are problems with this approach. Every time we define a new test method on the TestCase type we have to remember to register a subtest in the top-level test function. Oh, and did you notice how each test was calling the Setup method directly? This is something that should happen automatically if we're going to call this an xUnit-style test runner. It would be great if we could just call a method that points to our TestCase and iterates all test methods, calling Setup followed by a call to the test method.

From the calling side it could look something like this:

func TestStuff(t *testing.T) {
    xunit.RunTests(new(TestCase), t)
}

Notice we have to provide the *testing.T and an instance of our TestCase. The behavior defined in the mysterious xunit package would then find all the tests and run them. Impossible, you say? Not so! In fact, a draft implementation is trivial!

package xunit

import (
	"reflect"
	"strings"
	"testing"
)

func RunTests(fixture interface{}, t *testing.T) {
	fixtureType := reflect.TypeOf(fixture)

	for x := 0; x < fixtureType.NumMethod(); x++ {
		testMethodName := fixtureType.Method(x).Name
		if strings.HasPrefix(testMethodName, "Test") {
			// IMPORTANT: each test gets a new instance!
			instance := reflect.New(fixtureType.Elem())

			setupMethod := instance.MethodByName("Setup")
			callableSetup := setupMethod.Interface().(func())
			callableSetup()

			testMethod := instance.MethodByName(testMethodName)
			callableTest := testMethod.Interface().(func(t *testing.T))
			t.Run(testMethodName, callableTest)
		}
	}
}

This implementation makes a LOT of assumptions, lacks several features (like 'teardowns' and skipped tests) and isn't very robust, but hopefully you can see the emergence of an xUnit-style test runner. Most importantly, the tests are passing again:

$ go test -v
=== RUN   TestStuff
=== RUN   TestStuff/Test42
=== RUN   TestStuff/Test43
--- PASS: TestStuff (0.00s)
    --- PASS: TestStuff/Test42 (0.00s)
    --- PASS: TestStuff/Test43 (0.00s)
PASS
ok  	github.com/smartystreets/stuff	0.006s

Congratulations, you now possess a basic understanding of the inner workings of gunit! Stay tuned for a future post featuring a more in-depth look into xUnit-style testing in Go with gunit. In the meantime, feel free to kick the tires and fix things up a bit.


Source Code Download

Subscribe to our blog!
Learn more about RSS feeds here.
rss feed icon
Subscribe Now
Read our recent posts
Pinpoint: The Smarty virtual user conference, because the world is better validated
Arrow Icon
November 2025 | 100% online | 100% awesomeJoin us this November for the Smarty Virtual User Conference, a two-day event packed with insights, tools, laughs, and $1000 worth of prizes. This event is for you, whether you’re optimizing delivery accuracy, improving compliance, or just trying to figure out if your neighbor really has a breakfast nook. What to expect:2 days, 12 hours of content, zero fluffLive sessions from address data prosHands-on demos of Smarty’s latest tools and pluginsGiveaways galore, like gift cards, swag, and even a chance at a massive LEGO setHidden Easter eggs throughout the event (no, seriously—find them and win)An after-party with games (shoutout to Brady Amundson)Tailored tracks for every roleFor developers:Roll up your sleeves.
Welcome to the Address Zoo #1 | Override & underride city addresses
Arrow Icon
The benefits of reliable, easy-to-implement address data are straightforward. Actual addresses, on the other hand, aren’t always so cut and dry. If you’re looking to become an expert in everything that begins or ends with an address, this series is for you. We’ll demystify the types of addresses that have developers scratching their heads and introduce you to the tools keeping your address data best-in-class. Come one, come all, and enter the wonderful world of peculiar addresses! Let’s see what’s on exhibit.
Around the World in 80 Days (with Smarty!)
Arrow Icon
Phony passports. Runaway trains. Rogue elephants. Hot air balloons. Phileas Fogg dodged them all in the 1956 movie adaptation of Jules Verne’s novel, Around the World in 80 Days. His race was against time. Today, your ecommerce business is running a race of its own; delivering quickly, accurately, and affordably across a world full of logistical landmines. Fortunately, you don’t need a valet named Passepartout to guide you (although wouldn’t that be fun?!) You just need Smarty. Smarty is your passport to global address data perfection, specializing in address verification, autocomplete, geocoding, and enrichment.

Ready to get started?