MemoryConfig.SessionTTL and ToolPolicy.ParallelExecution were decoded by config loading and read nowhere, so setting either silently did nothing. Removing them routes both keys into the unknown-key detector, which names them in a boot warning instead. A live-looking knob wired to nothing is the worse state, and the sibling memory.provider already earned a loud load-time rejection for exactly this. Also drops the config.example.toml line that shipped session_ttl into every first-run config.toml via configtemplate.go, and the commented-out dir_test.go assertions that would have re-created both fields under that file's "make these pass without modifying them" header.
169 lines
5.5 KiB
Go
169 lines
5.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" +
|
|
"[agent]\nmode = \"inprocess\"\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")
|
|
}
|
|
}
|
|
|
|
// 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)
|
|
})
|
|
}
|
|
}
|