Files
archie/internal/app/controlplane/runtime_config_test.go
T
sam c579f6f021 fix(controlplane): carry parallel_tool_calls through the tool-settings projection
mcpServerSettings mirrors config.MCPServer field by field, and
runtimeToolConfigFrom rebuilds cfg.Tools from that mirror wholesale. The
parallel-tool-calls flag had no home in it, so on any deployment with a
control plane the file document's parallel_tool_calls = true was dropped and
every MCP server stayed serialized. The field is now carried through both
conversions -- the seed that writes the resource and the layering that reads
it back -- and the resource accepts it, so an operator can set it there too.

The field-by-field mirror is what let the field fall through, so the test
populates every MCPServer field by reflection and requires each one to be
projected and handed back, with an explicit allowlist for the fields the
projection deliberately leaves to the file document.
2026-09-22 01:57:58 +10:00

336 lines
16 KiB
Go

package controlplane
import (
"context"
"encoding/json"
"reflect"
"strings"
"testing"
"google.golang.org/grpc"
"github.com/samcharles93/archie-core/internal/config"
pb "github.com/samcharles93/archie-core/internal/contracts/controlplane/v1"
)
type runtimeConfigClient struct{ values map[string]any }
func (*runtimeConfigClient) Catalog(context.Context, *pb.CatalogRequest, ...grpc.CallOption) (*pb.CatalogResponse, error) {
return &pb.CatalogResponse{}, nil
}
func (c *runtimeConfigClient) Query(_ context.Context, request *pb.QueryRequest, _ ...grpc.CallOption) (*pb.QueryResponse, error) {
value, err := json.Marshal(c.values[request.Kind])
return &pb.QueryResponse{Resource: &pb.Resource{Kind: request.Kind, Version: 2, ValueJson: value}}, err
}
func (*runtimeConfigClient) History(context.Context, *pb.HistoryRequest, ...grpc.CallOption) (*pb.HistoryResponse, error) {
panic("unexpected History")
}
func (*runtimeConfigClient) Command(context.Context, *pb.CommandRequest, ...grpc.CallOption) (*pb.CommandResponse, error) {
panic("unexpected Command")
}
func (*runtimeConfigClient) Watch(context.Context, *pb.WatchRequest, ...grpc.CallOption) (grpc.ServerStreamingClient[pb.WatchResponse], error) {
panic("unexpected Watch")
}
func TestRuntimeConfigUsesDatabaseResourcesAndPreservesBootstrapOnlySecrets(t *testing.T) {
base := config.Config{
Providers: map[string]config.Provider{"old": {Class: "openai"}},
Models: map[string]string{"builder": "old/model"},
Repos: []config.Repo{{Owner: "old", Name: "repo"}},
Chat: config.ChatConfig{Telegram: config.TelegramConfig{
UpdateCheckCommand: []string{"check"}, UpdateInstallCommand: []string{"install"},
}},
Tools: config.ToolsConfig{MCPServers: []config.MCPServer{{Name: "docs", Headers: map[string]string{"Authorization": "secret"}}}},
}
client := NewRPCClient(&runtimeConfigClient{values: map[string]any{
ProviderSettingsKind: map[string]any{"main": map[string]any{"class": "openai", "base_url": "https://api.example.com", "api_key_ref": map[string]any{"engine": "env", "key": "API_KEY"}, "has_credential": true}},
ModelRoleAssignmentsKind: map[string]string{"builder": "main/model"},
RepositoryPoliciesKind: []config.Repo{{Owner: "acme", Name: "widget"}},
ChannelSettingsKind: map[string]any{"operator": "Sam", "show_tool_calls": true, "max_steps": 20, "models": []string{"main/model"}, "email": map[string]any{}, "webhook_addr": "", "webhook": map[string]any{}, "telegram": map[string]any{"allowed_user_ids": []int64{42}, "credential_configured": false}, "rate_limit": map[string]any{}, "unrestricted_filesystem": false, "workspace": "/workspace"},
SchedulingPolicyKind: map[string]any{"poll_interval": "2m", "max_retries": 7, "dispatch": map[string]any{"trigger": "assignee"}},
ToolSettingsKind: map[string]any{"mcp_servers": []map[string]any{{"name": "docs", "transport": "http", "url": "https://mcp.example.com", "headers_configured": true}}, "policy": map[string]any{}, "web_fetch": map[string]any{}, "minimax": map[string]any{"enabled": false, "credential_configured": false}},
PluginSettingsKind: map[string]any{"plugin_dir": "/plugins", "module_dir": "/modules", "secret_engine_dir": "/secrets", "skills_dir": "/skills"},
ContainerRuntimePoliciesKind: config.ContainerConfig{LegacyEnabled: true, Image: "archie:next", PullPolicy: "missing"},
}})
got, versions, err := client.RuntimeConfig(t.Context(), base)
if err != nil {
t.Fatalf("RuntimeConfig: %v", err)
}
// Every kind it read is reported as applied, so the version a process
// publishes is the one it actually layered in (archie-core-pskb).
for _, kind := range []string{
ProviderSettingsKind, ModelRoleAssignmentsKind, RepositoryPoliciesKind, ChannelSettingsKind,
SchedulingPolicyKind, ToolSettingsKind, PluginSettingsKind, ContainerRuntimePoliciesKind,
} {
if versions[kind] != 2 {
t.Errorf("versions[%s] = %d, want the 2 the store answered with", kind, versions[kind])
}
}
if got.Models["builder"] != "main/model" || got.Repos[0].FullName() != "acme/widget" || got.MaxRetries != 7 || got.PluginDir != "/plugins" || got.Containers.Image != "archie:next" {
t.Fatalf("database settings not applied: %+v", got)
}
if got.Chat.Operator != "Sam" || got.Chat.Telegram.AllowedUserIDs[0] != 42 {
t.Fatalf("channel settings not applied: %+v", got.Chat)
}
if got.Chat.Telegram.UpdateCheckCommand[0] != "check" || got.Tools.MCPServers[0].Headers["Authorization"] != "secret" {
t.Fatalf("bootstrap-only secret-backed settings were dropped: chat=%+v tools=%+v", got.Chat, got.Tools)
}
}
// TestRuntimeConfigLayersTheStoredSchedulingLabel: the label pairs with the
// dispatch trigger and layers with it. A policy that carries one replaces the
// file document's label, so the store owns the half of the pairing it judged
// at write time (archie-core-7pyj).
func TestRuntimeConfigLayersTheStoredSchedulingLabel(t *testing.T) {
base := config.Config{
Label: "file-label",
PollInterval: config.Duration(60 * 1e9),
Dispatch: config.Dispatch{Trigger: "assignee"},
}
client := NewRPCClient(&runtimeConfigClient{values: map[string]any{
SchedulingPolicyKind: map[string]any{"poll_interval": "2m", "max_retries": 7, "label": "stored-label", "dispatch": map[string]any{"trigger": "assignee"}},
}})
got, _, err := client.RuntimeConfig(t.Context(), base)
if err != nil {
t.Fatalf("RuntimeConfig: %v", err)
}
if got.Label != "stored-label" {
t.Fatalf("label after layering = %q, want the stored policy's label", got.Label)
}
}
// TestRuntimeConfigLeavesTheFileLabelInForceWhenThePolicyCarriesNone: a
// policy stored before the label field existed (or one that omits it) is not
// an instruction to clear the file document's label -- the same
// absence-means-inherited shape a kind with no stored value has.
func TestRuntimeConfigLeavesTheFileLabelInForceWhenThePolicyCarriesNone(t *testing.T) {
base := config.Config{
Label: "file-label",
PollInterval: config.Duration(60 * 1e9),
Dispatch: config.Dispatch{Trigger: "assignee"},
}
client := NewRPCClient(&runtimeConfigClient{values: map[string]any{
SchedulingPolicyKind: map[string]any{"poll_interval": "2m", "max_retries": 7, "dispatch": map[string]any{"trigger": "assignee"}},
}})
got, _, err := client.RuntimeConfig(t.Context(), base)
if err != nil {
t.Fatalf("RuntimeConfig: %v", err)
}
if got.Label != "file-label" {
t.Fatalf("label after layering = %q, want the file document's label left in force", got.Label)
}
}
// TestRuntimeConfigCarriesParallelToolCallsThroughTheProjection: the layering
// rebuilds cfg.Tools from the control plane's own projection wholesale
// (runtime_config.go), so a field the projection has no home for is dropped for
// every deployment that runs a control plane -- file-level
// parallel_tool_calls = true would be accepted, shown, and inert. The value has
// to survive both conversions: the seed that writes the resource and the
// layering that reads it back.
func TestRuntimeConfigCarriesParallelToolCallsThroughTheProjection(t *testing.T) {
base := config.Config{Tools: config.ToolsConfig{MCPServers: []config.MCPServer{{
Name: "docs", Transport: "stdio", Command: "docs-server", ParallelToolCalls: true,
}}}}
seed := seedToolSettings(t, base)
if carried, _ := seededServer(t, seed)["parallel_tool_calls"].(bool); !carried {
t.Errorf("%s seed = %s, want the file document's parallel_tool_calls in it", ToolSettingsKind, seed)
}
got := layerToolSettings(t, seed, base)
if !got.Tools.MCPServers[0].ParallelToolCalls {
t.Fatalf("ParallelToolCalls after the control-plane round trip = false, want true: %+v", got.Tools.MCPServers[0])
}
}
// TestToolSettingsProjectionCarriesEveryMCPServerField is the guard the field
// itself cannot be. mcpServerSettings mirrors config.MCPServer field by field,
// so the next field added to MCPServer -- internal/config's Sandboxed, when
// mcp-tool-completion's #178 lands -- silently falls out of the control-plane
// path unless something fails when it does. This test is that something: it
// populates every MCPServer field by reflection, so a field added later is
// populated without editing any fixture here, then requires the seed to name
// the field and the layering to hand it back.
//
// mcpServerFieldsLeftToTheFile is the only way past the check, and every entry
// in it has to say what the projection carries in place of the field.
func TestToolSettingsProjectionCarriesEveryMCPServerField(t *testing.T) {
var server config.MCPServer
populateEveryField(t, reflect.ValueOf(&server).Elem(), "config.MCPServer")
// The resource validator knows a fixed transport vocabulary, so the round
// trip needs one of them. It is the only value here the fixture takes from
// the validator rather than from the field's type; stdio requires a command,
// which the fixture has already set.
server.Transport = "stdio"
base := config.Config{Tools: config.ToolsConfig{MCPServers: []config.MCPServer{server}}}
seed := seedToolSettings(t, base)
seeded := seededServer(t, seed)
got := layerToolSettings(t, seed, base).Tools.MCPServers[0]
typ := reflect.TypeOf(server)
for i := range typ.NumField() {
field := typ.Field(i)
name := jsonFieldName(field)
surrogate, leftToTheFile := mcpServerFieldsLeftToTheFile[field.Name]
if leftToTheFile {
// Deliberately not carried: the stored value must not hold the
// field's own value, and whatever the projection carries instead
// must be there.
if _, carried := seeded[name]; carried {
t.Errorf("the %s seed carries MCPServer.%s (%q), which mcpServerFieldsLeftToTheFile leaves to the file document", ToolSettingsKind, field.Name, name)
}
if _, ok := seeded[surrogate]; !ok {
t.Errorf("the %s seed carries neither MCPServer.%s nor the %q the projection carries in its place", ToolSettingsKind, field.Name, surrogate)
}
continue
}
if _, carried := seeded[name]; !carried {
t.Errorf("the %s seed has no %q key, so seedTools never projects MCPServer.%s and the layering can only restore its zero value", ToolSettingsKind, name, field.Name)
continue
}
wantField := reflect.ValueOf(server).Field(i).Interface()
if gotField := reflect.ValueOf(got).Field(i).Interface(); !reflect.DeepEqual(gotField, wantField) {
t.Errorf("MCPServer.%s = %#v after the control-plane round trip, want %#v: carry it through mcpServerSettings, seedTools, and runtimeToolConfigFrom, or add it to mcpServerFieldsLeftToTheFile with what the projection carries in its place", field.Name, gotField, wantField)
}
}
// An allowlist entry for a field MCPServer no longer has is a dead pass.
for name := range mcpServerFieldsLeftToTheFile {
if _, ok := typ.FieldByName(name); !ok {
t.Errorf("mcpServerFieldsLeftToTheFile names MCPServer.%s, which the struct no longer has", name)
}
}
}
// mcpServerFieldsLeftToTheFile names the MCPServer fields the control plane's
// projection deliberately does not carry, with the projection key that stands
// in for each. It is deliberately short: a field belongs here only when the
// file document has to stay its owner. Headers hold credentials, so the stored
// resource records only that some are configured and the layering restores the
// real map from the base config by server name (runtime_config.go), which
// TestRuntimeConfigUsesDatabaseResourcesAndPreservesBootstrapOnlySecrets pins.
var mcpServerFieldsLeftToTheFile = map[string]string{
"Headers": "headers_configured",
}
// seedToolSettings is the value a State Store writes for the tool settings when
// it holds none for that kind: the production seed derived from the file
// document, run through the production Decode exactly as ImportConfig writes it.
func seedToolSettings(t *testing.T, base config.Config) []byte {
t.Helper()
seed, err := testServer(t, nil).definitions[ToolSettingsKind].seededValue(base)
if err != nil {
t.Fatalf("seed %s: %v", ToolSettingsKind, err)
}
return seed
}
// layerToolSettings layers a stored tool-settings value over base with the
// production layering, answering every other kind as absent -- the shape of a
// store that has seeded nothing else, where the file document's value stays in
// force.
func layerToolSettings(t *testing.T, stored []byte, base config.Config) config.Config {
t.Helper()
got, _, err := runtimeConfigFrom(t.Context(), toolSettingsReader{value: stored}, base)
if err != nil {
t.Fatalf("layer %s: %v", ToolSettingsKind, err)
}
return got
}
// toolSettingsReader answers the one kind under test and reports every other
// kind absent.
type toolSettingsReader struct{ value []byte }
func (r toolSettingsReader) query(_ context.Context, kind string, decode func([]byte) error) (int64, bool, error) {
if kind != ToolSettingsKind {
return 0, false, nil
}
return 2, true, decode(r.value)
}
// seededServer is the MCP server entry the seed actually wrote for the one
// server in the config: the projection's own output, which is what the layering
// reads back.
func seededServer(t *testing.T, seed []byte) map[string]any {
t.Helper()
var document struct {
MCPServers []map[string]any `json:"mcp_servers"`
}
if err := json.Unmarshal(seed, &document); err != nil {
t.Fatalf("decode %s seed: %v", ToolSettingsKind, err)
}
if len(document.MCPServers) != 1 {
t.Fatalf("%s seed carries %d MCP servers, want the one the config has: %s", ToolSettingsKind, len(document.MCPServers), seed)
}
return document.MCPServers[0]
}
// jsonFieldName is the key a field's value travels under in a stored resource.
func jsonFieldName(field reflect.StructField) string {
name, _, _ := strings.Cut(field.Tag.Get("json"), ",")
return name
}
// populateEveryField sets every field of value to a distinct non-zero value
// derived from its type, so a struct compared before and after a round trip
// differs on every field that round trip drops. Nothing about the struct is
// written down here: a field added to config.MCPServer later is populated
// without an edit, which is what lets the projection guard fail for a field
// nobody remembered to add to a fixture.
func populateEveryField(t *testing.T, value reflect.Value, label string) {
t.Helper()
if !value.CanSet() {
t.Fatalf("%s cannot be set, so the round-trip fixture cannot populate it", label)
}
switch value.Kind() {
case reflect.String:
value.SetString("value-for-" + label)
case reflect.Bool:
value.SetBool(true)
case reflect.Slice:
value.Set(reflect.MakeSlice(value.Type(), 1, 1))
populateEveryField(t, value.Index(0), label)
case reflect.Map:
entry := reflect.MakeMap(value.Type())
key, item := reflect.New(value.Type().Key()).Elem(), reflect.New(value.Type().Elem()).Elem()
populateEveryField(t, key, label)
populateEveryField(t, item, label)
entry.SetMapIndex(key, item)
value.Set(entry)
case reflect.Struct:
for i := range value.NumField() {
populateEveryField(t, value.Field(i), label+"."+value.Type().Field(i).Name)
}
default:
t.Fatalf("%s has kind %s, which the round-trip fixture cannot populate: teach populateEveryField that kind, or the projection guard cannot see the field", label, value.Kind())
}
}
// TestSchedulingPolicySeedCarriesTheLabel: the seed a fresh store writes must
// carry the file document's label, so the pairing a stored trigger requires
// is judgeable at write time from the moment the resource exists.
func TestSchedulingPolicySeedCarriesTheLabel(t *testing.T) {
server := testServer(t, nil)
seed, err := server.definitions[SchedulingPolicyKind].seededValue(config.Config{
Label: "archie:labelled",
PollInterval: config.Duration(60 * 1e9),
Dispatch: config.Dispatch{Trigger: "label"},
})
if err != nil {
t.Fatalf("seededValue: %v", err)
}
var document map[string]any
if err := json.Unmarshal(seed, &document); err != nil {
t.Fatalf("decode seed: %v", err)
}
if label, _ := document["label"].(string); label != "archie:labelled" {
t.Fatalf("seed label = %q, want the file document's label", label)
}
}