package config import ( "encoding/json" "reflect" "strings" "testing" "time" "github.com/BurntSushi/toml" ) func TestTaskConfigToConfigRoundTrip(t *testing.T) { cfg := Config{ BotUser: "archie-bot", BotEmail: "archie-bot@users.noreply.github.com", DiffCapLines: new(321), Models: map[string]string{"builder": "anthropic/claude"}, Budgets: Budgets{MaxSteps: 12, WallClock: Duration(45 * time.Minute), GateMaxFailures: 3}, Dispatch: Dispatch{Trigger: "label", AckReaction: "eyes", Labels: map[string]string{"working": "bot:working"}}, Notify: Notify{Webhook: "https://notify.example.test/hook"}, Forge: Forge{Type: "github", Host: "https://forge.example.test", Token: SecretRef{Engine: "env", Key: "TOP_SECRET"}}, Tools: ToolsConfig{Policy: ToolPolicy{MaxResultChars: 50_000, SpillDir: "/var/tmp/archie-spill"}}, } got := cfg.ForTask().ToConfig() if got.Tools.Policy != cfg.Tools.Policy { t.Fatalf("Tools.Policy = %#v, want %#v", got.Tools.Policy, cfg.Tools.Policy) } if !reflect.DeepEqual(got.Models, cfg.Models) { t.Fatalf("Models = %#v, want %#v", got.Models, cfg.Models) } if got.Budgets != cfg.Budgets { t.Fatalf("Budgets = %#v, want %#v", got.Budgets, cfg.Budgets) } if !reflect.DeepEqual(got.Dispatch, cfg.Dispatch) { t.Fatalf("Dispatch = %#v, want %#v", got.Dispatch, cfg.Dispatch) } // Compared by effective value, not pointer: the round trip through // TaskConfig carries the resolved cap and rebuilds a fresh pointer. if got.DiffCap() != cfg.DiffCap() { t.Fatalf("DiffCap() = %d, want %d", got.DiffCap(), cfg.DiffCap()) } if got.Notify != cfg.Notify { t.Fatalf("Notify = %#v, want %#v", got.Notify, cfg.Notify) } if got.Forge.Host != cfg.Forge.Host { t.Fatalf("Forge.Host = %q, want %q", got.Forge.Host, cfg.Forge.Host) } if got.Forge.Token != (SecretRef{}) { t.Fatalf("Forge.Token = %#v, want zero value (never carried by TaskConfig)", got.Forge.Token) } } func TestMCPServerTOMLIncludesClientWorkingDirectory(t *testing.T) { var cfg Config if _, err := toml.Decode(` [[tools.mcp_servers]] name = "desktop-commander" transport = "stdio" command = "npx" args = ["-y", "@wonderwhy-er/desktop-commander@0.2.46", "--no-onboarding"] work_dir = "/workspace" `, &cfg); err != nil { t.Fatal(err) } if len(cfg.Tools.MCPServers) != 1 { t.Fatalf("MCPServers = %#v, want one server", cfg.Tools.MCPServers) } server := cfg.Tools.MCPServers[0] if server.Name != "desktop-commander" || server.Command != "npx" || server.WorkDir != "/workspace" { t.Fatalf("MCP server = %#v", server) } if len(server.Args) != 3 || server.Args[1] != "@wonderwhy-er/desktop-commander@0.2.46" { t.Fatalf("MCP args = %v", server.Args) } } func TestMCPServerParallelToolCallsDecodesFromTOML(t *testing.T) { tests := []struct { name string server string want bool }{ { name: "absent key leaves the server serialized", server: ` [[tools.mcp_servers]] name = "desktop-commander" command = "npx" `, }, { name: "parallel_tool_calls opts the server in", server: ` [[tools.mcp_servers]] name = "desktop-commander" command = "npx" parallel_tool_calls = true `, want: true, }, } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { var cfg Config if _, err := toml.Decode(tt.server, &cfg); err != nil { t.Fatal(err) } if len(cfg.Tools.MCPServers) != 1 { t.Fatalf("MCPServers = %#v, want one server", cfg.Tools.MCPServers) } if got := cfg.Tools.MCPServers[0].ParallelToolCalls; got != tt.want { t.Fatalf("ParallelToolCalls = %t, want %t", got, tt.want) } }) } } func TestChatModelCatalogDecodesFromTOML(t *testing.T) { var cfg Config if _, err := toml.Decode(` [chat] models = ["openai/gpt-5.6-sol", "openrouter/openai/gpt-5.6-sol"] `, &cfg); err != nil { t.Fatal(err) } if len(cfg.Chat.Models) != 2 || cfg.Chat.Models[1] != "openrouter/openai/gpt-5.6-sol" { t.Fatalf("chat models = %v", cfg.Chat.Models) } } func TestConfigForTaskJSONRoundTrip(t *testing.T) { cfg := Config{ DiffCapLines: new(321), Models: map[string]string{ "builder": "anthropic/claude", "planner": "openai/gpt", }, Budgets: Budgets{ MaxSteps: 12, WallClock: Duration(45 * time.Minute), GateMaxFailures: 3, }, Dispatch: Dispatch{ Trigger: "label", AckReaction: "eyes", Labels: map[string]string{"working": "bot:working"}, }, Notify: Notify{Webhook: "https://notify.example.test/hook"}, Forge: Forge{ Type: "github", Host: "https://forge.example.test", Token: SecretRef{Engine: "env", Key: "TOP_SECRET_FORGE_TOKEN"}, }, Providers: map[string]Provider{ "secret": {APIKeyEnv: "TOP_SECRET_PROVIDER_TOKEN"}, }, NATS: NATSConfig{TokenEnv: "TOP_SECRET_NATS_TOKEN"}, Tools: ToolsConfig{Policy: ToolPolicy{MaxResultChars: 50_000, SpillDir: "/var/tmp/archie-spill"}}, } want := TaskConfig{ BotUser: cfg.BotUser, BotEmail: cfg.BotEmail, Models: cfg.Models, Budgets: cfg.Budgets, Dispatch: cfg.Dispatch, DiffCapLines: cfg.DiffCap(), Notify: cfg.Notify, Forge: TaskForge{Host: cfg.Forge.Host}, ToolPolicy: cfg.Tools.Policy, } got := cfg.ForTask() if !reflect.DeepEqual(got, want) { t.Fatalf("ForTask() = %#v, want %#v", got, want) } cfg.Models["source-only"] = "source/model" if _, ok := got.Models["source-only"]; ok { t.Fatal("ForTask().Models aliases Config.Models") } got.Models["task-only"] = "task/model" if _, ok := cfg.Models["task-only"]; ok { t.Fatal("Config.Models aliases ForTask().Models") } cfg.Dispatch.Labels["source-only"] = "source:label" if _, ok := got.Dispatch.Labels["source-only"]; ok { t.Fatal("ForTask().Dispatch.Labels aliases Config.Dispatch.Labels") } got.Dispatch.Labels["task-only"] = "task:label" if _, ok := cfg.Dispatch.Labels["task-only"]; ok { t.Fatal("Config.Dispatch.Labels aliases ForTask().Dispatch.Labels") } data, err := json.Marshal(got) if err != nil { t.Fatal(err) } assertJSONKeys(t, data, "bot_user", "bot_email", "models", "budgets", "dispatch", "diff_cap_lines", "notify", "forge", "tool_policy") var forgePayload map[string]json.RawMessage var payload map[string]json.RawMessage if err := json.Unmarshal(data, &payload); err != nil { t.Fatal(err) } var budgetsPayload map[string]json.RawMessage if err := json.Unmarshal(payload["budgets"], &budgetsPayload); err != nil { t.Fatal(err) } if string(budgetsPayload["wall_clock"]) != `"45m0s"` { t.Fatalf("wall_clock = %s, want JSON duration string", budgetsPayload["wall_clock"]) } if err := json.Unmarshal(payload["forge"], &forgePayload); err != nil { t.Fatal(err) } if !reflect.DeepEqual(forgePayload, map[string]json.RawMessage{ "host": json.RawMessage(`"https://forge.example.test"`), }) { t.Fatalf("forge payload = %s, want only host", payload["forge"]) } for _, ref := range []string{ cfg.Forge.Token.Key, cfg.Providers["secret"].APIKeyEnv, cfg.NATS.TokenEnv, } { if strings.Contains(string(data), ref) { t.Fatalf("task config JSON contains credential reference %q: %s", ref, data) } } var roundTripped TaskConfig if err := json.Unmarshal(data, &roundTripped); err != nil { t.Fatal(err) } if !reflect.DeepEqual(roundTripped, got) { t.Fatalf("JSON round trip = %#v, want %#v", roundTripped, got) } } func TestRepoJSONRoundTrip(t *testing.T) { repo := Repo{ Owner: "acme", Name: "widget", Base: "develop", Gate: [][]string{{"task", "check"}, {"go", "test", "./..."}}, Protect: []string{"_templ.go", ".generated"}, Ecosystem: "go", Preflight: [][]string{{"go", "version"}}, TestGlob: "*_test.go", PersistentStorage: true, MaxRetries: 4, AllowConcurrent: true, ReviewEnabled: true, } data, err := json.Marshal(repo) if err != nil { t.Fatal(err) } assertJSONKeys( t, data, "owner", "name", "base", "gate", "protect", "ecosystem", "preflight", "test_glob", "persistent_storage", "max_retries", "allow_concurrent", "review_enabled", ) var got Repo if err := json.Unmarshal(data, &got); err != nil { t.Fatal(err) } if !reflect.DeepEqual(got, repo) { t.Fatalf("JSON round trip = %#v, want %#v", got, repo) } } func assertJSONKeys(t *testing.T, data []byte, want ...string) { t.Helper() var payload map[string]json.RawMessage if err := json.Unmarshal(data, &payload); err != nil { t.Fatal(err) } got := make(map[string]bool, len(payload)) for key := range payload { got[key] = true } wantSet := make(map[string]bool, len(want)) for _, key := range want { wantSet[key] = true } if !reflect.DeepEqual(got, wantSet) { t.Fatalf("JSON keys = %v, want %v", got, wantSet) } } func TestDispatchDefaults(t *testing.T) { // Simulate a config with no [dispatch] section -- all fields zero. var d Dispatch d.Labels = map[string]string{} // Per-key defaults (mimicking Load's loop). for k, v := range dispatchLabelDefaults { if d.Labels[k] == "" { d.Labels[k] = v } } if d.Trigger == "" { d.Trigger = "assignee" } if d.AckReaction == "" { d.AckReaction = "eyes" } // StateLabel should return the default agent:* labels. if got := d.StateLabel("queued"); got != "agent:queued" { t.Errorf("queued: got %q, want agent:queued", got) } if got := d.StateLabel("working"); got != "agent:working" { t.Errorf("working: got %q, want agent:working", got) } if got := d.StateLabel("waiting"); got != "agent:waiting" { t.Errorf("waiting: got %q, want agent:waiting", got) } if got := d.StateLabel("pr"); got != "agent:pr" { t.Errorf("pr: got %q, want agent:pr", got) } if got := d.StateLabel("parked"); got != "agent:parked" { t.Errorf("parked: got %q, want agent:parked", got) } // Unknown state returns empty. if got := d.StateLabel("nonexistent"); got != "" { t.Errorf("nonexistent: got %q, want empty", got) } // AckReaction default. if d.AckReaction != "eyes" { t.Errorf("AckReaction: got %q, want eyes", d.AckReaction) } // Trigger default. if d.Trigger != "assignee" { t.Errorf("Trigger: got %q, want assignee", d.Trigger) } } func TestDispatchCustomLabels(t *testing.T) { d := Dispatch{ Trigger: "label", AckReaction: "", Labels: map[string]string{ "queued": "bot:queued", "working": "bot:working", "parked": "bot:parked", // "waiting" and "pr" intentionally missing -- should fall back. }, } // Custom labels. if got := d.StateLabel("queued"); got != "bot:queued" { t.Errorf("queued: got %q, want bot:queued", got) } if got := d.StateLabel("parked"); got != "bot:parked" { t.Errorf("parked: got %q, want bot:parked", got) } // Missing keys fall back to defaults. if got := d.StateLabel("waiting"); got != "agent:waiting" { t.Errorf("waiting: got %q, want agent:waiting (fallback)", got) } if got := d.StateLabel("pr"); got != "agent:pr" { t.Errorf("pr: got %q, want agent:pr (fallback)", got) } // Empty AckReaction. if d.AckReaction != "" { t.Errorf("AckReaction: got %q, want empty", d.AckReaction) } // LabelValues returns all six state labels. vals := d.LabelValues() if len(vals) != 6 { t.Errorf("LabelValues: got %d values, want 6: %v", len(vals), vals) } seen := map[string]bool{} for _, v := range vals { seen[v] = true } for _, want := range []string{"bot:queued", "bot:working", "bot:parked", "agent:waiting", "agent:pr", "agent:dead"} { if !seen[want] { t.Errorf("LabelValues missing %q", want) } } } func TestDispatchLabelValuesDedup(t *testing.T) { // When two state keys map to the same label string, LabelValues // should deduplicate. d := Dispatch{ Labels: map[string]string{ "queued": "bot:queued", "working": "bot:queued", // same as queued "parked": "bot:queued", // same again }, } vals := d.LabelValues() // Should have "bot:queued" plus fallbacks for waiting, pr, and dead. if len(vals) != 4 { t.Errorf("LabelValues: got %d values, want 4: %v", len(vals), vals) } } func TestEcosystemDefaults(t *testing.T) { // Empty ecosystem → "go" (backward compat). r := Repo{} if got := r.effectiveEcosystem(); got != "go" { t.Errorf("effectiveEcosystem empty: got %q, want go", got) } if got := r.ResolvedTestGlob(); got != "*_test.go" { t.Errorf("ResolvedTestGlob empty: got %q, want *_test.go", got) } pre := r.ResolvedPreflight() if len(pre) != 1 || pre[0][0] != "go" || pre[0][1] != "version" { t.Errorf("ResolvedPreflight empty: got %v, want [[go version]]", pre) } // Explicit ecosystem. r2 := Repo{Ecosystem: "python"} if got := r2.ResolvedTestGlob(); got != "test_*.py" { t.Errorf("ResolvedTestGlob python: got %q, want test_*.py", got) } pre2 := r2.ResolvedPreflight() if len(pre2) != 1 || pre2[0][0] != "python" || pre2[0][1] != "--version" { t.Errorf("ResolvedPreflight python: got %v, want [[python --version]]", pre2) } } func TestEcosystemOverrides(t *testing.T) { // Explicit Preflight and TestGlob always win over ecosystem. r := Repo{ Ecosystem: "go", Preflight: [][]string{{"make", "check"}}, TestGlob: "spec_*.py", } if got := r.ResolvedTestGlob(); got != "spec_*.py" { t.Errorf("ResolvedTestGlob override: got %q, want spec_*.py", got) } pre := r.ResolvedPreflight() if len(pre) != 1 || pre[0][0] != "make" || pre[0][1] != "check" { t.Errorf("ResolvedPreflight override: got %v, want [[make check]]", pre) } } func TestEcosystemCustom(t *testing.T) { // "custom" ecosystem has no defaults -- preflight empty, test glob empty. r := Repo{Ecosystem: "custom"} if got := r.ResolvedTestGlob(); got != "" { t.Errorf("ResolvedTestGlob custom: got %q, want empty", got) } if got := r.ResolvedPreflight(); got != nil { t.Errorf("ResolvedPreflight custom: got %v, want nil", got) } } func TestWebConfigTOML(t *testing.T) { tests := []struct { name string input string wantListen string wantTrustForwarded bool }{ { name: "default trust_forwarded_headers is false when absent", input: `[web]` + "\n" + `listen = "127.0.0.1:8484"`, wantListen: "127.0.0.1:8484", wantTrustForwarded: false, }, { name: "explicit trust_forwarded_headers true", input: `[web]` + "\n" + `listen = "127.0.0.1:8484"` + "\n" + `trust_forwarded_headers = true`, wantListen: "127.0.0.1:8484", wantTrustForwarded: true, }, { name: "explicit trust_forwarded_headers false", input: `[web]` + "\n" + `listen = "127.0.0.1:8484"` + "\n" + `trust_forwarded_headers = false`, wantListen: "127.0.0.1:8484", wantTrustForwarded: false, }, } for _, tc := range tests { t.Run(tc.name, func(t *testing.T) { var cfg Config if _, err := toml.Decode(tc.input, &cfg); err != nil { t.Fatalf("decode: %v", err) } if cfg.Web.Listen != tc.wantListen { t.Errorf("Web.Listen = %q, want %q", cfg.Web.Listen, tc.wantListen) } if cfg.Web.TrustForwardedHeaders != tc.wantTrustForwarded { t.Errorf("Web.TrustForwardedHeaders = %v, want %v", cfg.Web.TrustForwardedHeaders, tc.wantTrustForwarded) } }) } } // TestHealthURL renders the address out-of-process tooling probes. A wrong // address here reads as an unhealthy release and rolls back one that came up // fine (archie-core-1r4g). func TestHealthURL(t *testing.T) { for _, tc := range []struct{ listen, want string }{ {"127.0.0.1:8485", "http://127.0.0.1:8485"}, {"localhost:8485", "http://localhost:8485"}, {"0.0.0.0:8485", "http://localhost:8485"}, {":8485", "http://localhost:8485"}, {"[::]:8485", "http://localhost:8485"}, {"100.64.1.2:9000", "http://100.64.1.2:9000"}, {" 127.0.0.1:8485 ", "http://127.0.0.1:8485"}, {"", ""}, } { if got := (Health{Listen: tc.listen}).URL(); got != tc.want { t.Errorf("Health{Listen: %q}.URL() = %q, want %q", tc.listen, got, tc.want) } } }