add codeCoverageSummary.ts and change testResultsSummary.ts to add the view in between

Author: taguptamw

src/codeCoverageSummary.ts

@@ -0,0 +1,100 @@
+
+import * as core from "@actions/core";
+import { readFileSync, existsSync } from "fs";
+import * as path from "path";
+
+interface CoverageMetric {
+    Executed: number;
+    Total: number;
+    Percentage: number;
+}
+
+interface CoverageData {
+    MetricLevel?: string;
+    StatementCoverage?: CoverageMetric;  // Made optional with ?
+    FunctionCoverage?: CoverageMetric;   // Made optional with ?
+    DecisionCoverage?: CoverageMetric;   // Made optional with ?
+    ConditionCoverage?: CoverageMetric;  // Made optional with ?
+    MCDCCoverage?: CoverageMetric;       // Made optional with ?
+}
+
+export function getCoverageData(): CoverageData | null {
+    const runnerTemp = process.env.RUNNER_TEMP || "";
+    const runId = process.env.GITHUB_RUN_ID || "";
+    const coveragePath = path.join(runnerTemp, `matlabCoverageResults${runId}.json`);
+    
+    core.info(`Looking for coverage at: ${coveragePath}`);
+    
+    if (!existsSync(coveragePath)) {
+        core.info("No coverage data found");
+        return null;
+    }
+
+    try {
+        const coverageData: CoverageData[] = JSON.parse(readFileSync(coveragePath, "utf8"));
+        if (!coverageData || coverageData.length === 0) {
+            core.info("Coverage data is empty");
+            return null;
+        }
+        return coverageData[coverageData.length - 1];
+    } catch (error) {
+        core.error(`Error reading coverage data: ${error}`);
+        return null;
+    }
+}
+
+function formatPercentage(percentage: number): string {
+    if (percentage === null || percentage === undefined || isNaN(percentage)) {
+        return '0.00%';
+    }
+    return percentage.toFixed(2) + '%';
+}
+
+export function generateCoverageTableHTML(coverage: CoverageData): string {
+    try {
+        core.info(`Generating coverage table for metric level: ${coverage.MetricLevel}`);
+        
+        // Define all possible columns
+        const allColumns = [
+            { name: 'Statement', data: coverage.StatementCoverage },
+            { name: 'Function', data: coverage.FunctionCoverage },
+            { name: 'Decision', data: coverage.DecisionCoverage },
+            { name: 'Condition', data: coverage.ConditionCoverage },
+            { name: 'MC/DC', data: coverage.MCDCCoverage }
+        ];
+
+        // Filter to only include columns where data actually exists
+        const visibleColumns = allColumns.filter(col => col.data !== undefined && col.data !== null);
+
+        if (visibleColumns.length === 0) {
+            core.warning('No visible columns found');
+            return '<p>No coverage data available</p>';
+        }
+
+        core.info(`Visible columns: ${visibleColumns.map(c => c.name).join(', ')}`);
+
+        // Build header row
+        const headers = visibleColumns.map(col => `<th>${col.name}</th>`).join('');
+        const headerRow = `<tr align="center"><th>Metric</th>${headers}</tr>`;
+
+        // Build percentage row
+        const percentages = visibleColumns.map(col => 
+            `<td>${formatPercentage(col.data!.Percentage)}</td>`
+        ).join('');
+        const percentageRow = `<tr align="center"><td><b>Percentage</b></td>${percentages}</tr>`;
+
+        // Build covered/total row
+        const coveredTotals = visibleColumns.map(col => 
+            `<td>${col.data!.Executed}/${col.data!.Total}</td>`
+        ).join('');
+        const coveredTotalRow = `<tr align="center"><td><b>Covered/Total</b></td>${coveredTotals}</tr>`;
+
+        const tableHTML = `<table>${headerRow}${percentageRow}${coveredTotalRow}</table>`;
+        core.info(`Generated table HTML: ${tableHTML}`);
+        
+        return tableHTML;
+    } catch (error) {
+        core.error(`Error generating coverage table: ${error}`);
+        return '<p>Error generating coverage table</p>';
+    }
+}

src/testResultsSummary.ts

@@ -3,6 +3,7 @@
 import { readFileSync, unlinkSync, existsSync } from "fs";
 import * as path from "path";
 import * as core from "@actions/core";
+import { getCoverageData, generateCoverageTableHTML } from "./codeCoverageSummary";
 
 export enum MatlabTestStatus {
     PASSED = "PASSED",
@@ -143,9 +144,25 @@ export function addSummary(
         const header = getTestHeader(testResultsData.Stats);
         const detailedResults = getDetailedResults(testResultsData.TestResults);
 
+        // core.summary
+        //     .addHeading("MATLAB Test Results (" + actionName + ") " + helpLink)
+        //     .addRaw(header, true)
+        //     .addHeading("All tests", 3)
+        //     .addRaw(detailedResults, true);
         core.summary
             .addHeading("MATLAB Test Results (" + actionName + ") " + helpLink)
-            .addRaw(header, true)
+            .addRaw(header, true);
+
+        // Add coverage table if available
+        const coverageData = getCoverageData();
+        if (coverageData) {
+            core.summary
+                .addHeading("MATLAB Code Coverage", 3)
+                .addRaw(generateCoverageTableHTML(coverageData), true);
+        }
+
+        // Add detailed test results
+        core.summary
             .addHeading("All tests", 3)
             .addRaw(detailedResults, true);
     } catch (e) {