import { afterEach, describe, expect, it, vi } from "vitest"; import type { InstalledHttpOperationExecutor } from "../../src/adapters/http/index.ts"; import type { ProductCredentialProvider } from "../../src/bootstrap/product-composition-contract.ts"; import { createRuntimeAdapters } from "../../src/bootstrap/runtime-adapters.ts"; import { TEST_LIST_HTTP_CONTRACT } from "../helpers/external-contract-fixture.ts"; import { testRuntimeConfig } from "../helpers/runtime-config.ts"; /** * 09-02. The composition root alone decides the order a credential is looked * for, so a product credential provider can never run outside the fences: * * scope fence -> ANONYMOUS profile -> product provider -> session -> scope fence again * * Each row runs the real `createRuntimeAdapters`. Replaced: the installed * contract set (adds the fixture operations), the feature-input composer (to * reach the `http` capability) and the product-owned composition file (the * provider table under test). */ const fixture = vi.hoisted(() => ({ http: undefined as InstalledHttpOperationExecutor | undefined, providers: {} as Record, onCredentialRejected: undefined as ((binding: unknown) => void) | undefined, withProfile( contract: T, operationId: string, authProfileId: string, ): T { return { ...contract, contract: { ...contract.contract, operationId }, frontend: { ...contract.frontend, authProfileId }, }; }, })); vi.mock("../../src/features/installed-contract-contributions.ts", async (importOriginal) => { const original = await importOriginal(); const { TEST_CONTRACT_CONTRIBUTION, TEST_LIST_HTTP_CONTRACT: list } = await import("../helpers/external-contract-fixture.ts"); const source = TEST_CONTRACT_CONTRIBUTION.source; if (source.kind !== "EXTERNAL_PACKAGE") throw new Error("fixture source changed"); return { ...original, createInstalledContractRegistry: () => { const registry = original.createInstalledContractRegistry([ ...original.EXPECTED_CONTRACT_SET_PACKAGES, source.package, ]); registry.install(TEST_CONTRACT_CONTRIBUTION.featureId, [ { ...TEST_CONTRACT_CONTRIBUTION, http: [ list, fixture.withProfile(list, "TEST_LIST_ENTITIES_BEARER", "EXTERNAL_BEARER"), ] as typeof TEST_CONTRACT_CONTRIBUTION.http, }, ]); return registry; }, }; }); vi.mock("../../src/features/installed-feature-adapters.ts", async (importOriginal) => { const original = await importOriginal(); return { ...original, createInstalledFeatureLoaders: ( ...args: Parameters ) => { fixture.http = Reflect.get(args[0], "http") as typeof fixture.http; return original.createInstalledFeatureLoaders(...args); }, }; }); /** The product-owned file, filled the way a product fills it. */ vi.mock("../../src/bootstrap/product-composition.ts", () => ({ composeProductSessionOwner: () => null, composeProduct: () => ({ capabilities: {}, credentialProviders: fixture.providers, ...(fixture.onCredentialRejected === undefined ? {} : { onCredentialRejected: fixture.onCredentialRejected }), }), })); type Runtime = Parameters[0]["runtime"]; type Adapters = Awaited>; function runtimeFor(authMode: "demo" | "external"): Runtime { return { config: testRuntimeConfig({ APP_ENV: "local", API_BASE_URL: "http://localhost:8080", TELEMETRY_ENABLED: false, AUTH_MODE: authMode, 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, }; } const release: Parameters[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" }, }; const ANONYMOUS_OPERATION = TEST_LIST_HTTP_CONTRACT; /** The only non-anonymous profile the template installs. */ const PROFILE_OPERATION = fixture.withProfile( TEST_LIST_HTTP_CONTRACT, "TEST_LIST_ENTITIES_BEARER", "EXTERNAL_BEARER", ); 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: vi.fn(async () => ({ headers: { authorization: "Bearer owner-token" }, })), recoverSession: async () => "no-session", notifyUnauthenticated: () => {}, switchUser() { subject = "user-b"; for (const listener of listeners) listener(); }, }; } let current: Adapters | undefined; afterEach(() => { current?.infrastructure.dispose(); current = undefined; fixture.http = undefined; fixture.providers = {}; fixture.onCredentialRejected = undefined; }); async function compose( authMode: "demo" | "external", host: Record = {}, respond: () => Response = () => Response.json([{ id: "entity-1", name: "Entity" }]), ) { const fetcher = vi.fn(async (_input: RequestInfo | URL, _init?: RequestInit) => respond(), ); current = await createRuntimeAdapters({ runtime: runtimeFor(authMode), release, host, fetcher: fetcher as unknown as typeof fetch, }); const http = fixture.http; if (!http) throw new Error("The http capability was not composed"); return { adapters: current, http, fetcher }; } const productToken: ProductCredentialProvider = async () => ({ kind: "READY", headers: { authorization: "Bearer product-token" }, }); type Row = Readonly<{ step: string; /** Builds the product provider table; may close over the composed state. */ providers: (owner: ReturnType) => Record; authMode: "demo" | "external"; /** Runs after composition, before the request. */ before?: (adapters: Adapters) => void; operation: typeof PROFILE_OPERATION; outcome: Record; sentAuthorization: string | null; providerCalls: number; ownerCalls: number; }>; const ROWS: readonly Row[] = [ { step: "1 scope fence comes before the product provider", providers: () => ({ EXTERNAL_BEARER: productToken }), authMode: "demo", // The session change fences the scope synchronously; READY comes later. before: (adapters) => void adapters.outputPorts.session.beginSignIn(), operation: PROFILE_OPERATION, outcome: { kind: "CONTRACT_VIOLATION", violation: { kind: "SCOPE_FENCED" } }, sentAuthorization: null, providerCalls: 0, ownerCalls: 0, }, { step: "2 an ANONYMOUS profile never reaches a provider", providers: () => ({ ANONYMOUS: productToken }), authMode: "demo", operation: ANONYMOUS_OPERATION, outcome: { kind: "SUCCESS" }, sentAuthorization: null, providerCalls: 0, ownerCalls: 0, }, { step: "3 a registered provider answers before the session (signed out)", providers: () => ({ EXTERNAL_BEARER: productToken }), authMode: "demo", operation: PROFILE_OPERATION, outcome: { kind: "SUCCESS" }, sentAuthorization: "Bearer product-token", providerCalls: 1, ownerCalls: 0, }, { step: "3 a registered provider answers before the external owner", providers: () => ({ EXTERNAL_BEARER: productToken }), authMode: "external", operation: PROFILE_OPERATION, outcome: { kind: "SUCCESS" }, sentAuthorization: "Bearer product-token", providerCalls: 1, ownerCalls: 0, }, { step: "4 a profile without a provider still needs the session", providers: () => ({}), authMode: "demo", operation: PROFILE_OPERATION, outcome: { kind: "UNAUTHENTICATED", effect: "NOT_APPLICABLE" }, sentAuthorization: null, providerCalls: 0, ownerCalls: 0, }, { step: "5 the scope fence is checked again after the provider answers", providers: (owner) => ({ EXTERNAL_BEARER: async (...args) => { owner.switchUser(); return productToken(...args); }, }), authMode: "external", operation: PROFILE_OPERATION, // A fence during the credential wait aborts the transport (Q-6.3-6). The // composition root's own re-check behind it is not visible from here. outcome: { kind: "TRANSPORT_FAILURE", failure: { kind: "ABORTED_BY_SCOPE" } }, sentAuthorization: null, providerCalls: 1, ownerCalls: 0, }, { step: "6 a provider that throws fails closed", providers: () => ({ EXTERNAL_BEARER: async () => { throw new Error("product provider down"); }, }), authMode: "demo", operation: PROFILE_OPERATION, outcome: { kind: "AUTH_INTEGRATION_FAILURE", reason: "CREDENTIAL_OWNER_FAILED", }, sentAuthorization: null, providerCalls: 1, ownerCalls: 0, }, ]; describe("09-02 credential order in the composition root", () => { it.each(ROWS)("$step", async (row) => { const owner = externalOwner(); const providerCalls = vi.fn(); fixture.providers = Object.fromEntries( Object.entries(row.providers(owner)).map(([profileId, provider]) => [ profileId, ((...args) => { providerCalls(profileId); return provider(...args); }) satisfies ProductCredentialProvider, ]), ); const { http, fetcher, adapters } = await compose( row.authMode, row.authMode === "external" ? { __CA_FRONTEND_AUTH_OWNER__: owner } : {}, ); row.before?.(adapters); const outcome = await http.execute( row.operation, { limit: 1 }, { routeId: "TEST_ROUTE" }, ); expect(outcome).toMatchObject(row.outcome); expect(providerCalls).toHaveBeenCalledTimes(row.providerCalls); expect(owner.attachCredential).toHaveBeenCalledTimes(row.ownerCalls); if (row.sentAuthorization === null) { for (const [, init] of fetcher.mock.calls) { expect(new Headers(init?.headers).has("authorization")).toBe(false); } } else { expect(fetcher).toHaveBeenCalledOnce(); expect( new Headers(fetcher.mock.calls[0]?.[1]?.headers).get("authorization"), ).toBe(row.sentAuthorization); } }); }); /** * 1103/09-01. A 401 to a credential a product provider supplied is the * provider's verdict, not the template session's: the session did not supply * that credential. The product hears it through `onCredentialRejected`. */ describe("1103/09-01 a 401 to a product provider's credential", () => { const unauthorized = () => new Response(null, { status: 401 }); it("leaves the session alone and tells the product", async () => { const owner = externalOwner(); const notifyUnauthenticated = vi.spyOn(owner, "notifyUnauthenticated"); const rejected = vi.fn(); fixture.providers = { EXTERNAL_BEARER: productToken }; fixture.onCredentialRejected = rejected; const { http, adapters } = await compose( "external", { __CA_FRONTEND_AUTH_OWNER__: owner }, unauthorized, ); const scope = adapters.infrastructure.serverStateScope.getSnapshot(); const outcome = await http.execute( PROFILE_OPERATION, { limit: 1 }, { routeId: "TEST_ROUTE" }, ); expect(outcome.kind).toBe("UNAUTHENTICATED"); expect(notifyUnauthenticated).not.toHaveBeenCalled(); expect(scope.isCurrent()).toBe(true); expect(rejected).toHaveBeenCalledExactlyOnceWith({ operationId: "TEST_LIST_ENTITIES_BEARER", authProfileId: "EXTERNAL_BEARER", }); }); it("keeps the outcome when the product hook throws", async () => { fixture.providers = { EXTERNAL_BEARER: productToken }; fixture.onCredentialRejected = () => { throw new Error("product hook defect"); }; const { http } = await compose("demo", {}, unauthorized); const outcome = await http.execute( PROFILE_OPERATION, { limit: 1 }, { routeId: "TEST_ROUTE" }, ); expect(outcome.kind).toBe("UNAUTHENTICATED"); }); it("does not call the product hook for the session's own credential", async () => { const rejected = vi.fn(); fixture.onCredentialRejected = rejected; const owner = externalOwner(); const notifyUnauthenticated = vi.spyOn(owner, "notifyUnauthenticated"); const { http } = await compose( "external", { __CA_FRONTEND_AUTH_OWNER__: owner }, unauthorized, ); await http.execute(PROFILE_OPERATION, { limit: 1 }, { routeId: "TEST_ROUTE" }); expect(notifyUnauthenticated).toHaveBeenCalledOnce(); expect(rejected).not.toHaveBeenCalled(); }); });