golang-unit-test-v3.slide

Testing in Go
2 Mar 2020

badboyd
https://github.com/badboyd

* Purpose of this talk
- Write unit test in golang

* Why unit test?
- Get computers to check our work
- Run them automatically (every time we change something)
- End up with a suite of tests describing the functionality
- Bold and robust refactoring
- We know if we break something by mistake
- We know what we've broken
- We all do manual testing - takes time and effort >> make less effort

* Test

.play -edit test1.go /START OMIT/,/END OMIT/

* Table tests

.play -edit test2.go /START OMIT/,/END OMIT/

* Go test

- go test - runs tests and gives you output
- go test ./... - run tests for multi-package projects
- go test -cover

* T

The `*testing.T` argument is used for error reporting:

	t.Errorf("got bar = %v, want %v", got, want)
	t.Fatalf("Frobnicate(%v) returned error: %v", arg, err)
	t.Logf("iteration %v", i)

And enabling parallel tests:

	t.Parallel()

And controlling whether a test runs at all:

	if runtime.GOARCH == "arm" {
		t.Skip("this doesn't work on ARM")
	}


* Test coverage

The `go` tool can report test coverage statistics.

	$ go test -cover
	PASS
	coverage: 96.4% of statements
	ok  	strings	0.692s

The `go` tool can generate coverage profiles that may be intepreted by the `cover` tool.

	$ go test -coverprofile=cover.out
	$ go tool cover -func=cover.out
	strings/reader.go:    Len             66.7%
	strings/strings.go:   TrimSuffix     100.0%
	... many lines omitted ...
	strings/strings.go:   Replace        100.0%
	strings/strings.go:   EqualFold      100.0%
	total:                (statements)    96.4%

* Coverage visualization

	$ go tool cover -html=cover.out

.image cover.png

* Setup and teardown
.play -edit setupteardown.go


* Test Main
.play -edit testmain.go


* Testing HTTP clients and servers

The `net/http/httptest` package provides helpers for testing code that makes or serves HTTP requests.


* httptest.Server

An `httptest.Server` listens on a system-chosen port on the local loopback interface, for use in end-to-end HTTP tests.

	type Server struct {
		URL      string // base URL of form http://ipaddr:port with no trailing slash
		Listener net.Listener

		// TLS is the optional TLS configuration, populated with a new config
		// after TLS is started. If set on an unstarted server before StartTLS
		// is called, existing fields are copied into the new config.
		TLS *tls.Config

		// Config may be changed after calling NewUnstartedServer and
		// before Start or StartTLS.
		Config *http.Server
	}

	func NewServer(handler http.Handler) *Server

	func (*Server) Close() error

* httptest.Server in action

This code sets up a temporary HTTP server that serves a simple "Hello" response.

.play httpserver.go /START OMIT/,/STOP OMIT/


* httptest.ResponseRecorder

`httptest.ResponseRecorder` is an implementation of `http.ResponseWriter` that records its mutations for later inspection in tests.

	type ResponseRecorder struct {
		Code      int           // the HTTP response code from WriteHeader
		HeaderMap http.Header   // the HTTP response headers
		Body      *bytes.Buffer // if non-nil, the bytes.Buffer to append written data to
		Flushed   bool
	}

* httptest.ResponseRecorder in action

By passing a `ResponseRecorder` into an HTTP handler we can inspect the generated response.

.play httprecorder.go /START OMIT/,/STOP OMIT/

* In Action
.play table_test2.go /START OMIT/,/END OMIT/

* Race Detection

A data race occurs when two goroutines access the same variable concurrently and at least one of the accesses is a write.

To help diagnose such bugs, Go includes a built-in data race detector.

Pass the `-race` flag to the go tool to enable the race detector:

	$ go test -race mypkg    // to test the package
	$ go run -race mysrc.go  // to run the source file
	$ go build -race mycmd   // to build the command
	$ go install -race mypkg // to install the package

* Fixtures
- Fixtures allow us to reliably and repeatably create the state that our code relies on, without worrying about the details
- golang will ignore all the files in testdata

.play -edit fixtures.go /START OMIT/,/END OMIT/

* Golden
- Golden files contain the expected output of a test
- Read the contents of the golden file and compare it to the output of the unit under test

.play -edit golden.go /START OMIT/,/END OMIT/

* Golden files
- Empty
	| Title         | Author        | Publisher |  Pages  |  ISBN  |  Price  |
	| ------------- | ------------- | --------- | ------- | ------ | ------- |

- Inventory
	| Title         | Author        | Publisher |  Pages  |  ISBN  |  Price  |
	| ------------- | ------------- | --------- | ------- | ------ | ------- |
	| The Da Vinci Code | Dan Brown | Corgi | 592 | 978-0552161275 | 7 |
	| American on Purpose | Craig Ferguson | Harper Collins | 288 | 978-0061959158 | 19 |

* Golden(cont)

.play golden2.go /START OMIT/,/END OMIT/

* Golden(cont)
	var (
		update = flag.Bool("update", false, "update the golden files of this test")
	)


	func goldenValue(t *testing.T, goldenFile string, actual string, update bool) string {
		t.Helper()
		goldenPath := "testdata/" + goldenFile + ".golden"

		f, _ := os.OpenFile(goldenPath, os.O_RDWR, 0644)
		defer f.Close()

		if update {
			_, err := f.WriteString(actual)
			if err != nil {
				t.Fatalf("Error writing to file %s: %s", goldenPath, err)
			}

			return actual
		}

		content, err := ioutil.ReadAll(f)
		if err != nil {
			t.Fatalf("Error opening file %s: %s", goldenPath, err)
		}
		return string(content)
	}

* Golden(cont)

.play golden3.go /START OMIT/,/END OMIT/

* Mock
- Programming against interfaces not implementation

For example, if you're writing a file format parser, don't write a function like this:

		func Parse(f *os.File) error

instead, write functions that take the interface you need:

	func Parse(r io.Reader) error

(An `*os.File` implements `io.Reader`, as does `bytes.Buffer` or `strings.Reader`.)


* Fuzzing
- Fuzzing is a testing technique that loads our program with random data
- https://github.com/google/gofuzz

.play -edit fuzzing.go /START OMIT/,/END OMIT/