package engine import ( "reflect" "testing" "go.maximumdirect.net/configkit/internal/document" ) func TestDocumentRootControlScope(t *testing.T) { root := parseRootDirectiveDocument(t, `config: imports: [{path: fragment.yaml}] sequences: [] service: config: {imports: ordinary, sequences: ordinary} records: - config: {imports: ordinary} configkit: {imports: [{path: absent.yaml}]} _configkit: ordinary `) extracted, diagnostics := extractRootDirectives(root, rootDirectiveContextSource, sourceVersionContribution) if len(diagnostics) != 0 || len(extracted.imports) != 1 { t.Fatalf("extraction = %#v, diagnostics = %#v", extracted, diagnostics) } if len(root.Mapping) != 5 || len(extracted.body.Mapping) != 4 { t.Fatalf("source mutated or payload lost: root=%#v body=%#v", root.Mapping, extracted.body.Mapping) } for _, key := range []string{"service", "records", "configkit", "_configkit"} { got := documentEntryIndex(extracted.body.Mapping, key) if got < 0 { t.Errorf("payload missing %q", key) continue } original := documentEntryIndex(root.Mapping, key) if !reflect.DeepEqual(extracted.body.Mapping[got].Value, root.Mapping[original].Value) { t.Errorf("payload for %q changed", key) } } for _, guard := range []func(*document.Node) []Diagnostic{ func(node *document.Node) []Diagnostic { return disabledDirectiveDiagnostics(node, Path{}) }, disabledRootImportDiagnostics, func(node *document.Node) []Diagnostic { return overlayDirectiveDiagnostics(node, Path{}, true) }, } { if got := guard(extracted.body); len(got) != 0 { t.Errorf("nested application data rejected: %#v", got) } } } func TestDocumentRootControlValidation(t *testing.T) { for _, test := range []struct { name string input string code Code path string }{ {"not a mapping", "config: wrong\n", CodeImportInvalid, "/config"}, {"unknown field", "config: {unknown: true}\n", CodeImportInvalid, "/config/unknown"}, {"bad imports", "config: {imports: wrong}\n", CodeImportInvalid, "/config/imports"}, } { t.Run(test.name, func(t *testing.T) { _, diagnostics := extractRootDirectives(parseRootDirectiveDocument(t, test.input), rootDirectiveContextSource, sourceVersionContribution) if len(diagnostics) == 0 || diagnostics[0].Code != test.code || diagnostics[0].Path.String() != test.path { t.Fatalf("diagnostics = %#v", diagnostics) } }) } } func TestDocumentRootControlGuards(t *testing.T) { imports := parseRootDirectiveDocument(t, "config: {imports: [{path: fragment.yaml}]}\n") for _, got := range [][]Diagnostic{disabledDirectiveDiagnostics(imports, Path{}), disabledRootImportDiagnostics(imports)} { if len(got) != 1 || got[0].Code != CodeImportDisabled || got[0].Path.String() != "/config" { t.Fatalf("disabled diagnostics = %#v", got) } } if got := overlayDirectiveDiagnostics(imports, Path{}, true); len(got) != 1 || got[0].Code != CodeOverlayDirective { t.Fatalf("overlay imports diagnostics = %#v", got) } sequences := parseRootDirectiveDocument(t, "config: {sequences: []}\n") if got := disabledRootImportDiagnostics(sequences); len(got) != 0 { t.Fatalf("sequences with imports disabled = %#v", got) } if got := disabledDirectiveDiagnostics(sequences, Path{}); len(got) != 1 || got[0].Code != CodeImportDisabled { t.Fatalf("imports-only guard = %#v", got) } if got := overlayDirectiveDiagnostics(sequences, Path{}, true); len(got) != 0 { t.Fatalf("overlay sequences diagnostics = %#v", got) } if _, got := extractRootDirectives(sequences, rootDirectiveContextImportsOnly, sourceVersionContribution); len(got) == 0 || got[0].Code != CodeSequenceInvalid { t.Fatalf("imports-only extraction diagnostics = %#v", got) } } func TestBootstrapControlExtraction(t *testing.T) { root := parseRootDirectiveDocument(t, "config:\n imports: invalid\n secrets_dir: ../secrets\n secrets_overwrite: false\n") settings, diagnostics := extractBootstrapSettings(root) if len(diagnostics) != 0 || !settings.directoryDeclared || settings.directory != "../secrets" || !settings.overwriteDeclared || settings.overwrite || settings.directoryLocation.Line != 3 || settings.overwriteLocation.Line != 4 { t.Fatalf("settings = %#v, diagnostics = %#v", settings, diagnostics) } if _, diagnostics := extractRootDirectives(root, rootDirectiveContextSource, sourceVersionMain); len(diagnostics) == 0 { t.Fatal("normal extraction did not validate unrelated import grammar") } for _, test := range []struct { input string code Code path string }{ {"config: {secrets_dir: ''}", CodeSecretsInvalidPath, "/config/secrets_dir"}, {"config: {secrets_dir: /absolute}", CodeSecretsInvalidPath, "/config/secrets_dir"}, {"config: {secrets_dir: null}", CodeSecretsInvalidPath, "/config/secrets_dir"}, {"config: {secrets_dir: 123}", CodeSecretsInvalidPath, "/config/secrets_dir"}, {"config: {secrets_overwrite: null}", CodeSecretsInvalidValue, "/config/secrets_overwrite"}, {"config: {secrets_overwrite: 'true'}", CodeSecretsInvalidValue, "/config/secrets_overwrite"}, {"config: invalid", CodeImportInvalid, "/config"}, } { t.Run(test.input, func(t *testing.T) { root := parseRootDirectiveDocument(t, test.input+"\n") _, preparation := extractBootstrapSettings(root) _, normal := extractRootDirectives(root, rootDirectiveContextSource, sourceVersionMain) for _, got := range [][]Diagnostic{preparation, normal} { if len(got) != 1 || got[0].Code != test.code || got[0].Path.String() != test.path || got[0].Primary == nil || got[0].Primary.Line != 1 { t.Fatalf("diagnostics = %#v", got) } } }) } } func TestBootstrapControlsRequireMainSource(t *testing.T) { root := parseRootDirectiveDocument(t, "config: {secrets_dir: secrets, secrets_overwrite: true}\nvalue: ordinary\n") for _, context := range []rootDirectiveContext{rootDirectiveContextSource, rootDirectiveContextLayered} { main, diagnostics := extractRootDirectives(root, context, sourceVersionMain) if len(diagnostics) != 0 || len(main.body.Mapping) != 1 || main.body.Mapping[0].Key != "value" { t.Fatalf("main extraction = %#v, diagnostics = %#v", main, diagnostics) } _, diagnostics = extractRootDirectives(root, context, sourceVersionContribution) if len(diagnostics) != 2 || diagnostics[0].Code != CodeImportInvalid || diagnostics[1].Code != CodeImportInvalid { t.Fatalf("contribution diagnostics = %#v", diagnostics) } } _, diagnostics := extractRootDirectives(root, rootDirectiveContextOverlay, sourceVersionContribution) if len(diagnostics) != 2 || diagnostics[0].Code != CodeOverlayDirective || diagnostics[1].Code != CodeOverlayDirective { t.Fatalf("overlay diagnostics = %#v", diagnostics) } for _, name := range []string{"secrets_dir", "secrets_overwrite"} { if !sourceVersionControlOverlap(root, Keys("config", name)) { t.Errorf("version overlap not detected for %s", name) } } } func TestBootstrapControlsKeepSourceVersionChecksInLoad(t *testing.T) { root := parseRootDirectiveDocument(t, "config: {secrets_dir: secrets, secrets_overwrite: false}\nversion: 1\n") called := false rule := &VersionRule{Path: Keys("version"), Check: func(Version, *Validation) error { called = true return nil }} if _, diagnostics := extractBootstrapSettings(root); len(diagnostics) != 0 || called { t.Fatalf("preparation diagnostics = %#v, checker called = %v", diagnostics, called) } result := processSourceVersionWithDirectiveContext(root, rule, sourceVersionMain, Path{}, sourceVersionModeRequired, rootDirectiveContextSource) if len(result.diagnostics) != 0 || !called { t.Fatalf("load diagnostics = %#v, checker called = %v", result.diagnostics, called) } for _, name := range []string{"secrets_dir", "secrets_overwrite"} { rule.Path = Keys("config", name) result = processSourceVersionWithDirectiveContext(root, rule, sourceVersionMain, Path{}, sourceVersionModeRequired, rootDirectiveContextSource) if len(result.diagnostics) != 1 || result.diagnostics[0].Code != CodeVersionError { t.Errorf("overlap %s diagnostics = %#v", name, result.diagnostics) } } }