From 22e8f3548a72c78deccedc5a65c1cba029f52e6d Mon Sep 17 00:00:00 2001 From: Stefan Majewsky Date: Mon, 17 Aug 2026 22:56:47 +0200 Subject: add testing/microprom, initial parity with promhttp --- internal/accept/accept.go | 127 ++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 127 insertions(+) create mode 100644 internal/accept/accept.go (limited to 'internal') diff --git a/internal/accept/accept.go b/internal/accept/accept.go new file mode 100644 index 0000000..5e35f45 --- /dev/null +++ b/internal/accept/accept.go @@ -0,0 +1,127 @@ +// SPDX-FileCopyrightText: 2026 Stefan Majewsky +// SPDX-License-Identifier: Apache-2.0 + +// TODO: unit test coverage (use the examples from RFC 9110) +package accept + +import ( + "cmp" + "mime" + "regexp" + "slices" + "strconv" + "strings" + + . "go.xyrillian.de/gg/option" +) + +// Header contains a parsed set of "Accept" HTTP headers [RFC 9110, 12.5.1]. +type Header struct { + options []option +} + +type option struct { + MediaType string + Params map[string]string + Weight float64 +} + +var weightRx = regexp.MustCompile(`\s*;\s*q=([01](?:\.[0-9]{0,3})?)$`) + +// ParseHeader parses a Set of "Accept" HTTP headers [RFC 9110, 12.5.1]. +// If any part of the header is malformed, an empty Header struct is returned. +func ParseHeader(headers []string) Header { + var ( + result Header + none Header // return in case of errors + ) + for _, header := range headers { + for _, section := range strings.Split(header, ",") { + section = strings.TrimSpace(section) + + // remove weight from `section` while capturing the weight number in `weightStr` + var weightStr string + section = weightRx.ReplaceAllStringFunc(section, func(match string) string { + _, weightStr, _ = strings.Cut(match, "=") + return "" + }) + + mediaType, params, err := mime.ParseMediaType(section) + if err != nil { + return none + } + opt := option{mediaType, params, 1.0} + if weightStr != "" { + opt.Weight, err = strconv.ParseFloat(weightStr, 64) + if err != nil { + return none + } + if opt.Weight > 1.0 { // this boundary is easier to express here than in the regex + return none + } + } + + result.options = append(result.options, opt) + } + } + + // sort options by descending weight to simplify lookups + slices.SortFunc(result.options, func(lhs, rhs option) int { + return cmp.Compare(rhs.Weight, lhs.Weight) + }) + return result +} + +// Negotiate picks from a list of supported media types according to the client's request. +// If h is empty, the first argument is returned (thus the first argument is the server's preference). +// If none of the arguments (the server's options) satisfy the client's request, +// None is returned and a 406 response shall be generated. +func (h Header) Negotiate(mediaTypes ...string) Option[string] { + // parse all `mediaTypes` once + // TODO: if we decide to turn this package into public API, change the API to allow precomputing this + type offer struct { + OriginalValue string + MediaType string + Params map[string]string + } + var offers []offer + for _, mt := range mediaTypes { + mediaType, params, err := mime.ParseMediaType(mt) + if err == nil { + offers = append(offers, offer{mt, mediaType, params}) + } + } + + // we cannot choose from an empty set of options (this can only happen if the + // caller gave us no or only malformed media types) + if len(mediaTypes) == 0 { + return None[string]() + } + + // NOTE: ParseHeader() sorts options by descending weight, so the first match wins. + for _, opt := range h.options { + MEDIATYPE: + for _, offer := range offers { + // can only consider offered media types that match on all requested parameters + for k, v1 := range opt.Params { + if v2, ok := offer.Params[k]; !ok || v1 != v2 { + continue MEDIATYPE + } + } + + // check if offered media type matches requested media type or media type pattern + if opt.MediaType == "*/*" { + return Some(offer.OriginalValue) + } + if category, ok := strings.CutSuffix(opt.MediaType, "/*"); ok { + if rest, ok := strings.CutPrefix(offer.MediaType, category); ok && strings.HasPrefix(rest, "/") { + return Some(offer.OriginalValue) + } + } else if opt.MediaType == offer.MediaType { + return Some(offer.OriginalValue) + } + } + } + + return Some(offers[0].OriginalValue) +} -- cgit v1.3.1 From 5d17264c8ab8042042162f3b968557aabc4976b3 Mon Sep 17 00:00:00 2001 From: Stefan Majewsky Date: Tue, 18 Aug 2026 11:47:38 +0200 Subject: test coverage for internal/accept --- internal/accept/accept.go | 9 +++-- internal/accept/accept_test.go | 81 ++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 88 insertions(+), 2 deletions(-) create mode 100644 internal/accept/accept_test.go (limited to 'internal') diff --git a/internal/accept/accept.go b/internal/accept/accept.go index 5e35f45..5ed6e66 100644 --- a/internal/accept/accept.go +++ b/internal/accept/accept.go @@ -1,7 +1,6 @@ // SPDX-FileCopyrightText: 2026 Stefan Majewsky // SPDX-License-Identifier: Apache-2.0 -// TODO: unit test coverage (use the examples from RFC 9110) package accept import ( @@ -50,10 +49,16 @@ func ParseHeader(headers []string) Header { if err != nil { return none } + if _, ok := params["q"]; ok { + // malformed q-value that was not caught by the regex + return none + } opt := option{mediaType, params, 1.0} if weightStr != "" { opt.Weight, err = strconv.ParseFloat(weightStr, 64) if err != nil { + // defense in depth: unreachable because the regex match has + // extremely constrained grammar for `weightStr` return none } if opt.Weight > 1.0 { // this boundary is easier to express here than in the regex @@ -94,7 +99,7 @@ func (h Header) Negotiate(mediaTypes ...string) Option[string] { // we cannot choose from an empty set of options (this can only happen if the // caller gave us no or only malformed media types) - if len(mediaTypes) == 0 { + if len(offers) == 0 { return None[string]() } diff --git a/internal/accept/accept_test.go b/internal/accept/accept_test.go new file mode 100644 index 0000000..90b6934 --- /dev/null +++ b/internal/accept/accept_test.go @@ -0,0 +1,81 @@ +// SPDX-FileCopyrightText: 2026 Stefan Majewsky +// SPDX-License-Identifier: Apache-2.0 + +package accept_test + +import ( + "testing" + + "go.xyrillian.de/gg/assert" + "go.xyrillian.de/gg/internal/accept" + . "go.xyrillian.de/gg/option" +) + +func TestAcceptWithHeader(t *testing.T) { + 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( + "image/png", // matches with q=0.5 + "text/plain; format=fixed", // matches with q=0.4 + ), Some("image/png")) + + assert.Equal(t, h.Negotiate( + "image/png", // matches with q=0.5 + "text/plain; format=flowed", // matches with q=1.0 + ), Some("text/plain; format=flowed")) + + assert.Equal(t, h.Negotiate( + "text/plain", // matches with q=0.7 + "text/plain; format=flowed", // matches with q=1.0 + ), Some("text/plain; format=flowed")) + + assert.Equal(t, h.Negotiate( + "text/plain", // matches with q=0.7 + "text/plain; format=other", // matches with q=0.3 + ), Some("text/plain")) + + assert.Equal(t, h.Negotiate( + "text/markdown", // matches with q=0.3 + "text/plain", // matches with q=0.3 (but first wins) + ), Some("text/markdown")) +} + +func TestAcceptWithoutHeader(t *testing.T) { + // Negotiate() will always pick the first option + h := accept.ParseHeader(nil) + + assert.Equal(t, h.Negotiate( + "image/png", + "image/jpeg", + ), Some("image/png")) + + assert.Equal(t, h.Negotiate(nil...), None[string]()) + + // malformed media types are ignored + assert.Equal(t, h.Negotiate( + "image/png/foo", + "image/jpeg", + ), Some("image/jpeg")) + + assert.Equal(t, h.Negotiate( + "image/png/foo", + "image/jpeg/foo", + ), None[string]()) +} + +func TestAcceptWithMalformedHeader(t *testing.T) { + for _, brokenHeader := range []string{ + "text/plain, text/markdown/foo", // malformed media type + "text/plain, image/png; q=high", // malformed q-value + "text/plain, image/jpeg; q=1.25", // q-value out of range + } { + h := accept.ParseHeader([]string{brokenHeader}) + + // broken headers are ignored completely, so the first option wins by default + assert.Equal(t, h.Negotiate( + "image/png", + "image/jpeg", + "text/plain", + ), Some("image/png")) + } +} -- 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 'internal') 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