@sun-asterisk/sungen 2.4.5 → 2.5.0

package/src/exporters/types.ts

@@ -0,0 +1,112 @@
+/**
+ * Shared types for the delivery exporter.
+ */
+
+/**
+ * Test case row in the final CSV output.
+ */
+export interface TestCaseRow {
+  tcId: string;              // e.g. KUDOS-UI-001
+  category1: string;         // Scenario name (human part)
+  category2: string;         // "Accessing" | "GUI" | "Function"
+  category3: string;         // Feature name (e.g. "Create Kudo Modal")
+  category4: string;         // Screen name (e.g. "kudos")
+  precondition: string;      // Natural language Given + auth
+  testData: string;          // semicolon-separated key: value
+  steps: string;             // numbered steps
+  expectedResults: string;   // numbered expected results
+  priority: string;          // Critical | High | Normal | Low
+  testcaseType: string;      // Auto | Manual | Not compiled
+  testResult: string;        // Passed | Failed | Pending | N/A
+  executedDate: string;      // dd/mm/yyyy
+  testExecutor: string;      // git user.name
+  testEnvironment: string;   // baseURL + project
+  note: string;              // error + trace for failed
+}
+
+/**
+ * Summary stats per screen.
+ */
+export interface ScreenSummary {
+  screen: string;
+  total: number;
+  passed: number;
+  failed: number;
+  pending: number;
+  na: number;
+  notCompiled: number;
+  outputFile: string;
+}
+
+/**
+ * Pre-flight check result for a single screen.
+ */
+export interface PreflightCheck {
+  screen: string;
+  featureOk: boolean;
+  testDataOk: boolean;
+  selectorsOk: boolean;
+  specOk: boolean;
+  resultsOk: boolean;
+  missing: string[];         // Human-readable list of missing items
+  suggestions: string[];     // Suggested commands to run
+}
+
+/**
+ * Metadata extracted from a .feature file.
+ */
+export interface FeatureMetadata {
+  featureName: string;                    // e.g., "Create Kudo Modal"
+  featurePath?: string;                   // e.g., "/kudos"
+  featureTags: string[];                  // Feature-level tags
+  scenarios: ScenarioMetadata[];
+}
+
+export interface ScenarioMetadata {
+  name: string;                           // Full scenario name (with VP prefix)
+  tags: string[];                         // Scenario-level tags (merged with feature tags)
+  stepsName?: string;                     // @steps:<name>
+  extendsName?: string;                   // @extend:<name>
+  referencedVars: string[];               // Variables {{var}} used in this scenario
+  rawGivenSteps: string[];                // Raw Given/And-after-Given step text
+  rawWhenSteps: string[];                 // Raw When/And-after-When step text
+  rawThenSteps: string[];                 // Raw Then/And-after-Then step text
+}
+
+/**
+ * Structure extracted from a compiled .spec.ts test block.
+ */
+export interface SpecTest {
+  describeName: string;                   // test.describe title
+  authRole?: string;                      // nested describe for auth (e.g., "user")
+  testTitle: string;                      // Full Playwright test title (matches results.json)
+  scenarioName: string;                   // Scenario name without VP prefix stripped
+  vpId?: string;                          // Extracted VP-XX-NNN if present
+  precondition: string[];                 // Lines before first // [VP-...] marker
+  steps: string[];                        // Lines between marker and first expect()
+  expectations: string[];                 // Lines with expect() calls
+}
+
+export interface SpecFileData {
+  tests: SpecTest[];
+}
+
+/**
+ * Result from results.json per test.
+ */
+export interface PlaywrightResult {
+  testTitle: string;
+  status: 'passed' | 'failed' | 'skipped' | 'timedOut' | 'interrupted' | 'unknown';
+  startTime?: string;
+  error?: string;
+  tracePath?: string;
+}
+
+/**
+ * Environment metadata.
+ */
+export interface EnvironmentInfo {
+  baseURL: string;
+  projectName: string;
+  executor: string;
+}

package/src/exporters/xlsx-exporter.ts

@@ -0,0 +1,301 @@
+/**
+ * Render the same rows/summary the CSV exporter produces into a styled .xlsx
+ * workbook. Keeps the BM-2-901-13 layout but adds:
+ *   - bold header row with filled background + white font
+ *   - borders on the data region
+ *   - text wrapping in Steps / Expected / Pre-condition / Test Data
+ *   - frozen header so the first data rows stay aligned with the title row
+ *   - sensible column widths
+ *   - category-separator rows rendered as a filled bar spanning the table
+ */
+
+import * as fs from 'fs';
+import * as path from 'path';
+import ExcelJS from 'exceljs';
+import { ScreenSummary, TestCaseRow } from './types';
+import { getPackageVersion } from './package-info';
+
+const COL_COUNT = 16;
+const HEADER_FILL = 'FF1F4E78'; // deep blue band
+const HEADER_FONT = 'FFFFFFFF';
+const META_FILL = 'FFDCE6F1'; // soft blue for meta rows
+const CATEGORY_FILL = 'FFFFF2CC'; // soft yellow for group dividers
+const BORDER_COLOR = 'FFBFBFBF';
+
+type AnyCell = ExcelJS.Cell;
+type AnyRow = ExcelJS.Row;
+
+function applyBorder(cell: AnyCell): void {
+  cell.border = {
+    top: { style: 'thin', color: { argb: BORDER_COLOR } },
+    left: { style: 'thin', color: { argb: BORDER_COLOR } },
+    bottom: { style: 'thin', color: { argb: BORDER_COLOR } },
+    right: { style: 'thin', color: { argb: BORDER_COLOR } },
+  };
+}
+
+export function renderXlsx(
+  summary: ScreenSummary,
+  rows: TestCaseRow[],
+  specLink: string
+): ExcelJS.Workbook {
+  const wb = new ExcelJS.Workbook();
+  wb.creator = 'sungen delivery';
+  wb.created = new Date();
+  const ws = wb.addWorksheet('Testcases', {
+    views: [{ state: 'frozen', ySplit: 0, xSplit: 0 }],
+  });
+
+  const issueDate = (() => {
+    const d = new Date();
+    return `${String(d.getDate()).padStart(2, '0')}/${String(d.getMonth() + 1).padStart(2, '0')}/${d.getFullYear()}`;
+  })();
+
+  const total = summary.total || 1;
+  const pct = (n: number) => `${Math.round((n / total) * 100)}%`;
+
+  // -- Column widths (matches CSV column order) --
+  ws.columns = [
+    { width: 18 }, // TC ID
+    { width: 42 }, // Category 1
+    { width: 14 }, // Category 2
+    { width: 26 }, // Category 3
+    { width: 14 }, // Category 4
+    { width: 36 }, // Pre-condition
+    { width: 30 }, // Test Data
+    { width: 46 }, // Steps
+    { width: 52 }, // Expected results
+    { width: 10 }, // Priority
+    { width: 14 }, // Testcase type
+    { width: 14 }, // Test Result
+    { width: 14 }, // Executed Date
+    { width: 16 }, // Test Executor
+    { width: 38 }, // Test Environment
+    { width: 40 }, // Note
+  ];
+
+  // -- Top metadata band (rows 1-4) --
+  const titleLabel = `${summary.screen.toUpperCase()} TESTCASE`;
+  const titleRow = ws.addRow(['', '', '', titleLabel, '', '', 'No: BM-2-901-13']);
+  titleRow.getCell(4).font = { bold: true, size: 16 };
+  titleRow.getCell(4).alignment = { horizontal: 'center', vertical: 'middle' };
+  ws.mergeCells(titleRow.number, 4, titleRow.number, 6);
+  titleRow.getCell(7).font = { bold: true };
+  titleRow.height = 22;
+
+  const versionRow = ws.addRow(['', '', '', '', '', '', `Version: ${getPackageVersion()}`]);
+  versionRow.getCell(7).font = { bold: true };
+  const dateRow = ws.addRow(['', '', '', '', '', '', `Issue Date: ${issueDate}`]);
+  dateRow.getCell(7).font = { bold: true };
+  const companyRow = ws.addRow([
+    'SUN ASTERISK VIETNAM CO., LTD',
+    '',
+    '',
+    '',
+    '',
+    '',
+    'ISO/IEC 27001:2022 & ISO 9001:2015',
+  ]);
+  companyRow.getCell(1).font = { bold: true };
+  companyRow.getCell(7).font = { bold: true };
+
+  ws.addRow([]); // spacer
+
+  // -- Summary band --
+  const summaryHeader = ws.addRow([
+    '',
+    '',
+    'Total TCs',
+    'Passed',
+    'Failed',
+    'Pending',
+    'N/A',
+    'Remaining',
+  ]);
+  for (let i = 3; i <= 8; i++) {
+    const c = summaryHeader.getCell(i);
+    c.font = { bold: true, color: { argb: HEADER_FONT } };
+    c.fill = { type: 'pattern', pattern: 'solid', fgColor: { argb: HEADER_FILL } };
+    c.alignment = { horizontal: 'center', vertical: 'middle' };
+    applyBorder(c);
+  }
+
+  const summaryCounts = ws.addRow([
+    '',
+    '',
+    summary.total,
+    summary.passed,
+    summary.failed,
+    summary.pending,
+    summary.na,
+    summary.pending + summary.na,
+  ]);
+  for (let i = 3; i <= 8; i++) {
+    const c = summaryCounts.getCell(i);
+    c.font = { bold: true };
+    c.alignment = { horizontal: 'center' };
+    c.fill = { type: 'pattern', pattern: 'solid', fgColor: { argb: META_FILL } };
+    applyBorder(c);
+  }
+
+  const summaryPct = ws.addRow([
+    '',
+    '',
+    '',
+    pct(summary.passed),
+    pct(summary.failed),
+    pct(summary.pending),
+    pct(summary.na),
+    pct(summary.pending + summary.na),
+  ]);
+  for (let i = 4; i <= 8; i++) {
+    const c = summaryPct.getCell(i);
+    c.alignment = { horizontal: 'center' };
+    c.fill = { type: 'pattern', pattern: 'solid', fgColor: { argb: META_FILL } };
+    applyBorder(c);
+  }
+
+  ws.addRow([]); // spacer
+
+  const specRow = ws.addRow(['Spec/Design link:', specLink]);
+  specRow.getCell(1).font = { bold: true };
+  specRow.getCell(2).font = { color: { argb: 'FF1F4E78' }, underline: true };
+
+  ws.addRow([]); // spacer
+
+  const legendRow = ws.addRow(['*: Mandatory']);
+  legendRow.getCell(1).font = { italic: true, color: { argb: 'FF808080' } };
+
+  // -- Column header row (bold, filled, wrapped) --
+  const headerRow = ws.addRow([
+    'TC ID*',
+    '{Category 1}',
+    '{Category 2}',
+    '{Category 3}',
+    '{Category 4}',
+    'Pre-condition',
+    'Test Data',
+    'Steps*',
+    'Expected results*',
+    'Priority',
+    'Testcase type',
+    'Test Result*',
+    'Executed Date*',
+    'Test Executor*',
+    'Test Environment',
+    'Note\n(Test evidence, DefectID, Actual result)',
+  ]);
+  headerRow.height = 38;
+  headerRow.eachCell((cell) => {
+    cell.font = { bold: true, color: { argb: HEADER_FONT } };
+    cell.fill = { type: 'pattern', pattern: 'solid', fgColor: { argb: HEADER_FILL } };
+    cell.alignment = { horizontal: 'center', vertical: 'middle', wrapText: true };
+    applyBorder(cell);
+  });
+
+  // Freeze everything above and below the header row — reveal header when scrolling.
+  ws.views = [{ state: 'frozen', ySplit: headerRow.number }];
+
+  // -- Data rows grouped by category --
+  const order = ['Accessing', 'GUI', 'Function'];
+  const grouped = new Map<string, TestCaseRow[]>();
+  for (const r of rows) {
+    const g = grouped.get(r.category2) || [];
+    g.push(r);
+    grouped.set(r.category2, g);
+  }
+  const emittedGroups = new Set<string>();
+
+  function emitGroup(groupName: string, groupRows: TestCaseRow[]): void {
+    const divider = ws.addRow(['', groupName]);
+    divider.getCell(2).font = { bold: true };
+    divider.eachCell({ includeEmpty: false }, (cell) => {
+      cell.fill = { type: 'pattern', pattern: 'solid', fgColor: { argb: CATEGORY_FILL } };
+    });
+    // Fill the full width so the band spans the whole table
+    for (let i = 1; i <= COL_COUNT; i++) {
+      const c = divider.getCell(i);
+      c.fill = { type: 'pattern', pattern: 'solid', fgColor: { argb: CATEGORY_FILL } };
+      applyBorder(c);
+    }
+
+    for (const r of groupRows) {
+      const row = ws.addRow([
+        r.tcId,
+        r.category1,
+        '',
+        '',
+        '',
+        r.precondition,
+        r.testData,
+        r.steps,
+        r.expectedResults,
+        r.priority,
+        r.testcaseType,
+        r.testResult,
+        r.executedDate,
+        r.testExecutor,
+        r.testEnvironment,
+        r.note,
+      ]);
+      row.alignment = { vertical: 'top', wrapText: true };
+      row.eachCell({ includeEmpty: true }, (cell, colNumber) => {
+        applyBorder(cell);
+        if (colNumber === 1) {
+          cell.font = { bold: true };
+        }
+        if (colNumber === 12) {
+          // Test Result — colour-code
+          const val = String(cell.value || '');
+          if (val === 'Passed') {
+            cell.font = { color: { argb: 'FF107C41' }, bold: true };
+          } else if (val === 'Failed') {
+            cell.font = { color: { argb: 'FFC00000' }, bold: true };
+          } else if (val === 'Pending') {
+            cell.font = { color: { argb: 'FF996D00' }, bold: true };
+          } else if (val === 'N/A') {
+            cell.font = { color: { argb: 'FF808080' } };
+          }
+        }
+      });
+    }
+  }
+
+  for (const groupName of order) {
+    const groupRows = grouped.get(groupName);
+    if (!groupRows || groupRows.length === 0) continue;
+    emittedGroups.add(groupName);
+    emitGroup(groupName, groupRows);
+  }
+  for (const [groupName, groupRows] of grouped.entries()) {
+    if (emittedGroups.has(groupName)) continue;
+    emitGroup(groupName, groupRows);
+  }
+
+  // Auto-filter on the header row so QA can filter by result / priority / category
+  ws.autoFilter = {
+    from: { row: headerRow.number, column: 1 },
+    to: { row: ws.rowCount, column: COL_COUNT },
+  };
+
+  return wb;
+}
+
+/**
+ * Write the workbook to `qa/deliverables/<screen>-testcases.xlsx`.
+ * Directory is created on demand. Returns the absolute output path.
+ */
+export async function writeXlsx(
+  cwd: string,
+  screen: string,
+  wb: ExcelJS.Workbook
+): Promise<string> {
+  const outDir = path.join(cwd, 'qa', 'deliverables');
+  if (!fs.existsSync(outDir)) fs.mkdirSync(outDir, { recursive: true });
+  const outPath = path.join(outDir, `${screen}-testcases.xlsx`);
+  await wb.xlsx.writeFile(outPath);
+  return outPath;
+}
+
+void applyBorder;
+void ({} as AnyRow);

package/src/generators/gherkin-parser/index.ts

@@ -34,6 +34,7 @@ export interface ParsedScenario {
   steps: ParsedStep[];
   stepsName?: string;   // set when scenario has @steps:<name> — marks it as a reusable block
   extendsName?: string; // set when scenario has @extend:<name> — merges base steps inline
+  hookType?: 'beforeAll' | 'afterEach' | 'afterAll'; // set when scenario has @beforeAll/@afterEach/@afterAll
 }
 
 export interface ParsedFeature {
@@ -120,12 +121,15 @@ export class GherkinParser {
         const tags = scenario.tags.map((tag) => tag.name);
         const stepsName = tags.find(t => t.startsWith('@steps:'))?.replace('@steps:', '') || undefined;
         const extendsName = tags.find(t => t.startsWith('@extend:'))?.replace('@extend:', '') || undefined;
+        const hookTag = tags.find(t => /^@(beforeAll|afterEach|afterAll)$/.test(t));
+        const hookType = hookTag?.replace('@', '') as ParsedScenario['hookType'];
         return {
           name: scenario.name,
           tags,
           steps: scenario.steps.map((step) => this.parseStep(step)),
           stepsName,
           extendsName,
+          hookType,
         };
       });
   }

package/src/generators/test-generator/adapters/adapter-interface.ts

@@ -13,6 +13,14 @@ export interface TestFileData {
   featureName: string;
   featureDescription?: string;
   background?: string;
+  beforeAll?: string;
+  afterEach?: string;
+  afterAll?: string;
+  cleanupConfig?: string; // Pre-formatted autoCleanup config from @cleanup:* tags
+  screenshotOnFailure?: boolean; // @screenshot:on-failure tag
+  runtimeData?: boolean; // --runtime-data flag: testData.get() instead of hardcoded values
+  screenName?: string; // Screen name for TestDataLoader.load()
+  featureFileName?: string; // Feature file name for TestDataLoader.load()
   scenarios: string[];
   authGroups?: AuthGroup[]; // Grouped by auth role for nested describes
   singleAuthRole?: string;  // Auth role when all scenarios share the same role
@@ -49,8 +57,11 @@ export interface TestGeneratorAdapter {
   // Template rendering methods
   renderTestFile(data: TestFileData): string;
   renderScenario(data: ScenarioData): string;
-  renderImports(): string;
+  renderImports(options?: { runtimeData?: boolean }): string;
   renderBeforeEach(data: { steps: Array<{ comment?: string; code: string }> }): string;
+  renderBeforeAll(data: { steps: Array<{ comment?: string; code: string }> }): string;
+  renderAfterEach(data: { steps: Array<{ comment?: string; code: string }> }): string;
+  renderAfterAll(data: { steps: Array<{ comment?: string; code: string }> }): string;
 
   // Step rendering
   renderStep(templateName: string, data: any): string;

package/src/generators/test-generator/adapters/playwright/playwright-adapter.ts

@@ -26,14 +26,26 @@ export class PlaywrightAdapter implements TestGeneratorAdapter {
     return this.templateEngine.renderScenario(data);
   }
 
-  renderImports(): string {
-    return this.templateEngine.renderImports();
+  renderImports(options?: { runtimeData?: boolean }): string {
+    return this.templateEngine.renderImports(options);
   }
 
   renderBeforeEach(data: { steps: Array<{ comment?: string; code: string }> }): string {
     return this.templateEngine.renderBeforeEach(data);
   }
 
+  renderBeforeAll(data: { steps: Array<{ comment?: string; code: string }> }): string {
+    return this.templateEngine.renderBeforeAll(data);
+  }
+
+  renderAfterEach(data: { steps: Array<{ comment?: string; code: string }> }): string {
+    return this.templateEngine.renderAfterEach(data);
+  }
+
+  renderAfterAll(data: { steps: Array<{ comment?: string; code: string }> }): string {
+    return this.templateEngine.renderAfterAll(data);
+  }
+
   renderStep(templateName: string, data: any): string {
     return this.templateEngine.renderStep(templateName, data);
   }

package/src/generators/test-generator/adapters/playwright/templates/after-all.hbs

@@ -0,0 +1,8 @@
+  test.afterAll(async ({ request }) => {
+{{#each steps}}
+{{#if comment}}
+    // {{comment}}
+{{/if}}
+{{code}}
+{{/each}}
+  });

package/src/generators/test-generator/adapters/playwright/templates/after-each.hbs

@@ -0,0 +1,8 @@
+  test.afterEach(async ({ page }) => {
+{{#each steps}}
+{{#if comment}}
+    // {{comment}}
+{{/if}}
+{{code}}
+{{/each}}
+  });

package/src/generators/test-generator/adapters/playwright/templates/before-all.hbs

@@ -0,0 +1,8 @@
+  test.beforeAll(async ({ request }) => {
+{{#each steps}}
+{{#if comment}}
+    // {{comment}}
+{{/if}}
+{{code}}
+{{/each}}
+  });

package/src/generators/test-generator/adapters/playwright/templates/imports.hbs

@@ -1,4 +1,7 @@
 import { test, expect } from '../base';
+{{#if runtimeData}}
+import { TestDataLoader } from '../test-data';
+{{/if}}
 
 // This file is auto-generated from Gherkin feature files
 // DO NOT EDIT MANUALLY - changes will be overwritten

package/src/generators/test-generator/adapters/playwright/templates/test-file.hbs

@@ -1,4 +1,8 @@
 {{imports}}
+{{#if runtimeData}}
+
+const testData = TestDataLoader.load('{{screenName}}', '{{featureFileName}}');
+{{/if}}
 
 {{#if featureDescription}}
 /**
@@ -11,10 +15,30 @@ test.describe('{{featureName}}', () => {
 {{#if singleAuthRole}}
   test.use({ storageState: 'specs/.auth/{{singleAuthRole}}.json' });
 
+{{/if}}
+{{#if cleanupConfig}}
+  test.use({ autoCleanup: { {{cleanupConfig}} } });
+
+{{/if}}
+{{#if screenshotOnFailure}}
+  test.use({ screenshotOnFailure: true });
+
+{{/if}}
+{{#if beforeAll}}
+{{beforeAll}}
+
 {{/if}}
 {{#if background}}
 {{background}}
 
+{{/if}}
+{{#if afterEach}}
+{{afterEach}}
+
+{{/if}}
+{{#if afterAll}}
+{{afterAll}}
+
 {{/if}}
 {{#if authGroups}}
 {{#each authGroups}}