package engine import ( "errors" "fmt" "os" "path/filepath" "runtime" "strings" "testing" "testing/fstest" ) func TestSecretsFromConfigPreparesWithoutDirectory(t *testing.T) { root := t.TempDir() for _, body := range []string{"value: retained\n", "config: {secrets_overwrite: true, imports: invalid}\nvalue: retained\n"} { main := writeImportFile(t, root, "main.yml", body) values := map[string]string{"EXISTING": "kept"} report, prepared, err := loadSecretsFromConfig(File(main), nil, mapSecretsEnvironment(values), testSecretsAccess()) if err != nil || report == nil || len(report.Entries()) != 0 || prepared.captured == nil || values["EXISTING"] != "kept" { t.Fatalf("report = %#v, source = %#v, error = %v", report, prepared, err) } } for _, source := range []Source{NoSource(), SearchConfig("app", Paths(filepath.Join(root, "missing.yml")))} { report, prepared, err := loadSecretsFromConfig(source, nil, mapSecretsEnvironment(nil), testSecretsAccess()) if err != nil || report == nil || len(report.Entries()) != 0 || prepared.kind != sourceNone { t.Fatalf("absent: report = %#v, source = %#v, error = %v", report, prepared, err) } } } func TestSecretsFromConfigSelectsOverwritePolicy(t *testing.T) { root := t.TempDir() writeImportFile(t, root, "secrets/EXISTING", "replacement\n") writeImportFile(t, root, "secrets/NEW", "new\n") for _, test := range []struct { name, yaml, want string overwrite *bool }{ {"default preserves", "", "old", nil}, {"yaml enables", " secrets_overwrite: true\n", "replacement", nil}, {"explicit false wins", " secrets_overwrite: true\n", "old", boolPointer(false)}, {"explicit true wins", " secrets_overwrite: false\n", "replacement", boolPointer(true)}, } { t.Run(test.name, func(t *testing.T) { main := writeImportFile(t, root, "main.yml", "config:\n secrets_dir: secrets\n"+test.yaml+"value: fixed\n") values := map[string]string{"EXISTING": "old", "OTHER": "kept"} report, prepared, err := loadSecretsFromConfig(File(main), []SecretsFromConfigOptions{{Overwrite: test.overwrite}}, mapSecretsEnvironment(values), testSecretsAccess()) if err != nil || prepared.captured == nil || report == nil || len(report.Entries()) != 2 || values["EXISTING"] != test.want || values["NEW"] != "new" || values["OTHER"] != "kept" { t.Fatalf("report = %#v, source = %#v, values = %#v, error = %v", report, prepared, values, err) } }) } } func TestSecretsFromConfigAcceptsPreparedMainAgain(t *testing.T) { root := t.TempDir() main := writeImportFile(t, root, "main.yml", "config: {secrets_dir: secrets}\nvalue: captured\n") writeImportFile(t, root, "secrets/SECRET", "value") values := map[string]string{} _, prepared, err := loadSecretsFromConfig(File(main), nil, mapSecretsEnvironment(values), testSecretsAccess()) if err != nil { t.Fatal(err) } if err := os.WriteFile(main, []byte("config: {secrets_dir: missing}\n"), 0o600); err != nil { t.Fatal(err) } delete(values, "SECRET") report, again, err := loadSecretsFromConfig(prepared, nil, mapSecretsEnvironment(values), testSecretsAccess()) if err != nil || again.captured == nil || len(report.Entries()) != 1 || values["SECRET"] != "value" { t.Fatalf("report = %#v, source = %#v, error = %v", report, again, err) } } func TestSecretsFromConfigReportsPreparationFailures(t *testing.T) { root := t.TempDir() malformed := writeImportFile(t, root, "bad.yml", "config: {secrets_overwrite: wrong}\n") badRoot := writeImportFile(t, root, "bad-root.yml", "config: invalid\n") missing := filepath.Join(root, "missing.yml") native := NewFilesystem("native", fstest.MapFS{}) for _, test := range []struct { name string main Source opts []SecretsFromConfigOptions code Code }{ {"malformed even with override", File(malformed), []SecretsFromConfigOptions{{Overwrite: boolPointer(true)}}, CodeSecretsInvalidValue}, {"malformed root", File(badRoot), nil, CodeImportInvalid}, {"missing file", File(missing), nil, CodeSourceMissing}, {"required search", SearchConfig("app", Paths(missing), SearchOptions{Required: true}), nil, CodeSourceMissing}, {"unsupported source", Bytes("main", []byte("{}\n")), nil, CodeOptionsInvalid}, {"invalid search options", SearchConfig("app", Paths(malformed), SearchOptions{}, SearchOptions{}), nil, CodeOptionsInvalid}, {"native context", File(malformed), []SecretsFromConfigOptions{{Filesystem: &FilesystemContext{Root: ".", FS: &native}}}, CodeOptionsInvalid}, {"multiple options", File(malformed), []SecretsFromConfigOptions{{}, {}}, CodeOptionsInvalid}, } { t.Run(test.name, func(t *testing.T) { report, prepared, err := loadSecretsFromConfig(test.main, test.opts, mapSecretsEnvironment(nil), testSecretsAccess()) var failure *LoadError if report == nil || len(report.Entries()) != 0 || prepared.kind != sourceInvalid || !errors.As(err, &failure) || len(failure.Diagnostics()) == 0 || failure.Diagnostics()[0].Code != test.code { t.Fatalf("report = %#v, source = %#v, error = %#v", report, prepared, err) } if test.code == CodeOptionsInvalid && len(failure.Sources()) != 0 { t.Fatalf("option error acquired sources: %#v", failure.Sources()) } }) } } func TestSecretsFromConfigChecksDirectoryContainment(t *testing.T) { parent := t.TempDir() root := filepath.Join(parent, "root") writeImportFile(t, root, "inside/SECRET", "safe") writeImportFile(t, parent, "outside/SECRET", "outside") main := writeImportFile(t, root, "main.yml", "config: {secrets_dir: ../outside}\n") values := map[string]string{} report, prepared, err := loadSecretsFromConfig(File(main), nil, mapSecretsEnvironment(values), testSecretsAccess()) requireSecretsCode(t, err, CodeSecretsInvalidPath) if report == nil || len(report.Entries()) != 0 || prepared.kind != sourceInvalid || len(values) != 0 { t.Fatalf("outside: report = %#v, source = %#v, values = %#v", report, prepared, values) } if err := os.WriteFile(main, []byte("config: {secrets_dir: missing}\n"), 0o600); err != nil { t.Fatal(err) } report, prepared, err = loadSecretsFromConfig(File(main), nil, mapSecretsEnvironment(values), testSecretsAccess()) requireSecretsCode(t, err, CodeSecretsMissing) if report == nil || prepared.kind != sourceInvalid || len(values) != 0 { t.Fatalf("missing: report = %#v, source = %#v, values = %#v", report, prepared, values) } if runtime.GOOS == "windows" { return } if err := os.Symlink(filepath.Join(root, "inside"), filepath.Join(root, "linked")); err != nil { t.Fatal(err) } if err := os.WriteFile(main, []byte("config: {secrets_dir: linked}\n"), 0o600); err != nil { t.Fatal(err) } report, prepared, err = loadSecretsFromConfig(File(main), nil, mapSecretsEnvironment(values), testSecretsAccess()) if err != nil || prepared.captured == nil || len(report.Entries()) != 1 || values["SECRET"] != "safe" { t.Fatalf("contained link: report = %#v, source = %#v, error = %v", report, prepared, err) } if err := os.Remove(filepath.Join(root, "linked")); err != nil { t.Fatal(err) } if err := os.Symlink(filepath.Join(parent, "outside"), filepath.Join(root, "linked")); err != nil { t.Fatal(err) } report, prepared, err = loadSecretsFromConfig(File(main), nil, mapSecretsEnvironment(map[string]string{}), testSecretsAccess()) requireSecretsCode(t, err, CodeSecretsInvalidPath) if report == nil || len(report.Entries()) != 0 || prepared.kind != sourceInvalid { t.Fatalf("outside link: report = %#v, source = %#v", report, prepared) } } func TestSecretsFromConfigKeepsPartialReportSafe(t *testing.T) { root := t.TempDir() main := writeImportFile(t, root, "main.yml", "config: {secrets_dir: secrets}\n") writeImportFile(t, root, "secrets/A", "FIRST-CANARY") writeImportFile(t, root, "secrets/B", "SECOND-CANARY") writeImportFile(t, root, "secrets/C", "THIRD-CANARY") values := map[string]string{} environment := mapSecretsEnvironment(values) environment.set = func(name, value string) error { if name == "B" { return errors.New("unsafe canary failure") } values[name] = value return nil } report, prepared, err := loadSecretsFromConfig(File(main), nil, environment, testSecretsAccess()) requireSecretsCode(t, err, CodeSecretsApplyFailed) entries := report.Entries() if prepared.kind != sourceInvalid || len(entries) != 3 || entries[0].Status != SecretFileLoaded || entries[1].Status != SecretFileFailed || entries[2].Status != SecretFileNotApplied || values["A"] != "FIRST-CANARY" || strings.Contains(err.Error()+fmt.Sprintf("%#v", entries), "CANARY") { t.Fatalf("report = %#v, source = %#v, error = %v", report, prepared, err) } } func TestSecretsFromConfigClosesOpenedFiles(t *testing.T) { for _, test := range []struct { name, contents string fails bool }{ {"success", "value", false}, {"read failure", "bad\x00value", true}, } { t.Run(test.name, func(t *testing.T) { root := t.TempDir() main := writeImportFile(t, root, "main.yml", "config: {secrets_dir: secrets}\n") writeImportFile(t, root, "secrets/SECRET", test.contents) var opened []*os.File open := func(name string) (*os.File, error) { file, err := os.Open(name) if err == nil { opened = append(opened, file) } return file, err } access := testSecretsAccess() access.openDirectory, access.openFile = open, open _, prepared, err := loadSecretsFromConfig(File(main), nil, mapSecretsEnvironment(map[string]string{}), access) if (err != nil) != test.fails || (prepared.kind == sourceInvalid) != test.fails || len(opened) != 2 { t.Fatalf("source = %#v, error = %v, opened = %d", prepared, err, len(opened)) } for _, file := range opened { if _, err := file.Stat(); !errors.Is(err, os.ErrClosed) { t.Fatalf("file %q remains open: %v", file.Name(), err) } } // On systems exposing process descriptors, also check the main file, // whose normal acquisition uses the shared regular-file reader. entries, err := os.ReadDir("/proc/self/fd") if err != nil { return } canonical := canonicalTestPath(t, main) canonicalRoot := canonicalTestPath(t, root) for _, entry := range entries { target, err := os.Readlink(filepath.Join("/proc/self/fd", entry.Name())) if err == nil && (target == canonical || target == canonicalRoot) { t.Fatalf("main or root remains open through descriptor %s", entry.Name()) } } }) } }