eric/ConfigKit
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Expand ordered configuration search candidates

Browse Source
This commit is contained in:
Eric Rakestraw
2026-10-24 15:43:10 +00:00
parent e2634c8815
commit 4748313105
5 changed files with 390 additions and 2 deletions
Download Patch File Download Diff File Expand all files Collapse all files

183
internal/engine/discovery_test.go
View File

@@ -1,6 +1,8 @@
package engine
import (
"errors"
"path/filepath"
"runtime"
"testing"
)
@@ -150,3 +152,184 @@ func TestFilenameComponentValidation(t *testing.T) {
}
}
}
func TestSearchCandidatesPreserveDirectoryAndGroupOrder(t *testing.T) {
t.Parallel()
root := t.TempDir()
helpers := discoveryDirectoryHelpers{workingDir: func() (string, error) { return root, nil }}
search := Searches(
Paths("first.yml"),
SearchDirectory("settings", DirectorySearchOptions{Filenames: []FilenameGroup{
GenericFilenames(), CustomFilenames("special.yml"),
}}),
Paths("last.yml"),
)
candidates := collectSearchCandidates(t, search, "app", helpers)
want := []string{
filepath.Join(root, "first.yml"),
filepath.Join(root, "settings", "config.yml"),
filepath.Join(root, "settings", "config.yaml"),
filepath.Join(root, "settings", "main.yml"),
filepath.Join(root, "settings", "main.yaml"),
filepath.Join(root, "settings", "special.yml"),
filepath.Join(root, "last.yml"),
}
assertCandidatePaths(t, candidates, want)
reversed := SearchDirectory("settings", DirectorySearchOptions{Filenames: []FilenameGroup{NamedFilenames(), GenericFilenames()}})
reversedCandidates := collectSearchCandidates(t, reversed, "app", helpers)
assertCandidatePaths(t, reversedCandidates[:2], []string{
filepath.Join(root, "settings", "app.yml"),
filepath.Join(root, "settings", "app.yaml"),
})
}
func TestSearchPresetCandidateLists(t *testing.T) {
t.Parallel()
helpers := discoveryDirectoryHelpers{
userConfigDir: func() (string, error) { return "/controlled/config", nil },
userHomeDir: func() (string, error) { return "/controlled/home", nil },
workingDir: func() (string, error) { return "/controlled/work", nil },
unixSupported: func() bool { return true },
}
unix := collectSearchCandidates(t, UnixSystemDirectories(), "app", helpers)
if len(unix) != 14 {
t.Fatalf("Unix preset candidate count = %d: %#v", len(unix), unix)
}
assertCandidatePaths(t, unix, []string{
"/usr/local/etc/app/app.yml", "/usr/local/etc/app/app.yaml", "/usr/local/etc/app/config.yml", "/usr/local/etc/app/config.yaml", "/usr/local/etc/app/main.yml", "/usr/local/etc/app/main.yaml",
"/etc/app/app.yml", "/etc/app/app.yaml", "/etc/app/config.yml", "/etc/app/config.yaml", "/etc/app/main.yml", "/etc/app/main.yaml",
"/etc/app.yml", "/etc/app.yaml",
})
user := collectSearchCandidates(t, UserConfigDirectory(), "app", helpers)
assertCandidatePaths(t, user, []string{
"/controlled/config/app/app.yml", "/controlled/config/app/app.yaml", "/controlled/config/app/config.yml", "/controlled/config/app/config.yaml", "/controlled/config/app/main.yml", "/controlled/config/app/main.yaml",
"/controlled/config/app.yml", "/controlled/config/app.yaml",
})
home := collectSearchCandidates(t, HomeDirectory(), "app", helpers)
assertCandidatePaths(t, home, []string{
"/controlled/home/.app/app.yml", "/controlled/home/.app/app.yaml", "/controlled/home/.app/config.yml", "/controlled/home/.app/config.yaml", "/controlled/home/.app/main.yml", "/controlled/home/.app/main.yaml",
"/controlled/home/app.yml", "/controlled/home/app.yaml",
})
working := collectSearchCandidates(t, WorkingDirectory(), "app", helpers)
assertCandidatePaths(t, working, []string{"/controlled/work/app.yml", "/controlled/work/app.yaml"})
}
func TestSearchCandidateExpansionIsLazyAndSkipsEmptyDirectories(t *testing.T) {
t.Parallel()
configCalls := 0
helpers := discoveryDirectoryHelpers{
userConfigDir: func() (string, error) {
configCalls++
return "/controlled/config", nil
},
workingDir: func() (string, error) { return "/controlled/work", nil },
unixSupported: func() bool { return true },
}
search := Searches(Paths("/selected.yml"), UserConfigDirectory())
iterator, diagnostics := newSearchCandidateIterator(search, "app", helpers)
if len(diagnostics) != 0 {
t.Fatalf("iterator diagnostics = %#v", diagnostics)
}
if candidate, ok, err := iterator.next(); err != nil || !ok || candidate != "/selected.yml" {
t.Fatalf("first candidate = %q, %v, %v", candidate, ok, err)
}
if configCalls != 0 {
t.Fatalf("later user directory resolved before consumption: %d calls", configCalls)
}
emptyOnly := SearchDirectory("should-not-resolve", DirectorySearchOptions{Filenames: []FilenameGroup{}})
emptyCandidates := collectSearchCandidates(t, emptyOnly, "", helpers)
if len(emptyCandidates) != 0 || configCalls != 0 {
t.Fatalf("empty directory candidates = %#v, helper calls = %d", emptyCandidates, configCalls)
}
continued := collectSearchCandidates(t, Searches(emptyOnly, Paths("later.yml")), "", helpers)
assertCandidatePaths(t, continued, []string{filepath.Join("/controlled/work", "later.yml")})
if configCalls != 0 {
t.Fatalf("empty directory base was resolved: %d calls", configCalls)
}
}
func TestSearchCandidateBaseFailuresAndPlatformApplicability(t *testing.T) {
t.Parallel()
baseFailure := errors.New("controlled base failure")
helpers := discoveryDirectoryHelpers{
userConfigDir: func() (string, error) { return "", baseFailure },
workingDir: func() (string, error) { return "/controlled/work", nil },
unixSupported: func() bool { return false },
}
iterator, diagnostics := newSearchCandidateIterator(UserConfigDirectory(), "app", helpers)
if len(diagnostics) != 0 {
t.Fatalf("user preset validation = %#v", diagnostics)
}
if _, ok, err := iterator.next(); ok || !errors.Is(err, baseFailure) {
t.Fatalf("unavailable user base = ok %v, err %v", ok, err)
}
iterator, diagnostics = newSearchCandidateIterator(UnixSystemDirectories(), "app", helpers)
if len(diagnostics) != 0 {
t.Fatalf("Unix preset validation = %#v", diagnostics)
}
if _, ok, err := iterator.next(); ok || !errors.Is(err, errUnixSystemPresetUnavailable) {
t.Fatalf("unsupported Unix preset = ok %v, err %v", ok, err)
}
iterator, diagnostics = newSearchCandidateIterator(Searches(Paths("/earlier.yml"), UnixSystemDirectories()), "app", helpers)
if len(diagnostics) != 0 {
t.Fatalf("composed Unix preset validation = %#v", diagnostics)
}
if candidate, ok, err := iterator.next(); err != nil || !ok || candidate != "/earlier.yml" {
t.Fatalf("earlier candidate = %q, %v, %v", candidate, ok, err)
}
}
func TestRelativeAndShellLikeSearchPathsRemainLiteral(t *testing.T) {
t.Parallel()
root := t.TempDir()
helpers := discoveryDirectoryHelpers{workingDir: func() (string, error) { return root, nil }}
search := Searches(Paths("~/literal.yml", "$CONFIG/*.yaml"), SearchDirectory("./settings", DirectorySearchOptions{Filenames: []FilenameGroup{CustomFilenames("name with spaces.yml")}}))
candidates := collectSearchCandidates(t, search, "", helpers)
assertCandidatePaths(t, candidates, []string{
filepath.Join(root, "~/literal.yml"),
filepath.Join(root, "$CONFIG/*.yaml"),
filepath.Join(root, "settings", "name with spaces.yml"),
})
}
func collectSearchCandidates(t *testing.T, search Search, application string, helpers discoveryDirectoryHelpers) []string {
t.Helper()
iterator, diagnostics := newSearchCandidateIterator(search, application, helpers)
if len(diagnostics) != 0 {
t.Fatalf("search validation = %#v", diagnostics)
}
var candidates []string
for {
candidate, ok, err := iterator.next()
if err != nil {
t.Fatalf("expand candidate: %v", err)
}
if !ok {
return candidates
}
candidates = append(candidates, candidate)
}
}
func assertCandidatePaths(t *testing.T, got, want []string) {
t.Helper()
if len(got) != len(want) {
t.Fatalf("candidate count = %d, want %d: %#v", len(got), len(want), got)
}
for i := range want {
if got[i] != want[i] {
t.Fatalf("candidate %d = %q, want %q", i, got[i], want[i])
}
}
}