309 lines
16 KiB
JavaScript
309 lines
16 KiB
JavaScript
// e2e/validate-flow-browserless.js
|
|
// Connects to a browserless WebSocket endpoint and validates the BroadcastPanel -> Studio flow
|
|
// Expects env vars:
|
|
// BROWSERLESS_WS (wss://...)
|
|
// BROWSERLESS_TOKEN (optional)
|
|
// VITE_BROADCASTPANEL_URL or BROADCAST_URL
|
|
// VITE_STUDIO_URL or STUDIO_URL (optional, fallback to page's url)
|
|
// TOKEN or E2E_TOKEN (token to pass to studio)
|
|
|
|
const fs = require('fs');
|
|
const path = require('path');
|
|
const puppeteer = require('puppeteer-core');
|
|
|
|
// Helper: evaluate sessionStorage and backend token assertions
|
|
async function evaluateSessionAssertions(broadcastPage, studioPage, results, BROADCAST_URL, TOKEN) {
|
|
results.assertions = results.assertions || [];
|
|
try {
|
|
const storeKey = 'avanzacast_studio_session';
|
|
const stored = await broadcastPage.evaluate((k) => { try { return sessionStorage.getItem(k); } catch (e) { return null; } }, storeKey);
|
|
if (stored) {
|
|
try {
|
|
const parsed = JSON.parse(stored);
|
|
if (parsed && parsed.token) {
|
|
const note = (typeof TOKEN === 'string' && TOKEN.length && String(parsed.token).includes(TOKEN.slice(0,6))) ? 'sessionStorage contains token (matches provided TOKEN prefix)' : 'sessionStorage contains token (from backend)';
|
|
results.assertions.push({ name: 'sessionStorage_has_token', ok: true, detail: note });
|
|
|
|
try {
|
|
const parts = String(parsed.token).split('.');
|
|
const isJwt = parts.length >= 3;
|
|
results.assertions.push({ name: 'token_format_jwt', ok: isJwt, detail: isJwt ? 'looks like JWT' : 'not JWT-like' });
|
|
if (isJwt) {
|
|
const payloadB64 = parts[1].replace(/-/g, '+').replace(/_/g, '/');
|
|
const pad = '='.repeat((4 - (payloadB64.length % 4)) % 4);
|
|
const decoded = Buffer.from(payloadB64 + pad, 'base64').toString('utf8');
|
|
try {
|
|
const payloadObj = JSON.parse(decoded);
|
|
const nowSec = Math.floor(Date.now() / 1000);
|
|
if (payloadObj.exp && typeof payloadObj.exp === 'number') {
|
|
results.assertions.push({ name: 'token_not_expired', ok: payloadObj.exp > nowSec, detail: `exp=${payloadObj.exp} now=${nowSec}` });
|
|
} else {
|
|
results.assertions.push({ name: 'token_has_exp', ok: false, detail: 'exp missing or not a number' });
|
|
}
|
|
if (payloadObj.room) results.assertions.push({ name: 'token_payload_room', ok: true, detail: String(payloadObj.room) });
|
|
} catch (e) {
|
|
results.assertions.push({ name: 'token_payload_parse', ok: false, detail: 'failed to parse payload: ' + String(e) });
|
|
}
|
|
}
|
|
} catch (e) {
|
|
results.assertions.push({ name: 'token_format_check_failed', ok: false, detail: String(e) });
|
|
}
|
|
} else {
|
|
results.assertions.push({ name: 'sessionStorage_has_token', ok: false, detail: 'sessionStorage present but token missing or malformed' });
|
|
}
|
|
|
|
if (parsed && parsed.room) {
|
|
results.assertions.push({ name: 'session_room_present', ok: true, detail: String(parsed.room) });
|
|
} else {
|
|
results.assertions.push({ name: 'session_room_present', ok: false, detail: 'room missing in session payload' });
|
|
}
|
|
if (parsed && (parsed.url || parsed.serverUrl)) {
|
|
const serverUrl = parsed.url || parsed.serverUrl;
|
|
const okUrl = typeof serverUrl === 'string' && (serverUrl.startsWith('ws://') || serverUrl.startsWith('wss://') || serverUrl.startsWith('http://') || serverUrl.startsWith('https://'));
|
|
results.assertions.push({ name: 'session_serverUrl_valid', ok: okUrl, detail: okUrl ? String(serverUrl) : 'invalid or missing serverUrl' });
|
|
} else {
|
|
results.assertions.push({ name: 'session_serverUrl_valid', ok: false, detail: 'serverUrl missing' });
|
|
}
|
|
|
|
try {
|
|
const expectedRoom = process.env.EXPECTED_ROOM || null;
|
|
const expectedUsername = process.env.EXPECTED_USERNAME || null;
|
|
const minTtl = Number(process.env.MIN_TTL_SECONDS || process.env.MIN_TTL || 30);
|
|
|
|
if (expectedRoom) {
|
|
const roomMatches = !!parsed && String(parsed.room) === String(expectedRoom);
|
|
results.assertions.push({ name: 'session_room_matches_expected', ok: roomMatches, detail: roomMatches ? `room matches ${expectedRoom}` : `expected ${expectedRoom} got ${String(parsed.room)}` });
|
|
}
|
|
|
|
if (expectedUsername) {
|
|
const uname = parsed && (parsed.username || parsed.user || parsed.participantName || parsed.participant || parsed.participantName);
|
|
const unameMatches = !!uname && String(uname) === String(expectedUsername);
|
|
results.assertions.push({ name: 'session_username_matches_expected', ok: unameMatches, detail: unameMatches ? `username matches ${expectedUsername}` : `expected ${expectedUsername} got ${String(uname)}` });
|
|
} else {
|
|
const uname = parsed && (parsed.username || parsed.user || parsed.participantName || parsed.participant || parsed.participantName);
|
|
results.assertions.push({ name: 'session_username_present', ok: !!uname, detail: !!uname ? `username: ${String(uname)}` : 'username missing' });
|
|
}
|
|
|
|
let ttlSeconds = null;
|
|
if (parsed && typeof parsed.ttlSeconds === 'number') ttlSeconds = parsed.ttlSeconds;
|
|
else if (parsed && typeof parsed.ttl === 'number') ttlSeconds = parsed.ttl;
|
|
else if (parsed && parsed.expiresAt) {
|
|
const ex = typeof parsed.expiresAt === 'number' ? parsed.expiresAt : Date.parse(String(parsed.expiresAt));
|
|
if (!Number.isNaN(ex)) ttlSeconds = Math.max(0, Math.floor((ex - Date.now()) / 1000));
|
|
}
|
|
if (ttlSeconds !== null) {
|
|
results.assertions.push({ name: 'session_ttl_seconds', ok: true, detail: `ttlSeconds=${ttlSeconds}` });
|
|
results.assertions.push({ name: 'session_ttl_minimum', ok: ttlSeconds >= minTtl, detail: `ttl=${ttlSeconds} min=${minTtl}` });
|
|
} else {
|
|
results.assertions.push({ name: 'session_ttl_seconds', ok: false, detail: 'ttl not found in session payload' });
|
|
}
|
|
} catch (e) {
|
|
results.assertions.push({ name: 'session_ttl_check_failed', ok: false, detail: String(e) });
|
|
}
|
|
|
|
if (parsed && (parsed.id || parsed.sessionId)) {
|
|
const sid = parsed.id || parsed.sessionId;
|
|
try {
|
|
const base = (BROADCAST_URL || '').replace(/\/$/, '');
|
|
const tokenEndpoint = `${base}/api/session/${encodeURIComponent(sid)}/token`;
|
|
let fetched = null;
|
|
try {
|
|
const fetchMod = await import('node-fetch');
|
|
const r = await fetchMod.default(tokenEndpoint).catch(() => null);
|
|
if (r && r.ok) fetched = await r.json().catch(() => null);
|
|
} catch (fe) { fetched = null }
|
|
if (!fetched) {
|
|
const TOKEN_SERVER = process.env.TOKEN_SERVER_URL || process.env.VITE_TOKEN_SERVER_URL || process.env.VITE_BACKEND_TOKENS_URL || null;
|
|
if (TOKEN_SERVER) {
|
|
const abs = `${TOKEN_SERVER.replace(/\/$/, '')}/api/session/${encodeURIComponent(sid)}/token`;
|
|
try {
|
|
const fetchMod2 = await import('node-fetch');
|
|
const r2 = await fetchMod2.default(abs).catch(() => null);
|
|
if (r2 && r2.ok) fetched = await r2.json().catch(() => null);
|
|
} catch (fe2) { fetched = null }
|
|
}
|
|
}
|
|
if (fetched && fetched.token) {
|
|
results.assertions.push({ name: 'backend_token_fetch', ok: true, detail: 'fetched token from backend' });
|
|
try {
|
|
const minTtl = Number(process.env.MIN_TTL_SECONDS || process.env.MIN_TTL || 30);
|
|
const bttl = fetched.ttlSeconds || fetched.ttl || null;
|
|
if (typeof bttl === 'number') {
|
|
results.assertions.push({ name: 'backend_ttl_seconds', ok: true, detail: `backend ttlSeconds=${bttl}` });
|
|
results.assertions.push({ name: 'backend_ttl_minimum', ok: bttl >= minTtl, detail: `backend ttl=${bttl} min=${minTtl}` });
|
|
} else {
|
|
results.assertions.push({ name: 'backend_ttl_seconds', ok: false, detail: 'backend ttl not present or not numeric' });
|
|
}
|
|
} catch (e) {
|
|
results.assertions.push({ name: 'backend_ttl_check_failed', ok: false, detail: String(e) });
|
|
}
|
|
} else {
|
|
results.assertions.push({ name: 'backend_token_fetch', ok: false, detail: 'could not fetch token for session id' });
|
|
}
|
|
} catch (e) {
|
|
results.assertions.push({ name: 'backend_token_fetch', ok: false, detail: 'error: ' + String(e) });
|
|
}
|
|
}
|
|
|
|
} catch (e) {
|
|
results.assertions.push({ name: 'sessionStorage_parse', ok: false, detail: 'sessionStorage JSON parse failed: ' + String(e) });
|
|
}
|
|
} else {
|
|
results.assertions.push({ name: 'sessionStorage_has_token', ok: false, detail: 'sessionStorage key not found' });
|
|
}
|
|
} catch (e) {
|
|
results.assertions.push({ name: 'sessionStorage_check_failed', ok: false, detail: String(e) });
|
|
}
|
|
}
|
|
|
|
(async () => {
|
|
const outDir = path.resolve(__dirname);
|
|
const results = { startedAt: new Date().toISOString(), console: [], navigations: [] };
|
|
|
|
let ws = process.env.BROWSERLESS_WS || process.env.BWS || '';
|
|
const btoken = process.env.BROWSERLESS_TOKEN || process.env.BWS_TOKEN || '';
|
|
try {
|
|
if (ws && btoken) {
|
|
const hasQuery = ws.includes('?');
|
|
ws = hasQuery ? `${ws}&token=${encodeURIComponent(btoken)}` : `${ws}?token=${encodeURIComponent(btoken)}`;
|
|
}
|
|
} catch (e) {}
|
|
|
|
if (!ws) {
|
|
console.error('BROWSERLESS_WS is required');
|
|
process.exit(2);
|
|
}
|
|
|
|
const BROADCAST_URL = process.env.VITE_BROADCASTPANEL_URL || process.env.BROADCAST_URL || '';
|
|
const STUDIO_URL = process.env.VITE_STUDIO_URL || process.env.STUDIO_URL || null;
|
|
const TOKEN = process.env.TOKEN || process.env.E2E_TOKEN || '';
|
|
|
|
console.log('Connecting to browserless at', ws);
|
|
let browser;
|
|
try {
|
|
browser = await puppeteer.connect({ browserWSEndpoint: ws, ignoreHTTPSErrors: true, defaultViewport: { width: 1366, height: 768 } });
|
|
} catch (err) {
|
|
console.error('Failed to connect to browserless:', err && err.message ? err.message : err);
|
|
process.exit(2);
|
|
}
|
|
|
|
const page = await browser.newPage();
|
|
page.setDefaultNavigationTimeout(30000);
|
|
page.on('console', msg => { try { results.console.push({ type: msg.type(), text: msg.text() }); } catch (e) {} });
|
|
page.on('pageerror', err => { results.console.push({ type: 'pageerror', text: String(err && err.stack ? err.stack : err) }); });
|
|
|
|
try {
|
|
if (!BROADCAST_URL) {
|
|
console.error('BROADCAST_URL (VITE_BROADCASTPANEL_URL) is required');
|
|
await browser.disconnect();
|
|
process.exit(2);
|
|
}
|
|
|
|
await page.goto(BROADCAST_URL, { waitUntil: 'networkidle2' });
|
|
await page.waitForTimeout(1500);
|
|
|
|
const texts = ['Entrar al estudio', 'Entrar al Studio', 'Entrar al Estudio', 'Entrar al Studio', 'Enter studio', 'Enter the studio', 'Enter the studio'];
|
|
let clicked = false;
|
|
|
|
for (const t of texts) {
|
|
const els = await page.$x(`//a[contains(normalize-space(.), '${t}')] | //button[contains(normalize-space(.), '${t}')] | //span[contains(normalize-space(.), '${t}')]`);
|
|
if (els && els.length) {
|
|
console.log('Found element for text:', t, 'count=', els.length);
|
|
try {
|
|
// Try click and wait for targetcreated or navigation
|
|
const popupPromise = new Promise(resolve => {
|
|
const onTarget = target => { resolve(target); };
|
|
browser.once('targetcreated', onTarget);
|
|
setTimeout(() => { try { browser.removeListener('targetcreated', onTarget) } catch(e){}; resolve(null); }, 3000);
|
|
});
|
|
|
|
await els[0].click({ delay: 50 }).catch(() => null);
|
|
const popupTarget = await popupPromise;
|
|
|
|
let studioPage = null;
|
|
if (popupTarget) {
|
|
try { studioPage = await popupTarget.page(); } catch (e) { studioPage = null; }
|
|
}
|
|
|
|
if (!studioPage) {
|
|
await page.waitForTimeout(800);
|
|
const url = page.url();
|
|
if (url.includes('/studio') || url.includes('studio') || url.includes('avanzacast-studio')) studioPage = page;
|
|
}
|
|
|
|
if (studioPage) {
|
|
console.log('Studio page found; navigating with token...');
|
|
const targetStudioUrl = STUDIO_URL ? `${STUDIO_URL}?token=${encodeURIComponent(TOKEN)}` : `${studioPage.url().split('?')[0]}?token=${encodeURIComponent(TOKEN)}`;
|
|
await studioPage.goto(targetStudioUrl, { waitUntil: 'networkidle2' });
|
|
results.navigations.push({ type: 'studio_opened', url: studioPage.url() });
|
|
await studioPage.waitForTimeout(2500);
|
|
// Run assertions (sessionStorage + backend checks)
|
|
await evaluateSessionAssertions(page, studioPage, results, BROADCAST_URL, TOKEN);
|
|
const shot = path.join(outDir, 'studio_flow_browserless_result.png');
|
|
await studioPage.screenshot({ path: shot, fullPage: true });
|
|
results.screenshot = shot;
|
|
clicked = true;
|
|
break;
|
|
} else {
|
|
console.log('Click did not open studio for text:', t);
|
|
}
|
|
|
|
} catch (err) {
|
|
console.warn('Click attempt error', err && err.message);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!clicked) {
|
|
// fallback: try alternative selectors
|
|
const altSel = 'a#enter-studio, button#enter-studio, a[data-enter-studio], button[data-enter-studio]';
|
|
try {
|
|
const alt = await page.$(altSel);
|
|
if (alt) {
|
|
console.log('Found alternative selector, clicking...');
|
|
await alt.click().catch(() => null);
|
|
await page.waitForTimeout(1000);
|
|
}
|
|
} catch (e) {}
|
|
|
|
// fallback navigate directly to studio URL with token
|
|
if (STUDIO_URL) {
|
|
console.log('Fallback: navigating directly to STUDIO_URL with token');
|
|
const directUrl = `${STUDIO_URL}?token=${encodeURIComponent(TOKEN)}`;
|
|
await page.goto(directUrl, { waitUntil: 'networkidle2' });
|
|
await page.waitForTimeout(1500);
|
|
// Run assertions using current page as both broadcast and studio contexts
|
|
await evaluateSessionAssertions(page, page, results, BROADCAST_URL, TOKEN);
|
|
const shot = path.join(outDir, 'studio_flow_browserless_result.png');
|
|
await page.screenshot({ path: shot, fullPage: true });
|
|
results.screenshot = shot;
|
|
results.navigations.push({ type: 'direct_studio', url: directUrl });
|
|
} else {
|
|
console.error('No studio opened and no STUDIO_URL provided for fallback.');
|
|
}
|
|
}
|
|
|
|
results.endedAt = new Date().toISOString();
|
|
const outJson = path.join(outDir, 'validate-flow-browserless-result.json');
|
|
fs.writeFileSync(outJson, JSON.stringify(results, null, 2));
|
|
console.log('Wrote results to', outJson);
|
|
|
|
// Publish artifact and append run summary to LOG.md
|
|
try {
|
|
const { publishArtifact, appendLog } = require('./logging');
|
|
const artifactUrl = publishArtifact(outJson, 'validate-flow-browserless') || null;
|
|
appendLog('validate-flow-browserless', outJson, results, artifactUrl);
|
|
} catch (e) { console.warn('Failed to write LOG.md entry', e); }
|
|
|
|
try { await browser.disconnect(); } catch(e) { try { await browser.close(); } catch(e){} }
|
|
process.exit(0);
|
|
} catch (err) {
|
|
console.error('Error validating flow', err && err.stack ? err.stack : err);
|
|
results.error = String(err && err.stack ? err.stack : err);
|
|
results.endedAt = new Date().toISOString();
|
|
fs.writeFileSync(path.join(outDir, 'validate-flow-browserless-result.json'), JSON.stringify(results, null, 2));
|
|
try { await browser.disconnect(); } catch(e) { try { await browser.close(); } catch(e){} }
|
|
process.exit(1);
|
|
}
|
|
})();
|