Pinpoint: A virtual user conference in
Smarty

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

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
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.
Address component analysis: A smarter way to validate addresses
Arrow Icon
Most address validation tools give you a simple thumbs up or down on an address because it either matches or it doesn’t, right? But what if you need more than just “valid” or “invalid” as a response? What if you could know exactly what part of the address is off, like a misspelled street name or an unconfirmed vanity city (like Hollywood), and why it isn’t considered valid?What if part of an address needed to change in order to make it a mailable, valid address? We think you’d want to know that, too.
BREAKING: Rooftop geocodes walk off the job—chaos mounting by the hour
Arrow Icon
Dateline: Tuesday, 8:04 a. m. In what experts are calling “the biggest location intelligence crisis since the discovery of space,” rooftop-accurate geocodes have officially gone on strike. The high-precision coordinates—normally pinpointing locations down to the exact rooftop for deliveries, telecom installs, insurance claims, and analytics—appeared on Smarty TV and issued a short but cutting statement this morning:“We’re tired of being taken for granted. We’re tired of being treated like just another number.

Ready to get started?