@secureci/cli 0.5.1 → 0.6.0

package/dist/runner/dry-run.js

@@ -4,11 +4,15 @@ exports.dryRun = dryRun;
 const workflow_parser_1 = require("../parser/workflow-parser");
 const logger_1 = require("../utils/logger");
 const validator_1 = require("../parser/validator");
+const expression_1 = require("./expression");
+const job_plan_1 = require("./job-plan");
+// A matrix expression reading a context a dry run doesn't have.
+const RUN_TIME_MATRIX = /\$\{\{[^}]*\b(?:needs|inputs|vars|github|secrets)\b/;
 /**
  * Perform a dry run of a workflow or action file
  * Shows what would be executed without actually running anything
  */
-function dryRun(filePath) {
+function dryRun(filePath, options = {}) {
     try {
         const parsed = (0, workflow_parser_1.parseFile)(filePath);
         // A file a real run would reject fails the dry run too.
@@ -23,7 +27,7 @@ function dryRun(filePath) {
             return { success: false, type: parsed.type };
         }
         if (parsed.type === 'workflow') {
-            return dryRunWorkflow(parsed);
+            return dryRunWorkflow(parsed, options);
         }
         else {
             return dryRunAction(parsed);
@@ -37,22 +41,56 @@ function dryRun(filePath) {
         };
     }
 }
-function dryRunWorkflow(parsed) {
+function dryRunWorkflow(parsed, options) {
     const workflow = parsed.file;
+    const filter = options.matrix ?? {};
+    const definedKeys = new Set();
+    let runTimeMatrix = false;
+    let unmatched = false;
     logger_1.logger.info(`Workflow: ${workflow.name}`);
     logger_1.logger.info(`Trigger: ${JSON.stringify(workflow.on)}`);
-    const jobs = Object.entries(workflow.jobs).map(([jobId, job]) => {
+    const selectedJobs = Object.entries(workflow.jobs).filter(([jobId]) => !options.job || jobId === options.job);
+    const jobs = selectedJobs.flatMap(([jobId, job]) => {
+        // Matrix combinations, as far as they can be known without running.
+        let matrix;
+        const rawMatrix = job.strategy?.matrix;
+        const atRunTime = rawMatrix !== undefined &&
+            RUN_TIME_MATRIX.test(JSON.stringify(rawMatrix));
+        if (atRunTime) {
+            runTimeMatrix = true;
+        }
+        else if (rawMatrix !== undefined) {
+            const combinations = (0, job_plan_1.expandMatrix)(rawMatrix, (0, expression_1.createContext)());
+            combinations.forEach((c) => Object.keys(c).forEach((k) => definedKeys.add(k)));
+            const { keys, matches } = (0, job_plan_1.filterMatrix)(combinations, filter);
+            if (keys.length > 0 && matches.length === 0) {
+                logger_1.logger.warn((0, job_plan_1.noMatrixMatchMessage)(jobId, filter, combinations));
+                unmatched = true;
+                return [];
+            }
+            matrix = matches.map((m) => (0, job_plan_1.matrixLabel)(m.values));
+        }
         logger_1.logger.step(`Job: ${jobId} (${job.name || jobId})`);
+        if (atRunTime) {
+            logger_1.logger.info('  Matrix: resolved at run time');
+        }
+        else if (matrix) {
+            logger_1.logger.info(`  Matrix (${matrix.length} combination(s)):`);
+            matrix.forEach((label) => logger_1.logger.info(`    ${label}`));
+        }
         // Handle reusable workflow calls
         if (job.uses) {
             logger_1.logger.info(`  Uses workflow: ${job.uses}`);
             if (job.with) {
                 logger_1.logger.info(`  With inputs: ${JSON.stringify(job.with)}`);
             }
-            return {
-                name: jobId,
-                steps: [`Calls reusable workflow: ${job.uses}`]
-            };
+            return [
+                {
+                    name: jobId,
+                    steps: [`Calls reusable workflow: ${job.uses}`],
+                    ...(matrix ? { matrix } : {})
+                }
+            ];
         }
         // Handle regular jobs
         if (job['runs-on']) {
@@ -74,11 +112,18 @@ function dryRunWorkflow(parsed) {
             logger_1.logger.info(stepDesc);
             return stepDesc;
         });
-        return {
-            name: jobId,
-            steps
-        };
+        return [{ name: jobId, steps, ...(matrix ? { matrix } : {}) }];
     });
+    // A key might belong to a matrix only known at run time.
+    if (!runTimeMatrix) {
+        for (const key of (0, job_plan_1.unknownMatrixKeys)(filter, definedKeys)) {
+            logger_1.logger.warn(`--matrix ${key}: no matrix job defines this key; it was ignored`);
+        }
+    }
+    if (unmatched) {
+        logger_1.logger.error('Dry run failed: a --matrix filter matched no combination');
+        return { success: false, type: 'workflow', jobs };
+    }
     logger_1.logger.success('Dry run completed successfully');
     return {
         success: true,