@sun-asterisk/sungen 3.2.6 → 3.2.7

package/src/dashboard/types.ts

@@ -76,6 +76,25 @@ export interface FeatureSnapshot {
   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)
+  /** API detail sheet rows (api-kind units only) — precomputed by the snapshot
+   *  builder with the same buildApiDetailRows call the delivery CLI uses, so the
+   *  dashboard XLSX export appends an "API detail" sheet identical to delivery's. */
+  apiDetail?: ApiDetailRow[];
+}
+
+/**
+ * One endpoint row of the "API detail" sheet (api-kind units). Structural copy
+ * of ApiDetailRow in src/exporters/types.ts — kept local so this file stays
+ * import-free (it is mirrored verbatim into dashboard/src/types.ts).
+ */
+export interface ApiDetailRow {
+  endpoint: string;                    // catalog path, e.g. /users/count?email=:email
+  method: string;                      // HTTP method
+  authDatasource: string;              // datasource + any @auth tag
+  requestShape: string;                // body fields / params / encoding
+  expectedStatusMatrix: string;        // expect.status + @cases dataset pointer
+  flowSteps: string;                   // ordered @api:<name> chain for flow scenarios
+  concurrencyInvariant: string;        // @concurrent invariant, when present
 }
 
 /**

package/src/exporters/api-catalog-loader.ts

@@ -0,0 +1,44 @@
+/**
+ * Load the apis.yaml endpoint catalog for an api-kind unit — shared by the
+ * delivery CLI (CSV/XLSX export) and the dashboard snapshot builder so both
+ * surfaces render the identical request/response contract for API test cases.
+ */
+
+import * as fs from 'fs';
+import * as path from 'path';
+import { parse as parseYaml } from 'yaml';
+import { ApiCatalogEntry } from './types';
+
+/**
+ * Load the apis.yaml catalog for an api-kind unit, merging the shared catalog under
+ * the unit catalog. The runtime resolves an endpoint unit-scope-first then falls back
+ * to the shared catalog (driver-api api-catalog.ts), so an endpoint defined only in
+ * `qa/api/apis.yaml` still runs — we must load it too, or its request block would come
+ * back empty (the very bug this feature fixes). Unit wins on a name collision.
+ * Returns an empty object when neither file is present (graceful degradation).
+ */
+export function loadApiCatalog(
+  cwd: string,
+  kind: 'screen' | 'flow' | 'api',
+  screen: string,
+): Record<string, ApiCatalogEntry> {
+  if (kind !== 'api') return {};
+  const shared = readApiCatalogFile(path.join(cwd, 'qa', 'api', 'apis.yaml'));
+  const unit = readApiCatalogFile(path.join(cwd, 'qa', 'api', screen, 'api', 'apis.yaml'));
+  return { ...shared, ...unit };
+}
+
+/** Parse one apis.yaml file into an endpoint map, unwrapping the optional `apis:` wrapper. */
+export function readApiCatalogFile(catalogPath: string): Record<string, ApiCatalogEntry> {
+  if (!fs.existsSync(catalogPath)) return {};
+  try {
+    const parsed = parseYaml(fs.readFileSync(catalogPath, 'utf-8')) as Record<string, unknown> | null;
+    if (parsed && typeof parsed === 'object') {
+      // The runtime loader accepts both a flat map and an `apis:` wrapper — unwrap it
+      // here too so both loaders read the same file identically.
+      const root = parsed.apis && typeof parsed.apis === 'object' ? parsed.apis : parsed;
+      return root as Record<string, ApiCatalogEntry>;
+    }
+  } catch { /* malformed yaml — skip */ }
+  return {};
+}

package/src/exporters/json-exporter.ts

@@ -15,12 +15,13 @@ import {
   splitVpAndName,
 } from './feature-parser';
 import { formatPrecondition, keepActor, stripActor } from './step-formatter';
-import { formatTestData } from './test-data-resolver';
+import { formatTestData, substituteTestDataVars } from './test-data-resolver';
+import { collectSecretValues, formatApiExpected, formatApiRequest, hasApiCalls, redactSecrets } from './api-testcase-formatter';
 import {
   formatExecutedDate,
   statusToTestResult,
 } from './playwright-report-parser';
-import { EnvironmentInfo, PlaywrightResult } from './types';
+import { ApiCatalogEntry, EnvironmentInfo, PlaywrightResult } from './types';
 import { SelectorKeyMap, substituteSelectorKeysInStep } from './selector-key-resolver';
 import { resolveResultVariants } from './result-variants';
 import {
@@ -53,6 +54,15 @@ export interface BuildScreenSnapshotInput {
    * link" instead of the VI key "Click [VỀ KUDOS] link".
    */
   selectorKeyMap?: SelectorKeyMap;
+  /**
+   * Unit kind. When `'api'`, Steps/Expected are composed from the request
+   * contract (Method/API/Header/Body) and response contract (Status + Response)
+   * exactly like csv-exporter's buildTestCaseRows — so the dashboard UI and its
+   * XLSX export show the same cells as the delivery CSV.
+   */
+  kind?: 'screen' | 'flow' | 'api';
+  /** apis.yaml catalog (keyed by endpoint name) for api-kind units. */
+  apiCatalog?: Record<string, ApiCatalogEntry>;
 }
 
 /**
@@ -77,8 +87,40 @@ export function buildScreenSnapshot(input: BuildScreenSnapshotInput): ScreenSnap
         : text;
     const formatStep = (s: { text: string; bucket: 'given' | 'when' | 'then' }) =>
       localize(s.bucket === 'given' ? keepActor(s.text) : stripActor(s.text));
-    const steps = m.resolvedSteps.map(formatStep).filter(Boolean);
-    const expectedResults = m.resolvedExpected.map(formatStep).filter(Boolean);
+    let steps = m.resolvedSteps.map(formatStep).filter(Boolean);
+    let expectedResults = m.resolvedExpected.map(formatStep).filter(Boolean);
+
+    // API test cases: mirror csv-exporter's request/response rendering so the
+    // dashboard (UI + XLSX export) shows the same Steps / Expected results as
+    // the delivery CSV. The cells are composed with the CSV's exact single-vs-
+    // numbered join, then stored as ONE array entry — the dashboard XLSX
+    // adapter's formatList() (1 entry → raw) reproduces the delivery cell
+    // byte-for-byte, and the UI renders the block with pre-wrap.
+    if (input.kind === 'api' && input.apiCatalog && hasApiCalls(m.feature.tags)) {
+      // Delivery cells substitute {{var}} test-data refs (csv-exporter's localize);
+      // scope that to the API branch so non-API snapshot behavior is untouched.
+      const localizeApi = (text: string): string => substituteTestDataVars(localize(text), input.testData);
+      const formatStepApi = (s: { text: string; bucket: 'given' | 'when' | 'then' }) =>
+        localizeApi(s.bucket === 'given' ? keepActor(s.text) : stripActor(s.text));
+      const joinCell = (lines: string[]): string =>
+        lines.length === 0 ? '' :
+        lines.length === 1 ? lines[0] :
+        lines.map((l, i) => `${i + 1}. ${l}`).join('\n');
+      let stepsCell = joinCell(m.resolvedSteps.map(formatStepApi).filter(Boolean));
+      let expectedCell = joinCell(m.resolvedExpected.map(formatStepApi).filter(Boolean));
+      const apiRequest = formatApiRequest(m.feature.tags, input.apiCatalog, localizeApi);
+      if (apiRequest) stepsCell = stepsCell ? `${stepsCell}\n\n${apiRequest}` : apiRequest;
+      const apiExpected = formatApiExpected(m.resolvedExpected, m.feature.tags, localizeApi);
+      if (apiExpected) expectedCell = apiExpected;
+      // Same value-based redaction backstop as the CSV path.
+      const secrets = collectSecretValues(input.testData);
+      if (secrets.length > 0) {
+        stepsCell = redactSecrets(stepsCell, secrets);
+        expectedCell = redactSecrets(expectedCell, secrets);
+      }
+      steps = stepsCell ? [stepsCell] : [];
+      expectedResults = expectedCell ? [expectedCell] : [];
+    }
     // Dashboard modal uses whitespace-pre-wrap — pass '\n' to render one
     // key/value per line instead of the CSV-friendly "; " join.
     const testDataStr = formatTestData(m.feature.referencedVars, input.testData, Infinity, '\n');

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

@@ -3,8 +3,35 @@
  */
 
 import * as fs from 'fs';
+import * as path from 'path';
 import { PlaywrightResult } from './types';
 
+/**
+ * Resolve the results.json file for a unit — shared by the delivery CLI and
+ * the dashboard snapshot builder so both surfaces resolve execution status
+ * from the SAME file (they drifted: the dashboard only looked for the
+ * per-feature file and showed every scenario Pending on projects whose
+ * playwright.config writes only the default global test-results/results.json).
+ *
+ * Candidate order (first existing wins):
+ *   1. <genDir>/<featureBaseName>-test-result.<SUNGEN_ENV>.json  (env runs)
+ *   2. <genDir>/<featureBaseName>-test-result.json               (per-feature reporter)
+ *   3. <cwd>/test-results/results.<SUNGEN_ENV>.json
+ *   4. <cwd>/test-results/results.json                           (playwright default)
+ */
+export function resolveResultsPath(cwd: string, genDir: string, featureBaseName: string): string | null {
+  const env = process.env.SUNGEN_ENV;
+  const candidates: string[] = [];
+  if (env) candidates.push(path.join(genDir, `${featureBaseName}-test-result.${env}.json`));
+  candidates.push(path.join(genDir, `${featureBaseName}-test-result.json`));
+  if (env) candidates.push(path.join(cwd, 'test-results', `results.${env}.json`));
+  candidates.push(path.join(cwd, 'test-results', 'results.json'));
+  for (const c of candidates) {
+    if (fs.existsSync(c)) return c;
+  }
+  return null;
+}
+
 /**
  * Shape of the JSON reporter output we care about.
  * See https://playwright.dev/docs/test-reporters#json-reporter