Initial import from go-httpbin

Makefile

@@ -15,13 +15,19 @@ test:
 # based on codecov.io's documentation:
 # https://github.com/codecov/example-go/blob/b85638743b972bd0bd2af63421fe513c6f968930/README.md
 testci:
-	go test $(TEST_ARGS) $(COVERAGE_ARGS) ./...
+	AUTOBAHN_TESTS=1 go test $(TEST_ARGS) $(COVERAGE_ARGS) ./...
 .PHONY: testci
 
 testcover: testci
 	go tool cover -html=$(COVERAGE_PATH)
 .PHONY: testcover
 
+# Run the autobahn fuzzingclient test suite
+testautobahn:
+	AUTOBAHN_TESTS=1 AUTOBAHN_OPEN_REPORT=1 go test -v -run ^TestWebSocketServer$$ $(TEST_ARGS) ./...
+.PHONY: autobahntests
+
+
 lint:
 	test -z "$$(gofmt -d -s -e .)" || (echo "Error: gofmt failed"; gofmt -d -s -e . ; exit 1)
 	go vet ./...

README.md

@@ -1,24 +1,11 @@
-# go-pkg-template
+# github.com/mccutchen/websocket
 
-[![Documentation](https://pkg.go.dev/badge/github.com/mccutchen/go-pkg-template)](https://pkg.go.dev/github.com/mccutchen/go-pkg-template)
-[![Build status](https://github.com/mccutchen/go-pkg-template/actions/workflows/test.yaml/badge.svg)](https://github.com/mccutchen/go-pkg-template/actions/workflows/test.yaml)
-[![Code coverage](https://codecov.io/gh/mccutchen/go-pkg-template/branch/main/graph/badge.svg)](https://codecov.io/gh/mccutchen/go-pkg-template)
-[![Go report card](http://goreportcard.com/badge/github.com/mccutchen/go-pkg-template)](https://goreportcard.com/report/github.com/mccutchen/go-pkg-template)
+[![Documentation](https://pkg.go.dev/badge/github.com/mccutchen/websocket)](https://pkg.go.dev/github.com/mccutchen/websocket)
+[![Build status](https://github.com/mccutchen/websocket/actions/workflows/test.yaml/badge.svg)](https://github.com/mccutchen/websocket/actions/workflows/test.yaml)
+[![Code coverage](https://codecov.io/gh/mccutchen/websocket/branch/main/graph/badge.svg)](https://codecov.io/gh/mccutchen/websocket)
+[![Go report card](http://goreportcard.com/badge/github.com/mccutchen/websocket)](https://goreportcard.com/report/github.com/mccutchen/websocket)
 
-Template repo for Go packages/libraries
-
-TODO:
-- Replace go-pkg-template with new repo name
-- Add high level description
-- Add usage examples
-- Set up branch protection rules
-  - Require linear history
-  - Require pull requests
-  - Require lint/test CI checks to pass
-- Set up security scanning
-- Maybe:
-  - Update go version in go.mod
-  - Update action versions in .github/workflows/*.yaml
+A minimal Golang implementation of the websocket protocol, extracted from [mccutchen/go-httpbin][].
 
 ## Usage
 
@@ -29,3 +16,5 @@ TK
 ```bash
 make test
 ```
+
+[mccutchen/go-httpbin]: https://github.com/mccutchen/go-httpbin

go.mod

@@ -1,3 +1,3 @@
-module github.com/mccutchen/go-pkg-template
+module github.com/mccutchen/websocket
 
-go 1.23.0
+go 1.21.0

internal/testing/assert/assert.go

@@ -0,0 +1,142 @@
+// Package assert implements common assertions used in go-httbin's unit tests.
+package assert
+
+import (
+	"fmt"
+	"net/http"
+	"reflect"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/mccutchen/websocket/internal/testing/must"
+)
+
+// Equal asserts that two values are equal.
+func Equal[T comparable](t *testing.T, got, want T, msg string, arg ...any) {
+	t.Helper()
+	if got != want {
+		if msg == "" {
+			msg = "expected values to match"
+		}
+		msg = fmt.Sprintf(msg, arg...)
+		t.Fatalf("%s:\nwant: %#v\n got: %#v", msg, want, got)
+	}
+}
+
+// DeepEqual asserts that two values are deeply equal.
+func DeepEqual[T any](t *testing.T, got, want T, msg string, arg ...any) {
+	t.Helper()
+	if !reflect.DeepEqual(got, want) {
+		if msg == "" {
+			msg = "expected values to match"
+		}
+		msg = fmt.Sprintf(msg, arg...)
+		t.Fatalf("%s:\nwant: %#v\n got: %#v", msg, want, got)
+	}
+}
+
+// NilError asserts that an error is nil.
+func NilError(t *testing.T, err error) {
+	t.Helper()
+	if err != nil {
+		t.Fatalf("expected nil error, got %s (%T)", err, err)
+	}
+}
+
+// Error asserts that an error is not nil.
+func Error(t *testing.T, got, expected error) {
+	t.Helper()
+	if got != expected {
+		if got != nil && expected != nil {
+			if got.Error() == expected.Error() {
+				return
+			}
+		}
+		t.Fatalf("expected error %v, got %v", expected, got)
+	}
+}
+
+// StatusCode asserts that a response has a specific status code.
+func StatusCode(t *testing.T, resp *http.Response, code int) {
+	t.Helper()
+	if resp.StatusCode != code {
+		t.Fatalf("expected status code %d, got %d", code, resp.StatusCode)
+	}
+	if resp.StatusCode >= 400 {
+		// Ensure our error responses are never served as HTML, so that we do
+		// not need to worry about XSS or other attacks in error responses.
+		if ct := resp.Header.Get("Content-Type"); !isSafeContentType(ct) {
+			t.Errorf("HTTP %s error served with dangerous content type: %s", resp.Status, ct)
+		}
+	}
+}
+
+func isSafeContentType(ct string) bool {
+	return strings.HasPrefix(ct, "application/json") || strings.HasPrefix(ct, "text/plain") || strings.HasPrefix(ct, "application/octet-stream")
+}
+
+// Header asserts that a header key has a specific value in a response.
+func Header(t *testing.T, resp *http.Response, key, want string) {
+	t.Helper()
+	got := resp.Header.Get(key)
+	if want != got {
+		t.Fatalf("expected header %s=%#v, got %#v", key, want, got)
+	}
+}
+
+// ContentType asserts that a response has a specific Content-Type header
+// value.
+func ContentType(t *testing.T, resp *http.Response, contentType string) {
+	t.Helper()
+	Header(t, resp, "Content-Type", contentType)
+}
+
+// Contains asserts that needle is found in the given string.
+func Contains(t *testing.T, s string, needle string, description string) {
+	t.Helper()
+	if !strings.Contains(s, needle) {
+		t.Fatalf("expected string %q in %s %q", needle, description, s)
+	}
+}
+
+// BodyContains asserts that a response body contains a specific substring.
+func BodyContains(t *testing.T, resp *http.Response, needle string) {
+	t.Helper()
+	body := must.ReadAll(t, resp.Body)
+	Contains(t, body, needle, "body")
+}
+
+// BodyEquals asserts that a response body is equal to a specific string.
+func BodyEquals(t *testing.T, resp *http.Response, want string) {
+	t.Helper()
+	got := must.ReadAll(t, resp.Body)
+	Equal(t, got, want, "incorrect response body")
+}
+
+// BodySize asserts that a response body is a specific size.
+func BodySize(t *testing.T, resp *http.Response, want int) {
+	t.Helper()
+	got := must.ReadAll(t, resp.Body)
+	Equal(t, len(got), want, "incorrect response body size")
+}
+
+// DurationRange asserts that a duration is within a specific range.
+func DurationRange(t *testing.T, got, minVal, maxVal time.Duration) {
+	t.Helper()
+	if got < minVal || got > maxVal {
+		t.Fatalf("expected duration between %s and %s, got %s", minVal, maxVal, got)
+	}
+}
+
+type number interface {
+	~int64 | ~float64
+}
+
+// RoughlyEqual asserts that a numeric value is within a certain tolerance.
+func RoughlyEqual[T number](t *testing.T, got, want T, epsilon T) {
+	t.Helper()
+	if got < want-epsilon || got > want+epsilon {
+		t.Fatalf("expected value between %v and %v, got %v", want-epsilon, want+epsilon, got)
+	}
+}

internal/testing/must/must.go

@@ -0,0 +1,48 @@
+// Package must implements helper functions for testing to eliminate some error
+// checking boilerplate.
+package must
+
+import (
+	"encoding/json"
+	"io"
+	"net/http"
+	"testing"
+	"time"
+)
+
+// DoReq makes an HTTP request and fails the test if there is an error.
+func DoReq(t *testing.T, client *http.Client, req *http.Request) *http.Response {
+	t.Helper()
+	start := time.Now()
+	resp, err := client.Do(req)
+	if err != nil {
+		t.Fatalf("error making HTTP request: %s %s: %s", req.Method, req.URL, err)
+	}
+	t.Logf("HTTP request: %s %s => %s (%s)", req.Method, req.URL, resp.Status, time.Since(start))
+	return resp
+}
+
+// ReadAll reads all bytes from an io.Reader and fails the test if there is an
+// error.
+func ReadAll(t *testing.T, r io.Reader) string {
+	t.Helper()
+	body, err := io.ReadAll(r)
+	if err != nil {
+		t.Fatalf("error reading: %s", err)
+	}
+	if rc, ok := r.(io.ReadCloser); ok {
+		rc.Close()
+	}
+	return string(body)
+}
+
+// Unmarshal unmarshals JSON from an io.Reader into a value and fails the test
+// if there is an error.
+func Unmarshal[T any](t *testing.T, r io.Reader) T {
+	t.Helper()
+	var v T
+	if err := json.NewDecoder(r).Decode(&v); err != nil {
+		t.Fatal(err)
+	}
+	return v
+}