@sun-asterisk/sungen 2.6.1 → 2.6.2

package/src/dashboard/types.ts

@@ -0,0 +1,148 @@
+/**
+ * Schemas for the sungen dashboard snapshot.
+ *
+ * A snapshot is a self-describing JSON document that powers a single render
+ * of qa/dashboard/index.html. Past snapshots live in qa/dashboard/history/.
+ */
+
+export const SNAPSHOT_VERSION = 1 as const;
+
+export interface DashboardSnapshot {
+  version: typeof SNAPSHOT_VERSION;
+  runId: string;                       // ISO-ish: 2026-04-28T10-32-15Z (filename-safe)
+  generatedAt: string;                 // full ISO timestamp
+  environment: SnapshotEnvironment;
+  summary: AggregateSummary;
+  screens: ScreenSnapshot[];
+}
+
+export interface SnapshotEnvironment {
+  baseURL: string;
+  projectName: string;
+  executor: string;
+  sungenVersion: string;
+  gitBranch?: string;
+  gitSha?: string;
+}
+
+export interface AggregateSummary {
+  total: number;
+  passed: number;
+  failed: number;
+  pending: number;
+  na: number;
+  notCompiled: number;
+  passRate: number;                    // 0..1, only counting executed (passed+failed)
+  byPriority: Record<string, number>;  // Critical/High/Normal/Low
+  byCategory: Record<string, number>;  // Accessing/GUI/Function
+  byType: Record<string, number>;      // Auto/Manual/Not compiled
+}
+
+export interface ScreenSnapshot {
+  name: string;                        // "kudos" or "flow/checkout"
+  isFlow: boolean;
+  featureName: string;
+  featurePath?: string;
+  specLink?: string;                   // relative path to requirements/spec.md
+  summary: ScreenSummaryStats;
+  scenarios: ScenarioSnapshot[];
+}
+
+export interface ScreenSummaryStats {
+  total: number;
+  passed: number;
+  failed: number;
+  pending: number;
+  na: number;
+  notCompiled: number;
+  passRate: number;
+}
+
+export interface ScenarioSnapshot {
+  tcId: string;                        // KUDOS-UI-001
+  category1: string;                   // scenario name (VP-prefix stripped)
+  category2: string;                   // Accessing | GUI | Function
+  category3: string;                   // feature name
+  category4: string;                   // screen name
+  vpId?: string;                       // VP-UI-001 if present
+  priority: 'Critical' | 'High' | 'Normal' | 'Low';
+  type: 'Auto' | 'Manual' | 'Not compiled';
+  status: 'Passed' | 'Failed' | 'Pending' | 'N/A';
+  tags: string[];
+  precondition: string;
+  testData: string;
+  steps: string[];                     // numbered, one entry per step
+  expectedResults: string[];
+  duration?: number;                   // ms
+  errorMessage?: string;
+  tracePath?: string;
+  executedDate?: string;               // dd/mm/yyyy
+  testEnvironment?: string;
+  testExecutor?: string;
+}
+
+// ----------------------------------------------------------------------------
+// Diff schemas (Phase 2 will populate these in the dashboard UI from history)
+// ----------------------------------------------------------------------------
+
+export interface SnapshotDiff {
+  baseRunId: string;
+  headRunId: string;
+  summary: DiffSummary;
+  screens: ScreenDiff[];
+  tests: TestDiff[];
+}
+
+export interface DiffSummary {
+  added: number;
+  removed: number;
+  newlyPassing: number;
+  newlyFailing: number;
+  statusChanged: number;
+  priorityChanged: number;
+  totalDelta: number;                  // head.total - base.total
+  passRateDelta: number;               // head - base
+}
+
+export interface ScreenDiff {
+  name: string;
+  totalDelta: number;
+  passedDelta: number;
+  failedDelta: number;
+  passRateDelta: number;
+  isNew: boolean;
+  isRemoved: boolean;
+}
+
+export interface TestDiff {
+  tcId: string;
+  screen: string;
+  changeType:
+    | 'added'
+    | 'removed'
+    | 'newly_passing'
+    | 'newly_failing'
+    | 'status_changed'
+    | 'priority_changed'
+    | 'unchanged';
+  baseStatus?: ScenarioSnapshot['status'];
+  headStatus?: ScenarioSnapshot['status'];
+  basePriority?: ScenarioSnapshot['priority'];
+  headPriority?: ScenarioSnapshot['priority'];
+  category1: string;
+}
+
+// ----------------------------------------------------------------------------
+// Wire-format embedded into the HTML template
+// ----------------------------------------------------------------------------
+
+/**
+ * The single payload injected into qa/dashboard/index.html at build time.
+ * Holds the current snapshot plus all retained history runs (max 10).
+ *
+ * The dashboard UI reads `window.__SUNGEN_DASHBOARD__` at boot.
+ */
+export interface DashboardPayload {
+  current: DashboardSnapshot;
+  history: DashboardSnapshot[];        // oldest → newest, current excluded
+}

package/src/exporters/json-exporter.ts

@@ -0,0 +1,162 @@
+/**
+ * Convert merged Gherkin/spec/results data → structured JSON for the dashboard.
+ *
+ * Mirrors csv-exporter's buildTestCaseRows / buildSummary, but emits the
+ * richer ScenarioSnapshot / ScreenSnapshot shape used by the dashboard UI.
+ */
+
+import { MergedScenario } from './scenario-merger';
+import {
+  extractAuthRole,
+  extractPriority,
+  extractTestcaseType,
+  generateTcId,
+  mapVpToCategory2,
+  splitVpAndName,
+} from './feature-parser';
+import { formatPrecondition, cleanStepLine } from './step-formatter';
+import { formatTestData } from './test-data-resolver';
+import {
+  formatExecutedDate,
+  statusToTestResult,
+} from './playwright-report-parser';
+import { EnvironmentInfo, PlaywrightResult } from './types';
+import {
+  ScenarioSnapshot,
+  ScreenSnapshot,
+  ScreenSummaryStats,
+} from '../dashboard/types';
+
+export interface BuildScreenSnapshotInput {
+  screen: string;
+  isFlow: boolean;
+  featureName: string;
+  featurePath?: string;
+  specLink?: string;
+  merged: MergedScenario[];
+  testData: Record<string, string>;
+  results: Map<string, PlaywrightResult> | null;
+  env: EnvironmentInfo;
+}
+
+/**
+ * Build a ScreenSnapshot from merged scenarios.
+ */
+export function buildScreenSnapshot(input: BuildScreenSnapshotInput): ScreenSnapshot {
+  const scenarios: ScenarioSnapshot[] = [];
+  let fallbackIndex = 1;
+
+  for (const m of input.merged) {
+    const { vpId, category1 } = splitVpAndName(m.feature.name);
+    const tcId = generateTcId(input.screen, vpId, fallbackIndex);
+    if (!vpId) fallbackIndex++;
+
+    const category2 = mapVpToCategory2(vpId);
+    const priority = extractPriority(m.feature.tags) as ScenarioSnapshot['priority'];
+    const baseType = extractTestcaseType(m.feature.tags);
+    const authRole = extractAuthRole(m.feature.tags);
+
+    let stepsRaw: string[];
+    let expectedRaw: string[];
+    let givenForPrecondition: string[];
+
+    if (m.spec) {
+      givenForPrecondition = m.spec.precondition;
+      stepsRaw = m.spec.steps;
+      expectedRaw = m.spec.expectations;
+    } else {
+      givenForPrecondition = m.feature.rawGivenSteps;
+      stepsRaw = m.feature.rawWhenSteps;
+      expectedRaw = m.feature.rawThenSteps;
+    }
+
+    const precondition = formatPrecondition(authRole, givenForPrecondition);
+    const steps = stepsRaw.map(cleanStepLine).filter(Boolean);
+    const expectedResults = expectedRaw.map(cleanStepLine).filter(Boolean);
+    const testDataStr = formatTestData(m.feature.referencedVars, input.testData);
+
+    let result: PlaywrightResult | undefined;
+    if (input.results && m.spec) {
+      result = input.results.get(m.spec.testTitle);
+    }
+
+    let status: ScenarioSnapshot['status'];
+    let executedDate: string | undefined;
+    let errorMessage: string | undefined;
+    let tracePath: string | undefined;
+    let testEnvironment: string | undefined;
+    let testExecutor: string | undefined;
+    let type: ScenarioSnapshot['type'];
+
+    if (!m.spec) {
+      type = baseType === 'Manual' ? 'Manual' : 'Not compiled';
+      status = baseType === 'Manual' ? 'Pending' : 'N/A';
+    } else {
+      type = baseType;
+      if (!result) {
+        status = 'Pending';
+      } else {
+        status = statusToTestResult(result.status) as ScenarioSnapshot['status'];
+        executedDate = formatExecutedDate(result.startTime);
+        if (result.error) errorMessage = String(result.error).split('\n')[0].trim();
+        if (result.tracePath) tracePath = result.tracePath;
+        testEnvironment = `${input.env.baseURL} (${input.env.projectName})`;
+        testExecutor = input.env.executor;
+      }
+    }
+
+    scenarios.push({
+      tcId,
+      category1,
+      category2,
+      category3: input.featureName,
+      category4: input.screen,
+      vpId,
+      priority,
+      type,
+      status,
+      tags: m.feature.tags,
+      precondition,
+      testData: testDataStr,
+      steps,
+      expectedResults,
+      executedDate,
+      errorMessage,
+      tracePath,
+      testEnvironment,
+      testExecutor,
+    });
+  }
+
+  return {
+    name: input.screen,
+    isFlow: input.isFlow,
+    featureName: input.featureName,
+    featurePath: input.featurePath,
+    specLink: input.specLink,
+    summary: summarizeScreen(scenarios),
+    scenarios,
+  };
+}
+
+function summarizeScreen(scenarios: ScenarioSnapshot[]): ScreenSummaryStats {
+  const stats: ScreenSummaryStats = {
+    total: scenarios.length,
+    passed: 0,
+    failed: 0,
+    pending: 0,
+    na: 0,
+    notCompiled: 0,
+    passRate: 0,
+  };
+  for (const s of scenarios) {
+    if (s.status === 'Passed') stats.passed++;
+    else if (s.status === 'Failed') stats.failed++;
+    else if (s.status === 'Pending') stats.pending++;
+    else if (s.status === 'N/A') stats.na++;
+    if (s.type === 'Not compiled') stats.notCompiled++;
+  }
+  const executed = stats.passed + stats.failed;
+  stats.passRate = executed > 0 ? stats.passed / executed : 0;
+  return stats;
+}

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

@@ -74,7 +74,11 @@ export function loadPlaywrightReport(reportPath: string): Map<string, Playwright
   const result = new Map<string, PlaywrightResult>();
   for (const [fullTitle, spec] of specMap.entries()) {
     const test = spec.tests?.[0];
-    const res = test?.results?.[0];
+    // With retries enabled, take the LAST attempt — that's the final outcome.
+    // A flaky test (failed once, passed retry) shows as "passed" in the dashboard
+    // because the user-visible end state is "passed".
+    const results = test?.results || [];
+    const res = results[results.length - 1];
     const status = normalizeStatus(res?.status);
     const errorMsg = res?.error?.message || '';
     const trace = res?.attachments?.find((a) => a.name === 'trace' || a.contentType === 'application/zip')?.path;
@@ -141,15 +145,18 @@ export function statusToTestResult(status: PlaywrightResult['status']): string {
 }
 
 /**
- * Format startTime (ISO string) → "dd/mm/yyyy".
+ * Format startTime (ISO string) → "dd/mm/yyyy" in Vietnam time (UTC+7),
+ * so reports stay consistent regardless of where Playwright was executed.
  */
 export function formatExecutedDate(startTime: string | undefined): string {
   if (!startTime) return '';
   const d = new Date(startTime);
   if (isNaN(d.getTime())) return '';
-  const dd = String(d.getDate()).padStart(2, '0');
-  const mm = String(d.getMonth() + 1).padStart(2, '0');
-  const yyyy = d.getFullYear();
+  const VN_OFFSET_MS = 7 * 60 * 60 * 1000;
+  const shifted = new Date(d.getTime() + VN_OFFSET_MS);
+  const dd = String(shifted.getUTCDate()).padStart(2, '0');
+  const mm = String(shifted.getUTCMonth() + 1).padStart(2, '0');
+  const yyyy = shifted.getUTCFullYear();
   return `${dd}/${mm}/${yyyy}`;
 }
 

package/src/exporters/spec-parser.ts

@@ -15,13 +15,18 @@ function extractTestBlock(content: string, startIdx: number): {
   body: string;
   endIdx: number;
 } | null {
-  // Match test('title', async ({ page }) => {
-  const testRegex = /test\s*\(\s*['"]([^'"]+)['"]\s*,\s*async\s*\([^)]*\)\s*=>\s*\{/g;
+  // Match both legacy and tag-pass-through forms:
+  //   test('title', async ({ page }) => {
+  //   test('title', { tag: [...] }, async ({ page }) => {
+  // Backreference \1 lets the inner title contain the opposite quote type
+  // (e.g. test('Footer "X" link', ...) — common when scenarios cite UI labels).
+  const testRegex = /test\s*\(\s*(['"])((?:(?!\1).)+)\1\s*,\s*(?:\{[^}]*\}\s*,\s*)?async\s*\([^)]*\)\s*=>\s*\{/g;
   testRegex.lastIndex = startIdx;
   const match = testRegex.exec(content);
   if (!match) return null;
 
-  const title = match[1];
+  // [1] = outer quote char, [2] = title
+  const title = match[2];
   const bodyStart = match.index + match[0].length;
 
   // Find matching closing brace (accounting for nested braces)

package/src/orchestrator/templates/playwright.config.ts

@@ -28,7 +28,14 @@ export default defineConfig({
   /* Output file path is controlled by PLAYWRIGHT_JSON_OUTPUT_NAME env var for per-screen isolation. */
   reporter: [
     ['html'],
-    ['json', { outputFile: process.env.PLAYWRIGHT_JSON_OUTPUT_NAME || 'test-results/results.json' }],
+    [
+      'json',
+      {
+        outputFile:
+          process.env.PLAYWRIGHT_JSON_OUTPUT_NAME ||
+          'test-results/results.json',
+      },
+    ],
   ],
   /* Shared settings for all the projects below. See https://playwright.dev/docs/api/class-testoptions. */
   use: {
@@ -40,6 +47,9 @@ export default defineConfig({
 
     /* Collect trace when retrying the failed test. See https://playwright.dev/docs/trace-viewer */
     trace: 'on-first-retry',
+
+    /* Capture screenshot after each test failure. */
+    screenshot: 'only-on-failure',
   },
 
   /* Configure projects for major browsers */