@digitalpaws/starr 0.0.1

package/tests/state-store.test.ts

@@ -0,0 +1,700 @@
+// SPDX-License-Identifier: 0BSD
+// SPDX-FileCopyrightText: 2025 Digi <digitalpaws@proton.me>
+
+import { describe, it, expect } from "vitest";
+import Database from "better-sqlite3";
+import { EventBusImpl } from "../src/events/event-bus.js";
+import { createLogger } from "../src/logging/logger.js";
+import { runMigrations, CORE_MIGRATIONS } from "../src/datastore/migrations.js";
+import { StateStore } from "../src/state/state-store.js";
+import { requestIntake } from "../src/state/request-intake.js";
+import { ContentTypeRegistryImpl } from "../src/content-types/registry.js";
+import type { EventBus } from "../src/types/plugin.js";
+import type { ContentItemBase } from "@digitalpaws/starr-types-core";
+
+// ── Helpers ──────────────────────────────────────────────────────────
+
+function setup() {
+  // In-memory database with schema
+  const db = new Database(":memory:");
+  db.pragma("journal_mode = WAL");
+  db.pragma("foreign_keys = ON");
+  const logger = createLogger("test", "silent");
+  runMigrations(db, CORE_MIGRATIONS, logger);
+
+  // Real event bus
+  const impl = new EventBusImpl(logger);
+  const coreBus: EventBus = impl.coreBus();
+
+  // Content type registry with a movie descriptor for identity tests
+  const registry = new ContentTypeRegistryImpl();
+  registry.register({
+    id: "starr-video/movie@1",
+    name: "Movie",
+    identity: ["tmdb", "imdb"],
+    fields: [],
+  });
+
+  // State store
+  const store = new StateStore(db, coreBus, logger);
+
+  return { db, impl, coreBus, registry, store };
+}
+
+/** Minimal movie item for tests. */
+function movieItem(tmdbId: string): ContentItemBase {
+  return {
+    contentTypeId: "starr-video/movie@1",
+    title: `Movie ${tmdbId}`,
+    externalIds: { tmdb: tmdbId },
+  };
+}
+
+// ── State transitions (happy path) ──────────────────────────────────
+
+describe("state transitions (happy path)", () => {
+  it("requested → searching → downloading → downloaded", () => {
+    const { coreBus, registry, store } = setup();
+
+    // Insert a requested request directly (simulating intake)
+    const reqId = "req-001";
+    store.insert({
+      requestId: reqId,
+      contentTypeId: "starr-video/movie@1",
+      contentIdentity: "starr-video/movie@1::tmdb=123",
+      item: movieItem("123"),
+      ownerUserId: "admin",
+    });
+
+    let req = store.getByRequestId(reqId)!;
+    expect(req.status).toBe("requested");
+
+    // Emit release.found → searching
+    coreBus.emit("release.found", { requestId: reqId, contentTypeId: "starr-video/movie@1", release: {} });
+    req = store.getByRequestId(reqId)!;
+    expect(req.status).toBe("searching");
+
+    // Emit download.started → downloading
+    coreBus.emit("download.started", { requestId: reqId, release: { id: "rel-1", title: "Dune 1080p" } });
+    req = store.getByRequestId(reqId)!;
+    expect(req.status).toBe("downloading");
+    expect(req.chosenReleaseId).toBe("rel-1");
+    expect(req.attempts).toBe(1);
+
+    // Emit download.completed → downloaded (terminal)
+    coreBus.emit("download.completed", { requestId: reqId, release: {} });
+    req = store.getByRequestId(reqId)!;
+    expect(req.status).toBe("downloaded");
+  });
+
+  it("any state → failed via request.failed (terminal)", () => {
+    const { coreBus, store } = setup();
+
+    const reqId = "req-002";
+    store.insert({
+      requestId: reqId,
+      contentTypeId: "starr-video/movie@1",
+      contentIdentity: "starr-video/movie@1::tmdb=456",
+      item: movieItem("456"),
+      ownerUserId: "admin",
+    });
+
+    // Move to searching first
+    coreBus.emit("release.found", { requestId: reqId, contentTypeId: "starr-video/movie@1", release: {} });
+    expect(store.getByRequestId(reqId)!.status).toBe("searching");
+
+    // Terminal failure
+    coreBus.emit("request.failed", { requestId: reqId, reason: "no acceptable candidates" });
+    const req = store.getByRequestId(reqId)!;
+    expect(req.status).toBe("failed");
+    expect(req.statusDetail).toBe("no acceptable candidates");
+  });
+
+  it("download.failed is transient: downloading → searching with retry detail", () => {
+    const { coreBus, store } = setup();
+
+    const reqId = "req-003";
+    store.insert({
+      requestId: reqId,
+      contentTypeId: "starr-video/movie@1",
+      contentIdentity: "starr-video/movie@1::tmdb=789",
+      item: movieItem("789"),
+      ownerUserId: "admin",
+    });
+
+    // Move to downloading
+    coreBus.emit("release.found", { requestId: reqId, contentTypeId: "starr-video/movie@1", release: {} });
+    coreBus.emit("download.started", { requestId: reqId, release: { id: "rel-2" } });
+    expect(store.getByRequestId(reqId)!.status).toBe("downloading");
+    expect(store.getByRequestId(reqId)!.attempts).toBe(1);
+
+    // Transient failure → back to searching, NOT failed
+    coreBus.emit("download.failed", { requestId: reqId, release: {}, error: "connection reset" });
+    const req = store.getByRequestId(reqId)!;
+    expect(req.status).toBe("searching");
+    expect(req.statusDetail).toContain("retrying");
+    expect(req.statusDetail).toContain("attempt 1");
+  });
+
+  it("multiple release.found events keep status at searching", () => {
+    const { coreBus, store } = setup();
+
+    const reqId = "req-004";
+    store.insert({
+      requestId: reqId,
+      contentTypeId: "starr-video/movie@1",
+      contentIdentity: "starr-video/movie@1::tmdb=999",
+      item: movieItem("999"),
+      ownerUserId: "admin",
+    });
+
+    // First release.found: requested → searching
+    coreBus.emit("release.found", { requestId: reqId, contentTypeId: "starr-video/movie@1", release: { title: "A" } });
+    expect(store.getByRequestId(reqId)!.status).toBe("searching");
+
+    // Second release.found: stays searching
+    coreBus.emit("release.found", { requestId: reqId, contentTypeId: "starr-video/movie@1", release: { title: "B" } });
+    expect(store.getByRequestId(reqId)!.status).toBe("searching");
+  });
+});
+
+// ── item.updated emission ───────────────────────────────────────────
+
+describe("item.updated emission", () => {
+  it("emits item.updated on each status transition", () => {
+    const { coreBus, store } = setup();
+    const updates: Array<{ requestId: string; status: string }> = [];
+
+    coreBus.on("item.updated", (e) => {
+      updates.push(e.payload as { requestId: string; status: string });
+    });
+
+    const reqId = "req-010";
+    store.insert({
+      requestId: reqId,
+      contentTypeId: "starr-video/movie@1",
+      contentIdentity: "starr-video/movie@1::tmdb=010",
+      item: movieItem("010"),
+      ownerUserId: "admin",
+    });
+
+    // Note: insert does NOT emit item.updated (the item was created,
+    // not transitioned). The first emission comes from the first
+    // observed spine event.
+
+    coreBus.emit("release.found", { requestId: reqId, contentTypeId: "starr-video/movie@1", release: {} });
+    coreBus.emit("download.started", { requestId: reqId, release: {} });
+    coreBus.emit("download.completed", { requestId: reqId, release: {} });
+
+    expect(updates.length).toBe(3);
+    expect(updates[0]).toEqual({ requestId: reqId, status: "searching" });
+    expect(updates[1]).toEqual({ requestId: reqId, status: "downloading" });
+    expect(updates[2]).toEqual({ requestId: reqId, status: "downloaded" });
+  });
+
+  it("includes detail in item.updated when present", () => {
+    const { coreBus, store } = setup();
+    const updates: Array<{ requestId: string; status: string; detail?: string }> = [];
+
+    coreBus.on("item.updated", (e) => {
+      updates.push(e.payload as { requestId: string; status: string; detail?: string });
+    });
+
+    const reqId = "req-011";
+    store.insert({
+      requestId: reqId,
+      contentTypeId: "starr-video/movie@1",
+      contentIdentity: "starr-video/movie@1::tmdb=011",
+      item: movieItem("011"),
+      ownerUserId: "admin",
+    });
+
+    // Move to downloading, then fail transiently
+    coreBus.emit("release.found", { requestId: reqId, contentTypeId: "starr-video/movie@1", release: {} });
+    coreBus.emit("download.started", { requestId: reqId, release: {} });
+    coreBus.emit("download.failed", { requestId: reqId, release: {}, error: "boom" });
+
+    // The download.failed event should include a detail
+    const failedUpdate = updates.find((u) => u.status === "searching" && u.detail);
+    expect(failedUpdate).toBeDefined();
+    expect(failedUpdate!.detail).toContain("retrying");
+  });
+});
+
+// ── Request intake de-duplication ───────────────────────────────────
+
+describe("request intake de-duplication", () => {
+  it("first request creates a new tracked request and emits content.requested", () => {
+    const { coreBus, registry, store } = setup();
+    let contentRequestedEmitted = false;
+
+    coreBus.on("content.requested", () => {
+      contentRequestedEmitted = true;
+    });
+
+    const requestId = requestIntake(
+      { userId: "admin", item: movieItem("111") },
+      store,
+      registry,
+      coreBus,
+      createLogger("test", "silent"),
+    );
+
+    expect(requestId).toBeTruthy();
+    expect(contentRequestedEmitted).toBe(true);
+
+    const req = store.getByRequestId(requestId)!;
+    expect(req.status).toBe("requested");
+    expect(req.ownerUserId).toBe("admin");
+    expect(req.contentIdentity).toContain("tmdb=111");
+  });
+
+  it("second request for same item attaches as watcher (DU2), does NOT re-emit content.requested", () => {
+    const { coreBus, registry, store } = setup();
+    let emitCount = 0;
+
+    coreBus.on("content.requested", () => {
+      emitCount++;
+    });
+
+    // First request
+    const firstId = requestIntake(
+      { userId: "admin", item: movieItem("222") },
+      store,
+      registry,
+      coreBus,
+      createLogger("test", "silent"),
+    );
+
+    expect(emitCount).toBe(1);
+
+    // Second request — same item, same user
+    const secondId = requestIntake(
+      { userId: "admin", item: movieItem("222") },
+      store,
+      registry,
+      coreBus,
+      createLogger("test", "silent"),
+    );
+
+    // Same requestId returned, NO second emission
+    expect(secondId).toBe(firstId);
+    expect(emitCount).toBe(1);
+  });
+
+  it("re-requesting a failed item creates a NEW request (DU3)", () => {
+    const { coreBus, registry, store } = setup();
+    let emitCount = 0;
+
+    coreBus.on("content.requested", () => {
+      emitCount++;
+    });
+
+    // First request
+    const firstId = requestIntake(
+      { userId: "admin", item: movieItem("333") },
+      store,
+      registry,
+      coreBus,
+      createLogger("test", "silent"),
+    );
+    expect(emitCount).toBe(1);
+
+    // Mark it as failed
+    coreBus.emit("request.failed", { requestId: firstId, reason: "no candidates" });
+    expect(store.getByRequestId(firstId)!.status).toBe("failed");
+
+    // Second request — should create NEW request, not re-attach
+    const secondId = requestIntake(
+      { userId: "admin", item: movieItem("333") },
+      store,
+      registry,
+      coreBus,
+      createLogger("test", "silent"),
+    );
+
+    expect(secondId).not.toBe(firstId);
+    expect(emitCount).toBe(2);
+
+    const newReq = store.getByRequestId(secondId)!;
+    expect(newReq.status).toBe("requested");
+  });
+
+  it("adds user to watchers on re-attach (different user)", () => {
+    const { coreBus, registry, store } = setup();
+
+    // First request by admin
+    const firstId = requestIntake(
+      { userId: "admin", item: movieItem("444") },
+      store,
+      registry,
+      coreBus,
+      createLogger("test", "silent"),
+    );
+
+    // Second request by alice — should add alice as watcher
+    const secondId = requestIntake(
+      { userId: "alice", item: movieItem("444") },
+      store,
+      registry,
+      coreBus,
+      createLogger("test", "silent"),
+    );
+
+    expect(secondId).toBe(firstId);
+
+    const req = store.getByRequestId(firstId)!;
+    expect(req.ownerUserId).toBe("admin");
+    expect(req.watchers).toContain("alice");
+  });
+});
+
+// ── resetAndRetry ────────────────────────────────────────────────
+
+describe("resetAndRetry", () => {
+  it("resets a failed request to requested", () => {
+    const { coreBus, registry, store } = setup();
+
+    const reqId = "retry-test-1";
+    store.insert({
+      requestId: reqId,
+      contentTypeId: "starr-video/movie@1",
+      contentIdentity: "starr-video/movie@1::tmdb=999",
+      item: movieItem("999"),
+      ownerUserId: "admin",
+    });
+
+    // Move to failed via spine event
+    coreBus.emit("request.failed", { requestId: reqId, reason: "test" });
+    expect(store.getByRequestId(reqId)!.status).toBe("failed");
+
+    store.resetAndRetry(reqId);
+
+    const updated = store.getByRequestId(reqId);
+    expect(updated).toBeDefined();
+    expect(updated!.status).toBe("requested");
+    expect(updated!.attempts).toBe(0);
+    expect(updated!.chosenReleaseId).toBeUndefined();
+  });
+
+  it("resets a downloaded request to requested", () => {
+    const { coreBus, registry, store } = setup();
+
+    const reqId = "retry-test-2";
+    store.insert({
+      requestId: reqId,
+      contentTypeId: "starr-video/movie@1",
+      contentIdentity: "starr-video/movie@1::tmdb=998",
+      item: movieItem("998"),
+      ownerUserId: "admin",
+    });
+
+    // Move to downloaded via spine events
+    coreBus.emit("release.found", { requestId: reqId, contentTypeId: "starr-video/movie@1", release: {} });
+    coreBus.emit("download.started", { requestId: reqId, release: {} });
+    coreBus.emit("download.completed", { requestId: reqId, release: {} });
+    expect(store.getByRequestId(reqId)!.status).toBe("downloaded");
+
+    store.resetAndRetry(reqId);
+
+    const updated = store.getByRequestId(reqId);
+    expect(updated).toBeDefined();
+    expect(updated!.status).toBe("requested");
+    expect(updated!.attempts).toBe(0);
+  });
+
+  it("clears chosenReleaseId on retry", () => {
+    const { coreBus, store } = setup();
+
+    const reqId = "retry-test-3";
+    store.insert({
+      requestId: reqId,
+      contentTypeId: "starr-video/movie@1",
+      contentIdentity: "starr-video/movie@1::tmdb=997",
+      item: movieItem("997"),
+      ownerUserId: "admin",
+    });
+
+    // Set a chosenReleaseId by going through downloading
+    coreBus.emit("release.found", { requestId: reqId, contentTypeId: "starr-video/movie@1", release: {} });
+    coreBus.emit("download.started", { requestId: reqId, release: { id: "rel-retry", title: "Test" } });
+    expect(store.getByRequestId(reqId)!.chosenReleaseId).toBe("rel-retry");
+
+    // Move to failed
+    coreBus.emit("request.failed", { requestId: reqId, reason: "test" });
+
+    // Retry should clear chosenReleaseId
+    store.resetAndRetry(reqId);
+
+    const updated = store.getByRequestId(reqId);
+    expect(updated!.status).toBe("requested");
+    expect(updated!.chosenReleaseId).toBeUndefined();
+  });
+});
+
+// ── Import transitions ───────────────────────────────────────────
+
+describe("import transitions", () => {
+  it("downloaded → importing via import.started", () => {
+    const { coreBus, store } = setup();
+
+    const reqId = "import-test-1";
+    store.insert({
+      requestId: reqId,
+      contentTypeId: "starr-video/movie@1",
+      contentIdentity: "starr-video/movie@1::tmdb=1001",
+      item: movieItem("1001"),
+      ownerUserId: "admin",
+    });
+
+    // Move to downloaded
+    coreBus.emit("release.found", { requestId: reqId, contentTypeId: "starr-video/movie@1", release: {} });
+    coreBus.emit("download.started", { requestId: reqId, release: {} });
+    coreBus.emit("download.completed", { requestId: reqId, release: {} });
+    expect(store.getByRequestId(reqId)!.status).toBe("downloaded");
+
+    // Emit import.started → importing
+    coreBus.emit("import.started", { requestId: reqId });
+    expect(store.getByRequestId(reqId)!.status).toBe("importing");
+  });
+
+  it("importing → imported via import.completed (terminal)", () => {
+    const { coreBus, store } = setup();
+
+    const reqId = "import-test-2";
+    store.insert({
+      requestId: reqId,
+      contentTypeId: "starr-video/movie@1",
+      contentIdentity: "starr-video/movie@1::tmdb=1002",
+      item: movieItem("1002"),
+      ownerUserId: "admin",
+    });
+
+    // Move to importing
+    coreBus.emit("release.found", { requestId: reqId, contentTypeId: "starr-video/movie@1", release: {} });
+    coreBus.emit("download.started", { requestId: reqId, release: {} });
+    coreBus.emit("download.completed", { requestId: reqId, release: {} });
+    coreBus.emit("import.started", { requestId: reqId });
+    expect(store.getByRequestId(reqId)!.status).toBe("importing");
+
+    // Emit import.completed → imported
+    coreBus.emit("import.completed", { requestId: reqId });
+    expect(store.getByRequestId(reqId)!.status).toBe("imported");
+  });
+
+  it("importing → downloaded via import.failed (with detail)", () => {
+    const { coreBus, store } = setup();
+
+    const reqId = "import-test-3";
+    store.insert({
+      requestId: reqId,
+      contentTypeId: "starr-video/movie@1",
+      contentIdentity: "starr-video/movie@1::tmdb=1003",
+      item: movieItem("1003"),
+      ownerUserId: "admin",
+    });
+
+    // Move to importing
+    coreBus.emit("release.found", { requestId: reqId, contentTypeId: "starr-video/movie@1", release: {} });
+    coreBus.emit("download.started", { requestId: reqId, release: {} });
+    coreBus.emit("download.completed", { requestId: reqId, release: {} });
+    coreBus.emit("import.started", { requestId: reqId });
+    expect(store.getByRequestId(reqId)!.status).toBe("importing");
+
+    // Emit import.failed → back to downloaded with detail
+    coreBus.emit("import.failed", { requestId: reqId, error: "disk full" });
+    const req = store.getByRequestId(reqId)!;
+    expect(req.status).toBe("downloaded");
+    expect(req.statusDetail).toContain("Import failed:");
+    expect(req.statusDetail).toContain("disk full");
+  });
+
+  it("imported is terminal — no further transitions", () => {
+    const { coreBus, store } = setup();
+
+    const reqId = "import-test-4";
+    store.insert({
+      requestId: reqId,
+      contentTypeId: "starr-video/movie@1",
+      contentIdentity: "starr-video/movie@1::tmdb=1004",
+      item: movieItem("1004"),
+      ownerUserId: "admin",
+    });
+
+    // Move to imported
+    coreBus.emit("release.found", { requestId: reqId, contentTypeId: "starr-video/movie@1", release: {} });
+    coreBus.emit("download.started", { requestId: reqId, release: {} });
+    coreBus.emit("download.completed", { requestId: reqId, release: {} });
+    coreBus.emit("import.started", { requestId: reqId });
+    coreBus.emit("import.completed", { requestId: reqId });
+    expect(store.getByRequestId(reqId)!.status).toBe("imported");
+
+    // These should NOT change the status
+    coreBus.emit("download.completed", { requestId: reqId, release: {} });
+    expect(store.getByRequestId(reqId)!.status).toBe("imported");
+
+    coreBus.emit("request.failed", { requestId: reqId, reason: "late failure" });
+    expect(store.getByRequestId(reqId)!.status).toBe("imported");
+
+    coreBus.emit("import.started", { requestId: reqId });
+    expect(store.getByRequestId(reqId)!.status).toBe("imported");
+
+    coreBus.emit("import.failed", { requestId: reqId, error: "x" });
+    expect(store.getByRequestId(reqId)!.status).toBe("imported");
+  });
+
+  it("import events for unknown requestId are silent (no throw)", () => {
+    const { coreBus, store } = setup();
+
+    // None of these should throw
+    expect(() => coreBus.emit("import.started", { requestId: "nonexistent" })).not.toThrow();
+    expect(() => coreBus.emit("import.completed", { requestId: "nonexistent" })).not.toThrow();
+    expect(() => coreBus.emit("import.failed", { requestId: "nonexistent", error: "x" })).not.toThrow();
+  });
+});
+
+// ── deleteRequest ─────────────────────────────────────────────────
+
+describe("deleteRequest", () => {
+  it("deletes an existing request and its trace entries", () => {
+    const { store } = setup();
+
+    store.insert({
+      requestId: "delete-test-1",
+      contentTypeId: "starr-video/movie@1",
+      contentIdentity: "starr-video/movie@1::tmdb=996",
+      item: movieItem("996"),
+      ownerUserId: "admin",
+    });
+    expect(store.getByRequestId("delete-test-1")).toBeDefined();
+
+    const result = store.deleteRequest("delete-test-1");
+    expect(result).toBe(true);
+    expect(store.getByRequestId("delete-test-1")).toBeUndefined();
+  });
+
+  it("returns false for a non-existent requestId", () => {
+    const { store } = setup();
+    const result = store.deleteRequest("non-existent-id");
+    expect(result).toBe(false);
+  });
+
+  it("deletes requests in any status", () => {
+    const { coreBus, store } = setup();
+
+    // Insert and transition to searching
+    const reqId = "delete-test-2";
+    store.insert({
+      requestId: reqId,
+      contentTypeId: "starr-video/movie@1",
+      contentIdentity: "starr-video/movie@1::tmdb=995",
+      item: movieItem("995"),
+      ownerUserId: "admin",
+    });
+    coreBus.emit("release.found", { requestId: reqId, contentTypeId: "starr-video/movie@1", release: {} });
+    expect(store.getByRequestId(reqId)!.status).toBe("searching");
+
+    // Delete while in active acquisition
+    const result = store.deleteRequest(reqId);
+    expect(result).toBe(true);
+    expect(store.getByRequestId(reqId)).toBeUndefined();
+  });
+});
+
+// ── Defensive / edge-case tests ─────────────────────────────────────
+
+describe("defensive behavior", () => {
+  it("spine events for unknown requestId are logged but do not throw", () => {
+    const { coreBus, store } = setup();
+
+    // None of these should throw
+    expect(() => coreBus.emit("release.found", { requestId: "nonexistent", release: {} })).not.toThrow();
+    expect(() => coreBus.emit("download.started", { requestId: "nonexistent", release: {} })).not.toThrow();
+    expect(() => coreBus.emit("download.completed", { requestId: "nonexistent", release: {} })).not.toThrow();
+    expect(() => coreBus.emit("download.failed", { requestId: "nonexistent", release: {}, error: "x" })).not.toThrow();
+    expect(() => coreBus.emit("request.failed", { requestId: "nonexistent", reason: "x" })).not.toThrow();
+  });
+
+  it("terminal states do not transition further", () => {
+    const { coreBus, store } = setup();
+
+    const reqId = "req-term";
+    store.insert({
+      requestId: reqId,
+      contentTypeId: "starr-video/movie@1",
+      contentIdentity: "starr-video/movie@1::tmdb=555",
+      item: movieItem("555"),
+      ownerUserId: "admin",
+    });
+
+    // Move to downloaded (terminal)
+    coreBus.emit("release.found", { requestId: reqId, contentTypeId: "starr-video/movie@1", release: {} });
+    coreBus.emit("download.started", { requestId: reqId, release: {} });
+    coreBus.emit("download.completed", { requestId: reqId, release: {} });
+    expect(store.getByRequestId(reqId)!.status).toBe("downloaded");
+
+    // These should not change the status
+    coreBus.emit("download.failed", { requestId: reqId, release: {}, error: "x" });
+    expect(store.getByRequestId(reqId)!.status).toBe("downloaded");
+
+    coreBus.emit("request.failed", { requestId: reqId, reason: "x" });
+    expect(store.getByRequestId(reqId)!.status).toBe("downloaded");
+  });
+
+  it("listByUser returns requests where user is owner or watcher", () => {
+    const { store } = setup();
+
+    // Owner: admin, watcher: alice
+    store.insert({
+      requestId: "r1",
+      contentTypeId: "starr-video/movie@1",
+      contentIdentity: "starr-video/movie@1::tmdb=100",
+      item: movieItem("100"),
+      ownerUserId: "admin",
+    });
+
+    // Owner: bob
+    store.insert({
+      requestId: "r2",
+      contentTypeId: "starr-video/movie@1",
+      contentIdentity: "starr-video/movie@1::tmdb=200",
+      item: movieItem("200"),
+      ownerUserId: "bob",
+    });
+
+    // Admin sees r1 (owner) but not r2 (bob's)
+    const adminList = store.listByUser("admin");
+    expect(adminList.map((r) => r.requestId)).toContain("r1");
+    expect(adminList.map((r) => r.requestId)).not.toContain("r2");
+
+    // Bob sees r2 (owner) but not r1 (admin's)
+    const bobList = store.listByUser("bob");
+    expect(bobList.map((r) => r.requestId)).toContain("r2");
+    expect(bobList.map((r) => r.requestId)).not.toContain("r1");
+  });
+
+  it("attempts counter increments on each download.started", () => {
+    const { coreBus, store } = setup();
+
+    const reqId = "req-att";
+    store.insert({
+      requestId: reqId,
+      contentTypeId: "starr-video/movie@1",
+      contentIdentity: "starr-video/movie@1::tmdb=600",
+      item: movieItem("600"),
+      ownerUserId: "admin",
+    });
+
+    expect(store.getByRequestId(reqId)!.attempts).toBe(0);
+
+    // First attempt
+    coreBus.emit("release.found", { requestId: reqId, contentTypeId: "starr-video/movie@1", release: {} });
+    coreBus.emit("download.started", { requestId: reqId, release: {} });
+    expect(store.getByRequestId(reqId)!.attempts).toBe(1);
+
+    // Transient fail, then retry
+    coreBus.emit("download.failed", { requestId: reqId, release: {}, error: "x" });
+    coreBus.emit("download.started", { requestId: reqId, release: {} });
+    expect(store.getByRequestId(reqId)!.attempts).toBe(2);
+  });
+});