@cspeach/cli 1.1.17 → 1.1.19

package/dist/tools/fiori/smoke/driver.js

@@ -15,7 +15,10 @@
 // leg" trap). This driver deliberately stays neutral: it exposes failedRequests()
 // + consoleErrors() precisely so Task 9 can detect the logon-page / unreachable
 // cases from the collected signals. Do not add any deployed-URL assumption here.
-import puppeteer from 'puppeteer-core';
+import * as os from 'node:os';
+import * as path from 'node:path';
+/** L1-5a: a `$batch` URL (the only kind whose bodies the driver records). */
+export const BATCH_URL = /\/\$batch(\?|$)/;
 /**
  * Launch a headless browser at `executablePath`, navigate to `url`, and return a
  * SmokePage that has already begun collecting failed requests + console errors.
@@ -24,33 +27,197 @@ import puppeteer from 'puppeteer-core';
  * calls. Never called from unit tests (no real browser in CI) — exercised only
  * on the live leg (VPN, local authenticated preview up).
  */
-export async function openApp(executablePath, url, timeoutMs) {
-    const browser = await puppeteer.launch({ executablePath, headless: true });
+/**
+ * L1-3 in-page script for `cellTextsByColumn`: find the sap.m.Table /
+ * sap.ui.table.Table whose rows are bound to `/<entitySet>` through UI5's
+ * Element registry, then read headers, row paths and cell texts.
+ */
+export const TABLE_SNAPSHOT_SRC = String.raw `async function (entitySet) {
+  var Element = (sap.ui.require && sap.ui.require('sap/ui/core/Element')) || (sap.ui.core && sap.ui.core.Element);
+  if (!Element || !Element.registry) return null;
+  var all = Element.registry.all();
+  var table = null;
+  for (var id in all) {
+    var c = all[id];
+    if (!c || !c.isA) continue;
+    var isM = c.isA('sap.m.Table');
+    var isGrid = c.isA('sap.ui.table.Table');
+    if (!isM && !isGrid) continue;
+    var b = c.getBinding(isM ? 'items' : 'rows');
+    var bp = b && b.getPath ? String(b.getPath()) : '';
+    if (bp.replace(/^\//, '') === entitySet) { table = c; break; }
+  }
+  if (!table) return null;
+  var isMTable = table.isA('sap.m.Table');
+  function shown(ctrl) {
+    var d = ctrl && ctrl.getDomRef ? ctrl.getDomRef() : null;
+    return d ? String(d.innerText || d.textContent || '').replace(/\s+/g, ' ').trim() : '';
+  }
+  function headerText(col) {
+    var h = isMTable ? col.getHeader() : (col.getLabel ? col.getLabel() : null);
+    if (h && h.getText) { var t = h.getText(); if (t) return String(t); }
+    if (h && h.getLabel) { var l = h.getLabel(); if (l && l.getText) return String(l.getText()); }
+    return shown(h);
+  }
+  var allCols = table.getColumns();
+  var visibleIdx = [];
+  for (var i = 0; i < allCols.length; i++) if (allCols[i].getVisible()) visibleIdx.push(i);
+  var columns = visibleIdx.map(function (i) { return headerText(allCols[i]); });
+  var rows = [];
+  var items = isMTable ? table.getItems() : table.getRows();
+  for (var r = 0; r < items.length; r++) {
+    var item = items[r];
+    var ctx = item.getBindingContext();
+    if (!ctx) continue;
+    var cells = item.getCells();
+    var texts;
+    if (isMTable) {
+      texts = visibleIdx.map(function (i) { return shown(cells[i]); });
+    } else {
+      texts = cells.map(function (c) { return shown(c); });
+    }
+    rows.push({ path: String(ctx.getPath()), cells: texts });
+  }
+  return { columns: columns, rows: rows };
+}`;
+/**
+ * CAP phase 1 (F4): a 3xx is a redirect, not an answer — only the final response
+ * of a $batch carries a body to judge (SAP's CAP sample posts to a relative URL
+ * and gets a 308; an approuter can redirect too).
+ */
+export function isBatchCapturable(status) {
+    return status < 300 || status >= 400;
+}
+/**
+ * The browser reports a request re-sent after a redirect WITHOUT its
+ * content-type header although the body is there; take it from the original
+ * request in the redirect chain.
+ */
+export function effectiveRequestContentType(own, chain) {
+    return own || chain.find((c) => c) || '';
+}
+/** In-page: expand every collapsed sap.f.DynamicPage header; returns how many. */
+const EXPAND_HEADERS_SRC = `(() => {
+  const reg = window.sap?.ui?.core?.Element?.registry;
+  let n = 0;
+  if (reg?.filter) {
+    for (const dp of reg.filter((e) => e.isA && e.isA('sap.f.DynamicPage'))) {
+      if (dp.getHeaderExpanded && dp.getHeaderExpanded() === false) { dp.setHeaderExpanded(true); n++; }
+    }
+  }
+  return n;
+})()`;
+export async function openApp(executablePath, url, timeoutMs, navTimeoutMs = timeoutMs, 
+/** L1-8b: a visible, slowed-down browser for recording a run on camera. */
+launch = {}) {
+    // Loaded on use (fix round 3, item 11e) — not on every CLI start.
+    const { default: puppeteer } = await import('puppeteer-core');
+    const browser = await puppeteer.launch({
+        executablePath,
+        headless: launch.headless ?? true,
+        slowMo: launch.slowMo ?? 0,
+    });
     const failed = [];
+    const observed = [];
     const consoleErrs = [];
+    const pageErrs = [];
+    // CAP phase 1: requests still waiting — a login challenge holds them with no response event.
+    const inFlight = new Map();
+    // L1-5a: bodies of `$batch` exchanges only — read asynchronously, awaited by batchExchanges().
+    const batches = [];
     try {
         const page = await browser.newPage();
+        // A desktop-sized viewport (L1-2b; planned for L1-3). At puppeteer's default
+        // 800×600 a responsive table pops lower-importance columns into a sub-row, so
+        // their headers are not rendered and `columns` failed a correct app.
+        await page.setViewport({ width: 1600, height: 1000 });
+        // CAP path: the development login (mocked basic auth) for the proven local server.
+        if (launch.credentials)
+            await page.authenticate(launch.credentials);
         // Collect BEFORE navigating so the initial document + its OData calls are seen.
+        page.on('request', (req) => {
+            inFlight.set(req, req.url());
+        });
+        page.on('requestfinished', (req) => inFlight.delete(req));
+        page.on('requestfailed', (req) => inFlight.delete(req));
         page.on('response', (resp) => {
+            inFlight.delete(resp.request());
+            // L1-5b: fiori_draft_smoke's own in-page API calls (X-CSP-Smoke) are
+            // judged by the step that made them, not as the app's traffic.
+            if (resp.request().headers()['x-csp-smoke'] === '1')
+                return;
             const status = resp.status();
+            observed.push({ url: resp.url(), status });
             if (status >= 400)
                 failed.push({ url: resp.url(), status });
+            if (BATCH_URL.test(resp.url()) && isBatchCapturable(status)) {
+                const req = resp.request();
+                batches.push((async () => {
+                    try {
+                        const requestBody = req.postData() ?? (req.hasPostData() ? await req.fetchPostData() : '') ?? '';
+                        return {
+                            requestContentType: effectiveRequestContentType(req.headers()['content-type'] ?? '', req.redirectChain().map((r) => r.headers()['content-type'] ?? '')),
+                            requestBody,
+                            status,
+                            responseContentType: resp.headers()['content-type'] ?? '',
+                            responseBody: await resp.text(),
+                        };
+                    }
+                    catch {
+                        return undefined; // body gone (page navigated) — nothing to judge for this one
+                    }
+                })());
+            }
+        });
+        page.on('pageerror', (err) => {
+            pageErrs.push(err instanceof Error ? err.message : String(err));
         });
         page.on('console', (msg) => {
             if (msg.type() === 'error')
                 consoleErrs.push(msg.text());
         });
-        await page.goto(url, { waitUntil: 'networkidle2', timeout: timeoutMs });
+        try {
+            await page.goto(url, { waitUntil: 'networkidle2', timeout: navTimeoutMs });
+        }
+        catch (navErr) {
+            // L1-7: a page that did not settle is a boot FAILURE — keep a picture of
+            // what it showed before the browser closes (best-effort).
+            if (navErr instanceof Error && (navErr.name === 'TimeoutError' || /timeout/i.test(navErr.message))) {
+                try {
+                    const shot = path.join(os.tmpdir(), `cspeach-nav-timeout-${Date.now()}.png`);
+                    await page.screenshot({ path: shot });
+                    navErr.screenshotPath = shot;
+                }
+                catch {
+                    // no picture — the failure still stands
+                }
+            }
+            throw navErr;
+        }
         return {
             currentUrl: () => page.url(),
             waitForSelector: (selector) => page.waitForSelector(selector, { timeout: timeoutMs }),
             queryTexts: (selector) => page.$$eval(selector, (els) => els.map((el) => (el.textContent ?? '').trim())),
             failedRequests: () => [...failed],
             consoleErrors: () => [...consoleErrs],
+            observedRequests: () => [...observed],
+            unansweredRequests: () => [...inFlight.values()],
+            pageErrors: () => [...pageErrs],
+            batchExchanges: async () => (await Promise.all([...batches])).filter((b) => b !== undefined),
+            evalInPage: (functionSource, arg) => page.evaluate(`(${functionSource})(${JSON.stringify(arg)})`),
+            cellTextsByColumn: async (entitySet) => {
+                const r = await page.evaluate(`(${TABLE_SNAPSHOT_SRC})(${JSON.stringify(entitySet)})`);
+                return (r ?? undefined);
+            },
             // Track 3 exercises (live leg only — never unit-tested; the suite injects
             // fakes). `selectorHint` is a REAL DOM selector derived from the control id
             // (`[id$="--<id>"]`), so a plain click drives the press handler.
             press: async (selectorHint) => {
+                // UI5 1.84 collapses the list report's header after an on-open load,
+                // hiding the filter bar (Go). Expand it first, as a user would.
+                const expanded = await page.evaluate(EXPAND_HEADERS_SRC).catch(() => 0);
+                if (expanded)
+                    await page.waitForNetworkIdle({ idleTime: 300, timeout: timeoutMs }).catch(() => { });
                 await page.click(selectorHint, { delay: 0 });
                 await page.waitForNetworkIdle({ idleTime: 200, timeout: timeoutMs }).catch(() => { });
             },

package/dist/tools/fiori/smoke/evidence.js

@@ -0,0 +1,35 @@
+/**
+ * L1-8b (review F-17) — the evidence pack. Every real smoke run writes
+ * `evidence.json` beside its screenshots: what was checked, what the service
+ * audit said, the inner $batch log and how long each part took. LOCAL files
+ * only (under ~/.cspeach/smoke/… by default) — never sent anywhere.
+ */
+import { mkdirSync, writeFileSync } from 'node:fs';
+import * as path from 'node:path';
+/** The viewport every smoke renders at (driver.ts sets it). */
+export const SMOKE_VIEWPORT = { width: 1600, height: 1000 };
+/** A compact, stable summary of the audit — enough to see what was judged. */
+export function auditSummary(audit) {
+    if (!audit)
+        return undefined;
+    return {
+        servicePath: audit.servicePath,
+        entitySet: audit.entitySet,
+        entityType: audit.entityType,
+        properties: audit.properties.length,
+        lineItemColumns: audit.lineItem.length,
+        flags: audit.flags,
+    };
+}
+/** Write `evidence.json` into `dir`; returns its path, or undefined if the write failed. */
+export function writeEvidence(dir, data) {
+    try {
+        mkdirSync(dir, { recursive: true });
+        const file = path.join(dir, 'evidence.json');
+        writeFileSync(file, JSON.stringify(data, null, 2) + '\n', 'utf8');
+        return file;
+    }
+    catch {
+        return undefined; // evidence is best-effort — it never fails the smoke
+    }
+}

package/dist/tools/fiori/smoke/labels-codes.js

@@ -0,0 +1,207 @@
+import { normaliseHeader } from './assertions.js';
+/** At most this many rows are compared (plan: "the first 20 rows"). */
+export const MAX_CODE_ROWS = 20;
+// ─────────────────────────────── labels ───────────────────────────────
+export function checkLabels(snapshot, expected, audit) {
+    if (!snapshot) {
+        return {
+            name: 'labels',
+            ok: false,
+            detail: `could not read the list table for /${audit.entitySet} — no labels were checked`,
+        };
+    }
+    const rendered = new Set(snapshot.columns.map(normaliseHeader));
+    const unlabelled = expected.filter((c) => !c.label).map((c) => c.property);
+    const missing = expected.filter((c) => c.label && !rendered.has(normaliseHeader(c.label))).map((c) => c.label);
+    // A header equal to a technical name counts only where that name is NOT also
+    // the property's own label ("Inspector" labelled "Inspector" is fine).
+    // A header equal to an expected COLUMN label is that label (CAP: LineItem
+    // label "Author" on property `author` whose own label is "Name").
+    const columnLabels = new Set(expected.filter((c) => c.label).map((c) => normaliseHeader(c.label)));
+    const technical = snapshot.columns.filter((h) => !columnLabels.has(normaliseHeader(h)) &&
+        audit.properties.some((p) => normaliseHeader(p.name) === normaliseHeader(h) && normaliseHeader(p.label ?? '') !== normaliseHeader(p.name)));
+    // UI5 1.84 renders an unlabelled column with an EMPTY header (1.120 shows the
+    // technical name instead) — both are a missing label the user can see.
+    const empty = snapshot.columns.filter((h) => normaliseHeader(h) === '').length;
+    const ok = unlabelled.length === 0 && missing.length === 0 && technical.length === 0 && empty === 0;
+    const parts = [];
+    if (unlabelled.length)
+        parts.push(`no label for: ${unlabelled.join(', ')}`);
+    if (missing.length)
+        parts.push(`label not rendered: ${missing.join(', ')}`);
+    if (technical.length)
+        parts.push(`technical name shown as a header: ${technical.join(', ')}`);
+    if (empty)
+        parts.push(`${empty} column header(s) are empty`);
+    return {
+        name: 'labels',
+        ok,
+        detail: ok
+            ? `all ${expected.length} column(s) rendered under their labels`
+            : `${parts.join('; ')} (rendered: ${snapshot.columns.join(', ') || 'none'})`,
+    };
+}
+// ──────────────────────────── no-raw-codes ────────────────────────────
+/**
+ * Does `cell` show `code` as a value of its own? The text is taken out first,
+ * then the rest is split into word tokens: TextFirst "Open (O)" leaves "(O)" →
+ * shows the code; "Open Order" does not (the O is inside a word).
+ */
+export function cellShowsCode(cell, code, text) {
+    const rest = text ? cell.replace(text, ' ') : cell;
+    if (/^[\p{L}\p{N}]+$/u.test(code)) {
+        return rest.split(/[^\p{L}\p{N}]+/u).includes(code);
+    }
+    return rest.includes(code);
+}
+/** Coded properties that the list shows, with the column they sit in. */
+function codedColumns(audit, expected) {
+    const byName = new Map(audit.properties.map((p) => [p.name, p]));
+    return expected
+        .map((c) => ({ col: c, prop: byName.get(c.property) }))
+        .filter((x) => x.prop?.coded);
+}
+export function judgeRawCodes(audit, expected, snapshot, truths) {
+    const coded = codedColumns(audit, expected);
+    if (coded.length === 0) {
+        return { name: 'no-raw-codes', ok: true, detail: 'no coded column in the list — nothing to check' };
+    }
+    if (!snapshot) {
+        return {
+            name: 'no-raw-codes',
+            ok: false,
+            detail: `could not read the list table for /${audit.entitySet}; coded column(s) unchecked: ${coded.map((c) => c.col.property).join(', ')}`,
+        };
+    }
+    const rows = snapshot.rows.slice(0, MAX_CODE_ROWS);
+    const headers = snapshot.columns.map(normaliseHeader);
+    const failures = [];
+    let checked = 0;
+    for (const { col, prop } of coded) {
+        if (!prop.text) {
+            failures.push(`${col.property} is coded but has no text (Common.Text) — its cells can only show raw codes`);
+            continue;
+        }
+        const idx = col.label ? headers.indexOf(normaliseHeader(col.label)) : -1;
+        if (idx < 0) {
+            failures.push(`${col.property}: its column "${col.label ?? col.property}" is not rendered`);
+            continue;
+        }
+        const perRow = truths?.get(col.property);
+        for (const row of rows) {
+            const truth = perRow?.get(row.path);
+            if (!truth) {
+                failures.push(`${col.property} ${row.path}: the backend value could not be read`);
+                continue;
+            }
+            if (truth.code === null || truth.code === '')
+                continue; // nothing to display
+            const cell = (row.cells[idx] ?? '').trim();
+            checked++;
+            if (!truth.text) {
+                failures.push(`${col.property} ${row.path}: code "${truth.code}" has no text`);
+            }
+            else if (!cell.includes(truth.text)) {
+                failures.push(`${col.property} ${row.path}: cell "${cell}" does not show the text "${truth.text}"`);
+            }
+            else if (cellShowsCode(cell, truth.code, truth.text)) {
+                failures.push(`${col.property} ${row.path}: cell "${cell}" shows the raw code "${truth.code}"`);
+            }
+        }
+    }
+    const ok = failures.length === 0;
+    return {
+        name: 'no-raw-codes',
+        ok,
+        detail: ok
+            ? `${coded.length} coded column(s), ${rows.length} row(s): text shown, no raw code (${checked} cell(s) compared)`
+            : failures.slice(0, 6).join('; ') + (failures.length > 6 ? `; … ${failures.length - 6} more` : ''),
+    };
+}
+// ───────────────────────── reading the backend ─────────────────────────
+/** `/…/0001/$metadata` → `/…/0001/`. */
+export function serviceRootOf(servicePath) {
+    const root = servicePath.replace(/\$metadata(\?.*)?$/, '');
+    return root.endsWith('/') ? root : `${root}/`;
+}
+/** `$select`/`$expand` for the coded properties and their text paths (one nav level). */
+export function rowTruthQuery(items, language) {
+    const select = [];
+    const expand = new Map();
+    for (const { property, textPath } of items) {
+        if (!select.includes(property))
+            select.push(property);
+        const slash = textPath.indexOf('/');
+        if (slash < 0) {
+            if (!select.includes(textPath))
+                select.push(textPath);
+        }
+        else {
+            const nav = textPath.slice(0, slash);
+            const leaf = textPath.slice(slash + 1);
+            expand.set(nav, [...(expand.get(nav) ?? []), leaf]);
+        }
+    }
+    const parts = [`$select=${select.join(',')}`];
+    if (expand.size > 0) {
+        parts.push(`$expand=${[...expand].map(([nav, leaves]) => `${nav}($select=${leaves.join(',')})`).join(',')}`);
+    }
+    parts.push(`sap-language=${encodeURIComponent(language)}`);
+    return parts.join('&');
+}
+function valueAt(obj, path) {
+    let cur = obj;
+    for (const seg of path.split('/')) {
+        if (cur === null || typeof cur !== 'object')
+            return null;
+        cur = cur[seg];
+    }
+    return cur === null || cur === undefined ? null : String(cur);
+}
+/**
+ * In-page script (a function-expression SOURCE, not a closure — puppeteer
+ * serialises it, and a transpiled function can carry helpers the page lacks).
+ * Fetches each row path with the app's own session and returns the JSON bodies.
+ */
+const FETCH_ROWS_SRC = `async function (a) {
+  var out = {};
+  for (var i = 0; i < a.paths.length; i++) {
+    var p = a.paths[i];
+    try {
+      var r = await fetch(a.root + p.replace(/^\\//, '') + '?' + a.query, { headers: { Accept: 'application/json' }, credentials: 'same-origin' });
+      out[p] = r.ok ? await r.json() : null;
+    } catch (e) { out[p] = null; }
+  }
+  return out;
+}`;
+/**
+ * For every coded-with-text column the list shows, read the first
+ * MAX_CODE_ROWS rows' code + text from the backend, FROM INSIDE THE PAGE.
+ * Returns undefined when the page cannot evaluate (the judge then fails).
+ */
+export async function readRowTruths(page, audit, expected, snapshot) {
+    const items = codedColumns(audit, expected)
+        .filter((x) => x.prop.text)
+        .map((x) => ({ property: x.col.property, textPath: x.prop.text.path }));
+    if (items.length === 0)
+        return new Map();
+    if (!page.evalInPage)
+        return undefined;
+    const paths = snapshot.rows.slice(0, MAX_CODE_ROWS).map((r) => r.path).filter((p) => p.startsWith('/'));
+    const bodies = await page.evalInPage(FETCH_ROWS_SRC, {
+        root: serviceRootOf(audit.servicePath),
+        paths,
+        query: rowTruthQuery(items, audit.language || 'EN'),
+    });
+    const out = new Map();
+    for (const { property, textPath } of items) {
+        const perRow = new Map();
+        for (const p of paths) {
+            const body = bodies?.[p];
+            if (body && typeof body === 'object')
+                perRow.set(p, { code: valueAt(body, property), text: valueAt(body, textPath) });
+        }
+        out.set(property, perRow);
+    }
+    return out;
+}

package/dist/tools/fiori/smoke/nav-error.js

@@ -0,0 +1,26 @@
+/**
+ * L1-7 (review F-14) — classify a failed first navigation.
+ *
+ * Before, run-smoke swallowed every openApp error as "unreachable" and
+ * skipped: a timeout on a cold UI5 CDN load, a refused port and a certificate
+ * error all looked the same, and a skip is never a failure — the July flake.
+ * Only `refused` is worth retrying (the preview is still starting); a timeout
+ * means the app did not settle and is a real `boot` failure.
+ */
+/** First navigation: long enough for a cold UI5 CDN load. */
+export const NAV_TIMEOUT_MS = 90_000;
+/** Attempts for a refused connection, and the pause between them. */
+export const REFUSED_ATTEMPTS = 3;
+export const REFUSED_BACKOFF_MS = 2_000;
+export function classifyNavError(err) {
+    const message = err instanceof Error ? err.message : String(err);
+    const name = err instanceof Error ? err.name : '';
+    if (name === 'TimeoutError' || /navigation timeout|timeout of \d+ ?ms exceeded/i.test(message)) {
+        return { kind: 'timeout', message };
+    }
+    if (/ERR_CONNECTION_REFUSED|ECONNREFUSED/i.test(message))
+        return { kind: 'refused', message };
+    if (/ERR_CERT_|ERR_SSL_|CERT_|self[- ]signed|unable to verify/i.test(message))
+        return { kind: 'cert', message };
+    return { kind: 'other', message };
+}