clawbot
e4df415676
check / check (push) Successful in 1m57s
When a report would take the report files past DATA_DIR_MAX_BYTES, reportbuf now deletes the oldest report files until it fits, and does the same at start when files left by an earlier run are already past it. A file joins the files that may be deleted, at its place by name, only once it is completely written, so a file still being written is never deleted. A report is refused with 507 only when the reports waiting to be written fill the cap on their own, and then no file is deleted. The reports of a failed write stop counting, and the part of its file written is removed. A file whose deletion fails keeps counting; one already deleted by hand counts as freed. Model: opus-5-5
298 行
7.4 KiB
Go
298 行
7.4 KiB
Go
package handlers_test
|
|
|
|
import (
|
|
"bytes"
|
|
"encoding/json"
|
|
"errors"
|
|
"io"
|
|
"log/slog"
|
|
"net/http"
|
|
"net/http/httptest"
|
|
"strings"
|
|
"testing"
|
|
|
|
"sneak.berlin/go/netwatch/internal/handlers"
|
|
"sneak.berlin/go/netwatch/internal/logger"
|
|
"sneak.berlin/go/netwatch/internal/middleware"
|
|
"sneak.berlin/go/netwatch/internal/reportbuf"
|
|
)
|
|
|
|
var errStorageFailed = errors.New("storage failed")
|
|
|
|
// stubAppender drives the storage success/failure path without a
|
|
// real buffer or disk.
|
|
type stubAppender struct {
|
|
err error
|
|
}
|
|
|
|
func (s stubAppender) Append(any) error { return s.err }
|
|
|
|
func newTestHandlers(buf stubAppender, out io.Writer) *handlers.Handlers {
|
|
return handlers.NewForTest(buf, slog.New(slog.NewJSONHandler(out, nil)))
|
|
}
|
|
|
|
func decodeStatus(t *testing.T, body []byte) string {
|
|
t.Helper()
|
|
|
|
var resp struct {
|
|
Status string `json:"status"`
|
|
}
|
|
|
|
err := json.Unmarshal(body, &resp)
|
|
if err != nil {
|
|
t.Fatalf("response body not JSON: %v (%q)", err, body)
|
|
}
|
|
|
|
return resp.Status
|
|
}
|
|
|
|
// TestHandleReportAcceptsValidReports checks the answer to a valid
|
|
// report, one with no hosts and one shaped as the frontend sends them:
|
|
// 200 and {"status":"ok"} as JSON.
|
|
func TestHandleReportAcceptsValidReports(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
tests := []struct {
|
|
name string
|
|
body string
|
|
}{
|
|
{
|
|
name: "no hosts",
|
|
body: `{"clientId":"c1","geo":null,"hosts":[],` +
|
|
`"timestamp":"2026-10-03T12:00:00.000Z"}`,
|
|
},
|
|
{
|
|
name: "a host with a latency and an error sample",
|
|
body: `{"clientId":"c1","geo":null,"hosts":[{` +
|
|
`"name":"Example","url":"https://example.com/",` +
|
|
`"status":"error","history":[` +
|
|
`{"t":1790000000000,"latency":42,"error":null},` +
|
|
`{"t":1790000003000,"latency":null,"error":"timeout"}]}],` +
|
|
`"timestamp":"2026-10-03T12:00:00.000Z"}`,
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
h := newTestHandlers(stubAppender{}, io.Discard)
|
|
|
|
rec := httptest.NewRecorder()
|
|
req := httptest.NewRequestWithContext(t.Context(),
|
|
http.MethodPost, "/api/v1/reports",
|
|
strings.NewReader(tt.body),
|
|
)
|
|
|
|
h.HandleReport().ServeHTTP(rec, req)
|
|
|
|
if rec.Code != http.StatusOK {
|
|
t.Fatalf("status = %d, want %d", rec.Code, http.StatusOK)
|
|
}
|
|
|
|
contentType := rec.Header().Get("Content-Type")
|
|
if contentType != "application/json; charset=utf-8" {
|
|
t.Errorf("Content-Type = %q, want %q",
|
|
contentType, "application/json; charset=utf-8")
|
|
}
|
|
|
|
if got := rec.Body.String(); got != "{\"status\":\"ok\"}\n" {
|
|
t.Errorf("body = %q, want %q", got, "{\"status\":\"ok\"}\n")
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestHandleReportStorageFailureIsNon2xx(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
h := newTestHandlers(stubAppender{err: errStorageFailed}, io.Discard)
|
|
|
|
rec := httptest.NewRecorder()
|
|
req := httptest.NewRequestWithContext(t.Context(),
|
|
http.MethodPost, "/api/v1/reports",
|
|
strings.NewReader(`{"clientId":"c1","hosts":[]}`),
|
|
)
|
|
|
|
h.HandleReport().ServeHTTP(rec, req)
|
|
|
|
if rec.Code < 500 {
|
|
t.Fatalf("storage failure status = %d, want a 5xx", rec.Code)
|
|
}
|
|
|
|
if got := decodeStatus(t, rec.Body.Bytes()); got != "error" {
|
|
t.Fatalf("status field = %q, want %q", got, "error")
|
|
}
|
|
}
|
|
|
|
// TestHandleReportFullIs507 checks the answer when the reports waiting
|
|
// to be written fill the size cap: 507 and the usual error body, which
|
|
// tells the client nothing more.
|
|
func TestHandleReportFullIs507(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
h := newTestHandlers(stubAppender{err: reportbuf.ErrFull}, io.Discard)
|
|
|
|
rec := httptest.NewRecorder()
|
|
req := httptest.NewRequestWithContext(t.Context(),
|
|
http.MethodPost, "/api/v1/reports",
|
|
strings.NewReader(`{"clientId":"c1","hosts":[]}`),
|
|
)
|
|
|
|
h.HandleReport().ServeHTTP(rec, req)
|
|
|
|
if rec.Code != http.StatusInsufficientStorage {
|
|
t.Fatalf("status = %d, want %d",
|
|
rec.Code, http.StatusInsufficientStorage)
|
|
}
|
|
|
|
if got := rec.Body.String(); got != "{\"status\":\"error\"}\n" {
|
|
t.Errorf("body = %q, want %q", got, "{\"status\":\"error\"}\n")
|
|
}
|
|
}
|
|
|
|
func TestHandleReportMalformedJSONIs400(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
h := newTestHandlers(stubAppender{}, io.Discard)
|
|
|
|
rec := httptest.NewRecorder()
|
|
req := httptest.NewRequestWithContext(t.Context(),
|
|
http.MethodPost, "/api/v1/reports",
|
|
strings.NewReader(`{not json`),
|
|
)
|
|
|
|
h.HandleReport().ServeHTTP(rec, req)
|
|
|
|
if rec.Code != http.StatusBadRequest {
|
|
t.Fatalf("malformed status = %d, want %d",
|
|
rec.Code, http.StatusBadRequest)
|
|
}
|
|
}
|
|
|
|
func TestHandleReportOversizeIs413(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
const limit = 32
|
|
|
|
h := newTestHandlers(stubAppender{}, io.Discard)
|
|
handler := (&middleware.Middleware{}).MaxBodyBytes(limit)(
|
|
h.HandleReport(),
|
|
)
|
|
|
|
rec := httptest.NewRecorder()
|
|
req := httptest.NewRequestWithContext(t.Context(),
|
|
http.MethodPost, "/api/v1/reports",
|
|
strings.NewReader(`{"clientId":"`+strings.Repeat("x", 200)+`"}`),
|
|
)
|
|
// No declared length, so only the middleware's read cap can
|
|
// stop this body.
|
|
req.ContentLength = -1
|
|
|
|
handler.ServeHTTP(rec, req)
|
|
|
|
if rec.Code != http.StatusRequestEntityTooLarge {
|
|
t.Fatalf("oversize status = %d, want %d",
|
|
rec.Code, http.StatusRequestEntityTooLarge)
|
|
}
|
|
}
|
|
|
|
func TestHandleReportDoesNotLogRawGeo(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
const sentinel = "SENSITIVE-GEO-BLOB"
|
|
|
|
var logbuf bytes.Buffer
|
|
|
|
h := newTestHandlers(stubAppender{}, &logbuf)
|
|
|
|
rec := httptest.NewRecorder()
|
|
req := httptest.NewRequestWithContext(t.Context(),
|
|
http.MethodPost, "/api/v1/reports",
|
|
strings.NewReader(
|
|
`{"clientId":"c1","geo":{"raw":"`+sentinel+`"},"hosts":[]}`,
|
|
),
|
|
)
|
|
|
|
h.HandleReport().ServeHTTP(rec, req)
|
|
|
|
if rec.Code != http.StatusOK {
|
|
t.Fatalf("status = %d, want %d", rec.Code, http.StatusOK)
|
|
}
|
|
|
|
if strings.Contains(logbuf.String(), sentinel) {
|
|
t.Fatal("raw geo bytes were written to the log")
|
|
}
|
|
|
|
if !strings.Contains(logbuf.String(), "geo_bytes") {
|
|
t.Fatal("expected a bounded geo_bytes field in the log")
|
|
}
|
|
}
|
|
|
|
func TestHandleReportLogsClientIDCutToBound(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
long := strings.Repeat("c", 2*logger.MaxLoggedFieldBytes)
|
|
|
|
var logbuf bytes.Buffer
|
|
|
|
h := newTestHandlers(stubAppender{}, &logbuf)
|
|
|
|
rec := httptest.NewRecorder()
|
|
req := httptest.NewRequestWithContext(t.Context(),
|
|
http.MethodPost, "/api/v1/reports",
|
|
strings.NewReader(
|
|
`{"clientId":"`+long+`","timestamp":"`+long+`","hosts":[]}`,
|
|
),
|
|
)
|
|
|
|
h.HandleReport().ServeHTTP(rec, req)
|
|
|
|
var logged map[string]any
|
|
|
|
err := json.Unmarshal(logbuf.Bytes(), &logged)
|
|
if err != nil {
|
|
t.Fatalf("log line not JSON: %v (%q)", err, logbuf.String())
|
|
}
|
|
|
|
want := long[:logger.MaxLoggedFieldBytes]
|
|
|
|
if logged["client_id"] != want {
|
|
t.Fatalf("logged client_id not cut to %d bytes: %q",
|
|
logger.MaxLoggedFieldBytes, logged["client_id"])
|
|
}
|
|
|
|
if logged["timestamp"] != want {
|
|
t.Fatalf("logged timestamp not cut to %d bytes: %q",
|
|
logger.MaxLoggedFieldBytes, logged["timestamp"])
|
|
}
|
|
}
|
|
|
|
func TestHandleReportDecodeErrorLogIsBounded(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
// A number too large for its int64 field makes the decoder's
|
|
// error text quote the whole number.
|
|
huge := strings.Repeat("9", 2*logger.MaxLoggedFieldBytes)
|
|
|
|
var logbuf bytes.Buffer
|
|
|
|
h := newTestHandlers(stubAppender{}, &logbuf)
|
|
|
|
rec := httptest.NewRecorder()
|
|
req := httptest.NewRequestWithContext(t.Context(),
|
|
http.MethodPost, "/api/v1/reports",
|
|
strings.NewReader(`{"hosts":[{"history":[{"t":`+huge+`}]}]}`),
|
|
)
|
|
|
|
h.HandleReport().ServeHTTP(rec, req)
|
|
|
|
if rec.Code != http.StatusBadRequest {
|
|
t.Fatalf("status = %d, want %d", rec.Code, http.StatusBadRequest)
|
|
}
|
|
|
|
if strings.Contains(logbuf.String(), huge) {
|
|
t.Fatal("the whole oversized number was written to the log")
|
|
}
|
|
}
|