Files
configkit/internal/engine/directive_scope_test.go

175 lines
7.9 KiB
Go
Raw Normal View History

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)
}
}
}