@cspeach/cli 1.1.18 → 1.1.19

package/dist/tools/fiori/smoke/run-smoke.js

@@ -24,6 +24,34 @@ import * as path from 'node:path';
 import { resolveBrowserExecutable } from './browser.js';
 import { openApp as realOpenApp } from './driver.js';
 import { checkBoot, checkOData, checkColumns, checkRows, checkExercise, } from './assertions.js';
+import { deriveExpectedColumns } from './audit-columns.js';
+import { checkLabels, judgeRawCodes, readRowTruths } from './labels-codes.js';
+import { pairBatch } from './batch.js';
+import { writeEvidence, auditSummary, SMOKE_VIEWPORT } from './evidence.js';
+import { classifyNavError, NAV_TIMEOUT_MS, REFUSED_ATTEMPTS, REFUSED_BACKOFF_MS } from './nav-error.js';
+/**
+ * L1-5a: the inner requests of every recorded `$batch`. A body that cannot be
+ * read is itself a failure (status 0), never dropped.
+ */
+export async function innerBatchParts(page) {
+    if (!page.batchExchanges)
+        return [];
+    const out = [];
+    for (const ex of await page.batchExchanges()) {
+        try {
+            out.push(...pairBatch(ex));
+        }
+        catch (err) {
+            out.push({
+                method: '$batch',
+                url: '',
+                status: 0,
+                errorMessage: `could not read a $batch body (${err instanceof Error ? err.message : String(err)})`,
+            });
+        }
+    }
+    return out;
+}
 /**
  * UI5 selectors used by the driver-side collection. ONE exported const so Track
  * 3 can extend it (add chart/form control selectors) without hunting through
@@ -32,8 +60,16 @@ import { checkBoot, checkOData, checkColumns, checkRows, checkExercise, } from '
 export const SMOKE_SELECTORS = {
     /** Responsive-table + grid-table column headers. */
     tableHeaders: '.sapMColumnHeader, [role="columnheader"]',
-    /** Responsive-table + grid-table data rows. */
-    tableRows: '.sapMListTbl tr.sapMListTblRow, .sapUiTableRow',
+    /**
+     * DATA rows only (L1-2b F-3): a responsive-table list item that is neither
+     * the header row nor the "no data" line, or a grid-table content row that is
+     * not a hidden filler row. The old selector counted the header and the
+     * "To start, set the relevant filters and choose Go" line as 2 rows.
+     */
+    tableRows: '.sapMListTbl tr.sapMListTblRow:not(.sapMListTblHeader):not([id$="-nodata"]), ' +
+        'table.sapUiTableCtrlScroll tr.sapUiTableContentRow:not(.sapUiTableRowHidden)',
+    /** The table has finished loading and is empty (responsive no-data line / empty grid). */
+    emptyList: '.sapMListTbl tr[id$="-nodata"], .sapUiTableEmpty',
     /** Overview-page cards. */
     ovpCards: '.sapOvpCard',
     /** Freestyle chart control (sap.viz VizFrame) — Track 3 chart controlKind. */
@@ -89,8 +125,10 @@ function isRowsControl(kind) {
  */
 async function runExercises(page, exercises) {
     const results = [];
+    const pageErrors = () => (page.pageErrors ? page.pageErrors() : []);
     for (const ex of exercises) {
         const before = page.consoleErrors().length;
+        const beforePage = pageErrors().length;
         const label = ex.kind === 'press' ? ex.selectorHint : ex.name;
         let threw;
         try {
@@ -109,7 +147,8 @@ async function runExercises(page, exercises) {
             threw = err instanceof Error ? err.message : String(err);
         }
         const newConsoleErrors = page.consoleErrors().slice(before);
-        results.push({ kind: ex.kind, label, threw, newConsoleErrors });
+        const newPageErrors = pageErrors().slice(beforePage);
+        results.push({ kind: ex.kind, label, threw, newConsoleErrors, newPageErrors });
     }
     return results;
 }
@@ -125,18 +164,49 @@ export async function runSmoke(spec, deps) {
     const resolveBrowser = deps.resolveBrowser ?? (() => resolveBrowserExecutable());
     const open = deps.openApp ?? realOpenApp;
     const timeoutMs = deps.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+    const startedAt = new Date();
+    const t0 = Date.now();
     // Skip path 2 — no browser.
     const browser = resolveBrowser();
     if (!browser) {
         return skipped('no Chromium-based browser found (set CSPEACH_BROWSER to an Edge/Chrome executable); no app was rendered');
     }
-    // Skip path 3 — preview server unreachable (openApp throws on nav failure).
+    // Skip path 3 — the first navigation failed. L1-7: classified, never
+    // swallowed. Refused → the preview may still be starting: retry, then skip.
+    // Timeout → the app did not settle: a real `boot` FAILURE, never retried.
+    // Certificate → skip with the trust hint. Anything else → skip, named.
+    const sleep = deps.sleep ?? ((ms) => new Promise((r) => setTimeout(r, ms)));
     let page;
-    try {
-        page = await open(browser.path, spec.appUrl, timeoutMs);
-    }
-    catch {
-        return skipped(`preview server not reachable at ${spec.appUrl}; run npm run start first`);
+    for (let attempt = 1; !page; attempt++) {
+        try {
+            page = spec.capUser
+                ? await open(browser.path, spec.appUrl, timeoutMs, NAV_TIMEOUT_MS, { credentials: { username: spec.capUser, password: '' } })
+                : await open(browser.path, spec.appUrl, timeoutMs, NAV_TIMEOUT_MS);
+        }
+        catch (err) {
+            const nav = classifyNavError(err);
+            if (nav.kind === 'refused') {
+                if (attempt < REFUSED_ATTEMPTS) {
+                    await sleep(REFUSED_BACKOFF_MS);
+                    continue;
+                }
+                return skipped(`preview server not reachable at ${spec.appUrl}; run npm run start first`);
+            }
+            if (nav.kind === 'timeout') {
+                const shot = err.screenshotPath;
+                return {
+                    verification: 'smoke',
+                    passed: false,
+                    checks: [{ name: 'boot', ok: false, detail: `page did not settle in ${NAV_TIMEOUT_MS / 1000} s` }],
+                    ...(typeof shot === 'string' ? { screenshots: { failure: shot } } : {}),
+                };
+            }
+            if (nav.kind === 'cert') {
+                return skipped(`the browser does not trust the certificate at ${spec.appUrl} (${nav.message}); ` +
+                    'trust the SAP system certificate — run cspeach doctor for the steps');
+            }
+            return skipped(`could not open ${spec.appUrl}: ${nav.message}`);
+        }
     }
     // F-L2-10A evidence capture. The dir is created LAZILY on the first successful
     // capture, so a skip path (or a driver with no screenshot capability) writes
@@ -163,6 +233,10 @@ export async function runSmoke(spec, deps) {
     };
     // Hoisted so the finally block can decide whether a failure shot is owed.
     const checks = [];
+    // L1-8b: set once a real verdict exists — the finally block writes its evidence.
+    let result;
+    let batch = [];
+    const navMs = Date.now() - t0;
     try {
         // Skip path 4 — SAP logon page (deployed BSP / unauthenticated preview).
         // Detect via a logon-redirect URL OR the presence of a logon-form field, and
@@ -172,12 +246,37 @@ export async function runSmoke(spec, deps) {
         if (LOGON_URL.test(url) || logonHits.length > 0) {
             return skipped(`preview served a SAP logon page (not authenticated) at ${url}; run npm run start first`);
         }
+        // L1-2b F-2/F-3: a table is judged only once it has finished loading —
+        // data rows, or the empty-list marker. Navigation "settling" is not enough:
+        // UI5 loads the list after networkidle. A timeout falls through; the rows
+        // and odata checks then fail on what is (not) there.
+        if (isRowsControl(spec.controlKind) || spec.metadataAudit) {
+            try {
+                await page.waitForSelector(`${SMOKE_SELECTORS.tableRows}, ${SMOKE_SELECTORS.emptyList}`);
+            }
+            catch {
+                // judged below on what rendered
+            }
+        }
         // The app is open past the logon check — this is the boot evidence shot.
         await capture('boot', 'boot.png');
         // Real render — assert content. boot + odata always; columns only when the
         // spec asked for them; rows only for a rows-bearing (table) control.
-        checks.push(checkBoot(page.consoleErrors()));
-        checks.push(checkOData(page.failedRequests()));
+        // Dry run 2026-09-25: an "&amp;" in the header passed every check — boot
+        // also reads the visible text. A page that can't answer is judged as before.
+        let visibleText;
+        if (page.evalInPage) {
+            try {
+                const text = await page.evalInPage('function () { return document.body ? document.body.innerText : ""; }', null);
+                visibleText = typeof text === 'string' ? text : undefined;
+            }
+            catch {
+                visibleText = undefined;
+            }
+        }
+        checks.push(checkBoot(page.consoleErrors(), page.failedRequests(), visibleText));
+        batch = await innerBatchParts(page);
+        checks.push(checkOData(page.failedRequests(), page.observedRequests ? page.observedRequests() : [], batch, page.unansweredRequests ? page.unansweredRequests() : []));
         if (spec.expectedColumns && spec.expectedColumns.length > 0) {
             const headers = await page.queryTexts(SMOKE_SELECTORS.tableHeaders);
             checks.push(checkColumns(headers, spec.expectedColumns));
@@ -186,6 +285,28 @@ export async function runSmoke(spec, deps) {
             const rows = await page.queryTexts(SMOKE_SELECTORS.tableRows);
             checks.push(checkRows(rows.length, spec.allowEmptyRows === true));
         }
+        // L1-3: labels + no-raw-codes, judged against the audit (machine truth).
+        // Runs before the exercises, which may navigate away from the list.
+        if (spec.metadataAudit) {
+            const audit = spec.metadataAudit;
+            const expected = deriveExpectedColumns(audit);
+            let snapshot;
+            try {
+                snapshot = page.cellTextsByColumn ? await page.cellTextsByColumn(audit.entitySet) : undefined;
+            }
+            catch {
+                snapshot = undefined; // judged as "could not read the table" — a failure
+            }
+            checks.push(checkLabels(snapshot, expected, audit));
+            let truths;
+            try {
+                truths = snapshot ? await readRowTruths(page, audit, expected, snapshot) : undefined;
+            }
+            catch {
+                truths = undefined;
+            }
+            checks.push(judgeRawCodes(audit, expected, snapshot, truths));
+        }
         // Track 3 (dynamic A4): run each declared exercise through the SAME page
         // abstraction, diffing the driver's console-error collection around each
         // interaction. A press that throws or an exercise that emits a new console
@@ -200,17 +321,39 @@ export async function runSmoke(spec, deps) {
         // `screenshots` is the SAME object the finally block may still add the
         // failure entry to, so a failing run carries it even though the value is
         // built here. It rides along only when the driver can shoot at all.
-        return {
+        result = {
             verification: 'smoke',
             passed: checks.every((c) => c.ok),
             checks,
             ...(canShoot ? { screenshots } : {}),
         };
+        return result;
     }
     finally {
         // A failing check earns a failure shot — captured BEFORE the page is closed.
         if (checks.some((c) => !c.ok))
             await capture('failure', 'failure.png');
         await page.close();
+        // L1-8b evidence pack — only for a real verdict (never on a skip path).
+        // `result` is the object the caller receives, so the path rides along.
+        if (result) {
+            const dir = shotDir ?? deps.artifactDir ?? path.join(os.homedir(), '.cspeach', 'smoke', `${appNameFromUrl(spec.appUrl)}-${runStamp()}`);
+            const file = writeEvidence(dir, {
+                tool: 'fiori_render_smoke',
+                appUrl: spec.appUrl,
+                startedAt: startedAt.toISOString(),
+                finishedAt: new Date().toISOString(),
+                viewport: SMOKE_VIEWPORT,
+                verification: result.verification,
+                passed: result.passed,
+                checks: result.checks,
+                audit: auditSummary(spec.metadataAudit),
+                batch,
+                screenshots: result.screenshots ?? {},
+                timings: { navigateMs: navMs, totalMs: Date.now() - t0 },
+            });
+            if (file)
+                result.evidence = file;
+        }
     }
 }