144 lines
7.2 KiB
Go
144 lines
7.2 KiB
Go
package integration_test
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"os"
|
|
"path/filepath"
|
|
"strings"
|
|
"testing"
|
|
|
|
"gitea.maximumdirect.net/eric/notarius/internal/core/source"
|
|
"gitea.maximumdirect.net/eric/notarius/internal/framework/pipeline"
|
|
"gitea.maximumdirect.net/eric/notarius/internal/modules/dnd"
|
|
combatcodec "gitea.maximumdirect.net/eric/notarius/internal/modules/dnd/codec/combatturns"
|
|
eventcodec "gitea.maximumdirect.net/eric/notarius/internal/modules/dnd/codec/enemyevents"
|
|
occurrencecodec "gitea.maximumdirect.net/eric/notarius/internal/modules/dnd/codec/npcoccurrences"
|
|
npccodec "gitea.maximumdirect.net/eric/notarius/internal/modules/dnd/codec/npcregistry"
|
|
scenecodec "gitea.maximumdirect.net/eric/notarius/internal/modules/dnd/codec/scenedescriptions"
|
|
enemyextract "gitea.maximumdirect.net/eric/notarius/internal/modules/dnd/extract/enemyevents"
|
|
"gitea.maximumdirect.net/eric/notarius/internal/modules/dnd/npcs/identity"
|
|
"gitea.maximumdirect.net/eric/notarius/internal/modules/generic/chunk/units"
|
|
"gitea.maximumdirect.net/eric/notarius/internal/modules/generic/merge/appendorder"
|
|
"gitea.maximumdirect.net/eric/notarius/internal/modules/generic/normalize/noop"
|
|
jsonoutput "gitea.maximumdirect.net/eric/notarius/internal/modules/generic/output/json"
|
|
"gitea.maximumdirect.net/eric/notarius/internal/modules/seriatim/input/transcript"
|
|
)
|
|
|
|
func enemyPipelineReferenceSources(t *testing.T) map[string]pipeline.ReferenceSource {
|
|
t.Helper()
|
|
ref := func(unit int) source.SourceRef {
|
|
return source.SourceRef{SourceID: "combat-session", StartUnitID: unit, EndUnitID: unit}
|
|
}
|
|
encode := func(content []byte, err error) []byte {
|
|
t.Helper()
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
return content
|
|
}
|
|
contents := map[string][]byte{
|
|
enemyextract.NPCRegistryReferenceSlot: encode(npccodec.New().Encode(dnd.NPCRegistry{NPCs: []dnd.NPC{{
|
|
ID: identity.DeriveID("Ashfang"), Name: "Ashfang", SourceRefs: []source.SourceRef{ref(1)},
|
|
}}})),
|
|
enemyextract.SceneDescriptionReferenceSlot: encode(scenecodec.New().Encode(dnd.SceneDescriptionList{Scenes: []dnd.SceneDescription{{
|
|
ID: "chunk-000001", SourceRef: ref(1), Kind: dnd.SceneKindCombat, Title: "Combat", Summary: "Ashfang opposes the party.",
|
|
}}})),
|
|
enemyextract.CombatTurnReferenceSlot: encode(combatcodec.New().Encode(dnd.CombatTurnList{CombatTurns: []dnd.CombatTurn{
|
|
{Actor: "Ashfang", TurnKind: dnd.CombatTurnKindTurn, SourceRefs: []source.SourceRef{ref(1)}},
|
|
{Actor: "Aria", TurnKind: dnd.CombatTurnKindReaction, SourceRefs: []source.SourceRef{ref(2)}},
|
|
}})),
|
|
enemyextract.NPCOccurrenceReferenceSlot: encode(occurrencecodec.New().Encode(dnd.NPCOccurrenceList{Occurrences: []dnd.NPCOccurrence{
|
|
{NPCID: identity.DeriveID("Ashfang"), Name: "Ashfang", Kind: dnd.NPCOccurrenceKindCombatOpponent, SourceRefs: []source.SourceRef{ref(1)}},
|
|
{NPCID: identity.DeriveID("Aria"), Name: "Aria", Kind: dnd.NPCOccurrenceKindCombatAlly, SourceRefs: []source.SourceRef{ref(2)}},
|
|
}})),
|
|
}
|
|
root := t.TempDir()
|
|
references := make(map[string]pipeline.ReferenceSource, len(contents))
|
|
for slot, content := range contents {
|
|
path := filepath.Join(root, slot+".json")
|
|
if err := os.WriteFile(path, content, 0600); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
references[slot] = pipeline.ExternalReference(path)
|
|
}
|
|
return references
|
|
}
|
|
|
|
func TestNativeEnemyPipelineRetainsIntrinsicCodecBoundaryWithEmptyValidators(t *testing.T) {
|
|
for _, name := range []string{"Ashfang", " "} {
|
|
t.Run(name, func(t *testing.T) {
|
|
client := &nativeSequenceClient{responses: []string{fmt.Sprintf(`{"events":[{"name":%q,"kind":"engaged","source_refs":[{"start_unit_id":1,"end_unit_id":1}]}]}`, name)}}
|
|
engine := nativeTestEngine(t, client, "enemy-profile")
|
|
registries := pipeline.Registries{
|
|
Inputs: pipeline.NewInputAdapterRegistry(), Chunkers: pipeline.NewChunkerRegistry(),
|
|
ArtifactCodecs: pipeline.NewArtifactCodecRegistry(), Extractors: pipeline.NewExtractorRegistry(),
|
|
Mergers: pipeline.NewMergerRegistry(), Normalizers: pipeline.NewNormalizerRegistry(),
|
|
Validators: pipeline.NewValidatorRegistry(), ValidatorChains: pipeline.NewValidatorChainRegistry(),
|
|
Outputs: pipeline.NewOutputEncoderRegistry(),
|
|
}
|
|
check := func(err error) {
|
|
t.Helper()
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
}
|
|
check(transcript.Register(registries.Inputs))
|
|
check(units.Register(registries.Chunkers))
|
|
check(pipeline.RegisterArtifactCodec(registries.ArtifactCodecs, eventcodec.New()))
|
|
check(enemyextract.Register(registries.Extractors))
|
|
check(appendorder.RegisterTyped(registries.Mergers, dnd.EnemyEventListKind, func(values []dnd.EnemyEventList) (dnd.EnemyEventList, error) {
|
|
result := dnd.EnemyEventList{Events: []dnd.EnemyEvent{}}
|
|
for _, value := range values {
|
|
result.Events = append(result.Events, value.Events...)
|
|
}
|
|
return result, nil
|
|
}))
|
|
check(noop.RegisterTyped[dnd.EnemyEventList](registries.Normalizers, dnd.EnemyEventListKind))
|
|
check(jsonoutput.Register(registries.Outputs))
|
|
referenceSources := enemyPipelineReferenceSources(t)
|
|
profile := pipeline.PipelineProfile{
|
|
ID: "native-enemies", Input: pipeline.Binding(transcript.Key), Chunk: pipeline.Binding(units.Key), Output: pipeline.Binding(jsonoutput.Key),
|
|
LLMProfile: "enemy-profile",
|
|
Artifacts: map[string]pipeline.ArtifactLaneProfile{"enemies": {
|
|
Extract: pipeline.ModuleBinding{Module: enemyextract.Key, References: referenceSources, Validators: pipeline.ValidatorOverride{Set: true, Validators: []pipeline.ModuleBinding{}}},
|
|
Merge: pipeline.Binding(appendorder.Key), Normalize: pipeline.Binding(noop.Key),
|
|
}},
|
|
}
|
|
catalog := pipeline.ModuleCatalog{
|
|
Inputs: registries.Inputs, Chunkers: registries.Chunkers, ArtifactCodecs: registries.ArtifactCodecs,
|
|
Extractors: registries.Extractors, Mergers: registries.Mergers, Normalizers: registries.Normalizers,
|
|
Validators: registries.Validators, ValidatorChains: registries.ValidatorChains, Outputs: registries.Outputs,
|
|
}
|
|
resolved, err := pipeline.ResolvePipeline(profile, pipeline.ResolveOptions{}, catalog)
|
|
check(err)
|
|
resolved, _, err = pipeline.MaterializeReferences(resolved, catalog, pipeline.ReferenceMaterializationOptions{})
|
|
check(err)
|
|
prepared, err := pipeline.Prepare(resolved, registries, pipeline.ModuleDependencies{Engine: engine})
|
|
check(err)
|
|
result, err := pipeline.New().Run(context.Background(), pipeline.RunInput{
|
|
Prepared: prepared, SourceID: "combat-session", Workers: 1,
|
|
RawInput: []byte(`{"metadata":{},"segments":[{"id":1,"speaker":"GM","start":0,"end":1,"text":"Ashfang attacks the party."}]}`),
|
|
})
|
|
if len(client.requests) != 1 {
|
|
t.Fatalf("native calls=%d", len(client.requests))
|
|
}
|
|
if strings.TrimSpace(name) == "" {
|
|
if err == nil || !strings.Contains(err.Error(), "encode extract lane") || !strings.Contains(err.Error(), "name must not be empty") {
|
|
t.Fatalf("intrinsic codec error=%v", err)
|
|
}
|
|
return
|
|
}
|
|
check(err)
|
|
if result.FallbackCount != 0 || len(result.OutputFiles) != 1 {
|
|
t.Fatalf("assembled outcome=%#v", result)
|
|
}
|
|
value, err := eventcodec.New().Decode(result.OutputFiles[0].Bytes)
|
|
check(err)
|
|
if len(value.Events) != 1 || value.Events[0].Name != name || value.Events[0].SourceRefs[0].SourceID != "combat-session" {
|
|
t.Fatalf("durable events=%#v", value)
|
|
}
|
|
})
|
|
}
|
|
}
|