813 lines
35 KiB
TypeScript
813 lines
35 KiB
TypeScript
import { mkdirSync, writeFileSync } from 'node:fs';
|
|
import { resolve } from 'node:path';
|
|
|
|
import { expect, test, type Page, type Route } from '@playwright/test';
|
|
|
|
const response = (data: unknown) => ({ result: { data } });
|
|
const artifactRoot = process.env.GATEWAY_STATUS_ARTIFACT_DIR;
|
|
|
|
if (artifactRoot) {
|
|
mkdirSync(artifactRoot, { recursive: true });
|
|
}
|
|
|
|
const operationNames = (route: Route): string[] => {
|
|
const url = new URL(route.request().url());
|
|
return decodeURIComponent(url.pathname.slice(url.pathname.lastIndexOf('/trpc/') + 6)).split(',');
|
|
};
|
|
|
|
const fulfillTrpc = async (route: Route, results: unknown[]): Promise<void> => {
|
|
await route.fulfill({
|
|
status: 200,
|
|
contentType: 'application/json',
|
|
headers: {
|
|
'access-control-allow-origin': '*',
|
|
},
|
|
body: JSON.stringify(results),
|
|
});
|
|
};
|
|
|
|
type LobbyFixtureOptions = {
|
|
authenticated?: boolean;
|
|
roles?: string[];
|
|
kakaoVerified?: boolean;
|
|
canCreateGeneral?: boolean;
|
|
requiresKakaoVerification?: boolean;
|
|
specialAccess?: {
|
|
kind: 'OPERATOR' | 'TESTER' | 'RECOVERY' | 'OTHER';
|
|
grantId: string | null;
|
|
expiresAt: string | null;
|
|
allowsGeneralCreation: boolean;
|
|
} | null;
|
|
myGeneral?: {
|
|
name: string;
|
|
picture: string;
|
|
imageServer: number;
|
|
} | null;
|
|
selectionPoolEnabled?: boolean;
|
|
npcPossessionEnabled?: boolean;
|
|
userCnt?: number;
|
|
maxUserCnt?: number;
|
|
nationCnt?: number;
|
|
isUnited?: number;
|
|
starttime?: string;
|
|
opentime?: string;
|
|
preopenAt?: string;
|
|
turntime?: string;
|
|
turnTerm?: number;
|
|
scenarioTitle?: string;
|
|
npcMode?: number;
|
|
defaultStatTotal?: number;
|
|
korName?: string;
|
|
otherTextInfo?: string;
|
|
autorunUser?: {
|
|
limitMinutes: number;
|
|
options: string[];
|
|
} | null;
|
|
lobbyBundleFailures?: number;
|
|
profileStatus?: 'RUNNING' | 'PREOPEN' | 'PAUSED' | 'COMPLETED' | 'STOPPED';
|
|
includeStoppedProfile?: boolean;
|
|
};
|
|
|
|
const installFixture = async (page: Page, options: LobbyFixtureOptions = {}) => {
|
|
const {
|
|
authenticated = true,
|
|
roles = ['user'],
|
|
kakaoVerified = true,
|
|
canCreateGeneral = true,
|
|
requiresKakaoVerification = false,
|
|
specialAccess = null,
|
|
myGeneral = {
|
|
name: '선택장수',
|
|
picture: 'users/core2026/account-hash.png',
|
|
imageServer: 1,
|
|
},
|
|
selectionPoolEnabled = true,
|
|
npcPossessionEnabled = false,
|
|
userCnt = 1,
|
|
maxUserCnt = 500,
|
|
nationCnt = 0,
|
|
isUnited = 0,
|
|
starttime = '2026-07-30 00:00:00',
|
|
opentime = '2026-07-30 00:00:00',
|
|
preopenAt = '',
|
|
turntime = '2026-07-30 00:05:00',
|
|
turnTerm = 5,
|
|
scenarioTitle = '',
|
|
npcMode = 0,
|
|
defaultStatTotal = 165,
|
|
korName = 'hwe',
|
|
otherTextInfo = '',
|
|
autorunUser = null,
|
|
lobbyBundleFailures = 0,
|
|
profileStatus = 'RUNNING',
|
|
includeStoppedProfile = false,
|
|
} = options;
|
|
let remainingLobbyBundleFailures = lobbyBundleFailures;
|
|
const gameOperations: Array<{ operation: string; authorization: string | undefined }> = [];
|
|
if (authenticated) {
|
|
await page.addInitScript(() => {
|
|
window.localStorage.setItem('sammo-session-token', 'gateway-lobby-session');
|
|
});
|
|
}
|
|
await page.route('**/gateway/api/trpc/**', async (route) => {
|
|
const results = operationNames(route).map((operation) => {
|
|
if (operation === 'me') {
|
|
return response(
|
|
authenticated
|
|
? {
|
|
id: 'lobby-user',
|
|
username: 'lobby-user',
|
|
displayName: '로비사용자',
|
|
roles,
|
|
kakaoVerified,
|
|
createdAt: '2026-07-30T00:00:00.000Z',
|
|
}
|
|
: null
|
|
);
|
|
}
|
|
if (operation === 'lobby.notice') {
|
|
return response('');
|
|
}
|
|
if (operation === 'lobby.profiles') {
|
|
return response(
|
|
[
|
|
{
|
|
profileName: 'hwe:903',
|
|
profile: 'hwe',
|
|
instanceKey: '903',
|
|
currentScenario: '903',
|
|
scenario: '903',
|
|
status: profileStatus,
|
|
lifecycle: {
|
|
runtimeExpected: profileStatus !== 'STOPPED',
|
|
userAccessible: profileStatus !== 'STOPPED',
|
|
turnsRunning: profileStatus === 'RUNNING',
|
|
operatorResumable: profileStatus === 'PAUSED' || profileStatus === 'STOPPED',
|
|
dataInitialized: true,
|
|
},
|
|
apiPort: 15015,
|
|
runtime: {
|
|
apiRunning: true,
|
|
daemonRunning: true,
|
|
auctionRunning: true,
|
|
battleSimRunning: true,
|
|
tournamentRunning: true,
|
|
},
|
|
korName,
|
|
color: '#ffffff',
|
|
localAccountPolicy: {
|
|
accessAllowed: true,
|
|
canCreateGeneral,
|
|
requiresKakaoVerification,
|
|
graceEndsAt: null,
|
|
specialAccess,
|
|
},
|
|
},
|
|
includeStoppedProfile
|
|
? {
|
|
profileName: 'che:2601',
|
|
profile: 'che',
|
|
instanceKey: '2601',
|
|
currentScenario: '2601',
|
|
scenario: '2601',
|
|
status: 'STOPPED',
|
|
lifecycle: {
|
|
runtimeExpected: false,
|
|
userAccessible: false,
|
|
turnsRunning: false,
|
|
operatorResumable: true,
|
|
dataInitialized: true,
|
|
},
|
|
apiPort: 15003,
|
|
runtime: {
|
|
apiRunning: false,
|
|
daemonRunning: false,
|
|
auctionRunning: false,
|
|
battleSimRunning: false,
|
|
tournamentRunning: false,
|
|
},
|
|
korName: 'che',
|
|
color: '#f59e0b',
|
|
localAccountPolicy: {
|
|
accessAllowed: false,
|
|
canCreateGeneral: false,
|
|
requiresKakaoVerification: false,
|
|
graceEndsAt: null,
|
|
specialAccess: null,
|
|
},
|
|
}
|
|
: null,
|
|
].filter((profile) => profile !== null)
|
|
);
|
|
}
|
|
if (operation === 'auth.issueGameSession') {
|
|
return response({
|
|
profile: 'hwe:903',
|
|
gameToken: 'encrypted-gateway-game-token',
|
|
expiresAt: '2026-07-30T01:00:00.000Z',
|
|
});
|
|
}
|
|
throw new Error(`Unhandled gateway tRPC operation: ${operation}`);
|
|
});
|
|
await fulfillTrpc(route, results);
|
|
});
|
|
await page.route('**/hwe/api/trpc/**', async (route) => {
|
|
expect(new URL(route.request().url()).pathname).toContain('/hwe/api/trpc/');
|
|
const authorization = route.request().headers().authorization;
|
|
const operations = operationNames(route);
|
|
if (operations.includes('lobby.info') && remainingLobbyBundleFailures > 0) {
|
|
remainingLobbyBundleFailures -= 1;
|
|
gameOperations.push(...operations.map((operation) => ({ operation, authorization })));
|
|
await route.fulfill({
|
|
status: 502,
|
|
contentType: 'application/json',
|
|
body: JSON.stringify({ error: 'profile runtime is switching' }),
|
|
});
|
|
return;
|
|
}
|
|
const results = operations.map((operation) => {
|
|
gameOperations.push({ operation, authorization });
|
|
if (operation === 'auth.exchangeGatewayToken') {
|
|
return response({
|
|
accessToken: 'ga_lobby-access-token',
|
|
profile: 'hwe:903',
|
|
expiresAt: '2026-07-30T01:00:00.000Z',
|
|
});
|
|
}
|
|
if (operation === 'lobby.info') {
|
|
return response({
|
|
year: 180,
|
|
month: 1,
|
|
userCnt,
|
|
maxUserCnt,
|
|
npcCnt: 0,
|
|
nationCnt,
|
|
turnTerm,
|
|
fictionMode: '가상',
|
|
starttime,
|
|
opentime,
|
|
preopenAt,
|
|
turntime,
|
|
otherTextInfo,
|
|
scenarioTitle,
|
|
npcMode,
|
|
defaultStatTotal,
|
|
autorunUser,
|
|
isUnited,
|
|
selectionPoolEnabled,
|
|
npcPossessionEnabled,
|
|
myGeneral,
|
|
});
|
|
}
|
|
if (operation === 'public.getMapLayout') {
|
|
return response({ mapName: 'che', cityList: [] });
|
|
}
|
|
if (operation === 'public.getCachedMap') {
|
|
return response({ year: 180, month: 1, cityList: [], nationList: [] });
|
|
}
|
|
throw new Error(`Unhandled game tRPC operation: ${operation}`);
|
|
});
|
|
await fulfillTrpc(route, results);
|
|
});
|
|
await page.route('https://sam-image.hided.net/icons/users/core2026/account-hash.png', async (route) => {
|
|
await route.fulfill({
|
|
status: 200,
|
|
contentType: 'image/png',
|
|
body: Buffer.from(
|
|
'iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mNk+A8AAQUBAScY42YAAAAASUVORK5CYII=',
|
|
'base64'
|
|
),
|
|
});
|
|
});
|
|
return gameOperations;
|
|
};
|
|
|
|
test('exchanges the gateway token before loading authenticated lobby general data', async ({ page }) => {
|
|
const gameOperations = await installFixture(page);
|
|
|
|
await page.goto('lobby');
|
|
const row = page.locator('tbody tr').filter({ hasText: 'hwe섭' });
|
|
await expect(row).toContainText('선택장수');
|
|
await expect(row.getByRole('button', { name: '입장' })).toBeVisible();
|
|
const portrait = row.locator('img');
|
|
await expect(portrait).toHaveAttribute('src', 'https://sam-image.hided.net/icons/users/core2026/account-hash.png');
|
|
await expect.poll(() => portrait.evaluate((image: HTMLImageElement) => image.naturalWidth)).toBe(1);
|
|
|
|
expect(gameOperations.find(({ operation }) => operation === 'auth.exchangeGatewayToken')).toEqual({
|
|
operation: 'auth.exchangeGatewayToken',
|
|
authorization: undefined,
|
|
});
|
|
expect(gameOperations.find(({ operation }) => operation === 'lobby.info')).toEqual({
|
|
operation: 'lobby.info',
|
|
authorization: 'Bearer ga_lobby-access-token',
|
|
});
|
|
});
|
|
|
|
test('copies the complete preopen announcement and reveals autorun details without changing layout', async ({
|
|
page,
|
|
}, testInfo) => {
|
|
await installFixture(page, {
|
|
roles: ['superuser'],
|
|
kakaoVerified: false,
|
|
profileStatus: 'PREOPEN',
|
|
korName: '훼',
|
|
specialAccess: {
|
|
kind: 'OPERATOR',
|
|
grantId: null,
|
|
expiresAt: null,
|
|
allowsGeneralCreation: true,
|
|
},
|
|
preopenAt: '2026-08-19 22:00:00',
|
|
opentime: '2026-08-19 23:00:00',
|
|
starttime: '2026-08-19 23:00:00',
|
|
turnTerm: 1,
|
|
scenarioTitle: '【가상모드27-b】 아시아 명장전(비급)',
|
|
npcMode: 0,
|
|
defaultStatTotal: 310,
|
|
autorunUser: {
|
|
limitMinutes: 1_440,
|
|
options: ['develop', 'warp', 'recruit_high', 'train', 'battle', 'chief'],
|
|
},
|
|
});
|
|
await page.setViewportSize({ width: 1200, height: 900 });
|
|
|
|
await page.goto('lobby');
|
|
const row = page.locator('tbody tr').filter({ hasText: '훼섭' });
|
|
const serverName = row.locator('.profile-server-cell .font-bold');
|
|
const settings = row.locator('.profile-announcement-settings');
|
|
const autorun = row.locator('.copyable-autorun');
|
|
const detail = row.locator('.copyable-autorun-detail');
|
|
await expect(row.getByTestId('profile-preopen-at')).toHaveText('- 가오픈 일시 : 2026-08-19 22:00:00 -');
|
|
await expect(row.getByTestId('profile-open-at')).toHaveText('- 오픈 일시 : 2026-08-19 23:00:00 -');
|
|
await expect(row.getByTestId('profile-scenario-announcement')).toHaveText(
|
|
'【가상모드27-b】 아시아 명장전(비급) 1분 턴 서버'
|
|
);
|
|
const settingsText = (await settings.textContent())?.replace(/\s+/g, ' ').trim();
|
|
expect(settingsText).toBe(
|
|
'(상성 설정:가상), (빙의 여부:불가), (최대 스탯:310), ' +
|
|
'(기타 설정:자율행동[내정, 순간이동, 모병, 훈련/사기진작, 출병, 사령턴, 24시간 유효])'
|
|
);
|
|
await expect(detail).toHaveCSS('font-size', '0px');
|
|
await expect(detail).toHaveCSS('color', 'rgba(0, 0, 0, 0)');
|
|
await expect(page.getByText('특수 접근 · OPERATOR')).toHaveCount(0);
|
|
await expect(page.getByText('카카오 인증이 필요합니다.')).toHaveCount(0);
|
|
|
|
const baseGeometry = await row.evaluate((element) => ({
|
|
row: element.getBoundingClientRect().toJSON(),
|
|
documentWidth: document.documentElement.scrollWidth,
|
|
}));
|
|
await autorun.hover();
|
|
await expect(detail).toBeVisible();
|
|
await expect(detail).toContainText('내정, 순간이동, 모병, 훈련/사기진작, 출병, 사령턴, 24시간 유효');
|
|
const hoverGeometry = await row.evaluate((element) => ({
|
|
row: element.getBoundingClientRect().toJSON(),
|
|
documentWidth: document.documentElement.scrollWidth,
|
|
}));
|
|
expect(hoverGeometry).toEqual(baseGeometry);
|
|
await page.screenshot({ path: testInfo.outputPath('gateway-autorun-announcement-hover.png'), fullPage: true });
|
|
|
|
await autorun.focus();
|
|
await expect(autorun).toBeFocused();
|
|
await expect(detail).toBeVisible();
|
|
await expect(autorun).toHaveCSS('outline-width', '2px');
|
|
|
|
await page.mouse.click(8, 8);
|
|
const start = await serverName.boundingBox();
|
|
const end = await settings.boundingBox();
|
|
if (!start || !end) throw new Error('expected announcement selection geometry');
|
|
await page.mouse.move(start.x + 1, start.y + start.height / 2);
|
|
await page.mouse.down();
|
|
await page.mouse.move(end.x + end.width - 1, end.y + end.height / 2, { steps: 24 });
|
|
await page.mouse.up();
|
|
const selectedText = await page.evaluate(() => window.getSelection()?.toString() ?? '');
|
|
const compactSelection = selectedText.replace(/\s+/g, ' ').trim();
|
|
expect(compactSelection).toContain(
|
|
'훼섭 - 가오픈 일시 : 2026-08-19 22:00:00 - - 오픈 일시 : 2026-08-19 23:00:00 - ' +
|
|
'【가상모드27-b】 아시아 명장전(비급) 1분 턴 서버 ' +
|
|
'(상성 설정:가상), (빙의 여부:불가), (최대 스탯:310), ' +
|
|
'(기타 설정:자율행동[내정, 순간이동, 모병, 훈련/사기진작, 출병, 사령턴, 24시간 유효])'
|
|
);
|
|
expect(compactSelection).not.toContain('OPERATOR');
|
|
|
|
await page.evaluate(() => window.getSelection()?.removeAllRanges());
|
|
await page.setViewportSize({ width: 390, height: 844 });
|
|
await autorun.scrollIntoViewIfNeeded();
|
|
const mobileBase = await row.evaluate((element) => ({
|
|
row: element.getBoundingClientRect().toJSON(),
|
|
documentWidth: document.documentElement.scrollWidth,
|
|
}));
|
|
await autorun.hover();
|
|
await expect(detail).toBeVisible();
|
|
const mobileHover = await row.evaluate((element) => {
|
|
const tooltip = element.querySelector('.copyable-autorun-detail');
|
|
if (!tooltip) throw new Error('expected autorun tooltip');
|
|
return {
|
|
row: element.getBoundingClientRect().toJSON(),
|
|
tooltip: tooltip.getBoundingClientRect().toJSON(),
|
|
documentWidth: document.documentElement.scrollWidth,
|
|
viewportWidth: window.innerWidth,
|
|
};
|
|
});
|
|
expect(mobileHover.row).toEqual(mobileBase.row);
|
|
expect(mobileHover.documentWidth).toBe(mobileHover.viewportWidth);
|
|
expect(mobileHover.tooltip.left).toBeGreaterThanOrEqual(8);
|
|
expect(mobileHover.tooltip.right).toBeLessThanOrEqual(mobileHover.viewportWidth - 8);
|
|
await page.screenshot({ path: testInfo.outputPath('gateway-autorun-announcement-mobile.png'), fullPage: true });
|
|
});
|
|
|
|
test('loads and labels a PAUSED profile whose runtime remains available', async ({ page }, testInfo) => {
|
|
const gameOperations = await installFixture(page, { profileStatus: 'PAUSED' });
|
|
await page.setViewportSize({ width: 1365, height: 900 });
|
|
|
|
await page.goto('lobby');
|
|
const row = page.locator('tbody tr').filter({ hasText: 'hwe섭' });
|
|
const pausedStatus = row.getByTestId('profile-paused-status');
|
|
await expect(pausedStatus).toHaveText('턴 일시정지 · 조회/예약턴 가능');
|
|
await expect(pausedStatus).toHaveCSS('color', 'oklch(0.879 0.169 91.605)');
|
|
await expect(row).toContainText('선택장수');
|
|
await expect(row).not.toContainText('정보를 불러오는 중');
|
|
await expect(row.getByRole('button', { name: '입장' })).toBeVisible();
|
|
expect(gameOperations.some(({ operation }) => operation === 'lobby.info')).toBe(true);
|
|
await expect(page.getByRole('tab', { name: 'hwe섭' })).toBeVisible();
|
|
await page.screenshot({ path: testInfo.outputPath('gateway-paused-profile-lobby.png'), fullPage: true });
|
|
});
|
|
|
|
test('does not contact a STOPPED game runtime and labels it inaccessible', async ({ page }, testInfo) => {
|
|
const gameOperations = await installFixture(page, { profileStatus: 'STOPPED' });
|
|
|
|
await page.goto('lobby');
|
|
const row = page.locator('tbody tr').filter({ hasText: 'hwe섭' });
|
|
await expect(row).toContainText('서버 중지 · 접근 불가');
|
|
await expect(row).not.toContainText('정보를 불러오는 중');
|
|
await expect(row.getByRole('button', { name: '입장' })).toHaveCount(0);
|
|
await expect(page.getByRole('tab', { name: 'hwe섭' })).toHaveCount(0);
|
|
expect(gameOperations).toEqual([]);
|
|
await page.screenshot({ path: testInfo.outputPath('gateway-stopped-profile-lobby.png'), fullPage: true });
|
|
});
|
|
|
|
test('automatically recovers profile details after a transient update outage', async ({ page }) => {
|
|
const gameOperations = await installFixture(page, { lobbyBundleFailures: 1 });
|
|
|
|
await page.goto('lobby');
|
|
const row = page.locator('tbody tr').filter({ hasText: 'hwe섭' });
|
|
await expect(row.getByTestId('profile-info-retrying')).toContainText('서버 응답을 기다리고 있습니다.');
|
|
await expect(row.getByRole('button', { name: '지금 다시 확인' })).toBeVisible();
|
|
await expect(row).toContainText('선택장수', { timeout: 8_000 });
|
|
expect(gameOperations.filter(({ operation }) => operation === 'lobby.info')).toHaveLength(2);
|
|
});
|
|
|
|
test('uses two-row mobile server cards without horizontal scrolling and keeps retry keyboard-accessible', async ({
|
|
page,
|
|
}, testInfo) => {
|
|
// Keep the scheduled retry in the error state so it cannot race the manual retry after the screenshot.
|
|
await installFixture(page, { lobbyBundleFailures: 2, includeStoppedProfile: true });
|
|
await page.setViewportSize({ width: 390, height: 844 });
|
|
|
|
await page.goto('lobby');
|
|
const row = page.locator('tbody tr').filter({ hasText: 'hwe섭' });
|
|
const retry = row.getByRole('button', { name: '지금 다시 확인' });
|
|
const tableScroll = page.getByTestId('profile-table-scroll');
|
|
await expect(retry).toBeVisible();
|
|
await retry.focus();
|
|
await expect(retry).toBeFocused();
|
|
const geometry = await tableScroll.evaluate((scrollElement) => {
|
|
const rows = [...scrollElement.querySelectorAll('tbody tr')];
|
|
const row = rows[0];
|
|
const button = row?.querySelector('button');
|
|
const serverCell = row?.querySelector('.profile-server-cell');
|
|
const infoCell = row?.querySelector('.profile-info-cell');
|
|
const portraitCell = row?.querySelector('.profile-portrait-cell');
|
|
const generalCell = row?.querySelector('.profile-general-cell');
|
|
const actionCell = row?.querySelector('.profile-action-cell');
|
|
if (!row) throw new Error('expected profile row');
|
|
if (!button) throw new Error('expected profile retry button');
|
|
if (!serverCell || !infoCell || !portraitCell || !generalCell || !actionCell) {
|
|
throw new Error('expected all profile cells');
|
|
}
|
|
const scrollRect = scrollElement.getBoundingClientRect();
|
|
const rowRect = row.getBoundingClientRect();
|
|
const buttonRect = button.getBoundingClientRect();
|
|
const style = getComputedStyle(button);
|
|
const rect = (element: Element) => {
|
|
const value = element.getBoundingClientRect();
|
|
return { top: value.top, right: value.right, bottom: value.bottom, left: value.left, width: value.width };
|
|
};
|
|
return {
|
|
pageScrollWidth: document.documentElement.scrollWidth,
|
|
scroll: {
|
|
left: scrollRect.left,
|
|
right: scrollRect.right,
|
|
clientWidth: scrollElement.clientWidth,
|
|
scrollWidth: scrollElement.scrollWidth,
|
|
},
|
|
row: { left: rowRect.left, right: rowRect.right, width: rowRect.width },
|
|
rows: rows.map((element) => rect(element)),
|
|
button: { left: buttonRect.left, right: buttonRect.right, width: buttonRect.width },
|
|
cells: {
|
|
server: rect(serverCell),
|
|
info: rect(infoCell),
|
|
portrait: rect(portraitCell),
|
|
general: rect(generalCell),
|
|
action: rect(actionCell),
|
|
},
|
|
viewportWidth: window.innerWidth,
|
|
outlineStyle: style.outlineStyle,
|
|
outlineWidth: style.outlineWidth,
|
|
};
|
|
});
|
|
expect(geometry.pageScrollWidth).toBe(geometry.viewportWidth);
|
|
expect(geometry.scroll.clientWidth).toBeLessThanOrEqual(geometry.viewportWidth);
|
|
expect(geometry.scroll.scrollWidth).toBe(geometry.scroll.clientWidth);
|
|
expect(geometry.row.width).toBe(geometry.scroll.clientWidth);
|
|
expect(geometry.rows).toHaveLength(2);
|
|
expect(geometry.rows[0]?.bottom).toBeLessThanOrEqual(geometry.rows[1]?.top ?? 0);
|
|
expect(geometry.rows.every((item) => item.width === geometry.scroll.clientWidth)).toBe(true);
|
|
expect(geometry.button.left).toBeGreaterThanOrEqual(geometry.scroll.left);
|
|
expect(geometry.button.right).toBeLessThanOrEqual(geometry.scroll.right);
|
|
expect(geometry.cells.server.top).toBeCloseTo(geometry.cells.info.top, 0);
|
|
expect(geometry.cells.server.left).toBeCloseTo(geometry.row.left, 0);
|
|
expect(geometry.cells.info.right).toBeCloseTo(geometry.row.right, 0);
|
|
expect(geometry.cells.portrait.top).toBeCloseTo(geometry.cells.general.top, 0);
|
|
expect(geometry.cells.general.top).toBeCloseTo(geometry.cells.action.top, 0);
|
|
expect(geometry.cells.portrait.top).toBeGreaterThanOrEqual(geometry.cells.server.bottom);
|
|
expect(geometry.cells.portrait.left).toBeCloseTo(geometry.row.left, 0);
|
|
expect(geometry.cells.action.right).toBeCloseTo(geometry.row.right, 0);
|
|
expect(geometry.outlineStyle).toBe('solid');
|
|
expect(geometry.outlineWidth).toBe('2px');
|
|
|
|
await retry.click();
|
|
await expect(row).toContainText('선택장수');
|
|
await expect(row.getByTestId('profile-info-retrying')).toHaveCount(0);
|
|
const enterButton = row.getByRole('button', { name: '입장' });
|
|
await expect(enterButton).toBeVisible();
|
|
const enterBackground = await enterButton.evaluate((element) => getComputedStyle(element).backgroundColor);
|
|
await enterButton.hover();
|
|
await expect
|
|
.poll(() => enterButton.evaluate((element) => getComputedStyle(element).backgroundColor))
|
|
.not.toBe(enterBackground);
|
|
await page.screenshot({ path: testInfo.outputPath('gateway-profile-two-row-mobile.png'), fullPage: true });
|
|
|
|
await page.setViewportSize({ width: 320, height: 700 });
|
|
await expect
|
|
.poll(() =>
|
|
tableScroll.evaluate((element) => ({
|
|
documentWidth: document.documentElement.scrollWidth,
|
|
viewportWidth: window.innerWidth,
|
|
clientWidth: element.clientWidth,
|
|
scrollWidth: element.scrollWidth,
|
|
rowWidth: element.querySelector('tbody tr')?.getBoundingClientRect().width,
|
|
}))
|
|
)
|
|
.toEqual({ documentWidth: 320, viewportWidth: 320, clientWidth: 286, scrollWidth: 286, rowWidth: 286 });
|
|
|
|
await page.setViewportSize({ width: 799, height: 900 });
|
|
await expect
|
|
.poll(() =>
|
|
tableScroll.evaluate((element) => ({
|
|
clientWidth: element.clientWidth,
|
|
scrollWidth: element.scrollWidth,
|
|
rowDisplay: getComputedStyle(element.querySelector('tbody tr')!).display,
|
|
}))
|
|
)
|
|
.toEqual({ clientWidth: 765, scrollWidth: 765, rowDisplay: 'grid' });
|
|
|
|
await page.setViewportSize({ width: 800, height: 900 });
|
|
await expect
|
|
.poll(() =>
|
|
tableScroll.evaluate((element) => ({
|
|
clientWidth: element.clientWidth,
|
|
scrollWidth: element.scrollWidth,
|
|
rowDisplay: getComputedStyle(element.querySelector('tbody tr')!).display,
|
|
}))
|
|
)
|
|
.toEqual({ clientWidth: 766, scrollWidth: 766, rowDisplay: 'table-row' });
|
|
});
|
|
|
|
test('applies the signed general-acquisition policy to both create and possession actions', async ({ page }) => {
|
|
await installFixture(page, {
|
|
canCreateGeneral: false,
|
|
myGeneral: null,
|
|
selectionPoolEnabled: false,
|
|
npcPossessionEnabled: true,
|
|
});
|
|
|
|
await page.goto('lobby');
|
|
const row = page.locator('tbody tr').filter({ hasText: 'hwe섭' });
|
|
await expect(row.getByRole('button', { name: '인증 필요' })).toBeDisabled();
|
|
await expect(row.getByRole('button', { name: '장수빙의' })).toBeDisabled();
|
|
});
|
|
|
|
test('shows the Kakao verification banner when a profile still requires verification', async ({ page }) => {
|
|
await installFixture(page, {
|
|
kakaoVerified: false,
|
|
requiresKakaoVerification: true,
|
|
});
|
|
|
|
await page.goto('lobby');
|
|
await expect(page.getByText('카카오 인증이 필요합니다.')).toBeVisible();
|
|
});
|
|
|
|
test('hides the Kakao verification banner for operator special access', async ({ page }) => {
|
|
await installFixture(page, {
|
|
roles: ['superuser'],
|
|
kakaoVerified: false,
|
|
specialAccess: {
|
|
kind: 'OPERATOR',
|
|
grantId: null,
|
|
expiresAt: null,
|
|
allowsGeneralCreation: true,
|
|
},
|
|
});
|
|
|
|
await page.goto('lobby');
|
|
await expect(page.getByText('특수 접근 · OPERATOR')).toHaveCount(0);
|
|
await expect(page.getByText('카카오 인증이 필요합니다.')).toHaveCount(0);
|
|
});
|
|
|
|
test('hides the Kakao verification banner when a grant removes the remaining verification requirement', async ({
|
|
page,
|
|
}) => {
|
|
await installFixture(page, {
|
|
kakaoVerified: false,
|
|
specialAccess: {
|
|
kind: 'RECOVERY',
|
|
grantId: '11111111-1111-4111-8111-111111111111',
|
|
expiresAt: '2026-08-20T00:00:00.000Z',
|
|
allowsGeneralCreation: true,
|
|
},
|
|
});
|
|
|
|
await page.goto('lobby');
|
|
await expect(page.getByText('특수 접근 · RECOVERY')).toHaveCount(0);
|
|
await expect(page.getByText('카카오 인증이 필요합니다.')).toHaveCount(0);
|
|
});
|
|
|
|
test('opens the profile root without profile or game token query parameters', async ({ page }) => {
|
|
await installFixture(page);
|
|
await page.route('**/hwe/', async (route) => {
|
|
await route.fulfill({
|
|
status: 200,
|
|
contentType: 'text/html',
|
|
body: '<title>Clean profile target</title>',
|
|
});
|
|
});
|
|
|
|
await page.goto('lobby');
|
|
const row = page.locator('tbody tr').filter({ hasText: 'hwe섭' });
|
|
await row.getByRole('button', { name: '입장', exact: true }).click();
|
|
|
|
await expect(page).toHaveURL(/\/hwe\/$/);
|
|
const target = new URL(page.url());
|
|
expect(target.search).toBe('');
|
|
expect(
|
|
await page.evaluate(() => JSON.parse(window.sessionStorage.getItem('sammo-pending-game-session') ?? 'null'))
|
|
).toEqual({
|
|
profile: 'hwe:903',
|
|
gatewayToken: 'encrypted-gateway-game-token',
|
|
});
|
|
});
|
|
|
|
test('opens the mode-1 possession route with a fresh gateway game token outside the URL', async ({ page }) => {
|
|
await installFixture(page, {
|
|
myGeneral: null,
|
|
selectionPoolEnabled: false,
|
|
npcPossessionEnabled: true,
|
|
});
|
|
await page.route('**/hwe/join?**', async (route) => {
|
|
await route.fulfill({
|
|
status: 200,
|
|
contentType: 'text/html',
|
|
body: '<title>NPC possession target</title>',
|
|
});
|
|
});
|
|
|
|
await page.goto('lobby');
|
|
const row = page.locator('tbody tr').filter({ hasText: 'hwe섭' });
|
|
await expect(row.getByRole('button', { name: '장수빙의' })).toBeEnabled();
|
|
await row.getByRole('button', { name: '장수빙의' }).click();
|
|
|
|
await expect(page).toHaveURL(/\/hwe\/join\?tab=possess$/);
|
|
const target = new URL(page.url());
|
|
expect(target.searchParams.get('tab')).toBe('possess');
|
|
expect(target.searchParams.has('profile')).toBe(false);
|
|
expect(target.searchParams.has('gameToken')).toBe(false);
|
|
expect(
|
|
await page.evaluate(() => JSON.parse(window.sessionStorage.getItem('sammo-pending-game-session') ?? 'null'))
|
|
).toEqual({
|
|
profile: 'hwe:903',
|
|
gatewayToken: 'encrypted-gateway-game-token',
|
|
});
|
|
});
|
|
|
|
test('shows registration closed instead of acquisition actions at the Ref capacity boundary', async ({ page }) => {
|
|
await installFixture(page, {
|
|
myGeneral: null,
|
|
selectionPoolEnabled: false,
|
|
npcPossessionEnabled: true,
|
|
userCnt: 300,
|
|
maxUserCnt: 300,
|
|
});
|
|
|
|
await page.goto('lobby');
|
|
const row = page.locator('tbody tr').filter({ hasText: 'hwe섭' });
|
|
await expect(row).toContainText('장수 등록 마감');
|
|
await expect(row.getByRole('button', { name: '장수생성' })).toHaveCount(0);
|
|
await expect(row.getByRole('button', { name: '장수빙의' })).toHaveCount(0);
|
|
});
|
|
|
|
for (const season of [
|
|
{
|
|
name: 'competition',
|
|
isUnited: 0,
|
|
opentime: '2000-01-01 00:00:00',
|
|
label: '<4국 경쟁중>',
|
|
period: '2026-07-30 00:00:00 ~',
|
|
},
|
|
{
|
|
name: 'preopen',
|
|
isUnited: 0,
|
|
opentime: '2099-01-01 00:00:00',
|
|
label: '-가오픈 중-',
|
|
period: '2026-07-30 00:00:00 ~',
|
|
},
|
|
{
|
|
name: 'event running',
|
|
isUnited: 1,
|
|
opentime: '2099-01-01 00:00:00',
|
|
label: '§이벤트 진행중§',
|
|
period: '2026-07-30 00:00:00 ~',
|
|
},
|
|
{
|
|
name: 'united',
|
|
isUnited: 2,
|
|
opentime: '2099-01-01 00:00:00',
|
|
label: '§천하통일§',
|
|
period: '2026-07-30 00:00:00\n~ 2026-07-30 00:05:00',
|
|
},
|
|
{
|
|
name: 'event finished',
|
|
isUnited: 3,
|
|
opentime: '2099-01-01 00:00:00',
|
|
label: '§이벤트 종료§',
|
|
period: '2026-07-30 00:00:00\n~ 2026-07-30 00:05:00',
|
|
},
|
|
] as const) {
|
|
test(`renders the Ref ${season.name} season status without changing entry actions`, async ({ page }) => {
|
|
await installFixture(page, {
|
|
isUnited: season.isUnited,
|
|
opentime: season.opentime,
|
|
nationCnt: 4,
|
|
});
|
|
|
|
await page.goto('lobby');
|
|
const row = page.locator('tbody tr').filter({ hasText: 'hwe섭' });
|
|
const status = row.getByText(season.label, { exact: true });
|
|
await expect(status).toBeVisible();
|
|
await expect(row.locator('td').first().locator('[title]')).toHaveAttribute('title', season.period);
|
|
await expect(row.getByRole('button', { name: '입장' })).toBeVisible();
|
|
|
|
if (artifactRoot) {
|
|
const [viewport, rowGeometry, statusGeometry] = await Promise.all([
|
|
page.evaluate(() => ({
|
|
width: window.innerWidth,
|
|
height: window.innerHeight,
|
|
devicePixelRatio: window.devicePixelRatio,
|
|
})),
|
|
row.evaluate((element) => {
|
|
const rect = element.getBoundingClientRect();
|
|
return { x: rect.x, y: rect.y, width: rect.width, height: rect.height };
|
|
}),
|
|
status.evaluate((element) => {
|
|
const rect = element.getBoundingClientRect();
|
|
const style = getComputedStyle(element);
|
|
return {
|
|
x: rect.x,
|
|
y: rect.y,
|
|
width: rect.width,
|
|
height: rect.height,
|
|
color: style.color,
|
|
fontFamily: style.fontFamily,
|
|
fontSize: style.fontSize,
|
|
lineHeight: style.lineHeight,
|
|
textAlign: style.textAlign,
|
|
};
|
|
}),
|
|
]);
|
|
const geometry = { viewport, row: rowGeometry, status: statusGeometry };
|
|
const slug = season.name.replaceAll(' ', '-');
|
|
writeFileSync(resolve(artifactRoot, `gateway-${slug}.json`), `${JSON.stringify(geometry, null, 2)}\n`);
|
|
await page.screenshot({ path: resolve(artifactRoot, `gateway-${slug}.png`), fullPage: true });
|
|
}
|
|
});
|
|
}
|
|
|
|
test('renders the same Ref season status on the public gateway page', async ({ page }) => {
|
|
await installFixture(page, { authenticated: false, isUnited: 3, nationCnt: 4 });
|
|
|
|
await page.goto('');
|
|
const status = page.locator('.season-status');
|
|
await expect(status).toHaveText('§이벤트 종료§');
|
|
await expect(status).toHaveAttribute('title', '2026-07-30 00:00:00\n~ 2026-07-30 00:05:00');
|
|
await expect(page.getByRole('button', { name: '현황 새로고침' })).toBeEnabled();
|
|
});
|