289 lines
15 KiB
Go
289 lines
15 KiB
Go
package ckconfig
|
|
|
|
import (
|
|
"bytes"
|
|
"context"
|
|
"errors"
|
|
"fmt"
|
|
"io"
|
|
"strings"
|
|
"testing"
|
|
|
|
commandkit "gitea.maximumdirect.net/eric/CommandKit"
|
|
configkit "gitea.maximumdirect.net/eric/ConfigKit"
|
|
"go.yaml.in/yaml/v4"
|
|
)
|
|
|
|
func TestConfigDiffExecutesWithDefaultAndExplicitYAMLAndInheritedSelections(t *testing.T) {
|
|
type settings struct {
|
|
Greeting string `yaml:"greeting"`
|
|
}
|
|
var selections []Selection
|
|
app := newConfigTestApp(t, AppCommand(func(_ context.Context, selection Selection) (*configkit.Result[settings], error) {
|
|
selections = append(selections, selection)
|
|
value := "Hello"
|
|
if selection.Config.Set && selection.Config.Value == "after.yml" {
|
|
value = "Goodbye"
|
|
}
|
|
return configkit.Load(configkit.Mapping("selected configuration", map[string]any{"greeting": value}), configkit.Options[settings]{})
|
|
}))
|
|
var output bytes.Buffer
|
|
outcome := app.Execute(context.Background(), []string{"config", "diff", "--config", "before.yml", "--overlay", "base", "--against-config", "after.yml"}, commandkit.Streams{Out: &output, Err: io.Discard})
|
|
if outcome.Kind != commandkit.OutcomeSuccess {
|
|
t.Fatalf("default YAML comparison outcome = %#v", outcome)
|
|
}
|
|
if len(selections) != 2 || !selections[0].Config.Set || selections[0].Config.Value != "before.yml" || !selections[1].Config.Set || selections[1].Config.Value != "after.yml" || selections[1].Overlay != selections[0].Overlay {
|
|
t.Fatalf("comparison selections = %#v", selections)
|
|
}
|
|
var document yaml.Node
|
|
if err := yaml.Unmarshal(output.Bytes(), &document); err != nil {
|
|
t.Fatalf("default report is not YAML: %q: %v", output.String(), err)
|
|
}
|
|
changes := reportField(document.Content[0], "changes")
|
|
if value := reportField(changes, "greeting"); value == nil || value.Value != "Goodbye" {
|
|
t.Fatalf("public comparison output = %#v", document.Content[0])
|
|
}
|
|
|
|
output.Reset()
|
|
outcome = app.Execute(context.Background(), []string{"config", "diff", "--format", "yaml", "--config", "before.yml", "--against-config", "before.yml"}, commandkit.Streams{Out: &output, Err: io.Discard})
|
|
if outcome.Kind != commandkit.OutcomeSuccess {
|
|
t.Fatalf("explicit YAML comparison outcome = %#v", outcome)
|
|
}
|
|
var equal yaml.Node
|
|
if err := yaml.Unmarshal(output.Bytes(), &equal); err != nil {
|
|
t.Fatalf("explicit YAML report is not YAML: %q: %v", output.String(), err)
|
|
}
|
|
if len(reportField(equal.Content[0], "additions").Content) != 0 || len(reportField(equal.Content[0], "changes").Content) != 0 || len(reportField(equal.Content[0], "deletions").Content) != 0 {
|
|
t.Fatalf("equal comparison did not return empty categories: %q", output.String())
|
|
}
|
|
|
|
loadsBeforeText := len(selections)
|
|
output.Reset()
|
|
outcome = app.Execute(context.Background(), []string{"config", "diff", "--format", "text"}, commandkit.Streams{Out: &output, Err: io.Discard})
|
|
if outcome.Kind != commandkit.OutcomeUsage || len(selections) != loadsBeforeText || output.Len() != 0 {
|
|
t.Fatalf("text format outcome/work/output = %#v / %d / %q", outcome, len(selections)-loadsBeforeText, output.String())
|
|
}
|
|
}
|
|
|
|
func TestConfigDiffRunsComparisonOnlyScopeAndRejectsUnsupportedScopeBeforeWork(t *testing.T) {
|
|
var inputCalls, stateCalls, acquireCalls, compareCalls int
|
|
app := newConfigTestApp(t, Command(Suite[struct{}, struct{}]{
|
|
NewInput: func() struct{} { inputCalls++; return struct{}{} },
|
|
NewState: func() struct{} { stateCalls++; return struct{}{} },
|
|
Scopes: []Scope[struct{}, struct{}]{
|
|
{Name: "app", Operations: []Operation{Diff}, Compare: func(context.Context, ComparisonRequest[struct{}], struct{}) (commandkit.Acquired[[]configkit.Difference], error) {
|
|
compareCalls++
|
|
return commandkit.Acquired[[]configkit.Difference]{}, nil
|
|
}},
|
|
{Name: "plain", Operations: []Operation{Show}, Acquire: func(context.Context, Request, struct{}, struct{}) (commandkit.Acquired[View], error) {
|
|
acquireCalls++
|
|
return commandkit.Acquired[View]{}, nil
|
|
}},
|
|
},
|
|
}))
|
|
var output bytes.Buffer
|
|
outcome := app.Execute(context.Background(), []string{"config", "scopes"}, commandkit.Streams{Out: &output, Err: io.Discard})
|
|
if outcome.Kind != commandkit.OutcomeSuccess || !strings.Contains(output.String(), "app: diff") {
|
|
t.Fatalf("comparison-only discovery = %#v, %q", outcome, output.String())
|
|
}
|
|
output.Reset()
|
|
outcome = app.Execute(context.Background(), []string{"config", "diff", "--scope", "app"}, commandkit.Streams{Out: &output, Err: io.Discard})
|
|
if outcome.Kind != commandkit.OutcomeSuccess || compareCalls != 1 {
|
|
t.Fatalf("comparison-only execution = %#v calls=%d", outcome, compareCalls)
|
|
}
|
|
inputsBefore, statesBefore := inputCalls, stateCalls
|
|
output.Reset()
|
|
outcome = app.Execute(context.Background(), []string{"config", "diff", "--scope", "plain"}, commandkit.Streams{Out: &output, Err: io.Discard})
|
|
if outcome.Kind != commandkit.OutcomeUsage || inputCalls != inputsBefore || stateCalls != statesBefore || acquireCalls != 0 || compareCalls != 1 || output.Len() != 0 {
|
|
t.Fatalf("unsupported scope outcome/work/output = %#v / %d,%d,%d,%d / %q", outcome, inputCalls, stateCalls, acquireCalls, compareCalls, output.String())
|
|
}
|
|
}
|
|
|
|
func TestConfigDiffProviderFailureRetainsDiagnosticsAndCause(t *testing.T) {
|
|
wantErr := errors.New("provider unavailable")
|
|
diagnostic := commandkit.Diagnostic{Severity: commandkit.SeverityWarning, Write: func(writer io.Writer) error {
|
|
_, err := io.WriteString(writer, "provider warning\n")
|
|
return err
|
|
}}
|
|
app := newConfigTestApp(t, Command(Suite[struct{}, struct{}]{Scopes: []Scope[struct{}, struct{}]{{
|
|
Name: "app", Operations: []Operation{Diff},
|
|
Compare: func(context.Context, ComparisonRequest[struct{}], struct{}) (commandkit.Acquired[[]configkit.Difference], error) {
|
|
return commandkit.Acquired[[]configkit.Difference]{
|
|
Diagnostics: []commandkit.Diagnostic{diagnostic},
|
|
Explanation: commandkit.Explanation{Details: []commandkit.Detail{func(writer io.Writer) error {
|
|
_, err := io.WriteString(writer, "native comparison context\n")
|
|
return err
|
|
}}},
|
|
}, fmt.Errorf("comparison setup: %w", wantErr)
|
|
},
|
|
}}}))
|
|
var output, diagnosticOutput bytes.Buffer
|
|
outcome := app.Execute(context.Background(), []string{"config", "diff", "--verbose"}, commandkit.Streams{Out: &output, Err: &diagnosticOutput})
|
|
if outcome.Kind != commandkit.OutcomeOperational || !errors.Is(outcome.Cause, wantErr) || output.Len() != 0 {
|
|
t.Fatalf("provider failure outcome/output = %#v / %q", outcome, output.String())
|
|
}
|
|
if got := diagnosticOutput.String(); !strings.Contains(got, "provider warning") || !strings.Contains(got, "native comparison context") || strings.Index(got, "provider warning") > strings.Index(got, "native comparison context") || strings.Contains(got, wantErr.Error()) {
|
|
t.Fatalf("provider messages and terminal context = %q", got)
|
|
}
|
|
}
|
|
|
|
func TestConfigDiffReportPreparationFailureWritesNoReport(t *testing.T) {
|
|
app := newConfigTestApp(t, Command(Suite[struct{}, struct{}]{Scopes: []Scope[struct{}, struct{}]{{
|
|
Name: "app", Operations: []Operation{Diff},
|
|
Compare: func(context.Context, ComparisonRequest[struct{}], struct{}) (commandkit.Acquired[[]configkit.Difference], error) {
|
|
return commandkit.Acquired[[]configkit.Difference]{Value: []configkit.Difference{{
|
|
Path: configkit.Keys("invalid"), Right: configkit.ValueSnapshot{Present: true, YAML: "bad: ["},
|
|
}}}, nil
|
|
},
|
|
}}}))
|
|
var output bytes.Buffer
|
|
outcome := app.Execute(context.Background(), []string{"config", "diff", "--quiet"}, commandkit.Streams{Out: failingOutput{err: errors.New("quiet destination should not be called")}, Err: io.Discard})
|
|
if outcome.Kind != commandkit.OutcomeOperational || outcome.Cause != nil || outcome.Presentation.Output.State != commandkit.DeliveryIncomplete || outcome.Presentation.Output.RenderError == nil || output.Len() != 0 {
|
|
t.Fatalf("report preparation failure outcome/output = %#v / %q", outcome, output.String())
|
|
}
|
|
}
|
|
|
|
func TestConfigDiffCancellationAfterAcquisitionRetainsDiagnosticsWithoutWriting(t *testing.T) {
|
|
ctx, cancel := context.WithCancel(context.Background())
|
|
diagnostic := commandkit.Diagnostic{Severity: commandkit.SeverityWarning, Write: func(io.Writer) error { return nil }}
|
|
app := newConfigTestApp(t, Command(Suite[struct{}, struct{}]{Scopes: []Scope[struct{}, struct{}]{{
|
|
Name: "app", Operations: []Operation{Diff},
|
|
Compare: func(context.Context, ComparisonRequest[struct{}], struct{}) (commandkit.Acquired[[]configkit.Difference], error) {
|
|
cancel()
|
|
return commandkit.Acquired[[]configkit.Difference]{Diagnostics: []commandkit.Diagnostic{diagnostic}}, nil
|
|
},
|
|
}}}))
|
|
defer cancel()
|
|
var output bytes.Buffer
|
|
outcome := app.Execute(ctx, []string{"config", "diff", "--verbose"}, commandkit.Streams{Out: &output, Err: io.Discard})
|
|
if outcome.Kind != commandkit.OutcomeOperational || !errors.Is(outcome.Cause, context.Canceled) || output.Len() != 0 {
|
|
t.Fatalf("cancelled comparison outcome/output = %#v / %q", outcome, output.String())
|
|
}
|
|
}
|
|
|
|
func TestConfigDiffOutputErrorsCarryIncompleteDeliveryOutcome(t *testing.T) {
|
|
app := newConfigTestApp(t, Command(Suite[struct{}, struct{}]{Scopes: []Scope[struct{}, struct{}]{{
|
|
Name: "app", Operations: []Operation{Diff},
|
|
Compare: func(context.Context, ComparisonRequest[struct{}], struct{}) (commandkit.Acquired[[]configkit.Difference], error) {
|
|
return commandkit.Acquired[[]configkit.Difference]{}, nil
|
|
},
|
|
}}}))
|
|
wantErr := errors.New("output failed")
|
|
for _, test := range []struct {
|
|
name string
|
|
writer io.Writer
|
|
want error
|
|
}{
|
|
{name: "writer error", writer: failingOutput{err: wantErr}, want: wantErr},
|
|
{name: "short write", writer: shortWriter{}, want: io.ErrShortWrite},
|
|
} {
|
|
t.Run(test.name, func(t *testing.T) {
|
|
outcome := app.Execute(context.Background(), []string{"config", "diff"}, commandkit.Streams{Out: test.writer, Err: io.Discard})
|
|
if outcome.Kind != commandkit.OutcomeOperational || outcome.Cause != nil || !errors.Is(outcome.Presentation.Output.WriteError, test.want) || outcome.Presentation.Output.State != commandkit.DeliveryIncomplete {
|
|
t.Fatalf("delivery failure outcome = %#v", outcome)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestConfigDiffDiagnosticDestinationFailureIsPresentationEvidence(t *testing.T) {
|
|
app := newConfigTestApp(t, Command(Suite[struct{}, struct{}]{Scopes: []Scope[struct{}, struct{}]{{
|
|
Name: "app", Operations: []Operation{Diff},
|
|
Compare: func(context.Context, ComparisonRequest[struct{}], struct{}) (commandkit.Acquired[[]configkit.Difference], error) {
|
|
return commandkit.Acquired[[]configkit.Difference]{
|
|
Diagnostics: []commandkit.Diagnostic{{Severity: commandkit.SeverityWarning, Write: func(writer io.Writer) error {
|
|
_, err := io.WriteString(writer, "provider warning\n")
|
|
return err
|
|
}}},
|
|
}, nil
|
|
},
|
|
}}}))
|
|
writeErr := errors.New("diagnostic destination failed")
|
|
var output bytes.Buffer
|
|
outcome := app.Execute(context.Background(), []string{"config", "diff", "--verbose"}, commandkit.Streams{Out: &output, Err: failingOutput{err: writeErr}})
|
|
if outcome.Kind != commandkit.OutcomeOperational || outcome.Cause != nil || !errors.Is(outcome.Presentation.Diagnostics.WriteError, writeErr) || outcome.Presentation.Diagnostics.State != commandkit.DeliveryIncomplete {
|
|
t.Fatalf("diagnostic delivery failure outcome = %#v", outcome)
|
|
}
|
|
if output.Len() == 0 {
|
|
t.Fatal("healthy result destination did not receive the diff report")
|
|
}
|
|
}
|
|
|
|
func TestConfigDiffRepeatedInvocationsPrepareFreshInputsAndState(t *testing.T) {
|
|
type input struct {
|
|
ID int
|
|
Label string
|
|
}
|
|
type state struct{ ID int }
|
|
label := commandkit.ValueFlag(commandkit.FlagMeta{Name: "label"}, (*string)(nil), parseConfigString,
|
|
func(target *input, value commandkit.Supplied[string]) { target.Label = value.Value })
|
|
var inputID, stateID int
|
|
var observed []struct {
|
|
left, right input
|
|
state *state
|
|
}
|
|
app := newConfigTestApp(t, Command(Suite[input, *state]{
|
|
NewInput: func() input { inputID++; return input{ID: inputID} },
|
|
NewState: func() *state { stateID++; return &state{ID: stateID} },
|
|
Selectors: []Selector[input]{{Binding: label, Scopes: []string{"app"}}},
|
|
Scopes: []Scope[input, *state]{{Name: "app", Operations: []Operation{Diff}, Compare: func(_ context.Context, request ComparisonRequest[input], shared *state) (commandkit.Acquired[[]configkit.Difference], error) {
|
|
observed = append(observed, struct {
|
|
left, right input
|
|
state *state
|
|
}{request.Left.Input, request.Right.Input, shared})
|
|
left, err := configkit.Load[struct {
|
|
Label string `yaml:"label"`
|
|
}](configkit.Mapping("left", map[string]any{"label": request.Left.Input.Label}))
|
|
if err != nil {
|
|
return commandkit.Acquired[[]configkit.Difference]{}, err
|
|
}
|
|
right, err := configkit.Load[struct {
|
|
Label string `yaml:"label"`
|
|
}](configkit.Mapping("right", map[string]any{"label": request.Right.Input.Label + "-right"}))
|
|
if err != nil {
|
|
return commandkit.Acquired[[]configkit.Difference]{}, err
|
|
}
|
|
differences, err := configkit.Diff(left, right)
|
|
return commandkit.Acquired[[]configkit.Difference]{Value: differences}, err
|
|
}}},
|
|
}))
|
|
for range 2 {
|
|
outcome := app.Execute(context.Background(), []string{"config", "diff", "--label", "current"}, commandkit.Streams{Out: io.Discard, Err: io.Discard})
|
|
if outcome.Kind != commandkit.OutcomeSuccess {
|
|
t.Fatalf("comparison invocation outcome = %#v", outcome)
|
|
}
|
|
}
|
|
if len(observed) != 2 || observed[0].left.ID == observed[0].right.ID || observed[1].left.ID == observed[1].right.ID || observed[0].left.ID == observed[1].left.ID || observed[0].right.ID == observed[1].right.ID {
|
|
t.Fatalf("input instances were reused: %#v", observed)
|
|
}
|
|
if observed[0].left.Label != "current" || observed[0].right.Label != "current" || observed[1].left.Label != "current" || observed[1].right.Label != "current" {
|
|
t.Fatalf("comparison inputs missed captured flag values: %#v", observed)
|
|
}
|
|
if observed[0].state == nil || observed[1].state == nil || observed[0].state == observed[1].state || observed[0].state.ID != 1 || observed[1].state.ID != 2 {
|
|
t.Fatalf("state was not fresh per invocation: %#v", observed)
|
|
}
|
|
}
|
|
|
|
func TestConfigDiffExecutesConcealedChangesAndEmptyResults(t *testing.T) {
|
|
type settings struct {
|
|
Secret string `yaml:"secret"`
|
|
}
|
|
app := newConfigTestApp(t, AppCommand(func(_ context.Context, selection Selection) (*configkit.Result[settings], error) {
|
|
value := "same"
|
|
if selection.Config.Set && selection.Config.Value == "after" {
|
|
value = "changed-secret"
|
|
}
|
|
return configkit.Load(configkit.Mapping("selected", map[string]any{"secret": value}), configkit.Options[settings]{Definition: configkit.Definition[settings]{Secret: func(path configkit.Path) bool { return path.String() == "/secret" }}})
|
|
}))
|
|
var output bytes.Buffer
|
|
outcome := app.Execute(context.Background(), []string{"config", "diff", "--config", "before", "--against-config", "after"}, commandkit.Streams{Out: &output, Err: io.Discard})
|
|
if outcome.Kind != commandkit.OutcomeSuccess || !strings.Contains(output.String(), "[REDACTED]") || strings.Contains(output.String(), "changed-secret") {
|
|
t.Fatalf("concealed comparison outcome/report = %#v / %q", outcome, output.String())
|
|
}
|
|
output.Reset()
|
|
outcome = app.Execute(context.Background(), []string{"config", "diff", "--config", "before", "--against-config", "before"}, commandkit.Streams{Out: &output, Err: io.Discard})
|
|
if outcome.Kind != commandkit.OutcomeSuccess || !strings.Contains(output.String(), "additions:") || !strings.Contains(output.String(), "changes:") || !strings.Contains(output.String(), "deletions:") {
|
|
t.Fatalf("empty comparison outcome/report = %#v / %q", outcome, output.String())
|
|
}
|
|
}
|