Files
clean-architecture-frontend…/tests/recipes/browser-file-session-capability.test.ts
T
DongHyeonka b9524cfdd5 test(storage): scope participant 조립 테스트가 제품 설정 기본값을 같이 받는다
문제
fix/r1103-storage가 더한 browser-file-session-capability·
runtime-adapters-product-scope-participants 테스트는 RuntimeConfig를
글자 그대로 적는다. fix/r1103-app(09-02)의 제품 확장 타입 검사
테스트가 이 두 파일에서 TS2322로 실패한다(9b9d62a와 같은 원인).

고른 방법
- 두 테스트도 testRuntimeConfig로 설정을 만든다.

위험·한계
- 동작 변경은 없다.

검증
- tests/unit/product-extension-typecheck.test.ts, 두 테스트, test:recipes,
  lint 통과.

Refs: docs/reviews/2026-11-03-maturity-review/02-adapters-browser-files-cache.md 02-01
2026-11-04 21:50:30 +09:00

286 lines
8.5 KiB
TypeScript

// @vitest-environment jsdom
import { afterEach, describe, expect, it, vi } from "vitest";
import type { LocalFileRef } from "../../src/application/ports/browser-file-storage/index.ts";
import {
browserFilePolicyReference,
createBrowserFileRuntime,
type BrowserFilePolicyProfile,
} from "../../src/adapters/browser-files/index.ts";
import { createRuntimeAdapters } from "../../src/bootstrap/runtime-adapters.ts";
import { createSessionBrowserFileCapability } from "../../recipes/frontend-capabilities/browser-file-session-capability.ts";
import { testRuntimeConfig } from "../helpers/runtime-config.ts";
/**
* 2026-11-03 02-01. A product wires the browser file runtime to the session by
* filling only its own `product-composition.ts`: the recipe capability goes to
* features, its scope participant to the template. The real
* `createRuntimeAdapters` runs; only the product-owned file is replaced, with
* what a product would write in it.
*/
const selectPolicy = browserFilePolicyReference("session-file", "select-text");
const downloadPolicy = browserFilePolicyReference(
"session-download",
"bounded-generated-bin",
);
const policies: readonly BrowserFilePolicyProfile[] = [
{
reference: selectPolicy,
selection: {
policyId: "attachment-v1",
purpose: "attachment",
classification: "PERSONAL",
multiple: false,
maxCount: 1,
maxFileBytes: 8,
maxTotalBytes: 8,
allowEmpty: false,
accept: [{ mediaType: "text/plain", extensions: [".txt"] }],
},
},
{
reference: downloadPolicy,
download: {
strategy: "BOUNDED_OBJECT_URL",
mediaType: "application/octet-stream",
safeExtension: ".bin",
maxTransferBytes: 8,
maxBufferedBytes: 8,
integrity: "OPTIONAL",
},
},
];
const fixture = vi.hoisted(() => ({
files: undefined as
| ReturnType<typeof createSessionBrowserFileCapability>["files"]
| undefined,
inputs: [] as HTMLInputElement[],
handoffs: 0,
owner: undefined as
| Readonly<{ switchUser(subject: string): void }>
| undefined,
}));
function fileInput(): HTMLInputElement {
const input = document.createElement("input");
input.type = "file";
input.setAttribute("aria-label", "Attachment");
Object.defineProperty(input, "click", { configurable: true, value: vi.fn() });
document.body.append(input);
fixture.inputs.push(input);
return input;
}
function externalOwner() {
const listeners = new Set<() => void>();
let subject = "user-a";
return {
readState: () => "authenticated",
readSubject: () => subject,
subscribe(listener: () => void) {
listeners.add(listener);
return () => listeners.delete(listener);
},
beginSignIn: async () => {},
signOut: async () => {},
attachCredential: async () => ({ headers: {} }),
recoverSession: async () => "no-session",
notifyUnauthenticated: () => {},
switchUser(next: string) {
subject = next;
for (const listener of listeners) listener();
},
};
}
/** The product-owned file, filled the way a product fills it. */
vi.mock("../../src/bootstrap/product-composition.ts", () => ({
composeProductSessionOwner: () => {
const owner = externalOwner();
fixture.owner = owner;
return owner;
},
composeProduct: () => {
const browserFiles = createSessionBrowserFileCapability(() =>
createBrowserFileRuntime({
input: fileInput(),
policies,
limits: {
hardMaxPreviewBytes: 8,
hardMaxObjectUrlBytes: 8,
hardMaxTransferBytes: 16,
},
objectUrlApi: {
createObjectURL: () => "blob:session-download",
revokeObjectURL() {},
},
download: {
host: {
handoff() {
fixture.handoffs += 1;
},
},
browserManagedCapabilities: {
resolve: () => ({
ok: false as const,
error: {
code: "POLICY_REJECTED" as const,
operation: "DOWNLOAD" as const,
retryable: false,
recovery: "NONE" as const,
},
}),
},
},
}),
);
fixture.files = browserFiles.files;
return {
capabilities: {},
credentialProviders: {},
scopeParticipants: [browserFiles.scopeParticipant],
};
},
}));
let current: Awaited<ReturnType<typeof createRuntimeAdapters>> | undefined;
afterEach(() => {
current?.infrastructure.dispose();
current = undefined;
for (const input of fixture.inputs.splice(0)) input.remove();
fixture.files = undefined;
fixture.handoffs = 0;
});
async function compose() {
current = await createRuntimeAdapters({
runtime: {
config: testRuntimeConfig({
APP_ENV: "local",
API_BASE_URL: "http://localhost:8080",
TELEMETRY_ENABLED: false,
AUTH_MODE: "external",
REQUEST_TIMEOUT_MS: 10_000,
MAX_RETRY_ATTEMPTS: 0,
RELEASE_MANIFEST_URL: "/release-manifest.json",
CONFIG_SCHEMA_VERSION: "2.0",
CAPABILITY_OVERRIDES: {
REALTIME: "DEFAULT",
WEB_WORKER: "DEFAULT",
SERVICE_WORKER: "DEFAULT",
OFFLINE_COMMANDS: "DEFAULT",
},
FEATURE_OVERRIDES: {},
}),
configSchema: "V2",
build: {
buildId: "build-a",
commitSha: "abc123",
routerBasePath: "/",
runtimeConfigUrl: "/config.json",
},
validationDurationMs: 0,
},
release: {
schemaVersion: 2,
appVersion: "0.1.0",
buildId: "build-a",
commitSha: "abc123",
configSchemaVersion: "2.0",
contractSet: {
setAlgorithm: "CA_CONTRACT_SET_V1",
setDigest: `sha256:${"0".repeat(64)}`,
packages: [],
},
assetManifestHash: "hash-a",
releaseId: "release-a",
builtAt: "2026-07-25T00:00:00Z",
routeChunks: { "route-home": "assets/home.js" },
},
host: {},
});
const files = fixture.files;
const owner = fixture.owner;
if (!files || !owner) throw new Error("The product composition did not run");
return { adapters: current, files, owner };
}
async function selectOne(
runtime: ReturnType<NonNullable<typeof fixture.files>["current"]>,
name: string,
) {
const pending = runtime.baselinePicker.select({ policy: selectPolicy });
const input = fixture.inputs.at(-1)!;
Object.defineProperty(input, "files", {
configurable: true,
value: [new File(["text"], name, { type: "text/plain", lastModified: 1 })],
});
input.dispatchEvent(new Event("change"));
return await pending;
}
describe("a session-scoped browser file runtime (2026-11-03 02-01)", () => {
it("closes the previous user's files and downloads on an account switch and serves the next session a new runtime", async () => {
const { adapters, files, owner } = await compose();
const previous = files.current();
const selected = await selectOne(previous, "user-a.txt");
if (!selected.ok || selected.value.kind !== "SELECTED") {
throw new Error(`The first selection failed: ${JSON.stringify(selected)}`);
}
const ref: LocalFileRef = selected.value.files[0]!.ref;
let producing!: () => void;
const started = new Promise<void>((resolve) => {
producing = resolve;
});
const download = previous.downloads.deliver({
policy: downloadPolicy,
source: {
kind: "GENERATED",
bytes: {
byteLength: 1,
async *stream() {
producing();
await new Promise(() => {});
yield { ok: true as const, value: new Uint8Array([1]) };
},
},
},
suggestedFileName: "user-a-report",
maxTransferBytes: 8,
maxBufferedBytes: 8,
signal: new AbortController().signal,
onProgress() {},
});
await started;
owner.switchUser("user-b");
await vi.waitFor(() =>
expect(adapters.infrastructure.serverStateScope.getPhase()).toBe("READY"),
);
expect(
await previous.content.readRange({
ref,
offset: 0,
length: 1,
signal: new AbortController().signal,
}),
).toMatchObject({ ok: false, error: { code: "UNAVAILABLE" } });
expect(await download).toMatchObject({
ok: false,
error: { code: "ABORTED", operation: "DOWNLOAD" },
});
expect(fixture.handoffs).toBe(0);
const next = files.current();
expect(next).not.toBe(previous);
expect(await selectOne(next, "user-b.txt")).toMatchObject({
ok: true,
value: { kind: "SELECTED" },
});
});
});