Files
archie/internal/webui/api_capture_test.go
T
sam 2b102b04a2 feat(state-store): generalize storerpc as the State Store gRPC contract (archie-core-8cda.4.2) (#770)
* feat(state-store): generalize storerpc as the State Store gRPC contract

Implements archie-core-8cda.4.2 against docs/prds/state-store-contract.md
rev. 2c: generate protobuf/gRPC client and server adapters for every
ratified store contract (proto/state/v1/state.proto, 40 RPCs, one
StateStoreService), add internal/infrastructure/staterpc with a bufconn
conformance suite exercising both local and remote adapters, serve the
service in-process (bridge address + mandatory per-task bearer token when
agent containers exist, loopback-only otherwise), and flip archie-agent's
workflow.Store to a long-lived gRPC client when the daemon injects
STATE_STORE_URL/STATE_STORE_TOKEN (falling back to the legacy NATS
storerpc path otherwise -- one agent process is never both).

Also drops the *sql.Tx parameter from store.BindingDispatcher.RecordDispatch
(a required wire-blocker fix: a transaction cannot cross a gRPC boundary,
and production always passed nil).

fix(store): drop RecordDispatch's unusable *sql.Tx parameter
feat(config): add services.state contract-adapter selector

* fix(state-store): apply no-mistakes review decisions

- Drop StreamTokenInterceptor (unused; the State Store service has no
  streaming RPCs and nothing calls it).
- Make StateStoreTokens.Validate compare tokens in constant time
  (crypto/subtle) per the auto-fix hardening.ing finding.
- Amend config.example.toml / config.Services.State doc text so it frames
  [services.state].target as the ratified surface consumed by the upcoming
  standalone archie-state-store binary (.4.3), not active today.
2026-09-07 03:01:33 +10:00

780 lines
29 KiB
Go

package webui
import (
"context"
"crypto/hmac"
"crypto/sha256"
"encoding/hex"
"encoding/json"
"errors"
"log/slog"
"net/http"
"net/http/httptest"
"path/filepath"
"strings"
"testing"
"time"
"github.com/samcharles93/archie-core/internal/domain/binding"
"github.com/samcharles93/archie-core/internal/events"
"github.com/samcharles93/archie-core/internal/store"
"github.com/samcharles93/archie-core/internal/webhookguard"
)
// recordingPublisher captures every event.Publish call so a test can assert
// a capture reached the live SSE pipeline without standing up a real
// streaming HTTP connection.
type recordingPublisher struct {
published []events.Event
}
func (r *recordingPublisher) Publish(e events.Event) {
r.published = append(r.published, e)
}
// captureTestServer builds a Server whose Captures field points at the same
// concrete *store.Store as Store, so tests can assert on persisted rows
// through the narrower CaptureStore interface -- Server.Store's static type
// (store.TaskStore) does not expose InsertCapture/ListCaptures.
func captureTestServer(t *testing.T) *Server {
t.Helper()
s, err := store.Open(t.Context(), filepath.Join(t.TempDir(), "test.db"))
if err != nil {
t.Fatal(err)
}
t.Cleanup(func() { _ = s.Close() })
return &Server{
Store: s,
Log: slog.New(slog.DiscardHandler),
Captures: s,
CaptureMaxBodyBytes: 1024,
CaptureRetention: 7 * 24 * time.Hour,
CaptureMaxEvents: 100,
CaptureLimiter: webhookguard.NewRateLimiter(1000, 1000, time.Now),
}
}
// stubBindingStore injects a configurable armed-binding lookup result so
// handleCapture tests can exercise the single-binding HMAC path and the
// belt-and-braces 409-on-multiple path without seeding the real store
// (which would either run into the overlap-rejection guard or require
// bypassing the draft -> pending_approval -> armed lifecycle). The 409
// path exists exactly for the case where the write-time check was
// bypassed somehow, so simulating that case directly is the most honest
// way to cover it.
type stubBindingStore struct {
armedBySource map[string][]binding.Binding
lookupErr error
}
func (s *stubBindingStore) ArmedBindingsForSource(_ context.Context, source string) ([]binding.Binding, error) {
if s.lookupErr != nil {
return nil, s.lookupErr
}
return s.armedBySource[source], nil
}
// handleCapture only touches ArmedBindingsForSource on the binding
// surface. The rest of BindingStore is stubbed so the type satisfies the
// interface and Phase C's other handlers can be exercised elsewhere.
func (s *stubBindingStore) InsertBinding(_ context.Context, _ binding.Binding) (int64, error) {
return 0, nil
}
func (s *stubBindingStore) GetBinding(_ context.Context, _ int64) (*binding.Binding, error) {
return nil, nil
}
func (s *stubBindingStore) ListBindings(_ context.Context) ([]binding.Binding, error) {
return nil, nil
}
func (s *stubBindingStore) UpdateBinding(_ context.Context, _ binding.Binding) error {
return nil
}
func (s *stubBindingStore) DeleteBinding(_ context.Context, _ int64) error {
return nil
}
func (s *stubBindingStore) ApproveBinding(_ context.Context, _ int64) error {
return nil
}
func (s *stubBindingStore) RecordDispatch(
_ context.Context,
_ int64,
_ int64,
_ int64,
_ int64,
) error {
return nil
}
func (s *stubBindingStore) ListUndispatchedCaptures(_ context.Context, _ []string, _ int) ([]store.CapturedEvent, error) {
return nil, nil
}
// captureBindingServer builds a Server with both a real CaptureStore (so
// ListCaptures can read back what handleCapture persisted) and a stub
// BindingDispatcher configured with one armed binding for the given
// source. The mapping/workflow fields are placeholders -- handleCapture
// never reads them, only the Secret.
func captureBindingServer(t *testing.T, secret, source string) *Server {
t.Helper()
srv := captureTestServer(t)
srv.BindingDispatcher = &stubBindingStore{
armedBySource: map[string][]binding.Binding{
source: {{
ID: 1,
Name: "test",
Matcher: binding.Matcher{Source: source},
MappingID: 1,
Workflow: "implement",
Version: 1,
Status: binding.StatusArmed,
Secret: secret,
}},
},
}
return srv
}
// hmacSHA256 returns the GitHub-style "sha256=<hex>" signature for body
// under secret, the same form webhookguard.VerifyHMAC accepts.
func hmacSHA256(secret, body string) string {
mac := hmac.New(sha256.New, []byte(secret))
mac.Write([]byte(body))
return "sha256=" + hex.EncodeToString(mac.Sum(nil))
}
func TestHandleCaptureStoresRedactedBody(t *testing.T) {
srv := captureTestServer(t)
body := `{"action":"opened","sender":{"token":"shh-secret"}}`
req := httptest.NewRequestWithContext(t.Context(), http.MethodPost, "/webhooks/capture/github", strings.NewReader(body))
req.Header.Set("Content-Type", "application/json")
w := httptest.NewRecorder()
srv.Handler().ServeHTTP(w, req)
if w.Code != http.StatusAccepted {
t.Fatalf("status = %d, want %d; body = %s", w.Code, http.StatusAccepted, w.Body.String())
}
got, err := srv.Captures.ListCaptures(t.Context(), 10)
if err != nil {
t.Fatalf("ListCaptures: %v", err)
}
if len(got) != 1 {
t.Fatalf("captured rows = %d, want 1", len(got))
}
c := got[0]
if c.Source != "github" {
t.Errorf("Source = %q, want %q", c.Source, "github")
}
if c.ContentType != "application/json" {
t.Errorf("ContentType = %q, want application/json", c.ContentType)
}
if strings.Contains(c.Body, "shh-secret") {
t.Errorf("Body = %q, want the token value redacted", c.Body)
}
if !strings.Contains(c.Body, `"action":"opened"`) {
t.Errorf("Body = %q, want the non-sensitive field preserved", c.Body)
}
}
// TestHandleCapturePublishesLiveEventOnSuccess pins the "no manual refresh"
// acceptance criterion's actual mechanism: a successful capture must reach
// the existing operator-activity event pipeline (Server.emit -> Events.Publish)
// with Kind "capture" so the dashboard's event inspector knows to refetch.
// This does not open a real SSE connection -- it asserts what handleCapture
// hands to the publisher, which is the part this feature actually adds;
// Broadcast/handleSSE themselves are pre-existing and separately tested.
//
// The published event is deliberately LIGHTWEIGHT (id + source only, no
// body/headers): the events table this feeds (internal/store/events.go) has
// no retention or row-count prune, unlike captured_events, so embedding the
// full (up to CaptureMaxBodyBytes) payload here would duplicate it into an
// unbounded table and defeat the disk-bound guarantee InsertCapture's own
// prune-on-write exists to provide. See docs/prds/event-capture-storage.md.
func TestHandleCapturePublishesLiveEventOnSuccess(t *testing.T) {
srv := captureTestServer(t)
pub := &recordingPublisher{}
srv.Events = pub
req := httptest.NewRequestWithContext(t.Context(), http.MethodPost, "/webhooks/capture/github", strings.NewReader(`{"action":"opened"}`))
w := httptest.NewRecorder()
srv.Handler().ServeHTTP(w, req)
if w.Code != http.StatusAccepted {
t.Fatalf("status = %d, want %d", w.Code, http.StatusAccepted)
}
if len(pub.published) != 1 {
t.Fatalf("published events = %d, want 1", len(pub.published))
}
e := pub.published[0]
if e.Kind != "capture" {
t.Fatalf("Kind = %q, want \"capture\"", e.Kind)
}
if e.ID == 0 {
t.Fatalf("ID = 0, want the persisted events-table row id")
}
captured, err := srv.Captures.ListCaptures(t.Context(), 1)
if err != nil {
t.Fatalf("ListCaptures: %v", err)
}
if len(captured) != 1 {
t.Fatalf("captured rows = %d, want 1", len(captured))
}
if got, want := e.Data["id"], captured[0].ID; got != want {
t.Fatalf("Data[\"id\"] = %v, want %v (the persisted captured_events row id, for frontend dedup)", got, want)
}
if got, _ := e.Data["source"].(string); got != "github" {
t.Fatalf("Data[\"source\"] = %v, want \"github\"", e.Data["source"])
}
if _, hasBody := e.Data["body"]; hasBody {
t.Fatalf("Data[\"body\"] present, want it omitted -- embedding the full payload here duplicates it into the unbounded events table")
}
if _, hasHeaders := e.Data["headers"]; hasHeaders {
t.Fatalf("Data[\"headers\"] present, want it omitted -- same unbounded-duplication risk as body")
}
}
func TestHandleCaptureAcceptsUnauthenticatedByDesign(t *testing.T) {
// Capture must accept requests with no HMAC secret configured -- that is
// the entire point of an unbound capture endpoint. This test documents
// that the handler does not gate on any signature header.
srv := captureTestServer(t)
req := httptest.NewRequestWithContext(t.Context(), http.MethodPost, "/webhooks/capture/unknown-source", strings.NewReader(`{}`))
w := httptest.NewRecorder()
srv.Handler().ServeHTTP(w, req)
if w.Code != http.StatusAccepted {
t.Fatalf("status = %d, want %d", w.Code, http.StatusAccepted)
}
}
func TestHandleCaptureNonJSONBodyStoredUnredacted(t *testing.T) {
srv := captureTestServer(t)
req := httptest.NewRequestWithContext(t.Context(), http.MethodPost, "/webhooks/capture/plain", strings.NewReader("not json"))
w := httptest.NewRecorder()
srv.Handler().ServeHTTP(w, req)
if w.Code != http.StatusAccepted {
t.Fatalf("status = %d, want %d", w.Code, http.StatusAccepted)
}
got, err := srv.Captures.ListCaptures(t.Context(), 10)
if err != nil {
t.Fatalf("ListCaptures: %v", err)
}
if len(got) != 1 || got[0].Body != "not json" {
t.Fatalf("captured = %+v, want raw body preserved when it is not JSON", got)
}
}
func TestHandleCaptureRejectsOversizedBody(t *testing.T) {
srv := captureTestServer(t)
srv.CaptureMaxBodyBytes = 8
req := httptest.NewRequestWithContext(t.Context(), http.MethodPost, "/webhooks/capture/github", strings.NewReader(`{"far":"too big for the cap"}`))
w := httptest.NewRecorder()
srv.Handler().ServeHTTP(w, req)
if w.Code != http.StatusRequestEntityTooLarge {
t.Fatalf("status = %d, want %d", w.Code, http.StatusRequestEntityTooLarge)
}
got, err := srv.Captures.ListCaptures(t.Context(), 10)
if err != nil {
t.Fatalf("ListCaptures: %v", err)
}
if len(got) != 0 {
t.Fatalf("captured rows = %d, want 0 (oversized body must never be persisted)", len(got))
}
}
// TestHandleCaptureEnforcesBodyCapEvenWhenUnconfigured pins that a caller
// that forgets to set CaptureMaxBodyBytes (zero value) still gets a bound --
// this is the one disk-bound mechanic that limits a single payload's size
// rather than row count or write rate, so it must never silently no-op.
func TestHandleCaptureEnforcesBodyCapEvenWhenUnconfigured(t *testing.T) {
srv := captureTestServer(t)
srv.CaptureMaxBodyBytes = 0
oversized := strings.Repeat("x", fallbackCaptureMaxBodyBytes+1)
req := httptest.NewRequestWithContext(t.Context(), http.MethodPost, "/webhooks/capture/github", strings.NewReader(oversized))
w := httptest.NewRecorder()
srv.Handler().ServeHTTP(w, req)
if w.Code != http.StatusRequestEntityTooLarge {
t.Fatalf("status = %d, want %d (CaptureMaxBodyBytes=0 must still enforce the fallback cap)", w.Code, http.StatusRequestEntityTooLarge)
}
got, err := srv.Captures.ListCaptures(t.Context(), 10)
if err != nil {
t.Fatalf("ListCaptures: %v", err)
}
if len(got) != 0 {
t.Fatalf("captured rows = %d, want 0", len(got))
}
}
func TestHandleCaptureRateLimitsPerRemoteAddr(t *testing.T) {
// Deliberately NOT keyed by the source path segment: source is an
// unregistered, attacker-chosen string for this endpoint (see
// handleCapture and docs/prds/event-capture-storage.md), so both
// requests below use the SAME source and DIFFERENT RemoteAddr to prove
// the limiter is keyed on the sender's address, not the segment.
srv := captureTestServer(t)
srv.CaptureLimiter = webhookguard.NewRateLimiter(0, 1, time.Now) // burst 1, no refill
req := func(remoteAddr string) *http.Request {
r := httptest.NewRequestWithContext(t.Context(), http.MethodPost, "/webhooks/capture/github", strings.NewReader(`{}`))
r.RemoteAddr = remoteAddr
return r
}
w1 := httptest.NewRecorder()
srv.Handler().ServeHTTP(w1, req("203.0.113.5:11111"))
if w1.Code != http.StatusAccepted {
t.Fatalf("first request status = %d, want %d", w1.Code, http.StatusAccepted)
}
w2 := httptest.NewRecorder()
srv.Handler().ServeHTTP(w2, req("203.0.113.5:22222"))
if w2.Code != http.StatusTooManyRequests {
t.Fatalf("second request (same host, different port) status = %d, want %d", w2.Code, http.StatusTooManyRequests)
}
// A different remote address, same source segment, must not be affected
// by the exhausted budget above.
w3 := httptest.NewRecorder()
srv.Handler().ServeHTTP(w3, req("198.51.100.9:33333"))
if w3.Code != http.StatusAccepted {
t.Fatalf("other-remote-addr request status = %d, want %d", w3.Code, http.StatusAccepted)
}
got, err := srv.Captures.ListCaptures(t.Context(), 10)
if err != nil {
t.Fatalf("ListCaptures: %v", err)
}
if len(got) != 2 {
t.Fatalf("captured rows = %d, want 2 (the rate-limited request must not be persisted)", len(got))
}
}
func TestHandleCaptureIgnoresGetMethod(t *testing.T) {
// The route is registered "POST /webhooks/capture/{source}"; a GET does
// not match it and falls through to the dashboard's own routing, same as
// every other POST-only API route in this server -- it must not be
// treated as a capture.
srv := captureTestServer(t)
req := httptest.NewRequestWithContext(t.Context(), http.MethodGet, "/webhooks/capture/github", nil)
w := httptest.NewRecorder()
srv.Handler().ServeHTTP(w, req)
if w.Code == http.StatusAccepted {
t.Fatalf("status = %d, a GET must never be accepted as a capture", w.Code)
}
got, err := srv.Captures.ListCaptures(t.Context(), 10)
if err != nil {
t.Fatalf("ListCaptures: %v", err)
}
if len(got) != 0 {
t.Fatalf("captured rows = %d, want 0 (GET must not persist a capture)", len(got))
}
}
func TestHandleCaptureWithoutCapturesConfiguredIs503(t *testing.T) {
srv := newTestServer(t)
req := httptest.NewRequestWithContext(t.Context(), http.MethodPost, "/webhooks/capture/github", strings.NewReader(`{}`))
w := httptest.NewRecorder()
srv.Handler().ServeHTTP(w, req)
if w.Code != http.StatusServiceUnavailable {
t.Fatalf("status = %d, want %d when Captures is nil", w.Code, http.StatusServiceUnavailable)
}
}
func TestHandleCaptureBypassesTokenAuth(t *testing.T) {
// The capture endpoint must accept unauthenticated senders even when the
// dashboard itself is token-gated -- mirrors /healthz's precedent.
srv := captureTestServer(t)
srv.Token = "dashboard-secret"
req := httptest.NewRequestWithContext(t.Context(), http.MethodPost, "/webhooks/capture/github", strings.NewReader(`{}`))
w := httptest.NewRecorder()
srv.Handler().ServeHTTP(w, req)
if w.Code != http.StatusAccepted {
t.Fatalf("status = %d, want %d (capture must bypass requireToken)", w.Code, http.StatusAccepted)
}
}
// captureInsertErrorStore forces InsertCapture to fail so the handler's
// error path is exercised without relying on a real storage failure.
type captureInsertErrorStore struct {
store.CaptureStore
}
func (captureInsertErrorStore) InsertCapture(context.Context, store.CapturedEvent, time.Duration, int) (int64, error) {
return 0, errors.New("boom")
}
func TestHandleCaptureStorageFailureIs500(t *testing.T) {
srv := captureTestServer(t)
srv.Captures = captureInsertErrorStore{}
req := httptest.NewRequestWithContext(t.Context(), http.MethodPost, "/webhooks/capture/github", strings.NewReader(`{}`))
w := httptest.NewRecorder()
srv.Handler().ServeHTTP(w, req)
if w.Code != http.StatusInternalServerError {
t.Fatalf("status = %d, want %d", w.Code, http.StatusInternalServerError)
}
}
func captureListResponse(t *testing.T, w *httptest.ResponseRecorder) map[string]any {
t.Helper()
var body map[string]any
if err := json.Unmarshal(w.Body.Bytes(), &body); err != nil {
t.Fatalf("decode response: %v; body = %s", err, w.Body.String())
}
return body
}
func TestHandleCapturesListsRecentCapturesNewestFirst(t *testing.T) {
srv := captureTestServer(t)
for _, src := range []string{"first", "second", "third"} {
req := httptest.NewRequestWithContext(t.Context(), http.MethodPost, "/webhooks/capture/"+src, strings.NewReader(`{"n":1}`))
w := httptest.NewRecorder()
srv.Handler().ServeHTTP(w, req)
if w.Code != http.StatusAccepted {
t.Fatalf("seed capture %q: status = %d", src, w.Code)
}
}
req := httptest.NewRequestWithContext(t.Context(), http.MethodGet, "/api/captures", nil)
w := httptest.NewRecorder()
srv.Handler().ServeHTTP(w, req)
if w.Code != http.StatusOK {
t.Fatalf("status = %d, want %d; body = %s", w.Code, http.StatusOK, w.Body.String())
}
body := captureListResponse(t, w)
if enabled, _ := body["enabled"].(bool); !enabled {
t.Fatalf("enabled = %v, want true", body["enabled"])
}
captures, ok := body["captures"].([]any)
if !ok || len(captures) != 3 {
t.Fatalf("captures = %#v, want 3 entries", body["captures"])
}
first, ok := captures[0].(map[string]any)
if !ok || first["source"] != "third" {
t.Fatalf("captures[0] = %#v, want newest-first (source=\"third\")", captures[0])
}
}
func TestHandleCapturesRespectsLimitQueryParam(t *testing.T) {
srv := captureTestServer(t)
for range 3 {
req := httptest.NewRequestWithContext(t.Context(), http.MethodPost, "/webhooks/capture/src", strings.NewReader(`{}`))
w := httptest.NewRecorder()
srv.Handler().ServeHTTP(w, req)
}
req := httptest.NewRequestWithContext(t.Context(), http.MethodGet, "/api/captures?limit=1", nil)
w := httptest.NewRecorder()
srv.Handler().ServeHTTP(w, req)
body := captureListResponse(t, w)
captures, _ := body["captures"].([]any)
if len(captures) != 1 {
t.Fatalf("captures = %#v, want 1 entry (limit=1)", body["captures"])
}
}
func TestHandleCapturesDefaultsLimitWhenMissingOrInvalid(t *testing.T) {
srv := captureTestServer(t)
for range 3 {
req := httptest.NewRequestWithContext(t.Context(), http.MethodPost, "/webhooks/capture/src", strings.NewReader(`{}`))
w := httptest.NewRecorder()
srv.Handler().ServeHTTP(w, req)
}
for _, limit := range []string{"", "not-a-number", "-5", "0"} {
req := httptest.NewRequestWithContext(t.Context(), http.MethodGet, "/api/captures?limit="+limit, nil)
w := httptest.NewRecorder()
srv.Handler().ServeHTTP(w, req)
body := captureListResponse(t, w)
captures, _ := body["captures"].([]any)
if len(captures) != 3 {
t.Fatalf("limit=%q: captures = %#v, want all 3 (an invalid/absent limit must not become a 0-row LIMIT)", limit, body["captures"])
}
}
}
func TestHandleCapturesWithoutCapturesConfiguredIsEnabledFalse(t *testing.T) {
srv := newTestServer(t)
req := httptest.NewRequestWithContext(t.Context(), http.MethodGet, "/api/captures", nil)
w := httptest.NewRecorder()
srv.Handler().ServeHTTP(w, req)
if w.Code != http.StatusOK {
t.Fatalf("status = %d, want %d (unconfigured is not an error, per the memory/skills precedent)", w.Code, http.StatusOK)
}
body := captureListResponse(t, w)
if enabled, _ := body["enabled"].(bool); enabled {
t.Fatalf("enabled = %v, want false when Captures is nil", body["enabled"])
}
captures, ok := body["captures"].([]any)
if !ok || len(captures) != 0 {
t.Fatalf("captures = %#v, want an empty list", body["captures"])
}
}
func TestHandleCapturesRequiresToken(t *testing.T) {
srv := captureTestServer(t)
srv.Token = "dashboard-secret"
req := httptest.NewRequestWithContext(t.Context(), http.MethodGet, "/api/captures", nil)
w := httptest.NewRecorder()
srv.Handler().ServeHTTP(w, req)
if w.Code == http.StatusOK {
t.Fatalf("status = %d, want captures to require the dashboard token like every other /api/* route", w.Code)
}
}
// TestHandleCaptureMarksAuthenticatedWhenHMACMatches is the green half of
// the t2db.5 point 1 wiring: a capture POST signed with the armed
// binding's secret must be recorded with Authenticated=true so the
// dispatch loop's binding.Matcher.Matches check (which gates on
// authenticated) can fire.
func TestHandleCaptureMarksAuthenticatedWhenHMACMatches(t *testing.T) {
const secret = "abcdefghijklmnop" // exactly 16 bytes (binding.Validate floor)
srv := captureBindingServer(t, secret, "github")
body := `{"action":"opened"}`
req := httptest.NewRequestWithContext(t.Context(), http.MethodPost, "/webhooks/capture/github", strings.NewReader(body))
req.Header.Set("Content-Type", "application/json")
req.Header.Set("X-Hub-Signature-256", hmacSHA256(secret, body))
w := httptest.NewRecorder()
srv.Handler().ServeHTTP(w, req)
if w.Code != http.StatusAccepted {
t.Fatalf("status = %d, want %d; body = %s", w.Code, http.StatusAccepted, w.Body.String())
}
got, err := srv.Captures.ListCaptures(t.Context(), 10)
if err != nil {
t.Fatalf("ListCaptures: %v", err)
}
if len(got) != 1 {
t.Fatalf("captured rows = %d, want 1", len(got))
}
if !got[0].Authenticated {
t.Errorf("Authenticated = false, want true (signature matched armed binding's secret)")
}
}
// TestHandleCaptureMarksUnauthenticatedWhenHMACMismatches covers the
// negative side of the HMAC verification: a body signed with the WRONG
// secret is still captured (per t2db.5 point 1 -- captures must remain
// inspectable even when auth fails) but flagged as unauthenticated so
// the dispatch loop's auth gate can drop it.
func TestHandleCaptureMarksUnauthenticatedWhenHMACMismatches(t *testing.T) {
const secret = "abcdefghijklmnop"
srv := captureBindingServer(t, secret, "github")
body := `{"action":"opened"}`
wrong := hmacSHA256("not-the-real-secret-aaaaaaaaa", body)
req := httptest.NewRequestWithContext(t.Context(), http.MethodPost, "/webhooks/capture/github", strings.NewReader(body))
req.Header.Set("X-Hub-Signature-256", wrong)
w := httptest.NewRecorder()
srv.Handler().ServeHTTP(w, req)
if w.Code != http.StatusAccepted {
t.Fatalf("status = %d, want %d (a mismatched signature must still produce a capture, not reject the request)", w.Code, http.StatusAccepted)
}
got, err := srv.Captures.ListCaptures(t.Context(), 10)
if err != nil {
t.Fatalf("ListCaptures: %v", err)
}
if len(got) != 1 {
t.Fatalf("captured rows = %d, want 1", len(got))
}
if got[0].Authenticated {
t.Errorf("Authenticated = true, want false (signature did not match armed binding's secret)")
}
}
// TestHandleCaptureWithNoSignatureMarksUnauthenticated covers the
// "sender forgot the header" case: the binding is armed, the secret is
// registered, but the request carries no signature at all. The handler
// must fall through to authenticated=false (the empty-signature guard
// in webhookguard.VerifyHMAC). Captures are still recorded -- the
// operator can see the unsigned attempt in the inspector.
func TestHandleCaptureWithNoSignatureMarksUnauthenticated(t *testing.T) {
const secret = "abcdefghijklmnop"
srv := captureBindingServer(t, secret, "github")
req := httptest.NewRequestWithContext(t.Context(), http.MethodPost, "/webhooks/capture/github", strings.NewReader(`{}`))
// Deliberately no X-Hub-Signature-256 / X-Signature-256 header.
w := httptest.NewRecorder()
srv.Handler().ServeHTTP(w, req)
if w.Code != http.StatusAccepted {
t.Fatalf("status = %d, want %d", w.Code, http.StatusAccepted)
}
got, err := srv.Captures.ListCaptures(t.Context(), 10)
if err != nil {
t.Fatalf("ListCaptures: %v", err)
}
if len(got) != 1 || got[0].Authenticated {
t.Fatalf("captured = %+v, want 1 row with Authenticated=false", got)
}
}
// TestHandleCaptureWithMultipleArmedBindingsReturns409 covers the
// belt-and-braces TOCTOU guard: two armed bindings for the same source
// would race over every inbound webhook for that source, so the
// capture-time handler returns 409 Conflict instead of silently picking
// a winner. The store's overlap check should make this impossible in
// practice; the 409 is the safety net. The stub injects the state
// directly to exercise that safety net.
func TestHandleCaptureWithMultipleArmedBindingsReturns409(t *testing.T) {
srv := captureTestServer(t)
srv.BindingDispatcher = &stubBindingStore{
armedBySource: map[string][]binding.Binding{
"github": {
{ID: 1, Matcher: binding.Matcher{Source: "github"}, Status: binding.StatusArmed, Secret: "abcdefghijklmnop"},
{ID: 2, Matcher: binding.Matcher{Source: "github"}, Status: binding.StatusArmed, Secret: "qrstuvwxyz123456"},
},
},
}
req := httptest.NewRequestWithContext(t.Context(), http.MethodPost, "/webhooks/capture/github", strings.NewReader(`{}`))
w := httptest.NewRecorder()
srv.Handler().ServeHTTP(w, req)
if w.Code != http.StatusConflict {
t.Fatalf("status = %d, want %d (multiple armed bindings must surface as 409 at capture time)", w.Code, http.StatusConflict)
}
got, err := srv.Captures.ListCaptures(t.Context(), 10)
if err != nil {
t.Fatalf("ListCaptures: %v", err)
}
if len(got) != 0 {
t.Fatalf("captured rows = %d, want 0 (a 409 must never persist a row)", len(got))
}
}
// TestHandleCaptureAcceptsWhenNoArmedBindingExists documents the
// "source has never been bound" path: Bindings is wired but
// ArmedBindingsForSource returns an empty slice. The handler must
// still capture, with authenticated=false -- there is no armed binding
// to check against, so HMAC is meaningless, but the event itself is
// still worth recording for the inspector.
func TestHandleCaptureAcceptsWhenNoArmedBindingExists(t *testing.T) {
srv := captureTestServer(t)
srv.Bindings = &stubBindingStore{armedBySource: map[string][]binding.Binding{}}
req := httptest.NewRequestWithContext(t.Context(), http.MethodPost, "/webhooks/capture/github", strings.NewReader(`{}`))
w := httptest.NewRecorder()
srv.Handler().ServeHTTP(w, req)
if w.Code != http.StatusAccepted {
t.Fatalf("status = %d, want %d", w.Code, http.StatusAccepted)
}
got, err := srv.Captures.ListCaptures(t.Context(), 10)
if err != nil {
t.Fatalf("ListCaptures: %v", err)
}
if len(got) != 1 || got[0].Authenticated {
t.Fatalf("captured = %+v, want 1 row with Authenticated=false", got)
}
}
// TestHandleCaptureAcceptsWithBindingsNil pins the legacy backwards-
// compatibility behaviour: Bindings is nil (composition never wired the
// binding surface, or the dashboard is running without the feature).
// handleCapture must behave as it did before this phase landed -- still
// capture, still record authenticated=false.
func TestHandleCaptureAcceptsWithBindingsNil(t *testing.T) {
srv := captureTestServer(t)
if srv.Bindings != nil {
t.Fatalf("captureTestServer must not wire Bindings by default for this test")
}
req := httptest.NewRequestWithContext(t.Context(), http.MethodPost, "/webhooks/capture/github", strings.NewReader(`{}`))
w := httptest.NewRecorder()
srv.Handler().ServeHTTP(w, req)
if w.Code != http.StatusAccepted {
t.Fatalf("status = %d, want %d", w.Code, http.StatusAccepted)
}
got, err := srv.Captures.ListCaptures(t.Context(), 10)
if err != nil {
t.Fatalf("ListCaptures: %v", err)
}
if len(got) != 1 || got[0].Authenticated {
t.Fatalf("captured = %+v, want 1 row with Authenticated=false", got)
}
}
// TestHandleCaptureBindingsLookupErrorFailsOpenAtCapture pins the
// documented fail-open posture: if ArmedBindingsForSource errors, the
// capture still goes through (the dispatch loop's auth check is the
// actual gate). A transient store hiccup must not amplify into a
// capture outage for sends-that-haven't-been-bound-yet.
func TestHandleCaptureBindingsLookupErrorFailsOpenAtCapture(t *testing.T) {
srv := captureTestServer(t)
srv.Bindings = &stubBindingStore{lookupErr: errors.New("db locked")}
req := httptest.NewRequestWithContext(t.Context(), http.MethodPost, "/webhooks/capture/github", strings.NewReader(`{}`))
w := httptest.NewRecorder()
srv.Handler().ServeHTTP(w, req)
if w.Code != http.StatusAccepted {
t.Fatalf("status = %d, want %d (a transient lookup error must not fail closed at capture)", w.Code, http.StatusAccepted)
}
got, err := srv.Captures.ListCaptures(t.Context(), 10)
if err != nil {
t.Fatalf("ListCaptures: %v", err)
}
if len(got) != 1 || got[0].Authenticated {
t.Fatalf("captured = %+v, want 1 row with Authenticated=false", got)
}
}
// TestHandleCaptureAcceptsXSignature256FallbackHeader pins the second
// header in the precedence list: when X-Hub-Signature-256 is absent but
// X-Signature-256 is present, the fallback is honoured. Mirrors
// channels/webhook/webhook.go's header precedence.
func TestHandleCaptureAcceptsXSignature256FallbackHeader(t *testing.T) {
const secret = "abcdefghijklmnop"
srv := captureBindingServer(t, secret, "github")
body := `{"action":"opened"}`
req := httptest.NewRequestWithContext(t.Context(), http.MethodPost, "/webhooks/capture/github", strings.NewReader(body))
// No X-Hub-Signature-256; signature is in X-Signature-256 only.
req.Header.Set("X-Signature-256", hmacSHA256(secret, body))
w := httptest.NewRecorder()
srv.Handler().ServeHTTP(w, req)
if w.Code != http.StatusAccepted {
t.Fatalf("status = %d, want %d", w.Code, http.StatusAccepted)
}
got, err := srv.Captures.ListCaptures(t.Context(), 10)
if err != nil {
t.Fatalf("ListCaptures: %v", err)
}
if len(got) != 1 || !got[0].Authenticated {
t.Fatalf("captured = %+v, want 1 row with Authenticated=true (X-Signature-256 fallback must work)", got)
}
}