New 42 day free trial
Smarty
0
Cart Icon
Cart

Testing in Go by example: Part 1

Smarty header pin graphic
February 27, 2015
link-icon
Tags
Programming blog tagProgrammingTesting blog tagTesting

Here's part 1 of our "Testing in Go" series.

Introduction

Thinking about trying Go? You won't regret it! It's great that testing is baked into the "testing" package from the standard library and the corresponding go test command (which has all sorts of useful and interesting flags).

We'd like to show you how easy it is to get started using the built-in testing tools and introduce you to some tools we've created. This is the first installment of a series designed to do just that.

All you have to do is create a file named like *_test.go, and start with something like this:

package foo

import "testing"


func TestSomething(t *testing.T) {
// test stuff here...
}

Notice that the test function starts with Test... and receives a single parameter: t *testing.T. Those are the only contractual obligations to get a test going. Then just run go test in that directory and your test will run:

$ go test -v
=== RUN TestSomething
--- PASS: TestSomething (0.00s)
PASS
ok  	github.com/smartystreets/goconvey/examples/vanilla/foo	0.005s

The -v (verbose) flag shows test function names as they run.

Test functions are given the benefit of the doubt and labeled with PASS unless there is definite failure:

func TestSomething(t *testing.T) {
t.Fail()
}

Here's the output of go test:

=== RUN TestSomething
--- FAIL: TestSomething (0.00s)
FAIL
exit status 1
FAIL	github.com/smartystreets/goconvey/examples/vanilla/foo	0.005s

Typically you'll want to show why a test failed:

func TestSomething(t *testing.T) {
t.Error("I'm in a bad mood.")
}

And the output of go test:

=== RUN TestSomething
--- FAIL: TestSomething (0.00s)
foo_test.go:6: I'm in a bad mood.
FAIL
exit status 1
FAIL	github.com/smartystreets/goconvey/examples/vanilla/foo	0.004s

Recurring example

In this series about testing in Go I'll use a well-known unit testing example by Uncle Bob Martin called "Bowling Game".

The production code implements a scoring algorithm for a bowling game score card, incorporating bonus rules for strikes and spares. For reference, here's a correct implementation:

package vanilla


// Game contains the state of a bowling game.
type Game struct {
rolls   []int
current int
}


// NewGame allocates and starts a new game of bowling.
func NewGame() *Game {
game := new(Game)
game.rolls = make([]int, maxThrowsPerGame)
return game
}


// Roll rolls the ball and knocks down the number of pins specified by pins.
func (self *Game) Roll(pins int) {
self.rolls[self.current] = pins
self.current++
}


// Score calculates and returns the player's current score.
func (self *Game) Score() (sum int) {
for throw, frame := 0, 0; frame < framesPerGame; frame++ {
if self.isStrike(throw) {
sum += self.strikeBonusFor(throw)
throw += 1
} else if self.isSpare(throw) {
sum += self.spareBonusFor(throw)
throw += 2
} else {
sum += self.framePointsAt(throw)
throw += 2
}
}
return sum
}


// isStrike determines if a given throw is a strike or not. A strike is knocking
// down all pins in one throw.
func (self *Game) isStrike(throw int) bool {
return self.rolls[throw] == allPins
}


// strikeBonusFor calculates and returns the strike bonus for a throw.
func (self *Game) strikeBonusFor(throw int) int {
return allPins + self.framePointsAt(throw+1)
}


// isSpare determines if a given frame is a spare or not. A spare is knocking
// down all pins in one frame with two throws.
func (self *Game) isSpare(throw int) bool {
return self.framePointsAt(throw) == allPins
}


// spareBonusFor calculates and returns the spare bonus for a throw.
func (self *Game) spareBonusFor(throw int) int {
return allPins + self.rolls[throw+2]
}


// framePointsAt computes and returns the score in a frame specified by throw.
func (self *Game) framePointsAt(throw int) int {
return self.rolls[throw] + self.rolls[throw+1]
}


// testing utilities:


func (self *Game) rollMany(times, pins int) {
for x := 0; x < times; x++ {
self.Roll(pins)
}
}
func (self *Game) rollSpare() {
self.Roll(5)
self.Roll(5)
}
func (self *Game) rollStrike() {
self.Roll(10)
}


const (
// allPins is the number of pins allocated per fresh throw.
allPins = 10


// framesPerGame is the number of frames per bowling game.
framesPerGame = 10

// maxThrowsPerGame is the maximum number of throws possible in a single game.
maxThrowsPerGame = 21



)

Example test suite

I hope that's pretty straightforward, but if not, here are some tests that document how one would calculate a bowling game score with the provided Game struct (above).

package vanilla


import "testing"


func TestGutterBalls(t *testing.T) {
t.Log("Rolling all gutter balls... (expected score: 0)")
game := NewGame()
game.rollMany(20, 0)


if score := game.Score(); score != 0 {
	t.Errorf("Expected score of 0, but it was %d instead.", score)
}



}


func TestOnePinOnEveryThrow(t *testing.T) {
t.Log("Each throw knocks down one pin... (expected score: 20)")
game := NewGame()
game.rollMany(20, 1)


if score := game.Score(); score != 20 {
	t.Errorf("Expected score of 20, but it was %d instead.", score)
}



}


func TestSingleSpare(t *testing.T) {
t.Log("Rolling a spare, then a 3, then all gutters... (expected score: 16)")
game := NewGame()
game.rollSpare()
game.Roll(3)
game.rollMany(17, 0)


if score := game.Score(); score != 16 {
	t.Errorf("Expected score of 16, but it was %d instead.", score)
}



}


func TestSingleStrike(t *testing.T) {
t.Log("Rolling a strike, then 3, then 7, then all gutters... (expected score: 24)")
game := NewGame()
game.rollStrike()
game.Roll(3)
game.Roll(4)
game.rollMany(16, 0)


if score := game.Score(); score != 24 {
	t.Errorf("Expected score of 24, but it was %d instead.", score)
}



}


func TestPerfectGame(t *testing.T) {
t.Log("Rolling all strikes... (expected score: 300)")
game := NewGame()
game.rollMany(21, 10)


if score := game.Score(); score != 300 {
	t.Errorf("Expected score of 300, but it was %d instead.", score)
}



}

Test output

$ go test -v


=== RUN TestGutterBalls
--- PASS: TestGutterBalls (0.00s)
bowling_game_test.go:6: Rolling all gutter balls... (expected score: 0)
=== RUN TestOnePinOnEveryThrow
--- PASS: TestOnePinOnEveryThrow (0.00s)
bowling_game_test.go:16: Each throw knocks down one pin... (expected score: 20)
=== RUN TestSingleSpare
--- PASS: TestSingleSpare (0.00s)
bowling_game_test.go:26: Rolling a spare, then a 3, then all gutters... (expected score: 16)
=== RUN TestSingleStrike
--- PASS: TestSingleStrike (0.00s)
bowling_game_test.go:38: Rolling a strike, then 3, then 7, then all gutters... (expected score: 24)
=== RUN TestPerfectGame
--- PASS: TestPerfectGame (0.00s)
bowling_game_test.go:51: Rolling all strikes... (expected score: 300)
PASS
ok  	github.com/smartystreets/goconvey/examples/vanilla	0.005s

Analysis

Good stuff

  • Testing is a first-class citizen in Go.
  • The testing package is very easy to learn and use.
  • The go test command is an adequate, flexible test runner.
  • The go test command line flags are helpful and provide lots of interesting utility.

Not-so-good stuff

  • Tests are always run in the same order.
  • There's no convenient way to run shared "setup" or "teardown" logic to be run for each test function.
  • There are no helpful "assertion/helper" methods provided by the testing package.
  • You have to compose your own error messages in failure situations.
  • The convention is to check that what shouldn't have happened didn't happen, rathern than to ensure/assert that what should have happened actually did happen. This is a subtle yet important point which we will discuss more in a later post.

The "Not-So-Good Stuff" above can be rephrased this way: the Go testing package just isn't xunit. Depending on your point of view and experience this isn't a bad thing, it's just an observation.

Kent Beck came up with xunit (first called SUnit for the smalltalk language) to facilitate TDD and unit testing with a more expressive, automatable API. Later, Dan North coined the term "Behavoir Driven Development", or BDD, from which jBehave and other libraries were born.

So, when we came to Go we were specifically accustomed to:

You can probably understand that we were a little disappointed that the Go testing package did so little by comparison. This lack of features has been addressed by the Go authors so this wasn't an oversight on their part. They strived, successfully, to create the simplist solution for the largest audience. So, in the next few posts we'll demonstrate some of the things we've created at Smarty to achieve the kind of testing toolkit we were missing.

Subscribe to our blog!
Learn more about RSS feeds here.
rss feed icon
Subscribe Now
Read our 5 address validation use cases ebook nowDownload now
Read our recent posts
Inside Smarty® - Irina O'hara
Arrow Icon
Irina O'Hara is one of our uniquely clever, expert frontend developers. She’s immensely talented and has had a vital impact on our website redesign. When it came time to spotlight her, Irina was a joy to sit down with and get to know a little better. To get to the basics, she writes code and creates awesome websites, and she’s darn good at both. BackgroundIrina was born and raised in St. Petersburg, Russia. However, she wasn't born a development expert and had other aspirations from the start.
How I reduced my returned mail from 27% to 1% using address autocomplete
Arrow Icon
The following is based on a true story. Some of the names and relationships have been changed to protect the anonymity of individuals and companies. However, the numbers are 100% accurate. In 2023, I wanted to mail some really fancy cards to 165 businesses. I collected their addresses by asking for them or finding them in their online listing and collected them all in a neat little row. Then, I went a step further and ran these addresses through Smarty's bulk address validation tool. Everything was set and perfect.
The ROI of accurate healthcare address validation: Stop hemorrhaging red on your financial statements
Arrow Icon
In healthcare, the havoc an inaccurate address can wreak on your financial results is significant in more ways than one, and the boost in overall profitability from maintaining a clean address database is equally worth noting. Accurate healthcare address validation improves operational efficiency, patient engagement, and compliance and builds revenue to heights that couldn’t be met without it. Here’s what we’ll be covering:Healthcare address validation pros and consCon: Increased claim denials and organizational costsPro: Reduced claim denials and reprocessing costsCon: Increasing patient match error ratesPro: Improved patient matching and data qualityCon: Complicated billing and collections processesPro: Streamlined billing and collections capabilitiesCon: Exposure to legal liabilitiesPro: Enhanced regulatory compliance and risk aversionCon: Misplaced market strategyPro: Data-driven decision-making and market insightsEpilogue: Avoiding the pain (see our summarized financial savings)Healthcare address validation pros and consThere’s a pro and a con associated with having (or not having 🫣) accurate address data in your healthcare systems.
Previous Post
Next Post

Ready to get started?

Schedule Demo
42-day Free Trial