100 lines
4.3 KiB
Go
100 lines
4.3 KiB
Go
package promptkit_test
|
|
|
|
import (
|
|
"errors"
|
|
"strings"
|
|
"sync"
|
|
"testing"
|
|
|
|
"go.maximumdirect.net/configkit"
|
|
"go.maximumdirect.net/promptkit"
|
|
)
|
|
|
|
type rulesApplication struct {
|
|
Version string `yaml:"version"`
|
|
Other []rulesOther `yaml:"other"`
|
|
PromptKit *promptkit.Settings `yaml:"promptkit"`
|
|
}
|
|
|
|
type rulesOther struct {
|
|
ID string `yaml:"id"`
|
|
}
|
|
|
|
func TestConfigureComposesApplicationRules(t *testing.T) {
|
|
var events []string
|
|
definition := configkit.Definition[rulesApplication]{
|
|
Defaults: func() rulesApplication { return rulesApplication{Version: "app"} },
|
|
Version: &configkit.VersionRule{Path: configkit.Keys("version"), Check: func(v configkit.Version, validation *configkit.Validation) error {
|
|
events = append(events, "version")
|
|
return nil
|
|
}},
|
|
SequenceIdentities: []configkit.SequenceIdentity{configkit.SequenceIdentityAt(configkit.Keys("other"), "id")},
|
|
Resolve: func(_ *rulesApplication, _ *configkit.Resolution) error {
|
|
events = append(events, "application resolve")
|
|
return nil
|
|
},
|
|
Validate: func(_ *rulesApplication, _ *configkit.Validation) { events = append(events, "application validate") },
|
|
Sensitive: func(path configkit.Path) bool { return path.String() == "/application_secret" },
|
|
}
|
|
configured := promptkit.Configure(definition, func(v *rulesApplication) *promptkit.Settings { return v.PromptKit })
|
|
if len(definition.SequenceIdentities) != 1 || len(configured.SequenceIdentities) != 7 {
|
|
t.Fatalf("registrations: %d, %d", len(definition.SequenceIdentities), len(configured.SequenceIdentities))
|
|
}
|
|
priorValidate := configured.Validate
|
|
configured.Validate = func(value *rulesApplication, validation *configkit.Validation) {
|
|
priorValidate(value, validation)
|
|
if value.PromptKit == nil || value.PromptKit.Backends[0].Endpoint == nil || strings.TrimSpace(*value.PromptKit.Backends[0].Endpoint) != *value.PromptKit.Backends[0].Endpoint {
|
|
validation.Error(configkit.Keys("promptkit"), "normalization did not run")
|
|
}
|
|
events = append(events, "after validate")
|
|
}
|
|
source := configkit.Bytes("rules", []byte("promptkit:\n backends:\n - id: local\n endpoint: ' https://example.test/v1/ '\n extra_params: {api_key: hidden}\nother: [{id: one}]\n"))
|
|
result, err := configkit.Load(source, configkit.Options[rulesApplication]{Definition: configured})
|
|
if err != nil {
|
|
var loadError *configkit.LoadError
|
|
if errors.As(err, &loadError) {
|
|
t.Fatalf("%v: %+v", err, loadError.Diagnostics())
|
|
}
|
|
t.Fatal(err)
|
|
}
|
|
if result.Config.Version != "app" || strings.Join(events, ",") != "version,application resolve,application validate,after validate" {
|
|
t.Fatalf("callbacks: %+v, %+v", result.Config, events)
|
|
}
|
|
if !configured.Sensitive(configkit.Keys("application_secret")) || !configured.Sensitive(configkit.Keys("promptkit", "backends").Index(0).Key("extra_params").Key("api_key")) || configured.Sensitive(configkit.Keys("backends").Index(0).Key("extra_params").Key("api_key")) {
|
|
t.Fatal("sensitivity composition failed")
|
|
}
|
|
var rendered strings.Builder
|
|
if err := result.WriteEffective(&rendered); err != nil || strings.Contains(rendered.String(), "hidden") {
|
|
t.Fatalf("redaction: %q, %v", rendered.String(), err)
|
|
}
|
|
}
|
|
|
|
func TestConfigurePropagatesResolveError(t *testing.T) {
|
|
want := errors.New("resolve failed")
|
|
definition := promptkit.Configure(configkit.Definition[rulesApplication]{Resolve: func(*rulesApplication, *configkit.Resolution) error { return want }}, func(v *rulesApplication) *promptkit.Settings { return v.PromptKit })
|
|
err := definition.Resolve(&rulesApplication{}, nil)
|
|
if !errors.Is(err, want) {
|
|
t.Fatalf("resolve error = %v", err)
|
|
}
|
|
}
|
|
|
|
func TestConfigureReusableAcrossConcurrentLoads(t *testing.T) {
|
|
definition := promptkit.Configure(configkit.Definition[rulesApplication]{}, func(v *rulesApplication) *promptkit.Settings { return v.PromptKit })
|
|
var group sync.WaitGroup
|
|
for range 8 {
|
|
group.Go(func() {
|
|
for _, source := range []string{"{}", "promptkit: {prompts: [{id: test, output: {format: text, validation_mode: basic}}]}"} {
|
|
result, err := configkit.Load(configkit.Bytes("settings", []byte(source)), configkit.Options[rulesApplication]{Definition: definition})
|
|
if err != nil {
|
|
t.Error(err)
|
|
continue
|
|
}
|
|
if result.Config.PromptKit != nil && *result.Config.PromptKit.Prompts[0].Output.RepairAttempts != 1 {
|
|
t.Error("default was not resolved")
|
|
}
|
|
}
|
|
})
|
|
}
|
|
group.Wait()
|
|
}
|