From 50ba9cfb04e257fafa3fdd566f9f70a1986339e8 Mon Sep 17 00:00:00 2001 From: Stefan Majewsky Date: Tue, 18 Aug 2026 11:30:54 +0200 Subject: assert: add Panics, PanicsWith I want to use this for test coverage in microprom. This turned out to be a bigger change than expected because testcapture has a dependency on assert, which I had to invert to be able to use testcapture.Capture() in assert. --- assert/assert.go | 37 ++++--------------------------------- assert/errequal_test.go | 8 ++------ assert/panic.go | 32 ++++++++++++++++++++++++++++++++ assert/panic_test.go | 35 +++++++++++++++++++++++++++++++++++ 4 files changed, 73 insertions(+), 39 deletions(-) create mode 100644 assert/panic.go create mode 100644 assert/panic_test.go (limited to 'assert') diff --git a/assert/assert.go b/assert/assert.go index a13c15e..fe725f6 100644 --- a/assert/assert.go +++ b/assert/assert.go @@ -5,38 +5,9 @@ // Each assertion in this package returns a bool to indicate whether the check succeeded, and logs a t.Error() when the check does not succeed. package assert -import ( - "context" - "io" - "testing" -) +import "go.xyrillian.de/gg/testcapture" // TestingTB contains all the public functions of [testing.TB] (as of Go 1.26). -// Functions in this package use this type instead of [testing.TB] because the capture device used by package testcapture cannot implement [testing.TB]: It contains methods that are private to the standard library. -type TestingTB interface { - ArtifactDir() string - Attr(key, value string) - Chdir(dir string) - Cleanup(func()) - Context() context.Context - Error(args ...any) - Errorf(format string, args ...any) - Fail() - Failed() bool - FailNow() - Fatal(args ...any) - Fatalf(format string, args ...any) - Helper() - Log(args ...any) - Logf(format string, args ...any) - Name() string - Output() io.Writer - Setenv(key, value string) - Skip(args ...any) - Skipf(format string, args ...any) - SkipNow() - Skipped() bool - TempDir() string -} - -var _ TestingTB = testing.TB(nil) +// Functions in this package use this type instead of [testing.TB] to allow +// mocks of [testing.TB] to be substituted in tests for this package. +type TestingTB = testcapture.TestingTB diff --git a/assert/errequal_test.go b/assert/errequal_test.go index b97342a..2cefeab 100644 --- a/assert/errequal_test.go +++ b/assert/errequal_test.go @@ -11,7 +11,6 @@ import ( "testing" "go.xyrillian.de/gg/assert" - "go.xyrillian.de/gg/testcapture" ) func TestErrEqual(t *testing.T) { @@ -67,13 +66,10 @@ func TestErrEqual(t *testing.T) { }, `expected an error matching /foo/, but got no error`) // test matching against unexpected type - result := testcapture.Capture(t.Context(), t.Name(), func(t assert.TestingTB) { + result := assert.PanicsWith[string](t, func() { assert.ErrEqual(t, errors.New("42"), 42) }) - assert.Equal(t, result, testcapture.Result{ - Outcome: testcapture.OutcomePanicked, - Panic: "cannot handle `expected` of type int", - }) + assert.Equal(t, result, "cannot handle `expected` of type int") // an earlier version had a bug because this call caused reflect.Value.IsNil() to be called on a value of kind Struct expectErrors(t, func(t assert.TestingTB) { diff --git a/assert/panic.go b/assert/panic.go new file mode 100644 index 0000000..69828a4 --- /dev/null +++ b/assert/panic.go @@ -0,0 +1,32 @@ +// SPDX-FileCopyrightText: 2026 Stefan Majewsky +// SPDX-License-Identifier: Apache-2.0 + +package assert + +import ( + "go.xyrillian.de/gg/testcapture" +) + +// Panics runs the provided action and fails the test if it does not panic. +// On success, the error value passed to the call of panic is returned. +func Panics(t TestingTB, action func()) any { + return PanicsWith[any](t, action) +} + +// PanicsWith is like Panics(), but also checks if the recovered error value +// is of type T, failing the test if the type assertion fails. +func PanicsWith[T any](t TestingTB, action func()) T { + t.Helper() + result := testcapture.Capture(t.Context(), t.Name(), func(_ TestingTB) { + action() + }) + if result.Outcome != testcapture.OutcomePanicked { + t.Fatal("did not panic") + } + value, ok := result.Panic.(T) + if !ok { + var zero T + t.Fatalf("panicked with incorrect type: expected %T, but got %#v", zero, result.Panic) + } + return value +} diff --git a/assert/panic_test.go b/assert/panic_test.go new file mode 100644 index 0000000..135ce18 --- /dev/null +++ b/assert/panic_test.go @@ -0,0 +1,35 @@ +// SPDX-FileCopyrightText: 2026 Stefan Majewsky +// SPDX-License-Identifier: Apache-2.0 + +package assert_test + +import ( + "testing" + + "go.xyrillian.de/gg/assert" + "go.xyrillian.de/gg/testcapture" +) + +func TestPanics(t *testing.T) { + //only testing error cases here, coverage of the happy path is provided by + //usage of assert.Panics() in actual tests of other packages + tc := testcapture.Capture(t.Context(), t.Name(), func(t assert.TestingTB) { + assert.Panics(t, func() { + // no panic + }) + }) + assert.Equal(t, tc.Outcome, testcapture.OutcomeFailed) + assert.Equal(t, tc.Messages, []testcapture.Message{ + testcapture.Log("did not panic"), + }) + + tc = testcapture.Capture(t.Context(), t.Name(), func(t assert.TestingTB) { + assert.PanicsWith[string](t, func() { + panic(42) + }) + }) + assert.Equal(t, tc.Outcome, testcapture.OutcomeFailed) + assert.Equal(t, tc.Messages, []testcapture.Message{ + testcapture.Log("panicked with incorrect type: expected string, but got 42"), + }) +} -- cgit v1.3.1 From a3ccdd9f491c20771cfda343ebebd4b5d0ea6602 Mon Sep 17 00:00:00 2001 From: Stefan Majewsky Date: Tue, 18 Aug 2026 13:40:20 +0200 Subject: test coverage for microprom --- assert/panic.go | 2 +- assert/panic_test.go | 2 +- internal/accept/accept.go | 7 +- internal/accept/accept_test.go | 13 ++++ microprom/handler_test.go | 142 ++++++++++++++++++++++++++++++++++++++ microprom/labels.go | 2 +- microprom/microprom.go | 2 +- testing/microprom/handler_test.go | 6 -- 8 files changed, 165 insertions(+), 11 deletions(-) create mode 100644 microprom/handler_test.go (limited to 'assert') diff --git a/assert/panic.go b/assert/panic.go index 69828a4..e19b815 100644 --- a/assert/panic.go +++ b/assert/panic.go @@ -26,7 +26,7 @@ func PanicsWith[T any](t TestingTB, action func()) T { value, ok := result.Panic.(T) if !ok { var zero T - t.Fatalf("panicked with incorrect type: expected %T, but got %#v", zero, result.Panic) + t.Fatalf("panicked with incorrect type: expected %T, but got %T: %#v", zero, result.Panic, result.Panic) } return value } diff --git a/assert/panic_test.go b/assert/panic_test.go index 135ce18..a3d6877 100644 --- a/assert/panic_test.go +++ b/assert/panic_test.go @@ -30,6 +30,6 @@ func TestPanics(t *testing.T) { }) assert.Equal(t, tc.Outcome, testcapture.OutcomeFailed) assert.Equal(t, tc.Messages, []testcapture.Message{ - testcapture.Log("panicked with incorrect type: expected string, but got 42"), + testcapture.Log("panicked with incorrect type: expected string, but got int: 42"), }) } diff --git a/internal/accept/accept.go b/internal/accept/accept.go index 5ed6e66..c23905a 100644 --- a/internal/accept/accept.go +++ b/internal/accept/accept.go @@ -103,6 +103,11 @@ func (h Header) Negotiate(mediaTypes ...string) Option[string] { return None[string]() } + // if nothing was offered, we default to our own preferred option + if len(h.options) == 0 { + return Some(offers[0].OriginalValue) + } + // NOTE: ParseHeader() sorts options by descending weight, so the first match wins. for _, opt := range h.options { MEDIATYPE: @@ -128,5 +133,5 @@ func (h Header) Negotiate(mediaTypes ...string) Option[string] { } } - return Some(offers[0].OriginalValue) + return None[string]() } diff --git a/internal/accept/accept_test.go b/internal/accept/accept_test.go index 90b6934..edfef42 100644 --- a/internal/accept/accept_test.go +++ b/internal/accept/accept_test.go @@ -12,6 +12,7 @@ import ( ) func TestAcceptWithHeader(t *testing.T) { + // asking for a wide range of formats, including wildcard matches h := accept.ParseHeader([]string{"text/*;q=0.3, text/plain;format=flowed, text/plain;format=fixed;q=0.4, */*;q=0.5"}) assert.Equal(t, h.Negotiate( @@ -38,6 +39,18 @@ func TestAcceptWithHeader(t *testing.T) { "text/markdown", // matches with q=0.3 "text/plain", // matches with q=0.3 (but first wins) ), Some("text/markdown")) + + // asking for specific formats only + h = accept.ParseHeader([]string{"image/png, image/jpeg"}) + + assert.Equal(t, h.Negotiate( + "text/plain", + "image/png", + ), Some("image/png")) + + assert.Equal(t, h.Negotiate( + "text/plain", + ), None[string]()) } func TestAcceptWithoutHeader(t *testing.T) { diff --git a/microprom/handler_test.go b/microprom/handler_test.go new file mode 100644 index 0000000..7278945 --- /dev/null +++ b/microprom/handler_test.go @@ -0,0 +1,142 @@ +// SPDX-FileCopyrightText: 2026 Stefan Majewsky +// SPDX-License-Identifier: Apache-2.0 + +package microprom_test + +import ( + "context" + "errors" + "io" + "maps" + "net/http" + "net/http/httptest" + "strings" + "testing" + + "go.xyrillian.de/gg/assert" + "go.xyrillian.de/gg/microprom" +) + +func TestHandlerBasic(t *testing.T) { + // NOTE: Most happy path coverage is in `./testing/microprom`. + // This only covers the SortOutput = false case. + + h := microprom.Handler{ + Families: map[microprom.MetricFamilyName]microprom.MetricFamilyInfo{ + "process": { + Type: microprom.MetricTypeInfo, + Help: "Information about this process.", + }, + "foo": { + Type: microprom.MetricTypeGauge, + Help: "This metric family will not have any collected metrics and thus go unreported.", + }, + }, + Collect: func(ctx context.Context, ms *microprom.MetricSet) error { + names := microprom.NewLabelNames("version") + labels := ms.FormatLabels(names, "1.2.3") + ms.Add("process", labels, 1.0) + return nil + }, + } + + // test normal behavior + status, body, headers := getMetrics(t, h, nil) + assert.Equal(t, status, http.StatusOK) + assert.Equal(t, headers, http.Header{ + "Content-Type": {"text/plain; version=0.0.4; charset=utf-8; escaping=underscores"}, + }) + assert.Equal(t, body, strings.TrimSpace(` +# HELP process_info Information about this process. +# TYPE process_info info +process_info{version="1.2.3"} 1 + `)+"\n") +} + +func TestHandlerErrors(t *testing.T) { + h := microprom.Handler{ + Families: map[microprom.MetricFamilyName]microprom.MetricFamilyInfo{ + "process": { + Type: microprom.MetricTypeInfo, + Help: "Information about this process.", + }, + }, + Collect: func(ctx context.Context, ms *microprom.MetricSet) error { + return errors.New("kaboom") + }, + } + + // test unacceptable content negotiation + status, body, headers := getMetrics(t, h, http.Header{"Accept": {"application/json"}}) + assert.Equal(t, status, http.StatusNotAcceptable) + assert.Equal(t, headers.Get("Content-Type"), "text/plain; charset=utf-8") + assert.Equal(t, body, "supported formats are text/plain and application/openmetrics-text\n") + + // test error during h.Collect() + status, body, headers = getMetrics(t, h, nil) + assert.Equal(t, status, http.StatusInternalServerError) + assert.Equal(t, headers.Get("Content-Type"), "text/plain; charset=utf-8") + assert.Equal(t, body, "kaboom\n") + + // test panic from invalid metric family name + h.Families["what is this?"] = microprom.MetricFamilyInfo{ + Type: microprom.MetricTypeGauge, + Help: "invalid metric family name", + } + msg := assert.PanicsWith[string](t, func() { getMetrics(t, h, nil) }) + assert.Equal(t, msg, `in family "what is this?": invalid family name (does not match /^[a-zA-Z_:][a-zA-Z0-9_:]*$/)`) + delete(h.Families, "what is this?") + + // test panic from invalid metric type + h.Families["invalid"] = microprom.MetricFamilyInfo{ + Type: 100, + Help: "invalid metric type", + } + msg = assert.PanicsWith[string](t, func() { getMetrics(t, h, nil) }) + assert.Equal(t, msg, `in family "invalid": invalid value for microprom.MetricType: 100`) + delete(h.Families, "invalid") + + // test panic from invalid label name + h.Collect = func(ctx context.Context, ms *microprom.MetricSet) error { + names := microprom.NewLabelNames("app:version") + labels := ms.FormatLabels(names, "1.2.3") + ms.Add("process", labels, 1.0) + return nil + } + msg = assert.PanicsWith[string](t, func() { getMetrics(t, h, nil) }) + assert.Equal(t, msg, `invalid label name: "app:version"`) + + // test panic from wrong number of label values + h.Collect = func(ctx context.Context, ms *microprom.MetricSet) error { + names := microprom.NewLabelNames("version", "build_date") + labels := ms.FormatLabels(names, "1.2.3") // forgot build_date + ms.Add("process", labels, 1.0) + return nil + } + msg = assert.PanicsWith[string](t, func() { getMetrics(t, h, nil) }) + assert.Equal(t, msg, `expected 2 label values, but got 1`) + + // test panic from using an undeclared metric family + h.Collect = func(ctx context.Context, ms *microprom.MetricSet) error { + ms.Add("invalid", "", 1.0) + return nil + } + msg = assert.PanicsWith[string](t, func() { getMetrics(t, h, nil) }) + assert.Equal(t, msg, `no such family: invalid`) +} + +func getMetrics(t *testing.T, h http.Handler, requestHeaders http.Header) (status int, responseBody string, responseHeaders http.Header) { + t.Helper() + r := httptest.NewRequestWithContext(t.Context(), http.MethodGet, "/metrics", nil) + maps.Copy(r.Header, requestHeaders) + + w := httptest.NewRecorder() + h.ServeHTTP(w, r) + resp := w.Result() + + buf, err := io.ReadAll(resp.Body) + if err != nil { + t.Fatal(err.Error()) + } + return resp.StatusCode, string(buf), resp.Header +} diff --git a/microprom/labels.go b/microprom/labels.go index 51cdbb1..5b56c9c 100644 --- a/microprom/labels.go +++ b/microprom/labels.go @@ -54,7 +54,7 @@ func (ms *MetricSet) FormatLabels(n LabelNames, values ...string) Labels { // NOTE on API structure: This is not part of ms.Add() to allow reusing label sets for multiple metrics. if len(n.names) != len(values) { - panic("arguments are not of equal length") + panic(fmt.Sprintf("expected %d label values, but got %d", len(n.names), len(values))) } if len(n.names) == 0 { return "" diff --git a/microprom/microprom.go b/microprom/microprom.go index 86a5419..4055c8b 100644 --- a/microprom/microprom.go +++ b/microprom/microprom.go @@ -135,7 +135,7 @@ func NewMetricSet(syntax Syntax, families map[MetricFamilyName]MetricFamilyInfo) func (ms *MetricSet) Add(name MetricFamilyName, labels Labels, value float64) { _, ok := ms.metrics[name] if !ok { - panic("no such family: " + name) + panic("no such family: " + string(name)) } ms.metrics[name] = append(ms.metrics[name], metric{labels, value}) } diff --git a/testing/microprom/handler_test.go b/testing/microprom/handler_test.go index 6aa60f0..93027e3 100644 --- a/testing/microprom/handler_test.go +++ b/testing/microprom/handler_test.go @@ -76,12 +76,6 @@ func TestHandlerFunctionallyIdenticalToPromhttp(t *testing.T) { body2, headers2 = getMetrics(t, h2, http.Header{"Accept": {"application/openmetrics-text; version=1.0.0"}}) assert.Equal(t, strings.Split(body1, "\n"), strings.Split(body2, "\n")) assert.Equal(t, headers1, headers2) - - // test invalid Accept header - body1, headers1 = getMetrics(t, h1, http.Header{"Accept": {"image/*"}}) - body2, headers2 = getMetrics(t, h2, http.Header{"Accept": {"image/*"}}) - assert.Equal(t, strings.Split(body1, "\n"), strings.Split(body2, "\n")) - assert.Equal(t, headers1, headers2) } func getMetrics(t *testing.T, h http.Handler, requestHeaders http.Header) (responseBody string, responseHeaders http.Header) { -- cgit v1.3.1