Files
clean-architecture-frontend…/tests/component/starter-platform-overview-page.test.tsx
T
DongHyeonka 138c195fcd fix(examples): 릴리스 신원 칸의 자리를 미리 잡고 lab이 대상 화면 직접 진입 CLS를 잰다
문제: 플랫폼 구성 화면(lab 대상)은 getReleaseSummary()가 끝날 때까지
릴리스 신원 칸을 "상태" 한 칸으로 그리고, 끝나면 hint 줄이 있는 네 칸으로
바꾼다. 제목이 보인 뒤 약 30~100 ms에 grid가 hint 한 줄만큼 커져 아래
section이 21 px 내려간다(layout shift 0.00461, 리뷰 15-platform-shift
16회). lab은 `/`에서 클릭으로만 들어가고, 클릭 뒤 500 ms 안의 shift는
hadRecentInput이라 CLS에서 빠지므로 0을 낸다. `/` 밖의 라우트 CLS는 어느
게이트도 보지 않는다.

고른 방법:
- 화면: 요약 전·실패 때도 같은 네 칸(빌드·릴리스·설정 스키마·계약 집합
  다이제스트)을 같은 hint 줄 구성으로 그린다. 값만 "확인하고 있습니다."
  / "확인하지 못했습니다." / "—"다. 상태 문장은 가장 좁은 칸(13rem)에서도
  한 줄이 되게 짧게 했다. dl에 aria-busy를 둔다. 시각 테스트는 이미
  `main [aria-busy='true']`가 0개가 될 때까지 기다리므로, dt만 보고 찍던
  대기가 값이 채워진 뒤로 유지된다.
- lab: run마다 대상 라우트를 새 context에서 직접 열고 heading 뒤 network
  idle까지의 CLS를 잰다(metrics.targetDeepLinkCls, 중앙값,
  context.sampling.targetDeepLink에 표본). evaluateLabBudget가 lab.cls
  임계값으로 판정한다. 클릭 시계(상호작용 중앙값)와 대상 라우트는 그대로다.
- 컴포넌트 테스트: 요약 전과 후의 칸 이름·hint 유무가 같다. 실패 테스트는
  빌드 칸의 값으로 본다. 단위 테스트: 직접 진입 CLS가 임계값을 넘으면
  lab 판정이 실패한다.
버린 대안: 릴리스 요약을 동기로 읽기 — getReleaseSummary()가 비동기
포트 계약이라 포트를 바꿔야 한다. 클릭 run에서 hadRecentInput을 무시 —
CLS 정의와 달라져 field 값과 비교할 수 없다.

위험·한계: lab 시간이 run마다 cold navigation 하나(lab 조건 약 2~3초)
늘어 5회면 +10~15초다. 직접 진입 CLS 예산은 0.1이라 0.0046 같은 작은
shift는 실패시키지 않고 lab.json에 값으로만 남는다. layout shift 0건은
lab 값(0)과 15-platform-shift 방법으로 확인해야 한다. 상태 문구가 바뀌어
"런타임 정보를 확인하고 있습니다." 문장은 이 화면에서 사라졌다(홈 화면
문구는 그대로). lab.json 스키마 문서(config/schemas/lab-performance.schema.json)에
새 칸을 필수로 더했다.

검증: desktop batch에서 확인.
node scripts/run-vitest.ts run tests/component/starter-platform-overview-page.test.tsx
tests/unit/performance-budgets.test.ts
corepack pnpm build && corepack pnpm test:performance -- --runs=5
(lab.json metrics.targetDeepLinkCls가 0인지)

Refs: 1105/15-01
2026-11-06 01:23:48 +09:00

299 lines
11 KiB
TypeScript

// @vitest-environment jsdom
import { act, render, screen, waitFor, within } from "@testing-library/react";
import { describe, expect, it } from "vitest";
import {
composeContractContributions,
type ComposedContractContributions,
} from "../../src/contracts/external-contract-runtime.ts";
import { unvalidatedPayload } from "../../src/contracts/unvalidated-payload.ts";
import { SERVER_STATE_PROFILES } from "../../src/contracts/server-state.ts";
import { COMPOSED_CONTRACT_CONTRIBUTIONS } from "../../src/features/loaded-feature-runtimes.ts";
import { ROUTE_REGISTRY } from "../../src/features/installed-feature-contracts.ts";
import { PlatformOverviewPage } from "../../src/presentation/examples/platform-overview-page.tsx";
import { LocaleProvider } from "../../src/presentation/i18n/index.ts";
import { ApplicationProvider } from "../../src/presentation/providers/application-provider.tsx";
import { createTestApplication } from "../helpers/create-test-application.ts";
import { TEST_CONTRACT_CONTRIBUTION } from "../helpers/external-contract-fixture.ts";
import { createRuntimeCapabilitiesStub } from "../helpers/runtime-capabilities-stub.ts";
/**
* A starter screen (0929/10-02): a product that replaces `/examples/platform`
* deletes this file with it. Platform tests use the test-only feature's pages.
*
* The page must stay a projection of the installed registries. Every assertion
* below derives its expectation from the same registry the page reads, so a
* template that removes its sample feature still satisfies this suite.
*/
/**
* 1103/15-01. The contract tables wait for the features' runtime halves
* behind their own Suspense boundary; `act` lets the given promise settle.
*/
async function renderPage(
options: Readonly<{
application?: ReturnType<typeof createTestApplication>;
contracts?: ComposedContractContributions;
}> = {},
) {
await act(async () => {
render(
<ApplicationProvider
application={options.application ?? createTestApplication()}
>
<LocaleProvider>
<PlatformOverviewPage
contracts={Promise.resolve(
options.contracts ?? COMPOSED_CONTRACT_CONTRIBUTIONS,
)}
/>
</LocaleProvider>
</ApplicationProvider>,
);
});
}
function tableByCaption(caption: string): HTMLElement {
return screen.getByRole("table", { name: caption });
}
/** A metric is a `dt`/`dd` pair, which carries no ARIA role to query by. */
function metricByLabel(scope: HTMLElement, label: string): HTMLElement {
const term = within(scope).getByText(label).closest(".platform-metric");
if (!(term instanceof HTMLElement)) {
throw new Error(`No metric is labelled ${label}`);
}
return term;
}
describe("platform overview page", () => {
it("renders one route row per installed route registry entry", async () => {
await renderPage();
const table = tableByCaption("설치된 라우트 목록");
const dataRows = within(table).getAllByRole("row").slice(1);
expect(dataRows).toHaveLength(Object.keys(ROUTE_REGISTRY).length);
for (const definition of Object.values(ROUTE_REGISTRY)) {
expect(
within(table).getByText(definition.routeId),
).toBeInTheDocument();
}
});
it("renders one operation row per installed HTTP contract", async () => {
const operationIds = [
...COMPOSED_CONTRACT_CONTRIBUTIONS.httpByOperationId.keys(),
];
await renderPage();
if (operationIds.length === 0) {
expect(
screen.getByRole("heading", {
name: "설치된 HTTP 오퍼레이션이 없습니다.",
}),
).toBeVisible();
return;
}
const table = tableByCaption("설치된 HTTP 오퍼레이션");
expect(within(table).getAllByRole("row").slice(1)).toHaveLength(
operationIds.length,
);
for (const operationId of operationIds) {
expect(within(table).getByText(operationId)).toBeInTheDocument();
}
});
// 1101/07-03. A skipped validation is shown, not just composed.
it("lists the operations that skip runtime validation, with the reason", async () => {
const [listRow, ...rest] = TEST_CONTRACT_CONTRIBUTION.http;
const contracts = composeContractContributions([
Object.freeze({
...TEST_CONTRACT_CONTRIBUTION,
http: Object.freeze([
{
...listRow!,
contract: {
...listRow!.contract,
outputValidator: unvalidatedPayload(
"TestEntityListPayload",
"typed by the package",
),
},
},
...rest,
]),
}),
]);
await renderPage({ contracts });
const table = tableByCaption("런타임 검증을 생략한 계약");
const [row, ...others] = within(table).getAllByRole("row").slice(1);
expect(others).toHaveLength(0);
expect(within(row!).getByText("TEST_LIST_ENTITIES")).toBeVisible();
expect(within(row!).getByText("typed by the package")).toBeVisible();
});
it("shows no skipped-validation list when every operation validates", async () => {
await renderPage();
expect(
screen.queryByRole("table", { name: "런타임 검증을 생략한 계약" }),
).toBeNull();
});
it("renders every fixed server-state profile with its own budget", async () => {
await renderPage();
const table = tableByCaption("서버 상태 프로파일");
for (const profile of Object.values(SERVER_STATE_PROFILES)) {
expect(within(table).getByText(profile.profileId)).toBeInTheDocument();
}
expect(within(table).getAllByRole("row").slice(1)).toHaveLength(
Object.keys(SERVER_STATE_PROFILES).length,
);
});
it("labels a capability that was never selected as unselected", async () => {
await renderPage();
const region = screen.getByRole("region", { name: "선택적 런타임 능력" });
expect(within(region).getAllByText("미선택")).toHaveLength(4);
expect(within(region).queryByText("운영자가 비활성화함")).toBeNull();
});
it("separates an operator disable from a capability that was never selected", async () => {
await renderPage({
application: createTestApplication({
runtimeCapabilities: createRuntimeCapabilitiesStub({
SERVICE_WORKER: { selected: 1, active: 0, override: "DISABLED" },
OFFLINE_COMMANDS: { selected: 1, active: 1 },
}),
}),
});
const region = screen.getByRole("region", { name: "선택적 런타임 능력" });
expect(within(region).getByText("운영자가 비활성화함")).toBeVisible();
expect(within(region).getByText("활성 (1)")).toBeVisible();
expect(within(region).getAllByText("미선택")).toHaveLength(2);
});
it("counts installed contract packages separately from template fixtures", async () => {
const fixtures = COMPOSED_CONTRACT_CONTRIBUTIONS.contributions.filter(
(contribution) => contribution.source.kind === "TEMPLATE_FIXTURE",
).length;
await renderPage();
const summary = screen.getByRole("region", { name: "설치 요약" });
const packages = metricByLabel(summary, "외부 계약 패키지");
expect(
within(packages).getByText(
`${COMPOSED_CONTRACT_CONTRIBUTIONS.externalPackages.length}개`,
),
).toBeVisible();
expect(
within(packages).getByText(`템플릿 픽스처 ${fixtures}개`),
).toBeVisible();
expect(
within(metricByLabel(summary, "라우트")).getByText(
`${Object.keys(ROUTE_REGISTRY).length}개`,
),
).toBeVisible();
});
it("renders the verified release identity once the runtime resolves it", async () => {
await renderPage();
const region = screen.getByRole("region", { name: "릴리스 신원" });
await waitFor(() =>
expect(
within(metricByLabel(region, "빌드")).getByText("test-build"),
).toBeVisible(),
);
expect(
within(metricByLabel(region, "릴리스")).getByText("test-release"),
).toBeVisible();
});
it("stops the release metrics from loading forever", async () => {
await renderPage({
application: createTestApplication({
releaseInfo: {
getCurrent: async () => {
throw new Error("manifest unavailable");
},
refresh: async () => {
throw new Error("manifest unavailable");
},
},
}),
});
const region = screen.getByRole("region", { name: "릴리스 신원" });
await waitFor(() =>
expect(
within(metricByLabel(region, "빌드")).getByText("확인하지 못했습니다."),
).toBeVisible(),
);
expect(within(region).queryByText("확인하고 있습니다.")).not.toBeInTheDocument();
});
/**
* 1105/15-01. The release metrics drew one "상태" card until the summary
* resolved, then four cards with hint lines: the grid grew by a hint line
* about 30-100 ms after the title and pushed the rest of the page 21 px
* (CLS 0.0046 on a direct visit). The cards and their hint lines are the
* same in every state; only the values change.
*/
it("keeps the release metrics' cards and hint lines while the summary loads", async () => {
const summary = {
buildId: "test-build",
releaseId: "test-release",
configSchemaVersion: "1",
apiContractVersion: "1",
assetManifestHash: "test-hash",
routeChunks: { "route-home": "assets/home.js" },
};
let resolve: (value: typeof summary) => void = () => {};
const pending = new Promise<typeof summary>((settle) => {
resolve = settle;
});
await renderPage({
application: createTestApplication({
releaseInfo: { getCurrent: () => pending, refresh: () => pending },
}),
});
const region = screen.getByRole("region", { name: "릴리스 신원" });
const shape = () =>
[...region.querySelectorAll(".platform-metric")].map((card) => [
card.querySelector("dt")?.textContent,
card.querySelector(".platform-metric__hint") !== null,
]);
const loading = shape();
expect(within(metricByLabel(region, "빌드")).getByText("확인하고 있습니다.")).toBeVisible();
expect(region.querySelector("dl")).toHaveAttribute("aria-busy", "true");
await act(async () => {
resolve(summary);
await pending;
});
await waitFor(() =>
expect(within(metricByLabel(region, "빌드")).getByText("test-build")).toBeVisible(),
);
expect(loading).toEqual([
["빌드", false],
["릴리스", false],
["설정 스키마", true],
["계약 집합 다이제스트", true],
]);
expect(shape()).toEqual(loading);
expect(region.querySelector("dl")).toHaveAttribute("aria-busy", "false");
});
});