Chunk recovery kept its own guard: marker keyed by the release pair, no TTL, trusted write().ok. Round 1 fixed the boot guard (key-independent marker within a TTL, read-back check) but the chunk copy still reloaded on every failure when replicas alternated A->B, B->A. platform/release gains createReloadOnceGuard (the round-1 boot rule, now with a refusal reason); createReleaseMismatchRecovery wraps it with unchanged boot semantics (marker within TTL blocks regardless of key, markCoherentBoot clears), and decideChunkRecovery uses it over its own CHUNK_RELOAD_GUARD key, keeping its reason vocabulary. Application -> platform is allowed by .dependency-cruiser.json; platform may not import application, so the guard lives in platform. Behavior change (chunk only): a second reload within the TTL is refused even for a different release pair, and a marker that does not read back is guard-write-failed. tests/component/context-route-gateway.test.tsx used a preferences stub that dropped writes; it now persists them. Verified: tests/unit/chunk-recovery.test.ts characterization (read/write failure, same pair, invariants) green before the change; alternating pair test RED before, green after. Boot tests unchanged and green; FE-RB-002 drill PASS; test:integration PASS; all gates PASS. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
146 lines
4.8 KiB
TypeScript
146 lines
4.8 KiB
TypeScript
// @vitest-environment jsdom
|
|
|
|
import { act, render, screen, waitFor } from "@testing-library/react";
|
|
import { describe, expect, it, vi } from "vitest";
|
|
|
|
import { ApplicationProvider } from "../../src/presentation/providers/application-provider.tsx";
|
|
import { PreferenceProviders } from "../../src/presentation/providers/preference-providers.tsx";
|
|
import { AppRouter } from "../../src/presentation/routes/app-router.tsx";
|
|
import { createTestApplication } from "../helpers/create-test-application.ts";
|
|
|
|
/**
|
|
* Three bounded contexts cut from the real reference routes, so canonical
|
|
* redirects and access rules stay valid: A owns the list, B the status page,
|
|
* and the third one's routes module fails to download.
|
|
*/
|
|
vi.mock("../../src/apps/template-app.ts", async () => {
|
|
const { FEATURE_CONTEXT_ROUTES } = await import(
|
|
"../../src/features/reference-feature/context-routes.ts"
|
|
);
|
|
const only = (id: string) => async () =>
|
|
FEATURE_CONTEXT_ROUTES.filter((route) => route.id === id);
|
|
return {
|
|
TEMPLATE_APP_MODULE: {
|
|
id: "two-context-app",
|
|
budget: { maxContexts: 3 },
|
|
contexts: [
|
|
{
|
|
id: "context-a",
|
|
route: {
|
|
path: "examples/reference-resources/*",
|
|
loadRoutes: only("REFERENCE_RESOURCE_LIST"),
|
|
},
|
|
},
|
|
{
|
|
id: "context-b",
|
|
route: {
|
|
path: "examples/reference-resources/status/*",
|
|
loadRoutes: only("REFERENCE_RESOURCE_STATUS"),
|
|
},
|
|
},
|
|
{
|
|
id: "context-offline",
|
|
route: {
|
|
path: "examples/reference-resources/new/*",
|
|
loadRoutes: async () => {
|
|
throw new TypeError(
|
|
"Failed to fetch dynamically imported module: /assets/context-routes.js",
|
|
);
|
|
},
|
|
},
|
|
},
|
|
],
|
|
},
|
|
};
|
|
});
|
|
|
|
function navigateByHistory(url: string) {
|
|
act(() => {
|
|
window.history.pushState({}, "", url);
|
|
window.dispatchEvent(new PopStateEvent("popstate"));
|
|
});
|
|
}
|
|
|
|
function reportedRoutes(record: ReturnType<typeof vi.fn>): string[] {
|
|
return record.mock.calls
|
|
.map(([event]) => event as { eventId: string; context: { route_id: string } })
|
|
.filter((event) => event.eventId === "route.changed")
|
|
.map((event) => event.context.route_id);
|
|
}
|
|
|
|
describe("context route gateway", () => {
|
|
it("never matches a new context's URL against the previous context's routes", async () => {
|
|
const record = vi.fn();
|
|
window.history.pushState({}, "", "/examples/reference-resources");
|
|
render(
|
|
<ApplicationProvider
|
|
application={createTestApplication({ diagnostics: { record } })}
|
|
>
|
|
<PreferenceProviders>
|
|
<AppRouter />
|
|
</PreferenceProviders>
|
|
</ApplicationProvider>,
|
|
);
|
|
await waitFor(() =>
|
|
expect(reportedRoutes(record)).toContain("REFERENCE_RESOURCE_LIST"),
|
|
);
|
|
|
|
navigateByHistory("/examples/reference-resources/status");
|
|
|
|
await waitFor(() =>
|
|
expect(reportedRoutes(record)).toContain("REFERENCE_RESOURCE_STATUS"),
|
|
);
|
|
expect(reportedRoutes(record)).not.toContain("NOT_FOUND");
|
|
});
|
|
|
|
it("sends a failed routes-module download through chunk recovery", async () => {
|
|
const reload = vi.fn();
|
|
const release = (buildId: string, releaseId: string) => ({
|
|
buildId,
|
|
releaseId,
|
|
configSchemaVersion: "1",
|
|
apiContractVersion: "1",
|
|
assetManifestHash: "hash",
|
|
routeChunks: { "route-reference-resource-form": "assets/form.js" },
|
|
});
|
|
// The reload-once guard only trusts a marker it can read back (Q-6.9-9).
|
|
const stored = new Map<string, unknown>();
|
|
window.history.pushState({}, "", "/examples/reference-resources/new");
|
|
render(
|
|
<ApplicationProvider
|
|
application={createTestApplication({
|
|
preferences: {
|
|
read: (name) => ({
|
|
ok: true as const,
|
|
value: stored.has(name) ? stored.get(name) : "system",
|
|
}),
|
|
write: (name, value) => {
|
|
stored.set(name, value);
|
|
return { ok: true as const };
|
|
},
|
|
remove: (name) => {
|
|
stored.delete(name);
|
|
return { ok: true as const };
|
|
},
|
|
},
|
|
navigation: { reload },
|
|
// A deploy happened: the page runs build-a, the server has build-b.
|
|
releaseInfo: {
|
|
getCurrent: async () => release("build-a", "release-a"),
|
|
refresh: async () => release("build-b", "release-b"),
|
|
},
|
|
})}
|
|
>
|
|
<PreferenceProviders>
|
|
<AppRouter />
|
|
</PreferenceProviders>
|
|
</ApplicationProvider>,
|
|
);
|
|
|
|
await waitFor(() => expect(reload).toHaveBeenCalledOnce());
|
|
expect(
|
|
await screen.findByText("새 버전으로 한 번만 전환합니다."),
|
|
).toBeVisible();
|
|
});
|
|
});
|