839 lines
28 KiB
JavaScript
839 lines
28 KiB
JavaScript
#!/usr/bin/env node
|
|
/**
|
|
* E2E 전체 테스트 독립 실행 러너
|
|
*
|
|
* MCP 오버헤드 없이 Node.js + Playwright 직접 사용
|
|
* 시나리오당 ~10초, 전체 ~15분 목표
|
|
*
|
|
* Usage:
|
|
* node e2e/runner/run-all.js # 전체 실행
|
|
* node e2e/runner/run-all.js --filter board # 파일명 필터
|
|
* node e2e/runner/run-all.js --headed # headed (기본값)
|
|
* node e2e/runner/run-all.js --headless # headless
|
|
*/
|
|
|
|
const fs = require('fs');
|
|
const path = require('path');
|
|
|
|
// ─── Resolve Playwright from react/node_modules ─────────────
|
|
const SAM_ROOT = path.resolve(__dirname, '..', '..');
|
|
const PW_PATH = path.join(SAM_ROOT, 'react', 'node_modules', 'playwright');
|
|
const { chromium } = require(PW_PATH);
|
|
|
|
// ─── Config ─────────────────────────────────────────────────
|
|
const BASE_URL = 'https://dev.codebridge-x.com';
|
|
const AUTH = { username: 'TestUser5', password: 'password123!' };
|
|
const SCENARIOS_DIR = path.join(SAM_ROOT, 'e2e', 'scenarios');
|
|
const RESULTS_DIR = path.join(SAM_ROOT, 'e2e', 'results', 'hotfix');
|
|
const SUCCESS_DIR = path.join(RESULTS_DIR, 'success');
|
|
const SCREENSHOTS_DIR = path.join(RESULTS_DIR, 'screenshots');
|
|
const EXECUTOR_PATH = path.join(SAM_ROOT, 'e2e', 'runner', 'step-executor.js');
|
|
const DASHBOARD_URL = `${BASE_URL}/dashboard`;
|
|
|
|
// CLI args
|
|
const args = process.argv.slice(2);
|
|
const HEADLESS = args.includes('--headless');
|
|
const FILTER = (() => {
|
|
const idx = args.indexOf('--filter');
|
|
return idx >= 0 && args[idx + 1] ? args[idx + 1] : null;
|
|
})();
|
|
|
|
// ─── Helpers ────────────────────────────────────────────────
|
|
|
|
function getTimestamp() {
|
|
const n = new Date();
|
|
const pad = (v) => v.toString().padStart(2, '0');
|
|
return `${n.getFullYear()}-${pad(n.getMonth() + 1)}-${pad(n.getDate())}_${pad(n.getHours())}-${pad(n.getMinutes())}-${pad(n.getSeconds())}`;
|
|
}
|
|
|
|
function ensureDir(dir) {
|
|
if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
|
|
}
|
|
|
|
function sleep(ms) {
|
|
return new Promise((r) => setTimeout(r, ms));
|
|
}
|
|
|
|
/** Color console helpers */
|
|
const C = {
|
|
green: (s) => `\x1b[32m${s}\x1b[0m`,
|
|
red: (s) => `\x1b[31m${s}\x1b[0m`,
|
|
yellow: (s) => `\x1b[33m${s}\x1b[0m`,
|
|
cyan: (s) => `\x1b[36m${s}\x1b[0m`,
|
|
dim: (s) => `\x1b[2m${s}\x1b[0m`,
|
|
bold: (s) => `\x1b[1m${s}\x1b[0m`,
|
|
};
|
|
|
|
// ─── Executor Injection ─────────────────────────────────────
|
|
|
|
const executorCode = fs.readFileSync(EXECUTOR_PATH, 'utf-8');
|
|
|
|
async function injectExecutor(page) {
|
|
await page.evaluate(executorCode);
|
|
const initResult = await page.evaluate(() => JSON.stringify(window.__E2E__.init()));
|
|
const parsed = JSON.parse(initResult);
|
|
if (!parsed.ready) throw new Error('step-executor init failed');
|
|
return parsed;
|
|
}
|
|
|
|
// ─── Menu Navigation ────────────────────────────────────────
|
|
|
|
async function navigateViaMenu(page, level1, level2) {
|
|
// Wait for sidebar to be present AND have rendered menu items
|
|
try {
|
|
await page.waitForFunction(
|
|
() => {
|
|
const sidebar = document.querySelector('.sidebar-scroll, [data-sidebar="content"]');
|
|
if (!sidebar) return false;
|
|
const items = sidebar.querySelectorAll('a, button, [role="button"], [role="menuitem"]');
|
|
return Array.from(items).filter(el => (el.textContent || '').trim().length > 1).length >= 3;
|
|
},
|
|
null,
|
|
{ timeout: 8000 }
|
|
);
|
|
} catch (e) {
|
|
// Try reloading the page
|
|
console.log(C.yellow(` [DEBUG] sidebar check failed, reloading. URL: ${page.url()}`));
|
|
try {
|
|
await page.reload({ waitUntil: 'load', timeout: 10000 });
|
|
await sleep(2000);
|
|
await page.waitForFunction(
|
|
() => {
|
|
const sidebar = document.querySelector('.sidebar-scroll, [data-sidebar="content"]');
|
|
if (!sidebar) return false;
|
|
const items = sidebar.querySelectorAll('a, button, [role="button"], [role="menuitem"]');
|
|
return Array.from(items).filter(el => (el.textContent || '').trim().length > 1).length >= 3;
|
|
},
|
|
null,
|
|
{ timeout: 6000 }
|
|
);
|
|
} catch (e2) {
|
|
console.log(C.red(` [DEBUG] sidebar still not rendered after reload! URL: ${page.url()}`));
|
|
return false;
|
|
}
|
|
}
|
|
|
|
// Collapse all open menus first to ensure clean state
|
|
await page.evaluate(() => {
|
|
const collapseBtn = Array.from(document.querySelectorAll('button, [role="button"]'))
|
|
.find(el => el.innerText?.trim() === '모두 접기');
|
|
if (collapseBtn) collapseBtn.click();
|
|
});
|
|
await sleep(300);
|
|
|
|
// Scroll sidebar to top first
|
|
await page.evaluate(() => {
|
|
const sidebar = document.querySelector('.sidebar-scroll, [data-sidebar="content"], nav');
|
|
if (sidebar) sidebar.scrollTo({ top: 0, behavior: 'instant' });
|
|
});
|
|
await sleep(300);
|
|
|
|
// Ensure sidebar is expanded (not icon-only collapsed mode)
|
|
const sidebarExpanded = await page.evaluate(() => {
|
|
try {
|
|
const raw = localStorage.getItem('sam-menu');
|
|
if (raw) {
|
|
const data = JSON.parse(raw);
|
|
if (data.state && data.state.sidebarCollapsed) {
|
|
data.state.sidebarCollapsed = false;
|
|
localStorage.setItem('sam-menu', JSON.stringify(data));
|
|
return false; // was collapsed, need reload
|
|
}
|
|
}
|
|
} catch (e) {}
|
|
return true; // already expanded
|
|
});
|
|
if (!sidebarExpanded) {
|
|
await page.reload({ waitUntil: 'load', timeout: 10000 });
|
|
await sleep(1500);
|
|
}
|
|
|
|
// Wait specifically for the target L1 menu item to exist in DOM (textContent for collapsed text)
|
|
let l1Ready = false;
|
|
try {
|
|
l1Ready = await page.waitForFunction(
|
|
(l1Text) => {
|
|
const items = document.querySelectorAll('a, button, [role="button"], [role="menuitem"], [role="treeitem"]');
|
|
return Array.from(items).some(el => {
|
|
const text = (el.textContent || el.innerText || '').trim();
|
|
return text && (text === l1Text || text.startsWith(l1Text));
|
|
});
|
|
},
|
|
level1,
|
|
{ timeout: 8000 }
|
|
);
|
|
} catch (e) {
|
|
// L1 target not found after waiting - collect debug info and fail
|
|
const debugInfo = await page.evaluate(() => {
|
|
const sidebar = document.querySelector('.sidebar-scroll, [data-sidebar="content"], nav');
|
|
const items = document.querySelectorAll('a, button, [role="button"], [role="menuitem"], [role="treeitem"]');
|
|
const texts = [];
|
|
items.forEach(el => {
|
|
const t = (el.textContent || el.innerText || '').trim();
|
|
if (t && t.length > 1 && t.length < 25 && !texts.includes(t)) texts.push(t);
|
|
});
|
|
return { hasSidebar: !!sidebar, url: window.location.href, menuTexts: texts.slice(0, 25) };
|
|
});
|
|
console.log(C.red(` [NAV-FAIL] L1 "${level1}" not found after wait. URL: ${debugInfo.url}, sidebar: ${debugInfo.hasSidebar}`));
|
|
console.log(C.dim(` [NAV-FAIL] Visible items: ${debugInfo.menuTexts.join(', ')}`));
|
|
return false;
|
|
}
|
|
|
|
// Find and click level1 menu with scroll-based search
|
|
const l1Found = await page.evaluate(
|
|
async ({ l1Text }) => {
|
|
const sidebar = document.querySelector('.sidebar-scroll, [data-sidebar="content"], nav');
|
|
const maxAttempts = 20;
|
|
|
|
for (let i = 0; i < maxAttempts; i++) {
|
|
const items = Array.from(
|
|
document.querySelectorAll('a, button, [role="button"], [role="menuitem"], [role="treeitem"]')
|
|
);
|
|
|
|
const match = items.find((el) => {
|
|
const text = (el.textContent || el.innerText || '').trim();
|
|
return text && (text === l1Text || text.startsWith(l1Text));
|
|
});
|
|
|
|
if (match) {
|
|
match.scrollIntoView({ behavior: 'instant', block: 'center' });
|
|
await new Promise((r) => setTimeout(r, 100));
|
|
match.click();
|
|
return { found: true, attempt: i };
|
|
}
|
|
|
|
if (sidebar) {
|
|
sidebar.scrollBy({ top: 150, behavior: 'instant' });
|
|
await new Promise((r) => setTimeout(r, 100));
|
|
}
|
|
}
|
|
return { found: false };
|
|
},
|
|
{ l1Text: level1 }
|
|
);
|
|
|
|
if (!l1Found.found) {
|
|
return false;
|
|
}
|
|
await sleep(500); // Wait for submenu to expand
|
|
|
|
// Find and click level2 menu with scroll-based search
|
|
if (level2) {
|
|
const l2Found = await page.evaluate(
|
|
async ({ l2Text }) => {
|
|
const sidebar = document.querySelector('.sidebar-scroll, [data-sidebar="content"], nav');
|
|
const maxAttempts = 15;
|
|
|
|
for (let i = 0; i < maxAttempts; i++) {
|
|
const items = Array.from(
|
|
document.querySelectorAll('a, button, [role="button"], [role="menuitem"], [role="treeitem"]')
|
|
);
|
|
|
|
// Try exact match first (textContent for collapsed sidebar support)
|
|
let match = items.find((el) => (el.textContent || el.innerText || '').trim() === l2Text);
|
|
|
|
// Try partial match if exact match fails
|
|
if (!match) {
|
|
match = items.find((el) => (el.textContent || el.innerText || '').trim().includes(l2Text));
|
|
}
|
|
|
|
if (match) {
|
|
match.scrollIntoView({ behavior: 'instant', block: 'center' });
|
|
await new Promise((r) => setTimeout(r, 100));
|
|
match.click();
|
|
return { found: true };
|
|
}
|
|
|
|
// Scroll down a bit to find more items
|
|
if (sidebar) {
|
|
sidebar.scrollBy({ top: 100, behavior: 'instant' });
|
|
await new Promise((r) => setTimeout(r, 100));
|
|
}
|
|
}
|
|
return { found: false };
|
|
},
|
|
{ l2Text: level2 }
|
|
);
|
|
|
|
if (!l2Found.found) return false;
|
|
await sleep(2000); // Wait for page load
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
// ─── Dashboard Navigation ───────────────────────────────────
|
|
|
|
async function ensureLoggedIn(page) {
|
|
const url = page.url();
|
|
if (url.includes('/login')) {
|
|
// Need to re-login
|
|
await page.fill('#userId', AUTH.username);
|
|
await page.fill('#password', AUTH.password);
|
|
await page.click("button[type='submit']");
|
|
await sleep(3000);
|
|
}
|
|
}
|
|
|
|
async function goToDashboard(page) {
|
|
// Helper: expand sidebar if collapsed, then check menu items rendered
|
|
const waitForSidebar = async (timeout = 8000) => {
|
|
// Force sidebar expanded via sam-menu localStorage
|
|
await page.evaluate(() => {
|
|
try {
|
|
const raw = localStorage.getItem('sam-menu');
|
|
if (raw) {
|
|
const data = JSON.parse(raw);
|
|
if (data.state && data.state.sidebarCollapsed) {
|
|
data.state.sidebarCollapsed = false;
|
|
localStorage.setItem('sam-menu', JSON.stringify(data));
|
|
// Reload needed to apply the change
|
|
window.location.reload();
|
|
}
|
|
}
|
|
} catch (e) {}
|
|
});
|
|
await sleep(1500);
|
|
|
|
// Wait for sidebar menu items to have visible text (innerText works when expanded)
|
|
await page.waitForFunction(() => {
|
|
const sidebar = document.querySelector('.sidebar-scroll, [data-sidebar="content"]');
|
|
if (!sidebar) return false;
|
|
const items = sidebar.querySelectorAll('a, button, [role="button"], [role="menuitem"]');
|
|
const withText = Array.from(items).filter(el => {
|
|
const t = (el.innerText || el.textContent || '').trim();
|
|
return t.length > 1;
|
|
});
|
|
return withText.length >= 5;
|
|
}, null, { timeout });
|
|
};
|
|
|
|
// Force sidebar expanded state BEFORE navigation so page loads with full menu
|
|
try {
|
|
await page.evaluate(() => {
|
|
try {
|
|
// The sidebar state is stored in 'sam-menu' localStorage key
|
|
const raw = localStorage.getItem('sam-menu');
|
|
if (raw) {
|
|
const data = JSON.parse(raw);
|
|
if (data.state) {
|
|
data.state.sidebarCollapsed = false;
|
|
localStorage.setItem('sam-menu', JSON.stringify(data));
|
|
}
|
|
}
|
|
} catch (e) {}
|
|
});
|
|
} catch (e) { /* page may not be ready yet */ }
|
|
|
|
// Attempt 1: Navigate to dashboard
|
|
try {
|
|
await page.goto(DASHBOARD_URL, { waitUntil: 'load', timeout: 15000 });
|
|
await sleep(1000);
|
|
await ensureLoggedIn(page);
|
|
await waitForSidebar();
|
|
return;
|
|
} catch (e) {
|
|
const dbgUrl = page.url();
|
|
console.log(C.yellow(` [DASH] attempt 1 failed. URL: ${dbgUrl}, err: ${e.message?.substring(0, 80)}`));
|
|
}
|
|
|
|
// Attempt 2: Reload to force fresh render
|
|
try {
|
|
await page.reload({ waitUntil: 'load', timeout: 10000 });
|
|
await sleep(1500);
|
|
await ensureLoggedIn(page);
|
|
await waitForSidebar();
|
|
return;
|
|
} catch (e) {
|
|
const dbgUrl = page.url();
|
|
console.log(C.yellow(` [DASH] reload failed. URL: ${dbgUrl}, err: ${e.message?.substring(0, 80)}`));
|
|
}
|
|
|
|
// Attempt 3: Full re-login
|
|
try {
|
|
await page.goto(`${BASE_URL}/ko/login`, { waitUntil: 'load', timeout: 10000 });
|
|
await sleep(500);
|
|
try {
|
|
await page.fill('#userId', AUTH.username);
|
|
await page.fill('#password', AUTH.password);
|
|
await page.click("button[type='submit']");
|
|
await sleep(3000);
|
|
} catch (loginErr) { /* may already be on dashboard */ }
|
|
await waitForSidebar();
|
|
} catch (e) {
|
|
await sleep(2000);
|
|
}
|
|
}
|
|
|
|
const SCENARIO_TIMEOUT = 120000; // 2 minutes per scenario
|
|
|
|
// ─── Scenario Runner ────────────────────────────────────────
|
|
|
|
async function runScenario(page, scenarioPath) {
|
|
const scenarioJson = JSON.parse(fs.readFileSync(scenarioPath, 'utf-8'));
|
|
const { id, name, steps, selectors, menuNavigation } = scenarioJson;
|
|
|
|
const result = {
|
|
id: id || path.basename(scenarioPath, '.json'),
|
|
name: name || id,
|
|
steps: [],
|
|
passed: 0,
|
|
failed: 0,
|
|
warned: 0,
|
|
totalSteps: 0,
|
|
apiSummary: null,
|
|
error: null,
|
|
stoppedReason: 'complete',
|
|
currentUrl: '',
|
|
startTime: Date.now(),
|
|
endTime: 0,
|
|
};
|
|
|
|
if (!steps || steps.length === 0) {
|
|
result.error = 'No steps defined';
|
|
result.stoppedReason = 'no_steps';
|
|
result.endTime = Date.now();
|
|
return result;
|
|
}
|
|
|
|
try {
|
|
// Navigate to dashboard first
|
|
await goToDashboard(page);
|
|
|
|
// Inject executor
|
|
await injectExecutor(page);
|
|
|
|
// Menu navigation if specified
|
|
if (menuNavigation && menuNavigation.level1) {
|
|
const navOk = await navigateViaMenu(page, menuNavigation.level1, menuNavigation.level2);
|
|
if (!navOk) {
|
|
result.error = `Menu navigation failed: ${menuNavigation.level1} > ${menuNavigation.level2}`;
|
|
result.stoppedReason = 'navigation_failed';
|
|
result.endTime = Date.now();
|
|
return result;
|
|
}
|
|
// Re-inject after navigation
|
|
await sleep(1000);
|
|
await injectExecutor(page);
|
|
}
|
|
|
|
// Run steps in batches (handling navigation stops)
|
|
let currentIndex = 0;
|
|
let vars = {};
|
|
const allResults = [];
|
|
|
|
while (currentIndex < steps.length) {
|
|
const batch = steps.slice(currentIndex);
|
|
|
|
let batchResult;
|
|
try {
|
|
batchResult = await page.evaluate(
|
|
async ({ batch, vars, selectors }) => {
|
|
const r = await window.__E2E__.runBatch(batch, vars, { selectors: selectors || {} });
|
|
return r;
|
|
},
|
|
{ batch, vars, selectors: selectors || {} }
|
|
);
|
|
} catch (evalErr) {
|
|
// If evaluate fails (page navigated away, etc.), try re-injection
|
|
try {
|
|
await sleep(2000);
|
|
await injectExecutor(page);
|
|
batchResult = await page.evaluate(
|
|
async ({ batch, vars, selectors }) => {
|
|
const r = await window.__E2E__.runBatch(batch, vars, { selectors: selectors || {} });
|
|
return r;
|
|
},
|
|
{ batch, vars, selectors: selectors || {} }
|
|
);
|
|
} catch (retryErr) {
|
|
result.error = `Evaluate failed: ${retryErr.message}`;
|
|
result.stoppedReason = 'evaluate_error';
|
|
break;
|
|
}
|
|
}
|
|
|
|
// Collect results
|
|
if (batchResult.results) {
|
|
allResults.push(...batchResult.results);
|
|
}
|
|
vars = batchResult.variables || vars;
|
|
result.apiSummary = batchResult.apiSummary;
|
|
result.currentUrl = batchResult.currentUrl;
|
|
|
|
// Handle stoppedReason
|
|
if (batchResult.stoppedReason === 'complete') {
|
|
break;
|
|
}
|
|
|
|
if (batchResult.stoppedReason === 'navigation') {
|
|
await sleep(2000);
|
|
try {
|
|
await injectExecutor(page);
|
|
} catch (e) {
|
|
// Page might still be loading
|
|
await sleep(3000);
|
|
try {
|
|
await injectExecutor(page);
|
|
} catch (e2) {
|
|
result.error = `Re-injection failed after navigation: ${e2.message}`;
|
|
result.stoppedReason = 'reinjection_failed';
|
|
break;
|
|
}
|
|
}
|
|
currentIndex += batchResult.stoppedAtIndex;
|
|
continue;
|
|
}
|
|
|
|
if (batchResult.stoppedReason === 'native_required') {
|
|
// Take screenshot
|
|
const ssName = `${result.id}_step${batchResult.stoppedAtIndex}_${getTimestamp()}.png`;
|
|
try {
|
|
await page.screenshot({ path: path.join(SCREENSHOTS_DIR, ssName), fullPage: false });
|
|
} catch (ssErr) {
|
|
// Screenshot failed, continue
|
|
}
|
|
currentIndex += batchResult.stoppedAtIndex + 1;
|
|
// Re-inject in case page changed
|
|
try { await injectExecutor(page); } catch (e) { /* ignore */ }
|
|
continue;
|
|
}
|
|
|
|
if (batchResult.stoppedReason === 'critical_failure') {
|
|
result.stoppedReason = 'critical_failure';
|
|
break;
|
|
}
|
|
|
|
// Unknown stoppedReason
|
|
break;
|
|
}
|
|
|
|
// Aggregate results
|
|
result.steps = allResults;
|
|
result.totalSteps = allResults.length;
|
|
result.passed = allResults.filter((r) => r.status === 'pass').length;
|
|
result.failed = allResults.filter((r) => r.status === 'fail').length;
|
|
result.warned = allResults.filter((r) => r.status === 'warn').length;
|
|
if (result.stoppedReason === 'complete' && result.failed > 0) {
|
|
result.stoppedReason = 'completed_with_failures';
|
|
}
|
|
} catch (err) {
|
|
result.error = err.message;
|
|
result.stoppedReason = 'exception';
|
|
}
|
|
|
|
result.endTime = Date.now();
|
|
return result;
|
|
}
|
|
|
|
// ─── Report Generation ──────────────────────────────────────
|
|
|
|
function generateReport(result, timestamp) {
|
|
const duration = ((result.endTime - result.startTime) / 1000).toFixed(1);
|
|
const hasFail = result.failed > 0 || result.error;
|
|
const status = hasFail ? 'FAIL' : 'PASS';
|
|
const icon = hasFail ? '❌' : '✅';
|
|
|
|
const stepsTable = result.steps
|
|
.map((s) => {
|
|
const statusIcon = s.status === 'pass' ? '✅' : s.status === 'fail' ? '❌' : '⚠️';
|
|
const phase = s.phase || '-';
|
|
const details = (s.details || '').substring(0, 80).replace(/\|/g, '/');
|
|
return `| ${s.stepId} | ${s.name} | ${phase} | ${statusIcon} | ${s.duration}ms | ${details} |`;
|
|
})
|
|
.join('\n');
|
|
|
|
const failedSteps = result.steps.filter((s) => s.status === 'fail');
|
|
const failedTable = failedSteps.length > 0
|
|
? failedSteps
|
|
.map((s) => `| ${s.stepId} | ${s.name} | ${s.phase || '-'} | ${(s.error || s.details || '').substring(0, 100)} |`)
|
|
.join('\n')
|
|
: '';
|
|
|
|
const api = result.apiSummary || { total: 0, success: 0, failed: 0, avgResponseTime: 0, slowCalls: 0 };
|
|
|
|
let md = `# ${icon} E2E 테스트 ${hasFail ? '실패' : '성공'}: ${result.name}
|
|
|
|
**테스트 ID**: ${result.id} | **실행**: ${timestamp} | **결과**: ${status}
|
|
**소요 시간**: ${duration}초${result.error ? ` | **에러**: ${result.error}` : ''}${result.stoppedReason !== 'complete' && result.stoppedReason !== 'completed_with_failures' ? ` | **중단 사유**: ${result.stoppedReason}` : ''}
|
|
|
|
## 테스트 요약
|
|
| 전체 | 성공 | 실패 | 경고 | 성공률 |
|
|
|------|------|------|------|--------|
|
|
| ${result.totalSteps} | ${result.passed} | ${result.failed} | ${result.warned} | ${result.totalSteps > 0 ? Math.round((result.passed / result.totalSteps) * 100) : 0}% |
|
|
`;
|
|
|
|
if (failedTable) {
|
|
md += `
|
|
## 실패 스텝
|
|
| # | 스텝 | Phase | 에러 |
|
|
|---|------|-------|------|
|
|
${failedTable}
|
|
`;
|
|
}
|
|
|
|
md += `
|
|
## 전체 스텝 결과
|
|
| # | 스텝 | Phase | 상태 | 소요시간 | 비고 |
|
|
|---|------|-------|------|---------|------|
|
|
${stepsTable || '| - | (스텝 없음) | - | - | - | - |'}
|
|
|
|
## API 요약
|
|
| 총 호출 | 성공 | 실패 | 평균 응답 | 느린 호출(>2s) |
|
|
|---------|------|------|----------|--------------|
|
|
| ${api.total} | ${api.success} | ${api.failed} | ${api.avgResponseTime}ms | ${api.slowCalls} |
|
|
`;
|
|
|
|
return md;
|
|
}
|
|
|
|
function saveReport(result, timestamp) {
|
|
const hasFail = result.failed > 0 || result.error;
|
|
|
|
if (hasFail) {
|
|
const filePath = path.join(RESULTS_DIR, `Fail-${result.id}_${timestamp}.md`);
|
|
fs.writeFileSync(filePath, generateReport(result, timestamp), 'utf-8');
|
|
return filePath;
|
|
} else {
|
|
const filePath = path.join(SUCCESS_DIR, `OK-${result.id}_${timestamp}.md`);
|
|
fs.writeFileSync(filePath, generateReport(result, timestamp), 'utf-8');
|
|
return filePath;
|
|
}
|
|
}
|
|
|
|
// ─── Summary Report ─────────────────────────────────────────
|
|
|
|
function generateSummaryReport(allResults, totalTime, timestamp) {
|
|
const passed = allResults.filter((r) => !r.error && r.failed === 0).length;
|
|
const failed = allResults.length - passed;
|
|
|
|
let md = `# E2E 전체 테스트 결과 요약
|
|
|
|
**실행 시간**: ${timestamp}
|
|
**총 소요 시간**: ${(totalTime / 1000 / 60).toFixed(1)}분
|
|
**전체 시나리오**: ${allResults.length}개 | **성공**: ${passed}개 | **실패**: ${failed}개
|
|
|
|
## 시나리오별 결과
|
|
| # | 시나리오 | 결과 | 스텝 | 성공 | 실패 | 소요(초) |
|
|
|---|---------|------|------|------|------|---------|
|
|
`;
|
|
|
|
allResults.forEach((r, i) => {
|
|
const hasFail = r.failed > 0 || r.error;
|
|
const icon = hasFail ? '❌' : '✅';
|
|
const duration = ((r.endTime - r.startTime) / 1000).toFixed(1);
|
|
md += `| ${i + 1} | ${r.name} | ${icon} | ${r.totalSteps} | ${r.passed} | ${r.failed} | ${duration} |\n`;
|
|
});
|
|
|
|
if (failed > 0) {
|
|
md += `\n## 실패 시나리오 상세\n`;
|
|
allResults
|
|
.filter((r) => r.failed > 0 || r.error)
|
|
.forEach((r) => {
|
|
md += `\n### ❌ ${r.name} (${r.id})\n`;
|
|
if (r.error) md += `- **에러**: ${r.error}\n`;
|
|
const failSteps = r.steps.filter((s) => s.status === 'fail');
|
|
failSteps.forEach((s) => {
|
|
md += `- Step ${s.stepId} (${s.name}): ${s.error || s.details}\n`;
|
|
});
|
|
});
|
|
}
|
|
|
|
return md;
|
|
}
|
|
|
|
// ─── Main ───────────────────────────────────────────────────
|
|
|
|
async function main() {
|
|
console.log(C.bold('\n=== E2E 전체 테스트 러너 ==='));
|
|
console.log(`서버: ${BASE_URL}`);
|
|
console.log(`모드: ${HEADLESS ? 'headless' : 'headed'}`);
|
|
if (FILTER) console.log(`필터: ${FILTER}`);
|
|
console.log('');
|
|
|
|
// Ensure directories
|
|
ensureDir(RESULTS_DIR);
|
|
ensureDir(SUCCESS_DIR);
|
|
ensureDir(SCREENSHOTS_DIR);
|
|
|
|
// Collect scenario files (skip disabled scenarios)
|
|
let scenarioFiles = fs.readdirSync(SCENARIOS_DIR)
|
|
.filter((f) => f.endsWith('.json') && !f.startsWith('_'))
|
|
.filter((f) => {
|
|
try {
|
|
const data = JSON.parse(fs.readFileSync(path.join(SCENARIOS_DIR, f), 'utf-8'));
|
|
return data.enabled !== false; // Skip if explicitly disabled
|
|
} catch (e) {
|
|
return true; // Include if can't parse (will fail later with better error)
|
|
}
|
|
})
|
|
.sort();
|
|
|
|
if (FILTER) {
|
|
scenarioFiles = scenarioFiles.filter((f) => f.includes(FILTER));
|
|
}
|
|
|
|
const totalScenarios = scenarioFiles.length;
|
|
console.log(`시나리오: ${totalScenarios}개 발견\n`);
|
|
|
|
if (totalScenarios === 0) {
|
|
console.log(C.red('실행할 시나리오가 없습니다.'));
|
|
process.exit(1);
|
|
}
|
|
|
|
// Launch browser
|
|
const browser = await chromium.launch({
|
|
headless: HEADLESS,
|
|
args: [
|
|
`--window-position=1920,0`,
|
|
'--window-size=1920,1080',
|
|
'--disable-blink-features=AutomationControlled',
|
|
],
|
|
});
|
|
|
|
const context = await browser.newContext({
|
|
viewport: { width: 1920, height: 1080 },
|
|
locale: 'ko-KR',
|
|
ignoreHTTPSErrors: true,
|
|
userAgent: 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36',
|
|
});
|
|
|
|
const page = await context.newPage();
|
|
|
|
// Mask automation detection
|
|
await page.addInitScript(() => {
|
|
Object.defineProperty(navigator, 'webdriver', { get: () => undefined });
|
|
});
|
|
|
|
// Login
|
|
console.log(C.cyan('로그인 중...'));
|
|
try {
|
|
await page.goto(`${BASE_URL}/ko/login`, { waitUntil: 'domcontentloaded', timeout: 20000 });
|
|
await sleep(1000);
|
|
|
|
await page.fill('#userId', AUTH.username);
|
|
await page.fill('#password', AUTH.password);
|
|
await page.click("button[type='submit']");
|
|
await sleep(3000);
|
|
|
|
const url = page.url();
|
|
if (url.includes('/login')) {
|
|
console.log(C.red('로그인 실패! 대시보드로 이동하지 못함'));
|
|
await browser.close();
|
|
process.exit(1);
|
|
}
|
|
console.log(C.green('로그인 성공!\n'));
|
|
} catch (loginErr) {
|
|
console.log(C.red(`로그인 에러: ${loginErr.message}`));
|
|
await browser.close();
|
|
process.exit(1);
|
|
}
|
|
|
|
// Run scenarios
|
|
const allResults = [];
|
|
const startTime = Date.now();
|
|
|
|
for (let i = 0; i < scenarioFiles.length; i++) {
|
|
const file = scenarioFiles[i];
|
|
const scenarioPath = path.join(SCENARIOS_DIR, file);
|
|
const num = `(${i + 1}/${totalScenarios})`;
|
|
|
|
process.stdout.write(`${C.dim(num)} ${file.replace('.json', '')} ... `);
|
|
|
|
let result;
|
|
try {
|
|
// Wrap with timeout
|
|
result = await Promise.race([
|
|
runScenario(page, scenarioPath),
|
|
sleep(SCENARIO_TIMEOUT).then(() => ({
|
|
id: file.replace('.json', ''),
|
|
name: file.replace('.json', ''),
|
|
steps: [],
|
|
passed: 0,
|
|
failed: 0,
|
|
warned: 0,
|
|
totalSteps: 0,
|
|
apiSummary: null,
|
|
error: `Timeout (>${SCENARIO_TIMEOUT / 1000}s)`,
|
|
stoppedReason: 'timeout',
|
|
currentUrl: '',
|
|
startTime: Date.now() - SCENARIO_TIMEOUT,
|
|
endTime: Date.now(),
|
|
})),
|
|
]);
|
|
} catch (scenarioErr) {
|
|
result = {
|
|
id: file.replace('.json', ''),
|
|
name: file.replace('.json', ''),
|
|
steps: [],
|
|
passed: 0,
|
|
failed: 0,
|
|
warned: 0,
|
|
totalSteps: 0,
|
|
apiSummary: null,
|
|
error: scenarioErr.message,
|
|
stoppedReason: 'exception',
|
|
currentUrl: '',
|
|
startTime: Date.now(),
|
|
endTime: Date.now(),
|
|
};
|
|
}
|
|
|
|
allResults.push(result);
|
|
|
|
// Save report
|
|
const ts = getTimestamp();
|
|
saveReport(result, ts);
|
|
|
|
// Console output
|
|
const hasFail = result.failed > 0 || result.error;
|
|
const duration = ((result.endTime - result.startTime) / 1000).toFixed(1);
|
|
if (hasFail) {
|
|
console.log(`${C.red('FAIL')} ${C.dim(`(${result.passed}/${result.totalSteps} passed, ${duration}s)`)}`);
|
|
} else {
|
|
console.log(`${C.green('PASS')} ${C.dim(`(${result.passed}/${result.totalSteps}, ${duration}s)`)}`);
|
|
}
|
|
|
|
// After login scenario or if logged out, re-login
|
|
if (file === 'login.json' || page.url().includes('/login')) {
|
|
try {
|
|
await page.goto(`${BASE_URL}/ko/login`, { waitUntil: 'domcontentloaded', timeout: 10000 });
|
|
await sleep(500);
|
|
await page.fill('#userId', AUTH.username);
|
|
await page.fill('#password', AUTH.password);
|
|
await page.click("button[type='submit']");
|
|
await sleep(3000);
|
|
} catch (reloginErr) {
|
|
// Continue anyway
|
|
}
|
|
}
|
|
}
|
|
|
|
const totalTime = Date.now() - startTime;
|
|
|
|
// Generate summary report
|
|
const summaryTs = getTimestamp();
|
|
const summaryMd = generateSummaryReport(allResults, totalTime, summaryTs);
|
|
const summaryPath = path.join(RESULTS_DIR, `E2E_FULL_TEST_SUMMARY_${summaryTs}.md`);
|
|
fs.writeFileSync(summaryPath, summaryMd, 'utf-8');
|
|
|
|
// Close browser
|
|
await browser.close();
|
|
|
|
// Print summary
|
|
const passCount = allResults.filter((r) => !r.error && r.failed === 0).length;
|
|
const failCount = allResults.length - passCount;
|
|
|
|
console.log(C.bold('\n=== 테스트 완료 ==='));
|
|
console.log(`전체: ${totalScenarios} | ${C.green(`성공: ${passCount}`)} | ${failCount > 0 ? C.red(`실패: ${failCount}`) : '실패: 0'}`);
|
|
console.log(`소요 시간: ${(totalTime / 1000 / 60).toFixed(1)}분`);
|
|
console.log(`요약 리포트: ${summaryPath}`);
|
|
console.log('');
|
|
}
|
|
|
|
main().catch((err) => {
|
|
console.error(C.red(`\n치명적 에러: ${err.message}`));
|
|
console.error(err.stack);
|
|
process.exit(1);
|
|
});
|