golang-unit-test: my slide

Author: badboyd

count.png

@@ -0,0 +1,5 @@
+% go test -cover
+PASS
+coverage: 92.9% of statements
+ok      size    0.026s
+%

cover.png

@@ -0,0 +1,5 @@
+% go test -cover
+PASS
+coverage: 92.9% of statements
+ok      size    0.026s
+%

coverage.sh

@@ -0,0 +1,151 @@
+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/
+
+* FE
+.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

coverage0.sh

@@ -0,0 +1,26 @@
+package main
+
+import (
+	"fmt"
+	"log"
+	"net/http"
+	"net/http/httptest"
+)
+
+func main() {
+	// START OMIT
+	handler := func(w http.ResponseWriter, r *http.Request) {
+		http.Error(w, "something failed", http.StatusInternalServerError)
+	}
+
+	req, err := http.NewRequest("GET", "http://example.com/foo", nil)
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	w := httptest.NewRecorder()
+	handler(w, req)
+
+	fmt.Printf("%d - %s", w.Code, w.Body.String())
+	// STOP OMIT
+}

golang-unit-test.slide

@@ -0,0 +1,31 @@
+package main
+
+import (
+	"fmt"
+	"io/ioutil"
+	"log"
+	"net/http"
+	"net/http/httptest"
+)
+
+func main() {
+	// START OMIT
+	ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		fmt.Fprintln(w, "Hello, client")
+	}))
+	defer ts.Close()
+
+	res, err := http.Get(ts.URL)
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	greeting, err := ioutil.ReadAll(res.Body)
+	res.Body.Close()
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	fmt.Printf("%s", greeting)
+	// STOP OMIT
+}

httprecorder.go

@@ -0,0 +1,21 @@
+package main
+
+import "testing"
+import "fmt"
+
+func setup() {
+
+}
+func teardown() {
+
+}
+
+func TestX(t *testing.T) {
+	setup()
+	defer teardown()
+
+}
+
+func main() {
+	fmt.Println("man")
+}

httpserver.go

@@ -0,0 +1,66 @@
+package main
+
+import (
+	"io"
+	"io/ioutil"
+	"net/http"
+	"net/http/httptest"
+	"strings"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+// START OMIT
+var tests = []struct {
+	Method       string
+	Path         string
+	Body         io.Reader
+	BodyContains string
+	Status       int
+}{{
+	Method:       "GET",
+	Path:         "/things",
+	BodyContains: "Hello Golang UK Conference",
+	Status:       http.StatusOK,
+}, {
+	Method:       "POST",
+	Path:         "/things",
+	Body:         strings.NewReader(`{"name":"Golang UK Conference"}`),
+	BodyContains: "Hello Golang UK Conference",
+	Status:       http.StatusCreated,
+}}
+
+// END OMIT
+func TestAll(t *testing.T) {
+	assert := assert.New(t)
+	server := httptest.NewServer(&myhandler{}) // HL
+	defer server.Close()                       // HL
+	for _, test := range tests {
+		r, err := http.NewRequest(test.Method, server.URL+test.Path, test.Body) // HL
+		assert.NoError(err)
+		// call handler
+		response, err := http.DefaultClient.Do(r) // HL
+		assert.NoError(err)
+		actualBody, err := ioutil.ReadAll(response.Body)
+		assert.NoError(err)
+		assert.NoError(response.Body.Close())
+		// make assertions
+		assert.Contains(actualBody, test.BodyContains)
+		if test.Status > 0 {
+			assert.Equal(test.Status, response.StatusCode, "status code")
+		}
+	}
+}
+
+type myhandler struct{}
+
+func (h *myhandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
+
+}
+
+func main() {
+	var tests []testing.InternalTest
+	tests = append(tests, testing.InternalTest{Name: "TestAll", F: TestAll})
+	testing.Main(func(pat, str string) (bool, error) { return true, nil }, tests, nil, nil)
+}

setupteardown.go

@@ -0,0 +1,65 @@
+package main
+
+import (
+	"io"
+	"io/ioutil"
+	"net/http"
+	"net/http/httptest"
+	"strings"
+	"testing"
+
+	"github.com/cheekybits/is"
+)
+
+var tests = []struct {
+	Method       string
+	Path         string
+	Body         io.Reader
+	BodyContains string
+	Status       int
+}{{
+	Method:       "GET",
+	Path:         "/things",
+	BodyContains: "Hello Gophers",
+	Status:       http.StatusOK,
+}, {
+	Method:       "POST",
+	Path:         "/things",
+	Body:         strings.NewReader(`{"name":"Gophers"}`),
+	BodyContains: "Hello Gophers",
+	Status:       http.StatusCreated,
+}}
+
+// START OMIT
+func TestAll(t *testing.T) {
+	server := httptest.NewServer(&myhandler{}) // HL
+	defer server.Close()                       // HL
+	for _, test := range tests {
+		t.Run(test.Method+" "+test.Path, func(t *testing.T) {
+			is := is.New(t)
+			r, err := http.NewRequest(test.Method, server.URL+test.Path, test.Body) // HL
+			is.NoErr(err)
+			// call handler
+			response, err := http.DefaultClient.Do(r) // HL
+			is.NoErr(err)
+			actualBody, err := ioutil.ReadAll(response.Body)
+			is.NoErr(err)
+			// make assertions
+			is.True(strings.Contains(string(actualBody), test.BodyContains)) // HL
+			is.Equal(test.Status, response.StatusCode)                       // HL
+		})
+	}
+}
+
+// END OMIT
+type myhandler struct{}
+
+func (h *myhandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
+
+}
+
+func main() {
+	var tests []testing.InternalTest
+	tests = append(tests, testing.InternalTest{Name: "TestAll", F: TestAll})
+	testing.Main(func(pat, str string) (bool, error) { return true, nil }, tests, nil, nil)
+}