feat(workflow-result): depend on verify-matrix when it exists

Author: travi

src/jobs/lifter.js

@@ -1,16 +1,18 @@
 import buildNodeVersionMatrix from './node-version-matrix-builder.js';
 import insertMissingJobs from './missing-job-inserter.js';
 import * as matrixVerificationJobEnhancer from './verify-matrix/index.js';
+import * as workflowResultJobEnhancer from './workflow-result/index.js';
 import {lift as liftJob} from '../job/index.js';
 
 export default function ({jobs, engines, runner}) {
   const nodeEnginesMatrix = buildNodeVersionMatrix(engines);
 
-  const liftedJobs = Object.entries(jobs).map(([jobName, job]) => liftJob(
-    [jobName, job],
-    [matrixVerificationJobEnhancer],
-    {inRangeNodeVersions: nodeEnginesMatrix}
-  ));
+  const jobEntries = Object.entries(jobs);
+  const jobsWithMissingInserted = insertMissingJobs({versions: nodeEnginesMatrix, jobs: jobEntries, runner});
 
-  return Object.fromEntries(insertMissingJobs({versions: nodeEnginesMatrix, jobs: liftedJobs, runner}));
+  return Object.fromEntries(jobsWithMissingInserted.map(([jobName, job]) => liftJob(
+    [jobName, job],
+    [matrixVerificationJobEnhancer, workflowResultJobEnhancer],
+    {inRangeNodeVersions: nodeEnginesMatrix, jobs}
+  )));
 }

src/jobs/lifter.test.js

@@ -6,6 +6,7 @@ import {when} from 'jest-when';
 
 import {lift as liftJob} from '../job/index.js';
 import * as matrixVerificationJobEnhancer from './verify-matrix/index.js';
+import * as workflowResultJobEnhancer from './workflow-result/index.js';
 import insertMissingJob from './missing-job-inserter.js';
 import buildNodeVersionMatrix from './node-version-matrix-builder.js';
 import liftJobs from './lifter.js';
@@ -17,26 +18,29 @@ vi.mock('../job/index.js');
 describe('steps lifter', () => {
   it('should lift the steps', async () => {
     const jobNames = any.listOf(any.word);
+    const jobNamesWithMissingInjected = any.listOf(any.word);
     const jobDefinitions = jobNames.map(any.simpleObject);
-    const liftedJobDefinitions = jobDefinitions.map(any.simpleObject);
+    const jobDefinitionsWithMissingInjected = jobNamesWithMissingInjected.map(any.simpleObject);
+    const liftedJobDefinitions = jobDefinitionsWithMissingInjected.map(any.simpleObject);
     const supportedNodeVersionRange = any.string();
     const supportedNodeVersions = any.listOf(any.integer);
-    const jobPairsWithMissingInjected = zip(any.listOf(any.word), any.listOf(any.simpleObject));
     const runner = any.word();
+    const jobs = Object.fromEntries(zip(jobNames, jobDefinitions));
     when(buildNodeVersionMatrix).calledWith(supportedNodeVersionRange).mockReturnValue(supportedNodeVersions);
     when(insertMissingJob)
-      .calledWith({versions: supportedNodeVersions, jobs: zip(jobNames, liftedJobDefinitions), runner})
-      .mockReturnValue(jobPairsWithMissingInjected);
-    zip(jobDefinitions, liftedJobDefinitions, jobNames).forEach(
+      .calledWith({versions: supportedNodeVersions, jobs: zip(jobNames, jobDefinitions), runner})
+      .mockReturnValue(zip(jobNamesWithMissingInjected, jobDefinitionsWithMissingInjected));
+    zip(jobDefinitionsWithMissingInjected, liftedJobDefinitions, jobNamesWithMissingInjected).forEach(
       ([job, liftedJob, jobName]) => when(liftJob)
-        .calledWith([jobName, job], [matrixVerificationJobEnhancer], {inRangeNodeVersions: supportedNodeVersions})
+        .calledWith(
+          [jobName, job],
+          [matrixVerificationJobEnhancer, workflowResultJobEnhancer],
+          {inRangeNodeVersions: supportedNodeVersions, jobs}
+        )
         .mockReturnValue([jobName, liftedJob])
     );
 
-    expect(await liftJobs({
-      jobs: Object.fromEntries(zip(jobNames, jobDefinitions)),
-      engines: supportedNodeVersionRange,
-      runner
-    })).toEqual(Object.fromEntries(jobPairsWithMissingInjected));
+    expect(await liftJobs({jobs, engines: supportedNodeVersionRange, runner}))
+      .toEqual(Object.fromEntries(zip(jobNamesWithMissingInjected, liftedJobDefinitions)));
   });
 });

src/jobs/workflow-result/index.js

@@ -1 +1,3 @@
 export {default as scaffold} from './scaffolder.js';
+export {default as test} from './tester.js';
+export {default as lift} from './lifter.js';

src/jobs/workflow-result/lifter.js

@@ -0,0 +1,5 @@
+export default function (job, {jobs}) {
+  if (!Object.keys(jobs).includes('verify-matrix')) return job;
+
+  return {...job, needs: ['verify', 'verify-matrix']};
+}

src/jobs/workflow-result/lifter.test.js

@@ -0,0 +1,19 @@
+import {describe, it, expect} from 'vitest';
+import any from '@travi/any';
+
+import liftWorkflowResultJob from './lifter.js';
+
+describe('workflow-result job lifter', () => {
+  const existingJobDetails = any.simpleObject();
+
+  it('should not modify the job if no `verify-matrix` job exists', () => {
+    expect(liftWorkflowResultJob(existingJobDetails, {jobs: any.simpleObject()})).toEqual(existingJobDetails);
+  });
+
+  it('should make the job depend on the `verify-matrix` job if it exists', () => {
+    expect(liftWorkflowResultJob(
+      existingJobDetails,
+      {jobs: {...any.simpleObject(), 'verify-matrix': any.simpleObject()}}
+    )).toEqual({...existingJobDetails, needs: ['verify', 'verify-matrix']});
+  });
+});

src/jobs/workflow-result/tester.js

@@ -0,0 +1,3 @@
+export default function ({jobName}) {
+  return 'workflow-result' === jobName;
+}

src/jobs/workflow-result/tester.test.js

@@ -0,0 +1,14 @@
+import any from '@travi/any';
+import {it, describe, expect} from 'vitest';
+
+import jobIsMatrixVerification from './tester.js';
+
+describe('workflow-result predicate', () => {
+  it('should return `true` when the job name is `workflow-result`', () => {
+    expect(jobIsMatrixVerification({jobName: 'workflow-result'})).toBe(true);
+  });
+
+  it('should return `false` when the job name is not `workflow-result`', () => {
+    expect(jobIsMatrixVerification({jobName: any.word()})).toBe(false);
+  });
+});