Add versioned analysis artifact state
This commit is contained in:
309
internal/manifest/analyze_state_test.go
Normal file
309
internal/manifest/analyze_state_test.go
Normal file
@@ -0,0 +1,309 @@
|
||||
package manifest
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"context"
|
||||
"os"
|
||||
"path/filepath"
|
||||
"reflect"
|
||||
"strings"
|
||||
"testing"
|
||||
"time"
|
||||
|
||||
"gitea.maximumdirect.net/eric/narratio/internal/artifactmodel"
|
||||
)
|
||||
|
||||
func TestAnalyzeArtifactStateRoundTripsEveryStatusDeterministically(t *testing.T) {
|
||||
now := time.Date(2026, 5, 3, 10, 0, 0, 0, time.UTC)
|
||||
records := map[string]AnalyzeArtifactRecord{
|
||||
"session_recap": currentAnalyzeArtifactRecord("session_recap", now),
|
||||
"quest_log": {
|
||||
Key: "quest_log", Status: AnalyzeArtifactStale,
|
||||
FingerprintVersion: AnalyzeFingerprintContractVersion,
|
||||
Fingerprint: strings.Repeat("2", 64),
|
||||
Dependencies: []string{"session_recap"}, ProducerRunID: "run-stale", UpdatedAt: now,
|
||||
},
|
||||
"player_handout": {
|
||||
Key: "player_handout", Status: AnalyzeArtifactMissing,
|
||||
Dependencies: []string{"session_recap"}, ProducerRunID: "run-missing", UpdatedAt: now,
|
||||
},
|
||||
"npc_digest": {
|
||||
Key: "npc_digest", Status: AnalyzeArtifactFailed,
|
||||
ProducerRunID: "run-failed", UpdatedAt: now, Error: "scriptorium validation failed",
|
||||
Logs: []string{"runs/run-failed/logs/npc-digest.stderr.log"},
|
||||
},
|
||||
"gm_notes": {
|
||||
Key: "gm_notes", Status: AnalyzeArtifactUnselected,
|
||||
ProducerRunID: "run-unselected", UpdatedAt: now,
|
||||
},
|
||||
}
|
||||
records["session_recap"] = func() AnalyzeArtifactRecord {
|
||||
record := records["session_recap"]
|
||||
record.Dependencies = []string{"quest_log", "gm_notes"}
|
||||
return record
|
||||
}()
|
||||
|
||||
m := New("session", now)
|
||||
m.Stages["analyze"] = &StageRecord{
|
||||
Name: "analyze",
|
||||
Status: StatusSucceeded,
|
||||
CreatedAt: now,
|
||||
UpdatedAt: now,
|
||||
AnalyzeStateVersion: AnalyzeStateContractVersion,
|
||||
AnalyzeArtifacts: records,
|
||||
}
|
||||
path := filepath.Join(t.TempDir(), "manifest.json")
|
||||
store := &LocalStore{}
|
||||
if err := store.Save(context.Background(), path, m); err != nil {
|
||||
t.Fatalf("Save() error = %v", err)
|
||||
}
|
||||
loaded, err := store.Load(context.Background(), path)
|
||||
if err != nil {
|
||||
t.Fatalf("Load() error = %v", err)
|
||||
}
|
||||
analyze := loaded.Stages["analyze"]
|
||||
if !analyze.HasVersionedAnalyzeState() {
|
||||
t.Fatal("round-tripped analyze record lacks versioned state")
|
||||
}
|
||||
for key, want := range records {
|
||||
got, ok := analyze.AnalyzeArtifacts[key]
|
||||
if !ok || got.Status != want.Status {
|
||||
t.Fatalf("artifact %q = %#v, want status %q", key, got, want.Status)
|
||||
}
|
||||
}
|
||||
if got := analyze.AnalyzeArtifacts["session_recap"].Dependencies; !reflect.DeepEqual(got, []string{"gm_notes", "quest_log"}) {
|
||||
t.Fatalf("canonical dependencies = %#v", got)
|
||||
}
|
||||
|
||||
data, err := os.ReadFile(path)
|
||||
if err != nil {
|
||||
t.Fatalf("ReadFile() error = %v", err)
|
||||
}
|
||||
orderedKeys := []string{"gm_notes", "npc_digest", "player_handout", "quest_log", "session_recap"}
|
||||
previous := -1
|
||||
for _, key := range orderedKeys {
|
||||
position := bytes.Index(data, []byte(`"`+key+`": {`))
|
||||
if position <= previous {
|
||||
t.Fatalf("map key %q position = %d after %d; JSON is not canonical:\n%s", key, position, previous, data)
|
||||
}
|
||||
previous = position
|
||||
}
|
||||
}
|
||||
|
||||
func TestRunManifestAnalyzeArtifactStateRoundTrip(t *testing.T) {
|
||||
now := time.Date(2026, 5, 3, 10, 0, 0, 0, time.UTC)
|
||||
run := NewRun("session", "campaign", "run-123", true, []string{"analyze"}, now)
|
||||
run.Stages["analyze"] = &RunStageRecord{
|
||||
Name: "analyze",
|
||||
Action: RunStageActionRun,
|
||||
Status: StatusSucceeded,
|
||||
CreatedAt: now,
|
||||
UpdatedAt: now,
|
||||
AnalyzeStateVersion: AnalyzeStateContractVersion,
|
||||
AnalyzeArtifacts: map[string]AnalyzeArtifactRecord{
|
||||
"session_recap": currentAnalyzeArtifactRecord("session_recap", now),
|
||||
},
|
||||
}
|
||||
path := filepath.Join(t.TempDir(), "run.json")
|
||||
store := &LocalStore{}
|
||||
if err := store.SaveRun(context.Background(), path, run); err != nil {
|
||||
t.Fatalf("SaveRun() error = %v", err)
|
||||
}
|
||||
loaded, err := store.LoadRun(context.Background(), path)
|
||||
if err != nil {
|
||||
t.Fatalf("LoadRun() error = %v", err)
|
||||
}
|
||||
got := loaded.Stages["analyze"]
|
||||
if got.AnalyzeStateVersion != AnalyzeStateContractVersion || got.AnalyzeArtifacts["session_recap"].Status != AnalyzeArtifactCurrent {
|
||||
t.Fatalf("run analyze state = %#v", got)
|
||||
}
|
||||
}
|
||||
|
||||
func TestValidateAnalyzeArtifactCollectionRejectsMalformedState(t *testing.T) {
|
||||
now := time.Date(2026, 5, 3, 10, 0, 0, 0, time.UTC)
|
||||
valid := currentAnalyzeArtifactRecord("session_recap", now)
|
||||
tests := []struct {
|
||||
name string
|
||||
key string
|
||||
mutate func(*AnalyzeArtifactRecord)
|
||||
want string
|
||||
}{
|
||||
{name: "malformed map key", key: "Session Recap", want: "map key must match"},
|
||||
{name: "record key mismatch", key: "session_recap", mutate: func(r *AnalyzeArtifactRecord) { r.Key = "quest_log" }, want: "does not match map key"},
|
||||
{name: "unsupported status", key: "session_recap", mutate: func(r *AnalyzeArtifactRecord) { r.Status = "ready" }, want: "unsupported status"},
|
||||
{name: "unsupported fingerprint version", key: "session_recap", mutate: func(r *AnalyzeArtifactRecord) { r.FingerprintVersion = 99 }, want: "unsupported fingerprint version"},
|
||||
{name: "bad fingerprint", key: "session_recap", mutate: func(r *AnalyzeArtifactRecord) { r.Fingerprint = "not-a-digest" }, want: "fingerprint must be"},
|
||||
{name: "duplicate dependency", key: "session_recap", mutate: func(r *AnalyzeArtifactRecord) { r.Dependencies = []string{"quest_log", "quest_log"} }, want: "duplicate dependency"},
|
||||
{name: "malformed dependency", key: "session_recap", mutate: func(r *AnalyzeArtifactRecord) { r.Dependencies = []string{"Quest Log"} }, want: "dependencies[0]"},
|
||||
{name: "missing current output", key: "session_recap", mutate: func(r *AnalyzeArtifactRecord) { r.Output = nil }, want: "requires output"},
|
||||
{name: "bad current size", key: "session_recap", mutate: func(r *AnalyzeArtifactRecord) { r.OutputSize = 0 }, want: "positive output_size"},
|
||||
{name: "bad current source", key: "session_recap", mutate: func(r *AnalyzeArtifactRecord) { r.Output.SourceID = "narratio.artifact.other" }, want: "source_id"},
|
||||
{name: "unsafe current path", key: "session_recap", mutate: func(r *AnalyzeArtifactRecord) { r.Output.LocalPath = "../recap.md" }, want: "local_path is unsafe"},
|
||||
{name: "missing current contract", key: "session_recap", mutate: func(r *AnalyzeArtifactRecord) { r.Output.Contract = nil }, want: "output contract"},
|
||||
{name: "bad current checksum", key: "session_recap", mutate: func(r *AnalyzeArtifactRecord) { r.Output.Checksum = strings.Repeat("G", 64) }, want: "checksum must be"},
|
||||
{name: "producer mismatch", key: "session_recap", mutate: func(r *AnalyzeArtifactRecord) { r.Output.ProducerRunID = "other-run" }, want: "does not match record"},
|
||||
{name: "non-current output", key: "session_recap", mutate: func(r *AnalyzeArtifactRecord) { r.Status = AnalyzeArtifactStale }, want: "forbids output"},
|
||||
{name: "failed without error", key: "session_recap", mutate: func(r *AnalyzeArtifactRecord) { r.Status = AnalyzeArtifactFailed; r.Output = nil; r.OutputSize = 0 }, want: "requires error"},
|
||||
{name: "current with error", key: "session_recap", mutate: func(r *AnalyzeArtifactRecord) { r.Error = "unexpected" }, want: "forbids error"},
|
||||
{name: "oversized error", key: "session_recap", mutate: func(r *AnalyzeArtifactRecord) {
|
||||
r.Status = AnalyzeArtifactFailed
|
||||
r.Output = nil
|
||||
r.OutputSize = 0
|
||||
r.Error = strings.Repeat("x", maxAnalyzeArtifactErrorLength+1)
|
||||
}, want: "error exceeds"},
|
||||
{name: "bad producer run", key: "session_recap", mutate: func(r *AnalyzeArtifactRecord) { r.ProducerRunID = "bad/run" }, want: "producer_run_id"},
|
||||
{name: "missing update time", key: "session_recap", mutate: func(r *AnalyzeArtifactRecord) { r.UpdatedAt = time.Time{} }, want: "updated_at"},
|
||||
{name: "oversized log collection", key: "session_recap", mutate: func(r *AnalyzeArtifactRecord) { r.Logs = make([]string, maxAnalyzeArtifactListEntries+1) }, want: "logs exceeds"},
|
||||
}
|
||||
for _, test := range tests {
|
||||
t.Run(test.name, func(t *testing.T) {
|
||||
record := valid
|
||||
record.Output = cloneArtifactRecord(valid.Output)
|
||||
if test.mutate != nil {
|
||||
test.mutate(&record)
|
||||
}
|
||||
err := ValidateAnalyzeArtifactCollection(AnalyzeStateContractVersion, map[string]AnalyzeArtifactRecord{test.key: record})
|
||||
if err == nil || !strings.Contains(err.Error(), test.want) {
|
||||
t.Fatalf("error = %v, want %q", err, test.want)
|
||||
}
|
||||
})
|
||||
}
|
||||
if err := ValidateAnalyzeArtifactCollection(99, nil); err == nil || !strings.Contains(err.Error(), "unsupported analyze state version") {
|
||||
t.Fatalf("unsupported version error = %v", err)
|
||||
}
|
||||
}
|
||||
|
||||
func TestAnalyzeStateOwnershipAndLegacyCompatibility(t *testing.T) {
|
||||
now := time.Date(2026, 5, 3, 10, 0, 0, 0, time.UTC)
|
||||
store := &LocalStore{}
|
||||
legacy := `{
|
||||
"session_id": "session",
|
||||
"created_at": "2026-05-03T10:00:00Z",
|
||||
"updated_at": "2026-05-03T10:01:00Z",
|
||||
"stages": {
|
||||
"analyze": {
|
||||
"name": "analyze",
|
||||
"status": "succeeded",
|
||||
"created_at": "2026-05-03T10:00:00Z",
|
||||
"updated_at": "2026-05-03T10:01:00Z",
|
||||
"outputs": [{"kind":"session_recap","local_path":"artifacts/session_recap.md"}]
|
||||
}
|
||||
}
|
||||
}`
|
||||
loaded, err := store.LoadReader(context.Background(), strings.NewReader(legacy))
|
||||
if err != nil {
|
||||
t.Fatalf("LoadReader(legacy) error = %v", err)
|
||||
}
|
||||
if loaded.Stages["analyze"].HasVersionedAnalyzeState() {
|
||||
t.Fatal("legacy aggregate outputs became current per-artifact evidence")
|
||||
}
|
||||
path := filepath.Join(t.TempDir(), "legacy.json")
|
||||
if err := store.Save(context.Background(), path, loaded); err != nil {
|
||||
t.Fatalf("Save(legacy) error = %v", err)
|
||||
}
|
||||
data, err := os.ReadFile(path)
|
||||
if err != nil {
|
||||
t.Fatalf("ReadFile(legacy) error = %v", err)
|
||||
}
|
||||
if bytes.Contains(data, []byte("analyze_state_version")) || bytes.Contains(data, []byte("analyze_artifacts")) || bytes.Contains(data, []byte("fingerprint")) {
|
||||
t.Fatalf("legacy state gained fabricated evidence:\n%s", data)
|
||||
}
|
||||
|
||||
empty := New("session", now)
|
||||
empty.Stages["analyze"] = &StageRecord{
|
||||
Name: "analyze", Status: StatusSucceeded, CreatedAt: now, UpdatedAt: now,
|
||||
AnalyzeStateVersion: AnalyzeStateContractVersion,
|
||||
}
|
||||
emptyPath := filepath.Join(t.TempDir(), "empty.json")
|
||||
if err := store.Save(context.Background(), emptyPath, empty); err != nil {
|
||||
t.Fatalf("Save(versioned empty state) error = %v", err)
|
||||
}
|
||||
emptyLoaded, err := store.Load(context.Background(), emptyPath)
|
||||
if err != nil {
|
||||
t.Fatalf("Load(versioned empty state) error = %v", err)
|
||||
}
|
||||
if !emptyLoaded.Stages["analyze"].HasVersionedAnalyzeState() || len(emptyLoaded.Stages["analyze"].AnalyzeArtifacts) != 0 {
|
||||
t.Fatalf("versioned empty state = %#v", emptyLoaded.Stages["analyze"])
|
||||
}
|
||||
|
||||
m := New("session", now)
|
||||
m.Stages["render"] = &StageRecord{
|
||||
Name: "render", Status: StatusSucceeded, CreatedAt: now, UpdatedAt: now,
|
||||
AnalyzeStateVersion: AnalyzeStateContractVersion,
|
||||
}
|
||||
if err := store.Save(context.Background(), filepath.Join(t.TempDir(), "bad-owner.json"), m); err == nil || !strings.Contains(err.Error(), "cannot contain analyze-owned state") {
|
||||
t.Fatalf("non-analyze ownership error = %v", err)
|
||||
}
|
||||
|
||||
m.Stages = map[string]*StageRecord{"analyze": {
|
||||
Name: "analyze", Status: StatusSucceeded, CreatedAt: now, UpdatedAt: now,
|
||||
AnalyzeArtifacts: map[string]AnalyzeArtifactRecord{},
|
||||
}}
|
||||
if err := store.Save(context.Background(), filepath.Join(t.TempDir(), "missing-version.json"), m); err == nil || !strings.Contains(err.Error(), "without a state version") {
|
||||
t.Fatalf("missing version error = %v", err)
|
||||
}
|
||||
}
|
||||
|
||||
func TestAnalyzeArtifactStateSurvivesAggregateLifecycleClearing(t *testing.T) {
|
||||
now := time.Date(2026, 5, 3, 10, 0, 0, 0, time.UTC)
|
||||
for _, transition := range []struct {
|
||||
name string
|
||||
apply func(*Manifest)
|
||||
}{
|
||||
{name: "running", apply: func(m *Manifest) { m.MarkStageRunning("analyze", now.Add(time.Minute)) }},
|
||||
{name: "failed", apply: func(m *Manifest) { m.MarkStageFailed("analyze", now.Add(time.Minute), "aggregate failed") }},
|
||||
{name: "skipped", apply: func(m *Manifest) { m.MarkStageSkipped("analyze", now.Add(time.Minute), "disabled") }},
|
||||
} {
|
||||
t.Run(transition.name, func(t *testing.T) {
|
||||
m := New("session", now)
|
||||
m.Stages["analyze"] = &StageRecord{
|
||||
Name: "analyze", Status: StatusSucceeded, CreatedAt: now, UpdatedAt: now,
|
||||
Outputs: []ArtifactRecord{{Kind: "legacy", LocalPath: "artifacts/legacy.md"}},
|
||||
Logs: []string{"aggregate.log"}, GeneratedConfigs: []string{"aggregate.yml"}, Metadata: map[string]any{"aggregate": true},
|
||||
AnalyzeStateVersion: AnalyzeStateContractVersion,
|
||||
AnalyzeArtifacts: map[string]AnalyzeArtifactRecord{
|
||||
"session_recap": currentAnalyzeArtifactRecord("session_recap", now),
|
||||
},
|
||||
}
|
||||
transition.apply(m)
|
||||
stage := m.Stages["analyze"]
|
||||
if len(stage.Outputs) != 0 || len(stage.Logs) != 0 || len(stage.GeneratedConfigs) != 0 || len(stage.Metadata) != 0 {
|
||||
t.Fatalf("aggregate details survived %s: %#v", transition.name, stage)
|
||||
}
|
||||
if !stage.HasVersionedAnalyzeState() || stage.AnalyzeArtifacts["session_recap"].Status != AnalyzeArtifactCurrent {
|
||||
t.Fatalf("per-artifact state was cleared by %s: %#v", transition.name, stage)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func currentAnalyzeArtifactRecord(key string, now time.Time) AnalyzeArtifactRecord {
|
||||
runID := "run-" + strings.ReplaceAll(key, "_", "-")
|
||||
return AnalyzeArtifactRecord{
|
||||
Key: key,
|
||||
Status: AnalyzeArtifactCurrent,
|
||||
FingerprintVersion: AnalyzeFingerprintContractVersion,
|
||||
Fingerprint: strings.Repeat("1", 64),
|
||||
Output: &ArtifactRecord{
|
||||
Kind: key,
|
||||
SourceID: "narratio.artifact." + key,
|
||||
LocalPath: "artifacts/" + strings.ReplaceAll(key, "_", "-") + ".md",
|
||||
ProducerRunID: runID,
|
||||
Checksum: strings.Repeat("a", 64),
|
||||
Contract: &artifactmodel.ContractMetadata{
|
||||
MediaType: "text/markdown", SchemaID: "narratio." + key, SchemaVersion: "1",
|
||||
},
|
||||
ExternalProvenance: &artifactmodel.ExternalProvenance{
|
||||
System: "scriptorium", PipelineID: "campaign", ArtifactID: key,
|
||||
},
|
||||
},
|
||||
OutputSize: 42,
|
||||
ProducerRunID: runID,
|
||||
UpdatedAt: now,
|
||||
Scriptorium: &AnalyzeArtifactProvenance{
|
||||
PromptID: key, ProfileID: "default", CommandMode: "artifact",
|
||||
},
|
||||
Logs: []string{"runs/" + runID + "/logs/" + key + ".log"},
|
||||
GeneratedConfigs: []string{"runs/" + runID + "/config/" + key + ".yml"},
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user