177 lines
6.2 KiB
Go
177 lines
6.2 KiB
Go
package assets_test
|
|
|
|
import (
|
|
"context"
|
|
"encoding/json"
|
|
"io/fs"
|
|
"reflect"
|
|
"strings"
|
|
"testing"
|
|
|
|
"gitea.maximumdirect.net/eric/notarius/assets"
|
|
"go.maximumdirect.net/promptkit"
|
|
)
|
|
|
|
func TestCombatPromptPairPreservesNativeContractAndFixedGrounding(t *testing.T) {
|
|
_, engine := loadNativeAssets(t)
|
|
initial, err := engine.PrepareExecution(context.Background(), promptkit.RunRequest{
|
|
PromptID: "notarius/dnd.combat_turns", APIKey: "test-only",
|
|
Inputs: map[string]promptkit.ArtifactRef{
|
|
"transcript": promptkit.Inline(`{"units":[{"text":"combat-transcript-marker"}]}`),
|
|
"npc_registry": promptkit.Inline(`{"npcs":[{"name":"combat-npc-marker"}]}`),
|
|
"party": promptkit.Inline("combat-party-marker"),
|
|
"players": promptkit.Inline(" "),
|
|
"glossary": promptkit.Inline(" "),
|
|
},
|
|
})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
defer initial.Discard()
|
|
correction, err := engine.PrepareExecution(context.Background(), promptkit.RunRequest{
|
|
PromptID: "notarius/dnd.combat_turns.repair", APIKey: "test-only",
|
|
Inputs: map[string]promptkit.ArtifactRef{"guidance": promptkit.Inline("Fix the actor citation.")},
|
|
})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
defer correction.Discard()
|
|
first, next := initial.Details(), correction.Details()
|
|
if first.SelectedProfileID != "notarius/dnd-extraction" || first.SelectedProfileID != next.SelectedProfileID || first.StructuredOutput == nil || !reflect.DeepEqual(first.OutputContract, next.OutputContract) {
|
|
t.Fatal("combat native pair lost its schema/default profile")
|
|
}
|
|
var system, all string
|
|
for _, message := range first.Messages {
|
|
all += message.Content
|
|
if message.Role == "system" {
|
|
system += message.Content
|
|
}
|
|
}
|
|
for _, principle := range []string{"Unmatched actors remain permitted.", "Exclude initiative setup without a turn", "Transcript units are the only evidence", "legendary_action", "lair_action"} {
|
|
if !strings.Contains(strings.Join(strings.Fields(system), " "), principle) {
|
|
t.Fatalf("missing enduring rule %q", principle)
|
|
}
|
|
}
|
|
for _, marker := range []string{"combat-transcript-marker", "combat-npc-marker", "combat-party-marker"} {
|
|
if strings.Count(all, marker) != 1 {
|
|
t.Fatalf("fixed input repeated: %q", marker)
|
|
}
|
|
}
|
|
if len(next.Messages) != 1 || next.Messages[0].Role != "user" || !strings.Contains(next.Messages[0].Content, "Fix the actor citation.") || strings.Contains(next.Messages[0].Content, "combat-transcript-marker") {
|
|
t.Fatal("correction did not contain only findings and a replacement assignment")
|
|
}
|
|
}
|
|
|
|
func TestCombatResponseSchemaUsesPrivateShape(t *testing.T) {
|
|
schema, err := fs.ReadFile(assets.FS(), "dnd/combat-turns/schemas/dnd_combat_turns_llm.v1.json")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
valid := validCombatResponse()
|
|
content, err := json.Marshal(valid)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := validateJSONSchema(content, schema); err != nil {
|
|
t.Fatalf("valid combat response rejected: %v", err)
|
|
}
|
|
|
|
withSourceID := validCombatResponse()
|
|
withSourceID["combat_turns"].([]any)[0].(map[string]any)["source_refs"].([]any)[0].(map[string]any)["source_id"] = "session-alpha"
|
|
content, err = json.Marshal(withSourceID)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := validateJSONSchema(content, schema); err == nil {
|
|
t.Fatal("response schema accepted source_id, want private source-reference shape")
|
|
}
|
|
}
|
|
|
|
func TestCombatResponseSchemaLeavesNonCategoricalSemanticsToValidators(t *testing.T) {
|
|
schema, err := fs.ReadFile(assets.FS(), "dnd/combat-turns/schemas/dnd_combat_turns_llm.v1.json")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
semanticCandidate := validCombatResponse()
|
|
turn := semanticCandidate["combat_turns"].([]any)[0].(map[string]any)
|
|
turn["actor"] = ""
|
|
ref := turn["source_refs"].([]any)[0].(map[string]any)
|
|
ref["start_unit_id"] = 0
|
|
ref["end_unit_id"] = -1
|
|
content, err := json.Marshal(semanticCandidate)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := validateJSONSchema(content, schema); err != nil {
|
|
t.Fatalf("private schema rejected non-categorical validator-owned semantics: %v", err)
|
|
}
|
|
turn["source_refs"] = []any{}
|
|
content, err = json.Marshal(semanticCandidate)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := validateJSONSchema(content, schema); err != nil {
|
|
t.Fatalf("private schema rejected empty validator-owned collections: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestCombatResponseSchemaRetainsStructuralBoundary(t *testing.T) {
|
|
schema, err := fs.ReadFile(assets.FS(), "dnd/combat-turns/schemas/dnd_combat_turns_llm.v1.json")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
for _, test := range []struct {
|
|
name string
|
|
mutate func(map[string]any)
|
|
}{
|
|
{name: "missing actor", mutate: func(turn map[string]any) { delete(turn, "actor") }},
|
|
{name: "wrong actor type", mutate: func(turn map[string]any) { turn["actor"] = 1 }},
|
|
{name: "unknown field", mutate: func(turn map[string]any) { turn["unexpected"] = true }},
|
|
{name: "missing source refs", mutate: func(turn map[string]any) { delete(turn, "source_refs") }},
|
|
{name: "unsupported turn kind", mutate: func(turn map[string]any) { turn["turn_kind"] = "unsupported" }},
|
|
} {
|
|
t.Run(test.name, func(t *testing.T) {
|
|
candidate := validCombatResponse()
|
|
test.mutate(candidate["combat_turns"].([]any)[0].(map[string]any))
|
|
content, err := json.Marshal(candidate)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := validateJSONSchema(content, schema); err == nil {
|
|
t.Fatal("private schema accepted structurally invalid response")
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestCombatResponseSchemaAcceptsEverySupportedTurnKind(t *testing.T) {
|
|
schema, err := fs.ReadFile(assets.FS(), "dnd/combat-turns/schemas/dnd_combat_turns_llm.v1.json")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
for _, kind := range []string{"turn", "reaction", "legendary_action", "lair_action", "other"} {
|
|
candidate := validCombatResponse()
|
|
candidate["combat_turns"].([]any)[0].(map[string]any)["turn_kind"] = kind
|
|
content, err := json.Marshal(candidate)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := validateJSONSchema(content, schema); err != nil {
|
|
t.Fatalf("supported turn kind %q was rejected: %v", kind, err)
|
|
}
|
|
}
|
|
}
|
|
|
|
func validCombatResponse() map[string]any {
|
|
return map[string]any{
|
|
"combat_turns": []any{
|
|
map[string]any{
|
|
"actor": "Aria",
|
|
"turn_kind": "reaction",
|
|
"source_refs": []any{map[string]any{"start_unit_id": 1, "end_unit_id": 2}},
|
|
},
|
|
},
|
|
}
|
|
}
|