feat(plugin-coverage): do not halt plugin execution on fail

Author: vmasek

packages/plugin-coverage/src/lib/config.ts

@@ -38,6 +38,12 @@ export const coveragePluginConfigSchema = z.object({
         .optional(),
     })
     .optional(),
+  continueOnCommandFail: z
+    .boolean({
+      description:
+        'Continue on coverage tool command failure or error. Defaults to true.',
+    })
+    .default(true),
   coverageTypes: z
     .array(coverageTypeSchema, {
       description: 'Coverage types measured. Defaults to all available types.',

packages/plugin-coverage/src/lib/runner/index.ts

@@ -24,7 +24,7 @@ export async function executeRunner({
   runnerConfigPath,
   runnerOutputPath,
 }: RunnerFilesPaths): Promise<void> {
-  const { reports, coverageToolCommand, coverageTypes } =
+  const { reports, coverageToolCommand, continueOnCommandFail, coverageTypes } =
     await readJsonFile<FinalCoveragePluginConfig>(runnerConfigPath);
 
   // Run coverage tool if provided
@@ -34,20 +34,29 @@ export async function executeRunner({
       await executeProcess({ command, args });
     } catch (error) {
       if (error instanceof ProcessError) {
-        ui().logger.error(bold('stdout from failed coverage tool process:'));
-        ui().logger.error(error.stdout);
-        ui().logger.error(bold('stderr from failed coverage tool process:'));
-        ui().logger.error(error.stderr);
+        const loggingFn = continueOnCommandFail
+          ? ui().logger.warning
+          : ui().logger.error;
+        loggingFn(bold('stdout from failed coverage tool process:'));
+        loggingFn(error.stdout);
+        loggingFn(bold('stderr from failed coverage tool process:'));
+        loggingFn(error.stderr);
       }
 
-      throw new Error(
-        'Coverage plugin: Running coverage tool failed. Make sure all your provided tests are passing.',
-      );
+      if (!continueOnCommandFail) {
+        throw new Error(
+          'Coverage plugin: Running coverage tool failed. Make sure all your provided tests are passing.',
+        );
+      }
     }
   }
 
   // Calculate coverage from LCOV results
-  const auditOutputs = await lcovResultsToAuditOutputs(reports, coverageTypes);
+  const auditOutputs = await lcovResultsToAuditOutputs(
+    reports,
+    coverageTypes,
+    continueOnCommandFail,
+  );
 
   await ensureDirectoryExists(path.dirname(runnerOutputPath));
   await writeFile(runnerOutputPath, JSON.stringify(auditOutputs));

packages/plugin-coverage/src/lib/runner/lcov/lcov-runner.ts

@@ -18,14 +18,16 @@ import type { LCOVStat, LCOVStats } from './types.js';
  *
  * @param results Paths to LCOV results
  * @param coverageTypes types of coverage to be considered
+ * @param continueFail force execution to continue on possibly non-critical failures, defaults to true
  * @returns Audit outputs with complete coverage data.
  */
 export async function lcovResultsToAuditOutputs(
   results: CoverageResult[],
   coverageTypes: CoverageType[],
+  continueFail: boolean = true,
 ): Promise<AuditOutputs> {
   // Parse lcov files
-  const lcovResults = await parseLcovFiles(results);
+  const lcovResults = await parseLcovFiles(results, continueFail);
 
   // Merge multiple coverage reports for the same file
   const mergedResults = mergeLcovResults(lcovResults);
@@ -50,10 +52,12 @@ export async function lcovResultsToAuditOutputs(
 /**
  *
  * @param results Paths to LCOV results
+ * @param continueFail force execution to continue on possibly non-critical failures, defaults to true
  * @returns Array of parsed LCOVRecords.
  */
 export async function parseLcovFiles(
   results: CoverageResult[],
+  continueFail: boolean = true,
 ): Promise<LCOVRecord[]> {
   const parsedResults = await Promise.all(
     results.map(async result => {
@@ -76,13 +80,18 @@ export async function parseLcovFiles(
     }),
   );
   if (parsedResults.length !== results.length) {
-    throw new Error('Some provided LCOV results were not valid.');
+    const message = 'Some provided coverage LCOV results were not valid.';
+    if (continueFail) {
+      ui().logger.warning(message);
+    } else {
+      throw new Error(message);
+    }
   }
 
   const flatResults = parsedResults.flat();
 
   if (flatResults.length === 0) {
-    throw new Error('All provided results are empty.');
+    throw new Error('All provided coverage results are empty.');
   }
 
   return flatResults;