1104 lines
43 KiB
TypeScript
1104 lines
43 KiB
TypeScript
import { expect, test, type Page, type Response } from "@playwright/test";
|
|
import {
|
|
expectNoHorizontalOverflow,
|
|
fetchAvailablePersona,
|
|
signInAsLearner,
|
|
signInAsTeacher,
|
|
} from "./support";
|
|
|
|
interface SessionStartResponse {
|
|
session_id: string;
|
|
}
|
|
|
|
async function expectResponseOk(response: { ok: () => boolean; text: () => Promise<string> }) {
|
|
if (!response.ok()) {
|
|
expect(response.ok(), await response.text()).toBeTruthy();
|
|
}
|
|
}
|
|
|
|
async function expectVisibleButtonsFit(page: Page, selector: string, context: string) {
|
|
const clippedButtons = await page.locator(selector).evaluateAll((buttons) =>
|
|
buttons
|
|
.map((button) => {
|
|
const rect = button.getBoundingClientRect();
|
|
const owner = button.closest<HTMLElement>(".pf-persona,.pf-panel") ?? button.parentElement;
|
|
const ownerRect = owner?.getBoundingClientRect();
|
|
const style = window.getComputedStyle(button);
|
|
const visible =
|
|
style.display !== "none" &&
|
|
style.visibility !== "hidden" &&
|
|
Number(style.opacity) !== 0 &&
|
|
rect.width > 0 &&
|
|
rect.height > 0;
|
|
const contentClipped =
|
|
button.scrollWidth > button.clientWidth + 1 ||
|
|
button.scrollHeight > button.clientHeight + 1;
|
|
const outsideOwner = ownerRect
|
|
? rect.left < ownerRect.left - 1 ||
|
|
rect.right > ownerRect.right + 1 ||
|
|
rect.top < ownerRect.top - 1 ||
|
|
rect.bottom > ownerRect.bottom + 1
|
|
: false;
|
|
|
|
return {
|
|
text: button.textContent?.replace(/\s+/g, " ").trim(),
|
|
width: Math.ceil(rect.width),
|
|
contentClipped,
|
|
outsideOwner,
|
|
visible,
|
|
};
|
|
})
|
|
.filter((button) => button.visible && (button.contentClipped || button.outsideOwner)),
|
|
);
|
|
|
|
expect(clippedButtons, `${context}: ${JSON.stringify(clippedButtons)}`).toEqual([]);
|
|
}
|
|
|
|
function isTeacherDashboardResponse(response: Response) {
|
|
const url = new URL(response.url());
|
|
return response.request().method() === "GET" && url.pathname.endsWith("/teacher/dashboard");
|
|
}
|
|
|
|
async function createEndedLearnerSession(page: Page) {
|
|
await signInAsLearner(page);
|
|
const persona = await fetchAvailablePersona(page);
|
|
const start = await page.request.post("/api/sessions", {
|
|
data: {
|
|
persona_code: persona.code,
|
|
theory_mode: "humanistic",
|
|
},
|
|
});
|
|
await expectResponseOk(start);
|
|
const session = (await start.json()) as SessionStartResponse;
|
|
const ended = await page.request.post(`/api/sessions/${session.session_id}/end`);
|
|
await expectResponseOk(ended);
|
|
return session.session_id;
|
|
}
|
|
|
|
function recentSessionFixture(index: number) {
|
|
const padded = String(index).padStart(2, "0");
|
|
return {
|
|
session_id: `mobile-readable-session-${padded}-00000000-0000-4000-9000-${padded}${padded}${padded}${padded}${padded}${padded}`,
|
|
learner_id: `learner-${padded}`,
|
|
learner_label: `E2E Learner ${padded}`,
|
|
persona_code: `P-MOBILE-${padded}`,
|
|
persona_name: `Responsive persona ${padded}`,
|
|
session_no: index,
|
|
status: index % 2 === 0 ? "active" : "ended",
|
|
stage: index % 2 === 0 ? "intervention-planning" : "rapport-and-assessment",
|
|
turn_count: 12 + index,
|
|
learner_turn_count: 6 + index,
|
|
client_turn_count: 6,
|
|
started_at: `2026-06-26T0${index}:10:00Z`,
|
|
ended_at: index % 2 === 0 ? null : `2026-06-26T0${index}:45:00Z`,
|
|
};
|
|
}
|
|
|
|
function teacherReviewResponse(sessionId: string) {
|
|
return {
|
|
session_id: sessionId,
|
|
client: {
|
|
name: "서연",
|
|
initial: "서",
|
|
persona: "P1 · 고난도",
|
|
},
|
|
date: "2026-06-27",
|
|
durationLabel: "32분",
|
|
durationSeconds: 1920,
|
|
reachedPhase: "정리",
|
|
sessionSignal: "종료됨",
|
|
supervisorState: "평가 완료",
|
|
supervisorName: "AI",
|
|
teacherReview: {
|
|
status: "pending",
|
|
note: "",
|
|
reviewerId: null,
|
|
reviewedAt: null,
|
|
updatedAt: null,
|
|
},
|
|
summary: "교수자가 검토할 수 있는 종료 회기 리뷰입니다.",
|
|
phases: [{ key: "closing", label: "정리", weight: 1 }],
|
|
phaseAxis: ["0:00", "32:00"],
|
|
valenceAxis: [],
|
|
clientValence: [],
|
|
counselorBaseline: [],
|
|
turns: [
|
|
{
|
|
id: "t1",
|
|
ts: "01:00",
|
|
speaker: "learner",
|
|
who: "학습자",
|
|
text: "오늘은 비교당할 때의 감정을 더 살펴보고 싶습니다.",
|
|
techniques: [{ kind: "explore", label: "탐색 질문" }],
|
|
nonverbal: [],
|
|
note: {
|
|
author: "평가 AI",
|
|
tone: "good",
|
|
title: "검토 가능",
|
|
body: "교수자가 읽을 수 있는 자동 평가 노트입니다.",
|
|
quote: null,
|
|
},
|
|
},
|
|
{
|
|
id: "t2",
|
|
ts: "02:10",
|
|
speaker: "client",
|
|
who: "서연",
|
|
text: "말하기는 어렵지만 계속 비교당하는 게 힘들어요.",
|
|
techniques: [],
|
|
nonverbal: [],
|
|
note: null,
|
|
},
|
|
],
|
|
rubric: [],
|
|
goodMoments: [],
|
|
growthPoints: [],
|
|
caseWorksheet: {
|
|
status: "draft_from_transcript",
|
|
generatedBy: "rule-based transcript extractor",
|
|
sections: [
|
|
{
|
|
key: "trigger",
|
|
title: "촉발 장면",
|
|
items: [
|
|
{
|
|
key: "comparison",
|
|
label: "비교 경험",
|
|
value: "반복 비교 상황에서 감정 탐색이 필요함.",
|
|
evidence: [{ turnId: "t2", speaker: "client", quote: "계속 비교당하는 게 힘들어요" }],
|
|
confidence: "medium",
|
|
emptyReason: null,
|
|
},
|
|
],
|
|
},
|
|
],
|
|
limitations: ["교수자 검토 화면에서는 학습자 제출물을 수정하지 않습니다."],
|
|
savedAt: null,
|
|
},
|
|
nextLine: null,
|
|
clientFeedback: null,
|
|
audioUrl: null,
|
|
pdfExportUrl: null,
|
|
degraded: false,
|
|
reviewReady: true,
|
|
};
|
|
}
|
|
|
|
test.describe("teacher console", () => {
|
|
test("lets a teacher approve a pending persona review from the console @single-run", async ({
|
|
page,
|
|
}) => {
|
|
await signInAsTeacher(page);
|
|
|
|
const personaId = "00000000-0000-0000-0000-000000009901";
|
|
const pendingPersona = {
|
|
persona_id: personaId,
|
|
code: "P2",
|
|
version: 3,
|
|
status: "review",
|
|
display_name: "검수 대기 페르소나",
|
|
difficulty: "moderate",
|
|
theory_target: ["humanistic"],
|
|
source_provenance: "faculty import",
|
|
is_synthetic: true,
|
|
created_at: "2026-06-26T07:00:00Z",
|
|
approved_at: null,
|
|
};
|
|
|
|
await page.route("**/api/teacher/dashboard", (route) =>
|
|
route.fulfill({
|
|
status: 200,
|
|
contentType: "application/json",
|
|
body: JSON.stringify({
|
|
source: "database",
|
|
cohort_label: "E2E cohort",
|
|
total_learners: 0,
|
|
active_sessions: 0,
|
|
ended_sessions: 0,
|
|
pending_reviews: [],
|
|
recent_sessions: [],
|
|
message: "검토할 실제 회기가 없습니다.",
|
|
}),
|
|
}),
|
|
);
|
|
await page.route("**/api/personas/review", (route) =>
|
|
route.fulfill({
|
|
status: 200,
|
|
contentType: "application/json",
|
|
body: JSON.stringify([pendingPersona]),
|
|
}),
|
|
);
|
|
await page.route(`**/api/personas/review/${personaId}`, async (route) => {
|
|
expect(route.request().method()).toBe("POST");
|
|
expect(route.request().postDataJSON()).toEqual({ action: "approve" });
|
|
await route.fulfill({
|
|
status: 200,
|
|
contentType: "application/json",
|
|
body: JSON.stringify({
|
|
...pendingPersona,
|
|
status: "approved",
|
|
approved_at: "2026-06-26T07:01:00Z",
|
|
}),
|
|
});
|
|
});
|
|
|
|
await page.goto("/teach");
|
|
|
|
const row = page.locator('[data-persona-review-row="true"]').filter({
|
|
hasText: "검수 대기 페르소나",
|
|
});
|
|
await expect(row).toBeVisible();
|
|
await expect(row.getByText("검수 대기", { exact: true })).toBeVisible();
|
|
await expectVisibleButtonsFit(page, ".pf-persona__actions .vg-btn", "persona review actions");
|
|
|
|
await row.getByRole("button", { name: "승인" }).click();
|
|
|
|
await expect(row).toHaveCount(0);
|
|
await expect(page.getByText("검수 대기 페르소나 없음")).toBeVisible();
|
|
await expectNoHorizontalOverflow(page);
|
|
});
|
|
|
|
test("lets a teacher revise an approved persona from persona studio @single-run", async ({ page }) => {
|
|
const personaId = "00000000-0000-0000-0000-000000000701";
|
|
let revisionRequested = false;
|
|
const approvedPersona = {
|
|
persona_id: personaId,
|
|
code: "P1",
|
|
version: 1,
|
|
status: "approved",
|
|
display_name: "서연(가명) · 고2 · 우울/자살사고",
|
|
difficulty: "hard",
|
|
theory_target: ["humanistic"],
|
|
demographics: { age_band: "F-teen" },
|
|
presenting_summary: "최근 무기력과 자살사고를 호소합니다.",
|
|
source: "database",
|
|
degraded: false,
|
|
voice_preset: null,
|
|
};
|
|
const draftDetail = {
|
|
...approvedPersona,
|
|
version: 2,
|
|
status: "draft",
|
|
source_provenance: "bootstrap seed migrated to editable catalog",
|
|
is_synthetic: true,
|
|
created_at: "2026-06-28T00:00:00Z",
|
|
approved_at: null,
|
|
presenting: { complaint: "최근 무기력과 자살사고를 호소합니다." },
|
|
history: { family: "가족 갈등" },
|
|
big5: { O: 0.5, C: 0.4, E: 0.3, A: 0.6, N: 0.8 },
|
|
resistance: { base_resistance: 0.6, unlock_rate: 0.1, decay_floor: 0.05 },
|
|
speech_style: { register: "polite", honorific: true },
|
|
affect_baseline: { negative_affect: 0.7, anxiety: 0.4, suicide_ideation_stage: 1 },
|
|
ccd: { core_belief: "나는 짐이 된다" },
|
|
dsm5_dimensional: { depression: "moderate" },
|
|
triggers: { sore_spots: ["평가절하"], forbidden: ["단정"] },
|
|
};
|
|
|
|
await signInAsTeacher(page);
|
|
await page.route("**/api/personas", (route) => {
|
|
if (route.request().method() !== "GET") return route.fallback();
|
|
return route.fulfill({
|
|
status: 200,
|
|
contentType: "application/json",
|
|
body: JSON.stringify([approvedPersona]),
|
|
});
|
|
});
|
|
await page.route("**/api/personas/review", (route) =>
|
|
route.fulfill({ status: 200, contentType: "application/json", body: JSON.stringify([]) }),
|
|
);
|
|
await page.route(`**/api/personas/${personaId}/revisions`, async (route) => {
|
|
revisionRequested = true;
|
|
expect(route.request().method()).toBe("POST");
|
|
expect(route.request().postDataJSON()).toEqual({ submit_for_review: false });
|
|
await route.fulfill({
|
|
status: 201,
|
|
contentType: "application/json",
|
|
body: JSON.stringify(draftDetail),
|
|
});
|
|
});
|
|
|
|
await page.goto("/teach/personas");
|
|
const row = page.locator('[data-approved-persona-row="true"]').filter({ hasText: "P1" });
|
|
await expect(row).toBeVisible();
|
|
await row.getByRole("button", { name: "수정" }).click();
|
|
|
|
await expect(page.getByText("P1 v2 수정 초안을 불러왔습니다.")).toBeVisible();
|
|
await expect(page.getByLabel("표시 이름")).toHaveValue("서연(가명) · 고2 · 우울/자살사고");
|
|
await expect(page.getByLabel("코드")).toHaveValue("P1");
|
|
expect(revisionRequested).toBeTruthy();
|
|
await expectNoHorizontalOverflow(page);
|
|
});
|
|
|
|
test("saves persona studio list rows as structured arrays @single-run", async ({ page }) => {
|
|
type PersonaDraftSavePayload = {
|
|
ccd: { automatic_thought: string[] };
|
|
code: string;
|
|
difficulty: string;
|
|
display_name: string;
|
|
is_synthetic: boolean;
|
|
source_provenance: unknown;
|
|
theory_target: string;
|
|
triggers: { forbidden: string[]; sore_spots: string[] };
|
|
};
|
|
let savedPayload: PersonaDraftSavePayload | null = null;
|
|
|
|
await signInAsTeacher(page);
|
|
await page.route("**/api/personas", (route) => {
|
|
if (route.request().method() !== "GET") return route.fallback();
|
|
return route.fulfill({ status: 200, contentType: "application/json", body: JSON.stringify([]) });
|
|
});
|
|
await page.route("**/api/personas/review", (route) => {
|
|
if (route.request().method() !== "GET") return route.fallback();
|
|
return route.fulfill({ status: 200, contentType: "application/json", body: JSON.stringify([]) });
|
|
});
|
|
await page.route("**/api/personas/drafts", async (route) => {
|
|
if (route.request().method() !== "POST") return route.fallback();
|
|
savedPayload = route.request().postDataJSON() as PersonaDraftSavePayload;
|
|
await route.fulfill({
|
|
status: 201,
|
|
contentType: "application/json",
|
|
body: JSON.stringify({
|
|
persona_id: "00000000-0000-0000-0000-000000000703",
|
|
code: savedPayload.code,
|
|
version: 1,
|
|
status: "draft",
|
|
display_name: savedPayload.display_name,
|
|
difficulty: savedPayload.difficulty,
|
|
theory_target: savedPayload.theory_target,
|
|
source_provenance: savedPayload.source_provenance,
|
|
is_synthetic: savedPayload.is_synthetic,
|
|
created_at: "2026-06-28T00:00:00Z",
|
|
approved_at: null,
|
|
}),
|
|
});
|
|
});
|
|
|
|
await page.goto("/teach/personas");
|
|
await page.getByLabel("표시 이름").fill("항목형 페르소나");
|
|
|
|
await page.getByRole("tab", { name: "임상" }).click();
|
|
const automaticThoughts = page.locator(".ps-list-field").filter({ hasText: "자동사고" });
|
|
await automaticThoughts.getByRole("textbox", { name: "자동사고 1", exact: true }).fill("삭제될 자동사고");
|
|
await automaticThoughts.getByRole("button", { name: "항목 추가" }).click();
|
|
await automaticThoughts.getByRole("textbox", { name: "자동사고 2", exact: true }).fill("남길 자동사고");
|
|
await automaticThoughts.getByRole("button", { name: "자동사고 1 삭제" }).click();
|
|
|
|
await page.getByRole("tab", { name: "안전" }).click();
|
|
const forbidden = page.locator(".ps-list-field").filter({ hasText: "상담자 금기" });
|
|
await forbidden.getByRole("textbox", { name: "상담자 금기 1", exact: true }).fill("네가 예민한 거라고 단정");
|
|
|
|
await page.getByRole("button", { name: "초안 저장" }).click();
|
|
await expect(page.getByText("P1 v1 초안을 저장했습니다.")).toBeVisible();
|
|
|
|
expect(savedPayload).toBeTruthy();
|
|
expect(savedPayload?.ccd.automatic_thought).toEqual(["남길 자동사고"]);
|
|
expect(savedPayload?.triggers.forbidden).toEqual(["네가 예민한 거라고 단정"]);
|
|
expect(savedPayload?.triggers.sore_spots).toEqual([]);
|
|
await expectNoHorizontalOverflow(page);
|
|
});
|
|
|
|
test("renders persona prompt preview as labeled sections without raw JSON @single-run", async ({ page }) => {
|
|
await signInAsTeacher(page);
|
|
await page.route("**/api/personas", (route) => {
|
|
if (route.request().method() !== "GET") return route.fallback();
|
|
return route.fulfill({ status: 200, contentType: "application/json", body: JSON.stringify([]) });
|
|
});
|
|
await page.route("**/api/personas/review", (route) => {
|
|
if (route.request().method() !== "GET") return route.fallback();
|
|
return route.fulfill({ status: 200, contentType: "application/json", body: JSON.stringify([]) });
|
|
});
|
|
|
|
await page.goto("/teach/personas");
|
|
await page.getByLabel("표시 이름").fill("프롬프트 검토 페르소나");
|
|
await page.getByRole("tab", { name: "임상" }).click();
|
|
const automaticThoughts = page.locator(".ps-list-field").filter({ hasText: "자동사고" });
|
|
await automaticThoughts.getByRole("textbox", { name: "자동사고 1", exact: true }).fill("말하면 더 이상하게 볼 거야");
|
|
await page.getByRole("tab", { name: "안전" }).click();
|
|
const forbidden = page.locator(".ps-list-field").filter({ hasText: "상담자 금기" });
|
|
await forbidden.getByRole("textbox", { name: "상담자 금기 1", exact: true }).fill("네가 예민한 거라고 단정");
|
|
|
|
await page.getByRole("tab", { name: "프롬프트" }).click();
|
|
const promptPreview = page.getByLabel("프롬프트 미리보기");
|
|
await expect(promptPreview.getByRole("heading", { name: /L1 페르소나 카드/ })).toBeVisible();
|
|
await expect(promptPreview.getByText("자동사고")).toBeVisible();
|
|
await expect(promptPreview.getByText("말하면 더 이상하게 볼 거야")).toBeVisible();
|
|
await expect(promptPreview.getByText("상담자 금기")).toBeVisible();
|
|
await expect(promptPreview.getByText("네가 예민한 거라고 단정")).toBeVisible();
|
|
await expect(promptPreview.getByRole("textbox")).toHaveCount(0);
|
|
await expect(promptPreview).not.toContainText('"automatic_thought"');
|
|
await expect(promptPreview).not.toContainText('"forbidden"');
|
|
await expect(promptPreview).not.toContainText("{");
|
|
await expectNoHorizontalOverflow(page);
|
|
});
|
|
|
|
test("archives an approved persona from persona studio without layout drift @single-run", async ({ page }) => {
|
|
await page.setViewportSize({ width: 390, height: 844 });
|
|
const personaId = "00000000-0000-0000-0000-000000000702";
|
|
let archived = false;
|
|
const approvedPersona = {
|
|
persona_id: personaId,
|
|
code: "P7",
|
|
version: 1,
|
|
status: "approved",
|
|
display_name: "도현(가명) · 고3 · 입시 번아웃/무기력",
|
|
difficulty: "moderate",
|
|
theory_target: ["humanistic"],
|
|
demographics: { age_band: "M-teen" },
|
|
presenting_summary: "입시 번아웃과 무기력",
|
|
source: "database",
|
|
degraded: false,
|
|
voice_preset: null,
|
|
};
|
|
|
|
await signInAsTeacher(page);
|
|
await page.route("**/api/personas", (route) => {
|
|
if (route.request().method() !== "GET") return route.fallback();
|
|
return route.fulfill({
|
|
status: 200,
|
|
contentType: "application/json",
|
|
body: JSON.stringify(archived ? [] : [approvedPersona]),
|
|
});
|
|
});
|
|
await page.route("**/api/personas/review", (route) =>
|
|
route.fulfill({ status: 200, contentType: "application/json", body: JSON.stringify([]) }),
|
|
);
|
|
await page.route(`**/api/personas/${personaId}`, async (route) => {
|
|
archived = true;
|
|
expect(route.request().method()).toBe("DELETE");
|
|
await route.fulfill({
|
|
status: 200,
|
|
contentType: "application/json",
|
|
body: JSON.stringify({
|
|
persona_id: personaId,
|
|
code: "P7",
|
|
version: 1,
|
|
status: "archived",
|
|
display_name: approvedPersona.display_name,
|
|
difficulty: approvedPersona.difficulty,
|
|
theory_target: approvedPersona.theory_target,
|
|
source_provenance: "bootstrap seed migrated to editable catalog",
|
|
is_synthetic: true,
|
|
created_at: "2026-06-28T00:00:00Z",
|
|
approved_at: null,
|
|
}),
|
|
});
|
|
});
|
|
|
|
await page.goto("/teach/personas");
|
|
const row = page.locator('[data-approved-persona-row="true"]').filter({ hasText: "P7" });
|
|
await expect(row).toBeVisible();
|
|
await expectVisibleButtonsFit(page, ".ps-approved-row__actions .vg-btn", "approved persona actions");
|
|
page.once("dialog", (dialog) => dialog.accept());
|
|
await row.getByRole("button", { name: "삭제" }).click();
|
|
|
|
await expect(page.getByText("P7 페르소나를 보관 처리했습니다.")).toBeVisible();
|
|
await expect(page.getByText("공개 목록 없음")).toBeVisible();
|
|
expect(archived).toBeTruthy();
|
|
await expectNoHorizontalOverflow(page);
|
|
});
|
|
|
|
test("renders real server sessions from server-owned rows", async ({ page }) => {
|
|
const sessionId = await createEndedLearnerSession(page);
|
|
await signInAsTeacher(page);
|
|
|
|
const dashboardResponsePromise = page.waitForResponse(isTeacherDashboardResponse);
|
|
await page.goto("/teach");
|
|
const dashboardResponse = await dashboardResponsePromise;
|
|
await expectResponseOk(dashboardResponse);
|
|
|
|
const dashboard = await dashboardResponse.json();
|
|
expect(dashboard.recent_sessions.some((session: { session_id: string }) => session.session_id === sessionId)).toBe(
|
|
true,
|
|
);
|
|
|
|
await expect(page.locator("code").filter({ hasText: sessionId }).first()).toBeVisible();
|
|
await expect(page.getByRole("heading", { name: /\d+건의 리뷰가 대기 중입니다\./ })).toBeVisible();
|
|
await expect(page.getByText("3명에게 개입")).toHaveCount(0);
|
|
await expect(page.getByText("김상담")).toHaveCount(0);
|
|
await expectNoHorizontalOverflow(page);
|
|
});
|
|
|
|
test("shows selected learner analysis with the full session timeline @single-run", async ({
|
|
page,
|
|
}) => {
|
|
const learnerA = "teacher-analysis-learner-a";
|
|
const learnerB = "teacher-analysis-learner-b";
|
|
const sessionFor = (learnerId: string, label: string, index: number) => ({
|
|
session_id: `${learnerId}-session-${index}`,
|
|
learner_id: learnerId,
|
|
learner_label: label,
|
|
persona_code: index % 2 === 0 ? "P2" : "P1",
|
|
persona_name: index % 2 === 0 ? "민재" : "서연",
|
|
session_no: index,
|
|
status: "ended",
|
|
stage: index > 4 ? "개입" : "탐색",
|
|
turn_count: 8 + index,
|
|
learner_turn_count: 4 + index,
|
|
client_turn_count: 4,
|
|
started_at: `2026-06-${String(10 + index).padStart(2, "0")}T09:00:00Z`,
|
|
ended_at: `2026-06-${String(10 + index).padStart(2, "0")}T09:30:00Z`,
|
|
review_status: index === 2 ? "closed" : "pending",
|
|
review_note: null,
|
|
reviewed_at: index === 2 ? "2026-06-12T10:00:00Z" : null,
|
|
});
|
|
const pointFor = (learnerId: string, index: number) => ({
|
|
session_id: `${learnerId}-session-${index}`,
|
|
session_no: index,
|
|
persona_code: index % 2 === 0 ? "P2" : "P1",
|
|
stage: index > 4 ? "개입" : "탐색",
|
|
started_at: `2026-06-${String(10 + index).padStart(2, "0")}T09:00:00Z`,
|
|
ended_at: `2026-06-${String(10 + index).padStart(2, "0")}T09:30:00Z`,
|
|
score: index >= 5 ? 1 : 0.5,
|
|
rapport: Math.min(0.8, index * 0.1),
|
|
technique_count: index + 1,
|
|
watch_count: index < 5 ? 1 : 0,
|
|
});
|
|
const analysisFor = (learnerId: string, label: string, count: number) => {
|
|
const sessions = Array.from({ length: count }, (_unused, idx) =>
|
|
sessionFor(learnerId, label, idx + 1),
|
|
);
|
|
const points = Array.from({ length: count }, (_unused, idx) =>
|
|
pointFor(learnerId, idx + 1),
|
|
);
|
|
return {
|
|
source: "database",
|
|
learner_id: learnerId,
|
|
learner_label: label,
|
|
total_sessions: count,
|
|
active_sessions: 0,
|
|
ended_sessions: count,
|
|
pending_reviews: Math.max(0, count - 1),
|
|
closed_reviews: count > 1 ? 1 : 0,
|
|
summary: {
|
|
learner_id: learnerId,
|
|
learner_label: label,
|
|
sessions: count,
|
|
ended_sessions: count,
|
|
latest_at: sessions[count - 1].ended_at ?? "",
|
|
first_score: points[0].score,
|
|
latest_score: points[count - 1].score,
|
|
score_delta: (points[count - 1].score ?? 0) - (points[0].score ?? 0),
|
|
avg_score: 0.75,
|
|
avg_rapport: 0.4,
|
|
trend: count > 3 ? "up" : "flat",
|
|
top_techniques: ["reflection", "open question"],
|
|
points,
|
|
},
|
|
points,
|
|
stage_breakdown: [
|
|
{ stage: "라포", sessions: 0, turns: 0 },
|
|
{ stage: "탐색", sessions: Math.min(4, count), turns: 34 },
|
|
{ stage: "개입", sessions: Math.max(0, count - 4), turns: 42 },
|
|
{ stage: "정리", sessions: 0, turns: 0 },
|
|
],
|
|
sessions,
|
|
message: `${label} 전체 회기 ${count}건`,
|
|
};
|
|
};
|
|
const analysisA = analysisFor(learnerA, "사용자 A", 7);
|
|
const analysisB = analysisFor(learnerB, "사용자 B", 2);
|
|
|
|
await page.route("**/api/teacher/dashboard", (route) =>
|
|
route.fulfill({
|
|
status: 200,
|
|
contentType: "application/json",
|
|
body: JSON.stringify({
|
|
source: "database",
|
|
cohort_label: "E2E cohort",
|
|
total_learners: 2,
|
|
active_sessions: 0,
|
|
ended_sessions: 9,
|
|
learner_growth: [
|
|
{ ...analysisA.summary, points: analysisA.points.slice(-6) },
|
|
{ ...analysisB.summary, points: analysisB.points },
|
|
],
|
|
safety_alerts: [],
|
|
pending_reviews: [],
|
|
recent_sessions: analysisA.sessions.slice(-2),
|
|
message: "사용자별 분석 fixture.",
|
|
}),
|
|
}),
|
|
);
|
|
await page.route("**/api/teacher/learners/*/analysis", (route) => {
|
|
const path = new URL(route.request().url()).pathname;
|
|
const body = path.includes(learnerB) ? analysisB : analysisA;
|
|
return route.fulfill({
|
|
status: 200,
|
|
contentType: "application/json",
|
|
body: JSON.stringify(body),
|
|
});
|
|
});
|
|
await page.route("**/api/personas/review", (route) =>
|
|
route.fulfill({ status: 200, contentType: "application/json", body: "[]" }),
|
|
);
|
|
|
|
await signInAsTeacher(page);
|
|
await page.goto("/teach");
|
|
|
|
await expect(page.getByRole("link", { name: "학생 분석" })).toBeVisible();
|
|
await expect(page.locator('[data-learner-analysis-panel="true"]')).toHaveCount(0);
|
|
await page.getByRole("link", { name: "학생 분석" }).click();
|
|
await expect(page).toHaveURL(/\/teach\/analysis$/);
|
|
|
|
const overviewTable = page.locator('[data-learner-overview-table="true"]');
|
|
await expect(overviewTable).toBeVisible();
|
|
await expect(page.locator('[data-learner-overview-row="true"]')).toHaveCount(2);
|
|
await expect(page.locator('[data-learner-analysis-panel="true"]')).toHaveCount(0);
|
|
|
|
await page.getByLabel("학습자 검색").fill("사용자 B");
|
|
const learnerBRow = page
|
|
.locator('[data-learner-overview-row="true"]')
|
|
.filter({ hasText: "사용자 B" });
|
|
await expect(learnerBRow).toHaveCount(1);
|
|
await expect(learnerBRow.getByText(learnerB)).toBeVisible();
|
|
await expect(learnerBRow.getByRole("button", { name: "사용자 B", exact: true })).toBeVisible();
|
|
await learnerBRow.getByRole("button", { name: "사용자 B 요약 펼치기" }).click();
|
|
await expect(page.locator('[data-learner-expanded-row="true"]')).toBeVisible();
|
|
await expect(page.locator('[data-learner-expanded-row="true"]').getByText("회기별 추이")).toBeVisible();
|
|
await learnerBRow.getByRole("button", { name: "사용자 B 상세 보기" }).click();
|
|
await expect(page).toHaveURL(new RegExp(`/teach/analysis\\?learner=${learnerB}$`));
|
|
|
|
const analysisPanel = page.locator('[data-learner-analysis-panel="true"]');
|
|
await expect(analysisPanel).toBeVisible();
|
|
await expect(analysisPanel.locator('[data-learner-session-row="true"]')).toHaveCount(0);
|
|
await analysisPanel.getByRole("tab", { name: /^전체 회기/ }).click();
|
|
await expect(analysisPanel.locator('[data-learner-session-row="true"]')).toHaveCount(2);
|
|
await expect(analysisPanel.getByText(`${learnerB}-session-2`)).toBeVisible();
|
|
await expect(analysisPanel.getByText(`${learnerA}-session-7`)).toHaveCount(0);
|
|
await expect(page.getByText("전체 회기 2건")).toBeVisible();
|
|
|
|
await page.getByRole("button", { name: "전체 목록" }).click();
|
|
await expect(page).toHaveURL(/\/teach\/analysis$/);
|
|
await expect(page.locator('[data-learner-overview-table="true"]')).toBeVisible();
|
|
await expect(page.locator('[data-learner-overview-row="true"]')).toHaveCount(1);
|
|
await expectNoHorizontalOverflow(page);
|
|
});
|
|
|
|
test("opens a pending session review from the teacher queue @single-run", async ({ page }) => {
|
|
const sessionId = "teacher-review-fixture-session";
|
|
await page.route("**/api/teacher/dashboard", (route) =>
|
|
route.fulfill({
|
|
status: 200,
|
|
contentType: "application/json",
|
|
body: JSON.stringify({
|
|
source: "database",
|
|
cohort_label: "E2E cohort",
|
|
total_learners: 1,
|
|
active_sessions: 0,
|
|
ended_sessions: 1,
|
|
learner_growth: [],
|
|
safety_alerts: [],
|
|
pending_reviews: [
|
|
{
|
|
session_id: sessionId,
|
|
learner_id: "00000000-0000-0000-0000-000000000111",
|
|
learner_label: "E2E Learner",
|
|
persona_code: "P1",
|
|
persona_name: "서연",
|
|
session_no: 1,
|
|
status: "ended",
|
|
stage: "정리",
|
|
turn_count: 6,
|
|
learner_turn_count: 3,
|
|
client_turn_count: 3,
|
|
started_at: "2026-06-27T07:00:00Z",
|
|
ended_at: "2026-06-27T07:32:00Z",
|
|
review_status: "pending",
|
|
review_note: null,
|
|
reviewed_at: null,
|
|
},
|
|
],
|
|
recent_sessions: [],
|
|
message: "교수자 검토 대기 회기가 있습니다.",
|
|
}),
|
|
}),
|
|
);
|
|
await page.route("**/api/personas/review", (route) =>
|
|
route.fulfill({
|
|
status: 200,
|
|
contentType: "application/json",
|
|
body: "[]",
|
|
}),
|
|
);
|
|
await page.route(`**/api/sessions/${sessionId}/review`, (route) =>
|
|
route.fulfill({
|
|
status: 200,
|
|
contentType: "application/json",
|
|
body: JSON.stringify(teacherReviewResponse(sessionId)),
|
|
}),
|
|
);
|
|
await page.route(`**/api/teacher/sessions/${sessionId}/review-status`, async (route) => {
|
|
const body = route.request().postDataJSON() as { status: string; note: string };
|
|
await route.fulfill({
|
|
status: 200,
|
|
contentType: "application/json",
|
|
body: JSON.stringify({
|
|
session_id: sessionId,
|
|
status: body.status,
|
|
note: body.note,
|
|
reviewer_id: "00000000-0000-0000-0000-000000000901",
|
|
reviewed_at: body.status === "closed" ? "2026-06-27T10:00:00Z" : null,
|
|
updated_at: "2026-06-27T10:00:00Z",
|
|
}),
|
|
});
|
|
});
|
|
|
|
await signInAsTeacher(page);
|
|
await page.goto("/teach");
|
|
|
|
await expect(page.locator(".pf-triage")).toBeVisible();
|
|
await expect(page.locator(".pf-triage")).toContainText("리뷰 대기");
|
|
const row = page.getByRole("button", { name: /E2E Learner P1 회기 상세 검토/ });
|
|
await expect(row).toBeVisible();
|
|
await row.click();
|
|
|
|
await expect(page).toHaveURL(new RegExp(`/teach/session/${sessionId}/review$`));
|
|
await expect(page.getByText("교수자 검토 화면", { exact: true })).toBeVisible();
|
|
await expect(page.getByText("교수자 검토", { exact: true })).toBeVisible();
|
|
await expect(page.getByText("축어록 자동 초안 읽기 전용")).toBeVisible();
|
|
await expect(page.getByText("검토 전용")).toBeVisible();
|
|
await page.getByLabel("검토 메모").fill("다음 회기에서 감정 반영을 먼저 확인");
|
|
await page.getByRole("button", { name: "검토 완료" }).click();
|
|
await expect(page.getByText("완료 시각 2026-06-27T10:00:00Z")).toBeVisible();
|
|
await expect(page.getByRole("button", { name: "검토 완료" })).toBeDisabled();
|
|
await expect(page.getByRole("button", { name: "교수 콘솔로" })).toBeVisible();
|
|
await expect(page.getByRole("button", { name: /^저장/ })).toHaveCount(0);
|
|
await expectNoHorizontalOverflow(page);
|
|
});
|
|
|
|
test("opens recent ended and active sessions from the teacher history @single-run", async ({
|
|
page,
|
|
}) => {
|
|
const endedSession = {
|
|
...recentSessionFixture(1),
|
|
session_id: "teacher-recent-ended-session",
|
|
learner_label: "Recent Ended Learner",
|
|
persona_code: "P1",
|
|
status: "ended",
|
|
ended_at: "2026-06-27T07:32:00Z",
|
|
};
|
|
const activeSession = {
|
|
...recentSessionFixture(2),
|
|
session_id: "teacher-recent-active-session",
|
|
learner_label: "Recent Active Learner",
|
|
persona_code: "P2",
|
|
status: "active",
|
|
ended_at: null,
|
|
};
|
|
|
|
await page.route("**/api/teacher/dashboard", (route) =>
|
|
route.fulfill({
|
|
status: 200,
|
|
contentType: "application/json",
|
|
body: JSON.stringify({
|
|
source: "database",
|
|
cohort_label: "E2E cohort",
|
|
total_learners: 2,
|
|
active_sessions: 1,
|
|
ended_sessions: 1,
|
|
learner_growth: [],
|
|
safety_alerts: [],
|
|
pending_reviews: [],
|
|
recent_sessions: [endedSession, activeSession],
|
|
message: "최근 회기 기록 fixture.",
|
|
}),
|
|
}),
|
|
);
|
|
await page.route("**/api/personas/review", (route) =>
|
|
route.fulfill({
|
|
status: 200,
|
|
contentType: "application/json",
|
|
body: "[]",
|
|
}),
|
|
);
|
|
await page.route(`**/api/sessions/${endedSession.session_id}/review`, (route) =>
|
|
route.fulfill({
|
|
status: 200,
|
|
contentType: "application/json",
|
|
body: JSON.stringify(teacherReviewResponse(endedSession.session_id)),
|
|
}),
|
|
);
|
|
await page.route(`**/api/sessions/${activeSession.session_id}/review`, (route) =>
|
|
route.fulfill({
|
|
status: 200,
|
|
contentType: "application/json",
|
|
body: JSON.stringify({
|
|
...teacherReviewResponse(activeSession.session_id),
|
|
sessionSignal: "진행 중",
|
|
supervisorState: "평가 대기",
|
|
summary: "진행 중인 세션의 현재 기록을 교수자가 읽기 전용으로 확인합니다.",
|
|
reviewReady: false,
|
|
degraded: true,
|
|
}),
|
|
}),
|
|
);
|
|
|
|
await signInAsTeacher(page);
|
|
await page.goto("/teach");
|
|
|
|
const endedRow = page.getByRole("button", {
|
|
name: /Recent Ended Learner P1 상세 리뷰/,
|
|
});
|
|
await expect(endedRow).toBeVisible();
|
|
await endedRow.click();
|
|
|
|
await expect(page).toHaveURL(new RegExp(`/teach/session/${endedSession.session_id}/review$`));
|
|
await expect(page.getByText("교수자 검토 화면", { exact: true })).toBeVisible();
|
|
await expect(page.getByText("종료됨", { exact: true })).toBeVisible();
|
|
|
|
await page.getByRole("button", { name: "교수 콘솔로" }).click();
|
|
const activeRow = page.getByRole("button", {
|
|
name: /Recent Active Learner P2 진행 기록/,
|
|
});
|
|
await expect(activeRow).toBeVisible();
|
|
await activeRow.click();
|
|
|
|
await expect(page).toHaveURL(new RegExp(`/teach/session/${activeSession.session_id}/review$`));
|
|
await expect(page.getByText("교수자 검토 화면", { exact: true })).toBeVisible();
|
|
await expect(page.getByText("진행 중", { exact: true })).toBeVisible();
|
|
await expect(page.getByText("평가 대기", { exact: true })).toBeVisible();
|
|
await expectNoHorizontalOverflow(page);
|
|
});
|
|
|
|
test("opens a recent session review from the teacher history table @single-run", async ({ page }) => {
|
|
const sessionId = "teacher-recent-fixture-session";
|
|
await page.route("**/api/teacher/dashboard", (route) =>
|
|
route.fulfill({
|
|
status: 200,
|
|
contentType: "application/json",
|
|
body: JSON.stringify({
|
|
source: "database",
|
|
cohort_label: "E2E cohort",
|
|
total_learners: 1,
|
|
active_sessions: 1,
|
|
ended_sessions: 0,
|
|
learner_growth: [],
|
|
safety_alerts: [],
|
|
pending_reviews: [],
|
|
recent_sessions: [
|
|
{
|
|
session_id: sessionId,
|
|
learner_id: "00000000-0000-0000-0000-000000000222",
|
|
learner_label: "Recent Learner",
|
|
persona_code: "P2",
|
|
persona_name: "민재",
|
|
session_no: 2,
|
|
status: "active",
|
|
stage: "탐색",
|
|
turn_count: 4,
|
|
learner_turn_count: 2,
|
|
client_turn_count: 2,
|
|
started_at: "2026-06-27T08:00:00Z",
|
|
ended_at: null,
|
|
},
|
|
],
|
|
message: "최근 진행 회기가 있습니다.",
|
|
}),
|
|
}),
|
|
);
|
|
await page.route("**/api/personas/review", (route) =>
|
|
route.fulfill({
|
|
status: 200,
|
|
contentType: "application/json",
|
|
body: "[]",
|
|
}),
|
|
);
|
|
const review = teacherReviewResponse(sessionId);
|
|
review.sessionSignal = "진행 중";
|
|
review.supervisorState = "평가 대기";
|
|
review.reviewReady = false;
|
|
await page.route(`**/api/sessions/${sessionId}/review`, (route) =>
|
|
route.fulfill({
|
|
status: 200,
|
|
contentType: "application/json",
|
|
body: JSON.stringify(review),
|
|
}),
|
|
);
|
|
|
|
await signInAsTeacher(page);
|
|
await page.goto("/teach");
|
|
|
|
const row = page.getByRole("button", { name: /Recent Learner P2 진행 기록/ });
|
|
await expect(row).toBeVisible();
|
|
await row.press("Enter");
|
|
|
|
await expect(page).toHaveURL(new RegExp(`/teach/session/${sessionId}/review$`));
|
|
await expect(page.getByText("교수자 검토 화면", { exact: true })).toBeVisible();
|
|
await expect(page.getByText("진행 중", { exact: true })).toBeVisible();
|
|
await expect(page.getByText("검토 전용")).toBeVisible();
|
|
await expect(page.getByRole("button", { name: /^저장/ })).toHaveCount(0);
|
|
await expectNoHorizontalOverflow(page);
|
|
});
|
|
|
|
test("keeps recent sessions readable without horizontal scrolling across breakpoints", async ({
|
|
page,
|
|
}) => {
|
|
const recentSessions = [1, 2, 3].map(recentSessionFixture);
|
|
await page.route("**/api/teacher/dashboard", (route) =>
|
|
route.fulfill({
|
|
status: 200,
|
|
contentType: "application/json",
|
|
body: JSON.stringify({
|
|
source: "database",
|
|
cohort_label: "E2E cohort",
|
|
total_learners: recentSessions.length,
|
|
active_sessions: 1,
|
|
ended_sessions: 2,
|
|
pending_reviews: [],
|
|
recent_sessions: recentSessions,
|
|
message: "Fixture-backed recent session layout check.",
|
|
}),
|
|
}),
|
|
);
|
|
await page.route("**/api/personas/review", (route) =>
|
|
route.fulfill({
|
|
status: 200,
|
|
contentType: "application/json",
|
|
body: "[]",
|
|
}),
|
|
);
|
|
await signInAsTeacher(page);
|
|
|
|
await page.goto("/teach");
|
|
await expect(page.locator(".pf-recent-list")).toBeVisible();
|
|
await expect(page.locator('[data-recent-session-row="true"]')).toHaveCount(
|
|
recentSessions.length,
|
|
);
|
|
await expectNoHorizontalOverflow(page);
|
|
|
|
const metrics = await page.evaluate(() => {
|
|
const doc = document.documentElement;
|
|
const list = document.querySelector<HTMLElement>(".pf-recent-list");
|
|
const header = document.querySelector<HTMLElement>(".pf-recent-head");
|
|
const row = document.querySelector<HTMLElement>('[data-recent-session-row="true"]');
|
|
const cells = Array.from(row?.querySelectorAll<HTMLElement>(".pf-recent__cell") ?? []);
|
|
if (!list || !header || !row || cells.length === 0) {
|
|
throw new Error("recent sessions list was not rendered");
|
|
}
|
|
const listRect = list.getBoundingClientRect();
|
|
const rowRect = row.getBoundingClientRect();
|
|
return {
|
|
viewportWidth: doc.clientWidth,
|
|
listOverflowX: Math.ceil(list.scrollWidth - list.clientWidth),
|
|
headerDisplay: window.getComputedStyle(header).display,
|
|
headerPosition: window.getComputedStyle(header).position,
|
|
rowDisplay: window.getComputedStyle(row).display,
|
|
gridCellCount: cells.filter((cell) => window.getComputedStyle(cell).display === "grid").length,
|
|
labels: cells.map((cell) => cell.getAttribute("data-label")),
|
|
rowRight: Math.ceil(rowRect.right),
|
|
listRight: Math.ceil(listRect.right),
|
|
};
|
|
});
|
|
|
|
expect(metrics.listOverflowX).toBeLessThanOrEqual(1);
|
|
expect(metrics.rowRight).toBeLessThanOrEqual(metrics.listRight + 1);
|
|
if (metrics.viewportWidth <= 860) {
|
|
expect(metrics.headerDisplay).toBe("none");
|
|
expect(metrics.rowDisplay).toBe("grid");
|
|
expect(metrics.gridCellCount).toBe(7);
|
|
expect(metrics.labels).toEqual(["페르소나", "상태", "단계", "턴", "시작", "종료", "열기"]);
|
|
} else {
|
|
expect(metrics.headerDisplay).toBe("grid");
|
|
expect(metrics.headerPosition).toBe("sticky");
|
|
expect(metrics.rowDisplay).toBe("grid");
|
|
expect(metrics.gridCellCount).toBe(0);
|
|
}
|
|
});
|
|
|
|
test("keeps long teacher lists in bounded panels", async ({ page }) => {
|
|
await createEndedLearnerSession(page);
|
|
await signInAsTeacher(page);
|
|
|
|
await page.goto("/teach");
|
|
await expect(page.locator(".pf-list")).toBeVisible();
|
|
await expect(page.locator(".pf-recent-list")).toBeVisible();
|
|
|
|
const metrics = await page.evaluate(() => {
|
|
const list = document.querySelector<HTMLElement>(".pf-list");
|
|
const recent = document.querySelector<HTMLElement>(".pf-recent-list");
|
|
const header = document.querySelector<HTMLElement>(".pf-recent-head");
|
|
if (!list || !recent || !header) {
|
|
throw new Error("teacher list panels were not rendered");
|
|
}
|
|
const listStyle = window.getComputedStyle(list);
|
|
const recentStyle = window.getComputedStyle(recent);
|
|
const headerStyle = window.getComputedStyle(header);
|
|
const doc = document.documentElement;
|
|
return {
|
|
docHeight: doc.scrollHeight,
|
|
viewportHeight: doc.clientHeight,
|
|
listMaxHeight: listStyle.maxHeight,
|
|
listOverflowY: listStyle.overflowY,
|
|
recentMaxHeight: recentStyle.maxHeight,
|
|
recentOverflowY: recentStyle.overflowY,
|
|
headerPosition: headerStyle.position,
|
|
};
|
|
});
|
|
|
|
expect(metrics.listMaxHeight).not.toBe("none");
|
|
expect(metrics.recentMaxHeight).not.toBe("none");
|
|
expect(["auto", "scroll"]).toContain(metrics.listOverflowY);
|
|
expect(["auto", "scroll"]).toContain(metrics.recentOverflowY);
|
|
expect(metrics.headerPosition).toBe("sticky");
|
|
expect(metrics.docHeight - metrics.viewportHeight).toBeLessThanOrEqual(2200);
|
|
await expectNoHorizontalOverflow(page);
|
|
});
|
|
|
|
test("keeps persona review actions contained on mobile", async ({ page }) => {
|
|
await page.setViewportSize({ width: 390, height: 844 });
|
|
await page.route("**/api/teacher/dashboard", (route) =>
|
|
route.fulfill({
|
|
status: 200,
|
|
contentType: "application/json",
|
|
body: JSON.stringify({
|
|
source: "database",
|
|
cohort_label: "E2E cohort",
|
|
total_learners: 1,
|
|
active_sessions: 0,
|
|
ended_sessions: 0,
|
|
pending_reviews: [],
|
|
recent_sessions: [],
|
|
message: "Mobile review action layout check.",
|
|
}),
|
|
}),
|
|
);
|
|
await page.route("**/api/personas/review", (route) =>
|
|
route.fulfill({
|
|
status: 200,
|
|
contentType: "application/json",
|
|
body: JSON.stringify([
|
|
{
|
|
persona_id: "00000000-0000-0000-0000-000000009902",
|
|
code: "P-LONG-MOBILE",
|
|
version: 11,
|
|
status: "review",
|
|
display_name: "아주 긴 이름의 모바일 검수 대상 페르소나",
|
|
difficulty: "advanced",
|
|
theory_target: ["humanistic", "cognitive-behavioral"],
|
|
source_provenance: "mobile action clipping fixture",
|
|
is_synthetic: true,
|
|
created_at: "2026-06-26T07:00:00Z",
|
|
approved_at: null,
|
|
},
|
|
]),
|
|
}),
|
|
);
|
|
await signInAsTeacher(page);
|
|
|
|
await page.goto("/teach");
|
|
await expect(page.locator('[data-persona-review-row="true"]')).toBeVisible();
|
|
await expectNoHorizontalOverflow(page);
|
|
await expectVisibleButtonsFit(page, ".pf-persona__actions .vg-btn", "mobile persona review actions");
|
|
});
|
|
|
|
test("denies learner access to the teacher dashboard API and UI", async ({ page }) => {
|
|
await signInAsLearner(page);
|
|
|
|
const denied = await page.request.get("/api/teacher/dashboard");
|
|
expect(denied.status(), await denied.text()).toBe(403);
|
|
|
|
await page.goto("/teach");
|
|
await expect(page).toHaveURL(/\/learn$/);
|
|
await expect(page.locator(".pf-root")).toHaveCount(0);
|
|
});
|
|
});
|