Files
archie/internal/infrastructure/configuration/loader_test.go
T
sam 9a45a35c27 fix(config): judge a database-owned setting at the layer that owns it
Review of the two previous commits found the split was incomplete in both
directions: the checks moved off the file load path were still enforced
anywhere the value could enter the system, and the fold reached only one of the
three overlay paths.

A stale database-owned TOML value could still stop archie-state-store. The
process seeds every control-plane resource from the same file config on a fresh
database, and the seed runs the resource's own validator; three of the five
values the loader now accepts aborted the boot there (verified by booting
RunStateStore before the fix). A seed that does not validate is now SKIPPED and
reported instead of fatal: the resource stays absent, so the file's value is the
one in effect and editing config.toml is still the fix -- the daemon and the
Gateway are where it fails closed, at boot.runtimeConfig.

The resource validators were weaker than configuration.Validate for exactly the
fields the split reclassified, so a value the file path used to refuse at load
became storable in the database, and then un-fixable by editing config.toml.
The trigger enum and the test-glob rule now come from the configuration package
rather than being restated, the container image is required there as it is in the
file, and a table test ties the two layers together value by value.

The directory form of -config-overlay kept the archie-core-e2e2 failure: it
decoded each overlay file straight into the populated config, so a map-valued
entry it only partly addressed still cleared the fields it did not name. Both
the overlay layer's main file and its feature files now fold, which is what
Loader.Dir's documented parity with Loader.Overlay has always claimed.

The overlay file's key report is derived from the apply's own view of the file as
well as the file decode's, because TOML matches keys case-insensitively and the
fold's yaml decode does not: a key only the file decode matched was consumed by
the report and dropped by the apply, a silent no-op that worked in the base file.

Tests: the state-store boot is asserted against the real process, the directory
overlay and the case-mismatched key each have one, and ImportConfig pins that a
refused seed is not stored.
2026-09-21 22:12:32 +10:00

1086 lines
36 KiB
Go

package configuration
import (
"encoding/json"
"fmt"
"os"
"path/filepath"
"strings"
"testing"
"time"
"github.com/samcharles93/archie-core/internal/config"
"github.com/samcharles93/archie-core/internal/secret"
)
func TestLoadDispatchAckReaction(t *testing.T) {
tests := []struct {
name string
dispatch string
wantAck string
}{
{name: "default", wantAck: "eyes"},
{name: "disabled", dispatch: "\n[dispatch]\nack_reaction = \"off\"\n", wantAck: ""},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
path := filepath.Join(t.TempDir(), "config.toml")
contents := "bot_user = \"widget\"\n" + tt.dispatch + "\n[[repos]]\nowner = \"acme\"\nname = \"app\"\n"
if err := os.WriteFile(path, []byte(contents), 0o600); err != nil {
t.Fatal(err)
}
cfg, err := loadFile(path)
if err != nil {
t.Fatal(err)
}
if cfg.Dispatch.AckReaction != tt.wantAck {
t.Errorf("AckReaction: got %q, want %q", cfg.Dispatch.AckReaction, tt.wantAck)
}
})
}
}
func TestLegacyContainersEnabledCannotSelectExecutionTopology(t *testing.T) {
for _, enabled := range []bool{false, true} {
t.Run(map[bool]string{false: "disabled", true: "enabled"}[enabled], func(t *testing.T) {
path := filepath.Join(t.TempDir(), "config.toml")
contents := fmt.Sprintf("bot_user = \"widget\"\n[forge]\ntype = \"none\"\n[containers]\nenabled = %t\n", enabled)
if err := os.WriteFile(path, []byte(contents), 0o600); err != nil {
t.Fatal(err)
}
doc, err := New(nil).File(path)
if err != nil {
t.Fatal(err)
}
if doc.Config.Containers.LegacyEnabled != enabled {
t.Errorf("LegacyEnabled = %v, want decoded %v", doc.Config.Containers.LegacyEnabled, enabled)
}
if doc.Config.Containers.Image != defaultContainerImage {
t.Errorf("Image = %q, want mandatory default %q", doc.Config.Containers.Image, defaultContainerImage)
}
})
}
}
func TestLoadExpandsConfiguredHomePaths(t *testing.T) {
home, err := os.UserHomeDir()
if err != nil {
t.Fatal(err)
}
path := filepath.Join(t.TempDir(), "config.toml")
contents := `
bot_user = "widget"
work_dir = "~/archie/work"
db_path = "~/archie/archie.db"
[chat]
workspace = "~/archie/workspace"
[[repos]]
owner = "acme"
name = "app"
`
if err := os.WriteFile(path, []byte(contents), 0o600); err != nil {
t.Fatal(err)
}
cfg, err := loadFile(path)
if err != nil {
t.Fatal(err)
}
wants := map[string]struct {
got string
want string
}{
"work_dir": {got: cfg.WorkDir, want: filepath.Join(home, "archie", "work")},
"db_path": {got: cfg.DBPath, want: filepath.Join(home, "archie", "archie.db")},
"chat.workspace": {got: cfg.Chat.Workspace, want: filepath.Join(home, "archie", "workspace")},
}
for name, tt := range wants {
t.Run(name, func(t *testing.T) {
if tt.got != tt.want {
t.Errorf("got %q, want %q", tt.got, tt.want)
}
})
}
}
func TestResolveSelectsFileFormatsAndDirectories(t *testing.T) {
tests := []struct {
name string
prepare func(t *testing.T, dir string) string
wantUser string
wantPath string
}{
{
name: "toml file",
prepare: func(t *testing.T, dir string) string {
path := filepath.Join(dir, "config.toml")
if err := os.WriteFile(path, []byte("bot_user = \"toml-bot\"\n[[repos]]\nowner = \"acme\"\nname = \"app\"\n"), 0o600); err != nil {
t.Fatal(err)
}
return path
},
wantUser: "toml-bot", wantPath: "config.toml",
},
{
name: "yaml file",
prepare: func(t *testing.T, dir string) string {
path := filepath.Join(dir, "config.yaml")
if err := os.WriteFile(path, []byte("bot_user: yaml-bot\nrepos:\n - owner: acme\n name: app\n"), 0o600); err != nil {
t.Fatal(err)
}
return path
},
wantUser: "yaml-bot", wantPath: "config.yaml",
},
{
name: "directory",
prepare: func(t *testing.T, dir string) string {
if err := os.WriteFile(filepath.Join(dir, "config.yaml"), []byte("bot_user: directory-bot\nrepos:\n - owner: acme\n name: app\n"), 0o600); err != nil {
t.Fatal(err)
}
return dir
},
wantUser: "directory-bot", wantPath: "config.yaml",
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
dir := t.TempDir()
doc, err := New(nil).Resolve(tt.prepare(t, dir), "")
if err != nil {
t.Fatal(err)
}
if doc.Config.BotUser != tt.wantUser {
t.Errorf("BotUser = %q, want %q", doc.Config.BotUser, tt.wantUser)
}
if got := filepath.Base(doc.Provenance.Paths()[0]); got != tt.wantPath {
t.Errorf("provenance path = %q, want %q", got, tt.wantPath)
}
})
}
}
// TestLoadForgeTokenEnvBackwardCompat guards against a real production
// incident: the secrets-engine migration replaced [forge]'s flat
// token_env string with a {engine, key} struct, but TOML silently ignores
// unknown fields — so deployed configs still using the old token_env key
// had their token config dropped entirely and finalize() defaulted to
// demanding ARCHIE_GITHUB_TOKEN, crash-looping a gitea-backed daemon.
func TestLoadForgeTokenEnvBackwardCompat(t *testing.T) {
path := filepath.Join(t.TempDir(), "config.toml")
contents := "bot_user = \"widget\"\n" +
"[forge]\ntype = \"gitea\"\nhost = \"https://git.example.test\"\ntoken_env = \"MY_GITEA_TOKEN\"\n" +
"[[repos]]\nowner = \"acme\"\nname = \"app\"\n"
if err := os.WriteFile(path, []byte(contents), 0o600); err != nil {
t.Fatal(err)
}
cfg, err := loadFile(path)
if err != nil {
t.Fatal(err)
}
if cfg.Forge.Token != (secret.SecretRef{Engine: "env", Key: "MY_GITEA_TOKEN"}) {
t.Errorf("Forge.Token = %#v, want {env MY_GITEA_TOKEN} (from legacy token_env)", cfg.Forge.Token)
}
}
// TestLoadForgeTokenTakesPrecedenceOverTokenEnv verifies the new-style
// [forge.token] wins when both the legacy token_env and the new token
// struct are present (e.g. mid-migration configs).
func TestLoadForgeTokenTakesPrecedenceOverTokenEnv(t *testing.T) {
path := filepath.Join(t.TempDir(), "config.toml")
contents := "bot_user = \"widget\"\n" +
"[forge]\ntype = \"gitea\"\ntoken_env = \"OLD_TOKEN\"\n" +
"[forge.token]\nengine = \"env\"\nkey = \"NEW_TOKEN\"\n" +
"[[repos]]\nowner = \"acme\"\nname = \"app\"\n"
if err := os.WriteFile(path, []byte(contents), 0o600); err != nil {
t.Fatal(err)
}
cfg, err := loadFile(path)
if err != nil {
t.Fatal(err)
}
if cfg.Forge.Token != (secret.SecretRef{Engine: "env", Key: "NEW_TOKEN"}) {
t.Errorf("Forge.Token = %#v, want {env NEW_TOKEN} (new-style token wins)", cfg.Forge.Token)
}
}
func TestLoadTelegramTokenSecretRefAndLegacyFallback(t *testing.T) {
path := filepath.Join(t.TempDir(), "config.toml")
contents := "bot_user = \"widget\"\n" +
"[chat.telegram]\ntoken = { engine = \"bws\", key = \"TELEGRAM_BOT_TOKEN\" }\n" +
"token_env = \"TELEGRAM_LEGACY_TOKEN\"\n" +
"[[repos]]\nowner = \"acme\"\nname = \"app\"\n"
if err := os.WriteFile(path, []byte(contents), 0o600); err != nil {
t.Fatal(err)
}
cfg, err := loadFile(path)
if err != nil {
t.Fatal(err)
}
want := secret.SecretRef{Engine: "bws", Key: "TELEGRAM_BOT_TOKEN"}
if cfg.Chat.Telegram.Token != want {
t.Errorf("Telegram.Token = %#v, want %#v", cfg.Chat.Telegram.Token, want)
}
if cfg.Chat.Telegram.TokenEnv != "TELEGRAM_LEGACY_TOKEN" {
t.Errorf("Telegram.TokenEnv = %q, want TELEGRAM_LEGACY_TOKEN", cfg.Chat.Telegram.TokenEnv)
}
}
// TestLoadRejectsInvalidConfigEnumsAndGlobs pins which layer rejects each kind
// of invalid value. Every file source produces a BOOTSTRAP document, and the
// settings the control plane owns are layered over it later; a stale TOML value
// in one of those must not fail the load (docs/prds/runtime-control-plane.md,
// "Bootstrap, migration, and recovery"). So a check over a database-owned
// setting is asserted with Validate instead -- what boot.runtimeConfig runs over
// the document a process will use, and the checks the loader no longer applies.
// Each case asserts both halves it applies to, so a check that quietly
// disappeared fails the case rather than passing it.
func TestLoadRejectsInvalidConfigEnumsAndGlobs(t *testing.T) {
tests := []struct {
name string
body string
wantLoadErr bool
}{
{
name: "dispatch trigger",
body: fileConfigPrefix + "[dispatch]\ntrigger = \"labels\"\n",
},
{
name: "provider userinfo",
body: fileConfigPrefix + "[providers.openai]\nclass = \"openai\"\nbase_url = \"https://token@example.com/v1\"\n",
},
{
name: "provider query secret",
body: fileConfigPrefix + "[providers.openai]\nclass = \"openai\"\nbase_url = \"https://example.com/v1?api_key=secret\"\n",
},
{
name: "test glob",
body: fileConfigPrefix + "[[repos]]\nowner = \"acme\"\nname = \"app\"\ntest_glob = \"[\"\n",
},
{
// File-owned settings: no control-plane resource carries them, so
// the load path is the layer that has to reject them.
name: "forge intake",
body: fileConfigPrefix + "[forge]\nintake = \"not-a-real-intake\"\n",
wantLoadErr: true,
},
{
name: "memory engine",
body: fileConfigPrefix + "[memory]\nengine = \"not-a-real-engine\"\n",
wantLoadErr: true,
},
{
name: "negative capture retention",
body: fileConfigPrefix + "[capture]\nretention = \"-1h\"\n",
wantLoadErr: true,
},
{
name: "image default naming no provider",
body: fileConfigPrefix + "[image]\ndefault = \"not-a-real-provider\"\n",
wantLoadErr: true,
},
}
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(tt.body), 0o600); err != nil {
t.Fatal(err)
}
doc, err := New(nil).File(path)
if tt.wantLoadErr {
if err == nil {
t.Fatal("File() = nil error, want the bootstrap document rejected")
}
return
}
if err != nil {
t.Fatalf("File: %v (a database-owned value must not fail the load)", err)
}
if err := Validate(&doc.Config); err == nil {
t.Fatal("Validate = nil, want the value rejected there")
}
})
}
}
func TestLoadLegacyAgentSectionWithoutApplyingExecutionDefaults(t *testing.T) {
tests := []struct {
name string
agent string
wantMode string
wantCommand string
wantEnv []string
}{
{name: "absent section stays empty"},
{
name: "legacy values decode without validation", agent: "\n[agent]\nmode = \"removed-mode\"\ncommand = \"/opt/old-agent\"\nenv = [\"TOKEN=value\"]\n",
wantMode: "removed-mode", wantCommand: "/opt/old-agent", wantEnv: []string{"TOKEN=value"},
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
path := filepath.Join(t.TempDir(), "config.toml")
contents := "bot_user = \"widget\"\n" + tt.agent + "\n[[repos]]\nowner = \"acme\"\nname = \"app\"\n"
if err := os.WriteFile(path, []byte(contents), 0o600); err != nil {
t.Fatal(err)
}
cfg, err := loadFile(path)
if err != nil {
t.Fatal(err)
}
if cfg.LegacyAgent.Mode != tt.wantMode || cfg.LegacyAgent.Command != tt.wantCommand || strings.Join(cfg.LegacyAgent.Env, ",") != strings.Join(tt.wantEnv, ",") {
t.Fatalf("legacy agent config = %#v", cfg.LegacyAgent)
}
})
}
}
// TestLoadToolPolicyDefaultsAndOverrides covers the result-size and turn-budget
// limits end to end from TOML. Before these fields carried toml tags they could
// not be set from the daemon's config at all, so a test that only exercised
// defaulting would have passed against a setting no operator could reach.
//
// A negative value means "disabled" rather than zero: defaulting cannot tell an
// explicit 0 from an absent key, so zero has to stay available as "unset".
func TestLoadToolPolicyDefaultsAndOverrides(t *testing.T) {
tests := []struct {
name string
policy string
wantMaxResult int
wantSpillDir string
}{
{
// SpillDir has no default on purpose: a path outside
// chat.workspace is one the read tool refuses, so the model would
// be handed a reference it cannot open. Absent means truncate
// inline.
name: "defaults",
wantMaxResult: 50_000,
wantSpillDir: "",
},
{
name: "explicit values",
policy: "[tools.tool_policy]\nmax_result_chars = 1234\nspill_dir = \"/var/spool/archie\"\n",
wantMaxResult: 1234,
wantSpillDir: "/var/spool/archie",
},
{
name: "negative disables the per-result cap",
policy: "[tools.tool_policy]\nmax_result_chars = -1\n",
wantMaxResult: -1,
wantSpillDir: "",
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
path := filepath.Join(t.TempDir(), "config.toml")
contents := "bot_user = \"widget\"\n" + tt.policy +
"\n[[repos]]\nowner = \"acme\"\nname = \"app\"\n"
if err := os.WriteFile(path, []byte(contents), 0o600); err != nil {
t.Fatal(err)
}
cfg, err := loadFile(path)
if err != nil {
t.Fatal(err)
}
policy := cfg.Tools.Policy
if policy.MaxResultChars != tt.wantMaxResult {
t.Errorf("MaxResultChars = %d, want %d", policy.MaxResultChars, tt.wantMaxResult)
}
if policy.SpillDir != tt.wantSpillDir {
t.Errorf("SpillDir = %q, want %q", policy.SpillDir, tt.wantSpillDir)
}
})
}
}
func TestRemovedTurnCapsAreIgnoredByLegacyConfig(t *testing.T) {
path := filepath.Join(t.TempDir(), "config.toml")
contents := "bot_user = \"widget\"\n[budgets]\nmax_tokens = 1\n" +
"[tools.tool_policy]\nmax_result_chars = 1234\nturn_budget_chars = 1\n" +
"[[repos]]\nowner = \"acme\"\nname = \"app\"\n"
if err := os.WriteFile(path, []byte(contents), 0o600); err != nil {
t.Fatal(err)
}
cfg, err := loadFile(path)
if err != nil {
t.Fatal(err)
}
encoded, err := json.Marshal(cfg)
if err != nil {
t.Fatal(err)
}
for _, removed := range []string{"max_tokens", "turn_budget_chars"} {
if strings.Contains(string(encoded), removed) {
t.Fatalf("removed turn cap %q survived config decode: %s", removed, encoded)
}
}
if cfg.Tools.Policy.MaxResultChars != 1234 {
t.Fatalf("per-tool result cap = %d, want 1234", cfg.Tools.Policy.MaxResultChars)
}
}
// TestLoadWebFetchDefaultsAndOverrides covers the fetch tool's settings.
//
// The enabled case matters most: it is a pointer precisely so an operator can
// turn the tool off, which a plain bool could not express because defaulting
// cannot tell `enabled = false` from an absent key.
func TestLoadWebFetchDefaultsAndOverrides(t *testing.T) {
tests := []struct {
name string
webFetch string
wantEnabled bool
wantTimeout time.Duration
wantMaxBytes int64
wantPrivate bool
}{
{
name: "defaults",
wantEnabled: true,
wantTimeout: 30 * time.Second,
wantMaxBytes: 2_000_000,
},
{
name: "explicitly disabled",
webFetch: "[tools.web_fetch]\nenabled = false\n",
wantEnabled: false,
wantTimeout: 30 * time.Second,
wantMaxBytes: 2_000_000,
},
{
name: "overrides",
webFetch: "[tools.web_fetch]\ntimeout = \"5s\"\nmax_bytes = 4096\nallow_private_networks = true\n",
wantEnabled: true,
wantTimeout: 5 * time.Second,
wantMaxBytes: 4096,
wantPrivate: true,
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
path := filepath.Join(t.TempDir(), "config.toml")
contents := "bot_user = \"widget\"\n" + tt.webFetch +
"\n[[repos]]\nowner = \"acme\"\nname = \"app\"\n"
if err := os.WriteFile(path, []byte(contents), 0o600); err != nil {
t.Fatal(err)
}
cfg, err := loadFile(path)
if err != nil {
t.Fatal(err)
}
wf := cfg.Tools.WebFetch
if got := wf.IsEnabled(); got != tt.wantEnabled {
t.Errorf("IsEnabled() = %v, want %v", got, tt.wantEnabled)
}
if got := wf.Timeout.Std(); got != tt.wantTimeout {
t.Errorf("Timeout = %s, want %s", got, tt.wantTimeout)
}
if wf.MaxBytes != tt.wantMaxBytes {
t.Errorf("MaxBytes = %d, want %d", wf.MaxBytes, tt.wantMaxBytes)
}
if wf.AllowPrivateNetworks != tt.wantPrivate {
t.Errorf("AllowPrivateNetworks = %v, want %v", wf.AllowPrivateNetworks, tt.wantPrivate)
}
})
}
}
func TestLoadContainerVolumeTTL(t *testing.T) {
tests := []struct {
name string
ttl string
wantTTL time.Duration
}{
{name: "default", wantTTL: 72 * time.Hour},
{name: "explicit", ttl: "volume_ttl = \"6h\"\n", wantTTL: 6 * time.Hour},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
path := filepath.Join(t.TempDir(), "config.toml")
contents := "bot_user = \"widget\"\n" +
"[nats]\nurl = \"nats://localhost:4222\"\n" +
"[containers]\nenabled = true\nimage = \"archie-agent:test\"\n" + tt.ttl +
"[[repos]]\nowner = \"acme\"\nname = \"app\"\npersistent_storage = true\n"
if err := os.WriteFile(path, []byte(contents), 0o600); err != nil {
t.Fatal(err)
}
cfg, err := loadFile(path)
if err != nil {
t.Fatal(err)
}
if got := cfg.Containers.VolumeTTL.Std(); got != tt.wantTTL {
t.Fatalf("Containers.VolumeTTL = %s, want %s", got, tt.wantTTL)
}
})
}
}
// TestLoadRejectsNegativeContainerVolumeTTL: containers are a control-plane
// resource (container-runtime-policies), so a negative volume_ttl is judged by
// Validate rather than by the load path -- a stale TOML value in a database-owned
// setting must not fail a process's startup. The second half of the assertion is
// what keeps dropping the check from passing this test.
func TestLoadRejectsNegativeContainerVolumeTTL(t *testing.T) {
path := filepath.Join(t.TempDir(), "config.toml")
contents := "bot_user = \"widget\"\n" +
"[nats]\nurl = \"nats://localhost:4222\"\n" +
"[containers]\nenabled = true\nimage = \"archie-agent:test\"\nvolume_ttl = \"-1h\"\n" +
"[[repos]]\nowner = \"acme\"\nname = \"app\"\npersistent_storage = true\n"
if err := os.WriteFile(path, []byte(contents), 0o600); err != nil {
t.Fatal(err)
}
doc, err := New(nil).File(path)
if err != nil {
t.Fatalf("File: %v (a database-owned value must not fail the load)", err)
}
if err := Validate(&doc.Config); err == nil {
t.Fatal("Validate accepted a negative containers.volume_ttl")
}
}
func TestExampleConfigLoads(t *testing.T) {
cfg, err := loadFile(filepath.Join("..", "..", "..", "config.example.toml"))
if err != nil {
t.Fatal(err)
}
if cfg.Forge.Host != "https://github.com" {
t.Errorf("Forge.Host: got %q", cfg.Forge.Host)
}
if cfg.Dispatch.AckReaction != "eyes" {
t.Errorf("Dispatch.AckReaction: got %q", cfg.Dispatch.AckReaction)
}
// [[repos]] is commented out in the template on purpose: an active
// example here would validate as a normal repo (owner/name are only
// checked for non-empty) and archied would silently poll one that
// doesn't exist. At least one entry is required before archied will
// poll anything, but the template cannot supply it -- see the comment
// above [[repos]] in config.example.toml.
if len(cfg.Repos) != 0 {
t.Errorf("Repos: got %+v, want none: config.example.toml's [[repos]] entry is documentation, not a live default", cfg.Repos)
}
}
func TestOverlay(t *testing.T) {
dir := t.TempDir()
basePath := filepath.Join(dir, "config.toml")
base := "bot_user = \"widget\"\nwork_dir = \"/base/work\"\n" +
"[agent]\nmode = \"inprocess\"\n" +
"[[repos]]\nowner = \"acme\"\nname = \"app\"\n"
if err := os.WriteFile(basePath, []byte(base), 0o600); err != nil {
t.Fatal(err)
}
overlayPath := filepath.Join(dir, "config.docker.toml")
overlay := "work_dir = \"/var/lib/archie/work\"\n[agent]\nmode = \"nats\"\n" +
"[nats]\nurl = \"nats://nats:4222\"\n" +
"[containers]\nenabled = true\nimage = \"archie-agent:latest\"\n"
if err := os.WriteFile(overlayPath, []byte(overlay), 0o600); err != nil {
t.Fatal(err)
}
cfg, err := loadOverlay(basePath, overlayPath)
if err != nil {
t.Fatal(err)
}
// Overlay-set fields win.
if cfg.WorkDir != "/var/lib/archie/work" {
t.Errorf("WorkDir: got %q, want overlay value", cfg.WorkDir)
}
if cfg.LegacyAgent.Mode != "nats" {
t.Errorf("LegacyAgent.Mode: got %q, want %q", cfg.LegacyAgent.Mode, "nats")
}
// Fields the overlay omits keep the base value.
if cfg.BotUser != "widget" {
t.Errorf("BotUser: got %q, want base value", cfg.BotUser)
}
if len(cfg.Repos) != 1 || cfg.Repos[0].Owner != "acme" {
t.Errorf("Repos: got %+v, want base repos", cfg.Repos)
}
// No overlay path behaves like loadFile(basePath).
baseOnly, err := loadOverlay(basePath, "")
if err != nil {
t.Fatal(err)
}
if baseOnly.LegacyAgent.Mode != "inprocess" {
t.Errorf("LegacyAgent.Mode with empty overlay: got %q, want %q", baseOnly.LegacyAgent.Mode, "inprocess")
}
}
// TestResolveFileOverlayPreservesOmittedMapEntryFields characterizes the
// -config-overlay path at the depth the runtime overlay is already guarded at
// (TestApplyOverlayValuesPreservesOmittedNestedFields).
//
// It goes through Loader.Resolve, the production entry point, because the
// hazard was a property of how the overlay file is applied, not of any one
// decode helper: Loader.overlayFile decoded the overlay into the very config
// the base file produced, and a map-valued entry is replaced wholesale, so every
// field of that entry the overlay does not name was cleared.
//
// That is archie-core-e2e2 on a user-visible path. deployments/dev.toml is the
// documented -config-overlay argument and sets [services.state] target/listen,
// while the installed config.toml is where [services.state].target_token lives:
// the overlay silently dropped the token. The directory form of the same flag is
// covered by TestDirOverlayPreservesOmittedMapEntryFields.
func TestResolveFileOverlayPreservesOmittedMapEntryFields(t *testing.T) {
tests := []struct {
name string
base string
overlayName string
overlay string
check func(t *testing.T, cfg config.Config)
}{
{
// The deployment shape quoted above, with the value that is read
// only when a client dials a non-loopback State Store.
name: "services.state entry keeps the token it does not name",
base: "[services.state]\ntarget = \"127.0.0.1:9090\"\ntarget_token = \"secret\"\n",
overlay: "[services.state]\ntarget = \"10.0.0.5:9090\"\n",
check: func(t *testing.T, cfg config.Config) {
t.Helper()
got := cfg.Services[config.ServiceNameState]
if got.Target != "10.0.0.5:9090" {
t.Errorf("services.state.target = %q, want the overlay's 10.0.0.5:9090", got.Target)
}
if got.TargetToken != "secret" {
t.Errorf("services.state.target_token = %q, want the base's secret: a file overlay must not clear a field it does not name", got.TargetToken)
}
},
},
{
// An enabled hosted provider must keep its class and key env: the
// overlay naming only base_url would otherwise clear them and fail
// validation after the load.
name: "image.hosted entry keeps the fields it does not name",
base: "[image.hosted.minimax]\nenabled = true\nclass = \"minimax\"\n" +
"api_key_env = \"MINIMAX_API_KEY\"\n",
overlay: "[image.hosted.minimax]\nbase_url = \"https://api.example\"\n",
check: func(t *testing.T, cfg config.Config) {
t.Helper()
got := cfg.Image.Hosted["minimax"]
want := config.ImageHostedProvider{
Enabled: true,
Class: "minimax",
APIKeyEnv: "MINIMAX_API_KEY",
BaseURL: "https://api.example",
}
if got != want {
t.Errorf("image.hosted.minimax = %+v, want %+v", got, want)
}
},
},
{
name: "providers entry keeps the fields it does not name",
base: "[providers.anthropic]\nclass = \"anthropic\"\n" +
"api_key_env = \"ANTHROPIC_API_KEY\"\n",
overlay: "[providers.anthropic]\nbase_url = \"https://proxy.example\"\n",
check: func(t *testing.T, cfg config.Config) {
t.Helper()
got := cfg.Providers["anthropic"]
want := config.Provider{
Class: "anthropic",
APIKeyEnv: "ANTHROPIC_API_KEY",
BaseURL: "https://proxy.example",
}
if got != want {
t.Errorf("providers.anthropic = %+v, want %+v", got, want)
}
},
},
{
// The overlay file may be YAML (-config-overlay accepts either
// format), and it is folded by the same code.
name: "yaml overlay keeps the token it does not name",
base: "[services.state]\ntarget = \"127.0.0.1:9090\"\ntarget_token = \"secret\"\n",
overlayName: "dev.yaml",
overlay: "services:\n state:\n target: 10.0.0.5:9090\n",
check: func(t *testing.T, cfg config.Config) {
t.Helper()
got := cfg.Services[config.ServiceNameState]
if got.Target != "10.0.0.5:9090" {
t.Errorf("services.state.target = %q, want the overlay's 10.0.0.5:9090", got.Target)
}
if got.TargetToken != "secret" {
t.Errorf("services.state.target_token = %q, want the base's secret", got.TargetToken)
}
},
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
dir := t.TempDir()
basePath := filepath.Join(dir, "config.toml")
overlayName := tt.overlayName
if overlayName == "" {
overlayName = "dev.toml"
}
overlayPath := filepath.Join(dir, overlayName)
if err := os.WriteFile(basePath, []byte(minimalValidConfigTOML+tt.base), 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", err)
}
tt.check(t, doc.Config)
})
}
}
// TestLoadAcceptsStaleDatabaseOwnedValues is the bootstrap half of the layer
// split (archie-core-i3qm). docs/prds/runtime-control-plane.md,
// "Bootstrap, migration, and recovery": after migration, settings in TOML are
// ignored and cannot block State Store startup. The other half is the boot
// itself -- archie-state-store seeds these same settings into the control plane
// on a fresh database, and a seed it cannot validate is skipped rather than fatal
// (TestStateStoreBootsWithStaleDatabaseOwnedValues boots the process for that).
//
// Each case is a setting with a control-plane resource behind it, seeded from
// that field by controlplane.Server.ImportConfig: providers
// (provider-settings), poll_interval and dispatch (scheduling-policy),
// containers (container-runtime-policies), repositories
// (repository-policies). The second assertion is what keeps this from being a
// weaker gate: the value is still rejected by Validate, which is what the daemon
// and the Gateway run over the document a process will actually use. Nothing in
// this package layers that document, so the check here is the file document on
// its own -- the test is that the loader judges no database-owned field, not
// that the value is harmless.
func TestLoadAcceptsStaleDatabaseOwnedValues(t *testing.T) {
tests := []struct {
name string
body string
}{
{
name: "providers base_url carries userinfo",
body: fileConfigPrefix + "[providers.openai]\nclass = \"openai\"\nbase_url = \"https://token@example.com/v1\"\n",
},
{
name: "negative poll_interval",
body: fileConfigPrefix + "poll_interval = \"-5s\"\n",
},
{
name: "unrecognised dispatch.trigger",
body: fileConfigPrefix + "[dispatch]\ntrigger = \"labels\"\n",
},
{
name: "negative containers.volume_ttl",
body: fileConfigPrefix + "[containers]\nvolume_ttl = \"-1m\"\n",
},
{
name: "malformed repos test_glob",
body: fileConfigPrefix + "[[repos]]\nowner = \"acme\"\nname = \"app\"\ntest_glob = \"[\"\n",
},
}
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(tt.body), 0o600); err != nil {
t.Fatal(err)
}
doc, err := New(nil).File(path)
if err != nil {
t.Fatalf("File: %v (a stale database-owned value must not fail the load)", err)
}
if err := Validate(&doc.Config); err == nil {
t.Fatal("Validate = nil, want the control plane's own layer to reject it")
}
})
}
}
// fileConfigPrefix is the smallest document the load path accepts on its own,
// so each case above adds one stale setting and nothing else.
const fileConfigPrefix = "bot_user = \"widget\"\nwork_dir = \"/base/work\"\n"
// TestDirOverlayPreservesOmittedMapEntryFields is the directory form of the
// same guarantee TestResolveFileOverlayPreservesOmittedMapEntryFields pins.
// -config-overlay accepts a directory as well as a file, Loader.Dir documents
// "the same field-level precedence as [Loader.Overlay]", and Loader.Resolve
// routes a directory source to Dir -- so a map-valued entry the overlay only
// partly addresses must keep the fields it does not name on both forms of the
// flag, including when the entry arrives through a feature file.
func TestDirOverlayPreservesOmittedMapEntryFields(t *testing.T) {
tests := []struct {
name string
baseFiles map[string]string
overlayFiles map[string]string
check func(t *testing.T, cfg config.Config)
}{
{
name: "main config keeps the token it does not name",
baseFiles: map[string]string{
"config.yaml": "bot_user: widget\nservices:\n state:\n target: 127.0.0.1:9090\n target_token: secret\n",
},
overlayFiles: map[string]string{
"config.yaml": "services:\n state:\n target: 10.0.0.5:9090\n",
},
check: func(t *testing.T, cfg config.Config) {
t.Helper()
got := cfg.Services[config.ServiceNameState]
if got.Target != "10.0.0.5:9090" {
t.Errorf("services.state.target = %q, want the overlay's 10.0.0.5:9090", got.Target)
}
if got.TargetToken != "secret" {
t.Errorf("services.state.target_token = %q, want the base's secret: a directory overlay must not clear a field it does not name", got.TargetToken)
}
},
},
{
name: "feature file keeps the fields it does not name",
baseFiles: map[string]string{
"config.yaml": "bot_user: widget\n",
"config.models.yaml": "providers:\n anthropic:\n class: anthropic\n api_key_env: ANTHROPIC_API_KEY\n",
},
overlayFiles: map[string]string{
"config.models.yaml": "providers:\n anthropic:\n base_url: https://proxy.example\n",
},
check: func(t *testing.T, cfg config.Config) {
t.Helper()
got := cfg.Providers["anthropic"]
want := config.Provider{
Class: "anthropic",
APIKeyEnv: "ANTHROPIC_API_KEY",
BaseURL: "https://proxy.example",
}
if got != want {
t.Errorf("providers.anthropic = %+v, want %+v", got, want)
}
},
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
baseDir, overlayDir := tmpConfigDir(t), tmpConfigDir(t)
for name, content := range tt.baseFiles {
writeFile(t, baseDir, name, content)
}
for name, content := range tt.overlayFiles {
writeFile(t, overlayDir, name, content)
}
doc, err := New(nil).Resolve(baseDir, overlayDir)
if err != nil {
t.Fatalf("Resolve: %v", err)
}
tt.check(t, doc.Config)
})
}
}
func TestLoadBytesDoesNotExist(t *testing.T) {
_, err := loadBytes(nil)
if err == nil {
t.Error("expected error from nil LoadBytes")
}
}
func TestFinalizeIndexingDefaults(t *testing.T) {
tests := []struct {
name string
extra string
wantIndex string
wantDBIsSet bool
}{
{
name: "defaults derive from work_dir",
// Both paths must land under the daemon's own work_dir so two
// archied instances on one host cannot share an index.
extra: "\nwork_dir = \"/srv/archie/work\"\n",
wantIndex: filepath.Join("/srv/archie/work", "indexes"),
wantDBIsSet: true,
},
{
name: "explicit index_dir is preserved",
extra: "\nwork_dir = \"/srv/archie/work\"\n" +
"[indexing]\nindex_dir = \"/mnt/fast/idx\"\n",
wantIndex: "/mnt/fast/idx",
wantDBIsSet: true,
},
}
for _, tc := range tests {
t.Run(tc.name, func(t *testing.T) {
path := filepath.Join(t.TempDir(), "config.toml")
// tc.extra precedes the table sections: a top-level key written
// after [[repos]] would be parsed as a member of that table.
contents := "bot_user = \"widget\"\n" + tc.extra +
"[forge]\ntype = \"gitea\"\nhost = \"https://git.example.test\"\ntoken_env = \"T\"\n" +
"[[repos]]\nowner = \"acme\"\nname = \"app\"\n"
if err := os.WriteFile(path, []byte(contents), 0o600); err != nil {
t.Fatal(err)
}
cfg, err := loadFile(path)
if err != nil {
t.Fatal(err)
}
if cfg.Indexing.IndexDir != tc.wantIndex {
t.Errorf("Indexing.IndexDir = %q, want %q", cfg.Indexing.IndexDir, tc.wantIndex)
}
if tc.wantDBIsSet && cfg.Indexing.DBPath == "" {
t.Error("Indexing.DBPath is empty; want a default derived from work_dir")
}
})
}
}
func TestIdentitiesConfigParsesTwoIdentities(t *testing.T) {
cfg, err := loadBytes([]byte(`
bot_user = "default-legacy"
[[identities]]
name = "archie"
bot_user = "archie"
forge = { type = "gitea", host = "https://git.example.test", token = { engine = "env", key = "ARCHIE_TOKEN" } }
[[identities.repos]]
owner = "acme"
name = "archie-core"
base = "main"
ecosystem = "go"
[[identities]]
name = "winter"
bot_user = "winter"
forge = { type = "gitea", host = "https://git.example.test", token = { engine = "env", key = "WINTER_TOKEN" } }
[[identities.repos]]
owner = "acme"
name = "example-service"
base = "main"
ecosystem = "go"
`))
if err != nil {
t.Fatalf("LoadBytes: %v", err)
}
if len(cfg.Identities) != 2 {
t.Fatalf("len(Identities) = %d, want 2", len(cfg.Identities))
}
if cfg.Identities[0].Name != "archie" {
t.Errorf("Identities[0].Name = %q", cfg.Identities[0].Name)
}
if cfg.Identities[0].BotUser != "archie" {
t.Errorf("Identities[0].BotUser = %q", cfg.Identities[0].BotUser)
}
if cfg.Identities[0].Forge.Token != (secret.SecretRef{Engine: "env", Key: "ARCHIE_TOKEN"}) {
t.Errorf("Identities[0].Forge.Token = %#v", cfg.Identities[0].Forge.Token)
}
if len(cfg.Identities[0].Repos) != 1 || cfg.Identities[0].Repos[0].Name != "archie-core" {
t.Errorf("Identities[0].Repos = %+v", cfg.Identities[0].Repos)
}
if cfg.Identities[1].Name != "winter" {
t.Errorf("Identities[1].Name = %q", cfg.Identities[1].Name)
}
if cfg.Identities[1].BotUser != "winter" {
t.Errorf("Identities[1].BotUser = %q", cfg.Identities[1].BotUser)
}
if cfg.Identities[1].Forge.Token != (secret.SecretRef{Engine: "env", Key: "WINTER_TOKEN"}) {
t.Errorf("Identities[1].Forge.Token = %#v", cfg.Identities[1].Forge.Token)
}
if len(cfg.Identities[1].Repos) != 1 || cfg.Identities[1].Repos[0].Name != "example-service" {
t.Errorf("Identities[1].Repos = %+v", cfg.Identities[1].Repos)
}
}
func TestIdentitiesConfigFallsBackToLegacyWhenEmpty(t *testing.T) {
cfg, err := loadBytes([]byte(`
bot_user = "solo"
forge = { type = "github", host = "https://github.test", token_env = "GH_TOKEN" }
[[repos]]
owner = "acme"
name = "my-repo"
`))
if err != nil {
t.Fatalf("LoadBytes: %v", err)
}
if len(cfg.Identities) != 0 {
t.Errorf("len(Identities) = %d, want 0 (empty = legacy mode)", len(cfg.Identities))
}
if cfg.BotUser != "solo" {
t.Errorf("BotUser = %q, want solo (legacy field active)", cfg.BotUser)
}
}
func TestIdentitiesConfigRejectsEmptyName(t *testing.T) {
_, err := loadBytes([]byte(`
[[identities]]
bot_user = "no-name"
forge = { type = "github", token_env = "X" }
`))
if err == nil {
t.Error("expected error for identity with empty name")
}
}
func TestIdentitiesConfigRejectsMissingForgeToken(t *testing.T) {
// Unlike the top-level [forge], a per-identity forge has no default
// token -- each identity needs its own secret reference (e.g.
// distinct bot accounts each with their own token). Omitting it must
// be a startup error, not a silent empty-string token.
_, err := loadBytes([]byte(`
[[identities]]
name = "archie"
bot_user = "archie"
forge = { type = "github" }
[[identities.repos]]
owner = "acme"
name = "archie-core"
`))
if err == nil {
t.Fatal("expected error for identity with no forge.token")
}
if !strings.Contains(err.Error(), "forge.token") {
t.Errorf("error = %q, want mention of forge.token", err.Error())
}
}
// loadBytes writes data to a temporary file and loads it, so tests can
// exercise decoding without managing files themselves.
func loadBytes(data []byte) (config.Config, error) {
if data == nil {
return config.Config{}, os.ErrNotExist
}
tmp, err := os.CreateTemp("", "archie-config-*.toml")
if err != nil {
return config.Config{}, err
}
defer func() { _ = os.Remove(tmp.Name()) }()
if _, err := tmp.Write(data); err != nil {
_ = tmp.Close()
return config.Config{}, err
}
_ = tmp.Close()
return loadFile(tmp.Name())
}