224 lines
7.1 KiB
Go
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)
|
|
}
|
|
}
|
|
}
|