package configuration import ( "encoding/json" "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 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" state_dir = "~/archie/state" [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")}, "state_dir": {got: cfg.StateDir, want: filepath.Join(home, "archie", "state")}, "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) } }) } } // state_dir defaults to archie's directory under the data home. func TestStateDirDefaultsToTheDataHome(t *testing.T) { dataHome := t.TempDir() t.Setenv("XDG_DATA_HOME", dataHome) path := filepath.Join(t.TempDir(), "config.toml") contents := ` bot_user = "widget" [[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) } if want := filepath.Join(dataHome, "archie"); cfg.StateDir != want { t.Fatalf("StateDir = %q, want %q", cfg.StateDir, 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) } }) } } func TestLoadTelegramTokenSecretRef(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" + "[[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) } } // 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, }, } 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") } }) } } // 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]\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]\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" + "[log]\nlevel = \"warn\"\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[log]\nlevel = \"debug\"\n" + "[nats]\nurl = \"nats://nats:4222\"\n" + "[containers]\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.Log.Level != "debug" { t.Errorf("Log.Level: got %q, want %q", cfg.Log.Level, "debug") } // 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.Log.Level != "warn" { t.Errorf("Log.Level with empty overlay: got %q, want %q", baseOnly.Log.Level, "warn") } } // 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) } }, }, { 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 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 = { engine = "env", key = "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 = { engine = "env", key = "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()) }