@code-pushup/coverage-plugin 0.44.2 → 0.45.0

package/README.md

@@ -7,6 +7,7 @@
 🧪 **Code PushUp plugin for tracking code coverage.** ☂️
 
 This plugin allows you to measure and track code coverage on your project.
+It accepts the LCOV coverage format and merges coverage results from any test suites provided.
 
 Measured coverage types are mapped to Code PushUp audits in the following way
 
@@ -213,7 +214,11 @@ For instance, the following can be an audit output for line coverage.
 }
 ```
 
-### Providing coverage results in Nx monorepo
+### Coverage results alteration
+
+At the moment, the LCOV results include `(empty-report)` functions with missing coverage. These point to various imports or exports, not actual functions. For that reason, they are omitted from the results.
+
+## Providing coverage results in Nx monorepo
 
 As a part of the plugin, there is a `getNxCoveragePaths` helper for setting up paths to coverage results if you are using Nx. The helper accepts all relevant targets (e.g. `test` or `unit-test`) and searches for a coverage path option.
 Jest and Vitest configuration options are currently supported:

package/bin.js

@@ -1156,10 +1156,134 @@ var PLUGIN_CONFIG_PATH = join2(
   WORKDIR,
   "plugin-config.json"
 );
+var INVALID_FUNCTION_NAME = "(empty-report)";
 
 // packages/plugin-coverage/src/lib/runner/lcov/lcov-runner.ts
 import { join as join3 } from "node:path";
 
+// packages/plugin-coverage/src/lib/runner/lcov/merge-lcov.ts
+function mergeLcovResults(records) {
+  const allFilenames = records.map((record) => record.file);
+  if (allFilenames.length === new Set(allFilenames).size) {
+    return records;
+  }
+  return records.reduce((accMerged, currRecord, currIndex) => {
+    const filePath = currRecord.file;
+    const lines6 = currRecord.lines.found;
+    const duplicates = records.reduce(
+      (acc, candidateRecord, candidateIndex) => {
+        if (candidateRecord.file === filePath && candidateRecord.lines.found === lines6 && candidateIndex !== currIndex) {
+          return [...acc, [candidateRecord, candidateIndex]];
+        }
+        return acc;
+      },
+      []
+    );
+    if (duplicates.map((duplicate) => duplicate[1]).some((index) => index < currIndex)) {
+      return accMerged;
+    }
+    if (duplicates.length === 0) {
+      return [...accMerged, currRecord];
+    }
+    return [
+      ...accMerged,
+      mergeDuplicateLcovRecords([
+        currRecord,
+        ...duplicates.map((duplicate) => duplicate[0])
+      ])
+    ];
+  }, []);
+}
+function mergeDuplicateLcovRecords(records) {
+  const linesDetails = mergeLcovLineDetails(
+    records.map((record) => record.lines.details)
+  );
+  const linesHit = linesDetails.reduce(
+    (acc, line) => acc + (line.hit > 0 ? 1 : 0),
+    0
+  );
+  const branchesDetails = mergeLcovBranchesDetails(
+    records.map((record) => record.branches.details)
+  );
+  const branchesHit = branchesDetails.reduce(
+    (acc, branch) => acc + (branch.taken > 0 ? 1 : 0),
+    0
+  );
+  const functionsDetails = mergeLcovFunctionsDetails(
+    records.map((record) => record.functions.details)
+  );
+  const functionsHit = functionsDetails.reduce(
+    (acc, func) => acc + (func.hit != null && func.hit > 0 ? 1 : 0),
+    0
+  );
+  const mergedRecord = {
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    file: records[0].file,
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    title: records[0].title,
+    lines: {
+      found: linesDetails.length,
+      hit: linesHit,
+      details: linesDetails
+    },
+    branches: {
+      found: branchesDetails.length,
+      hit: branchesHit,
+      details: branchesDetails
+    },
+    functions: {
+      found: functionsDetails.length,
+      hit: functionsHit,
+      details: functionsDetails
+    }
+  };
+  return mergedRecord;
+}
+function mergeLcovLineDetails(details4) {
+  const flatDetails = details4.flat();
+  const uniqueLines = [
+    ...new Set(flatDetails.map((flatDetail) => flatDetail.line))
+  ];
+  return uniqueLines.map((line) => {
+    const hitSum = flatDetails.filter((lineDetail) => lineDetail.line === line).reduce((acc, lineDetail) => acc + lineDetail.hit, 0);
+    return { line, hit: hitSum };
+  });
+}
+function mergeLcovBranchesDetails(details4) {
+  const flatDetails = details4.flat();
+  const uniqueBranches = [
+    ...new Set(
+      flatDetails.map(
+        ({ line, block, branch }) => JSON.stringify({ line, block, branch })
+      )
+    )
+  ].map(
+    (functionJSON) => JSON.parse(functionJSON)
+  );
+  return uniqueBranches.map(({ line, block, branch }) => {
+    const takenSum = flatDetails.filter(
+      (branchDetail) => branchDetail.line === line && branchDetail.block === block && branchDetail.branch === branch
+    ).reduce((acc, branchDetail) => acc + branchDetail.taken, 0);
+    return { line, block, branch, taken: takenSum };
+  });
+}
+function mergeLcovFunctionsDetails(details4) {
+  const flatDetails = details4.flat();
+  const uniqueFunctions = [
+    ...new Set(
+      flatDetails.map(({ line, name }) => JSON.stringify({ line, name }))
+    )
+  ].map(
+    (functionJSON) => JSON.parse(functionJSON)
+  );
+  return uniqueFunctions.map(({ line, name }) => {
+    const hitSum = flatDetails.filter(
+      (functionDetail) => functionDetail.line === line && functionDetail.name === name
+    ).reduce((acc, functionDetail) => acc + (functionDetail.hit ?? 0), 0);
+    return { line, name, hit: hitSum };
+  });
+}
+
 // packages/plugin-coverage/src/lib/runner/lcov/parse-lcov.ts
 import parseLcovExport from "parse-lcov";
 var godKnows = parseLcovExport;
@@ -1184,21 +1308,41 @@ function mergeConsecutiveNumbers(numberArr) {
 
 // packages/plugin-coverage/src/lib/runner/lcov/transform.ts
 function lcovReportToFunctionStat(record) {
+  const validRecord = removeEmptyReport(record);
   return {
-    totalFound: record.functions.found,
-    totalHit: record.functions.hit,
-    issues: record.functions.hit < record.functions.found ? record.functions.details.filter((detail) => !detail.hit).map(
+    totalFound: validRecord.functions.found,
+    totalHit: validRecord.functions.hit,
+    issues: validRecord.functions.hit < validRecord.functions.found ? validRecord.functions.details.filter((detail) => !detail.hit).map(
       (detail) => ({
         message: `Function ${detail.name} is not called in any test case.`,
         severity: "error",
         source: {
-          file: record.file,
+          file: validRecord.file,
           position: { startLine: detail.line }
         }
       })
     ) : []
   };
 }
+function removeEmptyReport(record) {
+  const validFunctions = record.functions.details.filter(
+    (detail) => detail.name !== INVALID_FUNCTION_NAME
+  );
+  if (validFunctions.length === record.functions.found) {
+    return record;
+  }
+  return {
+    ...record,
+    functions: {
+      details: validFunctions,
+      found: validFunctions.length,
+      hit: validFunctions.reduce(
+        (acc, fn) => acc + (fn.hit != null && fn.hit > 0 ? 1 : 0),
+        0
+      )
+    }
+  };
+}
 function lcovReportToLineStat(record) {
   const missingCoverage = record.lines.hit < record.lines.found;
   const lines6 = missingCoverage ? record.lines.details.filter((detail) => !detail.hit).map((detail) => detail.line) : [];
@@ -1263,8 +1407,9 @@ function lcovCoverageToAuditOutput(stat2, coverageType) {
 // packages/plugin-coverage/src/lib/runner/lcov/lcov-runner.ts
 async function lcovResultsToAuditOutputs(results, coverageTypes) {
   const lcovResults = await parseLcovFiles(results);
+  const mergedResults = mergeLcovResults(lcovResults);
   const totalCoverageStats = getTotalCoverageFromLcovRecords(
-    lcovResults,
+    mergedResults,
     coverageTypes
   );
   return coverageTypes.map((coverageType) => {

package/index.js

@@ -1081,7 +1081,7 @@ import chalk4 from "chalk";
 
 // packages/plugin-coverage/package.json
 var name = "@code-pushup/coverage-plugin";
-var version = "0.44.2";
+var version = "0.45.0";
 
 // packages/plugin-coverage/src/lib/config.ts
 import { z as z16 } from "zod";

package/package.json

@@ -1,9 +1,9 @@
 {
   "name": "@code-pushup/coverage-plugin",
-  "version": "0.44.2",
+  "version": "0.45.0",
   "dependencies": {
-    "@code-pushup/models": "0.44.2",
-    "@code-pushup/utils": "0.44.2",
+    "@code-pushup/models": "0.45.0",
+    "@code-pushup/utils": "0.45.0",
     "parse-lcov": "^1.0.4",
     "chalk": "^5.3.0",
     "zod": "^3.22.4"

package/src/lib/runner/constants.d.ts

@@ -1,3 +1,4 @@
 export declare const WORKDIR: string;
 export declare const RUNNER_OUTPUT_PATH: string;
 export declare const PLUGIN_CONFIG_PATH: string;
+export declare const INVALID_FUNCTION_NAME = "(empty-report)";

package/src/lib/runner/lcov/merge-lcov.d.ts

@@ -0,0 +1,6 @@
+import { BranchesDetails, FunctionsDetails, LCOVRecord, LinesDetails } from 'parse-lcov';
+export declare function mergeLcovResults(records: LCOVRecord[]): LCOVRecord[];
+export declare function mergeDuplicateLcovRecords(records: LCOVRecord[]): LCOVRecord;
+export declare function mergeLcovLineDetails(details: LinesDetails[][]): LinesDetails[];
+export declare function mergeLcovBranchesDetails(details: BranchesDetails[][]): BranchesDetails[];
+export declare function mergeLcovFunctionsDetails(details: FunctionsDetails[][]): FunctionsDetails[];