Readiness probe test asserts each subsystem registers exactly once instead of an ordered five-item list. Config descriptor test drops the exact-count check and its stale settings.js rationale. Container defaults test references the production constant. Refs #1229 #1231 #1232
204 lines
7.5 KiB
Go
204 lines
7.5 KiB
Go
package configuration
|
|
|
|
import (
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/samcharles93/archie-core/internal/config"
|
|
)
|
|
|
|
func TestApplyNATSDefaultsResolvesMode(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
mode string
|
|
url string
|
|
want string
|
|
}{
|
|
{name: "url set implies external", url: "nats://localhost:4222", want: config.NATSModeExternal},
|
|
{name: "empty implies embedded", want: config.NATSModeEmbedded},
|
|
{name: "explicit embedded is preserved", mode: config.NATSModeEmbedded, want: config.NATSModeEmbedded},
|
|
{name: "explicit external is preserved", mode: config.NATSModeExternal, url: "nats://localhost:4222", want: config.NATSModeExternal},
|
|
}
|
|
for _, tc := range tests {
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
cfg := &config.Config{NATS: config.NATSConfig{Mode: tc.mode, URL: tc.url}}
|
|
applyNATSDefaults(cfg)
|
|
if cfg.NATS.Mode != tc.want {
|
|
t.Errorf("applyNATSDefaults() mode = %q, want %q", cfg.NATS.Mode, tc.want)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestApplyContainerDefaultsMakesManagedWorkersReadyByDefault(t *testing.T) {
|
|
cfg := &config.Config{}
|
|
applyContainerDefaults(cfg)
|
|
|
|
if cfg.Containers.Image != defaultContainerImage {
|
|
t.Errorf("Containers.Image = %q, want %q", cfg.Containers.Image, defaultContainerImage)
|
|
}
|
|
if cfg.Containers.MaxUptime.Std() != defaultContainerUptime {
|
|
t.Errorf("Containers.MaxUptime = %s, want %s", cfg.Containers.MaxUptime.Std(), defaultContainerUptime)
|
|
}
|
|
if cfg.Containers.VolumeTTL.Std() != defaultVolumeTTL {
|
|
t.Errorf("Containers.VolumeTTL = %s, want %s", cfg.Containers.VolumeTTL.Std(), defaultVolumeTTL)
|
|
}
|
|
if cfg.Containers.PullPolicy != defaultPullPolicy {
|
|
t.Errorf("Containers.PullPolicy = %q, want %q", cfg.Containers.PullPolicy, defaultPullPolicy)
|
|
}
|
|
}
|
|
|
|
func TestApplyForgeDefaultsIntake(t *testing.T) {
|
|
cfg := &config.Config{}
|
|
applyForgeDefaults(cfg)
|
|
if cfg.Forge.Intake != config.ForgeIntakePoll {
|
|
t.Errorf("applyForgeDefaults() intake = %q, want %q", cfg.Forge.Intake, config.ForgeIntakePoll)
|
|
}
|
|
|
|
explicit := &config.Config{Forge: config.Forge{Intake: config.ForgeIntakeWebhook}}
|
|
applyForgeDefaults(explicit)
|
|
if explicit.Forge.Intake != config.ForgeIntakeWebhook {
|
|
t.Errorf("applyForgeDefaults() intake = %q, want unchanged %q", explicit.Forge.Intake, config.ForgeIntakeWebhook)
|
|
}
|
|
}
|
|
|
|
func TestApplyIdentityDefaultsDerivesEmailPerIdentity(t *testing.T) {
|
|
cfg := &config.Config{Identities: []config.IdentityConfig{
|
|
{BotUser: "github-bot", Forge: config.Forge{Type: forgeTypeGitHub}},
|
|
{BotUser: "gitea-bot", Forge: config.Forge{Type: forgeTypeGitea}},
|
|
{BotUser: "explicit", BotEmail: "bot@example.test", Forge: config.Forge{Type: forgeTypeGitHub}},
|
|
}}
|
|
|
|
applyIdentityDefaults(cfg)
|
|
|
|
want := []string{"github-bot@users.noreply.github.com", "gitea-bot@gitea.local", "bot@example.test"}
|
|
for i := range want {
|
|
if cfg.Identities[i].BotEmail != want[i] {
|
|
t.Errorf("identity %d BotEmail = %q, want %q", i, cfg.Identities[i].BotEmail, want[i])
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestApplyCaptureDefaultsFillsZeroValues(t *testing.T) {
|
|
cfg := &config.Config{}
|
|
applyCaptureDefaults(cfg)
|
|
|
|
if got, want := cfg.Capture.Retention.Std(), defaultCaptureRetention; got != want {
|
|
t.Errorf("Capture.Retention = %v, want %v", got, want)
|
|
}
|
|
if cfg.Capture.MaxEvents != defaultCaptureMaxEvents {
|
|
t.Errorf("Capture.MaxEvents = %d, want %d", cfg.Capture.MaxEvents, defaultCaptureMaxEvents)
|
|
}
|
|
if cfg.Capture.MaxBodyBytes != defaultCaptureMaxBodyBytes {
|
|
t.Errorf("Capture.MaxBodyBytes = %d, want %d", cfg.Capture.MaxBodyBytes, defaultCaptureMaxBodyBytes)
|
|
}
|
|
if cfg.Capture.RatePerSecond != defaultCaptureRatePerSecond {
|
|
t.Errorf("Capture.RatePerSecond = %v, want %v", cfg.Capture.RatePerSecond, defaultCaptureRatePerSecond)
|
|
}
|
|
if cfg.Capture.RateBurst != defaultCaptureRateBurst {
|
|
t.Errorf("Capture.RateBurst = %d, want %d", cfg.Capture.RateBurst, defaultCaptureRateBurst)
|
|
}
|
|
}
|
|
|
|
func TestApplyCaptureDefaultsLeavesExplicitValuesAlone(t *testing.T) {
|
|
cfg := &config.Config{
|
|
Capture: config.CaptureConfig{
|
|
Retention: config.Duration(24 * time.Hour),
|
|
MaxEvents: 42,
|
|
MaxBodyBytes: 1024,
|
|
RatePerSecond: 2.5,
|
|
RateBurst: 9,
|
|
},
|
|
}
|
|
applyCaptureDefaults(cfg)
|
|
|
|
if cfg.Capture.Retention.Std() != 24*time.Hour {
|
|
t.Errorf("Capture.Retention = %v, want unchanged 24h", cfg.Capture.Retention.Std())
|
|
}
|
|
if cfg.Capture.MaxEvents != 42 {
|
|
t.Errorf("Capture.MaxEvents = %d, want unchanged 42", cfg.Capture.MaxEvents)
|
|
}
|
|
if cfg.Capture.MaxBodyBytes != 1024 {
|
|
t.Errorf("Capture.MaxBodyBytes = %d, want unchanged 1024", cfg.Capture.MaxBodyBytes)
|
|
}
|
|
if cfg.Capture.RatePerSecond != 2.5 {
|
|
t.Errorf("Capture.RatePerSecond = %v, want unchanged 2.5", cfg.Capture.RatePerSecond)
|
|
}
|
|
if cfg.Capture.RateBurst != 9 {
|
|
t.Errorf("Capture.RateBurst = %d, want unchanged 9", cfg.Capture.RateBurst)
|
|
}
|
|
}
|
|
|
|
func TestApplyMemoryDefaultsFillsAbsentEngineWithBuiltin(t *testing.T) {
|
|
cfg := &config.Config{}
|
|
applyMemoryDefaults(cfg)
|
|
|
|
if cfg.Memory.Engine != memoryEngineBuiltin {
|
|
t.Errorf("Memory.Engine = %q, want %q", cfg.Memory.Engine, memoryEngineBuiltin)
|
|
}
|
|
}
|
|
|
|
func TestApplyMemoryDefaultsLeavesExplicitEngineAlone(t *testing.T) {
|
|
cfg := &config.Config{Memory: config.MemoryConfig{Engine: "honcho"}}
|
|
applyMemoryDefaults(cfg)
|
|
|
|
if cfg.Memory.Engine != "honcho" {
|
|
t.Errorf("Memory.Engine = %q, want unchanged %q", cfg.Memory.Engine, "honcho")
|
|
}
|
|
}
|
|
|
|
// TestDefaultsKeepAnExplicitUnlimitedDiffCap is the regression case for
|
|
// diff_cap_lines = 0 silently becoming 400. The dashboard schema, and
|
|
// StageDiffCap itself, both document 0 as "no cap", but the defaults pass could
|
|
// not tell an explicit 0 from an absent key and rewrote both to 400 -- so the
|
|
// documented way to switch the cap off was unreachable through config.
|
|
func TestDefaultsKeepAnExplicitUnlimitedDiffCap(t *testing.T) {
|
|
unlimited := 0
|
|
cfg := config.Config{DiffCapLines: &unlimited}
|
|
(&Loader{}).applyDefaults(&cfg)
|
|
|
|
if cfg.DiffCapLines == nil {
|
|
t.Fatal("DiffCapLines = nil, want the explicit 0 preserved")
|
|
}
|
|
if *cfg.DiffCapLines != 0 {
|
|
t.Fatalf("DiffCapLines = %d, want 0: an explicit 0 means no cap", *cfg.DiffCapLines)
|
|
}
|
|
if cfg.DiffCap() != 0 {
|
|
t.Fatalf("DiffCap() = %d, want 0 (unlimited)", cfg.DiffCap())
|
|
}
|
|
}
|
|
|
|
// TestDefaultsApplyTheDiffCapWhenUnset pins the other half: an absent key still
|
|
// gets the safety cap, so omitting it never silently auto-opens huge PRs.
|
|
func TestDefaultsApplyTheDiffCapWhenUnset(t *testing.T) {
|
|
cfg := config.Config{}
|
|
(&Loader{}).applyDefaults(&cfg)
|
|
|
|
if cfg.DiffCapLines == nil || *cfg.DiffCapLines != defaultDiffCapLines {
|
|
t.Fatalf("DiffCapLines = %v, want %d when the key is absent", cfg.DiffCapLines, defaultDiffCapLines)
|
|
}
|
|
}
|
|
|
|
// TestDefaultsFillTheHealthDependencyTimeout pins that the probe timeout has a
|
|
// default, so a config that never mentions it still bounds the Gateway call
|
|
// rather than letting a hung dependency stall the whole health report.
|
|
func TestDefaultsFillTheHealthDependencyTimeout(t *testing.T) {
|
|
cfg := config.Config{}
|
|
(&Loader{}).applyDefaults(&cfg)
|
|
|
|
if got := time.Duration(cfg.Health.DependencyTimeout); got != defaultHealthDependencyTimeout {
|
|
t.Fatalf("Health.DependencyTimeout = %v, want %v", got, defaultHealthDependencyTimeout)
|
|
}
|
|
}
|
|
|
|
// TestDefaultsKeepAConfiguredHealthDependencyTimeout pins that an operator's
|
|
// value is not overwritten, which is the whole point of making it configurable.
|
|
func TestDefaultsKeepAConfiguredHealthDependencyTimeout(t *testing.T) {
|
|
cfg := config.Config{Health: config.Health{DependencyTimeout: config.Duration(30 * time.Second)}}
|
|
(&Loader{}).applyDefaults(&cfg)
|
|
|
|
if got := time.Duration(cfg.Health.DependencyTimeout); got != 30*time.Second {
|
|
t.Fatalf("Health.DependencyTimeout = %v, want the configured 30s", got)
|
|
}
|
|
}
|