cssprobe-cli 0.3.1 → 0.4.0

package/dist/scenario/assertions.js

@@ -0,0 +1,111 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolvePath = resolvePath;
+exports.evaluateAssertion = evaluateAssertion;
+function resolvePath(value, path) {
+    if (!path)
+        return value;
+    let current = value;
+    for (const part of path.split('.')) {
+        if (current === null || current === undefined)
+            return undefined;
+        current = current[part];
+    }
+    return current;
+}
+function deepEqual(a, b) {
+    if (a === b)
+        return true;
+    if (typeof a !== typeof b)
+        return false;
+    if (a === null || b === null)
+        return false;
+    if (Array.isArray(a) || Array.isArray(b)) {
+        if (!Array.isArray(a) || !Array.isArray(b) || a.length !== b.length)
+            return false;
+        return a.every((item, index) => deepEqual(item, b[index]));
+    }
+    if (typeof a === 'object' && typeof b === 'object') {
+        const aKeys = Object.keys(a).sort();
+        const bKeys = Object.keys(b).sort();
+        if (aKeys.length !== bKeys.length || aKeys.some((key, index) => key !== bKeys[index]))
+            return false;
+        return aKeys.every(key => deepEqual(a[key], b[key]));
+    }
+    return false;
+}
+function label(assertion) {
+    return assertion.label ?? 'assert';
+}
+function evaluateAssertion(assertion, context) {
+    const errors = [];
+    if (assertion.url) {
+        let regex;
+        try {
+            regex = new RegExp(assertion.url);
+        }
+        catch {
+            return `${label(assertion)}: invalid url pattern ${assertion.url}`;
+        }
+        if (!regex.test(context.state.url)) {
+            errors.push(`url ${JSON.stringify(context.state.url)} does not match ${assertion.url}`);
+        }
+    }
+    for (const [name, expected] of Object.entries(assertion.globals ?? {})) {
+        const actual = context.globals[name] ?? 'undefined';
+        if (actual !== expected) {
+            errors.push(`global ${name}: expected ${expected}, received ${actual}`);
+        }
+    }
+    for (const name of assertion.absent ?? []) {
+        const actual = context.globals[name] ?? 'undefined';
+        if (actual !== 'undefined') {
+            errors.push(`global ${name}: expected absent, received ${actual}`);
+        }
+    }
+    const hasValueCheck = ['eq', 'ne', 'match', 'within', 'min', 'max'].some(key => key in assertion);
+    if (!hasValueCheck) {
+        return errors.length ? `${label(assertion)}: ${errors.join('; ')}` : null;
+    }
+    let value;
+    if (assertion.on) {
+        if (assertion.on === 'state') {
+            value = context.state;
+        }
+        else if (assertion.on in context.vars) {
+            value = context.vars[assertion.on];
+        }
+        else {
+            return `${label(assertion)}: unknown variable "${assertion.on}"`;
+        }
+    }
+    else {
+        value = context.state;
+    }
+    value = resolvePath(value, assertion.path);
+    if ('eq' in assertion && !deepEqual(value, assertion.eq)) {
+        errors.push(`expected ${JSON.stringify(assertion.eq)}, received ${JSON.stringify(value)}`);
+    }
+    if ('ne' in assertion && deepEqual(value, assertion.ne)) {
+        errors.push(`expected value different from ${JSON.stringify(assertion.ne)}`);
+    }
+    if (assertion.match !== undefined) {
+        const actual = typeof value === 'string' ? value : JSON.stringify(value);
+        if (!new RegExp(assertion.match).test(actual)) {
+            errors.push(`expected ${JSON.stringify(actual)} to match ${assertion.match}`);
+        }
+    }
+    if (assertion.within) {
+        if (typeof value !== 'number' || Math.abs(value - assertion.within.expected) > assertion.within.tolerance) {
+            errors.push(`expected ${assertion.within.expected} ±${assertion.within.tolerance}, received ${JSON.stringify(value)}`);
+        }
+    }
+    if (assertion.min !== undefined && (typeof value !== 'number' || value < assertion.min)) {
+        errors.push(`expected >= ${assertion.min}, received ${JSON.stringify(value)}`);
+    }
+    if (assertion.max !== undefined && (typeof value !== 'number' || value > assertion.max)) {
+        errors.push(`expected <= ${assertion.max}, received ${JSON.stringify(value)}`);
+    }
+    return errors.length ? `${label(assertion)}: ${errors.join('; ')}` : null;
+}
+//# sourceMappingURL=assertions.js.map

package/dist/scenario/reporters.d.ts

@@ -0,0 +1,13 @@
+import type { CaseResult } from './schema';
+export declare function slugify(value: string): string;
+export interface ScenarioSummary {
+    total: number;
+    passed: number;
+    failed: number;
+    durationMs: number;
+    ok: boolean;
+}
+export declare function summarize(results: CaseResult[]): ScenarioSummary;
+export declare function formatConsole(suiteName: string, results: CaseResult[]): string;
+export declare function escapeXml(value: string): string;
+export declare function toJunit(suiteName: string, results: CaseResult[]): string;

package/dist/scenario/reporters.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.slugify = slugify;
+exports.summarize = summarize;
+exports.formatConsole = formatConsole;
+exports.escapeXml = escapeXml;
+exports.toJunit = toJunit;
+function slugify(value) {
+    return value
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, '-')
+        .replace(/^-+|-+$/g, '')
+        .slice(0, 60) || 'case';
+}
+function summarize(results) {
+    const passed = results.filter(result => result.ok).length;
+    const durationMs = results.reduce((total, result) => total + result.durationMs, 0);
+    return {
+        total: results.length,
+        passed,
+        failed: results.length - passed,
+        durationMs,
+        ok: passed === results.length,
+    };
+}
+function formatConsole(suiteName, results) {
+    const summary = summarize(results);
+    const lines = [];
+    for (const result of results) {
+        const marker = result.ok ? 'PASS' : result.skipped ? 'SKIP' : 'FAIL';
+        lines.push(`${marker} ${result.name} (${result.durationMs}ms)`);
+        if (result.error)
+            lines.push(`  ${result.error}`);
+        for (const step of result.steps) {
+            if (!step.ok)
+                lines.push(`  step ${step.index + 1} (${step.action}): ${step.error}`);
+        }
+        if (result.artifactsDir)
+            lines.push(`  artifacts: ${result.artifactsDir}`);
+    }
+    lines.push('');
+    lines.push(`${suiteName}: ${summary.passed}/${summary.total} passed, ${summary.failed} failed in ${summary.durationMs}ms`);
+    return lines.join('\n');
+}
+function escapeXml(value) {
+    return value
+        .replace(/&/g, '&')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;')
+        .replace(/"/g, '&quot;')
+        .replace(/'/g, '&apos;');
+}
+function toJunit(suiteName, results) {
+    const summary = summarize(results);
+    const cases = results
+        .map(result => {
+        const time = (result.durationMs / 1000).toFixed(3);
+        const failureDetails = [
+            result.error,
+            ...result.steps.filter(step => !step.ok).map(step => `step ${step.index + 1} (${step.action}): ${step.error}`),
+        ]
+            .filter(Boolean)
+            .join('\n');
+        const body = result.ok
+            ? ''
+            : `<failure message="${escapeXml(result.error ?? 'scenario case failed')}">${escapeXml(failureDetails)}</failure>`;
+        return `    <testcase classname="${escapeXml(suiteName)}" name="${escapeXml(result.name)}" time="${time}">${body}</testcase>`;
+    })
+        .join('\n');
+    return [
+        '<?xml version="1.0" encoding="UTF-8"?>',
+        `<testsuites tests="${summary.total}" failures="${summary.failed}" time="${(summary.durationMs / 1000).toFixed(3)}">`,
+        `  <testsuite name="${escapeXml(suiteName)}" tests="${summary.total}" failures="${summary.failed}" time="${(summary.durationMs / 1000).toFixed(3)}">`,
+        cases,
+        '  </testsuite>',
+        '</testsuites>',
+    ].join('\n');
+}
+//# sourceMappingURL=reporters.js.map

package/dist/scenario/runner.d.ts

@@ -0,0 +1,10 @@
+import { type ScenarioSummary } from './reporters';
+import type { CaseResult, ScenarioRunOptions, Suite } from './schema';
+export interface ScenarioRunResult {
+    suite: string;
+    ok: boolean;
+    summary: ScenarioSummary;
+    results: CaseResult[];
+    artifactsDir: string;
+}
+export declare function runScenario(suite: Suite, suitePath: string, options?: ScenarioRunOptions): Promise<ScenarioRunResult>;

package/dist/scenario/runner.js

@@ -0,0 +1,244 @@
+"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;
+            if (step.networkIdle) {
+                await (0, interactions_1.waitForCondition)(page, { kind: 'networkIdle' }, timeout);
+            }
+            else if (step.js) {
+                await (0, interactions_1.waitForCondition)(page, { kind: 'js', expression: step.js }, timeout);
+            }
+            else if (step.selector) {
+                await (0, interactions_1.waitForCondition)(page, { kind: 'selector', selector: step.selector, state: step.state ?? 'visible' }, timeout);
+            }
+            else {
+                throw new Error('waitFor requires selector, js, or networkIdle');
+            }
+            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