Files
archie/internal/infrastructure/configuration/validate_test.go
T
sam 13efe4fd1a fix(config): stop judging database-owned settings on the file load path
Loader.finalize ran the whole validation over the file document, so a stale
TOML value in a setting the control plane owns failed startup -- including
archie-state-store, which resolves its file config and opens the store without
ever layering a database resource over it. docs/prds/runtime-control-plane.md,
"Bootstrap, migration, and recovery": after migration, settings in TOML are
ignored and cannot block State Store startup.

The checks over the settings a control plane resource is seeded from and
replaces wholesale now run only on the effective document: providers
(provider-settings), poll_interval and dispatch (scheduling-policy), containers
(container-runtime-policies) and the repository lists (repository-policies).
They moved from validate to validateDatabaseOwned; validateBootstrap keeps the
checks over settings no resource carries (forge intake, identities, nats,
memory, image, capture). File sources pass validateBootstrap and
Loader.ApplyOverlay, which layers overrides onto an effective document, passes
Validate.

Nothing stops being judged: the daemon and the Gateway both run the full
Validate in boot.runtimeConfig, the one place database resources are layered
in, before any capability starts -- so a stored value that will not validate
still stops the process rather than being published. Cases that asserted the
load path rejects a database-owned value now assert both layers, and
TestRuntimeConfigFailsClosedOnAnInvalidDatabaseValue pins the second.
2026-09-21 22:09:06 +10:00

469 lines
15 KiB
Go

package configuration
import (
"errors"
"os"
"strings"
"testing"
"time"
"github.com/samcharles93/archie-core/internal/config"
"github.com/samcharles93/archie-core/internal/secret"
)
// A minimal config that satisfies every check validate applies without
// relying on applyDefaults -- Validate documents that it does not apply
// defaults, so this fixture fills in every field a default would otherwise
// have supplied.
func minimalValidConfig() config.Config {
return config.Config{
BotUser: "archie-bot",
PollInterval: config.Duration(60 * time.Second),
Dispatch: config.Dispatch{
Trigger: "assignee",
},
Forge: config.Forge{Type: "none"},
Containers: config.ContainerConfig{
Image: "ghcr.io/samcharles93/archie-agent:latest",
},
Services: config.Services{
config.ServiceNameGateway: {Target: "127.0.0.1:8585"},
},
}
}
// TestForgeDisabled pins the single definition of the disabled-forge
// predicate: cmd/archied's resolveForge calls ForgeDisabled instead of
// maintaining its own copy, so any alias added or removed here must hold
// for both config validation and daemon startup. The table deliberately
// includes a case-variant alias and the empty string to catch a future
// implementation that lowercases or matches prefixes instead of comparing
// the exact aliases.
func TestForgeDisabled(t *testing.T) {
tests := []struct {
name string
typ string
want bool
}{
{name: "none", typ: "none", want: true},
{name: "off", typ: "off", want: true},
{name: "disabled", typ: "disabled", want: true},
{name: "github", typ: "github", want: false},
{name: "gitea", typ: "gitea", want: false},
{name: "empty string", typ: "", want: false},
{name: "case variant is not an alias", typ: "None", want: false},
}
for _, tc := range tests {
t.Run(tc.name, func(t *testing.T) {
if got := ForgeDisabled(tc.typ); got != tc.want {
t.Errorf("ForgeDisabled(%q) = %v, want %v", tc.typ, got, tc.want)
}
})
}
}
func TestValidate_IsCallableOutsideThePackage(t *testing.T) {
cfg := minimalValidConfig()
if err := Validate(&cfg); err != nil {
t.Fatalf("Validate(minimal valid config) = %v, want nil", err)
}
}
// TestValidate_RejectsTheSameProblemsAsLoaderLoad pins the direction that still
// holds after archie-core-i3qm split the bootstrap checks from the effective
// ones: every problem the load path rejects, Validate rejects too. Validate
// additionally rejects the settings the control plane owns, which the load path
// must let through (validateBootstrap) so a stale TOML value cannot fail a
// process's startup. The name is kept from when the two check sets were equal.
func TestValidate_RejectsTheSameProblemsAsLoaderLoad(t *testing.T) {
tests := []struct {
name string
mutate func(cfg *config.Config)
wantErr bool
}{
{
name: "valid config",
mutate: func(cfg *config.Config) {},
wantErr: false,
},
{
name: "missing bot_user with no identities",
mutate: func(cfg *config.Config) { cfg.BotUser = "" },
wantErr: true,
},
{
name: "unrecognised dispatch.trigger",
mutate: func(cfg *config.Config) { cfg.Dispatch.Trigger = "not-a-real-trigger" },
wantErr: true,
},
{
// GH#445: an empty label matches every open issue via the forge
// API's issues-list filter, so a "label" trigger with no label
// set must fail validation rather than queue the whole repo.
name: "label trigger with empty label",
mutate: func(cfg *config.Config) {
cfg.Dispatch.Trigger = "label"
cfg.Label = ""
},
wantErr: true,
},
{
name: "either trigger with empty label",
mutate: func(cfg *config.Config) {
cfg.Dispatch.Trigger = "either"
cfg.Label = ""
},
wantErr: true,
},
{
name: "label trigger with a label set",
mutate: func(cfg *config.Config) {
cfg.Dispatch.Trigger = "label"
cfg.Label = "archie"
},
wantErr: false,
},
{
name: "unrecognised forge.type",
mutate: func(cfg *config.Config) { cfg.Forge.Type = "not-a-real-forge" },
wantErr: true,
},
{
name: "negative poll_interval",
mutate: func(cfg *config.Config) { cfg.PollInterval = config.Duration(-5 * time.Second) },
wantErr: true,
},
{
name: "zero poll_interval",
mutate: func(cfg *config.Config) { cfg.PollInterval = 0 },
wantErr: true,
},
{
name: "provider base_url carries userinfo",
mutate: func(cfg *config.Config) {
cfg.Providers = map[string]config.Provider{
"acme": {BaseURL: "https://user:pass@example.com"},
}
},
wantErr: true,
},
{
name: "unrecognised memory.engine",
mutate: func(cfg *config.Config) { cfg.Memory.Engine = "not-a-real-engine" },
wantErr: true,
},
{
name: "recognised memory.engine",
mutate: func(cfg *config.Config) { cfg.Memory.Engine = "builtin" },
wantErr: false,
},
{
name: "empty memory.engine is not unrecognised",
mutate: func(cfg *config.Config) { cfg.Memory.Engine = "" },
wantErr: false,
},
{
name: "negative capture.retention",
mutate: func(cfg *config.Config) { cfg.Capture.Retention = config.Duration(-time.Hour) },
wantErr: true,
},
{
name: "negative capture.max_events",
mutate: func(cfg *config.Config) { cfg.Capture.MaxEvents = -1 },
wantErr: true,
},
{
name: "negative capture.max_body_bytes",
mutate: func(cfg *config.Config) { cfg.Capture.MaxBodyBytes = -1 },
wantErr: true,
},
{
name: "negative capture.rate_per_second",
mutate: func(cfg *config.Config) { cfg.Capture.RatePerSecond = -1 },
wantErr: true,
},
{
name: "negative capture.rate_burst",
mutate: func(cfg *config.Config) { cfg.Capture.RateBurst = -1 },
wantErr: true,
},
{
name: "zero capture fields are valid (defaults fill them)",
mutate: func(cfg *config.Config) {},
wantErr: false,
},
}
for _, tc := range tests {
t.Run(tc.name, func(t *testing.T) {
cfg := minimalValidConfig()
tc.mutate(&cfg)
err := Validate(&cfg)
if tc.wantErr && err == nil {
t.Fatal("Validate() = nil, want an error")
}
if tc.wantErr && !errors.Is(err, ErrInvalidInput) {
t.Errorf("Validate() = %v, want it to wrap ErrInvalidInput", err)
}
if !tc.wantErr && err != nil {
t.Fatalf("Validate() = %v, want nil", err)
}
})
}
}
// TestValidateNATS pins the nats mode contract from docs/prds/embedded-nats.md:
// an unset mode resolves from url without mutating cfg, external requires url,
// embedded/off forbid a url, and full-task workers work with either embedded
// or external broker deployment.
func TestValidateNATS(t *testing.T) {
tests := []struct {
name string
mode string
url string
wantErr bool
}{
{name: "unset mode with url resolves external", url: "nats://localhost:4222"},
{name: "unset mode without url resolves embedded"},
{name: "embedded with no url", mode: config.NATSModeEmbedded},
{name: "removed off mode", mode: "off", wantErr: true},
{name: "external with url", mode: config.NATSModeExternal, url: "nats://localhost:4222"},
{name: "external without url", mode: config.NATSModeExternal, wantErr: true},
{name: "embedded with url", mode: config.NATSModeEmbedded, url: "nats://localhost:4222", wantErr: true},
{name: "removed off mode with url", mode: "off", url: "nats://localhost:4222", wantErr: true},
{name: "unknown mode", mode: "not-a-mode", wantErr: true},
}
for _, tc := range tests {
t.Run(tc.name, func(t *testing.T) {
cfg := minimalValidConfig()
cfg.NATS = config.NATSConfig{Mode: tc.mode, URL: tc.url}
err := validateNATS(&cfg)
if tc.wantErr && err == nil {
t.Fatal("validateNATS() = nil, want an error")
}
if !tc.wantErr && err != nil {
t.Fatalf("validateNATS() = %v, want nil", err)
}
})
}
}
// TestValidateContainersResolvesNATSMode pins that validateContainers reads
// the *resolved* nats mode, not the raw field: a hand-built config with
// containers enabled and a url but no explicit mode must validate the same way
// the loader's on-disk form does (url implies external), rather than diverge
// because validateContainers saw an empty mode.
func TestValidateContainersSupportsBothBrokerDeployments(t *testing.T) {
base := func() config.Config {
cfg := minimalValidConfig()
cfg.Containers = config.ContainerConfig{Image: "archie-agent:latest"}
return cfg
}
t.Run("unset mode with url resolves external", func(t *testing.T) {
cfg := base()
cfg.NATS.URL = "nats://localhost:4222"
if err := Validate(&cfg); err != nil {
t.Fatalf("Validate() = %v, want nil (unset mode + url resolves external)", err)
}
})
t.Run("embedded mode supports containers", func(t *testing.T) {
cfg := base()
cfg.NATS.Mode = config.NATSModeEmbedded
if err := Validate(&cfg); err != nil {
t.Fatalf("Validate() = %v, want nil for managed containers with embedded nats", err)
}
})
}
// TestValidateForgeIntake pins the forge.intake contract: an unset intake
// resolves to poll without mutating cfg, and webhook/both require a webhook
// secret and listen address.
func TestValidateForgeIntake(t *testing.T) {
tests := []struct {
name string
intake string
secret secret.SecretRef
addr string
natsMode string
wantErr bool
}{
{name: "unset resolves poll"},
{name: "poll is valid", intake: config.ForgeIntakePoll},
{name: "webhook requires secret", intake: config.ForgeIntakeWebhook, addr: "0.0.0.0:8645", wantErr: true},
{name: "webhook requires addr", intake: config.ForgeIntakeWebhook, secret: secret.SecretRef{Engine: "env", Key: "SECRET"}, wantErr: true},
{name: "webhook with secret and addr is valid", intake: config.ForgeIntakeWebhook, secret: secret.SecretRef{Engine: "env", Key: "SECRET"}, addr: "0.0.0.0:8645"},
{name: "both with secret and addr is valid", intake: config.ForgeIntakeBoth, secret: secret.SecretRef{Engine: "env", Key: "SECRET"}, addr: "0.0.0.0:8645"},
{name: "unknown intake", intake: "not-a-mode", wantErr: true},
}
for _, tc := range tests {
t.Run(tc.name, func(t *testing.T) {
cfg := minimalValidConfig()
cfg.Forge.Intake = tc.intake
cfg.Forge.WebhookSecret = tc.secret
cfg.Forge.WebhookAddr = tc.addr
if tc.natsMode != "" {
cfg.NATS.Mode = tc.natsMode
}
err := validateForgeIntake(&cfg)
if tc.wantErr && err == nil {
t.Fatal("validateForgeIntake() = nil, want an error")
}
if !tc.wantErr && err != nil {
t.Fatalf("validateForgeIntake() = %v, want nil", err)
}
})
}
}
// Validate must run the exact same checks Loader.File applies internally --
// this pins that a config Validate accepts on its own, once the same
// defaults Loader.File would apply are filled in by hand, is also accepted
// when it goes through the real file-loading path.
func TestValidate_AgreesWithLoaderLoad(t *testing.T) {
dir := t.TempDir()
path := dir + "/config.toml"
const doc = `
bot_user = "archie-bot"
[agent]
mode = "inprocess"
[dispatch]
trigger = "assignee"
[forge]
type = "none"
`
if err := os.WriteFile(path, []byte(doc), 0o600); err != nil {
t.Fatal(err)
}
cfg := minimalValidConfig()
if err := Validate(&cfg); err != nil {
t.Fatalf("Validate(in-memory) = %v, want nil", err)
}
if _, err := New(nil).File(path); err != nil {
t.Fatalf("Loader.File(equivalent config on disk) = %v, want nil", err)
}
}
// TestValidateMemoryNamesTheValidSet pins the AC this satisfies: an
// unknown memory.engine is rejected with a clear error naming the valid
// set, in the same style forge.type already uses.
func TestValidateMemoryNamesTheValidSet(t *testing.T) {
cfg := minimalValidConfig()
cfg.Memory.Engine = "not-a-real-engine"
err := validateMemory(&cfg)
if !errors.Is(err, ErrInvalidInput) {
t.Fatalf("validateMemory(unknown engine) = %v, want wrapping ErrInvalidInput", err)
}
if got, want := err.Error(), `memory.engine "not-a-real-engine" (want builtin)`; !strings.Contains(got, want) {
t.Errorf("error text = %q, want it to contain %q", got, want)
}
}
func TestValidateImageAcceptsAbsentSection(t *testing.T) {
cfg := minimalValidConfig()
if err := validateImage(&cfg); err != nil {
t.Fatalf("validateImage(absent) = %v, want nil", err)
}
}
func TestValidateImageRejectsEnabledHostedWithoutClass(t *testing.T) {
cfg := minimalValidConfig()
cfg.Image.Hosted = map[string]config.ImageHostedProvider{
"openai": {Enabled: true, APIKeyEnv: "OPENAI_API_KEY"},
}
err := validateImage(&cfg)
if !errors.Is(err, ErrInvalidInput) {
t.Fatalf("validateImage(no class) = %v, want wrapping ErrInvalidInput", err)
}
if !strings.Contains(err.Error(), "image.hosted.openai.class") {
t.Errorf("error text = %q, want it to name the field", err.Error())
}
}
func TestValidateImageRejectsEnabledHostedWithoutCredential(t *testing.T) {
cfg := minimalValidConfig()
cfg.Image.Hosted = map[string]config.ImageHostedProvider{
"openai": {Enabled: true, Class: "openai"},
}
err := validateImage(&cfg)
if !errors.Is(err, ErrInvalidInput) {
t.Fatalf("validateImage(no credential) = %v, want wrapping ErrInvalidInput", err)
}
}
func TestValidateImageAcceptsDisabledHostedWithoutCredential(t *testing.T) {
cfg := minimalValidConfig()
cfg.Image.Hosted = map[string]config.ImageHostedProvider{
"openai": {Enabled: false},
}
if err := validateImage(&cfg); err != nil {
t.Fatalf("validateImage(disabled) = %v, want nil", err)
}
}
func TestValidateImageAcceptsEnabledHostedWithCredential(t *testing.T) {
cfg := minimalValidConfig()
cfg.Image.Hosted = map[string]config.ImageHostedProvider{
"openai": {Enabled: true, Class: "openai", APIKeyEnv: "OPENAI_API_KEY"},
}
if err := validateImage(&cfg); err != nil {
t.Fatalf("validateImage(valid hosted) = %v, want nil", err)
}
}
func TestValidateImageRejectsEnabledLocalWithoutBackend(t *testing.T) {
cfg := minimalValidConfig()
cfg.Image.Local = map[string]config.ImageLocalProvider{
"sdxl": {Enabled: true},
}
err := validateImage(&cfg)
if !errors.Is(err, ErrInvalidInput) {
t.Fatalf("validateImage(no backend) = %v, want wrapping ErrInvalidInput", err)
}
if !strings.Contains(err.Error(), "image.local.sdxl.backend") {
t.Errorf("error text = %q, want it to name the field", err.Error())
}
}
func TestValidateImageRejectsDefaultNamingDisabledProvider(t *testing.T) {
cfg := minimalValidConfig()
cfg.Image.Default = "openai"
cfg.Image.Hosted = map[string]config.ImageHostedProvider{
"openai": {Enabled: false},
}
err := validateImage(&cfg)
if !errors.Is(err, ErrInvalidInput) {
t.Fatalf("validateImage(default names disabled) = %v, want wrapping ErrInvalidInput", err)
}
if !strings.Contains(err.Error(), `image.default "openai"`) {
t.Errorf("error text = %q, want it to name the field and value", err.Error())
}
}
func TestValidateImageRejectsDefaultNamingUnregisteredProvider(t *testing.T) {
cfg := minimalValidConfig()
cfg.Image.Default = "missing"
err := validateImage(&cfg)
if !errors.Is(err, ErrInvalidInput) {
t.Fatalf("validateImage(default names unregistered) = %v, want wrapping ErrInvalidInput", err)
}
}
func TestValidateImageAcceptsDefaultNamingEnabledLocalProvider(t *testing.T) {
cfg := minimalValidConfig()
cfg.Image.Default = "sdxl"
cfg.Image.Local = map[string]config.ImageLocalProvider{
"sdxl": {Enabled: true, Backend: "sdxl-turbo"},
}
if err := validateImage(&cfg); err != nil {
t.Fatalf("validateImage(default names enabled local) = %v, want nil", err)
}
}