131 lines
6.8 KiB
Go
131 lines
6.8 KiB
Go
package combatturns
|
|
|
|
import (
|
|
"context"
|
|
"os"
|
|
"path/filepath"
|
|
"testing"
|
|
|
|
"gitea.maximumdirect.net/eric/notarius/internal/core/source"
|
|
"gitea.maximumdirect.net/eric/notarius/internal/framework/contracts"
|
|
"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"
|
|
scenecodec "gitea.maximumdirect.net/eric/notarius/internal/modules/dnd/codec/scenedescriptions"
|
|
"gitea.maximumdirect.net/eric/notarius/internal/modules/dnd/validate/combatturns/shape"
|
|
sourcerefs "gitea.maximumdirect.net/eric/notarius/internal/modules/dnd/validate/combatturns/source_refs"
|
|
relatedness "gitea.maximumdirect.net/eric/notarius/internal/modules/dnd/validate/combatturns/source_relatedness"
|
|
"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"
|
|
"gitea.maximumdirect.net/eric/notarius/internal/modules/seriatim/input/transcript"
|
|
"go.maximumdirect.net/promptkit"
|
|
)
|
|
|
|
type combatPipelineOutput struct{}
|
|
|
|
func (combatPipelineOutput) Key() string { return "test/combat-output" }
|
|
func (combatPipelineOutput) Encode(context.Context, contracts.OutputRequest) (contracts.OutputResult, error) {
|
|
return contracts.OutputResult{}, nil
|
|
}
|
|
|
|
func TestNativeCombatPipelineHonorsSceneEligibilityWithoutSyntheticRequests(t *testing.T) {
|
|
for _, test := range []struct {
|
|
name string
|
|
kind dnd.SceneKind
|
|
mismatched bool
|
|
wantCalls int
|
|
}{
|
|
{"combat", dnd.SceneKindCombat, false, 1},
|
|
{"narrative", dnd.SceneKindNarrative, false, 0},
|
|
{"recap", dnd.SceneKindRecap, false, 0},
|
|
{"meta", dnd.SceneKindMeta, false, 0},
|
|
{"mismatched combat", dnd.SceneKindCombat, true, 0},
|
|
} {
|
|
t.Run(test.name, func(t *testing.T) {
|
|
client := &fakeCombatTurnsLLMClient{raw: `{"combat_turns":[{"actor":"Aria","turn_kind":"turn","source_refs":[{"start_unit_id":1,"end_unit_id":1}]}]}`}
|
|
engine := newExtractor(t, client).engine
|
|
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, combatcodec.New()))
|
|
check(Register(registries.Extractors))
|
|
check(appendorder.RegisterTyped(registries.Mergers, dnd.CombatTurnListKind, func(values []dnd.CombatTurnList) (dnd.CombatTurnList, error) {
|
|
result := dnd.CombatTurnList{CombatTurns: []dnd.CombatTurn{}}
|
|
for _, value := range values {
|
|
result.CombatTurns = append(result.CombatTurns, value.CombatTurns...)
|
|
}
|
|
return result, nil
|
|
}))
|
|
check(noop.RegisterTyped[dnd.CombatTurnList](registries.Normalizers, dnd.CombatTurnListKind))
|
|
check(registries.Outputs.RegisterWithSpec(pipeline.ModuleSpec{Key: "test/combat-output", Stage: pipeline.StageOutput, ExecutionClass: contracts.ExecutionClassDeterministic},
|
|
func() (contracts.OutputEncoder, error) { return combatPipelineOutput{}, nil }))
|
|
check(shape.Register(registries.Validators))
|
|
check(sourcerefs.Register(registries.Validators))
|
|
check(relatedness.Register(registries.Validators))
|
|
scene := dnd.SceneDescription{
|
|
ID: "chunk-000001", SourceRef: source.SourceRef{SourceID: "combat-session", StartUnitID: 1, EndUnitID: 1},
|
|
Kind: test.kind, Title: "Eligibility only", Summary: "This prose must not become combat evidence.",
|
|
}
|
|
if test.mismatched {
|
|
scene.SourceRef.EndUnitID = 2
|
|
}
|
|
content, err := scenecodec.New().Encode(dnd.SceneDescriptionList{Scenes: []dnd.SceneDescription{scene}})
|
|
check(err)
|
|
path := filepath.Join(t.TempDir(), "scenes.json")
|
|
check(os.WriteFile(path, content, 0600))
|
|
profile := pipeline.PipelineProfile{
|
|
ID: "native-combat", Input: pipeline.Binding(transcript.Key), Chunk: pipeline.Binding(units.Key), Output: pipeline.Binding("test/combat-output"),
|
|
LLMProfile: "profile-combat",
|
|
Artifacts: map[string]pipeline.ArtifactLaneProfile{"combat": {
|
|
Extract: pipeline.ModuleBinding{Module: Key, Validators: pipeline.ValidatorOverride{Set: true, Validators: []pipeline.ModuleBinding{
|
|
pipeline.Binding(shape.Key), pipeline.Binding(sourcerefs.Key), pipeline.Binding(relatedness.Key),
|
|
}}, References: map[string]pipeline.ReferenceSource{SceneDescriptionReferenceSlot: pipeline.ExternalReference(path)}},
|
|
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)
|
|
preparations := 0
|
|
result, err := pipeline.New().Run(context.Background(), pipeline.RunInput{
|
|
Prepared: prepared, SourceID: "combat-session", ExtractWorkers: 1,
|
|
RawInput: []byte(`{"segments":[{"id":1,"speaker":"Alice","start":0,"end":1,"text":"Aria strikes the ogre."}]}`),
|
|
Execution: contracts.ExecutionOptions{OnPrepared: func(context.Context, promptkit.PreparedRun) { preparations++ }},
|
|
})
|
|
check(err)
|
|
if len(client.requests) != test.wantCalls || preparations != test.wantCalls || result.FallbackCount != 0 || len(result.NormalizeOutputs) != 1 {
|
|
t.Fatalf("pipeline=%#v native=%d/%d, want %d", result, len(client.requests), preparations, test.wantCalls)
|
|
}
|
|
value, err := combatcodec.New().Decode(result.NormalizeOutputs[0].Artifact.Content)
|
|
check(err)
|
|
if value.CombatTurns == nil || len(value.CombatTurns) != test.wantCalls {
|
|
t.Fatalf("combat artifact=%#v", value)
|
|
}
|
|
if test.wantCalls > 0 && (value.CombatTurns[0].Actor != "Aria" || value.CombatTurns[0].SourceRefs[0].SourceID != "combat-session") {
|
|
t.Fatalf("combat evidence=%#v", value)
|
|
}
|
|
})
|
|
}
|
|
}
|