460 lines
14 KiB
TypeScript
460 lines
14 KiB
TypeScript
import { promises as fs } from "node:fs";
|
|
import path from "node:path";
|
|
import { spawnSync } from "node:child_process";
|
|
import { expect, type Page } from "@playwright/test";
|
|
|
|
export interface E2EPersona {
|
|
code: string;
|
|
display_name: string;
|
|
source: string;
|
|
degraded: boolean;
|
|
}
|
|
|
|
export async function useRealApi(_page: Page) {
|
|
// No-op marker for tests that should use the configured Vite /api proxy unless
|
|
// a spec explicitly installs route fixtures for a focused UI or error state.
|
|
// This helper alone is not proof that every test in the file is fixture-free.
|
|
}
|
|
|
|
function sleep(ms: number) {
|
|
return new Promise<void>((resolve) => {
|
|
setTimeout(resolve, ms);
|
|
});
|
|
}
|
|
|
|
let e2eEmailCounter = 0;
|
|
|
|
function uniqueE2EEmail(prefix: string, domain: string) {
|
|
e2eEmailCounter += 1;
|
|
return `${prefix}.${Date.now()}.${e2eEmailCounter}@${domain}`;
|
|
}
|
|
|
|
export async function acquireGlobalEngineConfigLock(
|
|
label: string,
|
|
): Promise<() => Promise<void>> {
|
|
const dir = path.join(process.cwd(), "node_modules", ".tmp");
|
|
const lockPath = path.join(dir, "engine-config.lock");
|
|
const startedAt = Date.now();
|
|
|
|
await fs.mkdir(dir, { recursive: true });
|
|
|
|
while (true) {
|
|
try {
|
|
const handle = await fs.open(lockPath, "wx");
|
|
try {
|
|
await handle.writeFile(`${process.pid} ${label} ${new Date().toISOString()}`);
|
|
} catch (err) {
|
|
await handle.close().catch(() => undefined);
|
|
await fs.unlink(lockPath).catch(() => undefined);
|
|
throw err;
|
|
}
|
|
let released = false;
|
|
return async () => {
|
|
if (released) return;
|
|
released = true;
|
|
await handle.close().catch(() => undefined);
|
|
await fs.unlink(lockPath).catch(() => undefined);
|
|
};
|
|
} catch (err) {
|
|
const code =
|
|
typeof err === "object" && err !== null && "code" in err
|
|
? String((err as { code?: unknown }).code)
|
|
: "";
|
|
if (code !== "EEXIST") throw err;
|
|
|
|
const stat = await fs.stat(lockPath).catch(() => null);
|
|
if (stat && Date.now() - stat.mtimeMs > 60_000) {
|
|
await fs.unlink(lockPath).catch(() => undefined);
|
|
continue;
|
|
}
|
|
if (Date.now() - startedAt > 30_000) {
|
|
throw new Error(`Timed out waiting for engine config lock: ${label}`);
|
|
}
|
|
await sleep(100);
|
|
}
|
|
}
|
|
}
|
|
|
|
export async function withGlobalEngineConfigLock<T>(
|
|
label: string,
|
|
action: () => Promise<T>,
|
|
): Promise<T> {
|
|
const release = await acquireGlobalEngineConfigLock(label);
|
|
try {
|
|
return await action();
|
|
} finally {
|
|
await release();
|
|
}
|
|
}
|
|
|
|
const ENGINE_CONFIG_DB_CONTAINER = process.env.E2E_DB_CONTAINER ?? "vignette-dev-db";
|
|
|
|
export interface EngineConfigSnapshot {
|
|
engine_mode: string;
|
|
engine_url: string;
|
|
model: string;
|
|
reasoning_effort: string | null;
|
|
updated_by: string | null;
|
|
updated_at: string | null;
|
|
}
|
|
|
|
function runEngineConfigPsql(sql: string): string {
|
|
const result = spawnSync(
|
|
"docker",
|
|
[
|
|
"exec",
|
|
"-i",
|
|
ENGINE_CONFIG_DB_CONTAINER,
|
|
"psql",
|
|
"-X",
|
|
"-U",
|
|
"vignette_owner",
|
|
"-d",
|
|
"vignette",
|
|
"-v",
|
|
"ON_ERROR_STOP=1",
|
|
"-A",
|
|
"-t",
|
|
"-F",
|
|
"|",
|
|
],
|
|
{ input: sql, encoding: "utf8", windowsHide: true },
|
|
);
|
|
if (result.status !== 0) {
|
|
throw new Error(`psql failed (${result.status}): ${String(result.stderr).trim()}`);
|
|
}
|
|
return String(result.stdout).trim();
|
|
}
|
|
|
|
function sqlEngineConfigTextValue(value: string | null): string {
|
|
return value === null ? "NULL" : `'${value.replaceAll("'", "''")}'`;
|
|
}
|
|
|
|
export function readEngineConfigSnapshot(): EngineConfigSnapshot | null {
|
|
const raw = runEngineConfigPsql(`
|
|
SELECT COALESCE(
|
|
(
|
|
SELECT json_build_object(
|
|
'engine_mode', engine_mode,
|
|
'engine_url', engine_url,
|
|
'model', model,
|
|
'reasoning_effort', reasoning_effort,
|
|
'updated_by', updated_by,
|
|
'updated_at', updated_at
|
|
)::text
|
|
FROM app.admin_engine_config
|
|
WHERE id = TRUE
|
|
),
|
|
'null'
|
|
);
|
|
`);
|
|
return raw === "null" ? null : (JSON.parse(raw) as EngineConfigSnapshot);
|
|
}
|
|
|
|
export function installControlledEngineConfig(options: {
|
|
engineUrl: string;
|
|
model: string;
|
|
reasoningEffort: string | null;
|
|
updatedBy: string;
|
|
}): void {
|
|
const { engineUrl, model, reasoningEffort, updatedBy } = options;
|
|
runEngineConfigPsql(`
|
|
INSERT INTO app.admin_engine_config (
|
|
id, engine_mode, engine_url, model, reasoning_effort, updated_by, updated_at
|
|
)
|
|
VALUES (
|
|
TRUE, 'claude_api', ${sqlEngineConfigTextValue(engineUrl)}, ${sqlEngineConfigTextValue(model)},
|
|
${sqlEngineConfigTextValue(reasoningEffort)}, ${sqlEngineConfigTextValue(updatedBy)}, now()
|
|
)
|
|
ON CONFLICT (id) DO UPDATE SET
|
|
engine_mode = EXCLUDED.engine_mode,
|
|
engine_url = EXCLUDED.engine_url,
|
|
model = EXCLUDED.model,
|
|
reasoning_effort = EXCLUDED.reasoning_effort,
|
|
updated_by = EXCLUDED.updated_by,
|
|
updated_at = EXCLUDED.updated_at;
|
|
`);
|
|
expect(readEngineConfigSnapshot()).toMatchObject({
|
|
engine_mode: "claude_api",
|
|
engine_url: engineUrl,
|
|
model,
|
|
reasoning_effort: reasoningEffort,
|
|
updated_by: updatedBy,
|
|
});
|
|
}
|
|
|
|
export function restoreEngineConfig(snapshot: EngineConfigSnapshot | null): void {
|
|
if (snapshot === null) {
|
|
runEngineConfigPsql("DELETE FROM app.admin_engine_config WHERE id = TRUE;");
|
|
} else {
|
|
runEngineConfigPsql(`
|
|
INSERT INTO app.admin_engine_config (
|
|
id, engine_mode, engine_url, model, reasoning_effort, updated_by, updated_at
|
|
)
|
|
VALUES (
|
|
TRUE,
|
|
${sqlEngineConfigTextValue(snapshot.engine_mode)},
|
|
${sqlEngineConfigTextValue(snapshot.engine_url)},
|
|
${sqlEngineConfigTextValue(snapshot.model)},
|
|
${sqlEngineConfigTextValue(snapshot.reasoning_effort)},
|
|
${sqlEngineConfigTextValue(snapshot.updated_by)},
|
|
${sqlEngineConfigTextValue(snapshot.updated_at)}::timestamptz
|
|
)
|
|
ON CONFLICT (id) DO UPDATE SET
|
|
engine_mode = EXCLUDED.engine_mode,
|
|
engine_url = EXCLUDED.engine_url,
|
|
model = EXCLUDED.model,
|
|
reasoning_effort = EXCLUDED.reasoning_effort,
|
|
updated_by = EXCLUDED.updated_by,
|
|
updated_at = EXCLUDED.updated_at;
|
|
`);
|
|
}
|
|
expect(readEngineConfigSnapshot()).toEqual(snapshot);
|
|
}
|
|
|
|
const E2E_COHORT_ID = "e2e-hanshin";
|
|
|
|
export async function signInAsLearner(page: Page) {
|
|
const res = await page.request.post("/api/auth/dev-login", {
|
|
data: {
|
|
email: uniqueE2EEmail("learner", "hs.ac.kr"),
|
|
role: "learner",
|
|
display_name: "E2E Learner",
|
|
cohort_ids: [E2E_COHORT_ID],
|
|
},
|
|
});
|
|
expect(res.ok(), await res.text()).toBeTruthy();
|
|
await completeOnboarding(page, {
|
|
legal_name: "E2E Learner",
|
|
affiliation: "한신대학교",
|
|
department: "상담심리학과",
|
|
grade_level: "3학년",
|
|
phone: "010-0000-0000",
|
|
contact_address: "경기도 오산시 한신대학교",
|
|
});
|
|
}
|
|
|
|
export async function signInAsTeacher(page: Page) {
|
|
const res = await page.request.post("/api/auth/dev-login", {
|
|
data: {
|
|
email: uniqueE2EEmail("teacher", "hs.ac.kr"),
|
|
role: "teacher",
|
|
display_name: "E2E Teacher",
|
|
cohort_ids: [E2E_COHORT_ID],
|
|
},
|
|
});
|
|
expect(res.ok(), await res.text()).toBeTruthy();
|
|
await completeOnboarding(page, {
|
|
legal_name: "E2E Teacher",
|
|
affiliation: "한신대학교",
|
|
department: "상담심리학과",
|
|
grade_level: "교수",
|
|
phone: "010-1111-1111",
|
|
contact_address: "경기도 오산시 한신대학교",
|
|
});
|
|
}
|
|
|
|
export async function signInAsAdmin(page: Page) {
|
|
const res = await page.request.post("/api/auth/dev-login", {
|
|
data: {
|
|
email: "admin@twentyoz.kr",
|
|
role: "admin",
|
|
display_name: "E2E Admin",
|
|
},
|
|
});
|
|
expect(res.ok(), await res.text()).toBeTruthy();
|
|
await completeOnboarding(page, {
|
|
legal_name: "E2E Admin",
|
|
affiliation: "한신대학교",
|
|
department: "운영",
|
|
grade_level: "관리자",
|
|
phone: "010-2222-2222",
|
|
contact_address: "경기도 오산시 한신대학교",
|
|
});
|
|
}
|
|
|
|
export async function completeOnboarding(
|
|
page: Page,
|
|
profile: {
|
|
legal_name: string;
|
|
affiliation: string;
|
|
department: string;
|
|
grade_level: string;
|
|
phone: string;
|
|
contact_address: string;
|
|
nickname?: string;
|
|
self_introduction?: string;
|
|
avatar_url?: string;
|
|
},
|
|
) {
|
|
const onboarding = await page.request.post("/api/users/me/onboarding", {
|
|
data: {
|
|
...profile,
|
|
nickname: profile.nickname ?? profile.legal_name,
|
|
self_introduction:
|
|
profile.self_introduction ?? "상담 시뮬레이션 훈련을 위한 테스트 사용자입니다.",
|
|
avatar_url: profile.avatar_url ?? "",
|
|
terms_accepted: true,
|
|
privacy_accepted: true,
|
|
},
|
|
});
|
|
expect(onboarding.ok(), await onboarding.text()).toBeTruthy();
|
|
}
|
|
|
|
export async function fetchAvailablePersonas(page: Page): Promise<E2EPersona[]> {
|
|
const res = await page.request.get("/api/personas");
|
|
expect(res.ok(), await res.text()).toBeTruthy();
|
|
const personas = (await res.json()) as E2EPersona[];
|
|
const usable = personas.filter((persona) => persona.source === "database" && !persona.degraded);
|
|
expect(usable.length, `Expected at least one database persona: ${JSON.stringify(personas)}`).toBeGreaterThan(0);
|
|
return usable;
|
|
}
|
|
|
|
export async function fetchAvailablePersona(page: Page, index = 0): Promise<E2EPersona> {
|
|
const personas = await fetchAvailablePersonas(page);
|
|
return personas[index] ?? personas[0];
|
|
}
|
|
|
|
/**
|
|
* 새 회기의 첫 발화 전에 append-only Alliance pre 기준을 잠근다.
|
|
* 실제 API를 사용하는 세션 E2E가 제품의 fail-closed 진입 계약을 우회하지 않게 한다.
|
|
*/
|
|
export async function completeAlliancePreCheckpoint(page: Page) {
|
|
const heading = page.getByRole("heading", {
|
|
name: "첫 발화 전에 내 기준을 잠급니다",
|
|
});
|
|
await expect(heading).toBeVisible({ timeout: 15_000 });
|
|
|
|
for (const axis of ["목표", "과업", "유대"] as const) {
|
|
/* elapsed/HMR 갱신으로 checkpoint subtree가 교체될 수 있다. 매 poll마다 현재
|
|
label 좌표를 다시 얻어 실제 포인터로 누르고, 새 DOM의 checked 상태를 읽는다.
|
|
input property를 직접 쓰거나 제품 gate를 우회하지 않는다. */
|
|
await expect
|
|
.poll(
|
|
async () => {
|
|
const group = page.getByRole("group", { name: new RegExp(`^${axis}`) });
|
|
const selected = group.getByRole("radio", { name: "3 보통이다" });
|
|
if (await selected.isChecked().catch(() => false)) return true;
|
|
|
|
const label = selected.locator("xpath=ancestor::label[1]");
|
|
const box = await label.boundingBox().catch(() => null);
|
|
if (!box) return false;
|
|
await page.mouse.click(box.x + box.width / 2, box.y + box.height / 2);
|
|
return page
|
|
.getByRole("group", { name: new RegExp(`^${axis}`) })
|
|
.getByRole("radio", { name: "3 보통이다" })
|
|
.isChecked()
|
|
.catch(() => false);
|
|
},
|
|
{
|
|
message: `${axis} 동맹 기준이 실제 포인터 입력으로 선택되어야 한다`,
|
|
timeout: 15_000,
|
|
intervals: [50, 100, 200, 400],
|
|
},
|
|
)
|
|
.toBe(true);
|
|
}
|
|
|
|
const saved = page.waitForResponse((response) => {
|
|
const url = new URL(response.url());
|
|
return (
|
|
response.request().method() === "POST" &&
|
|
url.pathname.includes("/sessions/") &&
|
|
url.pathname.includes("/alliance-pulses")
|
|
);
|
|
}, { timeout: 15_000 });
|
|
const submit = page.getByRole("button", {
|
|
name: "기준 잠그고 첫 발화 준비",
|
|
});
|
|
await submit.scrollIntoViewIfNeeded();
|
|
const currentSubmit = page.getByRole("button", {
|
|
name: "기준 잠그고 첫 발화 준비",
|
|
});
|
|
await expect(currentSubmit).toBeEnabled();
|
|
const submitBox = await currentSubmit.boundingBox();
|
|
expect(submitBox, "Alliance pre 저장 버튼 좌표").not.toBeNull();
|
|
await page.mouse.click(
|
|
(submitBox?.x ?? 0) + (submitBox?.width ?? 0) / 2,
|
|
(submitBox?.y ?? 0) + (submitBox?.height ?? 0) / 2,
|
|
);
|
|
const response = await saved;
|
|
expect(response.ok(), await response.text()).toBeTruthy();
|
|
await expect(
|
|
page.locator('.sx-page--active textarea[aria-label="학습자 발화 입력"]'),
|
|
).toBeEnabled({ timeout: 15_000 });
|
|
}
|
|
|
|
export async function expectNoHorizontalOverflow(page: Page) {
|
|
await expect
|
|
.poll(async () => {
|
|
try {
|
|
return await page.evaluate(() => {
|
|
const doc = document.documentElement;
|
|
return Math.ceil(doc.scrollWidth - doc.clientWidth);
|
|
});
|
|
} catch (err) {
|
|
if (isNavigationRace(err)) return Number.MAX_SAFE_INTEGER;
|
|
throw err;
|
|
}
|
|
})
|
|
.toBeLessThanOrEqual(1);
|
|
|
|
const overflow = await page.evaluate(() => {
|
|
const doc = document.documentElement;
|
|
const viewportWidth = doc.clientWidth;
|
|
const delta = Math.ceil(doc.scrollWidth - viewportWidth);
|
|
const offenders = Array.from(document.querySelectorAll<HTMLElement>("body *"))
|
|
.map((el) => {
|
|
const rect = el.getBoundingClientRect();
|
|
const style = window.getComputedStyle(el);
|
|
return {
|
|
tag: el.tagName.toLowerCase(),
|
|
className: String(el.className || ""),
|
|
text: (el.textContent ?? "").replace(/\s+/g, " ").trim().slice(0, 80),
|
|
left: Math.floor(rect.left),
|
|
right: Math.ceil(rect.right),
|
|
width: Math.ceil(rect.width),
|
|
visible:
|
|
style.display !== "none" &&
|
|
style.visibility !== "hidden" &&
|
|
Number(style.opacity) !== 0 &&
|
|
rect.width > 0 &&
|
|
rect.height > 0,
|
|
};
|
|
})
|
|
.filter((item) => item.visible && (item.left < -1 || item.right > viewportWidth + 1))
|
|
.slice(0, 8);
|
|
|
|
return { delta, viewportWidth, offenders };
|
|
});
|
|
|
|
expect(
|
|
overflow.delta,
|
|
`Horizontal overflow ${overflow.delta}px at ${overflow.viewportWidth}px viewport. Offenders: ${JSON.stringify(
|
|
overflow.offenders,
|
|
)}`,
|
|
).toBeLessThanOrEqual(1);
|
|
}
|
|
|
|
export async function expectNoDocumentOverflow(page: Page) {
|
|
await expect
|
|
.poll(async () => {
|
|
try {
|
|
return await page.evaluate(() => {
|
|
const doc = document.documentElement;
|
|
return {
|
|
x: Math.ceil(doc.scrollWidth - doc.clientWidth),
|
|
y: Math.ceil(doc.scrollHeight - doc.clientHeight),
|
|
};
|
|
});
|
|
} catch (err) {
|
|
if (isNavigationRace(err)) return { x: Number.MAX_SAFE_INTEGER, y: Number.MAX_SAFE_INTEGER };
|
|
throw err;
|
|
}
|
|
})
|
|
.toEqual({ x: 0, y: 0 });
|
|
}
|
|
|
|
function isNavigationRace(err: unknown) {
|
|
return err instanceof Error && /Execution context was destroyed|most likely because of a navigation/i.test(err.message);
|
|
}
|