StreamRecorder/pkg/transfer/watcher_test.go
Aaron e2566fdefa
Some checks failed
Build Go Binaries / build (push) Has been cancelled
Claude bugfixes
2026-08-07 03:49:37 +00:00

224 lines
7.1 KiB
Go

package transfer
import (
"context"
"os"
"path/filepath"
"sort"
"testing"
"time"
)
// settlingDelay is short so tests exercise the real timer path without
// waiting the production five seconds.
const testSettlingDelay = 40 * time.Millisecond
// newTestQueue builds a queue that accepts items but never transfers them:
// ProcessQueue is not started, so Add is a pure recording of intent.
func newTestQueue(t *testing.T) *TransferQueue {
t.Helper()
return NewTransferQueue(QueueConfig{
WorkerCount: 1,
PersistencePath: filepath.Join(t.TempDir(), "queue.json"),
MaxQueueSize: 100,
BatchSize: 10,
}, nil, nil)
}
// queuedDestinations returns the destination paths currently queued, sorted.
func queuedDestinations(q *TransferQueue) []string {
q.mu.RLock()
defer q.mu.RUnlock()
out := make([]string, 0, q.items.Len())
for _, item := range *q.items {
out = append(out, filepath.ToSlash(item.DestinationPath))
}
sort.Strings(out)
return out
}
// waitForQueue polls until the queue holds want items or the deadline passes.
// Polling beats a fixed sleep: it keeps the test fast when the watcher is
// prompt and tolerant when a loaded CI machine is not.
func waitForQueue(t *testing.T, q *TransferQueue, want int) []string {
t.Helper()
deadline := time.Now().Add(3 * time.Second)
var got []string
for time.Now().Before(deadline) {
got = queuedDestinations(q)
if len(got) >= want {
return got
}
time.Sleep(10 * time.Millisecond)
}
return got
}
func startWatcher(t *testing.T, dir, eventName string, q *TransferQueue) {
t.Helper()
fw, err := NewFileWatcher(dir, eventName, q, testSettlingDelay)
if err != nil {
t.Fatalf("NewFileWatcher failed: %v", err)
}
ctx, cancel := context.WithCancel(context.Background())
t.Cleanup(cancel)
started := make(chan struct{})
go func() {
close(started)
_ = fw.Start(ctx)
}()
<-started
// Give Start a moment to register its initial watches before the test
// begins creating files under them.
time.Sleep(100 * time.Millisecond)
}
// TestWatcherPicksUpDirectoriesCreatedAfterStart covers the normal recording
// sequence: the transfer service starts watching the event directory, and only
// then does the downloader create the per-resolution directories inside it.
// fsnotify is not recursive, so those directories have to be picked up from
// the create event or nothing inside them is ever transferred.
func TestWatcherPicksUpDirectoriesCreatedAfterStart(t *testing.T) {
eventDir := t.TempDir()
queue := newTestQueue(t)
startWatcher(t, eventDir, "2026-regionals", queue)
resolutionDir := filepath.Join(eventDir, "1080p")
if err := os.MkdirAll(resolutionDir, 0755); err != nil {
t.Fatalf("failed to create resolution dir: %v", err)
}
if err := os.WriteFile(filepath.Join(resolutionDir, "seg_1001.ts"), []byte("payload"), 0644); err != nil {
t.Fatalf("failed to write segment: %v", err)
}
got := waitForQueue(t, queue, 1)
if len(got) != 1 {
t.Fatalf("segment written to a new resolution directory was never queued, queue = %v", got)
}
if want := "2026-regionals/1080p/seg_1001.ts"; got[0] != want {
t.Errorf("destination = %q, want %q", got[0], want)
}
}
// TestWatcherSweepsFilesRacingDirectoryCreation covers the tighter race where
// segments are written immediately after the mkdir, before the new watch can
// be registered. Those writes produce no event the watcher would receive, so
// the directory has to be swept when it is first seen.
func TestWatcherSweepsFilesRacingDirectoryCreation(t *testing.T) {
eventDir := t.TempDir()
queue := newTestQueue(t)
startWatcher(t, eventDir, "event", queue)
// Stage the tree elsewhere and move it into place, so the files are
// guaranteed to already exist the instant the directory appears.
staging := filepath.Join(t.TempDir(), "1080p")
if err := os.MkdirAll(staging, 0755); err != nil {
t.Fatalf("failed to stage: %v", err)
}
for _, name := range []string{"seg_1001.ts", "seg_1002.ts"} {
if err := os.WriteFile(filepath.Join(staging, name), []byte("payload"), 0644); err != nil {
t.Fatalf("failed to stage segment: %v", err)
}
}
if err := os.Rename(staging, filepath.Join(eventDir, "1080p")); err != nil {
t.Fatalf("failed to move staged directory into place: %v", err)
}
got := waitForQueue(t, queue, 2)
want := []string{"event/1080p/seg_1001.ts", "event/1080p/seg_1002.ts"}
if len(got) != 2 || got[0] != want[0] || got[1] != want[1] {
t.Errorf("queued %v, want %v", got, want)
}
}
// TestWatcherDestinationIncludesEventName pins the layout agreement between
// live transfers and the catch-up path in QueueExistingFiles: both must write
// to <nas>/<event>/<resolution>/<file>.
func TestWatcherDestinationIncludesEventName(t *testing.T) {
eventDir := t.TempDir()
resolutionDir := filepath.Join(eventDir, "720p")
if err := os.MkdirAll(resolutionDir, 0755); err != nil {
t.Fatalf("setup failed: %v", err)
}
queue := newTestQueue(t)
startWatcher(t, eventDir, "my-event", queue)
if err := os.WriteFile(filepath.Join(resolutionDir, "seg_1001.ts"), []byte("payload"), 0644); err != nil {
t.Fatalf("failed to write segment: %v", err)
}
got := waitForQueue(t, queue, 1)
if len(got) != 1 {
t.Fatalf("expected one queued item, got %v", got)
}
if want := "my-event/720p/seg_1001.ts"; got[0] != want {
t.Errorf("destination = %q, want %q", got[0], want)
}
}
// TestWatcherWithoutEventNameUsesRoot mirrors a download run with no -event:
// segments land under the local output root, so the NAS destination must not
// invent a directory level for them.
func TestWatcherWithoutEventNameUsesRoot(t *testing.T) {
eventDir := t.TempDir()
resolutionDir := filepath.Join(eventDir, "1080p")
if err := os.MkdirAll(resolutionDir, 0755); err != nil {
t.Fatalf("setup failed: %v", err)
}
queue := newTestQueue(t)
startWatcher(t, eventDir, "", queue)
if err := os.WriteFile(filepath.Join(resolutionDir, "seg_1001.ts"), []byte("payload"), 0644); err != nil {
t.Fatalf("failed to write segment: %v", err)
}
got := waitForQueue(t, queue, 1)
if len(got) != 1 {
t.Fatalf("expected one queued item, got %v", got)
}
if want := "1080p/seg_1001.ts"; got[0] != want {
t.Errorf("destination = %q, want %q", got[0], want)
}
}
func TestWatcherIgnoresNonSegmentFiles(t *testing.T) {
eventDir := t.TempDir()
queue := newTestQueue(t)
startWatcher(t, eventDir, "event", queue)
for _, name := range []string{"notes.txt", "manifest.json", "segment.ts.part"} {
if err := os.WriteFile(filepath.Join(eventDir, name), []byte("x"), 0644); err != nil {
t.Fatalf("failed to write %s: %v", name, err)
}
}
time.Sleep(testSettlingDelay + 300*time.Millisecond)
if got := queuedDestinations(queue); len(got) != 0 {
t.Errorf("non-segment files should not be queued, got %v", got)
}
}
func TestExtractResolution(t *testing.T) {
fw := &FileWatcher{}
cases := map[string]string{
filepath.Join("data", "event", "1080p", "seg.ts"): "1080p",
filepath.Join("data", "event", "720p", "seg.ts"): "720p",
filepath.Join("data", "event", "seg.ts"): "",
}
for path, want := range cases {
if got := fw.extractResolution(path); got != want {
t.Errorf("extractResolution(%q) = %q, want %q", path, got, want)
}
}
}