0.2.64 update

server/internal/credits/queue_test.go

@@ -0,0 +1,143 @@
+package credits
+
+import (
+	"testing"
+	"time"
+)
+
+// The queue is bounded, and saturation is a real state with a right answer: throw the
+// speculation away. A queue holding forty episodes nobody has reached has stopped describing
+// demand.
+
+func queued(id string, priority int) Candidate {
+	return Candidate{ItemID: id, Priority: priority, LastViewed: now}
+}
+
+func TestQueueOrdersByPriority(t *testing.T) {
+	queue := NewQueue(10)
+	queue.Push(queued("ahead3", PriorityAhead3))
+	queue.Push(queued("live", PriorityLive))
+	queue.Push(queued("next", PriorityNext))
+
+	candidate, found := queue.Claim()
+	if !found || candidate.ItemID != "live" {
+		t.Fatalf("claimed %+v, want the live candidate first", candidate)
+	}
+	candidate, _ = queue.Claim()
+	if candidate.ItemID != "next" {
+		t.Fatalf("claimed %q second, want next", candidate.ItemID)
+	}
+}
+
+func TestSaturationDiscardsTheWeakestSpeculation(t *testing.T) {
+	queue := NewQueue(3)
+	queue.Push(queued("spec-a", PrioritySpeculative))
+	queue.Push(queued("spec-b", PrioritySpeculative+1))
+	queue.Push(queued("spec-c", PrioritySpeculative+2))
+
+	if queued := queue.Push(queued("live", PriorityLive)); !queued {
+		t.Fatal("a full queue refused live playback")
+	}
+	if queue.Len() != 3 {
+		t.Fatalf("queue length %d, want the limit of 3", queue.Len())
+	}
+	for _, candidate := range queue.Snapshot() {
+		if candidate.ItemID == "spec-a" {
+			t.Fatal("the weakest candidate survived saturation")
+		}
+	}
+}
+
+func TestSaturationRefusesWeakerWork(t *testing.T) {
+	queue := NewQueue(2)
+	queue.Push(queued("next-a", PriorityNext))
+	queue.Push(queued("next-b", PriorityNext))
+
+	if queue.Push(queued("spec", PrioritySpeculative)) {
+		t.Fatal("a full queue accepted work weaker than everything in it")
+	}
+	if queue.Len() != 2 {
+		t.Fatalf("queue length %d, want 2", queue.Len())
+	}
+}
+
+func TestPushMergesRatherThanDuplicating(t *testing.T) {
+	queue := NewQueue(10)
+	queue.Push(queued("bb-s06e08", PriorityAhead2))
+	queue.Push(Candidate{
+		ItemID: "bb-s06e08", Priority: PriorityNext, Reason: ReasonMultiUser,
+		UserCount: 2, LastViewed: now,
+	})
+
+	if queue.Len() != 1 {
+		t.Fatalf("queue length %d; the same episode must not be queued twice", queue.Len())
+	}
+	candidate, _ := queue.Claim()
+	if candidate.Priority != PriorityNext {
+		t.Fatalf("priority = %d; the stronger case should have won", candidate.Priority)
+	}
+	if candidate.UserCount != 2 {
+		t.Fatalf("UserCount = %d, want 2", candidate.UserCount)
+	}
+}
+
+// A weaker second viewer must never lower a candidate somebody else is about to reach.
+func TestPushNeverLowersPriority(t *testing.T) {
+	queue := NewQueue(10)
+	queue.Push(queued("bb-s06e08", PriorityNext))
+	queue.Push(queued("bb-s06e08", PrioritySpeculative))
+
+	candidate, _ := queue.Claim()
+	if candidate.Priority != PriorityNext {
+		t.Fatalf("priority = %d, want %d", candidate.Priority, PriorityNext)
+	}
+}
+
+// Cancelling a scan that is already reading a file, to replace it with a marginally better
+// candidate, would waste exactly the disk activity this package exists to avoid.
+func TestReplaceLeavesClaimedWorkAlone(t *testing.T) {
+	queue := NewQueue(10)
+	queue.Push(queued("in-flight", PriorityNext))
+	claimed, _ := queue.Claim()
+
+	queue.Replace([]Candidate{queued("fresh", PriorityNext), queued(claimed.ItemID, PriorityLive)})
+
+	for _, candidate := range queue.Snapshot() {
+		if candidate.ItemID == claimed.ItemID {
+			t.Fatal("a refresh re-queued an episode already being scanned")
+		}
+	}
+	queue.Release(claimed.ItemID)
+	if queue.Push(queued(claimed.ItemID, PriorityNext)); queue.Len() != 2 {
+		t.Fatalf("queue length %d after release, want 2", queue.Len())
+	}
+}
+
+func TestClaimedItemsAreNotReQueued(t *testing.T) {
+	queue := NewQueue(10)
+	queue.Push(queued("bb-s06e08", PriorityNext))
+	claimed, _ := queue.Claim()
+
+	if queue.Push(queued(claimed.ItemID, PriorityLive)) {
+		t.Fatal("an episode being scanned was queued a second time")
+	}
+}
+
+func TestEmptyQueueClaimsNothing(t *testing.T) {
+	if _, found := NewQueue(5).Claim(); found {
+		t.Fatal("an empty queue produced work")
+	}
+}
+
+func TestQueueOrderIsTotalAndStable(t *testing.T) {
+	queue := NewQueue(10)
+	older := now.Add(-2 * time.Hour)
+	queue.Push(Candidate{ItemID: "b", Priority: PriorityNext, LastViewed: older})
+	queue.Push(Candidate{ItemID: "a", Priority: PriorityNext, LastViewed: now})
+
+	// Equal priority: the more recent demand goes first.
+	candidate, _ := queue.Claim()
+	if candidate.ItemID != "a" {
+		t.Fatalf("claimed %q; more recent demand should win a tie", candidate.ItemID)
+	}
+}