feat(search): stream unsubscribed episodes directly; a subscribes in place

2026-08-11 14:01:46 -04:00
parent 1f0b9de456
commit 005ac8fde3
7 changed files with 380 additions and 4 deletions
--- a/tests/search-episode-actions.test.tsx
+++ b/tests/search-episode-actions.test.tsx
@@ -0,0 +1,344 @@
+/**
+ * search-episode-actions.test.tsx — episode search results must stream
+ * directly, subscribed or not, and `a` must subscribe an unsubscribed show
+ * in place.
+ *
+ * Regression: `enter` on an unsubscribed show's episode result used to
+ * subscribe instead of play — there was no direct "stream unsubscribed
+ * episode" path (subscribing first was the only way to hear it). `enter` now
+ * plays every episode result (matching Feed/My Shows), and the new `subscribe`
+ * action (`a`, sibling of `x` unsubscribe) subscribes the focused result.
+ *
+ * Mounts the real app (sandboxed, silent audio, mocked search store) and
+ * drives the Search tab with the test renderer's mock keys: enter on an
+ * unsubscribed episode plays it without subscribing; `a` subscribes (feed
+ * fetched from a local server); enter then plays the now-subscribed episode.
+ * The search store is mocked so results are deterministic (no directory
+ * network calls); the feed store is real and served from a local HTTP server.
+ *
+ * App modules are loaded dynamically (never statically) because the sandbox
+ * config/data dirs must be set BEFORE they evaluate — their module-level init
+ * reads those env vars at import time.
+ */
+
+import { test, expect, afterAll, beforeAll, mock } from "bun:test";
+import type { Server } from "bun";
+import { testRender } from "@opentui/solid";
+import { createSignal } from "solid-js";
+import { mkdirSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import type { AudioControls } from "../src/hooks/useAudio";
+import type { SearchResult, SearchScope } from "../src/types/source";
+import type { Episode } from "../src/types/episode";
+import type { Podcast } from "../src/types/podcast";
+import type { DepthFrame, NavigationState } from "../src/context/navigation-store";
+
+// Recording audio stub: `play` pushes what was streamed. Registered FIRST so
+// a leaked partial useAudio mock from another file in this worker can't break
+// the app mount (see tests/search-focus.test.tsx for the same hazard).
+const played: Episode[] = [];
+const stubAudio: AudioControls = {
+	isPlaying: () => false,
+	position: () => 0,
+	duration: () => 0,
+	volume: () => 1,
+	speed: () => 1,
+	backendName: () => "none",
+	error: () => null,
+	currentEpisode: () => null,
+	availablePlayers: () => [],
+	play: async (episode: Episode) => {
+		played.push(episode);
+	},
+	load: async () => {},
+	pause: async () => {},
+	resume: async () => {},
+	togglePlayback: async () => {},
+	stop: async () => {},
+	seek: async () => {},
+	seekRelative: async () => {},
+	setVolume: async () => {},
+	setSpeed: async () => {},
+	switchBackend: async () => {},
+	prev: async () => {},
+	next: async () => {},
+};
+mock.module("../src/hooks/useAudio", () => ({
+	useAudio: () => stubAudio,
+}));
+
+// Deterministic search store: `search` feeds the seeded results synchronously;
+// markSubscribed/markUnsubscribed flip the result's flag (SearchPage renders
+// it, and the real feed store still owns the actual subscription).
+const [scope, setScope] = createSignal<SearchScope>("episode");
+const [results, setResults] = createSignal<SearchResult[]>([]);
+const [query, setQuery] = createSignal("");
+const [isSearching, setIsSearching] = createSignal(false);
+const [error, setError] = createSignal<string | null>(null);
+const [history, setHistory] = createSignal<string[]>([]);
+const flip = (id: string, feedUrl: string | undefined, subscribed: boolean) =>
+	setResults((prev) =>
+		prev.map((r) =>
+			r.podcast.id === id ||
+			(feedUrl && r.podcast.feedUrl === feedUrl)
+				? { ...r, podcast: { ...r.podcast, isSubscribed: subscribed } }
+				: r,
+		),
+	);
+const mockSearchStore = {
+	query,
+	isSearching,
+	results,
+	error,
+	history,
+	selectedSources: () => [] as string[],
+	scope,
+	search: async () => {},
+	setQuery,
+	clearResults: () => setResults([]),
+	clearHistory: () => setHistory([]),
+	removeFromHistory: () => {},
+	setSelectedSources: () => {},
+	setScope,
+	markSubscribed: (id: string, feedUrl?: string) => flip(id, feedUrl, true),
+	markUnsubscribed: (id: string, feedUrl?: string) => flip(id, feedUrl, false),
+};
+mock.module("../src/stores/search", () => ({
+	useSearchStore: () => mockSearchStore,
+}));
+
+// Sandbox BEFORE any app module evaluates — config-dir/persistence read these
+// env vars at import time, so the app modules are loaded dynamically.
+const SANDBOX = join(process.cwd(), ".harness", "test-episode-actions");
+mkdirSync(join(SANDBOX, "config-home"), { recursive: true });
+mkdirSync(join(SANDBOX, "data-home"), { recursive: true });
+process.env.XDG_CONFIG_HOME = join(SANDBOX, "config-home");
+process.env.XDG_DATA_HOME = join(SANDBOX, "data-home");
+process.env.PODTUI_AUDIO_BACKEND = "none";
+
+const { App } = await import("../src/App");
+const { ThemeProvider } = await import("../src/context/ThemeContext");
+const toast = await import("../src/ui/toast");
+const { KeybindProvider, useKeybinds } = await import(
+	"../src/context/KeybindContext"
+);
+const { NavigationProvider, useNavigation } = await import(
+	"../src/context/NavigationContext"
+);
+const { DialogProvider } = await import("../src/ui/dialog");
+const { CommandProvider } = await import("../src/ui/command");
+const { TABS } = await import("../src/utils/navigation");
+const { useFeedStore } = await import("../src/stores/feed");
+
+// Local HTTP server serving one show's RSS feed (the feed store fetches it
+// when subscribing).
+let server: Server<unknown> | null = null;
+let feedUrl = "";
+let audioUrl = "";
+
+function feedXml(origin: string): string {
+	return `<?xml version="1.0" encoding="UTF-8"?>
+<rss version="2.0"><channel>
+<title>Stream Me Show</title>
+<description>Test feed</description>
+<item>
+<title>Ep 1</title>
+<pubDate>2026-08-01T00:00:00Z</pubDate>
+<enclosure url="${origin}/audio.mp3" length="12345" type="audio/mpeg"/>
+</item>
+</channel></rss>`;
+}
+
+function makeResult(): SearchResult {
+	const episode: Episode = {
+		id: "stream-ep-1",
+		podcastId: "dir-stream-me",
+		title: "Ep 1",
+		description: "",
+		audioUrl,
+		duration: 0,
+		pubDate: new Date("2026-08-01T00:00:00Z"),
+	};
+	const podcast: Podcast = {
+		id: "dir-stream-me",
+		title: "Stream Me Show",
+		description: "Test feed",
+		author: "tester",
+		feedUrl,
+		lastUpdated: new Date(),
+		isSubscribed: false,
+	};
+	return {
+		kind: "episode",
+		sourceId: "test",
+		sourceName: "Test",
+		podcast,
+		episode,
+	};
+}
+
+type MockInput = { pressKey: (key: string) => void; pressEnter: () => void };
+type Mounted = {
+	renderer: { destroy: () => void };
+	renderOnce: () => Promise<void>;
+	mockInput: MockInput;
+	nav: () => NavigationState;
+	keybindsReady: () => boolean;
+};
+
+async function mountApp(): Promise<Mounted> {
+	let navRef: NavigationState | null = null;
+	let keybindsRef: { ready: boolean } | null = null;
+	const StateProbe = () => {
+		navRef = useNavigation();
+		keybindsRef = useKeybinds();
+		return null;
+	};
+	const HarnessRoot = () => (
+		<toast.ToastProvider>
+			<ThemeProvider mode="dark">
+				<KeybindProvider>
+					<NavigationProvider>
+						<StateProbe />
+						<DialogProvider>
+							<CommandProvider>
+								<App />
+								<toast.Toast />
+							</CommandProvider>
+						</DialogProvider>
+					</NavigationProvider>
+				</KeybindProvider>
+			</ThemeProvider>
+		</toast.ToastProvider>
+	);
+	const setup = await testRender(() => <HarnessRoot />, {
+		width: 100,
+		height: 30,
+		useThread: false,
+	});
+	// The test renderer intercepts stdout; the app is a TUI that writes frames
+	// asynchronously, so silence that interception (same as search-focus).
+	(
+		setup.renderer as unknown as {
+			disableStdoutInterception?: () => void;
+		}
+	).disableStdoutInterception?.();
+	await setup.renderOnce();
+	await sleep(60);
+	return {
+		renderer: setup.renderer,
+		renderOnce: setup.renderOnce,
+		mockInput: setup.mockInput,
+		nav: () => navRef!,
+		keybindsReady: () => keybindsRef?.ready ?? false,
+	};
+}
+
+function sleep(ms: number): Promise<void> {
+	const { promise, resolve } = Promise.withResolvers<void>();
+	setTimeout(resolve, ms);
+	return promise;
+}
+
+async function settleReady(m: Mounted): Promise<void> {
+	for (let i = 0; i < 80; i++) {
+		await m.renderOnce();
+		await sleep(60);
+		if (m.keybindsReady()) return;
+	}
+	throw new Error("keybinds never became ready");
+}
+
+async function waitFor(
+	m: Mounted,
+	cond: () => boolean,
+	what: string,
+	timeoutMs = 5000,
+): Promise<void> {
+	const deadline = Date.now() + timeoutMs;
+	while (Date.now() < deadline) {
+		if (cond()) return;
+		await m.renderOnce();
+		await sleep(25);
+	}
+	throw new Error(`timed out waiting for: ${what}`);
+}
+
+beforeAll(() => {
+	server = Bun.serve({
+		port: 0,
+		fetch(req) {
+			const url = new URL(req.url);
+			if (url.pathname.endsWith(".xml")) {
+				return new Response(feedXml(url.origin), {
+					headers: { "Content-Type": "application/rss+xml" },
+				});
+			}
+			return new Response("audio bytes", {
+				headers: { "Content-Type": "audio/mpeg" },
+			});
+		},
+	});
+	feedUrl = `http://127.0.0.1:${server!.port}/show.xml`;
+	audioUrl = `http://127.0.0.1:${server!.port}/audio.mp3`;
+});
+
+afterAll(() => {
+	server?.stop(true);
+	rmSync(SANDBOX, { recursive: true, force: true });
+});
+
+test("enter streams an unsubscribed show's episode; a subscribes it in place; enter then still plays", async () => {
+	const m = await mountApp();
+	try {
+		await settleReady(m);
+
+		// Open the Search tab (digit press retried until the router attaches).
+		for (let i = 0; i < 20 && m.nav().activeTab() !== TABS.SEARCH; i++) {
+			m.mockInput.pressKey("4");
+			await m.renderOnce();
+			await sleep(40);
+		}
+		expect(m.nav().activeTab()).toBe(TABS.SEARCH);
+		m.mockInput.pressEnter(); // open the tab's content (query depth)
+		await waitFor(m, () => m.nav().inputFocused(), "search tab mounted");
+
+		// Seed one unsubscribed-show episode result and drill to results
+		// (mirrors SearchPage.runSearch: set results, push the frame).
+		setResults([makeResult()]);
+		const frame: DepthFrame = { kind: "search:results", ctx: "test", focus: 0 };
+		m.nav().pushDepth(frame);
+		m.nav().setActivePane(1);
+		await waitFor(m, () => m.nav().currentDepth() === 1, "results depth");
+
+		// enter → the episode streams; the show is NOT subscribed.
+		m.mockInput.pressEnter();
+		await waitFor(m, () => played.length === 1, "play called on enter");
+		expect(played[0].id).toBe("stream-ep-1");
+		expect(
+			useFeedStore()
+				.feeds()
+				.some((f) => f.podcast.feedUrl === feedUrl),
+		).toBe(false);
+		expect(mockSearchStore.results()[0].podcast.isSubscribed).toBe(false);
+
+		// a → subscribes in place (real feed fetch against the local server).
+		m.mockInput.pressKey("a");
+		await waitFor(
+			m,
+			() =>
+				useFeedStore()
+					.feeds()
+					.some((f) => f.podcast.feedUrl === feedUrl),
+			"a subscribes the show",
+		);
+		expect(mockSearchStore.results()[0].podcast.isSubscribed).toBe(true);
+
+		// enter again → still streams (now under the subscribed show).
+		m.mockInput.pressEnter();
+		await waitFor(m, () => played.length === 2, "play called after subscribe");
+		expect(played[1].id).toBe("stream-ep-1");
+	} finally {
+		m.renderer.destroy();
+	}
+});