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 ///. 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) } } }