`~/Desktop/tech-log-frontend` 가 세 번 더 고쳐져 있었다. 소스 열셋이 바뀌고 둘이
새로 생겼다(`markdown-block-editor`, `catalog-property-picker`). 검사 넷도 함께 바뀌었다.
기능이 바뀐 것부터 적는다.
**편집기에서 즉시 미리보기가 빠졌다.** v2 에서 「편집/나란히/미리보기」 모드가 생겼고,
v4 가 그 모드 자체를 없앴다 — 글 쓰는 화면은 하나이고 공개 렌더는 편집기의 두 번째
상태가 아니라는 판단이다. 직전 리뷰의 완료 조건 하나("preview 는 Desktop/Mobile 을
실제로 전환할 수 있다")가 이로써 다시 미적용이 된다. `InstantPreview` 는 파일로 남아
있으나 편집기 어디서도 부르지 않는다.
**본문이 textarea 에서 블록 편집기로 바뀌었다.** 기존 markdown 을 문단·제목·목록·인용·
코드·구분선·raw 로 읽고 같은 `bodyMarkdown` 계약으로 되돌려 쓴다. 읽었다가 그대로 다시
쓰는 왕복이 글을 바꾸면 작성자가 문서를 열어 저장하기만 해도 내용이 상하므로, 이
저장소가 실제로 쓰는 문법(앵커 단 소제목, 이름표 단 코드 울타리, `:::evidence`, 표,
인용, 목록, 구분선)을 하나씩 넣어 왕복을 검사로 고정했다. 빈 줄이 겹친 자리만 한 줄로
접히고 글자는 그대로다 — 그 예외도 검사에 적었다.
Project·Topic 이 검색 가능한 고르개로, 상태가 인라인 알약으로 바뀌었고, 메타데이터는
접히는 속성 면으로 내려갔다.
`useImperativeHandle` 안에서 부르는 `commit` 이 렌더마다 새로 만들어져 lint 가 막았다.
`useCallback` 으로 고정했다 — 바뀌는 것은 `onChange` 하나다.
Node 24 로 게이트 재실행: check:types · lint · test:unit(1829) · test:component(152) ·
test:tech-log(432) 전부 통과.
Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_015c8cBFUaVr7KLVUx6ujz7D
244 lines
11 KiB
TypeScript
244 lines
11 KiB
TypeScript
// @vitest-environment jsdom
|
|
|
|
import { fireEvent, render, screen, waitFor } from "@testing-library/react";
|
|
import userEvent from "@testing-library/user-event";
|
|
import { MemoryRouter } from "react-router-dom";
|
|
import { afterAll, afterEach, beforeAll, describe, expect, it, vi } from "vitest";
|
|
|
|
import { createTechLogFeatureInstalledInput } from "../../../src/features/tech-log/adapters/create-tech-log-feature-input.ts";
|
|
import { MOCK_STUDIO_INSTALL_CONTEXT } from "../../helpers/studio-install-context.ts";
|
|
import { FIXTURE_IDS } from "../../../src/features/tech-log/adapters/mock/fixtures.ts";
|
|
import type { StudioGateway } from "../../../src/features/tech-log/application/ports/studio-gateway.ts";
|
|
import { DocumentEditorScreen } from "../../../src/features/tech-log/presentation/studio/components/document-editor-screen.tsx";
|
|
import { PublicPreviewScreen } from "../../../src/features/tech-log/presentation/studio/components/public-preview-screen.tsx";
|
|
import { ValidationScreen } from "../../../src/features/tech-log/presentation/studio/components/validation-screen.tsx";
|
|
import { StudioProvider } from "../../../src/features/tech-log/presentation/studio/studio-provider.tsx";
|
|
import { createManagementGatewayStub } from "../../helpers/management-gateway-stub.ts";
|
|
|
|
class NoopIntersectionObserver implements IntersectionObserver {
|
|
readonly root = null;
|
|
readonly rootMargin = "0px";
|
|
readonly scrollMargin = "0px";
|
|
readonly thresholds = [0];
|
|
|
|
disconnect() {}
|
|
observe() {}
|
|
takeRecords(): IntersectionObserverEntry[] {
|
|
return [];
|
|
}
|
|
unobserve() {}
|
|
}
|
|
|
|
beforeAll(() => {
|
|
vi.stubGlobal("IntersectionObserver", NoopIntersectionObserver);
|
|
});
|
|
|
|
afterAll(() => {
|
|
vi.unstubAllGlobals();
|
|
});
|
|
|
|
afterEach(() => vi.restoreAllMocks());
|
|
|
|
function renderStudio(
|
|
child: React.ReactNode,
|
|
gateway: StudioGateway = createTechLogFeatureInstalledInput(MOCK_STUDIO_INSTALL_CONTEXT).input.createStudioGateway(),
|
|
) {
|
|
return render(
|
|
<MemoryRouter initialEntries={["/studio"]}>
|
|
<StudioProvider
|
|
createManagementGateway={createManagementGatewayStub} createGateway={() => gateway}>{child}</StudioProvider>
|
|
</MemoryRouter>,
|
|
);
|
|
}
|
|
|
|
describe("TechLog Studio validation workflow", () => {
|
|
it("reruns stale saved validation, reports exact freshness copy, and creates a new key per command", async () => {
|
|
const user = userEvent.setup();
|
|
const base = createTechLogFeatureInstalledInput(MOCK_STUDIO_INSTALL_CONTEXT).input.createStudioGateway();
|
|
const keys: string[] = [];
|
|
const gateway = {
|
|
...base,
|
|
validateDocument(...args: Parameters<StudioGateway["validateDocument"]>) {
|
|
keys.push(args[2].idempotencyKey);
|
|
return base.validateDocument(...args);
|
|
},
|
|
} satisfies StudioGateway;
|
|
renderStudio(<ValidationScreen documentId={FIXTURE_IDS.fetchJoinCase} />, gateway);
|
|
|
|
expect(await screen.findByText("저장 후 다시 검증해야 합니다")).toBeVisible();
|
|
expect(screen.getByText("이전 결과")).toBeVisible();
|
|
await user.click(screen.getByRole("button", { name: "다시 검증" }));
|
|
|
|
expect(await screen.findByText("검증이 완료되었습니다.")).toBeVisible();
|
|
expect(screen.getByText("현재")).toBeVisible();
|
|
expect(screen.getByRole("link", { name: "Public Preview 만들기" })).toHaveAttribute(
|
|
"href",
|
|
`/studio/documents/${FIXTURE_IDS.fetchJoinCase}/preview`,
|
|
);
|
|
await user.click(screen.getByRole("button", { name: "다시 검증" }));
|
|
await waitFor(() => expect(keys).toHaveLength(2));
|
|
expect(keys[0]).toBeTruthy();
|
|
expect(keys[1]).not.toBe(keys[0]);
|
|
});
|
|
|
|
it("orders validation issues and links each JSON pointer to the affected editor field", async () => {
|
|
const user = userEvent.setup();
|
|
const gateway = createTechLogFeatureInstalledInput(MOCK_STUDIO_INSTALL_CONTEXT).input.createStudioGateway();
|
|
const view = renderStudio(
|
|
<ValidationScreen documentId={FIXTURE_IDS.edgeTokenQuestion} />,
|
|
gateway,
|
|
);
|
|
|
|
const issue = await screen.findByText("사실이 필요합니다.");
|
|
expect(issue.closest("a")).toHaveAttribute(
|
|
"href",
|
|
`/studio/documents/${FIXTURE_IDS.edgeTokenQuestion}/edit#studio-field-facts`,
|
|
);
|
|
expect(screen.getByText("검증 오류를 수정해야 합니다")).toBeVisible();
|
|
expect(screen.getByRole("link", { name: "편집 화면에서 수정" })).toBeVisible();
|
|
|
|
await user.click(screen.getByRole("button", { name: "다시 검증" }));
|
|
const warning = await screen.findByText("선택지 두 개를 권장합니다.");
|
|
expect(warning.closest("a")).toHaveAttribute(
|
|
"href",
|
|
`/studio/documents/${FIXTURE_IDS.edgeTokenQuestion}/edit#studio-field-options`,
|
|
);
|
|
view.unmount();
|
|
|
|
renderStudio(<DocumentEditorScreen documentId={FIXTURE_IDS.edgeTokenQuestion} />, gateway);
|
|
await screen.findByRole("heading", { level: 1, name: /oauth2-proxy가 전달한 토큰/ });
|
|
expect(document.querySelector("#studio-field-facts")).toBeInTheDocument();
|
|
expect(document.querySelector("#studio-field-options")).toBeInTheDocument();
|
|
});
|
|
|
|
it("aborts a route-obsolete validation read without surfacing an abort error", async () => {
|
|
const base = createTechLogFeatureInstalledInput(MOCK_STUDIO_INSTALL_CONTEXT).input.createStudioGateway();
|
|
let firstSignal: AbortSignal | undefined;
|
|
const getDocument = vi
|
|
.fn<StudioGateway["getDocument"]>()
|
|
.mockImplementationOnce((_id, options) => {
|
|
firstSignal = options?.signal;
|
|
return new Promise((_resolve, reject) => {
|
|
options?.signal?.addEventListener("abort", () => reject(new DOMException("Aborted", "AbortError")));
|
|
});
|
|
})
|
|
.mockImplementation((id, options) => base.getDocument(id, options));
|
|
const gateway = { ...base, getDocument };
|
|
const view = renderStudio(
|
|
<ValidationScreen documentId={FIXTURE_IDS.fetchJoinCase} />,
|
|
gateway,
|
|
);
|
|
await waitFor(() => expect(firstSignal).toBeDefined());
|
|
|
|
view.rerender(
|
|
<MemoryRouter initialEntries={["/studio"]}>
|
|
<StudioProvider
|
|
createManagementGateway={createManagementGatewayStub} createGateway={() => gateway}>
|
|
<ValidationScreen documentId={FIXTURE_IDS.stateNonceReference} />
|
|
</StudioProvider>
|
|
</MemoryRouter>,
|
|
);
|
|
|
|
await waitFor(() => expect(firstSignal?.aborted).toBe(true));
|
|
expect(await screen.findByText("현재 저장 버전의 검증을 통과했습니다")).toBeVisible();
|
|
expect(screen.queryByRole("alert")).not.toBeInTheDocument();
|
|
});
|
|
});
|
|
|
|
describe("TechLog Studio Public Preview workflow", () => {
|
|
it("creates a missing preview, shows the current state, and renders the shared Public document", async () => {
|
|
const user = userEvent.setup();
|
|
const base = createTechLogFeatureInstalledInput(MOCK_STUDIO_INSTALL_CONTEXT).input.createStudioGateway();
|
|
const keys: string[] = [];
|
|
const gateway = {
|
|
...base,
|
|
createPreview(...args: Parameters<StudioGateway["createPreview"]>) {
|
|
keys.push(args[2].idempotencyKey);
|
|
return base.createPreview(...args);
|
|
},
|
|
} satisfies StudioGateway;
|
|
const view = renderStudio(
|
|
<PublicPreviewScreen documentId={FIXTURE_IDS.stateNonceReference} />,
|
|
gateway,
|
|
);
|
|
|
|
expect(await screen.findByText("아직 만든 Public Preview가 없습니다")).toBeVisible();
|
|
await user.click(screen.getByRole("button", { name: "Public Preview 만들기" }));
|
|
|
|
expect(await screen.findByText("현재 저장 버전의 Public Preview입니다.")).toBeVisible();
|
|
expect(screen.getByRole("link", { name: "게시 준비로 이동" })).toHaveAttribute(
|
|
"href",
|
|
`/studio/documents/${FIXTURE_IDS.stateNonceReference}/publish`,
|
|
);
|
|
expect(screen.getByRole("heading", { level: 1, name: "Authorization Code Flow에서 state와 nonce의 경계" })).toBeVisible();
|
|
expect(screen.getAllByRole("heading", { level: 1 })).toHaveLength(1);
|
|
expect(view.container.querySelector("main main")).toBeNull();
|
|
expect(view.container.querySelector(".public-record-embedded")).toBeInTheDocument();
|
|
expect(keys).toHaveLength(1);
|
|
expect(keys[0]).toBeTruthy();
|
|
});
|
|
|
|
it("keeps a stale preview inspectable and points to validation as the exact next action", async () => {
|
|
renderStudio(<PublicPreviewScreen documentId={FIXTURE_IDS.fetchJoinCase} />);
|
|
|
|
expect(await screen.findByText("저장본보다 이전에 만든 Public Preview입니다.")).toBeVisible();
|
|
expect(screen.getByText("STALE")).toBeVisible();
|
|
expect(screen.getByRole("heading", { level: 1, name: "컬렉션 Fetch Join과 페이징은 왜 충돌하는가" })).toBeVisible();
|
|
expect(screen.getByRole("link", { name: "검증 화면으로 이동" })).toHaveAttribute(
|
|
"href",
|
|
`/studio/documents/${FIXTURE_IDS.fetchJoinCase}/validation`,
|
|
);
|
|
expect(screen.queryByRole("button", { name: "Public Preview 다시 만들기" })).not.toBeInTheDocument();
|
|
});
|
|
|
|
it("keeps an expired preview inspectable and blocks recreation until validation", async () => {
|
|
renderStudio(<PublicPreviewScreen documentId={FIXTURE_IDS.expiredPreviewCase} />);
|
|
|
|
expect(await screen.findByText("이 Public Preview는 만료되었습니다.")).toBeVisible();
|
|
expect(screen.getByText("EXPIRED")).toBeVisible();
|
|
expect(screen.getByRole("heading", { level: 1, name: "만료 미리보기 예시" })).toBeVisible();
|
|
expect(screen.getByRole("link", { name: "검증 화면으로 이동" })).toHaveAttribute(
|
|
"href",
|
|
`/studio/documents/${FIXTURE_IDS.expiredPreviewCase}/validation`,
|
|
);
|
|
});
|
|
|
|
it("shows retryable preview-load errors and retries the read", async () => {
|
|
const base = createTechLogFeatureInstalledInput(MOCK_STUDIO_INSTALL_CONTEXT).input.createStudioGateway();
|
|
const getDocument = vi
|
|
.fn<StudioGateway["getDocument"]>()
|
|
.mockRejectedValueOnce(new Error("offline"))
|
|
.mockImplementation((id, options) => base.getDocument(id, options));
|
|
renderStudio(
|
|
<PublicPreviewScreen documentId={FIXTURE_IDS.stateNonceReference} />,
|
|
{ ...base, getDocument },
|
|
);
|
|
|
|
expect(await screen.findByRole("alert")).toHaveTextContent(
|
|
"Public Preview를 불러오지 못했습니다offline",
|
|
);
|
|
fireEvent.click(screen.getByRole("button", { name: "다시 시도" }));
|
|
expect(await screen.findByText("아직 만든 Public Preview가 없습니다")).toBeVisible();
|
|
expect(getDocument).toHaveBeenCalledTimes(2);
|
|
});
|
|
|
|
it("blocks an expired validation until validation runs again", async () => {
|
|
renderStudio(<ValidationScreen documentId={FIXTURE_IDS.expiredPreviewCase} />);
|
|
|
|
expect(await screen.findByText("저장 후 다시 검증해야 합니다")).toBeVisible();
|
|
expect(screen.queryByRole("link", { name: "Public Preview 만들기" })).not.toBeInTheDocument();
|
|
});
|
|
|
|
it("renders the source not-found state for unknown document ids", async () => {
|
|
renderStudio(
|
|
<ValidationScreen documentId="99999999-9999-4999-8999-999999999999" />,
|
|
);
|
|
|
|
expect(await screen.findByRole("heading", { level: 1, name: "작업본을 찾을 수 없습니다" })).toBeVisible();
|
|
expect(screen.getByRole("link", { name: "작업본으로 돌아가기" })).toHaveAttribute(
|
|
"href",
|
|
"/studio/documents",
|
|
);
|
|
});
|
|
});
|