Automate the Boring Stuff with Go, Ch. 15: Testing and Debugging

// a function worth testing: turn a title into a URL slug
package main

import (
	"fmt"
	"strings"
	"unicode"
)

// Slugify lower-cases, keeps letters and digits, and joins words with single hyphens.
func Slugify(title string) string {
	var b strings.Builder
	lastHyphen := true // so we never start with one
	for _, r := range strings.ToLower(title) {
		switch {
		case unicode.IsLetter(r) || unicode.IsDigit(r):
			b.WriteRune(r)
			lastHyphen = false
		case !lastHyphen:
			b.WriteByte('-')
			lastHyphen = true
		}
	}
	return strings.TrimSuffix(b.String(), "-")
}

func main() {
	fmt.Println(Slugify("Automate the Boring Stuff with Go, Ch. 15: Testing!"))
}

package main

import "testing"

// A table-driven test: one slice of cases, one loop, one failure message that names the
// case. Adding a case is adding a line.
func TestSlugify(t *testing.T) {
	cases := []struct {
		name, in, want string
	}{
		{"simple", "Hello World", "hello-world"},
		{"punctuation", "Ch. 15: Testing!", "ch-15-testing"},
		{"runs of separators", "a  --  b", "a-b"},
		{"leading and trailing", " -x- ", "x"},
		{"unicode letters", "Café Olé", "café-olé"},
		{"empty", "", ""},
	}
	for _, c := range cases {
		t.Run(c.name, func(t *testing.T) {
			if got := Slugify(c.in); got != c.want {
				t.Errorf("Slugify(%q) = %q, want %q", c.in, got, c.want)
			}
		})
	}
}

// Reverse a string by characters, not bytes. The fuzz test next door tries to break it.
package main

import "fmt"

// Reverse returns s with its runes in reverse order.
func Reverse(s string) string {
	r := []rune(s)
	for i, j := 0, len(r)-1; i < j; i, j = i+1, j-1 {
		r[i], r[j] = r[j], r[i]
	}
	return string(r)
}

func main() {
	fmt.Println(Reverse("Hello, 世界"))
}

package main

import (
	"testing"
	"unicode/utf8"
)

// A fuzz test states a property that must hold for ANY input, and lets Go invent inputs.
// Run the seeds only: go test ./ch15/examples/fuzz
// Fuzz for ten seconds:  go test -fuzz=FuzzReverse -fuzztime=10s ./ch15/examples/fuzz
func FuzzReverse(f *testing.F) {
	for _, seed := range []string{"", "a", "Hello, 世界", "!12345"} {
		f.Add(seed)
	}
	f.Fuzz(func(t *testing.T, s string) {
		if !utf8.ValidString(s) {
			t.Skip("not valid UTF-8; reversing bytes of a broken string is undefined")
		}
		twice := Reverse(Reverse(s))
		if twice != s {
			t.Errorf("Reverse(Reverse(%q)) = %q", s, twice)
		}
		if utf8.RuneCountInString(Reverse(s)) != utf8.RuneCountInString(s) {
			t.Errorf("Reverse(%q) changed the character count", s)
		}
	})
}

// two ways to build a big string; the benchmark says which is faster and by how much
package main

import (
	"fmt"
	"strings"
)

func joinWithPlus(parts []string) string {
	s := ""
	for _, p := range parts {
		s += p + "\n"
	}
	return s
}

func joinWithBuilder(parts []string) string {
	var b strings.Builder
	for _, p := range parts {
		b.WriteString(p)
		b.WriteByte('\n')
	}
	return b.String()
}

func main() {
	parts := []string{"one", "two", "three"}
	fmt.Print(joinWithPlus(parts), joinWithBuilder(parts))
}

package main

import (
	"fmt"
	"testing"
)

// go test -bench=. -benchmem ./ch15/examples/benchmark
var parts = func() []string {
	p := make([]string, 2000)
	for i := range p {
		p[i] = fmt.Sprintf("line number %d of the report", i)
	}
	return p
}()

func BenchmarkJoinWithPlus(b *testing.B) {
	for b.Loop() {
		joinWithPlus(parts)
	}
}

func BenchmarkJoinWithBuilder(b *testing.B) {
	for b.Loop() {
		joinWithBuilder(parts)
	}
}

func TestBothAgree(t *testing.T) {
	if joinWithPlus(parts) != joinWithBuilder(parts) {
		t.Fatal("the two implementations differ")
	}
}

go test -cover ./...                                  # what share of lines the tests ran
go test -coverprofile=cover.out ./ch8/... && go tool cover -html=cover.out   # which lines, in your browser
go test -race ./...                                   # chapter 14's data-race detector
go vet ./...                                          # mistakes the compiler accepts

// log/slog: log lines with fields a program (or a grep) can read later
package main

import (
	"errors"
	"log/slog"
	"os"
	"time"
)

func main() {
	// the default logger writes readable text to stderr
	slog.Info("backup started", "folder", "/Users/you/Documents", "files", 1284)
	slog.Warn("skipping unreadable file", "path", "/Users/you/Documents/locked.xlsx")

	// a JSON logger to a file is what you want for a scheduled job
	f, err := os.CreateTemp("", "run-*.log")
	if err != nil {
		slog.Error("cannot open log", "err", err)
		os.Exit(1)
	}
	defer os.Remove(f.Name())
	logger := slog.New(slog.NewJSONHandler(f, &slog.HandlerOptions{Level: slog.LevelDebug}))
	logger = logger.With("job", "nightly-backup", "run_id", time.Now().Format("20060102-150405"))

	logger.Debug("walking tree")
	logger.Info("done", "took", 4200*time.Millisecond, "bytes", 93_123_440)
	logger.Error("upload failed", "err", errors.New("connection reset"), "attempt", 3)

	f.Close()
	data, _ := os.ReadFile(f.Name())
	os.Stdout.Write(data)
}

// what a panic is, what it prints, and the one place recover belongs
package main

import (
	"fmt"
	"os"
	"runtime/debug"
)

// process stands in for work on one item that might blow up on bad data.
func process(item []int) int {
	return item[0] * 2 // panics when item is empty: index out of range
}

// safely runs fn and turns a panic into an error, so one bad item does not take down
// the loop that is processing a thousand of them. This is the legitimate use of recover.
func safely(fn func() int) (result int, err error) {
	defer func() {
		if r := recover(); r != nil {
			err = fmt.Errorf("recovered: %v\n%s", r, debug.Stack())
		}
	}()
	return fn(), nil
}

func main() {
	items := [][]int{{1}, {}, {3}}
	for i, item := range items {
		result, err := safely(func() int { return process(item) })
		if err != nil {
			fmt.Fprintf(os.Stderr, "item %d failed: %v\n", i, err)
			continue
		}
		fmt.Printf("item %d -> %d\n", i, result)
	}
	fmt.Println("the loop survived")
}

go install github.com/go-delve/delve/cmd/dlv@latest
dlv debug ./ch13/projects/every -- -times 1 -- date
(dlv) break main.RunOnce
(dlv) continue
(dlv) print timeout
(dlv) next

// retry runs an operation again when it fails, waiting longer each time, up to a limit.
// Networks fail for a second and come back; a script that gives up at the first error is
// a script you have to babysit. The demo talks to a local server that fails twice first.
//
//	go run ./ch15/projects/retry
package main

import (
	"context"
	"errors"
	"fmt"
	"log/slog"
	"net/http"
	"net/http/httptest"
	"os"
	"sync/atomic"
	"time"
)

// Policy says how many attempts to make and how long to wait after the first failure;
// each later wait doubles, up to MaxWait.
type Policy struct {
	Attempts int
	Wait     time.Duration
	MaxWait  time.Duration
	Sleep    func(context.Context, time.Duration) error // swapped out in tests
}

// Do runs op until it returns nil, the attempts run out, or the context ends. The error
// returned is the last one op produced, wrapped with the attempt count.
func (p Policy) Do(ctx context.Context, op func() error) error {
	sleep := p.Sleep
	if sleep == nil {
		sleep = sleepCtx
	}
	wait := p.Wait
	var last error
	for attempt := 1; attempt <= p.Attempts; attempt++ {
		last = op()
		if last == nil {
			return nil
		}
		if attempt == p.Attempts {
			break
		}
		slog.Warn("attempt failed, retrying", "attempt", attempt, "wait", wait, "err", last)
		if err := sleep(ctx, wait); err != nil {
			return fmt.Errorf("gave up after %d attempt(s): %w (last error: %v)", attempt, err, last)
		}
		wait = min(wait*2, p.MaxWait)
	}
	return fmt.Errorf("gave up after %d attempt(s): %w", p.Attempts, last)
}

func sleepCtx(ctx context.Context, d time.Duration) error {
	select {
	case <-time.After(d):
		return nil
	case <-ctx.Done():
		return ctx.Err()
	}
}

// flakyServer answers 503 to the first n requests and 200 afterwards.
func flakyServer(n int32) *httptest.Server {
	var calls atomic.Int32
	return httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		if calls.Add(1) <= n {
			http.Error(w, "warming up", http.StatusServiceUnavailable)
			return
		}
		fmt.Fprintln(w, "ok, here is your data")
	}))
}

func run() error {
	srv := flakyServer(2)
	defer srv.Close()

	client := &http.Client{Timeout: 5 * time.Second}
	policy := Policy{Attempts: 5, Wait: 200 * time.Millisecond, MaxWait: 2 * time.Second}

	var body []byte
	err := policy.Do(context.Background(), func() error {
		resp, err := client.Get(srv.URL)
		if err != nil {
			return err
		}
		defer resp.Body.Close()
		if resp.StatusCode != http.StatusOK {
			return errors.New(resp.Status)
		}
		body = make([]byte, 64)
		n, _ := resp.Body.Read(body)
		body = body[:n]
		return nil
	})
	if err != nil {
		return err
	}
	fmt.Printf("got: %s", body)
	return nil
}

func main() {
	if err := run(); err != nil {
		fmt.Fprintln(os.Stderr, "error:", err)
		os.Exit(1)
	}
}