commandkit/integrations/ckconfig/contracts_adapter_test.go

package ckconfig

import (
	"bytes"
	"context"
	"errors"
	"fmt"
	"io"
	"strings"
	"testing"

	commandkit "gitea.maximumdirect.net/eric/CommandKit"
	configkit "gitea.maximumdirect.net/eric/ConfigKit"
)

func TestWithScopeErrorCopiesAndRetainsCauses(t *testing.T) {
	first := &scopeCause{message: "first construction problem"}
	second := errors.New("second construction problem")
	original := Scope[struct{}, struct{}]{issues: []error{fmt.Errorf("wrapped: %w", first)}}

	copyWithError := WithScopeError(original, second)
	if len(original.issues) != 1 || !errors.Is(original.issues[0], first) {
		t.Fatalf("original issues changed: %#v", original.issues)
	}
	if len(copyWithError.issues) != 2 || !errors.Is(copyWithError.issues[0], first) || !errors.Is(copyWithError.issues[1], second) {
		t.Fatalf("attached issues = %#v", copyWithError.issues)
	}
	if copyWithError.issues[0] != original.issues[0] {
		t.Fatal("existing cause identity was not preserved")
	}
	var retained *scopeCause
	if !errors.As(copyWithError.issues[0], &retained) || retained != first {
		t.Fatalf("retained concrete cause = %#v, want %#v", retained, first)
	}

	narrowed := copyWithError
	narrowed.Operations = nil
	third := errors.New("third construction problem")
	withThird := WithScopeError(narrowed, third)
	unchanged := WithScopeError(withThird, nil)
	if len(unchanged.issues) != len(copyWithError.issues)+1 || !errors.Is(unchanged.issues[2], third) {
		t.Fatalf("repeated attachment lost issues: %#v", unchanged.issues)
	}
}

type scopeCause struct{ message string }

func (e *scopeCause) Error() string { return e.message }

func TestFromConfigKitRetainsNilLoaderIssue(t *testing.T) {
	scope := FromConfigKit[struct{}, struct{}, struct{}]("app", "Application configuration", nil)
	scope.Operations = nil
	if scope.Acquire != nil {
		t.Fatal("nil loader produced an acquisition callback")
	}
	if len(scope.issues) != 1 || !strings.Contains(scope.issues[0].Error(), "loader") {
		t.Fatalf("retained nil-loader issues = %#v", scope.issues)
	}
}

func TestFromConfigKitPassesInvocationValuesAndNativeFacets(t *testing.T) {
	type input struct{ Label string }
	type state struct{ Calls int }
	type settings struct {
		Name string `yaml:"name"`
	}
	ctx, cancel := context.WithCancel(context.Background())
	defer cancel()
	selection := Selection{
		Config:  commandkit.Supplied[string]{Value: "chosen.yaml", Set: true},
		Overlay: commandkit.Supplied[string]{Value: "", Set: true},
	}
	gotContext, gotSelection, gotInput, gotState := context.Context(nil), Selection{}, input{}, (*state)(nil)
	result, err := configkit.Load(configkit.Mapping("source.yaml", map[string]any{"name": "native"}), configkit.Options[settings]{Definition: configkit.Definition[settings]{}})
	if err != nil {
		t.Fatal(err)
	}
	scope := FromConfigKit[input, *state, settings]("app", "Application configuration", func(got context.Context, selected Selection, in input, st *state) (*configkit.Result[settings], error) {
		gotContext, gotSelection, gotInput, gotState = got, selected, in, st
		st.Calls++
		return result, nil
	})
	if len(scope.Operations) != 5 || scope.Operations[0] != Validate || scope.Operations[1] != Show || scope.Operations[2] != Sources || scope.Operations[3] != Explain || scope.Operations[4] != Diff {
		t.Fatalf("operations = %#v", scope.Operations)
	}
	if gotContext != nil {
		t.Fatal("loader ran during adapter construction")
	}
	stateValue := &state{}
	acquired, err := scope.Acquire(ctx, Request{Operation: Show, Selection: selection}, input{Label: "typed"}, stateValue)
	if err != nil {
		t.Fatal(err)
	}
	if gotContext != ctx || gotSelection != selection || gotInput.Label != "typed" || gotState != stateValue || stateValue.Calls != 1 {
		t.Fatalf("loader arguments/context/state = %v, %#v, %#v, %p, %d", gotContext, gotSelection, gotInput, gotState, stateValue.Calls)
	}
	if acquired.Value.Effective != result || acquired.Value.Sources != result || acquired.Value.Explanation != result {
		t.Fatal("adapter did not expose the native result facets directly")
	}

	var effective bytes.Buffer
	if err := acquired.Value.Effective.WriteEffective(&effective); err != nil {
		t.Fatal(err)
	}
	if !strings.Contains(effective.String(), "name: native") {
		t.Fatalf("native effective output = %q", effective.String())
	}
	sources := acquired.Value.Sources.Sources()
	if len(sources) != 1 || sources[0].Label != "source.yaml" {
		t.Fatalf("native sources = %#v", sources)
	}
	path, err := configkit.ParsePath("/name")
	if err != nil {
		t.Fatal(err)
	}
	if _, ok := acquired.Value.Explanation.Explain(path); !ok {
		t.Fatal("native explanation facet did not resolve /name")
	}
	var explanation bytes.Buffer
	if err := acquired.Value.Explanation.WriteExplanation(&explanation, path); err != nil {
		t.Fatal(err)
	}
	if explanation.Len() == 0 {
		t.Fatal("native explanation writer produced no output")
	}
}

func TestFromConfigKitRetainsLoadErrorAndDiagnostics(t *testing.T) {
	path := configkit.Keys("schema_version")
	_, loadErr := configkit.Load(configkit.Bytes("bad source", []byte("{}\n")), configkit.Options[struct{}]{
		Definition: configkit.Definition[struct{}]{Version: &configkit.VersionRule{
			Path: path,
			Check: func(_ configkit.Version, validation *configkit.Validation) error {
				validation.Warning(path, "review schema compatibility")
				return errors.New("private checker error")
			},
		}},
	})
	if loadErr == nil {
		t.Fatal("fixture did not produce a ConfigKit load error")
	}
	scope := FromConfigKit[struct{}, struct{}, struct{}]("app", "", func(context.Context, Selection, struct{}, struct{}) (*configkit.Result[struct{}], error) {
		return nil, loadErr
	})
	acquired, gotErr := scope.Acquire(context.Background(), Request{}, struct{}{}, struct{}{})
	if gotErr != loadErr {
		t.Fatalf("load error identity = %v, want original %v", gotErr, loadErr)
	}
	var typed *configkit.LoadError
	if !errors.As(gotErr, &typed) {
		t.Fatalf("load error type was not retained: %T", gotErr)
	}
	if len(acquired.Diagnostics) != 1 || acquired.Diagnostics[0].Severity != commandkit.SeverityWarning {
		t.Fatalf("failure diagnostics = %#v", acquired.Diagnostics)
	}
	if acquired.Explanation.Message != "" || len(acquired.Explanation.Details) != 1 {
		t.Fatalf("failure explanation = %#v", acquired.Explanation)
	}
	var warning, terminal bytes.Buffer
	if err := acquired.Diagnostics[0].Write(&warning); err != nil {
		t.Fatal(err)
	}
	if err := acquired.Explanation.Details[0](&terminal); err != nil {
		t.Fatal(err)
	}
	if !strings.Contains(warning.String(), `Configuration scope "app":`) || !strings.Contains(warning.String(), `review schema compatibility`) {
		t.Fatalf("warning output lost its scope or record: %q", warning.String())
	}
	if !strings.Contains(terminal.String(), `Configuration scope "app":`) || !strings.Contains(terminal.String(), `"bad source"`) || strings.Contains(terminal.String(), "review schema compatibility") {
		t.Fatalf("terminal explanation lost native context or included an independent warning: %q", terminal.String())
	}
	if strings.Contains(terminal.String(), "private checker error") {
		t.Fatalf("terminal explanation exposed the upstream cause: %q", terminal.String())
	}
}

func TestFromConfigKitPreservesValueAndDiagnosticsAlongsideError(t *testing.T) {
	result, err := adapterSettingsLoad(configkit.Mapping("partial source", map[string]any{"greeting": "Hello"}))
	if err != nil {
		t.Fatal(err)
	}
	loadErr := errors.New("loader returned a value with an error")
	scope := FromConfigKit[struct{}, struct{}, adapterSettings]("app", "", func(context.Context, Selection, struct{}, struct{}) (*configkit.Result[adapterSettings], error) {
		return result, loadErr
	})

	acquired, gotErr := scope.Acquire(context.Background(), Request{}, struct{}{}, struct{}{})
	if gotErr != loadErr {
		t.Fatalf("load error identity = %v, want %v", gotErr, loadErr)
	}
	if acquired.Value.Effective != result || acquired.Value.Sources != result || acquired.Value.Explanation != result {
		t.Fatalf("acquired value facets were lost: %#v", acquired.Value)
	}
	if len(acquired.Diagnostics) != 1 || acquired.Diagnostics[0].Severity != commandkit.SeverityWarning {
		t.Fatalf("independent diagnostics = %#v", acquired.Diagnostics)
	}
	if len(acquired.Explanation.Details) != 0 {
		t.Fatalf("warning-only result acquired terminal context: %#v", acquired.Explanation)
	}
}

func TestConfigKitDiagnosticsMapSeverityAndPropagateWriterFailures(t *testing.T) {
	warning, noExplanation := configKitDiagnostics("app", nil, []configkit.Diagnostic{{Severity: configkit.SeverityWarning, Message: "safe warning"}})
	if len(warning) != 1 || warning[0].Severity != commandkit.SeverityWarning {
		t.Fatalf("warning diagnostics = %#v", warning)
	}
	if noExplanation.Message != "" || len(noExplanation.Details) != 0 {
		t.Fatalf("warning-only explanation = %#v", noExplanation)
	}
	withWarning, withExplanation := configKitDiagnostics("app", nil, []configkit.Diagnostic{
		{Severity: configkit.SeverityWarning, Message: "safe warning"},
		{Severity: configkit.SeverityError, Message: "safe error"},
	})
	if len(withWarning) != 1 || withWarning[0].Severity != commandkit.SeverityWarning || len(withExplanation.Details) != 1 {
		t.Fatalf("mixed diagnostics = %#v, explanation = %#v", withWarning, withExplanation)
	}

	if err := withWarning[0].Write(shortWriter{}); !errors.Is(err, io.ErrShortWrite) {
		t.Fatalf("short writer error = %v, want %v", err, io.ErrShortWrite)
	}
	if err := withExplanation.Details[0](shortWriter{}); !errors.Is(err, io.ErrShortWrite) {
		t.Fatalf("terminal short writer error = %v, want %v", err, io.ErrShortWrite)
	}
	wantErr := errors.New("writer failed")
	if err := withWarning[0].Write(failingWriter{err: wantErr}); !errors.Is(err, wantErr) {
		t.Fatalf("writer error = %v, want %v", err, wantErr)
	}
	if err := withExplanation.Details[0](failingWriter{err: wantErr}); !errors.Is(err, wantErr) {
		t.Fatalf("terminal writer error = %v, want %v", err, wantErr)
	}

}

func TestConfigKitTerminalContextRetainsRelatedLocationsAndSnapshots(t *testing.T) {
	primary := &configkit.Location{SourceID: "primary-source", Line: 4, Column: 2}
	related := []configkit.Location{{SourceID: "related-source", Line: 2, Column: 1}}
	sources := []configkit.SourceInfo{
		{ID: "primary-source", Label: "primary", Path: "primary.yml"},
		{ID: "related-source", Label: "related", Path: "related.yml"},
	}
	records := []configkit.Diagnostic{{
		Severity: configkit.SeverityError,
		Path:     configkit.Keys("name"),
		Message:  "native terminal context",
		Primary:  primary,
		Related:  related,
	}}
	_, explanation := configKitDiagnostics("app", sources, records)
	primary.SourceID = "mutated-primary"
	related[0].SourceID = "mutated-related"
	sources[0].Path = "mutated.yml"

	if len(explanation.Details) != 1 {
		t.Fatalf("explanation = %#v", explanation)
	}
	var output bytes.Buffer
	if err := explanation.Details[0](&output); err != nil {
		t.Fatal(err)
	}
	for _, fragment := range []string{"primary.yml", "primary-source", "related-source", "native terminal context"} {
		if !strings.Contains(output.String(), fragment) {
			t.Errorf("terminal context %q omits %q", output.String(), fragment)
		}
	}
	if strings.Contains(output.String(), "mutated-") || strings.Contains(output.String(), "mutated.yml") {
		t.Fatalf("terminal renderer retained caller mutations: %q", output.String())
	}
}

type shortWriter struct{}

func (shortWriter) Write(value []byte) (int, error) { return len(value) - 1, nil }

type failingWriter struct{ err error }

func (w failingWriter) Write([]byte) (int, error) { return 0, w.err }