389 lines
16 KiB
Go
389 lines
16 KiB
Go
package configuration
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"io/fs"
|
|
"os"
|
|
"path/filepath"
|
|
"strings"
|
|
"testing"
|
|
"testing/fstest"
|
|
|
|
"gitea.maximumdirect.net/eric/ConfigKit"
|
|
"gitea.maximumdirect.net/eric/promptkit/internal/promptdef"
|
|
)
|
|
|
|
func TestLoadCapturesInheritedImportedContent(t *testing.T) {
|
|
files := fstest.MapFS{
|
|
"app/main.yaml": {Data: []byte("configkit:\n imports:\n - path: ../catalog/base.yaml\nprompts:\n child:\n extends: base\n")},
|
|
"catalog/base.yaml": {Data: []byte("prompts:\n base:\n version: \"v1\"\n messages:\n - role: ' USER '\n cache_control:\n type: ' ephemeral '\n ttl: ' 1h '\n content_file: ./body.md\n output:\n format: text\n validation_mode: basic\n")},
|
|
"catalog/body.md": {Data: []byte("Captured {{.name}}")},
|
|
}
|
|
namespace := configkit.NewFilesystem("embedded", files)
|
|
state, err := load(configkit.Input{
|
|
Source: namespace.File("app/main.yaml"), Imports: true,
|
|
Filesystem: &configkit.FilesystemContext{FS: &namespace, Root: "."},
|
|
}, nil)
|
|
if err != nil {
|
|
var loadError *configkit.LoadError
|
|
if errors.As(err, &loadError) {
|
|
t.Fatalf("%v: %+v", err, loadError.Diagnostics())
|
|
}
|
|
t.Fatal(err)
|
|
}
|
|
definition, inspection, err := state.prompt("child")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if definition.Templates[0].Content != "Captured {{.name}}" || inspection.PromptHash == "" {
|
|
t.Fatalf("inherited file content was not captured: %+v, %+v", definition, inspection)
|
|
}
|
|
message := definition.Templates[0]
|
|
if message.Role != "user" || message.CacheControl == nil || message.CacheControl.Type != "ephemeral" || message.CacheControl.TTL != "1h" {
|
|
t.Fatalf("message metadata was not normalized: %+v", message)
|
|
}
|
|
field, ok := state.result.Metadata().Lookup(configkit.Keys("prompts", "child", "messages").Index(0).Key("content_file"))
|
|
if !ok || len(field.Origin.Locations) != 1 {
|
|
t.Fatalf("content origin was lost during normalization: %+v", field)
|
|
}
|
|
var originPath string
|
|
for _, source := range state.result.Sources() {
|
|
if source.ID == field.Origin.Locations[0].SourceID {
|
|
originPath = source.Path
|
|
}
|
|
}
|
|
if originPath != "catalog/base.yaml" {
|
|
t.Fatalf("content origin = %q, want catalog/base.yaml", originPath)
|
|
}
|
|
files["catalog/body.md"].Data = []byte("Changed")
|
|
again, againInspection, err := state.prompt("child")
|
|
if err != nil || again.Templates[0].Content != "Captured {{.name}}" || againInspection.PromptHash != inspection.PromptHash {
|
|
t.Fatalf("captured definition changed after source mutation: %+v, %+v, %v", again, againInspection, err)
|
|
}
|
|
definition.Templates[0].Content = "caller mutation"
|
|
third, _, err := state.prompt("child")
|
|
if err != nil || third.Templates[0].Content != "Captured {{.name}}" {
|
|
t.Fatalf("caller mutation escaped into index: %+v, %v", third, err)
|
|
}
|
|
}
|
|
|
|
func TestLoadUsesExplicitMappingContextAndClosesContent(t *testing.T) {
|
|
filesystem := &countingFS{FS: fstest.MapFS{
|
|
"assets/body.md": {Data: []byte("From mapping")},
|
|
}}
|
|
namespace := configkit.NewFilesystem("mapping-context", filesystem)
|
|
source := configkit.Mapping("application", promptWithFile("body.md"))
|
|
state, err := load(configkit.Input{
|
|
Source: source,
|
|
Filesystem: &configkit.FilesystemContext{FS: &namespace, Root: ".", BaseDir: "assets"},
|
|
}, nil)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
definition, _, err := state.prompt("example")
|
|
if err != nil || definition.Templates[0].Content != "From mapping" || filesystem.contentOpened != 1 || filesystem.contentClosed != 1 {
|
|
t.Fatalf("mapping context or handle ownership failed: %+v, opens=%d closes=%d, %v", definition, filesystem.contentOpened, filesystem.contentClosed, err)
|
|
}
|
|
_, err = load(mapping("contextless", promptWithFile("body.md")), nil)
|
|
if err == nil || !strings.Contains(err.Error(), "/prompts/example/messages/0/content_file") {
|
|
t.Fatalf("expected semantic path for contextless resource, got %v", err)
|
|
}
|
|
}
|
|
|
|
func TestLoadCapturesNativeContentFile(t *testing.T) {
|
|
root := t.TempDir()
|
|
definitionPath := filepath.Join(root, "definition.yaml")
|
|
contentPath := filepath.Join(root, "body.md")
|
|
if err := os.WriteFile(definitionPath, []byte("prompts:\n example:\n version: \"v1\"\n messages:\n - role: user\n content_file: body.md\n output:\n format: text\n validation_mode: basic\n"), 0o600); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := os.WriteFile(contentPath, []byte("Native body"), 0o600); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
state, err := load(configkit.Input{Source: configkit.File(definitionPath), Filesystem: &configkit.FilesystemContext{Root: root}}, nil)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := os.WriteFile(contentPath, []byte("Modified"), 0o600); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
definition, _, err := state.prompt("example")
|
|
if err != nil || definition.Templates[0].Content != "Native body" {
|
|
t.Fatalf("native content was not captured: %+v, %v", definition, err)
|
|
}
|
|
}
|
|
|
|
func TestLoadRejectsMalformedStaticSyntaxAndCapturesOptionalVersion(t *testing.T) {
|
|
_, err := load(mapping("bad-template", map[string]any{"prompts": map[string]any{"example": map[string]any{
|
|
"messages": []any{map[string]any{"role": "user", "content": "{{if}}"}},
|
|
"output": map[string]any{"format": "text", "validation_mode": "basic"},
|
|
}}}), nil)
|
|
if err == nil || !strings.Contains(err.Error(), "invalid template syntax") {
|
|
t.Fatalf("expected construction-time syntax error, got %v", err)
|
|
}
|
|
state, err := load(mapping("version metadata", map[string]any{"prompts": map[string]any{"example": map[string]any{
|
|
"version": "release label",
|
|
"messages": []any{map[string]any{"role": "user", "content": "one"}},
|
|
"output": map[string]any{"format": "text", "validation_mode": "basic"},
|
|
}}}), nil)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
definition, inspection, err := state.prompt("example")
|
|
if err != nil || definition.Version != "release label" || inspection.PromptVersion != "release label" {
|
|
t.Fatalf("optional version metadata was not retained: definition=%+v inspection=%+v err=%v", definition, inspection, err)
|
|
}
|
|
}
|
|
|
|
func TestPromptInspectionLookupMatchesSnapshotSelectionAndOwnsInputs(t *testing.T) {
|
|
makePrompt := func(content string) map[string]any {
|
|
return map[string]any{
|
|
"default_profile": "partial",
|
|
"inputs": []any{map[string]any{
|
|
"name": "document", "required": true,
|
|
"content_type": " text/plain ", "description": " source document ",
|
|
}},
|
|
"messages": []any{map[string]any{"role": "user", "content": content}},
|
|
"output": map[string]any{"format": "text", "validation_mode": "none"},
|
|
}
|
|
}
|
|
selectedPrompt := makePrompt("selected")
|
|
selectedPrompt["version"] = "v2"
|
|
state, err := load(mapping("prompt inspection lookup", map[string]any{
|
|
"profiles": map[string]any{"partial": map[string]any{}},
|
|
"prompts": map[string]any{
|
|
"selected": selectedPrompt,
|
|
},
|
|
}), nil)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
{
|
|
inspection, err := state.GetPromptInspection(context.Background(), "selected")
|
|
if err != nil {
|
|
t.Fatalf("inspect prompt ID: %v", err)
|
|
}
|
|
definition, hash, err := state.GetPromptSnapshot(context.Background(), "selected")
|
|
if err != nil {
|
|
t.Fatalf("snapshot prompt ID: %v", err)
|
|
}
|
|
if inspection.PromptID != definition.ID || inspection.PromptVersion != definition.Version ||
|
|
inspection.PromptHash != hash || inspection.DefaultProfileID != "partial" ||
|
|
len(inspection.Inputs) != 1 || inspection.Inputs[0].Name != "document" ||
|
|
inspection.Inputs[0].ContentType != "text/plain" || inspection.Inputs[0].Description != "source document" {
|
|
t.Fatalf("inspection did not match the selected snapshot: inspection=%+v definition=%+v hash=%q", inspection, definition, hash)
|
|
}
|
|
if len(definition.Inputs) != len(inspection.Inputs) || definition.Inputs[0].Name != inspection.Inputs[0].Name {
|
|
t.Fatalf("definition and inspection inputs diverged: definition=%+v inspection=%+v", definition.Inputs, inspection.Inputs)
|
|
}
|
|
}
|
|
|
|
owned, err := state.GetPromptInspection(context.Background(), "selected")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
owned.Inputs[0].Name = "caller mutation"
|
|
owned.Inputs[0].Description = "caller mutation"
|
|
again, err := state.GetPromptInspection(context.Background(), "selected")
|
|
if err != nil || again.Inputs[0].Name != "document" || again.Inputs[0].Description != "source document" {
|
|
t.Fatalf("inspection mutation escaped into captured state: inspection=%+v err=%v", again, err)
|
|
}
|
|
|
|
for _, id := range []string{"missing", " "} {
|
|
inspection, err := state.GetPromptInspection(context.Background(), id)
|
|
if inspection != nil || !errors.Is(err, promptdef.ErrPromptDefinitionNotFound) {
|
|
t.Errorf("inspection lookup %q=(%+v, %v), want not found", id, inspection, err)
|
|
}
|
|
definition, _, err := state.GetPromptSnapshot(context.Background(), id)
|
|
if definition != nil || !errors.Is(err, promptdef.ErrPromptDefinitionNotFound) {
|
|
t.Errorf("snapshot lookup %q=(%+v, %v), want not found", id, definition, err)
|
|
}
|
|
}
|
|
ctx, cancel := context.WithCancel(context.Background())
|
|
cancel()
|
|
if _, err := state.GetPromptInspection(ctx, "selected"); !errors.Is(err, context.Canceled) {
|
|
t.Errorf("canceled inspection selection error=%v", err)
|
|
}
|
|
}
|
|
|
|
func TestLoadAcceptsEmptyInlineContentAndRejectsInvalidPromptFields(t *testing.T) {
|
|
state, err := load(mapping("empty-content", map[string]any{"prompts": map[string]any{" exact.id ": map[string]any{
|
|
"version": "v1",
|
|
"inputs": []any{map[string]any{"name": " note ", "required": true}},
|
|
"messages": []any{map[string]any{"role": " USER ", "content": "", "content_file": nil,
|
|
"cache_control": map[string]any{"type": " ephemeral ", "ttl": "1h "}}},
|
|
"output": map[string]any{"format": "text", "validation_mode": "basic"},
|
|
}}}), nil)
|
|
if err != nil {
|
|
var loadError *configkit.LoadError
|
|
if errors.As(err, &loadError) {
|
|
t.Fatalf("%v: %+v", err, loadError.Diagnostics())
|
|
}
|
|
t.Fatal(err)
|
|
}
|
|
definition, _, err := state.prompt(" exact.id ")
|
|
if err != nil || definition.ID != " exact.id " || definition.Templates[0].Content != "" || definition.Templates[0].Role != "user" ||
|
|
definition.Inputs[0].Name != "note" || definition.Templates[0].CacheControl.TTL != "1h" {
|
|
t.Fatalf("explicit empty content or literal ID was changed: %+v, %v", definition, err)
|
|
}
|
|
if _, _, err := state.prompt("exact.id"); !errors.Is(err, errPromptNotFound) {
|
|
t.Fatalf("trimmed prompt identity unexpectedly matched: %v", err)
|
|
}
|
|
_, err = load(mapping("obsolete-field", map[string]any{"prompts": map[string]any{"example": map[string]any{
|
|
"version": "v1",
|
|
"id": "example", "messages": []any{map[string]any{"role": "user", "content": "ok"}},
|
|
"output": map[string]any{"format": "text", "validation_mode": "basic"},
|
|
}}}), nil)
|
|
var loadError *configkit.LoadError
|
|
if !errors.As(err, &loadError) {
|
|
t.Fatalf("obsolete identity field should fail strict decoding: %v", err)
|
|
}
|
|
_, err = load(mapping("null-prompt", map[string]any{"prompts": map[string]any{"example": nil}}), nil)
|
|
if err == nil {
|
|
t.Fatal("null prompt collection was accepted")
|
|
}
|
|
}
|
|
|
|
func TestRequirementSnapshotCapturesMetadataPresenceAndNormalizedValues(t *testing.T) {
|
|
state, err := load(mapping("requirement-metadata", map[string]any{
|
|
"prompts": map[string]any{"example": map[string]any{
|
|
"version": "v1",
|
|
"session_id": "{{.session}}",
|
|
"inputs": []any{
|
|
map[string]any{"name": "absent"},
|
|
map[string]any{"name": "null", "content_type": nil, "description": nil},
|
|
map[string]any{"name": "empty", "content_type": "", "description": ""},
|
|
map[string]any{"name": "normalized", "content_type": " text/plain ", "description": " final text "},
|
|
},
|
|
"messages": []any{map[string]any{"role": "user", "content": "{{input \"absent\"}}"}},
|
|
"output": map[string]any{"format": "text", "validation_mode": "basic"},
|
|
}},
|
|
}), nil)
|
|
if err != nil {
|
|
var loadError *configkit.LoadError
|
|
if errors.As(err, &loadError) {
|
|
t.Fatalf("%v: %+v", err, loadError.Diagnostics())
|
|
}
|
|
t.Fatal(err)
|
|
}
|
|
|
|
snapshot, ok := state.GetRequirementSnapshot("example")
|
|
if !ok || len(snapshot.Inputs) != 4 || len(snapshot.Templates.Messages) != 1 || snapshot.Templates.Session == nil {
|
|
t.Fatalf("requirement snapshot was not captured: %+v, %t", snapshot, ok)
|
|
}
|
|
for _, index := range []int{0, 1} {
|
|
if snapshot.Inputs[index].ContentType != nil || snapshot.Inputs[index].Description != nil {
|
|
t.Errorf("input %q should not have explicit string metadata: %+v", snapshot.Inputs[index].Name, snapshot.Inputs[index])
|
|
}
|
|
}
|
|
if snapshot.Inputs[2].ContentType == nil || *snapshot.Inputs[2].ContentType != "" ||
|
|
snapshot.Inputs[2].Description == nil || *snapshot.Inputs[2].Description != "" {
|
|
t.Errorf("explicit empty metadata presence was lost: %+v", snapshot.Inputs[2])
|
|
}
|
|
if snapshot.Inputs[3].ContentType == nil || *snapshot.Inputs[3].ContentType != "text/plain" ||
|
|
snapshot.Inputs[3].Description == nil || *snapshot.Inputs[3].Description != "final text" {
|
|
t.Errorf("snapshot did not use normalized final metadata: %+v", snapshot.Inputs[3])
|
|
}
|
|
|
|
definition, inspection, err := state.prompt("example")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if len(definition.Inputs) != 4 || len(inspection.Inputs) != 4 || inspection.Inputs[2].ContentType != "" || inspection.Inputs[2].Description != "" ||
|
|
inspection.Inputs[3].ContentType != "text/plain" || inspection.Inputs[3].Description != "final text" {
|
|
t.Fatalf("existing prompt inspection shape or normalized values changed: %+v", inspection)
|
|
}
|
|
|
|
*snapshot.Inputs[2].ContentType = "caller mutation"
|
|
snapshot.Inputs[3].Name = "caller mutation"
|
|
snapshot.Templates.Messages[0] = nil
|
|
again, ok := state.GetRequirementSnapshot("example")
|
|
if !ok || *again.Inputs[2].ContentType != "" || again.Inputs[3].Name != "normalized" || again.Templates.Messages[0] == nil {
|
|
t.Fatalf("snapshot mutation escaped into captured state: %+v, %t", again, ok)
|
|
}
|
|
}
|
|
|
|
func TestInputMetadataPresenceDoesNotChangePromptHashOrInspection(t *testing.T) {
|
|
variants := []struct {
|
|
name string
|
|
fields map[string]any
|
|
}{
|
|
{name: "absent"},
|
|
{name: "null", fields: map[string]any{"content_type": nil, "description": nil}},
|
|
{name: "empty", fields: map[string]any{"content_type": "", "description": ""}},
|
|
}
|
|
var expectedHash string
|
|
for _, variant := range variants {
|
|
t.Run(variant.name, func(t *testing.T) {
|
|
input := map[string]any{"name": "document"}
|
|
for name, value := range variant.fields {
|
|
input[name] = value
|
|
}
|
|
state, err := load(mapping("hash-"+variant.name, map[string]any{
|
|
"prompts": map[string]any{"same": map[string]any{
|
|
"version": "v1",
|
|
"inputs": []any{input},
|
|
"messages": []any{map[string]any{"role": "user", "content": "hello"}},
|
|
"output": map[string]any{"format": "text", "validation_mode": "basic"},
|
|
}},
|
|
}), nil)
|
|
if err != nil {
|
|
var loadError *configkit.LoadError
|
|
if errors.As(err, &loadError) {
|
|
t.Fatalf("%v: %+v", err, loadError.Diagnostics())
|
|
}
|
|
t.Fatal(err)
|
|
}
|
|
_, inspection, err := state.prompt("same")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if len(inspection.Inputs) != 1 || inspection.Inputs[0].ContentType != "" || inspection.Inputs[0].Description != "" {
|
|
t.Fatalf("old inspection metadata changed: %+v", inspection.Inputs)
|
|
}
|
|
if expectedHash == "" {
|
|
expectedHash = inspection.PromptHash
|
|
} else if inspection.PromptHash != expectedHash {
|
|
t.Fatalf("metadata presence changed the definition hash: got %q, want %q", inspection.PromptHash, expectedHash)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func promptWithFile(name string) map[string]any {
|
|
return map[string]any{"prompts": map[string]any{"example": map[string]any{
|
|
"messages": []any{map[string]any{"role": "user", "content_file": name}},
|
|
"output": map[string]any{"format": "text", "validation_mode": "basic"},
|
|
}}}
|
|
}
|
|
|
|
type countingFS struct {
|
|
fs.FS
|
|
contentOpened int
|
|
contentClosed int
|
|
}
|
|
|
|
func (filesystem *countingFS) Open(name string) (fs.File, error) {
|
|
file, err := filesystem.FS.Open(name)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if name == "assets/body.md" {
|
|
filesystem.contentOpened++
|
|
return &countingFile{File: file, owner: filesystem}, nil
|
|
}
|
|
return file, nil
|
|
}
|
|
|
|
type countingFile struct {
|
|
fs.File
|
|
owner *countingFS
|
|
}
|
|
|
|
func (file *countingFile) Close() error {
|
|
file.owner.contentClosed++
|
|
return file.File.Close()
|
|
}
|