package ckconfig import ( "bytes" "context" "errors" "io" "reflect" "strings" "testing" commandkit "go.maximumdirect.net/commandkit" configkit "go.maximumdirect.net/configkit" ) func TestSubtreeScopeUsesNativeInspection(t *testing.T) { definition := configkit.Definition[map[string]any]{Validate: func(_ *map[string]any, validation *configkit.Validation) { validation.Warning(configkit.Keys("sibling"), "sibling warning") }} makeResult := func(value any) *configkit.Result[map[string]any] { t.Helper() result, err := configkit.Load(configkit.Mapping("application", map[string]any{"storage": value, "sibling": "outside"}), configkit.Options[map[string]any]{Definition: definition}) if err != nil { t.Fatal(err) } return result } left, right := makeResult(map[string]any{"name": "before"}), makeResult(map[string]any{"name": "after"}) calls := 0 scope := FromConfigKitSubtree("storage", "", configkit.Keys("storage"), func(_ context.Context, selection Selection, _, _ struct{}) (*configkit.Result[map[string]any], error) { calls++ if selection.Config.Value == "after" { return right, nil } return left, nil }) app := newConfigTestApp(t, Command(Suite[struct{}, struct{}]{Scopes: []Scope[struct{}, struct{}]{scope}})) if calls != 0 { t.Fatal("construction acquired configuration") } run := func(args ...string) (commandkit.Outcome, string, string) { t.Helper() var out, diagnostics bytes.Buffer outcome := app.Execute(context.Background(), append(append([]string{"config"}, args...), "--scope=storage"), commandkit.Streams{Out: &out, Err: &diagnostics}) return outcome, out.String(), diagnostics.String() } for _, tc := range []struct { args []string contains, excludes string }{ {[]string{"show"}, "before", "outside"}, {[]string{"explain", "--list"}, "/storage/name", "/sibling"}, {[]string{"explain", "--path=/sibling"}, "/sibling", ""}, {[]string{"sources"}, "application", ""}, {[]string{"diff", "--config=before", "--against-config=after"}, "after", ""}, } { outcome, output, diagnostics := run(tc.args...) if outcome.Kind != commandkit.OutcomeSuccess || !strings.Contains(output, tc.contains) || (tc.excludes != "" && strings.Contains(output, tc.excludes)) { t.Errorf("%v: outcome=%#v output=%q diagnostics=%q", tc.args, outcome, output, diagnostics) } } lv, _ := left.InspectSubtree(configkit.Keys("storage")) rv, _ := right.InspectSubtree(configkit.Keys("storage")) want, err := lv.Diff(rv) if err != nil { t.Fatal(err) } got, err := scope.Compare(context.Background(), ComparisonRequest[struct{}]{Left: ComparisonSide[struct{}]{Selection: Selection{Config: commandkit.Supplied[string]{Value: "before", Set: true}}}, Right: ComparisonSide[struct{}]{Selection: Selection{Config: commandkit.Supplied[string]{Value: "after", Set: true}}}}, struct{}{}) if err != nil || !reflect.DeepEqual(got.Value, want) || len(got.Diagnostics) != 2 { t.Fatalf("comparison = %#v, %v; want %#v", got, err, want) } } func TestSubtreeScopeAbsenceAndErrors(t *testing.T) { load := func(value map[string]any) *configkit.Result[map[string]any] { t.Helper() result, err := configkit.Load[map[string]any](configkit.Mapping("application", value)) if err != nil { t.Fatal(err) } return result } for _, tc := range []struct { name string result *configkit.Result[map[string]any] wantWriteError bool }{ {"absent", load(map[string]any{"sibling": 1}), true}, {"null", load(map[string]any{"storage": nil}), false}, } { t.Run(tc.name, func(t *testing.T) { scope := FromConfigKitSubtree("storage", "", configkit.Keys("storage"), func(context.Context, Selection, struct{}, struct{}) (*configkit.Result[map[string]any], error) { return tc.result, nil }) acquired, err := scope.Acquire(context.Background(), Request{}, struct{}{}, struct{}{}) if err != nil { t.Fatal(err) } var output bytes.Buffer err = acquired.Value.Effective.WriteEffective(&output) if (err != nil) != tc.wantWriteError || (!tc.wantWriteError && !strings.Contains(output.String(), "null")) { t.Fatalf("write = %q, %v", output.String(), err) } }) } cause := errors.New("application load failed") result := load(map[string]any{"sibling": 1}) scope := FromConfigKitSubtree("storage", "", configkit.Keys("storage"), func(context.Context, Selection, struct{}, struct{}) (*configkit.Result[map[string]any], error) { return result, cause }) acquired, err := scope.Acquire(context.Background(), Request{}, struct{}{}, struct{}{}) if !errors.Is(err, cause) || acquired.Value.Sources == nil || acquired.Value.Findings == nil { t.Fatalf("load failure = %#v, %v", acquired, err) } app := newConfigTestApp(t, Command(Suite[struct{}, struct{}]{Scopes: []Scope[struct{}, struct{}]{scope}})) outcome := app.Execute(context.Background(), []string{"config", "show", "--scope=storage"}, commandkit.Streams{Out: io.Discard, Err: io.Discard}) if outcome.Kind != commandkit.OutcomeOperational || !errors.Is(outcome.Cause, cause) { t.Fatalf("outcome = %#v", outcome) } unavailable := FromConfigKitSubtree("storage", "", configkit.Keys("storage"), func(context.Context, Selection, struct{}, struct{}) (*configkit.Result[map[string]any], error) { return &configkit.Result[map[string]any]{}, nil }) acquired, err = unavailable.Acquire(context.Background(), Request{}, struct{}{}, struct{}{}) if err == nil || acquired.Value.Findings == nil || acquired.Value.Sources == nil { t.Fatalf("unavailable = %#v, %v", acquired, err) } nilScope := FromConfigKitSubtree[struct{}, struct{}, map[string]any]("storage", "", configkit.Keys("storage"), nil) if len(nilScope.issues) == 0 { t.Fatal("nil loader not retained") } } func TestSubtreeScopeRetainsWholeLoadFailure(t *testing.T) { path := configkit.Keys("sibling") _, loadErr := configkit.Load(configkit.Bytes("bad application", []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, "outside warning") return errors.New("invalid outside") }, }}}) if loadErr == nil { t.Fatal("fixture did not fail") } scope := FromConfigKitSubtree("storage", "", configkit.Keys("storage"), func(context.Context, Selection, struct{}, struct{}) (*configkit.Result[struct{}], error) { return nil, loadErr }) acquired, err := scope.Acquire(context.Background(), Request{}, struct{}{}, struct{}{}) var native *configkit.LoadError if !errors.As(err, &native) || !errors.Is(err, loadErr) || acquired.Value.Sources == nil || acquired.Value.Findings == nil || !reflect.DeepEqual(acquired.Value.Findings.Records, native.Diagnostics()) || len(acquired.Explanation.Details) == 0 { t.Fatalf("failure evidence = %#v, %v", acquired, err) } app := newConfigTestApp(t, Command(Suite[struct{}, struct{}]{Scopes: []Scope[struct{}, struct{}]{scope}})) outcome := app.Execute(context.Background(), []string{"config", "validate", "--scope=storage"}, commandkit.Streams{Out: io.Discard, Err: io.Discard}) if !errors.Is(outcome.Cause, loadErr) { t.Fatalf("validation outcome = %#v", outcome) } } func TestSubtreeComparisonRetainsNativeAncestor(t *testing.T) { makeResult := func(item string) *configkit.Result[map[string]any] { t.Helper() result, err := configkit.Load[map[string]any](configkit.Mapping(item, map[string]any{"items": []any{item}})) if err != nil { t.Fatal(err) } return result } left, right := makeResult("before"), makeResult("after") path := configkit.Keys("items", "0") scope := FromConfigKitSubtree("item", "", path, func(_ context.Context, selection Selection, _, _ struct{}) (*configkit.Result[map[string]any], error) { if selection.Config.Value == "right" { return right, nil } return left, nil }) got, err := scope.Compare(context.Background(), ComparisonRequest[struct{}]{Right: ComparisonSide[struct{}]{Selection: Selection{Config: commandkit.Supplied[string]{Value: "right", Set: true}}}}, struct{}{}) lv, _ := left.InspectSubtree(path) rv, _ := right.InspectSubtree(path) want, nativeErr := lv.Diff(rv) if err != nil || nativeErr != nil || !reflect.DeepEqual(got.Value, want) || len(want) != 1 || want[0].Path.String() != "/items" { t.Fatalf("comparison = %#v, %v; native = %#v, %v", got.Value, err, want, nativeErr) } }