@sun-asterisk/sungen 3.2.3 → 3.2.5

package/src/dashboard/types.ts

@@ -39,14 +39,20 @@ export interface AggregateSummary {
 }
 
 export interface ScreenSnapshot {
-  name: string;                        // "kudos" or "flow/checkout" — the screen DIRECTORY name
+  name: string;                        // "kudos", "flow/checkout", or "api/login" — the unit label
   isFlow: boolean;
+  /** Unit kind — screen | flow | api. Drives the dashboard's suite badge so API
+   *  suites read as API rather than being mislabelled "web". Optional so history
+   *  snapshots written before this field still parse (they render as screen). */
+  kind?: 'screen' | 'flow' | 'api';
+  platform?: 'web' | 'android' | 'ios' | 'mobile'; // 'mobile' = @platform:mobile screen (per-OS features below)
   featureName: string;                 // name of the primary (first) feature; kept for backwards compat
   featurePath?: string;                // entry-point path of the primary feature
   specLink?: string;                   // relative path to requirements/spec.md
   summary: ScreenSummaryStats;         // rollup across all features
   scenarios: ScenarioSnapshot[];       // flat list across all features (each carries its `featureBaseName`)
   features?: FeatureSnapshot[];        // present when a screen has 1+ .feature files; UI groups by this
+  executedPlatforms?: ('android' | 'ios')[]; // OSes that produced a result file this run (mobile only)
 }
 
 /**
@@ -67,7 +73,9 @@ export interface FeatureSnapshot {
   specLink?: string;                   // relative path to requirements/spec.md, when present
   summary: ScreenSummaryStats;         // BASE locale rollup — back-compat for non-locale consumers
   scenarios: ScenarioSnapshot[];       // BASE locale scenarios
-  locales?: LocaleSnapshot[];          // present when 2+ locales detected (base + at least one overlay)
+  locales?: LocaleSnapshot[];          // locale overlays WITHIN this entry (base + at least one overlay)
+  platform?: 'android' | 'ios';        // one OS run of a @platform:mobile feature (separate entry per OS)
+  executedPlatforms?: ('android' | 'ios')[]; // OSes that produced a result file this run (mobile only)
 }
 
 /**

package/src/exporters/api-testcase-formatter.ts

@@ -0,0 +1,325 @@
+/**
+ * Render an API test case's Steps / Expected-results cells for the delivery report.
+ *
+ * API scenarios carry no Given/When steps and assert against runtime response
+ * refs (`expect {{endpoint.status}} is 201`), so the generic row builder leaves
+ * the Steps cell empty and the Expected cell showing raw `{{…}}`. This module
+ * turns the scenario's `@api:<name>(args)` tag + the apis.yaml catalog into a
+ * human-readable request block (Method / API / Header / Body) and rewrites the
+ * assertions into "Status / Response" language.
+ *
+ * Deterministic — no AI, no network. Everything is sourced from the catalog +
+ * scenario tags + test-data, mirroring exactly what the generated request sends
+ * (see orchestrator/templates/specs-api.ts: catalog headers + a Content-Type
+ * implied by the body wire format; `:param` falls back to the same-named
+ * test-data key when the tag omits it).
+ */
+
+import { ApiCatalogEntry } from './types';
+
+/** A single `@api:<name>(k=v,…)` invocation parsed from a scenario's tags. */
+export interface ApiCall {
+  name: string;
+  /** param → value expression, kept raw: `{{new_email}}`, `"literal"`, `3`. */
+  args: Record<string, string>;
+}
+
+/** True when the scenario invokes at least one `@api:` endpoint. */
+export function hasApiCalls(tags: string[]): boolean {
+  return tags.some((t) => t.startsWith('@api:'));
+}
+
+/**
+ * Parse the ordered `@api:<name>(arg=expr,…)` invocations from a scenario's tags.
+ * Mirrors the driver's override grammar: split the top-level comma list, then the
+ * first `=` per pair. Values stay as raw expressions so the caller resolves them
+ * the same way the runtime does.
+ */
+/**
+ * Same shape the runtime accepts (`driver-api/src/index.ts`): `@api:<name>` with an
+ * optional balanced `(...)` arg list. A malformed tag (e.g. unclosed paren) is rejected
+ * here too, so the report never documents a call the runtime silently dropped.
+ */
+const API_TAG = /^@api:([A-Za-z_][A-Za-z0-9_]*)(?:\((.*)\))?$/;
+
+export function parseApiCalls(tags: string[]): ApiCall[] {
+  const calls: ApiCall[] = [];
+  for (const t of tags) {
+    const m = API_TAG.exec(t);
+    if (!m) continue;
+    const args: Record<string, string> = {};
+    for (const pair of splitTopLevel(m[2] ?? '')) {
+      const eq = pair.indexOf('=');
+      if (eq < 0) continue;
+      args[pair.slice(0, eq).trim()] = pair.slice(eq + 1).trim();
+    }
+    calls.push({ name: m[1], args });
+  }
+  return calls;
+}
+
+/**
+ * Build the "Steps" cell for an API test case: one block per invoked endpoint,
+ * showing Method / API (resolved path) / Header / Body. Endpoints absent from the
+ * catalog are skipped. Returns '' when nothing resolves (caller keeps generic Steps).
+ *
+ * `localize` resolves `{{var}}` test-data placeholders (and selector keys) to
+ * concrete values — the same resolver the row builder uses for UI steps.
+ */
+export function formatApiRequest(
+  tags: string[],
+  catalog: Record<string, ApiCatalogEntry>,
+  localize: (text: string) => string,
+): string {
+  const calls = parseApiCalls(tags).filter((c) => catalog[c.name]);
+  if (calls.length === 0) return '';
+
+  const blocks = calls.map((call) => {
+    const entry = catalog[call.name];
+    const resolve = (raw: string): string => localize(bindParams(raw, call.args));
+    // Coerce method/path — loadApiCatalog is a raw passthrough, so a malformed entry
+    // (numeric method/path) must degrade gracefully, not crash the unit's export.
+    const method = String(entry.method ?? '').toUpperCase() || '—';
+    const api = entry.path ? resolve(String(entry.path)) : '—';
+    const header = formatHeaders(entry, call.args, localize);
+    const bodyStr = formatBody(entry.body, call.args, localize);
+    return [`Method: ${method}`, `API: ${api}`, `Header: ${header}`, `Body: ${bodyStr}`].join('\n');
+  });
+
+  if (blocks.length === 1) return blocks[0];
+  // Multiple endpoints (flow) — number them so the call order is explicit.
+  return blocks
+    .map((b, i) => b.split('\n').map((l, j) => (j === 0 ? `${i + 1}. ${l}` : `   ${l}`)).join('\n'))
+    .join('\n');
+}
+
+/**
+ * Rewrite an API scenario's `Then` assertions into readable Status / Response lines.
+ * Raw assertions reference the runtime response object
+ * (`expect {{endpoint.status}} is 201`, `expect {{endpoint.body.email}} is {{x}}`);
+ * we strip the endpoint prefix (a runtime var, meaningless to a reader), keep the
+ * field path, label status vs body, and resolve `{{var}}` on the right-hand side.
+ */
+export function formatApiExpected(
+  expectedSteps: Array<{ text: string }>,
+  tags: string[],
+  localize: (text: string) => string,
+): string {
+  const endpointNames = parseApiCalls(tags).map((c) => c.name);
+  const oracleNames = parseQueryOracles(tags);
+  const lines = expectedSteps
+    .map((s) => humanizeAssertion(s.text, endpointNames, oracleNames, localize))
+    .filter((l) => l.length > 0);
+  if (lines.length === 0) return '';
+  if (lines.length === 1) return lines[0];
+  return lines.map((l, i) => `${i + 1}. ${l}`).join('\n');
+}
+
+// ---------------------------------------------------------------------------
+// Internals
+// ---------------------------------------------------------------------------
+
+/** Split a comma list, ignoring commas nested inside {}/[]/() so `{a,b}` stays whole. */
+function splitTopLevel(s: string): string[] {
+  const out: string[] = [];
+  let depth = 0;
+  let cur = '';
+  for (const ch of s) {
+    if (ch === '{' || ch === '[' || ch === '(') depth++;
+    else if (ch === '}' || ch === ']' || ch === ')') depth = Math.max(0, depth - 1);
+    if (ch === ',' && depth === 0) {
+      out.push(cur);
+      cur = '';
+    } else {
+      cur += ch;
+    }
+  }
+  if (cur.trim().length > 0) out.push(cur);
+  return out;
+}
+
+/**
+ * Substitute `:param` tokens (path / body / header templates) with the invocation's
+ * arg expression, falling back to `{{param}}` when the tag omits it — matching the
+ * runtime, where an unbound param resolves from the same-named test-data key.
+ */
+function bindParams(raw: string, args: Record<string, string>): string {
+  return raw.replace(/:([A-Za-z_][A-Za-z0-9_]*)/g, (_m, p: string) => {
+    const expr = p in args ? args[p] : `{{${p}}}`;
+    return unquoteExpr(expr);
+  });
+}
+
+/** Strip a matching pair of surrounding quotes from a tag-arg literal (`"x"` → `x`). */
+function unquoteExpr(e: string): string {
+  const m = e.match(/^"(.*)"$/) || e.match(/^'(.*)'$/);
+  return m ? m[1] : e;
+}
+
+/**
+ * Compose the Header cell from catalog `headers:` (with `:param` bound + `{{var}}`
+ * resolved) plus the Content-Type implied by the body wire format — Playwright sets
+ * that Content-Type from the encoding option at runtime (specs-api.ts), shown only
+ * when a body is sent and the catalog didn't already declare one. Returns '—' when
+ * the request has none.
+ *
+ * Scope: this reflects the per-endpoint catalog headers only. Datasource-level headers
+ * (`conf.headers` from the datasources config, merged at runtime) are NOT read here —
+ * the exporter doesn't load `.env.qa`/datasources — so the cell is a catalog view, not
+ * a byte-for-byte copy of the wire request.
+ */
+function formatHeaders(
+  entry: ApiCatalogEntry,
+  args: Record<string, string>,
+  localize: (text: string) => string,
+): string {
+  const explicit = entry.headers && typeof entry.headers === 'object' ? entry.headers : {};
+  const hasContentType = Object.keys(explicit).some((k) => k.toLowerCase() === 'content-type');
+  // Auth headers (authorization/cookie/api-key…) carry credentials — show the scheme
+  // but mask the value. A value-based redaction pass (redactSecrets) backstops this.
+  const parts = Object.entries(explicit).map(([k, v]) =>
+    isSensitiveHeader(k) ? `${k}: ${maskHeaderValue(String(v))}` : `${k}: ${localize(bindParams(String(v), args))}`,
+  );
+  if (!hasContentType && entry.body !== undefined && entry.body !== null) {
+    parts.push(`Content-Type: ${contentTypeFor(entry.encoding)}`);
+  }
+  return parts.length > 0 ? parts.join('\n') : '—';
+}
+
+function contentTypeFor(encoding?: string): string {
+  if (encoding === 'form') return 'application/x-www-form-urlencoded';
+  if (encoding === 'multipart') return 'multipart/form-data';
+  return 'application/json';
+}
+
+/**
+ * Compose the Body cell, masking credential fields. When the body is a flat object
+ * with a sensitive key (password/token/secret/…), each value is rendered per-key so
+ * that field can be replaced with `***`; otherwise the body resolves wholesale
+ * (preserving numbers/nesting exactly as before).
+ */
+function formatBody(body: unknown, args: Record<string, string>, localize: (text: string) => string): string {
+  if (body === undefined || body === null) return '—';
+  if (isPlainObject(body)) {
+    const obj = body as Record<string, unknown>;
+    if (Object.keys(obj).some(isSensitiveField)) {
+      const out: Record<string, string> = {};
+      for (const [k, v] of Object.entries(obj)) {
+        out[k] = isSensitiveField(k) ? '***' : localize(bindParams(typeof v === 'string' ? v : JSON.stringify(v), args));
+      }
+      return JSON.stringify(out);
+    }
+  }
+  return localize(bindParams(typeof body === 'string' ? body : JSON.stringify(body), args));
+}
+
+function isPlainObject(v: unknown): boolean {
+  return typeof v === 'object' && v !== null && !Array.isArray(v);
+}
+
+/**
+ * Credential name matcher (substring, not anchored) for both body-field keys and
+ * test-data keys — catches variants like confirmPassword / new_password /
+ * password_confirmation / access_token / client_secret / otp / passcode.
+ */
+const SENSITIVE_NAME = /pass(word|code)?|passwd|pwd|secret|token|otp|api[-_]?key|apikey|credential|authorization/i;
+function isSensitiveField(key: string): boolean {
+  return SENSITIVE_NAME.test(key);
+}
+
+/**
+ * Resolved values of sensitive test-data keys — used for a value-based redaction pass
+ * over the finished Steps/Expected cells, closing the paths key-based masking misses
+ * (nested request bodies, query-string credentials, and the Expected assertion cell).
+ * Values shorter than 3 chars are skipped to avoid masking trivial/coincidental text.
+ */
+export function collectSecretValues(testData: Record<string, string>): string[] {
+  const secrets: string[] = [];
+  for (const [k, v] of Object.entries(testData)) {
+    if (typeof v === 'string' && v.length >= 3 && SENSITIVE_NAME.test(k)) secrets.push(v);
+  }
+  // Longest-first so a longer secret is redacted before any shorter substring of it.
+  return [...new Set(secrets)].sort((a, b) => b.length - a.length);
+}
+
+/** Replace every occurrence of each secret value with `***` (literal, not regex). */
+export function redactSecrets(text: string, secrets: string[]): string {
+  if (secrets.length === 0 || !text) return text;
+  let out = text;
+  for (const s of secrets) out = out.split(s).join('***');
+  return out;
+}
+
+/** Header names that carry credentials — value masked, scheme kept. */
+const SENSITIVE_HEADER = /^(authorization|proxy-authorization|cookie|set-cookie|x-api-key|api-key|x-auth-token|x-access-token|x-session-token)$/i;
+function isSensitiveHeader(name: string): boolean {
+  return SENSITIVE_HEADER.test(name);
+}
+
+/** Keep an auth scheme prefix (Bearer/Basic/…) but hide the credential. */
+function maskHeaderValue(value: string): string {
+  const m = value.match(/^(Bearer|Basic|Digest|Token)\b/i);
+  return m ? `${m[1]} ***` : '***';
+}
+
+/** Ordered `@query:<oracle>` DB-oracle names (a @concurrent idempotency cross-check). */
+function parseQueryOracles(tags: string[]): string[] {
+  return tags
+    .filter((t) => t.startsWith('@query:'))
+    .map((t) => {
+      const body = t.slice('@query:'.length);
+      const parenIdx = body.indexOf('(');
+      return parenIdx >= 0 ? body.slice(0, parenIdx) : body;
+    });
+}
+
+/**
+ * Turn one raw assertion line into a readable Status/Response statement.
+ * `{{<endpoint>.<field>}}` → a labelled response reference; `{{<oracle>.<field>}}`
+ * (a @query DB oracle) → the plain dotted path; remaining `{{var}}` (genuine
+ * test-data on the right-hand side) is resolved by `localize`.
+ */
+function humanizeAssertion(
+  raw: string,
+  endpointNames: string[],
+  oracleNames: string[],
+  localize: (text: string) => string,
+): string {
+  let s = raw.trim().replace(/^expect\s+/i, '');
+  // Field path allows array-index segments so @concurrent refs like
+  // `{{login.responses[0].body.token}}` are matched, not left as raw `{{…}}`.
+  const FIELD = '(?:[\\w.]|\\[\\d+\\])+';
+  if (endpointNames.length > 0) {
+    const alt = endpointNames.map(escapeRe).join('|');
+    s = s.replace(new RegExp(`\\{\\{\\s*(?:${alt})\\.(${FIELD})\\s*\\}\\}`, 'g'), (_m, field: string) =>
+      responseFieldLabel(field),
+    );
+  }
+  if (oracleNames.length > 0) {
+    // @query oracle refs read as a DB check — strip the `{{ }}` noise, keep `oracle.field`.
+    const alt = oracleNames.map(escapeRe).join('|');
+    s = s.replace(new RegExp(`\\{\\{\\s*((?:${alt})\\.${FIELD})\\s*\\}\\}`, 'g'), (_m, ref: string) => ref);
+  }
+  s = localize(s);
+  if (s.length === 0) return s;
+  // Don't recase a line that leads with a @query oracle identifier (a code name) —
+  // `user_count.count is 1` must not become `User_count.count is 1`.
+  const leadsWithOracle = oracleNames.some((o) => s === o || s.startsWith(`${o}.`));
+  return leadsWithOracle ? s : s.charAt(0).toUpperCase() + s.slice(1);
+}
+
+/** Map a response field path (after the `<endpoint>.` prefix) to reader-friendly text. */
+function responseFieldLabel(field: string): string {
+  if (field === 'status') return 'Status';
+  if (field === 'ok') return 'Response ok';
+  if (field === 'ok_count') return 'Success count';
+  if (field === 'body') return 'Response body';
+  if (field.startsWith('body.')) return `Response body.${field.slice('body.'.length)}`;
+  if (field.startsWith('status_counts.')) return `Count of ${field.slice('status_counts.'.length)} responses`;
+  if (field.startsWith('headers.')) return `Response header "${field.slice('headers.'.length)}"`;
+  return `Response ${field}`;
+}
+
+function escapeRe(s: string): string {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}

package/src/exporters/csv-exporter.ts

@@ -16,13 +16,14 @@ import {
   splitVpAndName,
 } from './feature-parser';
 import { formatFeatureSteps, formatPrecondition, keepActor, stripActor } from './step-formatter';
-import { formatTestData } from './test-data-resolver';
+import { formatTestData, substituteTestDataVars } from './test-data-resolver';
 import {
   formatExecutedDate,
   formatNote,
   statusToTestResult,
 } from './playwright-report-parser';
-import { EnvironmentInfo, PlaywrightResult, ScreenSummary, TestCaseRow } from './types';
+import { ApiCatalogEntry, EnvironmentInfo, PlaywrightResult, ScreenSummary, TestCaseRow } from './types';
+import { collectSecretValues, formatApiExpected, formatApiRequest, hasApiCalls, redactSecrets } from './api-testcase-formatter';
 import { SelectorKeyMap, substituteSelectorKeysInStep } from './selector-key-resolver';
 
 export interface BuildCsvInput {
@@ -43,6 +44,18 @@ export interface BuildCsvInput {
    * instead of the VI selector key "Click [VỀ KUDOS] link".
    */
   selectorKeyMap?: SelectorKeyMap;
+  /**
+   * Unit kind. When `'api'`, the row builder renders the request contract
+   * (Method/API/Header/Body) into the Steps cell and the response contract
+   * (Status + Response) into the Expected cell — API scenarios otherwise leave
+   * Steps empty and Expected showing raw `{{endpoint.field}}` refs.
+   */
+  kind?: 'screen' | 'flow' | 'api';
+  /**
+   * apis.yaml catalog (keyed by endpoint name) for api-kind units. Supplies the
+   * Method/path/headers/body/encoding the readable request block is built from.
+   */
+  apiCatalog?: Record<string, ApiCatalogEntry>;
 }
 
 /**
@@ -83,23 +96,49 @@ export function buildTestCaseRows(input: BuildCsvInput): TestCaseRow[] {
     // Pre-condition is auth-only. Steps section = Background + @extend base
     // (entire) + own pre-Then. Expected = own's Then-onwards only.
     const precondition = formatPrecondition(authRole);
-    const localize = (text: string): string =>
-      input.selectorKeyMap
+    const localize = (text: string): string => {
+      // 1. resolve [Reference] selector keys → their label/value; 2. resolve {{var}} test-data
+      //    placeholders → concrete values, so Steps / Expected results show what QA actually verifies
+      //    (e.g. `text contains {{app_version}}` → `text contains Version 1.0.0`) instead of the raw
+      //    template. An unknown {{var}} is left literal.
+      const withKeys = input.selectorKeyMap
         ? substituteSelectorKeysInStep(text, input.selectorKeyMap, input.testData)
         : text;
+      return substituteTestDataVars(withKeys, input.testData);
+    };
     const formatStep = (s: { text: string; bucket: 'given' | 'when' | 'then' }) =>
       localize(s.bucket === 'given' ? keepActor(s.text) : stripActor(s.text));
     const stepLines    = m.resolvedSteps.map(formatStep).filter(Boolean);
     const expectedLines = m.resolvedExpected.map(formatStep).filter(Boolean);
-    const steps =
+    let steps =
       stepLines.length === 0 ? '' :
       stepLines.length === 1 ? stepLines[0] :
       stepLines.map((l, i) => `${i + 1}. ${l}`).join('\n');
-    const expectedResults =
+    let expectedResults =
       expectedLines.length === 0 ? '' :
       expectedLines.length === 1 ? expectedLines[0] :
       expectedLines.map((l, i) => `${i + 1}. ${l}`).join('\n');
 
+    // API test cases: the scenario has no Given/When (Steps empty) and asserts
+    // against runtime response refs (`{{endpoint.status}}` — left literal since
+    // they aren't test-data keys). Render the request contract into Steps and the
+    // response contract into Expected from the @api tag + apis.yaml catalog, so
+    // QA reads Method/API/Header/Body and Status/Response instead of raw refs.
+    if (input.kind === 'api' && input.apiCatalog && hasApiCalls(m.feature.tags)) {
+      const apiRequest = formatApiRequest(m.feature.tags, input.apiCatalog, localize);
+      if (apiRequest) steps = steps ? `${steps}\n\n${apiRequest}` : apiRequest;
+      const apiExpected = formatApiExpected(m.resolvedExpected, m.feature.tags, localize);
+      if (apiExpected) expectedResults = apiExpected;
+      // Value-based redaction backstop: mask resolved credential values (from
+      // sensitively-named test-data keys) anywhere in the API cells — closes the
+      // nested-body, query-string and Expected-cell paths key-based masking misses.
+      const secrets = collectSecretValues(input.testData);
+      if (secrets.length > 0) {
+        steps = redactSecrets(steps, secrets);
+        expectedResults = redactSecrets(expectedResults, secrets);
+      }
+    }
+
     // Multi-line bullet format keeps delivery CSV/XLSX in sync with the
     // dashboard's Test data section. Multi-line CSV cells are valid (quoted
     // automatically) and render natively as multi-line in XLSX.
@@ -127,7 +166,7 @@ export function buildTestCaseRows(input: BuildCsvInput): TestCaseRow[] {
     } else {
       testResult = statusToTestResult(result.status);
       executedDate = formatExecutedDate(result.startTime);
-      note = formatNote(result);
+      note = formatNote(result, expectedResults);
       environment = formatEnv(input.env.baseURL, input.featurePath, result.projectName || input.env.projectName);
       executor = input.env.executor;
     }

package/src/exporters/feature-parser.ts

@@ -90,6 +90,7 @@ export function parseFeatureMetadata(featureFilePath: string): FeatureMetadata {
       rawWhenSteps:  when,
       rawThenSteps:  then,
       orderedSteps:  ordered,
+      comments:      sc.comments,
     };
   });
 
@@ -132,9 +133,13 @@ export function extractPriority(tags: string[]): string {
 
 /**
  * Extract testcase type from scenario tags.
+ * Matches the bare `@manual` AND the reason-coded form `@manual:M1`..`@manual:M9`
+ * (the canonical way to tag manual scenarios). Without the `startsWith` check a
+ * `@manual:M1` scenario was misclassified as `Auto` → rendered "Not compiled"/"N/A"
+ * in the report instead of "Manual"/"Pending".
  */
 export function extractTestcaseType(tags: string[]): 'Auto' | 'Manual' {
-  return tags.includes('@manual') ? 'Manual' : 'Auto';
+  return tags.some((t) => t === '@manual' || t.startsWith('@manual:')) ? 'Manual' : 'Auto';
 }
 
 /**
@@ -153,7 +158,7 @@ export function extractAuthRole(tags: string[]): string | null {
  *   { vpId: "VP-UI-001", category1: "Modal displays all required fields" }
  */
 export function splitVpAndName(scenarioName: string): { vpId?: string; category1: string } {
-  const match = scenarioName.match(/^(VP-[A-Z]+-\d+[a-zA-Z]?)\s+(.+)$/);
+  const match = scenarioName.match(/^(VP-[A-Z][A-Z0-9]*-\d+[a-zA-Z]?)\s+(.+)$/);
   if (match) {
     return { vpId: match[1], category1: match[2] };
   }

package/src/exporters/json-exporter.ts

@@ -111,9 +111,17 @@ export function buildScreenSnapshot(input: BuildScreenSnapshotInput): ScreenSnap
         status = statusToTestResult(result.status) as ScenarioSnapshot['status'];
         executedDate = formatExecutedDate(result.startTime);
         if (result.error) {
-          // Strip a leading "Error:" so consumers (dashboard / CSV `Note`)
-          // can prepend their own label without ending up with `Error: Error:`.
-          errorMessage = String(result.error).split('\n')[0].trim().replace(/^Error:\s*/i, '');
+          // Keep the FULL assertion message on one line. Do NOT use split('\n')[0]: a WDIO
+          // selector value can itself contain a newline (a Flutter composite accessibility-id
+          // like `~Share with Friends\nSpread the word`), which would truncate the message
+          // mid-selector. Drop the stack trace (frames start with "at "), collapse the remaining
+          // newlines (incl. the Expected/Received lines) to spaces, and strip a leading "Error:"
+          // so consumers (dashboard / CSV `Note`) can prepend their own label.
+          errorMessage = String(result.error)
+            .split(/\n\s*at\s/)[0]
+            .replace(/\s*\n\s*/g, ' ')
+            .trim()
+            .replace(/^Error:\s*/i, '');
         }
         if (result.tracePath) tracePath = result.tracePath;
         testEnvironment = formatTestEnvironment(input.env.baseURL, input.featurePath, result.projectName || input.env.projectName);

package/src/exporters/playwright-report-parser.ts

@@ -192,22 +192,61 @@ export function formatExecutedDate(startTime: string | undefined): string {
   return `${dd}/${mm}/${yyyy}`;
 }
 
+const NOTE_FIELD_MAX = 300;
+const clip = (s: string): string => {
+  const t = s.replace(/\s*\n\s*/g, ' ').trim();
+  return t.length > NOTE_FIELD_MAX ? t.slice(0, NOTE_FIELD_MAX - 1) + '…' : t;
+};
+
+/**
+ * Split an assertion failure message into its Expected + Received values, so QA can compare.
+ * Both frameworks embed them in the error message: Playwright — `Expected string: "…"` /
+ * `Received string: "…"` (also `Expected pattern/substring/value`, `Received value`); expect-
+ * webdriverio — `Expected: …` / `Received: …`. `(.+)` (no /s flag) captures to end-of-line, so a
+ * multi-line stack after the value is not swallowed. Undefined when the message isn't an assertion
+ * (e.g. element-not-found / timeout) — then there is no runtime Expected to show.
+ */
+export function parseExpectedReceived(raw: string): { expected?: string; received?: string } {
+  const grab = (re: RegExp): string | undefined => { const m = raw.match(re); return m ? clip(m[1]) : undefined; };
+  return {
+    expected: grab(/\bExpected(?:\s+[\w-]+)?:\s*(.+)/i),
+    received: grab(/\bReceived(?:\s+[\w-]+)?:\s*(.+)/i),
+  };
+}
+
 /**
- * Format error message for Note column. Truncate long stacks, include trace path.
+ * Format the Note column for a FAILED test case (returns '' for any non-failed status — so only
+ * `Test Result = Failed` rows get a Note). Emits the two fields QA compares:
+ *   • Expected result: the asserted value parsed from the error, or — when the failure isn't an
+ *     assertion (timeout / element-not-found, which carry no Expected/Received) — the scenario's
+ *     expected (`expectedFallback`, i.e. the "Expected results" column / Then steps), so QA always
+ *     sees what SHOULD have happened next to the actual.
+ *   • Actual result: the Received value, or the raw error.
+ * Plus the trace path.
  */
-export function formatNote(result: PlaywrightResult | undefined): string {
+export function formatNote(result: PlaywrightResult | undefined, expectedFallback = ''): string {
   if (!result) return '';
   if (result.status !== 'failed' && result.status !== 'timedOut') return '';
-  // Some Playwright error messages already start with `Error:` — strip it
-  // so we don't end up rendering `Error: Error: …` once we prepend the label.
-  const firstLine = (result.error || '').split('\n')[0].trim().replace(/^Error:\s*/i, '');
-  const truncated = firstLine.length > 200 ? firstLine.substring(0, 197) + '…' : firstLine;
+  // Full assertion message with stack frames dropped (frames start with "at ") + a leading `Error:`
+  // stripped. Keep newlines here so parseExpectedReceived can delimit the Expected/Received lines.
+  const raw = (result.error || '').split(/\n\s*at\s/)[0].replace(/^Error:\s*/i, '').trim();
+  const { expected, received } = parseExpectedReceived(raw);
+  const actual = received || clip(raw); // received value, else the raw error
+
+  // Newline-separated bullets so each field lands on its own row when the cell wraps — matches the
+  // Test Data column's `• key: value` formatting. Excel/CSV honour `\n` inside quoted cells; the
+  // dashboard modal renders with whitespace-pre-wrap.
   const parts: string[] = [];
-  if (truncated)        parts.push(`• Error: ${truncated}`);
+  // Expected result: a parsed assertion value stays inline; the scenario expected (Then steps) can be
+  // several numbered criteria — put each on its own indented line so the cell reads as a list.
+  if (expected) {
+    parts.push(`• Expected result: ${expected}`);
+  } else {
+    const lines = expectedFallback.split(/\r?\n/).map((l) => clip(l)).filter(Boolean);
+    if (lines.length === 1) parts.push(`• Expected result: ${lines[0]}`);
+    else if (lines.length > 1) parts.push(`• Expected result:\n${lines.map((l) => `   ${l}`).join('\n')}`);
+  }
+  if (actual)           parts.push(`• Actual result: ${actual}`);
   if (result.tracePath) parts.push(`• Trace: ${result.tracePath}`);
-  // Newline-separated bullets so each field lands on its own row when the
-  // cell wraps — matches the Test Data column's `• key: value` formatting.
-  // Excel/CSV honour `\n` inside quoted cells; the dashboard modal already
-  // renders this with whitespace-pre-wrap.
   return parts.join('\n');
 }