cssprobe-cli 0.3.1 → 0.4.1

package/dist/scenario/runner.js

@@ -0,0 +1,251 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runScenario = runScenario;
+const fs_1 = __importDefault(require("fs"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const launcher_1 = require("../browser/launcher");
+const frames_1 = require("../browser/frames");
+const sampler_1 = require("../browser/sampler");
+const interactions_1 = require("../browser/interactions");
+const evalSerializer_1 = require("../engine/evalSerializer");
+const screenshot_1 = require("../utils/screenshot");
+const assertions_1 = require("./assertions");
+const reporters_1 = require("./reporters");
+async function evaluateValue(frame, expression) {
+    const handle = await frame.evaluateHandle(expression);
+    try {
+        const resolved = await handle.evaluateHandle((value) => Promise.resolve(value));
+        try {
+            return await resolved.evaluate(evalSerializer_1.serializeEvalResult);
+        }
+        finally {
+            await resolved.dispose();
+        }
+    }
+    finally {
+        await handle.dispose();
+    }
+}
+async function readState(page) {
+    return { url: page.url(), title: await page.title(), frames: (0, frames_1.describeFrames)(page).length };
+}
+async function readGlobals(page, names) {
+    if (!names.length)
+        return {};
+    return page.evaluate((list) => {
+        const out = {};
+        for (const name of list) {
+            let current = window;
+            for (const part of name.split('.')) {
+                if (current === null || current === undefined) {
+                    current = undefined;
+                    break;
+                }
+                current = current[part];
+            }
+            out[name] = typeof current;
+        }
+        return out;
+    }, names);
+}
+function stepLabel(step) {
+    return step.do;
+}
+function resolveCaseState(suiteDir, caseState, defaultsState, cliState) {
+    if (caseState)
+        return path_1.default.resolve(suiteDir, caseState);
+    if (defaultsState)
+        return path_1.default.resolve(suiteDir, defaultsState);
+    return cliState ? path_1.default.resolve(process.cwd(), cliState) : undefined;
+}
+function caseDirectory(root, index, name) {
+    const dir = path_1.default.join(root, `${String(index + 1).padStart(2, '0')}-${(0, reporters_1.slugify)(name)}`);
+    fs_1.default.mkdirSync(dir, { recursive: true });
+    return dir;
+}
+async function runScenario(suite, suitePath, options = {}) {
+    const suiteDir = path_1.default.dirname(path_1.default.resolve(suitePath));
+    const stamp = new Date().toISOString().replace(/[:.]/g, '-');
+    const artifactsDir = options.artifactsDir ??
+        path_1.default.join(os_1.default.homedir(), '.cssprobe-cli', 'scenario-runs', `${(0, reporters_1.slugify)(suite.name)}-${stamp}`);
+    fs_1.default.mkdirSync(artifactsDir, { recursive: true });
+    const results = [];
+    for (const [caseIndex, scenarioCase] of suite.cases.entries()) {
+        const caseDir = caseDirectory(artifactsDir, caseIndex, scenarioCase.name);
+        const result = {
+            name: scenarioCase.name,
+            ok: false,
+            durationMs: 0,
+            steps: [],
+            artifactsDir: caseDir,
+        };
+        const started = Date.now();
+        const launcher = new launcher_1.BrowserLauncher({
+            browser: options.browser,
+            headed: options.headed,
+            viewport: options.viewport ?? suite.defaults?.viewport,
+            state: resolveCaseState(suiteDir, scenarioCase.state, suite.defaults?.state, options.state),
+        });
+        const vars = {};
+        try {
+            const url = scenarioCase.url ?? suite.defaults?.url ?? 'about:blank';
+            await launcher.open(url);
+            const page = launcher.getPage();
+            if (!page)
+                throw new Error('Browser page is not available');
+            for (const [stepIndex, step] of scenarioCase.steps.entries()) {
+                const stepStarted = Date.now();
+                const stepResult = {
+                    index: stepIndex,
+                    action: stepLabel(step),
+                    ok: false,
+                    durationMs: 0,
+                };
+                try {
+                    await executeStep(step, {
+                        page,
+                        vars,
+                        frameSpec: scenarioCase.frame ?? suite.defaults?.frame,
+                        caseDir,
+                        stepIndex,
+                    });
+                    stepResult.ok = true;
+                    if ('save' in step && step.save)
+                        stepResult.saved = step.save;
+                }
+                catch (error) {
+                    stepResult.error = error.message;
+                    await page
+                        .screenshot({ path: path_1.default.join(caseDir, `failure-step-${stepIndex + 1}.png`) })
+                        .catch(() => { });
+                    throw error;
+                }
+                finally {
+                    stepResult.durationMs = Date.now() - stepStarted;
+                    result.steps.push(stepResult);
+                }
+            }
+            result.ok = true;
+        }
+        catch (error) {
+            result.ok = false;
+            result.error = error.message;
+        }
+        finally {
+            result.durationMs = Date.now() - started;
+            fs_1.default.writeFileSync(path_1.default.join(caseDir, 'case.json'), JSON.stringify(result, null, 2));
+            await launcher.close().catch(() => { });
+        }
+        results.push(result);
+        if (!result.ok && options.bail)
+            break;
+    }
+    const summary = (0, reporters_1.summarize)(results);
+    const runResult = { suite: suite.name, ok: summary.ok, summary, results, artifactsDir };
+    fs_1.default.writeFileSync(path_1.default.join(artifactsDir, 'summary.json'), JSON.stringify(runResult, null, 2));
+    if (options.junitPath) {
+        fs_1.default.mkdirSync(path_1.default.dirname(path_1.default.resolve(options.junitPath)), { recursive: true });
+        fs_1.default.writeFileSync(path_1.default.resolve(options.junitPath), require('./reporters').toJunit(suite.name, results), 'utf-8');
+    }
+    return runResult;
+}
+async function executeStep(step, context) {
+    const { page, vars, caseDir, stepIndex } = context;
+    switch (step.do) {
+        case 'goto': {
+            await page.goto(step.url, { waitUntil: step.waitUntil ?? 'domcontentloaded', timeout: 60000 });
+            if (step.save)
+                vars[step.save] = await readState(page);
+            return;
+        }
+        case 'reload': {
+            await page.reload({ waitUntil: step.waitUntil ?? 'domcontentloaded', timeout: 60000 });
+            if (step.save)
+                vars[step.save] = await readState(page);
+            return;
+        }
+        case 'eval': {
+            const frame = (0, frames_1.resolveFrame)(page, step.frame ?? context.frameSpec);
+            const value = await evaluateValue(frame, step.expression);
+            if (step.save)
+                vars[step.save] = value;
+            return;
+        }
+        case 'sample': {
+            const frame = (0, frames_1.resolveFrame)(page, step.frame ?? context.frameSpec);
+            const points = await (0, sampler_1.sampleFrame)(frame, step.expression, {
+                intervalMs: step.interval ?? 250,
+                durationMs: step.duration ?? 5000,
+                ignoreErrors: step.ignoreErrors,
+            });
+            const summary = (0, sampler_1.summarizeSamples)(points, step.key, 5000, step.tailFrom);
+            const value = { expression: step.expression, summary, series: points };
+            if (step.save)
+                vars[step.save] = value;
+            fs_1.default.writeFileSync(path_1.default.join(caseDir, `step-${stepIndex + 1}-${step.save ?? 'sample'}-series.json`), JSON.stringify(value, null, 2));
+            return;
+        }
+        case 'waitStable': {
+            const frame = (0, frames_1.resolveFrame)(page, step.frame ?? context.frameSpec);
+            const value = await (0, sampler_1.waitForStableValue)(frame, step.expression, {
+                tolerance: step.tolerance,
+                windowMs: step.window,
+                timeoutMs: step.timeout,
+                intervalMs: step.interval,
+            });
+            if (step.save)
+                vars[step.save] = value;
+            return;
+        }
+        case 'click': {
+            await (0, interactions_1.clickElement)(page, step.selector, { nth: step.nth, timeout: step.timeout });
+            return;
+        }
+        case 'waitFor': {
+            const timeout = step.timeout ?? 30000;
+            const frameSpec = step.frame ?? context.frameSpec;
+            if (step.networkIdle) {
+                if (frameSpec)
+                    throw new Error('networkIdle waits are page-level; remove frame');
+                await (0, interactions_1.waitForCondition)(page, { kind: 'networkIdle' }, timeout);
+            }
+            else if (step.js) {
+                await (0, interactions_1.waitForCondition)(frameSpec ? (0, frames_1.resolveFrame)(page, frameSpec) : page, { kind: 'js', expression: step.js }, timeout);
+            }
+            else if (step.selector) {
+                await (0, interactions_1.waitForCondition)(frameSpec ? (0, frames_1.resolveFrame)(page, frameSpec) : page, { kind: 'selector', selector: step.selector, state: step.state ?? 'visible' }, timeout);
+            }
+            else {
+                throw new Error('waitFor requires selector, js, or networkIdle');
+            }
+            return;
+        }
+        case 'wait': {
+            await new Promise(resolve => setTimeout(resolve, step.ms));
+            return;
+        }
+        case 'screenshot': {
+            const buffer = await page.screenshot({ fullPage: step.fullPage });
+            const out = path_1.default.resolve(caseDir, step.path ?? `step-${stepIndex + 1}-screenshot.png`);
+            (0, screenshot_1.saveScreenshotFile)(`data:image/png;base64,${buffer.toString('base64')}`, out);
+            return;
+        }
+        case 'assert': {
+            const names = [...Object.keys(step.globals ?? {}), ...(step.absent ?? [])];
+            const assertionContext = {
+                vars,
+                state: await readState(page),
+                globals: await readGlobals(page, names),
+            };
+            const error = (0, assertions_1.evaluateAssertion)(step, assertionContext);
+            if (error)
+                throw new Error(error);
+            return;
+        }
+    }
+}
+//# sourceMappingURL=runner.js.map