refactor(jobs-lifter): enable providing lifters targeted at specific jobs

Author: travi

src/job/lifter.js

@@ -1,16 +1,9 @@
 import {lift as liftSteps} from '../steps/index.js';
 
-function enginesShouldBeUpdated(inRangeNodeVersions, job) {
-  return inRangeNodeVersions && job.strategy?.matrix?.node;
-}
+export default function ([jobName, job], enhancers, options) {
+  const enhancer = enhancers.find(({test}) => test({jobName}));
+
+  const jobWithLiftedSteps = {...job, ...job.steps && {steps: liftSteps(job.steps)}};
 
-export default function ([jobName, job], inRangeNodeVersions) {
-  return [
-    jobName,
-    {
-      ...job,
-      ...job.steps && {steps: liftSteps(job.steps)},
-      ...enginesShouldBeUpdated(inRangeNodeVersions, job) && {strategy: {matrix: {node: inRangeNodeVersions}}}
-    }
-  ];
+  return [jobName, enhancer ? enhancer.lift(jobWithLiftedSteps, options) : jobWithLiftedSteps];
 }

src/job/lifter.test.js

@@ -1,4 +1,4 @@
-import {describe, it, expect, afterEach, vi} from 'vitest';
+import {describe, expect, it, vi} from 'vitest';
 import any from '@travi/any';
 import {when} from 'jest-when';
 
@@ -9,60 +9,44 @@ vi.mock('../steps/index.js');
 
 describe('job lifter', () => {
   const jobName = any.word();
-  const updatedSupportedNodeVersions = any.listOf(any.simpleObject);
-
-  afterEach(() => {
-    vi.clearAllMocks();
-  });
+  const jobSteps = any.listOf(any.simpleObject);
+  const liftedSteps = any.listOf(any.simpleObject);
+  const enhancerOptions = any.simpleObject();
+  const nonApplicableEnhancerFactory = () => ({test: () => false});
 
   it('should lift the steps of a job', () => {
     const jobWithoutSteps = any.simpleObject();
-    const jobSteps = any.listOf(any.simpleObject);
-    const liftedSteps = any.listOf(any.simpleObject);
     when(liftSteps).calledWith(jobSteps).mockReturnValue(liftedSteps);
 
-    expect(liftJob([jobName, {...jobWithoutSteps, steps: jobSteps}]))
+    expect(liftJob([jobName, {...jobWithoutSteps, steps: jobSteps}], any.listOf(nonApplicableEnhancerFactory)))
       .toEqual([jobName, {...jobWithoutSteps, steps: liftedSteps}]);
   });
 
   it('should lift a job that calls a reusable workflow', () => {
     const jobThatCallsReusableWorkflow = {...any.simpleObject(), uses: any.string()};
-    const liftedJob = liftJob([jobName, jobThatCallsReusableWorkflow]);
+    const liftedJob = liftJob([jobName, jobThatCallsReusableWorkflow], any.listOf(nonApplicableEnhancerFactory));
 
     expect(liftSteps).not.toHaveBeenCalled();
     expect(liftedJob).toEqual([jobName, jobThatCallsReusableWorkflow]);
   });
 
-  it('should replace the node versions in an existing matrix job', () => {
-    const [, updatedJobDefinition] = liftJob(
-      [jobName, {...any.simpleObject(), strategy: {matrix: {node: any.listOf(any.integer)}}}],
-      updatedSupportedNodeVersions
-    );
-
-    expect(updatedJobDefinition.strategy.matrix.node).toEqual(updatedSupportedNodeVersions);
-  });
-
-  it('should not add a test strategy to a job that does not already have one defined', () => {
-    const [, updatedJobDefinition] = liftJob([jobName, any.simpleObject()], updatedSupportedNodeVersions);
-
-    expect(updatedJobDefinition.strategy).toBe(undefined);
-  });
-
-  it('should not add a test matrix to a job that does not already have one defined', () => {
-    const [, updatedJobDefinition] = liftJob(
-      [jobName, {...any.simpleObject(), strategy: any.simpleObject()}],
-      updatedSupportedNodeVersions
-    );
-
-    expect(updatedJobDefinition.strategy.matrix).toBe(undefined);
-  });
+  it('should apply a related enhancer', () => {
+    const jobLifter = vi.fn();
+    const applicableEnhancer = {test: () => true, lift: jobLifter};
+    const enhancers = [
+      ...any.listOf(nonApplicableEnhancerFactory),
+      applicableEnhancer,
+      ...any.listOf(nonApplicableEnhancerFactory)
+    ];
+    const existingJobDetails = {...any.simpleObject(), steps: jobSteps};
+    const liftedJobDetails = any.simpleObject();
+    when(liftSteps).calledWith(jobSteps).mockReturnValue(liftedSteps);
+    when(jobLifter)
+      .calledWith({...existingJobDetails, steps: liftedSteps}, enhancerOptions)
+      .mockReturnValue(liftedJobDetails);
 
-  it('should not add a list of supported node versions to a job that does not already have one defined', () => {
-    const [, updatedJobDefinition] = liftJob(
-      [jobName, {...any.simpleObject(), strategy: {...any.simpleObject(), matrix: any.simpleObject()}}],
-      updatedSupportedNodeVersions
-    );
+    const [, updatedJobDefinition] = liftJob(['verify-matrix', existingJobDetails], enhancers, enhancerOptions);
 
-    expect(updatedJobDefinition.strategy.matrix.node).toBe(undefined);
+    expect(updatedJobDefinition).toEqual(liftedJobDetails);
   });
 });

src/jobs/lifter.js

@@ -1,11 +1,16 @@
 import buildNodeVersionMatrix from './node-version-matrix-builder.js';
 import insertMissingJobs from './missing-job-inserter.js';
+import * as matrixVerificationJobEnhancer from './verify-matrix/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], nodeEnginesMatrix));
+  const liftedJobs = Object.entries(jobs).map(([jobName, job]) => liftJob(
+    [jobName, job],
+    [matrixVerificationJobEnhancer],
+    {inRangeNodeVersions: nodeEnginesMatrix}
+  ));
 
   return Object.fromEntries(insertMissingJobs({versions: nodeEnginesMatrix, jobs: liftedJobs, runner}));
 }

src/jobs/lifter.test.js

@@ -1,23 +1,20 @@
 import zip from 'lodash.zip';
 
-import {describe, it, expect, afterEach, vi} from 'vitest';
+import {describe, expect, it, vi} from 'vitest';
 import any from '@travi/any';
 import {when} from 'jest-when';
 
+import {lift as liftJob} from '../job/index.js';
+import * as matrixVerificationJobEnhancer from './verify-matrix/index.js';
 import insertMissingJob from './missing-job-inserter.js';
 import buildNodeVersionMatrix from './node-version-matrix-builder.js';
-import {lift as liftJob} from '../job/index.js';
 import liftJobs from './lifter.js';
 
 vi.mock('./missing-job-inserter.js');
 vi.mock('./node-version-matrix-builder.js');
 vi.mock('../job/index.js');
 
 describe('steps lifter', () => {
-  afterEach(() => {
-    vi.clearAllMocks();
-  });
-
   it('should lift the steps', async () => {
     const jobNames = any.listOf(any.word);
     const jobDefinitions = jobNames.map(any.simpleObject);
@@ -32,7 +29,7 @@ describe('steps lifter', () => {
       .mockReturnValue(jobPairsWithMissingInjected);
     zip(jobDefinitions, liftedJobDefinitions, jobNames).forEach(
       ([job, liftedJob, jobName]) => when(liftJob)
-        .calledWith([jobName, job], supportedNodeVersions)
+        .calledWith([jobName, job], [matrixVerificationJobEnhancer], {inRangeNodeVersions: supportedNodeVersions})
         .mockReturnValue([jobName, liftedJob])
     );
 

src/jobs/verify-matrix/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/verify-matrix/lifter.js

@@ -0,0 +1,5 @@
+export default function (job, {inRangeNodeVersions}) {
+  if (!inRangeNodeVersions) return job;
+
+  return {...job, strategy: {matrix: {node: inRangeNodeVersions}}};
+}

src/jobs/verify-matrix/lifter.test.js

@@ -0,0 +1,19 @@
+import {describe, it, expect} from 'vitest';
+import any from '@travi/any';
+
+import liftMatrixVerificationJob from './lifter.js';
+
+describe('matrix verification job lifter', () => {
+  const existingJobDetails = any.simpleObject();
+
+  it('should define the node version matrix for the job', () => {
+    const inRangeNodeVersions = any.listOf(any.simpleObject);
+
+    expect(liftMatrixVerificationJob(existingJobDetails, {inRangeNodeVersions}))
+      .toEqual({...existingJobDetails, strategy: {matrix: {node: inRangeNodeVersions}}});
+  });
+
+  it('should not modify the job if node versions are not provided', () => {
+    expect(liftMatrixVerificationJob(existingJobDetails, {})).toEqual(existingJobDetails);
+  });
+});

src/jobs/verify-matrix/tester.js

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

src/jobs/verify-matrix/tester.test.js

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

test/integration/features/step_definitions/node-versions-steps.js

@@ -69,7 +69,7 @@ Given('the version is read from the nvmrc and passed as a value to the setup-nod
 });
 
 Given('the node version is based on a matrix {string} caching enabled', async function (cachingEnabled) {
-  this.existingJobName = any.word();
+  this.existingJobName = 'verify-matrix';
   this.existingNodeVersions = any.listOf(any.integer);
   this.existingJobSteps = [
     {uses: 'actions/checkout@v3'},