337 lines
9.9 KiB
Go
337 lines
9.9 KiB
Go
package artifacts
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"os"
|
|
"os/exec"
|
|
"path/filepath"
|
|
"strings"
|
|
"testing"
|
|
"time"
|
|
)
|
|
|
|
func TestEnsureLayoutCreatesExpectedDirectories(t *testing.T) {
|
|
store := NewLocalStore(t.TempDir())
|
|
paths, err := store.EnsureLayoutFor("sample-campaign", "session-1")
|
|
if err != nil {
|
|
t.Fatalf("EnsureLayoutFor() error = %v", err)
|
|
}
|
|
|
|
checkDirExists(t, paths.Root)
|
|
checkDirExists(t, paths.InputsDir)
|
|
checkDirExists(t, paths.AudioDir)
|
|
checkDirExists(t, paths.TranscriptsDir)
|
|
checkDirExists(t, paths.TranscriptsRawDir)
|
|
checkDirExists(t, paths.TranscriptsTrimmedDir)
|
|
checkDirExists(t, paths.ArtifactsDir)
|
|
checkDirExists(t, paths.ReportsDir)
|
|
checkDirExists(t, paths.ConfigDir)
|
|
checkDirExists(t, paths.LogsDir)
|
|
checkDirExists(t, paths.CurrentDir)
|
|
checkDirExists(t, paths.RunsDir)
|
|
checkDirExists(t, paths.PreviousDir)
|
|
checkDirExists(t, paths.PreviousArtifactsDir)
|
|
|
|
if filepath.Base(paths.ManifestPath) != "manifest.json" {
|
|
t.Fatalf("ManifestPath = %q, want basename manifest.json", paths.ManifestPath)
|
|
}
|
|
if filepath.Base(paths.PreviousManifestPath) != "manifest.json" {
|
|
t.Fatalf("PreviousManifestPath = %q, want basename manifest.json", paths.PreviousManifestPath)
|
|
}
|
|
if filepath.Base(paths.LockPath) != ".lock" {
|
|
t.Fatalf("LockPath = %q, want basename .lock", paths.LockPath)
|
|
}
|
|
}
|
|
|
|
func TestEnsureLayoutForRequiresCampaign(t *testing.T) {
|
|
store := NewLocalStore(t.TempDir())
|
|
_, err := store.EnsureLayoutFor("", "session-1")
|
|
if err == nil {
|
|
t.Fatal("expected campaign-required error, got nil")
|
|
}
|
|
if !strings.Contains(err.Error(), "campaign is required") {
|
|
t.Fatalf("error = %v, want campaign-required error", err)
|
|
}
|
|
}
|
|
|
|
func TestChecksumCalculation(t *testing.T) {
|
|
store := NewLocalStore(t.TempDir())
|
|
path := filepath.Join(t.TempDir(), "sample.txt")
|
|
if err := os.WriteFile(path, []byte("hello"), 0o644); err != nil {
|
|
t.Fatalf("WriteFile() error = %v", err)
|
|
}
|
|
|
|
checksum, err := store.Checksum(path)
|
|
if err != nil {
|
|
t.Fatalf("Checksum() error = %v", err)
|
|
}
|
|
const want = "2cf24dba5fb0a30e26e83b2ac5b9e29e1b161e5c1fa7425e73043362938b9824"
|
|
if checksum != want {
|
|
t.Fatalf("checksum = %q, want %q", checksum, want)
|
|
}
|
|
}
|
|
|
|
func TestLockAcquireRelease(t *testing.T) {
|
|
store := NewLocalStore(t.TempDir())
|
|
|
|
lock, err := store.AcquireSessionLockFor("sample-campaign", "session-1")
|
|
if err != nil {
|
|
t.Fatalf("AcquireSessionLockFor() error = %v", err)
|
|
}
|
|
|
|
exists, err := store.Exists(lock.path)
|
|
if err != nil {
|
|
t.Fatalf("Exists() error = %v", err)
|
|
}
|
|
if !exists {
|
|
t.Fatalf("expected lock file %q to exist", lock.path)
|
|
}
|
|
|
|
if err := store.ReleaseSessionLock(lock); err != nil {
|
|
t.Fatalf("ReleaseSessionLock() error = %v", err)
|
|
}
|
|
|
|
exists, err = store.Exists(lock.path)
|
|
if err != nil {
|
|
t.Fatalf("Exists() error = %v", err)
|
|
}
|
|
if !exists {
|
|
t.Fatalf("expected lock metadata file %q to remain", lock.path)
|
|
}
|
|
secondLock, err := store.AcquireSessionLockFor("sample-campaign", "session-1")
|
|
if err != nil {
|
|
t.Fatalf("AcquireSessionLockFor() after release error = %v", err)
|
|
}
|
|
if err := store.ReleaseSessionLock(secondLock); err != nil {
|
|
t.Fatalf("ReleaseSessionLock(second lock) error = %v", err)
|
|
}
|
|
}
|
|
|
|
func TestLockWaitHonorsCancellation(t *testing.T) {
|
|
store := NewLocalStore(t.TempDir())
|
|
lock, err := store.AcquireSessionLockFor("sample-campaign", "session-1")
|
|
if err != nil {
|
|
t.Fatalf("AcquireSessionLockFor() error = %v", err)
|
|
}
|
|
defer func() { _ = store.ReleaseSessionLock(lock) }()
|
|
|
|
ctx, cancel := context.WithCancel(context.Background())
|
|
cancel()
|
|
_, err = store.AcquireSessionLockForContext(ctx, "sample-campaign", "session-1")
|
|
if !errors.Is(err, context.Canceled) {
|
|
t.Fatalf("AcquireSessionLockForContext() error = %v, want context cancellation", err)
|
|
}
|
|
}
|
|
|
|
func TestLockWaitsUntilRelease(t *testing.T) {
|
|
store := NewLocalStore(t.TempDir())
|
|
first, err := store.AcquireSessionLockFor("sample-campaign", "session-1")
|
|
if err != nil {
|
|
t.Fatalf("AcquireSessionLockFor() error = %v", err)
|
|
}
|
|
acquired := make(chan *LockHandle, 1)
|
|
errs := make(chan error, 1)
|
|
go func() {
|
|
lock, err := store.AcquireSessionLockForContext(context.Background(), "sample-campaign", "session-1")
|
|
if err != nil {
|
|
errs <- err
|
|
return
|
|
}
|
|
acquired <- lock
|
|
}()
|
|
|
|
select {
|
|
case err := <-errs:
|
|
t.Fatalf("AcquireSessionLockForContext() error = %v", err)
|
|
case lock := <-acquired:
|
|
_ = store.ReleaseSessionLock(lock)
|
|
t.Fatal("AcquireSessionLockForContext() acquired before the held lock was released")
|
|
case <-time.After(150 * time.Millisecond):
|
|
}
|
|
if err := store.ReleaseSessionLock(first); err != nil {
|
|
t.Fatalf("ReleaseSessionLock(first) error = %v", err)
|
|
}
|
|
select {
|
|
case err := <-errs:
|
|
t.Fatalf("AcquireSessionLockForContext() error = %v", err)
|
|
case lock := <-acquired:
|
|
if err := store.ReleaseSessionLock(lock); err != nil {
|
|
t.Fatalf("ReleaseSessionLock(waiting lock) error = %v", err)
|
|
}
|
|
case <-time.After(2 * time.Second):
|
|
t.Fatal("AcquireSessionLockForContext() did not acquire after release")
|
|
}
|
|
}
|
|
|
|
func TestLockRecoversAfterLockHolderDies(t *testing.T) {
|
|
if os.Getenv("NARRATIO_LOCK_PROCESS_HELPER") == "1" {
|
|
store := NewLocalStore(os.Getenv("NARRATIO_LOCK_PROCESS_ROOT"))
|
|
lock, err := store.AcquireSessionLockFor("sample-campaign", "session-1")
|
|
if err != nil {
|
|
os.Exit(2)
|
|
}
|
|
if err := os.WriteFile(os.Getenv("NARRATIO_LOCK_PROCESS_READY"), []byte(lock.path), 0o600); err != nil {
|
|
os.Exit(3)
|
|
}
|
|
select {}
|
|
}
|
|
|
|
root := t.TempDir()
|
|
ready := filepath.Join(t.TempDir(), "ready")
|
|
cmd := exec.Command(os.Args[0], "-test.run=^TestLockRecoversAfterLockHolderDies$")
|
|
cmd.Env = append(os.Environ(),
|
|
"NARRATIO_LOCK_PROCESS_HELPER=1",
|
|
"NARRATIO_LOCK_PROCESS_ROOT="+root,
|
|
"NARRATIO_LOCK_PROCESS_READY="+ready,
|
|
)
|
|
if err := cmd.Start(); err != nil {
|
|
t.Fatalf("start lock-holder process: %v", err)
|
|
}
|
|
defer func() {
|
|
if cmd.Process != nil {
|
|
_ = cmd.Process.Kill()
|
|
}
|
|
_ = cmd.Wait()
|
|
}()
|
|
deadline := time.Now().Add(2 * time.Second)
|
|
for {
|
|
if _, err := os.Stat(ready); err == nil {
|
|
break
|
|
}
|
|
if time.Now().After(deadline) {
|
|
t.Fatal("lock-holder process did not signal readiness")
|
|
}
|
|
time.Sleep(10 * time.Millisecond)
|
|
}
|
|
|
|
store := NewLocalStore(root)
|
|
if _, err := store.AcquireSessionLockFor("sample-campaign", "session-1"); !errors.Is(err, ErrLockConflict) {
|
|
t.Fatalf("AcquireSessionLockFor() error = %v, want lock conflict", err)
|
|
}
|
|
if err := cmd.Process.Kill(); err != nil {
|
|
t.Fatalf("kill lock-holder process: %v", err)
|
|
}
|
|
if err := cmd.Wait(); err == nil {
|
|
t.Fatal("lock-holder process exited without being killed")
|
|
}
|
|
cmd.Process = nil
|
|
|
|
lock, err := store.AcquireSessionLockFor("sample-campaign", "session-1")
|
|
if err != nil {
|
|
t.Fatalf("AcquireSessionLockFor() after holder death error = %v", err)
|
|
}
|
|
if err := store.ReleaseSessionLock(lock); err != nil {
|
|
t.Fatalf("ReleaseSessionLock() error = %v", err)
|
|
}
|
|
}
|
|
|
|
func TestReleaseSessionLockReportsUnlockFailure(t *testing.T) {
|
|
store := NewLocalStore(t.TempDir())
|
|
lock, err := store.AcquireSessionLockFor("sample-campaign", "session-1")
|
|
if err != nil {
|
|
t.Fatalf("AcquireSessionLockFor() error = %v", err)
|
|
}
|
|
|
|
original := releaseHeldFileLockFn
|
|
releaseHeldFileLockFn = func(*os.File) error { return errors.New("unlock failed") }
|
|
t.Cleanup(func() { releaseHeldFileLockFn = original })
|
|
if err := store.ReleaseSessionLock(lock); err == nil || !strings.Contains(err.Error(), "unlock failed") {
|
|
t.Fatalf("ReleaseSessionLock() error = %v, want unlock failure", err)
|
|
}
|
|
}
|
|
|
|
func TestLockConflict(t *testing.T) {
|
|
store := NewLocalStore(t.TempDir())
|
|
lock1, err := store.AcquireSessionLockFor("sample-campaign", "session-1")
|
|
if err != nil {
|
|
t.Fatalf("first AcquireSessionLockFor() error = %v", err)
|
|
}
|
|
defer func() {
|
|
_ = store.ReleaseSessionLock(lock1)
|
|
}()
|
|
|
|
_, err = store.AcquireSessionLockFor("sample-campaign", "session-1")
|
|
if err == nil {
|
|
t.Fatal("expected lock conflict error, got nil")
|
|
}
|
|
if !errors.Is(err, ErrLockConflict) {
|
|
t.Fatalf("error = %v, want ErrLockConflict", err)
|
|
}
|
|
}
|
|
|
|
func TestWriteFileAtomicAndOverwrite(t *testing.T) {
|
|
store := NewLocalStore(t.TempDir())
|
|
path := filepath.Join(t.TempDir(), "out", "value.txt")
|
|
|
|
if err := store.WriteFileAtomic(path, []byte("one"), 0o644); err != nil {
|
|
t.Fatalf("first WriteFileAtomic() error = %v", err)
|
|
}
|
|
if err := store.WriteFileAtomic(path, []byte("two"), 0o644); err != nil {
|
|
t.Fatalf("second WriteFileAtomic() error = %v", err)
|
|
}
|
|
|
|
data, err := os.ReadFile(path)
|
|
if err != nil {
|
|
t.Fatalf("ReadFile() error = %v", err)
|
|
}
|
|
if string(data) != "two" {
|
|
t.Fatalf("file content = %q, want %q", string(data), "two")
|
|
}
|
|
|
|
entries, err := os.ReadDir(filepath.Dir(path))
|
|
if err != nil {
|
|
t.Fatalf("ReadDir() error = %v", err)
|
|
}
|
|
for _, e := range entries {
|
|
if strings.Contains(e.Name(), ".tmp-") {
|
|
t.Fatalf("unexpected temp file residue: %s", e.Name())
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestCopyInput(t *testing.T) {
|
|
root := t.TempDir()
|
|
store := NewLocalStore(root)
|
|
|
|
srcPath := filepath.Join(t.TempDir(), "speakers.yml")
|
|
content := "alice: alice.flac\n"
|
|
if err := os.WriteFile(srcPath, []byte(content), 0o644); err != nil {
|
|
t.Fatalf("WriteFile() error = %v", err)
|
|
}
|
|
|
|
ref, err := store.CopyInputFor("sample-campaign", "session-1", srcPath, "inputs/speakers.yml")
|
|
if err != nil {
|
|
t.Fatalf("CopyInputFor() error = %v", err)
|
|
}
|
|
|
|
if ref.Kind != "input" {
|
|
t.Fatalf("ref.Kind = %q, want %q", ref.Kind, "input")
|
|
}
|
|
if ref.RelativePath != filepath.Clean("inputs/speakers.yml") {
|
|
t.Fatalf("ref.RelativePath = %q, want %q", ref.RelativePath, filepath.Clean("inputs/speakers.yml"))
|
|
}
|
|
if !strings.HasPrefix(ref.AbsolutePath, root) {
|
|
t.Fatalf("ref.AbsolutePath = %q, want under workspace root %q", ref.AbsolutePath, root)
|
|
}
|
|
|
|
data, err := os.ReadFile(ref.AbsolutePath)
|
|
if err != nil {
|
|
t.Fatalf("ReadFile() error = %v", err)
|
|
}
|
|
if string(data) != content {
|
|
t.Fatalf("copied content = %q, want %q", string(data), content)
|
|
}
|
|
}
|
|
|
|
func checkDirExists(t *testing.T, path string) {
|
|
t.Helper()
|
|
info, err := os.Stat(path)
|
|
if err != nil {
|
|
t.Fatalf("Stat(%q) error = %v", path, err)
|
|
}
|
|
if !info.IsDir() {
|
|
t.Fatalf("%q is not a directory", path)
|
|
}
|
|
}
|