309 lines
13 KiB
Go
309 lines
13 KiB
Go
package app
|
|
|
|
import (
|
|
"context"
|
|
"crypto/sha256"
|
|
"encoding/hex"
|
|
"encoding/json"
|
|
"os"
|
|
"path/filepath"
|
|
"sort"
|
|
"strings"
|
|
"testing"
|
|
"time"
|
|
|
|
"gitea.maximumdirect.net/eric/narratio/internal/adapters/storage"
|
|
"gitea.maximumdirect.net/eric/narratio/internal/artifacts"
|
|
"gitea.maximumdirect.net/eric/narratio/internal/config"
|
|
"gitea.maximumdirect.net/eric/narratio/internal/manifest"
|
|
)
|
|
|
|
func TestCommittedRestorePlanUsesOnlyDeclaredObjects(t *testing.T) {
|
|
cfg := restorePlanConfig(t)
|
|
fake := &storage.FakeBackend{}
|
|
current := seedCommittedRestoreSnapshot(t, cfg, fake, "20260519T010203Z-a1b2c3d4", map[string][]byte{
|
|
"transcripts/full.json": []byte(`{"segments":[1]}`),
|
|
})
|
|
fake.SeedObject(storage.FakeObject{Key: current.SessionPrefix + "artifacts/stale.md", Data: []byte("stale")})
|
|
fake.SeedObject(storage.FakeObject{Key: artifacts.S3RunRelativeDestinationKey(artifacts.S3RunPrefix(current.SessionPrefix, "20260519T010204Z-e5f6a7b8"), "transcripts/other.json"), Data: []byte("other")})
|
|
|
|
plan, err := buildRestorePlan(context.Background(), cfg, current, fake, RestorePlanOptions{})
|
|
if err != nil {
|
|
t.Fatalf("buildRestorePlan() error = %v", err)
|
|
}
|
|
got := actionRelPaths(plan.Actions)
|
|
want := []string{"manifest.json", "transcripts/full.json"}
|
|
if len(got) != len(want) {
|
|
t.Fatalf("action paths = %#v, want %#v", got, want)
|
|
}
|
|
for index := range want {
|
|
if got[index] != want[index] {
|
|
t.Fatalf("action paths = %#v, want %#v", got, want)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestCommittedRestoreReusesVerifiedManifestCandidate(t *testing.T) {
|
|
cfg := restorePlanConfig(t)
|
|
fake := &storage.FakeBackend{}
|
|
current := seedCommittedRestoreSnapshot(t, cfg, fake, "20260519T010203Z-a1b2c3d4", nil)
|
|
|
|
plan, err := buildRestorePlan(context.Background(), cfg, current, fake, RestorePlanOptions{})
|
|
if err != nil {
|
|
t.Fatalf("buildRestorePlan() error = %v", err)
|
|
}
|
|
if _, err := executeRestorePlan(context.Background(), cfg, current, plan, nil, fake); err != nil {
|
|
t.Fatalf("executeRestorePlan() error = %v", err)
|
|
}
|
|
if got := fakeReadCount(fake, current.CurrentManifestKey); got != 1 {
|
|
t.Fatalf("manifest reads = %d, want one discovery read reused by restore", got)
|
|
}
|
|
if got := fakeDownloadCount(fake, current.CurrentManifestKey); got != 0 {
|
|
t.Fatalf("manifest downloads = %d, want no temporary download", got)
|
|
}
|
|
}
|
|
|
|
func TestCommittedRestoreRejectsChangedGenerationForVerifiedManifestCandidate(t *testing.T) {
|
|
cfg := restorePlanConfig(t)
|
|
fake := &storage.FakeBackend{}
|
|
current := seedCommittedRestoreSnapshot(t, cfg, fake, "20260519T010203Z-a1b2c3d4", nil)
|
|
plan, err := buildRestorePlan(context.Background(), cfg, current, fake, RestorePlanOptions{})
|
|
if err != nil {
|
|
t.Fatalf("buildRestorePlan() error = %v", err)
|
|
}
|
|
fake.SeedObject(storage.FakeObject{Key: current.CurrentManifestKey, Data: []byte("changed manifest"), ETag: "changed-generation"})
|
|
|
|
_, err = executeRestorePlan(context.Background(), cfg, current, plan, nil, fake)
|
|
if err == nil || !strings.Contains(err.Error(), "generation mismatch") {
|
|
t.Fatalf("executeRestorePlan() error = %v, want generation mismatch", err)
|
|
}
|
|
if got := fakeReadCount(fake, current.CurrentManifestKey); got != 1 {
|
|
t.Fatalf("manifest reads = %d, want no second transfer for rejected candidate", got)
|
|
}
|
|
}
|
|
|
|
func TestCommittedStatusReportsOnlyDeclaredPublishedOutputs(t *testing.T) {
|
|
cfg := restorePlanConfig(t)
|
|
cfg.Pipeline.Publish = &config.PublishConfig{Outputs: []config.PublishOutputRule{{
|
|
Source: "narratio.transcript.final_trimmed",
|
|
Dest: "transcripts/full.json",
|
|
}}}
|
|
fake := &storage.FakeBackend{}
|
|
current := seedCommittedRestoreSnapshot(t, cfg, fake, "20260519T010203Z-a1b2c3d4", map[string][]byte{
|
|
"transcripts/full.json": []byte("declared\n"),
|
|
})
|
|
fake.SeedObject(storage.FakeObject{Key: current.SessionPrefix + "transcripts/full.json", Data: []byte("mutable stale copy\n")})
|
|
|
|
availability := remotePublishedOutputAvailabilityForCurrent(context.Background(), cfg, fake, nil, current)
|
|
key := publishedOutputRemoteStateKey("narratio.transcript.final_trimmed", "transcripts/full.json")
|
|
if availability[key] != "remote=published" {
|
|
t.Fatalf("availability = %#v, want committed published output", availability)
|
|
}
|
|
}
|
|
|
|
func TestCommittedRestoreKeepsSelectedSnapshotWhenPointerChanges(t *testing.T) {
|
|
cfg := restorePlanConfig(t)
|
|
fake := &storage.FakeBackend{}
|
|
first := seedCommittedRestoreSnapshot(t, cfg, fake, "20260519T010203Z-a1b2c3d4", map[string][]byte{
|
|
"transcripts/full.json": []byte("from first commit\n"),
|
|
})
|
|
plan, err := buildRestorePlan(context.Background(), cfg, first, fake, RestorePlanOptions{})
|
|
if err != nil {
|
|
t.Fatalf("buildRestorePlan() error = %v", err)
|
|
}
|
|
_ = seedCommittedRestoreSnapshot(t, cfg, fake, "20260519T010204Z-e5f6a7b8", map[string][]byte{
|
|
"transcripts/full.json": []byte("from second commit\n"),
|
|
})
|
|
|
|
if _, err := executeRestorePlan(context.Background(), cfg, first, plan, nil, fake); err != nil {
|
|
t.Fatalf("executeRestorePlan() error = %v", err)
|
|
}
|
|
root := artifacts.SessionWorkDirForCampaign(cfg.Pipeline.Workspace.Root, cfg.Session.Campaign, cfg.Session.SessionID)
|
|
mustReadEquals(t, filepath.Join(root, "transcripts", "full.json"), "from first commit\n")
|
|
restored, err := (&manifest.LocalStore{}).Load(context.Background(), filepath.Join(root, "manifest.json"))
|
|
if err != nil {
|
|
t.Fatalf("load restored manifest: %v", err)
|
|
}
|
|
if restored.RunID != first.RunID {
|
|
t.Fatalf("restored run id = %q, want %q", restored.RunID, first.RunID)
|
|
}
|
|
}
|
|
|
|
func TestCommittedRestoreRejectsChangedDeclaredObjectBeforeManifestInstall(t *testing.T) {
|
|
cfg := restorePlanConfig(t)
|
|
fake := &storage.FakeBackend{}
|
|
current := seedCommittedRestoreSnapshot(t, cfg, fake, "20260519T010203Z-a1b2c3d4", map[string][]byte{
|
|
"transcripts/full.json": []byte("committed bytes\n"),
|
|
})
|
|
plan, err := buildRestorePlan(context.Background(), cfg, current, fake, RestorePlanOptions{})
|
|
if err != nil {
|
|
t.Fatalf("buildRestorePlan() error = %v", err)
|
|
}
|
|
key := artifacts.S3RunRelativeDestinationKey(artifacts.S3RunPrefix(current.SessionPrefix, current.RunID), "transcripts/full.json")
|
|
fake.SeedObject(storage.FakeObject{Key: key, Data: []byte("changed bytes\n")})
|
|
|
|
if _, err := executeRestorePlan(context.Background(), cfg, current, plan, nil, fake); err == nil {
|
|
t.Fatal("executeRestorePlan() error = nil, want committed-object verification failure")
|
|
}
|
|
root := artifacts.SessionWorkDirForCampaign(cfg.Pipeline.Workspace.Root, cfg.Session.Campaign, cfg.Session.SessionID)
|
|
if _, err := os.Stat(filepath.Join(root, "manifest.json")); !os.IsNotExist(err) {
|
|
t.Fatalf("manifest should not be installed after failed restore; stat err=%v", err)
|
|
}
|
|
}
|
|
|
|
func TestCommittedRestoreRejectsChangedDeclaredObjectGeneration(t *testing.T) {
|
|
cfg := restorePlanConfig(t)
|
|
fake := &storage.FakeBackend{}
|
|
current := seedCommittedRestoreSnapshot(t, cfg, fake, "20260519T010203Z-a1b2c3d4", map[string][]byte{
|
|
"transcripts/full.json": []byte("committed bytes\n"),
|
|
})
|
|
plan, err := buildRestorePlan(context.Background(), cfg, current, fake, RestorePlanOptions{})
|
|
if err != nil {
|
|
t.Fatalf("buildRestorePlan() error = %v", err)
|
|
}
|
|
key := artifacts.S3RunRelativeDestinationKey(artifacts.S3RunPrefix(current.SessionPrefix, current.RunID), "transcripts/full.json")
|
|
fake.SeedObject(storage.FakeObject{Key: key, Data: []byte("committed bytes\n"), ETag: "replacement-generation"})
|
|
|
|
if _, err := executeRestorePlan(context.Background(), cfg, current, plan, nil, fake); err == nil {
|
|
t.Fatal("executeRestorePlan() error = nil, want generation verification failure")
|
|
}
|
|
root := artifacts.SessionWorkDirForCampaign(cfg.Pipeline.Workspace.Root, cfg.Session.Campaign, cfg.Session.SessionID)
|
|
if _, err := os.Stat(filepath.Join(root, "manifest.json")); !os.IsNotExist(err) {
|
|
t.Fatalf("manifest should not be installed after failed restore; stat err=%v", err)
|
|
}
|
|
}
|
|
|
|
func TestCommittedRestoreRejectsMissingDeclaredObjectBeforeManifestInstall(t *testing.T) {
|
|
cfg := restorePlanConfig(t)
|
|
fake := &storage.FakeBackend{}
|
|
current := seedCommittedRestoreSnapshot(t, cfg, fake, "20260519T010203Z-a1b2c3d4", map[string][]byte{
|
|
"transcripts/full.json": []byte("committed bytes\n"),
|
|
})
|
|
plan, err := buildRestorePlan(context.Background(), cfg, current, fake, RestorePlanOptions{})
|
|
if err != nil {
|
|
t.Fatalf("buildRestorePlan() error = %v", err)
|
|
}
|
|
missingKey := artifacts.S3RunRelativeDestinationKey(artifacts.S3RunPrefix(current.SessionPrefix, current.RunID), "transcripts/full.json")
|
|
fake.DownloadHook = func(call storage.FakeDownloadCall) error {
|
|
if call.Key == missingKey {
|
|
return os.ErrNotExist
|
|
}
|
|
return nil
|
|
}
|
|
|
|
if _, err := executeRestorePlan(context.Background(), cfg, current, plan, nil, fake); err == nil {
|
|
t.Fatal("executeRestorePlan() error = nil, want missing-object failure")
|
|
}
|
|
root := artifacts.SessionWorkDirForCampaign(cfg.Pipeline.Workspace.Root, cfg.Session.Campaign, cfg.Session.SessionID)
|
|
if _, err := os.Stat(filepath.Join(root, "manifest.json")); !os.IsNotExist(err) {
|
|
t.Fatalf("manifest should not be installed after failed restore; stat err=%v", err)
|
|
}
|
|
}
|
|
|
|
func TestCommittedRestoreForceRetainsDirectoryConflict(t *testing.T) {
|
|
cfg := restorePlanConfig(t)
|
|
fake := &storage.FakeBackend{}
|
|
current := seedCommittedRestoreSnapshot(t, cfg, fake, "20260519T010203Z-a1b2c3d4", map[string][]byte{
|
|
"transcripts/full.json": []byte("committed bytes\n"),
|
|
})
|
|
root := artifacts.SessionWorkDirForCampaign(cfg.Pipeline.Workspace.Root, cfg.Session.Campaign, cfg.Session.SessionID)
|
|
if err := os.MkdirAll(filepath.Join(root, "transcripts", "full.json"), 0o755); err != nil {
|
|
t.Fatalf("MkdirAll() error = %v", err)
|
|
}
|
|
|
|
plan, err := buildRestorePlan(context.Background(), cfg, current, fake, RestorePlanOptions{Force: true})
|
|
if err != nil {
|
|
t.Fatalf("buildRestorePlan() error = %v", err)
|
|
}
|
|
if plan.ConflictCount != 1 {
|
|
t.Fatalf("ConflictCount = %d, want 1", plan.ConflictCount)
|
|
}
|
|
for _, action := range plan.Actions {
|
|
if action.LocalRelativePath == "transcripts/full.json" && action.ConflictKind != RestoreConflictDirectory {
|
|
t.Fatalf("ConflictKind = %q, want %q", action.ConflictKind, RestoreConflictDirectory)
|
|
}
|
|
}
|
|
}
|
|
|
|
func seedCommittedRestoreSnapshot(t *testing.T, cfg *config.Config, fake *storage.FakeBackend, runID string, outputs map[string][]byte) *RemoteCurrentState {
|
|
t.Helper()
|
|
sessionPrefix := artifacts.S3SessionPrefix("dnd", cfg.Session.Campaign, cfg.Session.SessionID)
|
|
remoteManifest := manifest.New(cfg.Session.SessionID, time.Now().UTC())
|
|
remoteManifest.Campaign = cfg.Session.Campaign
|
|
remoteManifest.RunID = runID
|
|
manifestData, err := json.Marshal(remoteManifest)
|
|
if err != nil {
|
|
t.Fatalf("marshal manifest: %v", err)
|
|
}
|
|
manifestData = append(manifestData, '\n')
|
|
manifestKey := artifacts.S3RunSessionManifestKey(sessionPrefix, runID)
|
|
fake.SeedObject(storage.FakeObject{Key: manifestKey, Data: manifestData})
|
|
artifactsByKey := []artifacts.RemoteArtifact{remoteRestoreArtifact(fake, artifacts.RemoteArtifactTypeSessionManifest, "session.manifest", manifestKey)}
|
|
|
|
paths := make([]string, 0, len(outputs))
|
|
for relative := range outputs {
|
|
paths = append(paths, relative)
|
|
}
|
|
sort.Strings(paths)
|
|
for _, relative := range paths {
|
|
key := artifacts.S3RunRelativeDestinationKey(artifacts.S3RunPrefix(sessionPrefix, runID), relative)
|
|
fake.SeedObject(storage.FakeObject{Key: key, Data: outputs[relative]})
|
|
artifactsByKey = append(artifactsByKey, remoteRestoreArtifact(fake, artifacts.RemoteArtifactTypePublishedOutput, "narratio.test", key))
|
|
}
|
|
commit := artifacts.RemoteCommitManifest{
|
|
FormatVersion: artifacts.RemoteCommitFormatVersion,
|
|
Campaign: cfg.Session.Campaign,
|
|
SessionID: cfg.Session.SessionID,
|
|
RunID: runID,
|
|
Artifacts: artifactsByKey,
|
|
}
|
|
commitData, err := artifacts.EncodeRemoteCommitManifest(commit)
|
|
if err != nil {
|
|
t.Fatalf("encode remote commit: %v", err)
|
|
}
|
|
commitKey := artifacts.S3RunCommitKey(sessionPrefix, runID)
|
|
fake.SeedObject(storage.FakeObject{Key: commitKey, Data: commitData})
|
|
commitObject := fake.Objects[commitKey]
|
|
pointerData, err := artifacts.EncodeCurrentCommitPointer(artifacts.CurrentCommitPointer{
|
|
FormatVersion: artifacts.RemoteCommitFormatVersion,
|
|
Campaign: cfg.Session.Campaign,
|
|
SessionID: cfg.Session.SessionID,
|
|
RunID: runID,
|
|
CommitKey: commitKey,
|
|
CommitSHA256: restoreCommitSHA256(commitData),
|
|
CommitSize: int64(len(commitData)),
|
|
CommitGeneration: commitObject.ETag,
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("encode current pointer: %v", err)
|
|
}
|
|
fake.SeedObject(storage.FakeObject{Key: artifacts.S3CurrentCommitPointerKey(sessionPrefix), Data: pointerData})
|
|
current, err := discoverRemoteCurrentState(context.Background(), cfg, fake)
|
|
if err != nil {
|
|
t.Fatalf("discoverRemoteCurrentState() error = %v", err)
|
|
}
|
|
return current
|
|
}
|
|
|
|
func remoteRestoreArtifact(fake *storage.FakeBackend, artifactType artifacts.RemoteArtifactType, source, key string) artifacts.RemoteArtifact {
|
|
object := fake.Objects[key]
|
|
return artifacts.RemoteArtifact{
|
|
Type: artifactType, Source: source, DestinationKey: key, SHA256: restoreCommitSHA256(object.Data), Size: int64(len(object.Data)), Generation: object.ETag,
|
|
}
|
|
}
|
|
|
|
func fakeReadCount(fake *storage.FakeBackend, key string) int {
|
|
count := 0
|
|
for _, call := range fake.Reads {
|
|
if call.Key == key {
|
|
count++
|
|
}
|
|
}
|
|
return count
|
|
}
|
|
|
|
func restoreCommitSHA256(data []byte) string {
|
|
sum := sha256.Sum256(data)
|
|
return hex.EncodeToString(sum[:])
|
|
}
|