package config import ( "bytes" "errors" "reflect" "strings" "testing" configkit "gitea.maximumdirect.net/eric/ConfigKit" ) func loadDocumentBytes(content string) (*configkit.Result[Document], error) { return configkit.Load(configkit.Bytes("application.yml", []byte(content)), configkit.Options[Document]{ Definition: documentDefinition(), }) } func TestDocumentDefaultsAndExplicitValues(t *testing.T) { defaultsOnly, err := configkit.Load(configkit.NoSource(), configkit.Options[Document]{Definition: documentDefinition()}) if err != nil { t.Fatalf("defaults-only load: %v", err) } if !reflect.DeepEqual(defaultsOnly.Config, documentDefaults()) || len(defaultsOnly.Sources()) != 0 { t.Fatalf("unexpected defaults-only result: %+v sources=%+v", defaultsOnly.Config, defaultsOnly.Sources()) } result, err := loadDocumentBytes(`prompt_dir: "" profile_dir: "" schema_dir: "" transient_retries: 0 server: addr: "" artifact_root: "" max_request_bytes: 0 max_artifact_bytes: 0 max_response_bytes: 0 defaults: render_format: " JSON " backends: local: endpoint: "http://fixture.invalid/v1" queue_capacity: 0 extra_params: sample_count: 23 `) if err != nil { t.Fatalf("explicit-value load: %v", err) } config := result.Config if config.SchemaDir != "" || config.Server.Addr != "" || config.Server.MaxRequestBytes != 0 || config.Server.MaxArtifactBytes != 0 || config.Server.MaxResponseBytes != 0 { t.Fatalf("explicit empty and zero values did not replace defaults: %+v", config) } if config.TransientRetries == nil || *config.TransientRetries != 0 { t.Fatalf("explicit zero retry budget lost: %+v", config.TransientRetries) } if backend := config.Backends["local"]; backend.QueueCapacity == nil || *backend.QueueCapacity != 0 || backend.ExtraParams["sample_count"] != int64(23) { t.Fatalf("backend presence or dynamic integer changed: %+v", backend) } if config.Defaults.RenderFormat != "json" { t.Fatalf("render format normalization failed: %q", config.Defaults.RenderFormat) } nullable, err := loadDocumentBytes("transient_retries: null\nbackends:\n local:\n queue_capacity: null\n") if err != nil { t.Fatalf("nullable-value load: %v", err) } if nullable.Config.TransientRetries != nil || nullable.Config.Backends["local"].QueueCapacity != nil { t.Fatalf("nullable fields did not remain nil: %+v", nullable.Config) } nullBackends, err := loadDocumentBytes("backends: null\n") if err != nil || nullBackends.Config.Backends != nil { t.Fatalf("nullable backend map did not remain nil: %+v error=%v", nullBackends, err) } } func TestDocumentResolvesBackendInheritance(t *testing.T) { result, err := loadDocumentBytes(`backends: base: endpoint: http://base.invalid/v1 api_key_env: BASE_API_KEY concurrency_limit: 2 queue_capacity: 4 extra_params: enabled: true shared: visible count: 7 child: extends: base queue_capacity: 0 extra_params: enabled: false nullable-child: extends: base queue_capacity: null `) if err != nil { t.Fatalf("load inherited document: %v", err) } child := result.Config.Backends["child"] if child.Endpoint != "http://base.invalid/v1" || child.APIKeyEnv != "BASE_API_KEY" || child.ConcurrencyLimit != 2 { t.Fatalf("child did not inherit backend settings: %+v", child) } if child.QueueCapacity == nil || *child.QueueCapacity != 0 { t.Fatalf("explicit zero queue capacity was not retained: %+v", child.QueueCapacity) } if child.ExtraParams["enabled"] != false || child.ExtraParams["shared"] != "visible" || child.ExtraParams["count"] != int64(7) { t.Fatalf("child parameters were not combined with explicit presence: %#v", child.ExtraParams) } nullableChild := result.Config.Backends["nullable-child"] if nullableChild.QueueCapacity != nil { t.Fatalf("explicit null inherited the parent's queue capacity: %+v", nullableChild.QueueCapacity) } metadata := result.Metadata() endpointPath := configkit.Keys("backends", "child", "endpoint") field, known := metadata.Lookup(endpointPath) if !known || !field.Explicit || !metadata.IsExplicit(endpointPath) { t.Fatalf("inherited endpoint presence was lost: field=%+v known=%t", field, known) } wantFrom := configkit.Keys("backends", "base", "endpoint").String() wantTo := endpointPath.String() wantReference := configkit.Keys("backends", "child", "extends").String() foundInheritance := false for _, step := range field.Origin.Inheritance { if step.From.String() == wantFrom && step.To.String() == wantTo && step.Reference.String() == wantReference { foundInheritance = true break } } if !foundInheritance { t.Fatalf("inherited endpoint provenance missing: %+v", field.Origin.Inheritance) } settings := Settings(result.Config) wantIDs := []string{"base", "child", "nullable-child"} if len(settings.Backends) != len(wantIDs) { t.Fatalf("backend definitions were dropped: %+v", settings.Backends) } for i, want := range wantIDs { if settings.Backends[i].ID != want { t.Fatalf("backend IDs are not sorted: %+v", settings.Backends) } } convertedChild := settings.Backends[1] if convertedChild.Endpoint != child.Endpoint || convertedChild.APIKeyEnv != child.APIKeyEnv || convertedChild.ConcurrencyLimit != 2 { t.Fatalf("inherited settings changed during conversion: %+v", convertedChild) } if convertedChild.QueueCapacity == nil || *convertedChild.QueueCapacity != 0 { t.Fatalf("zero queue capacity presence changed during conversion: %+v", convertedChild.QueueCapacity) } if value := convertedChild.ExtraParams["count"]; value != int64(7) { t.Fatalf("dynamic integer changed during conversion: %T %v", value, value) } if settings.Backends[2].QueueCapacity != nil { t.Fatalf("nullable queue capacity changed during conversion: %+v", settings.Backends[2].QueueCapacity) } } func TestDocumentRecordsEffectiveNormalization(t *testing.T) { result, err := loadDocumentBytes(`prompt_dir: " ./one/../two " profile_dir: " " server: artifact_root: " ./data/../artifacts " addr: " :9000 " defaults: render_format: " JSON " `) if err != nil { t.Fatalf("load normalized document: %v", err) } if result.Config.PromptDir != "two" || result.Config.ProfileDir != "" || result.Config.Server.ArtifactRoot != "artifacts" || result.Config.Server.Addr != ":9000" { t.Fatalf("unexpected normalized values: %+v", result.Config) } var effective bytes.Buffer if err := result.WriteEffective(&effective); err != nil { t.Fatalf("write effective configuration: %v", err) } for _, fragment := range []string{"prompt_dir: two", "profile_dir: ''", "artifact_root: artifacts", "addr: :9000", "render_format: json"} { if !strings.Contains(effective.String(), fragment) { t.Fatalf("effective output omitted %q: %s", fragment, effective.String()) } } explanation, known := result.Explain(configkit.Keys("prompt_dir")) if !known || explanation.Effective.YAML != "two\n" { t.Fatalf("explanation does not agree with effective value: %+v known=%t", explanation, known) } found := false for _, change := range explanation.History { if change.Origin.Operation == configkit.ChangeNormalization { found = true } } if !found { t.Fatalf("normalization was not recorded: %+v", explanation.History) } } func TestDocumentValidationIsSafeAndPathSpecific(t *testing.T) { for _, tc := range []struct{ name, content, path string }{ {"negative retry", "transient_retries: -9173\n", "/transient_retries"}, {"negative request limit", "server:\n max_request_bytes: -9173\n", "/server/max_request_bytes"}, {"negative artifact limit", "server:\n max_artifact_bytes: -9173\n", "/server/max_artifact_bytes"}, {"negative response limit", "server:\n max_response_bytes: -9173\n", "/server/max_response_bytes"}, {"empty format", "defaults:\n render_format: \"\"\n", "/defaults/render_format"}, {"unknown format", "defaults:\n render_format: private-invalid-value\n", "/defaults/render_format"}, } { t.Run(tc.name, func(t *testing.T) { _, err := loadDocumentBytes(tc.content) var loadError *configkit.LoadError if !errors.As(err, &loadError) { t.Fatalf("expected typed validation error, got %v", err) } found := false for _, diagnostic := range loadError.Diagnostics() { if diagnostic.Code == configkit.CodeValidateError && diagnostic.Path.String() == tc.path { found = true } if strings.Contains(diagnostic.Message, "9173") || strings.Contains(diagnostic.Message, "private-invalid-value") { t.Fatalf("diagnostic disclosed rejected value: %+v", diagnostic) } } if !found { t.Fatalf("expected validation at %s, got %+v", tc.path, loadError.Diagnostics()) } }) } } func TestDocumentRejectsNativeShapeErrors(t *testing.T) { for _, content := range []string{ "server: null\n", "defaults: null\n", "server:\n addr: null\n", "server:\n max_request_bytes: null\n", "defaults:\n render_format: null\n", "server:\n unknown_field: 1\n", "backends:\n local:\n unknown_field: 1\n", } { _, err := loadDocumentBytes(content) if err == nil { t.Fatalf("unexpected acceptance of %q", content) } } }