Initial Commit

packages/media/audio-ir/audio-ir-room-plugin-pool/tests/integration/bundle-only.test.ts

@@ -0,0 +1,143 @@
+import { readFile, stat } from "node:fs/promises";
+import { fileURLToPath } from "node:url";
+import { decodeWav } from "@suaveplan/audio-decode-wav";
+import {
+    createIrRegistry,
+    createUriPluginCollector,
+} from "@suaveplan/audio-ir-core";
+import { createIrLoader } from "@suaveplan/audio-ir-loader";
+import {
+    createStorageUriResolver,
+    STORAGE_URI_CODES,
+    StorageUriError,
+    type UriPlugin,
+} from "@suaveplan/storage-uri";
+import { fallbackUriPlugin } from "@suaveplan/storage-uri-plugin-fallback";
+import type { FetchLike } from "@suaveplan/types";
+
+/**
+ * Minimal `file://` `FetchLike` for Node — Node's `globalThis.fetch` rejects
+ * `file://` URLs, so we substitute one that round-trips via `node:fs`. Lives
+ * in the test file by design (no new package introduced).
+ */
+const nodeFileFetch: FetchLike = async (input, init) => {
+    const url =
+        typeof input === "string"
+            ? new URL(input)
+            : input instanceof URL
+              ? input
+              : new URL((input as Request).url);
+    if (url.protocol !== "file:") {
+        return globalThis.fetch(
+            input as Parameters<typeof globalThis.fetch>[0],
+            init
+        );
+    }
+    const path = fileURLToPath(url);
+    try {
+        const bytes = await readFile(path);
+        const meta = await stat(path);
+        return new Response(bytes, {
+            status: 200,
+            headers: {
+                "content-length": String(meta.size),
+                "content-type": "application/octet-stream",
+            },
+        });
+    } catch (err) {
+        const code = (err as NodeJS.ErrnoException).code;
+        if (code === "ENOENT") {
+            return new Response(null, { status: 404 });
+        }
+        throw err;
+    }
+};
+
+import { describe, expect, it } from "@suaveplan/testing/runner";
+import { ENTRY_ID, manifest } from "../../src/manifest/manifest.js";
+import { register } from "../../src/register/register.js";
+
+/**
+ * Minimal in-test https `UriPlugin` wrapping `globalThis.fetch`. Lives in
+ * the test file by design — there is no shipped storage-uri plugin for
+ * https today, and the integration test must not introduce a new package.
+ */
+function makeHttpsPlugin(spy: { calls: number }): UriPlugin {
+    return {
+        scheme: "https",
+        adapter: {
+            async get(key: string) {
+                spy.calls += 1;
+                const url = `https://${key}`;
+                const res = await fetch(url);
+                if (res.status === 404) return undefined;
+                if (!res.ok) {
+                    throw new StorageUriError(
+                        STORAGE_URI_CODES.ADAPTER_ERROR,
+                        `HTTP ${res.status} from ${url}`,
+                        { uri: url, scheme: "https" }
+                    );
+                }
+                return new Uint8Array(await res.arrayBuffer());
+            },
+            async set() {
+                return;
+            },
+            async delete() {
+                return true;
+            },
+            async exists() {
+                spy.calls += 1;
+                return false;
+            },
+            async list() {
+                return { keys: [], total: 0, hasMore: false };
+            },
+            async clear() {
+                return;
+            },
+        },
+        parse(uri: string) {
+            const noScheme = uri.replace(/^https:\/\//, "");
+            return { key: noScheme };
+        },
+    };
+}
+
+describe("integration: bundle-only", () => {
+    it("bundle candidate wins without fetching HTTPS via foundation collector", {
+        timeout: 30000,
+    }, async () => {
+        const collector = createUriPluginCollector();
+        const registry = createIrRegistry();
+        register(registry, collector, { fetch: nodeFileFetch });
+
+        const spy = { calls: 0 };
+        const httpsPlugin = makeHttpsPlugin(spy);
+        collector.use(httpsPlugin);
+
+        const plugins: readonly UriPlugin[] = collector.plugins;
+        const innerResolver = createStorageUriResolver([...plugins]);
+        const fb = fallbackUriPlugin({
+            resolver: innerResolver,
+            policy: { errorClass: "any" },
+        });
+        const outerResolver = createStorageUriResolver([...plugins, fb]);
+
+        const loader = createIrLoader({
+            registry,
+            resolver: outerResolver,
+            decoders: { wav: decodeWav },
+        });
+
+        const ir = await loader.load(ENTRY_ID);
+        expect(ir.id).toBe(ENTRY_ID);
+        expect(ir.family).toBe("room");
+        expect(ir.channels).toBe(manifest.entries[0]?.channels);
+        expect(ir.sampleRate).toBe(manifest.entries[0]?.sampleRate);
+        expect(Object.isFrozen(ir)).toBe(true);
+
+        // Critical assertion: HTTPS adapter was never invoked.
+        expect(spy.calls).toBe(0);
+    });
+});