370 lines
15 KiB
Go
370 lines
15 KiB
Go
package consumers_test
|
|
|
|
import (
|
|
"bytes"
|
|
"errors"
|
|
"fmt"
|
|
"os"
|
|
"path/filepath"
|
|
"reflect"
|
|
"runtime"
|
|
"strings"
|
|
"testing"
|
|
|
|
configkit "gitea.maximumdirect.net/eric/ConfigKit"
|
|
"gitea.maximumdirect.net/eric/ConfigKit/examples/consumers"
|
|
)
|
|
|
|
func Example_narratio() {
|
|
result, err := consumers.LoadNarratio(fixture("narratio", "pipeline.yml"))
|
|
artifact := result.Config.Artifacts["transcript"]
|
|
fmt.Println(result.Config.ModelProfile, artifact.Output, result.Config.Timeout, artifact.Timeout, err)
|
|
// Output: concise transcript.txt 6s 6s <nil>
|
|
}
|
|
|
|
func Example_notarius() {
|
|
result, err := consumers.LoadNotarius(fixture("notarius", "config.yml"))
|
|
window, ok := consumers.NotariusWindow(result.Config, 0)
|
|
fmt.Println(result.Config.Version, result.Config.Bindings[0].Object, window, ok, err)
|
|
// Output: 4 summary 12 true <nil>
|
|
}
|
|
|
|
func Example_notariusPaths() {
|
|
result, err := consumers.LoadNotariusPaths(fixture("notarius-paths", "main.yml"), "/invocation")
|
|
fmt.Println(filepath.Base(result.Config.Reference), err)
|
|
// Output: imported.txt <nil>
|
|
}
|
|
|
|
func Example_weatherReporter() {
|
|
defaults, defaultsErr := consumers.LoadWeather(configkit.NoSource())
|
|
result, err := consumers.LoadWeather(configkit.File(fixture("weather", "config.yml")))
|
|
discussion := result.Config.Reports["daily"].Modules[1]
|
|
fmt.Println(defaults.Config.Units, result.Config.Units, discussion.Options.Sections[0], defaultsErr, err)
|
|
// Output: metric us short_term <nil> <nil>
|
|
}
|
|
|
|
func Example_seriatim() {
|
|
speakers, speakerErr := consumers.LoadSpeakerRules(fixture("seriatim", "speakers.yml"))
|
|
autocorrect, autocorrectErr := consumers.LoadAutocorrectRules(fixture("seriatim", "autocorrect.yml"))
|
|
name, found := consumers.SpeakerName(speakers.Config, "Guest: teh event occured")
|
|
text := consumers.ApplyAutocorrect(autocorrect.Config, "teh event occured")
|
|
fmt.Println(name, found, text, speakerErr, autocorrectErr)
|
|
// Output: visitor true the event occurred <nil> <nil>
|
|
}
|
|
|
|
func Example_inheritedPresets() {
|
|
result, err := consumers.LoadPresets(configkit.File(fixture("inheritance", "presets.yml")))
|
|
if err != nil {
|
|
fmt.Println(err)
|
|
return
|
|
}
|
|
path := configkit.Keys("presets", "custom", "enabled")
|
|
info, _ := result.Metadata().Lookup(path)
|
|
custom := result.Config.Presets["custom"]
|
|
fmt.Println(custom.Enabled, result.Metadata().IsExplicit(path), custom.Settings["secondary"]["width"])
|
|
fmt.Println(info.Origin.Locations[0].SourceID, info.Origin.Inheritance[0].From)
|
|
// Output:
|
|
// false true 20
|
|
// source-1 /presets/base/enabled
|
|
}
|
|
|
|
func Example_weatherStartup() {
|
|
const blockedName = "CONFIGKIT_WEATHER_EXAMPLE_BLOCKED"
|
|
const tokenName = "CONFIGKIT_WEATHER_EXAMPLE_TOKEN"
|
|
restoreBlocked := preserveEnvironment(blockedName)
|
|
restoreToken := preserveEnvironment(tokenName)
|
|
defer restoreBlocked()
|
|
defer restoreToken()
|
|
_ = os.Setenv(blockedName, "")
|
|
_ = os.Unsetenv(tokenName)
|
|
|
|
directory, _ := os.MkdirTemp("", "configkit-weather-example-")
|
|
defer os.RemoveAll(directory)
|
|
_ = os.WriteFile(filepath.Join(directory, blockedName), []byte("unused-example-value\n"), 0o600)
|
|
_ = os.WriteFile(filepath.Join(directory, tokenName), []byte("disposable-example-credential\n"), 0o600)
|
|
report, bootstrapErr := configkit.LoadSecretsDir(directory)
|
|
var reportOutput bytes.Buffer
|
|
_, reportWriteErr := report.WriteTo(&reportOutput)
|
|
|
|
result, loadErr := consumers.LoadWeather(configkit.Bytes("weather.yml", []byte("units: metric\ntoken: "+tokenName+"\n")),
|
|
configkit.Override{Path: configkit.Keys("units"), Value: "us", Flag: "--units"})
|
|
var explanation bytes.Buffer
|
|
explainErr := result.WriteExplanation(&explanation, configkit.Keys("units"))
|
|
blocked, loaded := secretStatus(report, blockedName), secretStatus(report, tokenName)
|
|
value, present := os.LookupEnv(tokenName)
|
|
fmt.Printf("blocked=%s loaded=%s report=%t reference=%s explained=%t unchanged=%t errors=%t\n",
|
|
blocked, loaded, reportOutput.Len() > 0, result.Config.Token.EnvName(),
|
|
strings.Contains(explanation.String(), "--units"), present && value == "disposable-example-credential",
|
|
bootstrapErr != nil || reportWriteErr != nil || loadErr != nil || explainErr != nil)
|
|
// Output: blocked=skipped_existing loaded=loaded report=true reference=CONFIGKIT_WEATHER_EXAMPLE_TOKEN explained=true unchanged=true errors=false
|
|
}
|
|
|
|
func TestMaintainedConsumerFixturesPreserveDomainOutcomes(t *testing.T) {
|
|
narratio, err := consumers.LoadNarratio(fixture("narratio", "pipeline.yml"))
|
|
if err != nil || narratio.Config.Artifacts["transcript"].Output != "transcript.txt" ||
|
|
narratio.Config.ModelProfile != "concise" || len(narratio.Sources()) != 2 {
|
|
t.Fatalf("Narratio shape = %#v, %v", narratio, err)
|
|
}
|
|
if origin, ok := narratio.Metadata().Lookup(configkit.Keys("artifacts", "transcript", "output")); !ok || origin.Origin.Layer != configkit.LayerResolution {
|
|
t.Fatalf("artifact origin = %#v, %v", origin, ok)
|
|
}
|
|
overlaid, err := consumers.LoadNarratioOverlay(fixture("narratio", "pipeline.yml"), "testing")
|
|
if err != nil || overlaid.Config.PollInterval.String() != "2m0s" ||
|
|
overlaid.Config.ModelProfile != "concise" || len(overlaid.Sources()) != 3 {
|
|
t.Fatalf("configuration overlay and application model profile = %#v, %v", overlaid, err)
|
|
}
|
|
if source := overlaid.Sources()[2]; source.Label != "overlays/testing.yml" || source.Layer != configkit.LayerOverlay {
|
|
t.Fatalf("Narratio overlay source = %#v", source)
|
|
}
|
|
|
|
notarius, err := consumers.LoadNotarius(fixture("notarius", "config.yml"))
|
|
window, converted := consumers.NotariusWindow(notarius.Config, 0)
|
|
if err != nil || !converted || window != 12 {
|
|
t.Fatalf("Notarius shape = %#v, %v, %v", notarius, converted, err)
|
|
}
|
|
if _, ok := notarius.Config.Bindings[0].Options["window_units"].(int64); !ok {
|
|
t.Fatalf("dynamic integer type = %T", notarius.Config.Bindings[0].Options["window_units"])
|
|
}
|
|
integerNotarius, err := consumers.LoadNotarius(fixture("notarius", "integer-version.yml"))
|
|
if err != nil || integerNotarius.Config.Version != notarius.Config.Version || integerNotarius.Config.Version != "4" {
|
|
t.Fatalf("Notarius version forms = %#v / %#v, %v", notarius.Config, integerNotarius, err)
|
|
}
|
|
|
|
weather, err := consumers.LoadWeather(configkit.File(fixture("weather", "config.yml")))
|
|
if err != nil || weather.Config.Reports["daily"].Modules[1].Options.Sections[0] != "short_term" {
|
|
t.Fatalf("WeatherReporter shape = %#v, %v", weather, err)
|
|
}
|
|
|
|
speakers, err := consumers.LoadSpeakerRules(fixture("seriatim", "speakers.yml"))
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
name, ok := consumers.SpeakerName(speakers.Config, "Host: introduction")
|
|
if !ok || name != "narrator" || speakers.Config.Rules[0].Prefix != "Host:" {
|
|
t.Fatalf("ordered speaker rules = %#v, %q, %v", speakers.Config.Rules, name, ok)
|
|
}
|
|
}
|
|
|
|
func TestMigrationFixturesFailWithStableCodesAndPaths(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
load func() error
|
|
code configkit.Code
|
|
path string
|
|
}{
|
|
{
|
|
name: "unsupported application version",
|
|
load: func() error {
|
|
_, err := consumers.LoadNotarius(fixture("notarius", "unsupported-version.yml"))
|
|
return err
|
|
},
|
|
code: configkit.CodeVersionError, path: "/version",
|
|
},
|
|
{
|
|
name: "non-integer numeric version",
|
|
load: func() error {
|
|
_, err := consumers.LoadNotarius(fixture("notarius", "noninteger-version.yml"))
|
|
return err
|
|
},
|
|
code: configkit.CodeVersionType, path: "/version",
|
|
},
|
|
{
|
|
name: "module shorthand",
|
|
load: func() error {
|
|
_, err := consumers.LoadWeather(configkit.File(fixture("weather", "shorthand-module.yml")))
|
|
return err
|
|
},
|
|
code: configkit.CodeDecodeType, path: "/reports/daily/modules/0",
|
|
},
|
|
{
|
|
name: "explicit empty modules",
|
|
load: func() error {
|
|
_, err := consumers.LoadWeather(configkit.File(fixture("weather", "empty-modules.yml")))
|
|
return err
|
|
},
|
|
code: configkit.CodeValidateError, path: "/reports/daily/modules",
|
|
},
|
|
{
|
|
name: "explicit empty path templates",
|
|
load: func() error {
|
|
_, err := consumers.LoadWeather(configkit.File(fixture("weather", "empty-paths.yml")))
|
|
return err
|
|
},
|
|
code: configkit.CodeValidateError, path: "/reports/daily/path_templates",
|
|
},
|
|
{
|
|
name: "explicit null required option",
|
|
load: func() error {
|
|
_, err := consumers.LoadWeather(configkit.File(fixture("weather", "null-window.yml")))
|
|
return err
|
|
},
|
|
code: configkit.CodeValidateError, path: "/reports/daily/modules/0/options/window_units",
|
|
},
|
|
{
|
|
name: "strict unknown rule field",
|
|
load: func() error {
|
|
_, err := consumers.LoadSpeakerRules(fixture("seriatim", "unknown-field.yml"))
|
|
return err
|
|
},
|
|
code: configkit.CodeDecodeUnknownField, path: "/rules/0/color",
|
|
},
|
|
}
|
|
for _, test := range tests {
|
|
t.Run(test.name, func(t *testing.T) {
|
|
var loadError *configkit.LoadError
|
|
if err := test.load(); !errors.As(err, &loadError) {
|
|
t.Fatalf("error = %T %v", err, err)
|
|
}
|
|
diagnostics := loadError.Diagnostics()
|
|
if len(diagnostics) == 0 || diagnostics[0].Code != test.code || diagnostics[0].Path.String() != test.path {
|
|
t.Fatalf("diagnostics = %#v", diagnostics)
|
|
}
|
|
if strings.Contains(diagnostics[0].Message, "wrong-before-overlay") {
|
|
t.Fatalf("diagnostic exposed raw parser input: %#v", diagnostics[0])
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestWeatherLoadedAndConstructedRulesAgreeWithoutMutation(t *testing.T) {
|
|
loaded, err := consumers.LoadWeather(configkit.File(fixture("weather", "config.yml")))
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
reconstructed, err := consumers.LoadConstructedWeather(loaded.Config)
|
|
if err != nil || !reflect.DeepEqual(reconstructed.Config, loaded.Config) {
|
|
t.Fatalf("loaded/constructed outcomes differ: %#v, %v", reconstructed, err)
|
|
}
|
|
constructed := consumers.WeatherConfig{Units: loaded.Config.Units, Reports: map[string]consumers.ReportConfig{}}
|
|
constructed.Reports["daily"] = consumers.ReportConfig{
|
|
Modules: []consumers.ModuleSpec{{Module: "discussion", Options: consumers.ModuleOptions{Sections: []string{" short_term "}}}},
|
|
PathTemplates: []string{"daily/{date}.md"},
|
|
}
|
|
wantInput := constructed.Reports["daily"].Modules[0].Options.Sections[0]
|
|
result, err := consumers.LoadConstructedWeather(constructed)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if got := constructed.Reports["daily"].Modules[0].Options.Sections[0]; got != wantInput {
|
|
t.Fatalf("constructed options mutated from %q to %q", wantInput, got)
|
|
}
|
|
if result.Config.Reports["daily"].Modules[0].Options.Sections[0] != "short_term" {
|
|
t.Fatalf("normalized result = %#v", result.Config.Reports["daily"])
|
|
}
|
|
|
|
empty := consumers.WeatherConfig{Units: "metric", Reports: map[string]consumers.ReportConfig{
|
|
"daily": {Modules: []consumers.ModuleSpec{}},
|
|
}}
|
|
_, err = consumers.LoadConstructedWeather(empty)
|
|
var loadError *configkit.LoadError
|
|
if !errors.As(err, &loadError) || loadError.Diagnostics()[0].Code != configkit.CodeValidateError {
|
|
t.Fatalf("constructed empty modules error = %v", err)
|
|
}
|
|
if !reflect.DeepEqual(empty.Reports["daily"].Modules, []consumers.ModuleSpec{}) {
|
|
t.Fatal("constructed empty module input was mutated")
|
|
}
|
|
}
|
|
|
|
func TestNotariusPathExampleUsesEntryProvenance(t *testing.T) {
|
|
main := fixture("notarius-paths", "main.yml")
|
|
declared := fixture("notarius-paths", "declarations", "path.yml")
|
|
declaredCanonical := canonicalFixture(t, declared)
|
|
wantImported := filepath.Join(filepath.Dir(declaredCanonical), "..", "assets", "imported.txt")
|
|
result, err := consumers.LoadNotariusPaths(main, filepath.Join(t.TempDir(), "invocation"))
|
|
if err != nil || result.Config.Reference != wantImported {
|
|
t.Fatalf("imported reference = %#v, %v", result, err)
|
|
}
|
|
var effective bytes.Buffer
|
|
if err := result.WriteEffective(&effective); err != nil || !strings.Contains(effective.String(), wantImported) ||
|
|
strings.Contains(effective.String(), "PATH_REFERENCE_SECRET_CANARY") {
|
|
t.Fatalf("effective output = %q, %v", effective.String(), err)
|
|
}
|
|
explanation, found := result.Explain(configkit.Keys("reference"))
|
|
if !found || len(explanation.History) == 0 || explanation.History[len(explanation.History)-1].Before.YAML != "../assets/imported.txt\n" ||
|
|
len(explanation.History[len(explanation.History)-1].Reasons) != 1 || explanation.History[len(explanation.History)-1].Reasons[0] != "resolved relative reference from entry source" {
|
|
t.Fatalf("reference explanation = %#v, %v", explanation, found)
|
|
}
|
|
sensitive, found := result.Explain(configkit.Keys("sensitive"))
|
|
var rendered bytes.Buffer
|
|
writeErr := result.WriteExplanation(&rendered, configkit.Keys("sensitive"))
|
|
if !found || !sensitive.Effective.Redacted || writeErr != nil ||
|
|
strings.Contains(fmt.Sprintf("%#v %s", sensitive, rendered.String()), "PATH_REFERENCE_SECRET_CANARY") {
|
|
t.Fatalf("sensitive inspection = %#v, %q, %v", sensitive, rendered.String(), writeErr)
|
|
}
|
|
|
|
defaults := fixture("notarius-paths", "defaults.yml")
|
|
defaultCanonical := canonicalFixture(t, defaults)
|
|
defaultResult, err := consumers.LoadNotariusPaths(defaults, filepath.Join(t.TempDir(), "invocation"))
|
|
wantDefault := filepath.Join(filepath.Dir(defaultCanonical), "defaults", "reference.txt")
|
|
if err != nil || defaultResult.Config.Reference != wantDefault {
|
|
t.Fatalf("default reference = %#v, %v", defaultResult, err)
|
|
}
|
|
|
|
invocation := filepath.Join(t.TempDir(), "caller")
|
|
cliResult, err := consumers.LoadNotariusPaths(main, invocation,
|
|
configkit.Override{Path: configkit.Keys("reference"), Value: "cli/reference.txt", Flag: "--reference"})
|
|
wantCLI := filepath.Join(invocation, "cli", "reference.txt")
|
|
if err != nil || cliResult.Config.Reference != wantCLI {
|
|
t.Fatalf("CLI reference = %#v, %v", cliResult, err)
|
|
}
|
|
missingBase, err := consumers.LoadNotariusPaths(main, "",
|
|
configkit.Override{Path: configkit.Keys("reference"), Value: "cli/reference.txt", Flag: "--reference"})
|
|
if err != nil || missingBase.Config.Reference != "cli/reference.txt" || len(missingBase.Diagnostics()) != 1 ||
|
|
missingBase.Diagnostics()[0].Code != configkit.CodeResolveWarning {
|
|
t.Fatalf("missing CLI base = %#v, %v", missingBase, err)
|
|
}
|
|
absolute := filepath.Join(t.TempDir(), "absolute.txt")
|
|
absoluteResult, err := consumers.LoadNotariusPaths(main, invocation,
|
|
configkit.Override{Path: configkit.Keys("reference"), Value: absolute, Flag: "--reference"})
|
|
if err != nil || absoluteResult.Config.Reference != absolute {
|
|
t.Fatalf("absolute reference = %#v, %v", absoluteResult, err)
|
|
}
|
|
|
|
target := fixture("notarius-paths", "symlink-target.yml")
|
|
link := filepath.Join(t.TempDir(), "linked-config.yml")
|
|
if err := os.Symlink(target, link); err != nil {
|
|
t.Skipf("symlink fixture unavailable: %v", err)
|
|
}
|
|
symlinkResult, err := consumers.LoadNotariusPaths(link, invocation)
|
|
targetCanonical := canonicalFixture(t, target)
|
|
wantSymlink := filepath.Join(filepath.Dir(targetCanonical), "..", "assets", "target.txt")
|
|
if err != nil || symlinkResult.Config.Reference != wantSymlink {
|
|
t.Fatalf("symlink reference = %#v, %v", symlinkResult, err)
|
|
}
|
|
}
|
|
|
|
func fixture(parts ...string) string {
|
|
_, file, _, _ := runtime.Caller(0)
|
|
values := append([]string{filepath.Dir(file), "testdata"}, parts...)
|
|
return filepath.Join(values...)
|
|
}
|
|
|
|
func canonicalFixture(t *testing.T, path string) string {
|
|
t.Helper()
|
|
canonical, err := filepath.EvalSymlinks(path)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
return canonical
|
|
}
|
|
|
|
func preserveEnvironment(name string) func() {
|
|
value, present := os.LookupEnv(name)
|
|
return func() {
|
|
if present {
|
|
_ = os.Setenv(name, value)
|
|
} else {
|
|
_ = os.Unsetenv(name)
|
|
}
|
|
}
|
|
}
|
|
|
|
func secretStatus(report *configkit.SecretsReport, name string) configkit.SecretFileStatus {
|
|
for _, entry := range report.Entries() {
|
|
if entry.Name == name {
|
|
return entry.Status
|
|
}
|
|
}
|
|
return "missing"
|
|
}
|