@o3co/create-auth-provider 0.17.0 → 0.18.0-rc.1

package/templates/standalone/src/__tests__/all-modules-composition.multi.test.mts

@@ -1,285 +0,0 @@
-/*
- * Copyright 2026 1o1 Co. Ltd.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-/**
- * The all-modules composition of `all-modules-composition.test.mts` on more
- * than one replica: every shared store on Redis, `core.deployment.mode = "multi"`,
- * every module the template can turn on switched on together.
- *
- * With every module on, the all-Redis composition boots with nothing declaring
- * replica-unsafe state, and each store switched back to memory is refused at
- * boot, naming the module. The Redis adapters change nothing a client can
- * see: the same routes, the same discovery document as on one replica.
- *
- * ioredis, node-redis and connect-redis are stand-ins, as in
- * `replica-safety.test.mts`: nothing here issues a command. `packages/redis`
- * runs its adapters against a real server.
- */
-
-import { type Module, replicaUnsafeReason } from "@o3co/auth-provider-core";
-import * as redisPackage from "@o3co/auth-provider-redis";
-import request from "supertest";
-import { afterEach, describe, expect, it, vi } from "vitest";
-import { readOwnLayers, resolveForBoot } from "#/configPath.mjs";
-import { standaloneRedisClientsModule } from "#/modules.mjs";
-import {
-	type Composition,
-	compose,
-	composedModules,
-	MULTI_ENV,
-	ownFiles,
-	resolveConfig,
-} from "./all-modules-composition.fixture.mjs";
-
-vi.mock("redis", () => ({
-	createClient: vi.fn(() => ({
-		connect: vi.fn().mockResolvedValue(undefined),
-		quit: vi.fn().mockResolvedValue(undefined),
-		ping: vi.fn().mockResolvedValue("PONG"),
-		on: vi.fn(),
-	})),
-}));
-
-vi.mock("connect-redis", async () => {
-	const { EventEmitter } = await import("node:events");
-	// express-session subscribes to store events, so the stand-in is an emitter.
-	return {
-		RedisStore: class MockRedisStore extends EventEmitter {
-			constructor(_opts: { client: unknown }) {
-				super();
-			}
-			get(): unknown {
-				return undefined;
-			}
-			set(): void {}
-			destroy(): void {}
-		},
-	};
-});
-
-vi.mock("ioredis", () => {
-	// Constructible, quits cleanly, answers the readiness probe's `ping`;
-	// every other command resolves to nothing.
-	const explicit: Record<string, unknown> = {
-		on: () => undefined,
-		quit: async () => "OK",
-		disconnect: () => undefined,
-		ping: async () => "PONG",
-		// The Redis stores' eviction gate reads the policy from INFO memory: a
-		// default server's.
-		info: async (section: string) =>
-			section === "memory" ? "# Memory\r\nmaxmemory_policy:noeviction\r\n" : null,
-	};
-	const makeMockRedis = (): object =>
-		new Proxy(
-			{},
-			{
-				get(_target, prop) {
-					// A function-valued `then` would make the instance a thenable.
-					if (typeof prop !== "string" || prop === "then") return undefined;
-					if (prop === "duplicate") return makeMockRedis;
-					if (prop in explicit) return explicit[prop];
-					return async () => null;
-				},
-			},
-		);
-	function MockRedis(): object {
-		return makeMockRedis();
-	}
-	return { Redis: MockRedis, default: MockRedis };
-});
-
-let current: Composition | undefined;
-
-afterEach(async () => {
-	await current?.handle.dispose();
-	current = undefined;
-});
-
-const MULTI = { env: MULTI_ENV, shippedRefreshTokenFamilyStore: true } as const;
-
-/** What `buildModules` lists with every switch on and every shared store on Redis. */
-const ALL_ON_REDIS_MODULES = [
-	"session-store",
-	"federation-grant-background",
-	"federation-grants",
-	"oauth",
-	"oauth-session",
-	"oauth-authorization",
-	"jwks",
-	"session",
-	"federation-google-type",
-	"federation-oidc",
-	"logging",
-	"http",
-	"key-store",
-	"test:repositories",
-	"audit-sink",
-	"standard-smtp-mail-sender",
-	"redis-clients",
-	"redis-federation-token-store",
-	"redis-federation-grant-store",
-	"redis-federation-grant-intent-store",
-	"redis-session-stores",
-	"core-session-lifecycle",
-	"redis-rate-limiter",
-	"redis-attempt-counter",
-	"redis-code-repository",
-	"redis-access-token-denylist",
-	"redis-replay-seen-set",
-	"redis-consent-store",
-	"redis-refresh-token-family-store",
-	"core-default-refresh-token-family-rotation",
-	"core-default-refresh-token-family-revocation",
-	"subject-revocation-service",
-];
-
-describe('every module on, every shared store on Redis, core.deployment.mode = "multi"', () => {
-	it("lists every module, none declaring replica-unsafe state, and boots", async () => {
-		const own = readOwnLayers(ownFiles(MULTI_ENV), { env: MULTI_ENV });
-		const config = resolveConfig(MULTI_ENV, own);
-		const modules = composedModules(config, MULTI);
-		expect(modules.map((m) => m.name)).toEqual(ALL_ON_REDIS_MODULES);
-		// Each module's section at its name, as boot is handed it: a
-		// declaration made from the section is answered for it.
-		const sections = resolveForBoot(own, modules, config) as unknown as Record<string, unknown>;
-		for (const module of modules) {
-			expect(replicaUnsafeReason(module, sections[module.name]), module.name).toBeUndefined();
-		}
-		current = await compose(MULTI);
-		expect(current.handle.readinessProbes.map((p) => p.name)).toContain("redis");
-	});
-
-	it("mounts the same routes and serves the same discovery document as one replica on memory", async () => {
-		current = await compose();
-		const single = {
-			routes: current.handle.routes.map((r) => r.contribution.id),
-			discovery: (await request(current.app).get("/.well-known/openid-configuration")).body,
-		};
-		await current.handle.dispose();
-		current = undefined;
-
-		current = await compose(MULTI);
-		expect(current.handle.routes.map((r) => r.contribution.id)).toEqual(single.routes);
-		const discovery = await request(current.app).get("/.well-known/openid-configuration");
-		expect(discovery.status).toBe(200);
-		expect(discovery.body).toEqual(single.discovery);
-	});
-
-	it("boots as multi on CORE_DEPLOYMENT_MODE=multi alone", async () => {
-		expect(MULTI_ENV).toMatchObject({ CORE_DEPLOYMENT_MODE: "multi" });
-		expect(MULTI_ENV).not.toHaveProperty("DEPLOYMENT_MODE");
-		current = await compose(MULTI);
-		expect(current.handle.components.deploymentMode).toBe("multi");
-	});
-
-	it("refuses DEPLOYMENT_MODE=multi beside CORE_DEPLOYMENT_MODE=multi: the old name must be unset", async () => {
-		await expect(
-			compose({
-				...MULTI,
-				env: { ...MULTI_ENV, DEPLOYMENT_MODE: "multi", CORE_DEPLOYMENT_MODE: "multi" },
-			}),
-		).rejects.toMatchObject({
-			reason: "environment-variable-renamed",
-			details: { renamed: [{ from: "DEPLOYMENT_MODE", state: "different" }] },
-		});
-	});
-
-	/**
-	 * Each store's switch back to memory, alone, with every module on. The
-	 * boot names the module that declared the state it would fork.
-	 */
-	const MEMORY_SWITCHES: ReadonlyArray<readonly [variable: string, module: string]> = [
-		["SESSION_STORE_STORAGE_TYPE", "session-store"],
-		["ADAPTERS_USER_SESSION_STORES", "standalone-in-memory-session-stores"],
-		["ADAPTERS_CODE_REPOSITORY", "standalone-in-memory-code-repository"],
-		["ADAPTERS_FEDERATION_TOKEN_STORE", "standalone-in-memory-federation-token-store"],
-		["ADAPTERS_RATE_LIMITER", "core-rate-limiter-memory"],
-		["ADAPTERS_ACCESS_TOKEN_DENYLIST", "core-access-token-denylist-memory"],
-		["ADAPTERS_REPLAY_SEEN_SET", "core-replay-seen-set-memory"],
-		["ADAPTERS_CONSENT_STORE", "core-consent-store-memory"],
-		["ADAPTERS_FEDERATION_GRANT_STORE", "core-federation-grant-store-memory"],
-		["ADAPTERS_FEDERATION_GRANT_INTENT_STORE", "core-federation-grant-intent-store-memory"],
-	];
-
-	it.each(MEMORY_SWITCHES)("%s=memory is refused at boot, naming %s", async (variable, module) => {
-		await expect(
-			compose({ ...MULTI, env: { ...MULTI_ENV, [variable]: "memory" } }),
-		).rejects.toMatchObject({
-			name: "BootError",
-			reason: "replica-unsafe-adapter",
-			details: { modules: [module] },
-		});
-	});
-
-	it("ADAPTERS_ATTEMPT_COUNTER=memory is refused at boot: the login would count its attempts per replica", async () => {
-		await expect(
-			compose({ ...MULTI, env: { ...MULTI_ENV, ADAPTERS_ATTEMPT_COUNTER: "memory" } }),
-		).rejects.toMatchObject({
-			name: "BootError",
-			reason: "contribute-factory-failed",
-			cause: {
-				message: expect.stringContaining('no shared attemptCounter is wired for "login"'),
-			},
-		});
-	});
-
-	it("names every memory store together when every switch is memory", async () => {
-		const env = { ...MULTI_ENV };
-		for (const [variable] of MEMORY_SWITCHES) env[variable] = "memory";
-		await expect(compose({ ...MULTI, env })).rejects.toMatchObject({
-			reason: "replica-unsafe-adapter",
-			details: {
-				modules: expect.arrayContaining(MEMORY_SWITCHES.map(([, module]) => module)),
-			},
-		});
-	});
-});
-
-describe("the shared Redis socket can back every store the Redis package ships", () => {
-	/**
-	 * Every store module `@o3co/auth-provider-redis` exports, the two built per
-	 * composition root included. This template composes some; a deployment adds
-	 * the others to the manifest with the modules that read them (the device
-	 * grant's code store, WebAuthn's challenge store), and each requires its
-	 * client from this module. One it does not provide is a boot refused with
-	 * `missing-required-component`, which `modules.mts` guards against for
-	 * the device-code store by name.
-	 */
-	const storeModules: Module[] = Object.entries(redisPackage).flatMap(([name, value]) => {
-		if (name.endsWith("ModuleFor") && typeof value === "function") {
-			return [(value as (options: object) => Module)({})];
-		}
-		if (name.endsWith("Module") && typeof value === "object" && value !== null) {
-			return [value as Module];
-		}
-		return [];
-	});
-
-	it.each(storeModules.map((m) => [m.name, m] as const))(
-		"%s: its client slot is provided by redis-clients",
-		(_name, module) => {
-			const provided = Object.keys(standaloneRedisClientsModule.provides ?? {});
-			const clients = (module.requires ?? []).filter((slot) => String(slot).endsWith("Client"));
-			expect(clients.length).toBeGreaterThan(0);
-			for (const slot of clients) expect(provided, slot).toContain(slot);
-		},
-	);
-
-	it("finds the store modules to check", () => {
-		expect(storeModules.length).toBeGreaterThanOrEqual(12);
-	});
-});