package ckconfig import ( "context" "errors" "fmt" "testing" "go.maximumdirect.net/commandkit" "go.maximumdirect.net/configkit" ) func TestConfigurationDiagnosticClassification(t *testing.T) { usageCodes := []configkit.Code{ configkit.CodeYAMLInvalid, configkit.CodeYAMLEmpty, configkit.CodeYAMLMultipleDocuments, configkit.CodeYAMLRootType, configkit.CodeYAMLDuplicateKey, configkit.CodeYAMLTag, configkit.CodeYAMLAnchor, configkit.CodeYAMLAlias, configkit.CodeYAMLMergeKey, configkit.CodeYAMLScalar, configkit.CodeYAMLDepthLimit, configkit.CodeYAMLNodeLimit, configkit.CodeDecodeType, configkit.CodeDecodeNull, configkit.CodeDecodeRange, configkit.CodeDecodeDuration, configkit.CodeDecodeText, configkit.CodeDecodeUnknownField, configkit.CodeDecodeArrayLength, configkit.CodeSourceLimitExceeded, configkit.CodeImportDisabled, configkit.CodeImportCycle, configkit.CodeImportRepeated, configkit.CodeImportVersion, configkit.CodeSequenceInvalid, configkit.CodeSequenceConflict, configkit.CodeComposeInvalid, configkit.CodeComposeConflict, configkit.CodeUnderlayVersion, configkit.CodeOverlayVersion, configkit.CodeOverlayRepeated, configkit.CodeOverlayDirective, configkit.CodeVersionType, configkit.CodeVersionError, configkit.CodeResolveError, configkit.CodeValidateError, configkit.CodeInheritanceInvalid, configkit.CodeInheritanceMissing, configkit.CodeInheritanceCycle, configkit.CodeInheritanceVersion, configkit.CodeOverrideInvalidPath, configkit.CodeOverrideDuplicate, configkit.CodeOverrideOverlap, configkit.CodeOverrideDirective, configkit.CodeOverrideVersion, configkit.CodeOverrideLimitExceeded, configkit.CodeSecretRequired, configkit.CodeSecretInvalidName, } for _, code := range usageCodes { t.Run(string(code), func(t *testing.T) { ds := []configkit.Diagnostic{{Severity: configkit.SeverityWarning, Code: configkit.CodeSourceRead}, {Severity: configkit.SeverityError, Code: code}} if got := classifyConfigurationDiagnostics(ds); got != commandkit.OutcomeUsage { t.Fatalf("got %s", got) } }) } for _, code := range []configkit.Code{configkit.CodeSourceMissing, configkit.CodeSourcePermission, configkit.CodeImportInvalid, configkit.CodeImportOutsideRoot, configkit.CodeImportLimitExceeded, configkit.CodeOverlayInvalid, configkit.CodeOverlayOutsideRoot, configkit.CodeOverlayLimitExceeded, configkit.CodeSchemaRoot, configkit.CodeOptionsInvalid, configkit.CodeHistoryLimitExceeded, configkit.CodeResolveHookFailed, configkit.CodeValidateMutation, configkit.CodeOverrideInvalidLabel, configkit.CodeOverrideInvalidValue, configkit.CodeSecretUnset, configkit.CodeSecretEmpty, configkit.CodeSecretsMissing, "future.code"} { t.Run(string(code), func(t *testing.T) { ds := []configkit.Diagnostic{{Severity: configkit.SeverityError, Code: configkit.CodeYAMLInvalid}, {Severity: configkit.SeverityError, Code: code}} if got := classifyConfigurationDiagnostics(ds); got != commandkit.OutcomeOperational { t.Fatalf("got %s", got) } }) } for _, ds := range [][]configkit.Diagnostic{nil, {{Severity: configkit.SeverityWarning, Code: configkit.CodeYAMLInvalid}}, {{Severity: "future", Code: configkit.CodeYAMLInvalid}}, {{Severity: configkit.SeverityError, Code: configkit.CodeYAMLInvalid}, {Severity: "future"}}} { if got := classifyConfigurationDiagnostics(ds); got != commandkit.OutcomeOperational { t.Fatalf("%v: got %s", ds, got) } } } type emptyChildren struct{} func (emptyChildren) Error() string { return "empty" } func (emptyChildren) Unwrap() []error { return nil } func TestClassifyConfigurationError(t *testing.T) { _, invalid := configkit.Load[map[string]any](configkit.Bytes("invalid", []byte("broken: ["))) _, missing := configkit.Load[map[string]any](configkit.File("/nonexistent-commandkit-classifier-test")) var load *configkit.LoadError if !errors.As(invalid, &load) || load == nil { t.Fatalf("invalid fixture: %v", invalid) } if missing == nil { t.Fatal("missing fixture unexpectedly succeeded") } var typedNil *configkit.LoadError opaque := errors.New("opaque") cases := []struct { name string err error want commandkit.OutcomeKind }{ {"nil", nil, commandkit.OutcomeSuccess}, {"invalid", invalid, commandkit.OutcomeUsage}, {"wrapped", fmt.Errorf("wrapped: %w", invalid), commandkit.OutcomeUsage}, {"all input", errors.Join(invalid, fmt.Errorf("wrapped: %w", invalid)), commandkit.OutcomeUsage}, {"mixed first", errors.Join(missing, invalid), commandkit.OutcomeOperational}, {"mixed last", errors.Join(invalid, missing), commandkit.OutcomeOperational}, {"nested", errors.Join(invalid, errors.Join(invalid, opaque)), commandkit.OutcomeOperational}, {"canceled", errors.Join(invalid, context.Canceled), commandkit.OutcomeOperational}, {"deadline", fmt.Errorf("deadline: %w", context.DeadlineExceeded), commandkit.OutcomeOperational}, {"missing", missing, commandkit.OutcomeOperational}, {"opaque", opaque, commandkit.OutcomeOperational}, {"empty load", &configkit.LoadError{}, commandkit.OutcomeOperational}, {"typed nil", typedNil, commandkit.OutcomeOperational}, {"empty children", emptyChildren{}, commandkit.OutcomeOperational}, } for _, tc := range cases { t.Run(tc.name, func(t *testing.T) { if got := ClassifyConfigurationError(tc.err); got != tc.want { t.Fatalf("got %s, want %s", got, tc.want) } if errors.Is(tc.err, invalid) { var got *configkit.LoadError if !errors.As(tc.err, &got) || got == nil { t.Fatal("load identity lost") } } }) } }