Files
archie/internal/infrastructure/configuration/unknown_keys_test.go
T
sam 9a0efa295e chore(config): remove dead [agent], [oidc], [image] and containers.enabled keys
None had a production consumer: [agent] and containers.enabled were decoded
only so old files kept loading, [oidc] was never read (archie-ui takes OIDC
from flags), and [image] was validated but no provider exists.
2026-09-24 23:52:06 +10:00

222 lines
7.5 KiB
Go

package configuration
import (
"os"
"path/filepath"
"slices"
"testing"
)
// minimalValidConfigTOML is enough to pass Validate on its own, so these tests
// isolate the unknown-key behaviour from unrelated validation failures.
const minimalValidConfigTOML = "bot_user = \"widget\"\nwork_dir = \"/base/work\"\n"
// TestUnknownKeysAreReported pins plan-config-drift.md step 1: a
// misspelled key must not parse, validate and silently do nothing. Today
// (before the fix) it loads with zero indication anything was ignored.
func TestUnknownKeysAreReported(t *testing.T) {
path := filepath.Join(t.TempDir(), "config.toml")
src := minimalValidConfigTOML + "[containers]\nmax_concurrancy = 4\n" // typo: concurrancy
if err := os.WriteFile(path, []byte(src), 0o600); err != nil {
t.Fatal(err)
}
doc, err := New(nil).File(path)
if err != nil {
t.Fatalf("File: %v (an unknown key must not fail the load)", err)
}
if len(doc.UnknownKeys) == 0 {
t.Fatal("UnknownKeys is empty, want the typo'd key reported")
}
found := false
for _, k := range doc.UnknownKeys {
if k == "containers.max_concurrancy" {
found = true
}
}
if !found {
t.Errorf("UnknownKeys = %v, want it to contain %q", doc.UnknownKeys, "containers.max_concurrancy")
}
}
// TestValidSchedulingBlockIsNotReportedAsUnknown pins Hazard 1 from
// plan-config-drift.md: one file feeds both &doc.Config and
// &doc.Scheduling. Reporting either target's Undecoded() verbatim would
// flag every config carrying a real [scheduling] block, since Config has
// no "scheduling" field and SchedulingInput has nothing else.
func TestValidSchedulingBlockIsNotReportedAsUnknown(t *testing.T) {
path := filepath.Join(t.TempDir(), "config.toml")
src := minimalValidConfigTOML + "[scheduling]\ninterval = \"60s\"\nmax_parallel = 4\n"
if err := os.WriteFile(path, []byte(src), 0o600); err != nil {
t.Fatal(err)
}
doc, err := New(nil).File(path)
if err != nil {
t.Fatal(err)
}
if len(doc.UnknownKeys) != 0 {
t.Errorf("UnknownKeys = %v, want none: a valid [scheduling] block is not an unknown key", doc.UnknownKeys)
}
if doc.Scheduling.MaxParallel != 4 {
t.Errorf("Scheduling.MaxParallel = %d, want 4 (scheduling must still decode correctly)", doc.Scheduling.MaxParallel)
}
}
// TestUnknownSchedulingKeyIsStillReported is the mirror of the Hazard 1
// test: a typo inside [scheduling] must not be masked by the intersection
// logic that protects legitimate cross-target keys.
func TestUnknownSchedulingKeyIsStillReported(t *testing.T) {
path := filepath.Join(t.TempDir(), "config.toml")
src := minimalValidConfigTOML + "[scheduling]\nmax_parallell = 4\n" // typo: extra "l"
if err := os.WriteFile(path, []byte(src), 0o600); err != nil {
t.Fatal(err)
}
doc, err := New(nil).File(path)
if err != nil {
t.Fatal(err)
}
found := false
for _, k := range doc.UnknownKeys {
if k == "scheduling.max_parallell" {
found = true
}
}
if !found {
t.Errorf("UnknownKeys = %v, want it to contain %q", doc.UnknownKeys, "scheduling.max_parallell")
}
}
// TestOverlayUnknownKeysAreStillReported pins that the overlay path kept its
// drift detection when the overlay file started being applied through the
// config fold instead of being decoded into the document's config. That matters
// twice over there: the report comes from a separate decode, and a file is
// parsed by TOML while the fold applies it with a yaml decode, which do not
// match keys the same way. A key the APPLY cannot consume has to be reported,
// or a spelling that works in the base config would silently do nothing in the
// overlay.
func TestOverlayUnknownKeysAreStillReported(t *testing.T) {
tests := []struct {
name string
overlay string
wantUnknown string
}{
{
name: "a key no decode target consumes",
overlay: "[containers]\nmax_concurrancy = 4\n", // typo: concurrancy
wantUnknown: "containers.max_concurrancy",
},
{
// TOML matches keys case-insensitively, so the file's own decode
// consumes BOT_USER and reports nothing; the apply folds the file's
// mapping with a yaml decode, which does not match it. Without the
// second source for this report the value would be dropped in
// silence, so the spelling is reported instead.
name: "a key only the file decode can match",
overlay: "BOT_USER = \"upper\"\n",
wantUnknown: "BOT_USER",
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
dir := t.TempDir()
basePath := filepath.Join(dir, "config.toml")
overlayPath := filepath.Join(dir, "dev.toml")
if err := os.WriteFile(basePath, []byte(minimalValidConfigTOML), 0o600); err != nil {
t.Fatal(err)
}
if err := os.WriteFile(overlayPath, []byte(tt.overlay), 0o600); err != nil {
t.Fatal(err)
}
doc, err := New(nil).Resolve(basePath, overlayPath)
if err != nil {
t.Fatalf("Resolve: %v (an unknown key must not fail the load)", err)
}
if !slices.Contains(doc.UnknownKeys, tt.wantUnknown) {
t.Errorf("UnknownKeys = %v, want it to contain %q", doc.UnknownKeys, tt.wantUnknown)
}
})
}
}
// TestExampleConfigHasNoUnknownKeys is the contract test the design
// promised: the checked-in template must never itself trip the detector.
func TestExampleConfigHasNoUnknownKeys(t *testing.T) {
doc, err := New(nil).File(filepath.Join("..", "..", "..", "config.example.toml"))
if err != nil {
t.Fatal(err)
}
if len(doc.UnknownKeys) != 0 {
t.Errorf("config.example.toml has unknown keys: %v", doc.UnknownKeys)
}
}
// TestDeploymentOverlaysHaveNoUnknownKeys covers every shipped overlay
// profile the same way, loaded as they are in production: layered over
// config.example.toml via -config-overlay.
func TestDeploymentOverlaysHaveNoUnknownKeys(t *testing.T) {
base := filepath.Join("..", "..", "..", "config.example.toml")
dir := filepath.Join("..", "..", "..", "deployments")
entries, err := os.ReadDir(dir)
if err != nil {
t.Fatal(err)
}
for _, e := range entries {
if filepath.Ext(e.Name()) != ".toml" {
continue
}
t.Run(e.Name(), func(t *testing.T) {
doc, err := New(nil).Overlay(base, filepath.Join(dir, e.Name()))
if err != nil {
t.Fatal(err)
}
if len(doc.UnknownKeys) != 0 {
t.Errorf("%s has unknown keys: %v", e.Name(), doc.UnknownKeys)
}
})
}
}
// TestRemovedFieldsSurfaceAsUnknownKeys pins the removal of two fields that
// were decoded but read nowhere. Once they are gone the compiler guards
// nothing, so the unknown-key detector is the only thing left that can tell an
// operator their setting does nothing -- which is the whole reason to remove
// them rather than leave a live-looking knob wired to nothing.
func TestRemovedFieldsSurfaceAsUnknownKeys(t *testing.T) {
tests := []struct {
name string
block string
key string
}{
{
name: "memory session_ttl",
block: "[memory]\nsession_ttl = \"72h\"\n",
key: "memory.session_ttl",
},
{
name: "tool policy parallel_execution",
block: "[tools.tool_policy]\nparallel_execution = true\n",
key: "tools.tool_policy.parallel_execution",
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
path := filepath.Join(t.TempDir(), "config.toml")
if err := os.WriteFile(path, []byte(minimalValidConfigTOML+tt.block), 0o600); err != nil {
t.Fatal(err)
}
doc, err := New(nil).File(path)
if err != nil {
t.Fatalf("File: %v (a removed key must not fail the load)", err)
}
if slices.Contains(doc.UnknownKeys, tt.key) {
return
}
t.Errorf("UnknownKeys = %v, want it to contain %q", doc.UnknownKeys, tt.key)
})
}
}