RouteLifecycle lived inside the route content, which ProtectedRoute,
InvalidRouteSurface and DisabledFeatureSurface never render. On those
screens document.title kept the previous page's title, focus stayed on the
link the user left (screen readers got no page-change cue), and no
route.changed diagnostic was recorded.
RegisteredRoute is now a thin wrapper that renders RouteLifecycle first and
the former body (renamed RouteSurface) after it, so every branch gets title,
main focus and telemetry, and the lifecycle effect still runs before the
page heading's focus effect.
Verified: RED "runs the route lifecycle on the {authentication-required,
invalid-route, disabled-feature} surface" (focus left on a nav link, then a
history navigation) all failed before with the home title still set and
pass after. check:architecture, check:types:app, check:types:test, lint,
test:component, test:reference-feature pass; test:unit passes except the
pre-existing removal-fixture test (needs generated artifacts/ files absent
from a fresh worktree).
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
219 lines
7.2 KiB
TypeScript
219 lines
7.2 KiB
TypeScript
// @vitest-environment jsdom
|
|
|
|
import { act, render, screen, waitFor } from "@testing-library/react";
|
|
import userEvent from "@testing-library/user-event";
|
|
import { describe, expect, it, vi } from "vitest";
|
|
|
|
import { createAnonymousSessionAdapter } from "../../src/adapters/auth/external-session-adapter.ts";
|
|
import type { ApplicationOutputPorts } from "../../src/application/create-application.ts";
|
|
import { INSTALLED_PRODUCT_FEATURE_IDS } from "../../src/features/installed-product-manifest.ts";
|
|
import { ApplicationProvider } from "../../src/presentation/providers/application-provider.tsx";
|
|
import { AppRouter } from "../../src/presentation/routes/app-router.tsx";
|
|
import { createTestApplication } from "../helpers/create-test-application.ts";
|
|
import { createProductFeaturesStub } from "../helpers/runtime-capabilities-stub.ts";
|
|
|
|
function renderRouter(
|
|
diagnostics: ApplicationOutputPorts["diagnostics"] = { record: () => {} },
|
|
productFeatures?: ApplicationOutputPorts["productFeatures"],
|
|
) {
|
|
return render(
|
|
<ApplicationProvider
|
|
application={createTestApplication({
|
|
session: createAnonymousSessionAdapter(),
|
|
diagnostics,
|
|
...(productFeatures ? { productFeatures } : {}),
|
|
})}
|
|
>
|
|
<AppRouter />
|
|
</ApplicationProvider>,
|
|
);
|
|
}
|
|
|
|
/** A back/forward style navigation that leaves focus where the user left it. */
|
|
function navigateByHistory(url: string) {
|
|
act(() => {
|
|
window.history.pushState({}, "", url);
|
|
window.dispatchEvent(new PopStateEvent("popstate"));
|
|
});
|
|
}
|
|
|
|
function routeChangeReports(record: ReturnType<typeof vi.fn>) {
|
|
return record.mock.calls.filter(
|
|
([event]) => (event as { eventId: string }).eventId === "route.changed",
|
|
).length;
|
|
}
|
|
|
|
describe("generic application router", () => {
|
|
it("reaches the platform overview from the home starter actions", async () => {
|
|
const user = userEvent.setup();
|
|
window.history.pushState({}, "", "/");
|
|
renderRouter();
|
|
|
|
// The starter action lives inside the lazily loaded home chunk, so this is
|
|
// the first wait in the file that has to outlast a chunk load rather than
|
|
// an already-mounted shell element.
|
|
await user.click(
|
|
await screen.findByRole(
|
|
"link",
|
|
{ name: "플랫폼 구성 보기" },
|
|
{ timeout: 5000 },
|
|
),
|
|
);
|
|
|
|
await waitFor(() =>
|
|
expect(
|
|
screen.getByRole("heading", { name: "플랫폼 구성", level: 1 }),
|
|
).toHaveFocus(),
|
|
);
|
|
});
|
|
|
|
it("renders the app shell and not-found route without a feature input", async () => {
|
|
window.history.pushState({}, "", "/missing");
|
|
renderRouter();
|
|
|
|
expect(
|
|
await screen.findByRole("heading", {
|
|
name: "페이지를 찾을 수 없습니다.",
|
|
}),
|
|
).toBeVisible();
|
|
expect(screen.getByRole("navigation", { name: "주요 탐색" })).toBeVisible();
|
|
expect(screen.getByRole("main")).toBeVisible();
|
|
});
|
|
|
|
it("navigates between registry-backed platform routes", async () => {
|
|
const user = userEvent.setup();
|
|
window.history.pushState({}, "", "/");
|
|
renderRouter();
|
|
|
|
await user.click(
|
|
await screen.findByRole("link", { name: "UI 구성요소" }),
|
|
);
|
|
|
|
expect(
|
|
await screen.findByRole("heading", { name: "UI 구성요소", level: 1 }),
|
|
).toBeVisible();
|
|
expect(window.location.pathname).toBe("/examples/ui");
|
|
await waitFor(() =>
|
|
expect(document.title).toBe("UI 구성요소 · Frontend Skeleton"),
|
|
);
|
|
await waitFor(() =>
|
|
expect(
|
|
screen.getByRole("heading", { name: "UI 구성요소", level: 1 }),
|
|
).toHaveFocus(),
|
|
);
|
|
});
|
|
|
|
it("changes only the title and copy when the locale changes", async () => {
|
|
// docs/architecture/routing-pages-and-patterns.md §9: a locale change
|
|
// re-renders the document title and copy; it is not a route change.
|
|
const user = userEvent.setup();
|
|
const record = vi.fn();
|
|
window.history.pushState({}, "", "/missing");
|
|
renderRouter({ record });
|
|
|
|
await waitFor(() =>
|
|
expect(
|
|
screen.getByRole("heading", {
|
|
name: "페이지를 찾을 수 없습니다.",
|
|
level: 1,
|
|
}),
|
|
).toHaveFocus(),
|
|
);
|
|
const reportsBefore = routeChangeReports(record);
|
|
expect(reportsBefore).toBeGreaterThan(0);
|
|
|
|
const localeSelect = screen.getByLabelText("언어");
|
|
await user.selectOptions(localeSelect, "en-US");
|
|
|
|
await waitFor(() =>
|
|
expect(document.title).toBe("Page not found · Frontend Skeleton"),
|
|
);
|
|
expect(
|
|
screen.getByRole("heading", { name: "Page not found.", level: 1 }),
|
|
).toBeVisible();
|
|
expect(localeSelect).toHaveFocus();
|
|
expect(routeChangeReports(record)).toBe(reportsBefore);
|
|
});
|
|
|
|
it.each([
|
|
{
|
|
surface: "authentication-required",
|
|
url: "/examples/reference-resources",
|
|
routeId: "REFERENCE_RESOURCE_LIST",
|
|
title: "Reference resources · Frontend Skeleton",
|
|
disableFeature: false,
|
|
},
|
|
{
|
|
surface: "invalid-route",
|
|
url: "/examples/ui?unexpected=1",
|
|
routeId: "EXAMPLES_UI",
|
|
title: "UI 구성요소 · Frontend Skeleton",
|
|
disableFeature: false,
|
|
},
|
|
{
|
|
surface: "disabled-feature",
|
|
url: "/examples/reference-resources",
|
|
routeId: "REFERENCE_RESOURCE_LIST",
|
|
title: "Reference resources · Frontend Skeleton",
|
|
disableFeature: true,
|
|
},
|
|
])(
|
|
"runs the route lifecycle on the $surface surface",
|
|
async ({ surface, url, routeId, title, disableFeature }) => {
|
|
const record = vi.fn();
|
|
window.history.pushState({}, "", "/");
|
|
const { container } = renderRouter(
|
|
{ record },
|
|
disableFeature
|
|
? createProductFeaturesStub({
|
|
[INSTALLED_PRODUCT_FEATURE_IDS[0]!]: "DISABLED_BY_CONFIG",
|
|
})
|
|
: undefined,
|
|
);
|
|
const link = (
|
|
await screen.findAllByRole("link", { name: "UI 구성요소" })
|
|
)[0]!;
|
|
link.focus();
|
|
|
|
navigateByHistory(url);
|
|
|
|
await waitFor(
|
|
() =>
|
|
expect(
|
|
container.querySelector(`[data-surface="${surface}"]`),
|
|
).not.toBeNull(),
|
|
{ timeout: 5000 },
|
|
);
|
|
await waitFor(() => expect(document.title).toBe(title));
|
|
expect(
|
|
screen.getByRole("main").contains(document.activeElement),
|
|
).toBe(true);
|
|
expect(record).toHaveBeenCalledWith(
|
|
expect.objectContaining({
|
|
eventId: "route.changed",
|
|
context: expect.objectContaining({ route_id: routeId }),
|
|
}),
|
|
);
|
|
},
|
|
);
|
|
|
|
it("focuses the route heading again when the lazy chunk is already cached", async () => {
|
|
// §9.7. The first visit resolves the route module asynchronously, so the
|
|
// router lifecycle and the page header commit separately. A later visit
|
|
// renders the cached module in the same commit, which is the ordering that
|
|
// must still hand focus to the heading rather than leaving it on main.
|
|
const user = userEvent.setup();
|
|
window.history.pushState({}, "", "/");
|
|
renderRouter();
|
|
|
|
for (const label of ["UI 구성요소", "화면 상태", "UI 구성요소"]) {
|
|
await user.click(await screen.findByRole("link", { name: label }));
|
|
await waitFor(() =>
|
|
expect(
|
|
screen.getByRole("heading", { name: label, level: 1 }),
|
|
).toHaveFocus(),
|
|
);
|
|
}
|
|
});
|
|
});
|