Files
archie/internal/gateway/health_test.go
T
sam f6397af7f4 fix: address the Greptile findings on the merged PRs (#902)
* fix: address the Greptile findings on the merged PRs

Four valid review findings from PRs #892, #893, #898 and #899, which were
merged without the comments being read.

- Config.Clone left the new diff-cap pointers aliased (#899, mine). Clone
  deep-copies every reference field, including the *bool beside it, so a
  clone could write the cap through to the published snapshot. Both the
  top-level field and the identity overrides are copied, with the clone test
  extended to cover them.
- providerOutcomeRecorder.record could report an older call as the latest
  (#892). The completion time is taken before the lock, so two concurrent
  calls can reach the lock in the opposite order to their completion and the
  unconditional store overwrote the newer outcome. It now keeps the newer,
  via a recordAt seam that makes the reordering testable.
- Curator model calls bypassed the recorder (#892). curatorLLMRunner calls
  the runtime directly, so a daemon whose only recent model traffic was
  curator work reported "no calls attempted yet" while the provider was
  demonstrably reachable. It records at its own adapter, and sendChatTurn's
  "single choke point" comment is corrected to say there are two.
- A provider error reached /status raw (#892), unlike channel details, so a
  multiline or oversized error broke the one-line-per-fact layout. Both now
  share one bounded formatter.

Found while fixing the curator path: agentexec.NewRuntime returns nil when no
provider is configured, and a nil *runtime.Runtime panics on its first method
call, so a curator asking for a completion took the daemon down. It now
returns an error, and records nothing -- a local misconfiguration is not a
provider call.

Not fixed, filed instead: the shared lastPollAt masking a stuck identity, the
container max-uptime callback resurrecting teardown bookkeeping, the
dashboard dropping a served-only status filter on cold load, and the route
registry test's line-by-line parser.

* fix(build): drop goimports from the gate's formatter set

`task check` spent 136 of its 167 seconds in `task fmt`, and 134 of those
136 in one formatter: goimports alone over the tree.

golangci-lint's goimports formatter calls imports.Process once per file,
which builds a fresh x/tools ProcessEnv each time, so
internal/imports.getFixesWithSource re-reads modindex.Read($GOMODCACHE) per
file. On this machine that index is 62.7 MiB / 2,081,070 lines (an 11 GiB
module cache), and modindex's in-process memo does not take effect: 3 files
read 187.9 MiB back, 15 files open the payload 15 times. That is ~53 GiB of
I/O and CSV parsing per run, and it is linear at ~155 ms per file (122 files
-> 18.8s, 864 -> 133.8s). Pointing the index cache elsewhere drops the same
command to 3.9s.

The same analyzer runs under `golangci-lint run`, so a cold cache pays it
again: 169s cold with goimports, 31s without -- which is what CI and archied's
own PR gate see, since only `fmt` never caches locally.

Removing it costs no enforcement. gofumpt and gci remain, `task lint` still
reports formatter drift as an issue, and the whole-tree fmt is now 2.2s with
the tree byte-identical. What is given up is goimports' convenience of
adding and removing import lines, which compile errors already cover.

The examples/secret-engines exclusion stays: gofumpt and gci leave those
Yaegi programs alone today, but the exclusion is the stated invariant that a
formatter must not rewrite the imports of files it cannot type-check, and
TestFormattersExcludeInterpretedSecretEngines holds it. Its comment no longer
pins the reason to the formatter that was dropped.

* fix(gateway): stop /status promising and mis-reporting health it cannot see

Two findings from the cloud review of #892.

Title generation no longer records chat-model health. It runs detached after
a first turn under its own 30s bound and its error is swallowed by the
caller, but it shared the process-wide outcome recorder, so a title that
merely timed out overwrote the health line with "failed" -- reporting a
broken provider on the strength of a call no user was waiting for.

The /status command description no longer claims "workers" and "channels".
Neither can render: newStatusHealth reads the container pool and the poll
loop from boot, but the only production router.Health assignment is in
setupGatewayChat, which runs solely in the archie-gateway process, where
neither exists; channels is nil since the Messaging Service took the
front-ends. Only the broker and chat-model lines actually appear, so that is
what the help text now says.

The underlying split -- daemon owns the facts, Gateway owns the Router -- is
filed rather than patched here: it needs either a cross-process health
contract or a ratified two-section /status, not a quick wire-up.
2026-09-20 02:42:36 +10:00

268 lines
8.3 KiB
Go

package gateway
import (
"context"
"strings"
"testing"
"time"
)
// fakeHealthSource is the seam the daemon supplies in production; the report
// it returns is fixed so each case pins one rendering rule.
type fakeHealthSource struct {
report HealthReport
}
func (f fakeHealthSource) Health() HealthReport { return f.report }
// TestFormatHealthRendersOnlyWhatWasReported pins the rule that makes /status
// trustworthy: a section the reporting process has no truthful source for is
// omitted, never rendered as a zero, a dash or a guess. A health surface that
// invents a value is worse than a thin one, because an operator cannot tell
// an invented "0" from a measured one.
func TestFormatHealthRendersOnlyWhatWasReported(t *testing.T) {
now := time.Date(2026, 9, 19, 12, 0, 0, 0, time.UTC)
past := func(d time.Duration) time.Time { return now.Add(-d) }
at := func(d time.Duration) *time.Time { v := past(d); return &v }
// The zero time is the daemon's "no pass has started yet" value, distinct
// from a stale timestamp.
var zeroTime time.Time
tests := []struct {
name string
report HealthReport
want string
}{
{
name: "no source wired reports nothing at all",
report: HealthReport{},
want: "",
},
{
name: "disconnected broker",
report: HealthReport{Broker: &BrokerHealth{}},
want: "Broker: disconnected",
},
{
name: "connected broker",
report: HealthReport{Broker: &BrokerHealth{Connected: true}},
want: "Broker: connected",
},
{
name: "worker pool with a configured cap",
report: HealthReport{Containers: &ContainerHealth{Active: 1, Cap: 4}},
want: "Containers: 1/4 active",
},
{
name: "worker pool with no configured cap renders no ratio",
// MaxConcurrency <= 0 means unlimited, so "2/0" would read as
// "at capacity" when it means the opposite.
report: HealthReport{Containers: &ContainerHealth{Active: 2}},
want: "Containers: 2 active",
},
{
name: "empty pool with a cap",
report: HealthReport{
Containers: &ContainerHealth{Cap: 3},
},
want: "Containers: 0/3 active",
},
{
name: "channels report their own lifecycle state",
report: HealthReport{Channels: []ChannelHealth{
{Name: "telegram", State: "running"},
{Name: "email", State: "failed", Detail: "dial tcp 127.0.0.1:2525: connection refused"},
}},
want: "Channels: telegram running · email failed (dial tcp 127.0.0.1:2525: connection refused)",
},
{
name: "a multi-line channel detail stays on one line",
report: HealthReport{Channels: []ChannelHealth{
{Name: "telegram", State: "failed", Detail: "getMe failed:\n 401 Unauthorized"},
}},
want: "Channels: telegram failed (getMe failed: 401 Unauthorized)",
},
{
name: "chat model with nothing attempted says so",
report: HealthReport{
ChatModel: &ChatModelHealth{},
},
want: "Chat model: no calls attempted yet",
},
{
name: "last chat model call succeeded",
report: HealthReport{
ChatModel: &ChatModelHealth{
Attempted: true,
Outcome: ChatModelOutcome{Model: "openai/gpt-5.6", At: past(30 * time.Second)},
},
},
want: "Chat model: ok just now (openai/gpt-5.6)",
},
{
name: "last chat model call failed, with its model and error",
report: HealthReport{
ChatModel: &ChatModelHealth{
Attempted: true,
Outcome: ChatModelOutcome{
Model: "openai/gpt-5.6",
At: past(4 * time.Minute),
Err: "401 Unauthorized",
},
},
},
want: "Chat model: failed 4m ago (openai/gpt-5.6): 401 Unauthorized",
},
{
name: "a call whose model is unknown still reports its outcome",
report: HealthReport{
ChatModel: &ChatModelHealth{
Attempted: true,
Outcome: ChatModelOutcome{At: past(2 * time.Minute), Err: "connection reset"},
},
},
want: "Chat model: failed 2m ago: connection reset",
},
{
name: "poller has not run a pass yet",
report: HealthReport{LastPoll: &zeroTime},
want: "Last poll: not yet",
},
{
name: "poller last ran minutes ago",
report: HealthReport{LastPoll: at(12 * time.Minute)},
want: "Last poll: 12m ago",
},
{
name: "every section present renders in one stable order",
report: HealthReport{
Broker: &BrokerHealth{Connected: true},
Containers: &ContainerHealth{Active: 1, Cap: 2},
Channels: []ChannelHealth{{Name: "telegram", State: "running"}},
ChatModel: &ChatModelHealth{
Attempted: true,
Outcome: ChatModelOutcome{Model: "openai/gpt-5.6", At: past(time.Minute)},
},
LastPoll: at(5 * time.Second),
},
want: strings.Join([]string{
"Broker: connected",
"Containers: 1/2 active",
"Channels: telegram running",
"Chat model: ok 1m ago (openai/gpt-5.6)",
"Last poll: just now",
// Joined with the report's hard line break: each of these is a
// line, and a plain "\n" soft-joins them into one paragraph
// in a Markdown-rendering channel.
}, reportLineBreak),
},
}
for _, tc := range tests {
t.Run(tc.name, func(t *testing.T) {
if got := formatHealth(tc.report, now); got != tc.want {
t.Errorf("formatHealth() =\n%q\nwant:\n%q", got, tc.want)
}
})
}
}
// TestFormatStatusAppendsHealthToTheQueueLine pins the shape of the whole
// reply: the aggregate queue line keeps its place (Phase 1's own health
// signal), the health section follows it, and an unwired health source leaves
// the reply exactly as it was.
func TestFormatStatusAppendsHealthToTheQueueLine(t *testing.T) {
now := time.Date(2026, 9, 19, 12, 0, 0, 0, time.UTC)
tests := []struct {
name string
counts map[string]int
report HealthReport
want string
}{
{
name: "unwired health source",
counts: map[string]int{"running": 1},
want: "📊 Archie status\n\nQueue: 1 in flight (1 running) \nRuntime: not configured",
},
{
name: "wired health source",
counts: map[string]int{"running": 1},
report: HealthReport{Broker: &BrokerHealth{Connected: true}},
want: "📊 Archie status\n\nQueue: 1 in flight (1 running) \nBroker: connected \nRuntime: not configured",
},
}
for _, tc := range tests {
t.Run(tc.name, func(t *testing.T) {
got := formatStatus(tc.counts, tc.report, nil, now)
if got != tc.want {
t.Errorf("formatStatus() =\n%q\nwant:\n%q", got, tc.want)
}
})
}
}
// TestHandleStatusReadsTheWiredHealthSource pins that /status asks the daemon
// for health rather than leaving the seam unread -- the failure mode this pins
// is a router field that exists, is set by composition, and is never called.
func TestHandleStatusReadsTheWiredHealthSource(t *testing.T) {
tests := []struct {
name string
health HealthSource
want string
absent string
}{
{
name: "health source wired",
health: fakeHealthSource{report: HealthReport{Broker: &BrokerHealth{Connected: true}}},
want: "Broker: connected",
},
{
name: "no health source",
health: nil,
absent: "Broker:",
},
}
for _, tc := range tests {
t.Run(tc.name, func(t *testing.T) {
r := NewRouter(&fakeStore{counts: map[string]int{}}, nil, "test")
r.Health = tc.health
reply, err := r.Route(context.Background(), inbound("", "/status"))
if err != nil {
t.Fatalf("Route: %v", err)
}
if tc.want != "" && !strings.Contains(reply, tc.want) {
t.Errorf("reply = %q, want contains %q", reply, tc.want)
}
if tc.absent != "" && strings.Contains(reply, tc.absent) {
t.Errorf("reply = %q, want no %q", reply, tc.absent)
}
})
}
}
// TestFormatChatModelBoundsTheProviderError pins that a provider error cannot
// break /status' one-line-per-fact layout. The error is whatever the provider
// returned, which for an HTML error page is neither short nor single-line, and
// unlike a channel detail it was passed through raw.
func TestFormatChatModelBoundsTheProviderError(t *testing.T) {
now := time.Now()
health := ChatModelHealth{
Attempted: true,
Outcome: ChatModelOutcome{
Model: "openai/gpt-5.6",
At: now.Add(-time.Minute),
Err: "502 Bad Gateway\n<html>\n<head><title>502</title></head>\n" + strings.Repeat("body text ", 40),
},
}
got := formatChatModel(health, now)
if strings.ContainsAny(got, "\n\r") {
t.Fatalf("formatChatModel() = %q, want a single line", got)
}
if len([]rune(got)) > maxChannelDetail+80 {
t.Fatalf("formatChatModel() is %d runes, want it bounded near maxChannelDetail (%d)",
len([]rune(got)), maxChannelDetail)
}
}