Files
archie/internal/app/archied/setup_test.go
T
sam 164886308b refactor(install): install.sh delegates config generation, and tests stop reading hand-written configs
Two things fall out of one principle: a test that asserts against a
hand-written file is testing an artifact a human or an agent may legitimately
rewrite at any moment, so only generated output is a valid target.

install.sh generated config.toml two ways -- a full heredoc for the self-host
path and an awk splice of the [forge] block into config.example.toml -- with a
forge_block shell helper feeding both. That is the arrangement
docs/architecture/configuration.md decided against: it "must stop generating
config.toml; archied setup owns it", because the installer hand-rolling TOML
already drifted once (choosing Gitea produced a config naming a token the
installer never wrote). Both generators and forge_block are gone; install.sh
collects its answers as before and passes them to archied setup as parameters,
with secrets passed as REFERENCES to the env keys it just wrote rather than as
values, which would put them on a command line. The installer also now asks for
a cloud model, which archied setup requires and the old path never emitted.

deployment_contract_test.go tested the removed generators by parsing install.sh's
shell text, reconstructing the heredoc and asserting on its content. It broke the
instant install.sh stopped generating config -- "install.sh has no heredoc
declaring the daemon config's [nats] table" -- which is the failure mode in
miniature: the test was coupled to an artifact, not to behaviour. Deleted.

What it actually protected is kept, asserted on the GENERATED config instead:
TestRunSetup_GeneratedConfigSatisfiesDaemonRequirements runs archied setup and
loads what it wrote, requiring services.state.target and bot_user. A test against
generated output fails when generation breaks and passes when a human merely
tidies the template.

Found by an adversarial package sweep (temp tracker: config-1,
repo-root-deployment-1, repo-root-deployment-2).
2026-09-15 03:35:45 +10:00

285 lines
10 KiB
Go

package archied
import (
"os"
"path/filepath"
"strings"
"testing"
"github.com/samcharles93/archie-core/internal/config"
"github.com/samcharles93/archie-core/internal/infrastructure/configuration"
"github.com/samcharles93/archie-core/internal/infrastructure/configuration/setup"
)
func TestSetupSubcommandIsRecognised(t *testing.T) {
if !IsSetupArgs([]string{setupCommand, "--defaults"}) {
t.Errorf("IsSetupArgs() did not recognise %q", setupCommand)
}
if IsSetupArgs([]string{"-once"}) {
t.Error("IsSetupArgs() claimed a normal daemon flag")
}
if IsSetupArgs(nil) {
t.Error("IsSetupArgs() claimed an empty argument list")
}
}
func TestRunSetup_DefaultsWritesLoadableConfig(t *testing.T) {
dir := t.TempDir()
cfgPath := filepath.Join(dir, "config.toml")
stdin, err := os.Open(os.DevNull)
if err != nil {
t.Fatal(err)
}
defer stdin.Close()
var stdout, stderr strings.Builder
code := RunSetup([]string{"--defaults", "-config", cfgPath}, stdin, &stdout, &stderr)
if code != 0 {
t.Fatalf("RunSetup exit = %d, stderr:\n%s", code, stderr.String())
}
info, err := os.Stat(cfgPath)
if err != nil {
t.Fatalf("config not written: %v", err)
}
if info.Mode().Perm() != 0o600 {
t.Errorf("config mode = %v, want 0600", info.Mode().Perm())
}
doc, err := configuration.New(nil).File(cfgPath)
if err != nil {
t.Fatalf("generated config does not load: %v", err)
}
if doc.Config.BotUser != "archie-bot" {
t.Errorf("bot_user = %q, want archie-bot", doc.Config.BotUser)
}
// The defaults baseline is keyless (ollama), so nothing may be written
// to the env file.
if _, err := os.Stat(filepath.Join(dir, "env")); !os.IsNotExist(err) {
t.Errorf("env file should not exist after a defaults run, got %v", err)
}
}
// TestRunSetupRejectsSecretValueFlags pins that no secret value can be passed
// on the command line. Secrets are set in a secret engine; this flow only ever
// writes a reference to one. A flag that carried a value would be a second,
// silent way to set a secret -- and would put it in shell history and in every
// process listing, which is why install.sh prompts with read_secret instead.
func TestRunSetupRejectsSecretValueFlags(t *testing.T) {
for _, flagName := range []string{"-forge-token", "-provider-api-key", "-telegram-token"} {
t.Run(flagName, func(t *testing.T) {
dir := t.TempDir()
cfgPath := filepath.Join(dir, "config.toml")
devNull, err := os.Open(os.DevNull)
if err != nil {
t.Fatal(err)
}
defer func() { _ = devNull.Close() }()
var stdout, stderr strings.Builder
code := RunSetup([]string{"--defaults", "-config", cfgPath, flagName, "leaked-value"}, devNull, &stdout, &stderr)
if code != 2 {
t.Fatalf("RunSetup with %s = exit %d, want 2 (unknown flag); stderr: %s", flagName, code, stderr.String())
}
if _, err := os.Stat(cfgPath); !os.IsNotExist(err) {
t.Errorf("config written despite a rejected flag: %v", err)
}
if _, err := os.Stat(filepath.Join(dir, "env")); !os.IsNotExist(err) {
t.Errorf("env file written despite a rejected flag: %v", err)
}
})
}
}
func TestRunSetup_GuidedRequiresTTY(t *testing.T) {
dir := t.TempDir()
cfgPath := filepath.Join(dir, "config.toml")
stdin, err := os.Open(os.DevNull)
if err != nil {
t.Fatal(err)
}
defer stdin.Close()
var stdout, stderr strings.Builder
code := RunSetup([]string{"-config", cfgPath}, stdin, &stdout, &stderr)
if code == 0 {
t.Fatalf("RunSetup exit = 0, want non-zero for a guided run without a TTY")
}
if _, err := os.Stat(cfgPath); !os.IsNotExist(err) {
t.Errorf("config should not be written when a guided non-TTY run is refused, got %v", err)
}
}
func TestInstallValidatedConfig_ValidationFailureWritesNothing(t *testing.T) {
dir := t.TempDir()
cfgPath := filepath.Join(dir, "config.toml")
sink := setup.NewEnvFileSink(filepath.Join(dir, "env"))
if err := sink.Put("env", "ARCHIE_GITHUB_TOKEN", "secret"); err != nil {
t.Fatal(err)
}
err := installValidatedConfig(configuration.New(nil), cfgPath, sink, []byte("this is not toml"))
if err == nil {
t.Fatal("installValidatedConfig = nil error, want a load failure")
}
if _, err := os.Stat(cfgPath); !os.IsNotExist(err) {
t.Errorf("config written despite validation failure: %v", err)
}
if _, err := os.Stat(filepath.Join(dir, "env")); !os.IsNotExist(err) {
t.Errorf("secret written despite validation failure: %v", err)
}
}
// TestInstallValidatedConfig_ConfigWriteFailureLeavesNoSecret pins the write
// order the setup package's SecretSink contract depends on: the config is
// installed before any secret is committed, so a secret is never left on disk
// pointing at a config that was never written.
//
// This is not covered by the validation-failure test: inverting the two writes
// leaves every other test in the package green, so this assertion is what
// actually holds the invariant.
func TestInstallValidatedConfig_ConfigWriteFailureLeavesNoSecret(t *testing.T) {
dir := t.TempDir()
// The parent directory does not exist, so validation succeeds and the
// config write fails.
cfgPath := filepath.Join(dir, "missing", "config.toml")
envPath := filepath.Join(dir, "env")
sink := setup.NewEnvFileSink(envPath)
if err := sink.Put("env", "ARCHIE_GITHUB_TOKEN", "secret"); err != nil {
t.Fatal(err)
}
rendered := []byte("bot_user = \"widget\"\nwork_dir = \"/tmp/archie-setup-work\"\n")
// Prove the fixture is loadable BEFORE relying on the write failing.
// Asserted by loading it rather than by matching the error text below: a
// reworded error must not silently disarm this guard and let the test pass
// for the wrong reason.
fixture := filepath.Join(dir, "fixture.toml")
if err := os.WriteFile(fixture, rendered, 0o600); err != nil {
t.Fatal(err)
}
if _, err := configuration.New(nil).File(fixture); err != nil {
t.Fatalf("fixture config does not load, so this test would not exercise the write path: %v", err)
}
if err := installValidatedConfig(configuration.New(nil), cfgPath, sink, rendered); err == nil {
t.Fatal("installValidatedConfig = nil error, want a write failure")
}
if _, statErr := os.Stat(envPath); !os.IsNotExist(statErr) {
t.Errorf("secret committed even though the config was never written: %v", statErr)
}
}
// TestRunSetup_SecretRefFlagsWriteReferencesWithoutEnvFile pins the reference
// form end to end: naming where a secret is stored writes the reference, and
// setup stores nothing, so no env file appears. The engine here (bws) is one
// setup has no writer for -- which is the point, the value is not setup's.
func TestRunSetup_SecretRefFlagsWriteReferencesWithoutEnvFile(t *testing.T) {
dir := t.TempDir()
cfgPath := filepath.Join(dir, "config.toml")
devNull, err := os.Open(os.DevNull)
if err != nil {
t.Fatal(err)
}
defer func() { _ = devNull.Close() }()
var stdout, stderr strings.Builder
code := RunSetup([]string{
"--defaults", "-config", cfgPath,
"-provider", "openai", "-model", "gpt-5.4",
"-provider-secret-ref", "bws:OPENAI_API_KEY",
"-forge-secret-ref", "bws:ARCHIE_GITHUB_TOKEN",
}, devNull, &stdout, &stderr)
if code != 0 {
t.Fatalf("RunSetup exit = %d, stderr: %s", code, stderr.String())
}
doc, err := configuration.New(nil).File(cfgPath)
if err != nil {
t.Fatalf("generated config does not load: %v", err)
}
if got, want := doc.Config.Providers["openai"].APIKey, (config.SecretRef{Engine: "bws", Key: "OPENAI_API_KEY"}); got != want {
t.Errorf("providers.openai.api_key = %+v, want %+v", got, want)
}
if got, want := doc.Config.Forge.Token, (config.SecretRef{Engine: "bws", Key: "ARCHIE_GITHUB_TOKEN"}); got != want {
t.Errorf("forge.token = %+v, want %+v", got, want)
}
if _, err := os.Stat(filepath.Join(dir, "env")); !os.IsNotExist(err) {
t.Errorf("env file written: a reference means setup stores no value (stat err: %v)", err)
}
}
// TestRunSetup_RejectsReferencesNothingWouldUse pins the no-silent-no-op rule.
// A reference for a keyless provider, or for a disabled forge, would sit in the
// config looking configured while nothing read it -- the failure shape this
// whole flow exists to remove -- so it is refused instead.
func TestRunSetup_RejectsReferencesNothingWouldUse(t *testing.T) {
tests := []struct {
name string
args []string
}{
{name: "provider ref with the keyless self-hosted provider", args: []string{"-provider-secret-ref", "bws:OPENAI_API_KEY"}},
{name: "forge ref with the forge disabled", args: []string{"-forge-type", "none", "-forge-secret-ref", "bws:ARCHIE_GITHUB_TOKEN"}},
}
for _, tc := range tests {
t.Run(tc.name, func(t *testing.T) {
dir := t.TempDir()
cfgPath := filepath.Join(dir, "config.toml")
devNull, err := os.Open(os.DevNull)
if err != nil {
t.Fatal(err)
}
defer func() { _ = devNull.Close() }()
args := append([]string{"--defaults", "-config", cfgPath}, tc.args...)
var stdout, stderr strings.Builder
if code := RunSetup(args, devNull, &stdout, &stderr); code == 0 {
t.Fatalf("RunSetup = exit 0, want a refusal; stderr: %s", stderr.String())
}
if _, err := os.Stat(cfgPath); !os.IsNotExist(err) {
t.Errorf("config written despite the refusal: %v", err)
}
})
}
}
// TestRunSetup_GeneratedConfigSatisfiesDaemonRequirements pins the properties
// archied needs of whatever setup emits, asserted on the GENERATED config.
//
// It replaces a test that read config.example.toml and reconstructed install.sh's
// shell heredoc. Testing hand-written files is testing an artifact a human or an
// agent may legitimately rewrite at any time -- and that test in fact broke the
// moment install.sh stopped generating config, because the heredoc it parsed no
// longer existed. The generated output is the contract; the template is an input.
func TestRunSetup_GeneratedConfigSatisfiesDaemonRequirements(t *testing.T) {
dir := t.TempDir()
cfgPath := filepath.Join(dir, "config.toml")
devNull, err := os.Open(os.DevNull)
if err != nil {
t.Fatal(err)
}
defer func() { _ = devNull.Close() }()
var stdout, stderr strings.Builder
if code := RunSetup([]string{"--defaults", "-config", cfgPath}, devNull, &stdout, &stderr); code != 0 {
t.Fatalf("RunSetup exit = %d, stderr: %s", code, stderr.String())
}
doc, err := configuration.New(nil).File(cfgPath)
if err != nil {
t.Fatalf("generated config does not load: %v", err)
}
// openStateStoreAdapter refuses an empty target, so this is the difference
// between a config that boots and one that does not.
if doc.Config.Services.State.Target == "" {
t.Error("generated config leaves services.state.target empty; the daemon would not boot")
}
if doc.Config.BotUser == "" {
t.Error("generated config leaves bot_user empty")
}
}