Files
archie/internal/gateway/stream_test.go
T
sam 0e0611a6b3 refactor(gateway): share sensitive-key markers with webhookguard
Resolves infra-misc-3.

WIRE: webhookguard.SensitiveKeyMarkers is now the single exported marker
list, and gateway.sensitiveParameterKey consumes it instead of inlining an
identical copy. webhookguard/redact.go documented that the two lists must
match "exactly so the two redaction paths agree"; that agreement is now
structural (one slice, two consumers) rather than a comment nothing
enforces. A new test asserts both consumers observe the same set, so a
future edit cannot silently desynchronise chat-transcript redaction from
webhook-capture redaction.
2026-09-15 12:55:52 +10:00

193 lines
6.5 KiB
Go

package gateway
import (
"encoding/json"
"strings"
"testing"
"github.com/samcharles93/archie-core/internal/webhookguard"
)
func TestRedactionConsumersShareMarkerSet(t *testing.T) {
if len(webhookguard.SensitiveKeyMarkers) == 0 {
t.Fatal("webhookguard.SensitiveKeyMarkers is empty, want a non-empty shared set")
}
for _, marker := range webhookguard.SensitiveKeyMarkers {
if !sensitiveParameterKey(marker) {
t.Errorf("sensitiveParameterKey(%q) = false, want true (shared marker set)", marker)
}
payload, err := json.Marshal(map[string]string{marker: "secret"})
if err != nil {
t.Fatal(err)
}
got, err := webhookguard.RedactPayload(payload)
if err != nil {
t.Fatalf("RedactPayload(%q): %v", marker, err)
}
if string(got) == string(payload) {
t.Errorf("webhookguard did not redact shared marker key %q", marker)
}
}
}
func TestSummarizeToolParameters(t *testing.T) {
tests := []struct {
name string
input string
want string
}{
{name: "empty", input: "", want: ""},
{name: "compact object", input: `{ "path": "/tmp/file", "line": 2 }`, want: `{"line":2,"path":"[string]"}`},
{name: "nested secrets", input: `{"headers":{"Authorization":"Bearer secret"},"api-token":"secret","safe":"visible"}`, want: `{"api-token":"[redacted]","headers":{"Authorization":"[redacted]"},"safe":"[string]"}`},
{name: "secret embedded in ordinary value", input: `{"command":"curl -H 'Authorization: Bearer secret'"}`, want: `{"command":"[string]"}`},
{name: "secret in array", input: `[{"password":"secret"}]`, want: `[{"password":"[redacted]"}]`},
{name: "non-string secret", input: `{"password":123456,"token":true}`, want: `{"password":"[redacted]","token":"[redacted]"}`},
{name: "nested value under sensitive key", input: `{"credentials":{"user":"archie","password":"secret"}}`, want: `{"credentials":"[redacted]"}`},
{name: "invalid JSON", input: `token=secret`, want: "[unavailable]"},
}
for _, tc := range tests {
t.Run(tc.name, func(t *testing.T) {
if got := SummarizeToolParameters(tc.input); got != tc.want {
t.Fatalf("SummarizeToolParameters() = %q, want %q", got, tc.want)
}
})
}
got := SummarizeToolParameters(`{"value":[` + strings.Repeat("0,", toolParametersMaxRunes) + `0]}`)
if len([]rune(got)) != toolParametersMaxRunes {
t.Fatalf("bounded summary is %d runes, want %d", len([]rune(got)), toolParametersMaxRunes)
}
if !strings.HasSuffix(got, "…") {
t.Fatalf("bounded summary = %q, want ellipsis", got)
}
}
func TestToolCallEventSummary(t *testing.T) {
tests := []struct {
name string
event ToolCallEvent
want string
}{
{
name: "single line output is the summary",
event: ToolCallEvent{Name: "memory_edit", Output: "added entry"},
want: "added entry",
},
{
name: "only the first non-empty line is kept",
event: ToolCallEvent{Name: "read", Output: "\n\nfirst line\nsecond line"},
want: "first line",
},
{
name: "surrounding whitespace is trimmed",
event: ToolCallEvent{Name: "shell", Output: " exit 0 \n"},
want: "exit 0",
},
{
name: "an error replaces the output",
event: ToolCallEvent{Name: "shell", Output: "partial", Err: "exit status 2"},
want: "failed: exit status 2",
},
{
name: "a multi-line error is reduced the same way",
event: ToolCallEvent{Name: "shell", Err: "exit status 2\nstack trace"},
want: "failed: exit status 2",
},
{
name: "no output at all still reads as a completed call",
event: ToolCallEvent{Name: "write"},
want: "done",
},
{
name: "whitespace-only output reads as a completed call",
event: ToolCallEvent{Name: "write", Output: " \n "},
want: "done",
},
{
name: "a long line is truncated with an ellipsis",
event: ToolCallEvent{Name: "grep", Output: strings.Repeat("x", toolSummaryMaxRunes+10)},
want: strings.Repeat("x", toolSummaryMaxRunes) + "…",
},
{
name: "truncation counts runes, not bytes",
event: ToolCallEvent{Name: "grep", Output: strings.Repeat("é", toolSummaryMaxRunes+10)},
want: strings.Repeat("é", toolSummaryMaxRunes) + "…",
},
}
for _, tc := range tests {
t.Run(tc.name, func(t *testing.T) {
if got := tc.event.Summary(); got != tc.want {
t.Fatalf("Summary() = %q, want %q", got, tc.want)
}
})
}
}
// A caller that only renders text must be able to keep passing a plain
// callback, and must never be handed a tool event it cannot use.
func TestDeltaFuncIsTextOnly(t *testing.T) {
var got []string
stream := DeltaFunc(func(delta string) { got = append(got, delta) })
stream.Delta("one")
stream.ToolCall(ToolCallEvent{Name: "shell", Output: "exit 0"})
stream.Delta("two")
want := []string{"one", "two"}
if len(got) != len(want) {
t.Fatalf("deltas = %v, want %v", got, want)
}
for i := range want {
if got[i] != want[i] {
t.Fatalf("deltas = %v, want %v", got, want)
}
}
}
// RouteStream and TurnRunner accept a nil sink to mean "not streaming", so a
// nil DeltaFunc must be inert rather than a panic waiting for the first token.
func TestDeltaFuncNilIsInert(t *testing.T) {
stream := DeltaFunc(nil)
stream.Delta("anything")
stream.ToolCall(ToolCallEvent{Name: "shell"})
stream.Media(MediaEvent{ToolName: "video_gen"})
}
// A text-only caller has nowhere to put media, so DeltaFunc must discard it
// exactly like it discards ToolCall -- never panic, never route it into the
// text stream as a raw URL the caller didn't ask for.
func TestDeltaFuncDiscardsMedia(t *testing.T) {
var got []string
stream := DeltaFunc(func(delta string) { got = append(got, delta) })
stream.Media(MediaEvent{ToolName: "video_gen", Attachment: MediaAttachment{Type: "video", URL: "https://example.com/v.mp4"}})
if len(got) != 0 {
t.Fatalf("Media leaked into the text stream: %v", got)
}
}
// toolCallRecorder must forward Media to the wrapped stream unchanged, the
// same contract it already honors for Delta and ToolCall.
func TestToolCallRecorderForwardsMedia(t *testing.T) {
next := &recordingStream{}
r := &toolCallRecorder{next: next}
event := MediaEvent{ToolName: "video_gen", Attachment: MediaAttachment{Type: "video", URL: "https://example.com/v.mp4"}}
r.Media(event)
want := []string{"media:video_gen:video"}
if len(next.events) != len(want) || next.events[0] != want[0] {
t.Fatalf("events = %v, want %v", next.events, want)
}
}
// toolCallRecorder must not panic when wrapping a nil stream (the
// non-streaming caller case Delta/ToolCall already handle).
func TestToolCallRecorderMediaNilNextIsInert(t *testing.T) {
r := &toolCallRecorder{}
r.Media(MediaEvent{ToolName: "video_gen"})
}