295 lines
9.0 KiB
Go
295 lines
9.0 KiB
Go
package manifest
|
|
|
|
import (
|
|
"context"
|
|
"encoding/json"
|
|
"os"
|
|
"path/filepath"
|
|
"strings"
|
|
"testing"
|
|
"time"
|
|
|
|
"gitea.maximumdirect.net/eric/narratio/internal/artifactmodel"
|
|
)
|
|
|
|
func TestLocalStoreCreateSaveLoadRoundTrip(t *testing.T) {
|
|
store := &LocalStore{}
|
|
ctx := context.Background()
|
|
|
|
m, err := store.Create(ctx, "2026-05-03")
|
|
if err != nil {
|
|
t.Fatalf("Create() error = %v", err)
|
|
}
|
|
|
|
now := time.Date(2026, 5, 3, 12, 0, 0, 0, time.UTC)
|
|
m.MarkStageRunning("prepare", now)
|
|
m.MarkStageSucceeded("prepare", now.Add(2*time.Second), []ArtifactRecord{{Kind: "transcript", LocalPath: "transcripts/base.json"}})
|
|
m.Campaign = "forsaken"
|
|
m.RunID = "20260515T031522Z-a1b2c3d4"
|
|
m.LocalWorkDir = "/var/lib/narratio/work/forsaken/2026-05-03/20260515T031522Z-a1b2c3d4"
|
|
m.LocalSpoolDir = "/var/spool/narratio/forsaken/2026-05-03/20260515T031522Z-a1b2c3d4/audio"
|
|
m.S3Bucket = "my-dnd-archive"
|
|
m.S3SessionPrefix = "dnd/campaigns/forsaken/sessions/2026-05-03/"
|
|
m.S3RunPrefix = "dnd/campaigns/forsaken/sessions/2026-05-03/runs/20260515T031522Z-a1b2c3d4/"
|
|
|
|
path := filepath.Join(t.TempDir(), "manifest.json")
|
|
if err := store.Save(ctx, path, m); err != nil {
|
|
t.Fatalf("Save() error = %v", err)
|
|
}
|
|
|
|
loaded, err := store.Load(ctx, path)
|
|
if err != nil {
|
|
t.Fatalf("Load() error = %v", err)
|
|
}
|
|
|
|
if loaded.SessionID != "2026-05-03" {
|
|
t.Fatalf("SessionID = %q, want %q", loaded.SessionID, "2026-05-03")
|
|
}
|
|
if loaded.Campaign != "forsaken" {
|
|
t.Fatalf("Campaign = %q, want %q", loaded.Campaign, "forsaken")
|
|
}
|
|
if loaded.RunID != "20260515T031522Z-a1b2c3d4" {
|
|
t.Fatalf("RunID = %q, want run id", loaded.RunID)
|
|
}
|
|
stage, ok := loaded.Stages["prepare"]
|
|
if !ok {
|
|
t.Fatalf("stage prepare not found")
|
|
}
|
|
if stage.Status != StatusSucceeded {
|
|
t.Fatalf("status = %q, want %q", stage.Status, StatusSucceeded)
|
|
}
|
|
if len(stage.Outputs) != 1 {
|
|
t.Fatalf("outputs len = %d, want 1", len(stage.Outputs))
|
|
}
|
|
if loaded.UpdatedAt.IsZero() {
|
|
t.Fatal("UpdatedAt is zero")
|
|
}
|
|
}
|
|
|
|
func TestLocalStoreArtifactMetadataCompatibility(t *testing.T) {
|
|
store := &LocalStore{}
|
|
ctx := context.Background()
|
|
dir := t.TempDir()
|
|
oldPath := filepath.Join(dir, "old-manifest.json")
|
|
oldJSON := `{
|
|
"session_id": "2026-05-03",
|
|
"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":"scriptorium_artifact","local_path":"artifacts/recap.md"}]
|
|
}
|
|
}
|
|
}`
|
|
if err := os.WriteFile(oldPath, []byte(oldJSON), 0o644); err != nil {
|
|
t.Fatalf("WriteFile() old manifest error = %v", err)
|
|
}
|
|
|
|
loaded, err := store.Load(ctx, oldPath)
|
|
if err != nil {
|
|
t.Fatalf("Load() old manifest error = %v", err)
|
|
}
|
|
oldOutput := loaded.Stages["analyze"].Outputs[0]
|
|
if oldOutput.Contract != nil || oldOutput.ExternalProvenance != nil {
|
|
t.Fatalf("old output metadata = %#v, %#v; want nil", oldOutput.Contract, oldOutput.ExternalProvenance)
|
|
}
|
|
if err := store.Save(ctx, oldPath, loaded); err != nil {
|
|
t.Fatalf("Save() old manifest error = %v", err)
|
|
}
|
|
roundTripped, err := os.ReadFile(oldPath)
|
|
if err != nil {
|
|
t.Fatalf("ReadFile() round-tripped old manifest error = %v", err)
|
|
}
|
|
if strings.Contains(string(roundTripped), `"contract"`) || strings.Contains(string(roundTripped), `"external_provenance"`) {
|
|
t.Fatalf("old manifest gained fabricated metadata:\n%s", roundTripped)
|
|
}
|
|
|
|
loaded.Stages["analyze"].Outputs[0].Contract = &artifactmodel.ContractMetadata{
|
|
MediaType: "application/json",
|
|
SchemaID: "example.recap",
|
|
SchemaVersion: "v1",
|
|
}
|
|
loaded.Stages["analyze"].Outputs[0].ExternalProvenance = &artifactmodel.ExternalProvenance{
|
|
System: "example",
|
|
RunID: "external-run",
|
|
PipelineID: "pipeline",
|
|
ArtifactID: "recap",
|
|
}
|
|
metadataPath := filepath.Join(dir, "metadata-manifest.json")
|
|
if err := store.Save(ctx, metadataPath, loaded); err != nil {
|
|
t.Fatalf("Save() metadata manifest error = %v", err)
|
|
}
|
|
withMetadata, err := store.Load(ctx, metadataPath)
|
|
if err != nil {
|
|
t.Fatalf("Load() metadata manifest error = %v", err)
|
|
}
|
|
got := withMetadata.Stages["analyze"].Outputs[0]
|
|
if got.Contract == nil || got.Contract.SchemaID != "example.recap" {
|
|
t.Fatalf("contract = %#v, want persisted contract", got.Contract)
|
|
}
|
|
if got.ExternalProvenance == nil || got.ExternalProvenance.RunID != "external-run" {
|
|
t.Fatalf("external provenance = %#v, want persisted provenance", got.ExternalProvenance)
|
|
}
|
|
}
|
|
|
|
func TestLocalStoreSaveUpdatesTimestamp(t *testing.T) {
|
|
store := &LocalStore{}
|
|
ctx := context.Background()
|
|
|
|
createdAt := time.Date(2026, 5, 3, 10, 0, 0, 0, time.UTC)
|
|
m := New("2026-05-03", createdAt)
|
|
m.UpdatedAt = createdAt
|
|
|
|
path := filepath.Join(t.TempDir(), "manifest.json")
|
|
if err := store.Save(ctx, path, m); err != nil {
|
|
t.Fatalf("first Save() error = %v", err)
|
|
}
|
|
firstUpdated := m.UpdatedAt
|
|
|
|
time.Sleep(5 * time.Millisecond)
|
|
if err := store.Save(ctx, path, m); err != nil {
|
|
t.Fatalf("second Save() error = %v", err)
|
|
}
|
|
|
|
if !m.UpdatedAt.After(firstUpdated) {
|
|
t.Fatalf("UpdatedAt = %v, want after %v", m.UpdatedAt, firstUpdated)
|
|
}
|
|
}
|
|
|
|
func TestLocalStoreSaveAtomicPractical(t *testing.T) {
|
|
store := &LocalStore{}
|
|
ctx := context.Background()
|
|
|
|
dir := t.TempDir()
|
|
path := filepath.Join(dir, "manifest.json")
|
|
|
|
m := New("session-a", time.Date(2026, 5, 3, 10, 0, 0, 0, time.UTC))
|
|
if err := store.Save(ctx, path, m); err != nil {
|
|
t.Fatalf("Save() error = %v", err)
|
|
}
|
|
|
|
data, err := os.ReadFile(path)
|
|
if err != nil {
|
|
t.Fatalf("ReadFile() error = %v", err)
|
|
}
|
|
var decoded Manifest
|
|
if err := json.Unmarshal(data, &decoded); err != nil {
|
|
t.Fatalf("saved manifest is not valid JSON: %v", err)
|
|
}
|
|
|
|
entries, err := os.ReadDir(dir)
|
|
if err != nil {
|
|
t.Fatalf("ReadDir() error = %v", err)
|
|
}
|
|
for _, e := range entries {
|
|
if strings.HasPrefix(e.Name(), ".manifest.json.tmp-") {
|
|
t.Fatalf("found unexpected temp file after save: %s", e.Name())
|
|
}
|
|
}
|
|
|
|
m.SessionID = "session-b"
|
|
if err := store.Save(ctx, path, m); err != nil {
|
|
t.Fatalf("second Save() error = %v", err)
|
|
}
|
|
|
|
loaded, err := store.Load(ctx, path)
|
|
if err != nil {
|
|
t.Fatalf("Load() error = %v", err)
|
|
}
|
|
if loaded.SessionID != "session-b" {
|
|
t.Fatalf("SessionID = %q, want %q", loaded.SessionID, "session-b")
|
|
}
|
|
}
|
|
|
|
func TestLoadRejectsInvalidManifest(t *testing.T) {
|
|
store := &LocalStore{}
|
|
ctx := context.Background()
|
|
|
|
path := filepath.Join(t.TempDir(), "manifest.json")
|
|
if err := os.WriteFile(path, []byte(`{"updated_at":"2026-05-03T10:00:00Z"}`), 0o644); err != nil {
|
|
t.Fatalf("WriteFile() error = %v", err)
|
|
}
|
|
|
|
_, err := store.Load(ctx, path)
|
|
if err == nil {
|
|
t.Fatal("expected error, got nil")
|
|
}
|
|
if !strings.Contains(err.Error(), "session_id is required") {
|
|
t.Fatalf("error = %q, want session_id validation", err.Error())
|
|
}
|
|
}
|
|
|
|
func TestLocalStoreCreateSaveLoadRunManifestRoundTrip(t *testing.T) {
|
|
store := &LocalStore{}
|
|
ctx := context.Background()
|
|
|
|
run, err := store.CreateRun(
|
|
ctx,
|
|
"2026-05-03",
|
|
"forsaken",
|
|
"20260517T000000Z-abcdef12",
|
|
true,
|
|
[]string{"prepare", "transcribe"},
|
|
)
|
|
if err != nil {
|
|
t.Fatalf("CreateRun() error = %v", err)
|
|
}
|
|
run.SessionManifestPath = "/var/lib/narratio/work/forsaken/2026-05-03/manifest.json"
|
|
run.MarkStageRunning("prepare", time.Date(2026, 5, 3, 12, 1, 0, 0, time.UTC))
|
|
run.MarkStageSucceeded("prepare", time.Date(2026, 5, 3, 12, 2, 0, 0, time.UTC), []ArtifactRecord{
|
|
{Kind: "input", LocalPath: "inputs/session.yml"},
|
|
})
|
|
run.MarkSucceeded(time.Date(2026, 5, 3, 12, 3, 0, 0, time.UTC))
|
|
|
|
path := filepath.Join(t.TempDir(), "run-manifest.json")
|
|
if err := store.SaveRun(ctx, path, run); err != nil {
|
|
t.Fatalf("SaveRun() error = %v", err)
|
|
}
|
|
|
|
loaded, err := store.LoadRun(ctx, path)
|
|
if err != nil {
|
|
t.Fatalf("LoadRun() error = %v", err)
|
|
}
|
|
|
|
if loaded.SessionID != "2026-05-03" {
|
|
t.Fatalf("SessionID = %q, want %q", loaded.SessionID, "2026-05-03")
|
|
}
|
|
if loaded.Campaign != "forsaken" {
|
|
t.Fatalf("Campaign = %q, want %q", loaded.Campaign, "forsaken")
|
|
}
|
|
if loaded.RunID != "20260517T000000Z-abcdef12" {
|
|
t.Fatalf("RunID = %q, want %q", loaded.RunID, "20260517T000000Z-abcdef12")
|
|
}
|
|
if loaded.Status != RunManifestStatusSucceeded {
|
|
t.Fatalf("Status = %q, want %q", loaded.Status, RunManifestStatusSucceeded)
|
|
}
|
|
if loaded.Stages["prepare"] == nil || loaded.Stages["prepare"].Status != StatusSucceeded {
|
|
t.Fatalf("prepare stage = %#v, want succeeded", loaded.Stages["prepare"])
|
|
}
|
|
if loaded.Stages["prepare"].Action != RunStageActionRun {
|
|
t.Fatalf("prepare action = %q, want %q", loaded.Stages["prepare"].Action, RunStageActionRun)
|
|
}
|
|
}
|
|
|
|
func TestLoadRunRejectsInvalidManifest(t *testing.T) {
|
|
store := &LocalStore{}
|
|
ctx := context.Background()
|
|
|
|
path := filepath.Join(t.TempDir(), "run-manifest.json")
|
|
if err := os.WriteFile(path, []byte(`{"session_id":"2026-05-03"}`), 0o644); err != nil {
|
|
t.Fatalf("WriteFile() error = %v", err)
|
|
}
|
|
|
|
_, err := store.LoadRun(ctx, path)
|
|
if err == nil {
|
|
t.Fatal("expected error, got nil")
|
|
}
|
|
if !strings.Contains(err.Error(), "run_id is required") {
|
|
t.Fatalf("error = %q, want run_id validation", err.Error())
|
|
}
|
|
}
|