promptkit/internal/configuration/load_test.go

package configuration

import (
	"errors"
	"testing"

	"gitea.maximumdirect.net/eric/ConfigKit"
)

func mapping(label string, values map[string]any) configkit.Input {
	return configkit.Input{Source: configkit.Mapping(label, values)}
}

func TestLoadComposesLiteralKeysAndEffectivePresence(t *testing.T) {
	base := mapping("defaults", map[string]any{
		"backends": map[string]any{
			"local.v1": map[string]any{"endpoint": "http://localhost:8080/v1", "concurrency_limit": 2},
		},
		"profiles": map[string]any{
			"base/one": map[string]any{"backend": "local.v1", "temperature": 0.8, "top_p": 0.9, "api_key_required": true,
				"extra_params": map[string]any{"provider": map[string]any{"first": 1, "second": 2}}},
			"child.v1": map[string]any{"extends": "base/one"},
		},
		"prompts": map[string]any{"invoice/summary": map[string]any{"v1.0": map[string]any{
			"messages": []any{map[string]any{"role": "user", "content": "Summarize."}},
			"output":   map[string]any{"format": "text", "validation_mode": "basic"},
		}}},
	})
	overlay := mapping("operator", map[string]any{
		"backends": map[string]any{"local.v1": map[string]any{"queue_capacity": 0}},
		"profiles": map[string]any{"child.v1": map[string]any{
			"temperature": 0, "top_p": nil, "api_key_required": false,
			"extra_params": map[string]any{"provider": map[string]any{"second": 3}},
		}},
	})
	loaded, err := load(configkit.Input{Source: configkit.NoSource()}, []configkit.Underlay{
		{Inputs: []configkit.Input{base}}, {Inputs: []configkit.Input{overlay}},
	})
	if err != nil {
		t.Fatal(err)
	}
	profile := loaded.result.Config.Profiles["child.v1"]
	if profile.Temperature == nil || *profile.Temperature != 0 || profile.TopP != nil || profile.APIKeyRequired == nil || *profile.APIKeyRequired {
		t.Fatalf("effective values were not retained: %+v", profile)
	}
	if loaded.profiles["child.v1"]["temperature"] != fieldValue || loaded.profiles["child.v1"]["top_p"] != fieldNull || loaded.profiles["child.v1"]["api_key_required"] != fieldValue {
		t.Fatalf("effective presence was lost: %+v", loaded.profiles["child.v1"])
	}
	provider := profile.ExtraParams["provider"].(map[string]any)
	if provider["first"] != int64(1) || provider["second"] != int64(3) {
		t.Fatalf("recursive overlay failed: %+v", provider)
	}
	backend := loaded.result.Config.Backends["local.v1"]
	if backend.QueueCapacity == nil || *backend.QueueCapacity != 0 || loaded.backends["local.v1"]["queue_capacity"] != fieldValue {
		t.Fatalf("explicit zero queue capacity was lost: %+v", backend)
	}
	if loaded.result.Config.Prompts["invoice/summary"]["v1.0"].Messages[0].Content == nil {
		t.Fatal("literal prompt ID and version were not decoded")
	}
}

func TestLoadRecordsBackendNormalizationAndNullDefault(t *testing.T) {
	loaded, err := load(mapping("backend", map[string]any{"backends": map[string]any{
		"local": map[string]any{"endpoint": " HTTP://localhost:8080/v1 ", "api_key_env": " TOKEN_NAME ",
			"concurrency_limit": 2, "queue_capacity": nil},
	}}), nil)
	if err != nil {
		t.Fatal(err)
	}
	backend := loaded.result.Config.Backends["local"]
	if backend.Endpoint == nil || *backend.Endpoint != "http://localhost:8080/v1" ||
		backend.APIKeyEnv == nil || *backend.APIKeyEnv != "TOKEN_NAME" ||
		backend.QueueCapacity == nil || *backend.QueueCapacity != 1024 {
		t.Fatalf("backend normalization/default was not applied: %+v", backend)
	}
	if loaded.backends["local"]["queue_capacity"] != fieldNull {
		t.Fatalf("explicit null was not retained: %+v", loaded.backends["local"])
	}
}

func TestLoadDefaultsAbsentQueueCapacity(t *testing.T) {
	loaded, err := load(mapping("backend", map[string]any{"backends": map[string]any{
		"local": map[string]any{"endpoint": "http://localhost:8080/v1", "concurrency_limit": 1},
	}}), nil)
	if err != nil {
		t.Fatal(err)
	}
	backend := loaded.result.Config.Backends["local"]
	if backend.QueueCapacity == nil || *backend.QueueCapacity != 1024 || loaded.backends["local"]["queue_capacity"] != fieldAbsent {
		t.Fatalf("absent queue capacity did not receive its default: %+v", backend)
	}
}

func TestLoadRejectsStrictGroupConflict(t *testing.T) {
	_, err := load(configkit.Input{Source: configkit.NoSource()}, []configkit.Underlay{{Inputs: []configkit.Input{
		mapping("first", map[string]any{"profiles": map[string]any{"shared": map[string]any{"model": "one"}}}),
		mapping("second", map[string]any{"profiles": map[string]any{"shared": map[string]any{"model": "one"}}}),
	}}})
	var loadError *configkit.LoadError
	if !errors.As(err, &loadError) {
		t.Fatalf("expected ConfigKit load error, got %v", err)
	}
}

func TestLoadValidatesOnlyFinalDomainValues(t *testing.T) {
	underlay := mapping("defaults", map[string]any{
		"backends": map[string]any{"local": map[string]any{"endpoint": "not a URL"}},
		"profiles": map[string]any{"partial": map[string]any{"backend": "local"}},
	})
	main := mapping("operator", map[string]any{"backends": map[string]any{"local": map[string]any{"endpoint": "http://localhost:8080/v1"}}})
	loaded, err := load(main, []configkit.Underlay{{Inputs: []configkit.Input{underlay}}})
	if err != nil {
		t.Fatalf("replaced lower-layer domain value should not fail: %v", err)
	}
	if loaded.result.Config.Profiles["partial"].Model != nil {
		t.Fatal("unused partial profile unexpectedly gained a model")
	}

	_, err = load(configkit.Input{Source: configkit.NoSource()}, []configkit.Underlay{{Inputs: []configkit.Input{
		mapping("invalid", map[string]any{"backends": map[string]any{"unused": map[string]any{"endpoint": "not a URL"}}}),
	}}})
	var loadError *configkit.LoadError
	if !errors.As(err, &loadError) {
		t.Fatalf("expected path-aware effective backend failure, got %v", err)
	}
	if diagnostics := loadError.Diagnostics(); len(diagnostics) != 1 || diagnostics[0].Path.String() != "/backends/unused/endpoint" {
		t.Fatalf("expected endpoint diagnostic, got %+v", diagnostics)
	}
}

func TestLoadKeepsSyntaxErrorsFromLowerTiers(t *testing.T) {
	_, err := load(mapping("operator", map[string]any{"backends": map[string]any{"local": map[string]any{"endpoint": "http://localhost:8080"}}}),
		[]configkit.Underlay{{Inputs: []configkit.Input{{Source: configkit.Bytes("broken", []byte("backends: ["))}}}})
	var loadError *configkit.LoadError
	if !errors.As(err, &loadError) {
		t.Fatalf("expected lower-tier parsing error, got %v", err)
	}
}