dceky 1.0.5-beta.ky-declarations.12 → 1.0.5

package/start/helpers/generateReportHomepage.ts

@@ -0,0 +1,148 @@
+/* eslint-disable no-console */
+import fs from 'fs';
+import path from 'path';
+import ejs from 'ejs';
+
+// Import helpers
+import collectPngFiles from './collectPngFiles';
+
+// Import types
+import ReportInfo from '../types/ReportInfo';
+import ScreenshotInfo from '../types/ScreenshotInfo';
+import TemplateReportInfo from '../types/TemplateReportInfo';
+
+/**
+ * Generate an HTML homepage that links to all reports
+ * @author Yuen Ler Chow
+ * @param reports - Array of report information
+ * @param outputDir - The directory where the homepage should be created
+ */
+const generateReportHomepage = (
+  reports: ReportInfo[],
+  outputDir: string,
+): void => {
+  const homepagePath = path.join(outputDir, 'index.html');
+  const combinedReportPath = path.join(outputDir, 'all-runs.html');
+  const combinedJsonPath = path.join(outputDir, 'all-report-data.json');
+
+  const hasCombinedReport = fs.existsSync(combinedReportPath);
+
+  // Try to read combined stats from all-report-data.json
+  let combinedTotalTests: number | null = null;
+  let combinedPassedTests: number | null = null;
+  if (fs.existsSync(combinedJsonPath)) {
+    try {
+      const raw = fs.readFileSync(combinedJsonPath, 'utf-8');
+      const data = JSON.parse(raw);
+      const stats = (data && data.stats) || null;
+      if (stats && typeof stats.tests === 'number' && typeof stats.passes === 'number') {
+        combinedTotalTests = stats.tests;
+        combinedPassedTests = stats.passes;
+      }
+    } catch (err) {
+      // File exists but couldn't be read/parsed - log warning
+      console.warn('⚠️ Could not read combined stats:', err);
+    }
+  }
+
+  // Try to read per-combination stats from each combo's report-data.json
+  reports.forEach((report) => {
+    const comboJsonPath = path.join(
+      outputDir,
+      `${report.profileName}-${report.browser}`,
+      'report-data.json',
+    );
+    if (!fs.existsSync(comboJsonPath)) {
+      return;
+    }
+    try {
+      const raw = fs.readFileSync(comboJsonPath, 'utf-8');
+      const data = JSON.parse(raw);
+      const stats = (data && data.stats) || null;
+      if (stats && typeof stats.tests === 'number' && typeof stats.passes === 'number') {
+        // eslint-disable-next-line no-param-reassign
+        report.totalTests = stats.tests;
+        // eslint-disable-next-line no-param-reassign
+        report.passedTests = stats.passes;
+      }
+    } catch (err) {
+      // File exists but couldn't be read/parsed - log warning
+      console.warn(`⚠️ Could not read stats for ${report.profileName}-${report.browser}:`, err);
+    }
+  });
+
+  // Sort reports by profile name, then browser
+  const sortedReports = [...reports].sort((a, b) => {
+    if (a.profileName !== b.profileName) {
+      return a.profileName.localeCompare(b.profileName);
+    }
+    return a.browser.localeCompare(b.browser);
+  });
+
+  // Prepare reports with computed fields for the template
+  const templateReports: TemplateReportInfo[] = sortedReports.map((report) => {
+    // Compute relative report path
+    let relativeReportPath: string | null = null;
+    if (report.reportPath && fs.existsSync(report.reportPath)) {
+      relativeReportPath = path.relative(outputDir, report.reportPath).replace(/\\/g, '/');
+    }
+
+    // Collect screenshots
+    const screenshots: ScreenshotInfo[] = [];
+    const comboScreenshotsDir = path.join(
+      outputDir,
+      `${report.profileName}-${report.browser}`,
+      'screenshots',
+    );
+    if (fs.existsSync(comboScreenshotsDir)) {
+      const pngFiles = collectPngFiles(comboScreenshotsDir);
+      pngFiles.forEach((rel) => {
+        const href = path
+          .relative(outputDir, path.join(comboScreenshotsDir, rel))
+          .replace(/\\/g, '/');
+        screenshots.push({ href, name: rel });
+      });
+    }
+
+    return {
+      ...report,
+      relativeReportPath,
+      screenshots,
+    };
+  });
+
+  // Group by profile
+  const reportsByProfile: { [key: string]: TemplateReportInfo[] } = {};
+  templateReports.forEach((report) => {
+    if (!reportsByProfile[report.profileName]) {
+      reportsByProfile[report.profileName] = [];
+    }
+    reportsByProfile[report.profileName].push(report);
+  });
+
+  // Calculate summary stats
+  const totalRuns = reports.length;
+  const passedRuns = reports.filter((r) => { return r.success; }).length;
+  const failedRuns = reports.filter((r) => { return !r.success; }).length;
+  const profileCount = Object.keys(reportsByProfile).length;
+
+  // Load and render EJS template
+  const templatePath = path.join(__dirname, 'reportHomepage.ejs');
+  const templateFile = fs.readFileSync(templatePath, 'utf-8');
+  const html = ejs.render(templateFile, {
+    hasCombinedReport,
+    combinedTotalTests,
+    combinedPassedTests,
+    totalRuns,
+    passedRuns,
+    failedRuns,
+    profileCount,
+    reportsByProfile,
+  });
+
+  // Write the HTML file
+  fs.writeFileSync(homepagePath, html, 'utf-8');
+  console.log(`\n📄 Report homepage generated: ${homepagePath}`);
+};
+
+export default generateReportHomepage;

package/start/helpers/generateReporterConfig.ts

@@ -0,0 +1,39 @@
+import path from 'path';
+import MochawesomeReporterConfig from '../types/MochawesomeReporterConfig';
+
+/**
+ * Generate inline reporter configuration for cypress-multi-reporters
+ * that produces granular mochawesome JSON per spec
+ * @author Yuen Ler Chow
+ * @param opts - object of arguments
+ * @param opts.resultsDir - Base directory for results
+ * @param opts.profileName - Profile name
+ * @param opts.browserName - Browser name
+ * @returns Reporter config object
+ */
+const generateReporterConfig = (opts: {
+  resultsDir: string;
+  profileName: string;
+  browserName: string;
+}): MochawesomeReporterConfig => {
+  const { resultsDir, profileName, browserName } = opts;
+
+  const granularResultsDir = path.join(
+    resultsDir,
+    `${profileName}-${browserName}`,
+    'granular-results',
+  );
+
+  return {
+    reporterEnabled: 'mochawesome',
+    mochawesomeReporterOptions: {
+      reportDir: granularResultsDir,
+      reportFilename: 'test-[name]',
+      overwrite: false,
+      html: false,
+      json: true,
+    },
+  };
+};
+
+export default generateReporterConfig;

package/start/helpers/getDateLabeledDir.ts

@@ -0,0 +1,43 @@
+import path from 'path';
+import getRootPath from './getRootPath';
+
+/**
+ * Get a date-labeled directory path for results using Eastern Time
+ * @author Yuen Ler Chow
+ * @returns path to date-labeled directory (e.g., cypress-results/2024-1-15_3-05pm)
+ */
+const getDateLabeledDir = (): string => {
+  const root = getRootPath();
+  const now = new Date();
+
+  // Format date in Eastern Time
+  const str = now.toLocaleString(
+    'en-US', // Using US encoding (it's the only one installed on containers)
+    { timeZone: 'America/New_York' }, // Force EST timezone
+  );
+
+  // Parse the string for the date/time info
+  const [dateStr, timeStr] = str.split(', '); // Format: MM/DD/YYYY, HH:MM:SS AM
+  const [monthStr, dayStr, yearStr] = dateStr.split('/'); // Format: MM/DD/YYYY
+  const [hourStr, minStr, ending] = timeStr.split(':'); // Format: HH:MM:SS AM
+
+  // Create all time numbers
+  const year = Number.parseInt(yearStr, 10);
+  const month = Number.parseInt(monthStr, 10);
+  const day = Number.parseInt(dayStr, 10);
+  const minute = Number.parseInt(minStr, 10);
+  const hour12 = Number.parseInt(hourStr, 10);
+
+  // Determine AM/PM
+  const isAM = ending.toLowerCase().includes('am');
+
+  // Pad minute with leading zero if needed
+  const minutePadded = minute.toString().padStart(2, '0');
+
+  // Build formatted date string: YYYY-M-D_H-MMam/pm (no spaces for shell compatibility)
+  const formattedDate = `${year}-${month}-${day}_${hour12}-${minutePadded}${isAM ? 'am' : 'pm'}`;
+
+  return path.join(root, 'cypress-results', formattedDate);
+};
+
+export default getDateLabeledDir;

package/start/helpers/mergeAllReportsAndGenerateHtml.ts

@@ -0,0 +1,150 @@
+/* eslint-disable no-console */
+
+// Import libs
+import { execSync } from 'child_process';
+import fs from 'fs';
+import path from 'path';
+
+// Import helpers
+import getRootPath from './getRootPath';
+import RunResult from '../types/RunResult';
+
+/**
+ * Recursively annotate mochawesome suites (not individual tests) with a label
+ * so the combined report shows profile+browser for each suite
+ * @author Yuen Ler Chow
+ * @param node - The mochawesome node to annotate
+ * @param label - The label to prepend to suite titles
+ */
+const annotateMochawesomeSuites = (node: any, label: string): void => {
+  if (!node || typeof node !== 'object') {
+    return;
+  }
+
+  // If this is an array of nodes, annotate each element
+  if (Array.isArray(node)) {
+    node.forEach((child: any) => {
+      annotateMochawesomeSuites(child, label);
+    });
+    return;
+  }
+
+  // Only annotate if this is a suite (has suites or tests arrays)
+  const isSuite = Array.isArray(node.suites) || Array.isArray(node.tests);
+  if (isSuite) {
+    if (typeof node.title === 'string') {
+      // eslint-disable-next-line no-param-reassign
+      node.title = `${label}${node.title}`;
+    }
+    if (typeof node.fullTitle === 'string') {
+      // eslint-disable-next-line no-param-reassign
+      node.fullTitle = `${label}${node.fullTitle}`;
+    }
+  }
+
+  // Recurse into child suites (but not tests)
+  if (Array.isArray(node.suites)) {
+    node.suites.forEach((suite: any) => {
+      annotateMochawesomeSuites(suite, label);
+    });
+  }
+};
+
+/**
+ * Merge all per-combination mochawesome JSON reports into a single JSON
+ * and generate one combined HTML report for all runs.
+ * Each suite/test is annotated with [profile][browser] in its title.
+ * @author Yuen Ler Chow
+ * @param outputDir - Date-labeled results directory
+ * @param results - Array of run results
+ */
+const mergeAllReportsAndGenerateHtml = (
+  outputDir: string,
+  results: RunResult[],
+): void => {
+  // Collect annotated copies of report-data.json files from successful runs
+  const annotatedJsonPaths: string[] = [];
+
+  results.forEach((result) => {
+    const jsonPath = path.join(
+      outputDir,
+      `${result.profileName}-${result.browser}`,
+      'report-data.json',
+    );
+    if (!fs.existsSync(jsonPath)) {
+      return;
+    }
+
+    try {
+      // Import the json report
+      const raw = fs.readFileSync(jsonPath, 'utf-8');
+      const data = JSON.parse(raw);
+      const label = `[${result.profileName}][${result.browser}] `;
+
+      if (Array.isArray(data.results)) {
+        data.results.forEach((res: any) => {
+          if (res && res.suites) {
+            annotateMochawesomeSuites(res.suites, label);
+          }
+        });
+      }
+
+      // Annotate tests with their profile+browser
+      const annotatedPath = path.join(
+        outputDir,
+        `${result.profileName}-${result.browser}-labeled.json`,
+      );
+      fs.writeFileSync(annotatedPath, JSON.stringify(data, null, 2), 'utf-8');
+      annotatedJsonPaths.push(annotatedPath);
+    } catch (e) {
+      console.error(`Error annotating report for ${result.profileName} + ${result.browser}:`, e);
+    }
+  });
+
+  if (annotatedJsonPaths.length === 0) {
+    console.warn('No annotated report-data.json files found. Skipping global merge.');
+    return;
+  }
+
+  const allReportDataPath = path.join(outputDir, 'all-report-data.json');
+  const allReportHtmlDir = outputDir;
+
+  try {
+    // Build mochawesome-merge command with all annotated JSON paths
+    const mergedArgs = (
+      annotatedJsonPaths
+        .map((p) => {
+          return `"${p}"`;
+        })
+        .join(' ')
+    );
+    const mergeCommand = `npx mochawesome-merge ${mergedArgs} > "${allReportDataPath}"`;
+
+    console.log('Merging all annotated report-data.json files into a single JSON for all runs...');
+
+    execSync(mergeCommand, {
+      stdio: 'inherit',
+      cwd: getRootPath(),
+      shell: '/bin/bash',
+    });
+
+    // Generate combined HTML using marge
+    const margeCommand = `npx marge "${allReportDataPath}" --reportDir "${allReportHtmlDir}" --reportFilename "all-runs"`;
+
+    console.log('Generating combined HTML report for all runs...');
+
+    execSync(
+      margeCommand,
+      {
+        stdio: 'inherit',
+        cwd: getRootPath(),
+      },
+    );
+
+    console.log(`Combined HTML report generated at: ${path.join(allReportHtmlDir, 'all-runs.html')}`);
+  } catch (e) {
+    console.error('Error generating combined HTML report for all runs:', e);
+  }
+};
+
+export default mergeAllReportsAndGenerateHtml;

package/start/helpers/mergeReports.ts

@@ -0,0 +1,82 @@
+/* eslint-disable no-console */
+import { execSync } from 'child_process';
+import path from 'path';
+import { existsSync, readdirSync } from 'fs';
+import getRootPath from './getRootPath';
+
+/**
+ * Merge mochawesome JSON reports into a single JSON file using mochawesome-merge
+ * @author Yuen Ler Chow
+ * @param opts - object of arguments
+ * @param opts.resultsDir - Results directory containing the reports
+ * @param opts.profileName - Profile name
+ * @param opts.browserName - Browser name
+ */
+const mergeReports = (
+  opts: {
+    resultsDir: string;
+    profileName: string;
+    browserName: string;
+  },
+): void => {
+  const { resultsDir, profileName, browserName } = opts;
+
+  const granularResultsDir = path.join(
+    resultsDir,
+    `${profileName}-${browserName}`,
+    'granular-results',
+  );
+  const reportDataPath = path.join(
+    resultsDir,
+    `${profileName}-${browserName}`,
+    'report-data.json',
+  );
+
+  console.log(`\n📊 Merge Reports Debug for ${profileName} + ${browserName}:`);
+  console.log(`   Granular results dir: ${granularResultsDir}`);
+  console.log(`   Report data path: ${reportDataPath}`);
+
+  if (!existsSync(granularResultsDir)) {
+    const errorMsg = `❌ ERROR: Granular results directory does not exist: ${granularResultsDir}`;
+    console.error(errorMsg);
+    throw new Error(errorMsg);
+  }
+
+  // List files in granular results directory
+  const files = readdirSync(granularResultsDir);
+  const jsonFiles = files.filter((f) => { return f.endsWith('.json'); });
+  console.log(`   Found ${jsonFiles.length} JSON files: ${jsonFiles.join(', ') || '(none)'}`);
+
+  if (jsonFiles.length === 0) {
+    const errorMsg = `❌ ERROR: No JSON files found in granular results directory: ${granularResultsDir}`;
+    console.error(errorMsg);
+    throw new Error(errorMsg);
+  }
+
+  try {
+    const command = `npx mochawesome-merge "${path.join(granularResultsDir, '*.json')}" > "${reportDataPath}"`;
+
+    console.log(`   Running: ${command}`);
+    console.log(`Merging reports for ${profileName} + ${browserName}...`);
+
+    execSync(command, {
+      stdio: 'inherit',
+      cwd: getRootPath(),
+      shell: '/bin/bash',
+    });
+
+    // Verify the report was created
+    if (!existsSync(reportDataPath)) {
+      const errorMsg = `❌ ERROR: Report data was not created at: ${reportDataPath}`;
+      console.error(errorMsg);
+      throw new Error(errorMsg);
+    }
+
+    console.log(`   ✅ Report data created successfully at: ${reportDataPath}`);
+  } catch (e) {
+    console.error(`Error merging reports for ${profileName} + ${browserName}:`, e);
+    throw e;
+  }
+};
+
+export default mergeReports;