@sun-asterisk/sungen 2.6.12 → 2.6.15

package/src/dashboard/snapshot-builder.ts

@@ -18,6 +18,7 @@ import { parse as parseYaml } from 'yaml';
 import { parseFeatureMetadata } from '../exporters/feature-parser';
 import { parseSpecFile } from '../exporters/spec-parser';
 import { loadTestData } from '../exporters/test-data-resolver';
+import { loadSelectorKeyMap } from '../exporters/selector-key-resolver';
 import { loadPlaywrightReport } from '../exporters/playwright-report-parser';
 import { mergeFeatureAndSpec } from '../exporters/scenario-merger';
 import { buildScreenSnapshot } from '../exporters/json-exporter';
@@ -26,11 +27,20 @@ import { EnvironmentInfo } from '../exporters/types';
 import {
   AggregateSummary,
   DashboardSnapshot,
+  FeatureSnapshot,
+  LocaleSnapshot,
   ScenarioSnapshot,
   ScreenSnapshot,
+  ScreenSummaryStats,
   SNAPSHOT_VERSION,
 } from './types';
 
+/**
+ * Locale code displayed when a screen has no overlay variants — the base
+ * test-data file alone. Matches the delivery CLI's `DEFAULT_BASE_LOCALE`.
+ */
+const DEFAULT_BASE_LOCALE = 'vi';
+
 export interface DashboardTarget {
   name: string;
   isFlow: boolean;
@@ -80,12 +90,62 @@ function buildOneScreen(
   env: EnvironmentInfo
 ): ScreenSnapshot | null {
   const base = qaDir(cwd, target);
-  const genBase = generatedDir(cwd, target);
-  const featureFile = path.join(base, 'features', `${target.name}.feature`);
-  const testDataFile = path.join(base, 'test-data', `${target.name}.yaml`);
-  const specFile = path.join(genBase, `${target.name}.spec.ts`);
+  const featuresDir = path.join(base, 'features');
+  if (!fs.existsSync(featuresDir)) return null;
+
+  // Enumerate all .feature files inside the screen/flow — matches delivery's
+  // discovery so dashboard scenarios share TC IDs with the exported CSVs.
+  const featureBaseNames = fs.readdirSync(featuresDir)
+    .filter((f) => f.endsWith('.feature'))
+    .map((f) => f.slice(0, -'.feature'.length))
+    .sort();
+  if (featureBaseNames.length === 0) return null;
+
   const specMdFile = path.join(base, 'requirements', 'spec.md');
-  const resultsFile = resolveResultsPath(cwd, target);
+  const specLink = fs.existsSync(specMdFile) ? path.relative(cwd, specMdFile) : undefined;
+
+  const features: FeatureSnapshot[] = [];
+  for (const featureBaseName of featureBaseNames) {
+    const fs2 = buildOneFeature(cwd, target, featureBaseName, env, specLink);
+    if (fs2) features.push(fs2);
+  }
+  if (features.length === 0) return null;
+
+  // Flat scenarios across all features (each scenario already carries its
+  // own `featureBaseName`, so consumers that want to group can do so cheaply).
+  const scenarios = features.flatMap((f) => f.scenarios);
+  const label = target.isFlow ? `flow/${target.name}` : target.name;
+  const primary = features[0];
+
+  return {
+    name: label,
+    isFlow: target.isFlow,
+    featureName: primary.featureName,
+    featurePath: primary.featurePath,
+    specLink,
+    summary: rollupScreenSummary(features),
+    scenarios,
+    features,
+  };
+}
+
+/**
+ * Build a FeatureSnapshot for a single `.feature` file inside a screen/flow.
+ * TC IDs are generated using `featureBaseName` as the prefix so they match
+ * the delivery CSV (e.g. `HOME-MODAL-UI-001`, not `HOME-UI-001`).
+ */
+function buildOneFeature(
+  cwd: string,
+  target: DashboardTarget,
+  featureBaseName: string,
+  env: EnvironmentInfo,
+  specLink: string | undefined,
+): FeatureSnapshot | null {
+  const base = qaDir(cwd, target);
+  const genBase = generatedDir(cwd, target);
+  const featureFile = path.join(base, 'features', `${featureBaseName}.feature`);
+  const testDataFile = path.join(base, 'test-data', `${featureBaseName}.yaml`);
+  const specFile = path.join(genBase, `${featureBaseName}.spec.ts`);
 
   if (!fs.existsSync(featureFile)) return null;
 
@@ -93,33 +153,157 @@ function buildOneScreen(
   const spec = fs.existsSync(specFile)
     ? parseSpecFile(specFile)
     : { tests: [] };
-  const testData = fs.existsSync(testDataFile) ? loadTestData(testDataFile) : {};
-  const results = resultsFile ? loadPlaywrightReport(resultsFile) : null;
-
   const merged = mergeFeatureAndSpec(feature, spec);
-  const label = target.isFlow ? `flow/${target.name}` : target.name;
-  const specLink = fs.existsSync(specMdFile) ? path.relative(cwd, specMdFile) : undefined;
 
   // Screens declare their URL inline in the .feature ("Path: /awards"). Flows
-  // don't have one there, so fall back to the first `type: 'page'` entry in
-  // the flow's selectors YAML — that's where the entry point is recorded.
+  // don't, so fall back to the first `type: 'page'` entry in selectors YAML.
   let featurePath = feature.featurePath;
+  const selectorsFile = path.join(base, 'selectors', `${featureBaseName}.yaml`);
   if (!featurePath && target.isFlow) {
-    const selectorsFile = path.join(base, 'selectors', `${target.name}.yaml`);
     featurePath = readPagePathFromSelectors(selectorsFile);
   }
+  const selectorKeyMap = loadSelectorKeyMap(selectorsFile);
+
+  // Discover locale variants by scanning <feature>-test-result*.json files.
+  // Always includes base ('') as the first entry, even if its results file
+  // is missing — UI still needs to render the feature.
+  const variants = discoverLocaleVariants(genBase, featureBaseName);
+
+  // Build per-locale ScreenSnapshot, then collect into FeatureSnapshot.locales[].
+  // Base variant is also used to populate the top-level (`scenarios`, `summary`)
+  // for back-compat with consumers that don't read the locales array.
+  const locales: LocaleSnapshot[] = [];
+  let baseBuilt: { scenarios: ScenarioSnapshot[]; summary: ScreenSummaryStats; featureName: string; featurePath?: string; specLink?: string } | null = null;
+
+  for (const variant of variants) {
+    const testData = fs.existsSync(testDataFile)
+      ? loadTestData(testDataFile, variant.locale || null)
+      : {};
+    const results = variant.resultsPath ? loadPlaywrightReport(variant.resultsPath) : null;
+
+    const built = buildScreenSnapshot({
+      screen: featureBaseName,
+      isFlow: target.isFlow,
+      featureName: feature.featureName,
+      featurePath,
+      specLink,
+      merged,
+      testData,
+      results,
+      env,
+      featureBaseName,
+      selectorKeyMap,
+    });
+
+    locales.push({
+      locale: variant.locale,
+      displayCode: variant.displayCode,
+      summary: built.summary,
+      scenarios: built.scenarios,
+    });
+
+    if (variant.locale === '') {
+      baseBuilt = built;
+    }
+  }
 
-  return buildScreenSnapshot({
-    screen: label,
-    isFlow: target.isFlow,
-    featureName: feature.featureName,
-    featurePath,
-    specLink,
-    merged,
-    testData,
-    results,
-    env,
+  // Guarantee a base entry — every feature in the dashboard must have
+  // something to fall back to even if base results file is missing.
+  if (!baseBuilt && locales.length > 0) {
+    baseBuilt = {
+      scenarios: locales[0].scenarios,
+      summary: locales[0].summary,
+      featureName: feature.featureName,
+      featurePath,
+      specLink,
+    };
+  }
+  if (!baseBuilt) return null;
+
+  return {
+    featureBaseName,
+    featureName: baseBuilt.featureName,
+    featurePath: baseBuilt.featurePath,
+    specLink: baseBuilt.specLink,
+    summary: baseBuilt.summary,
+    scenarios: baseBuilt.scenarios,
+    // Only expose `locales` array when 2+ variants exist — single-locale
+    // features stay slimmer and UI can skip the locale tab UI entirely.
+    locales: locales.length >= 2 ? locales : undefined,
+  };
+}
+
+/**
+ * A single locale variant of a feature.
+ * `locale === ''` denotes the base (file `<name>-test-result.json`,
+ * test-data without overlay merge). Variants come from
+ * `<name>-test-result.<locale>.json` filenames.
+ */
+interface FeatureLocaleVariant {
+  locale: string;
+  displayCode: string;
+  resultsPath: string | null;
+}
+
+/**
+ * Scan the generated directory for `<basename>-test-result*.json` files
+ * and infer locale codes. The base entry is always returned first; locale
+ * variants follow alphabetically so sheet/tab order stays deterministic.
+ *
+ * Mirrors `discoverLocaleVariants` in `src/cli/commands/delivery.ts` so the
+ * dashboard and the CSV/XLSX delivery agree on what locales exist for a
+ * given feature.
+ */
+function discoverLocaleVariants(genDir: string, featureBaseName: string): FeatureLocaleVariant[] {
+  const prefix = `${featureBaseName}-test-result`;
+  const variants: FeatureLocaleVariant[] = [];
+
+  const basePath = path.join(genDir, `${prefix}.json`);
+  variants.push({
+    locale: '',
+    displayCode: DEFAULT_BASE_LOCALE.toUpperCase(),
+    resultsPath: fs.existsSync(basePath) ? basePath : null,
   });
+
+  if (fs.existsSync(genDir)) {
+    const localeFiles = fs.readdirSync(genDir)
+      .filter((f) => f.startsWith(`${prefix}.`) && f.endsWith('.json') && f !== `${prefix}.json`)
+      .sort();
+    for (const f of localeFiles) {
+      const locale = f.slice(prefix.length + 1, -'.json'.length);
+      if (!locale) continue;
+      variants.push({
+        locale,
+        displayCode: locale.toUpperCase(),
+        resultsPath: path.join(genDir, f),
+      });
+    }
+  }
+
+  return variants;
+}
+
+/**
+ * Combine per-feature summaries into a single screen-level rollup.
+ * passRate is recomputed across the combined passed+failed totals so a
+ * screen with one all-passing feature and one all-failing feature shows
+ * 50% rather than the arithmetic mean of two rates.
+ */
+function rollupScreenSummary(features: FeatureSnapshot[]): ScreenSummaryStats {
+  const out: ScreenSummaryStats = {
+    total: 0, passed: 0, failed: 0, pending: 0, na: 0, notCompiled: 0, passRate: 0,
+  };
+  for (const f of features) {
+    out.total       += f.summary.total;
+    out.passed      += f.summary.passed;
+    out.failed      += f.summary.failed;
+    out.pending     += f.summary.pending;
+    out.na          += f.summary.na;
+    out.notCompiled += f.summary.notCompiled;
+  }
+  const executed = out.passed + out.failed;
+  out.passRate = executed > 0 ? out.passed / executed : 0;
+  return out;
 }
 
 // ----------------------------------------------------------------------------
@@ -178,15 +362,6 @@ function generatedDir(cwd: string, target: DashboardTarget): string {
     : path.join(cwd, 'specs', 'generated', target.name);
 }
 
-function resolveResultsPath(cwd: string, target: DashboardTarget): string | null {
-  const genDir = generatedDir(cwd, target);
-  const perTarget = path.join(genDir, `${target.name}-test-result.json`);
-  if (fs.existsSync(perTarget)) return perTarget;
-  const global = path.join(cwd, 'test-results', 'results.json');
-  if (fs.existsSync(global)) return global;
-  return null;
-}
-
 // ----------------------------------------------------------------------------
 // Discovery (also used by CLI)
 // ----------------------------------------------------------------------------