feat(workflow-result): enable use of a custom runner for the workflow-result job

Author: travi

src/job/scaffolder.js

@@ -1,7 +1,9 @@
-export default function ({steps, strategy, runner = 'ubuntu-latest'}) {
+export default function ({steps, strategy, needs, if: conditional, runner = 'ubuntu-latest'}) {
   return {
     'runs-on': runner,
     ...strategy && {strategy},
+    ...needs && {needs},
+    ...conditional && {if: conditional},
     steps
   };
 }

src/job/scaffolder.test.js

@@ -21,4 +21,16 @@ describe('job scaffolder', () => {
 
     expect(scaffoldJob({steps, strategy})).toEqual({'runs-on': 'ubuntu-latest', strategy, steps});
   });
+
+  it('should define the `needs` dependencies if any are provided', () => {
+    const dependencies = any.listOf(any.word);
+
+    expect(scaffoldJob({steps, needs: dependencies})).toEqual({'runs-on': 'ubuntu-latest', needs: dependencies, steps});
+  });
+
+  it('should define the `if` conditional if provided', () => {
+    const conditional = any.string();
+
+    expect(scaffoldJob({steps, if: conditional})).toEqual({'runs-on': 'ubuntu-latest', if: conditional, steps});
+  });
 });

src/jobs/missing-job-inserter.js

@@ -14,7 +14,7 @@ export default function ({versions: matrixOfNodeVersions, jobs, runner}) {
     return [['verify-matrix', matrixVerification({versions: matrixOfNodeVersions, runner})], ...jobs];
   }
 
-  if (!resultJobAlreadyExists(jobs)) return [...jobs, ['workflow-result', scaffoldWorkflowResultJob()]];
+  if (!resultJobAlreadyExists(jobs)) return [...jobs, ['workflow-result', scaffoldWorkflowResultJob({runner})]];
 
   return jobs;
 }

src/jobs/missing-job-inserter.test.js

@@ -69,9 +69,9 @@ describe('missing job inserter', () => {
     it('should insert a `workflow-result` job when one doesnt already exist', async () => {
       const jobs = any.listOf(() => ([any.word(), any.simpleObject()]));
       const resultJob = any.simpleObject();
-      when(scaffoldWorkflowResultJob).calledWith().mockReturnValue(resultJob);
+      when(scaffoldWorkflowResultJob).calledWith({runner}).mockReturnValue(resultJob);
 
-      expect(insertMissingJobs({jobs}))
+      expect(insertMissingJobs({jobs, runner}))
         .toEqual([...jobs, ['workflow-result', resultJob]]);
     });
   });

src/jobs/workflow-result/scaffolder.js

@@ -1,6 +1,8 @@
-export default function () {
-  return {
-    'runs-on': 'ubuntu-latest',
+import {scaffold as scaffoldJob} from '../../job/index.js';
+
+export default function ({runner}) {
+  return scaffoldJob({
+    runner,
     needs: ['verify'],
     // eslint-disable-next-line no-template-curly-in-string
     if: '${{ !cancelled() }}',
@@ -18,5 +20,5 @@ export default function () {
         run: 'exit 1'
       }
     ]
-  };
+  });
 }

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

@@ -1,28 +1,38 @@
-import {it, expect, describe} from 'vitest';
+import {it, expect, describe, vi} from 'vitest';
+import {when} from 'jest-when';
+import any from '@travi/any';
 
+import {scaffold as scaffoldJob} from '../../job/index.js';
 import scaffoldWorkflowResultJob from './scaffolder.js';
 
+vi.mock('../../job/index.js');
 describe('workflow-result job scaffolder', () => {
   it('should determine exit code based on previous job results', () => {
-    expect(scaffoldWorkflowResultJob()).toEqual({
-      'runs-on': 'ubuntu-latest',
-      needs: ['verify'],
-      // eslint-disable-next-line no-template-curly-in-string
-      if: '${{ !cancelled() }}',
-      steps: [
-        {
-          name: 'All matrix versions passed',
-          // eslint-disable-next-line no-template-curly-in-string
-          if: "${{ !(contains(needs.*.result, 'failure')) }}",
-          run: 'exit 0'
-        },
-        {
-          name: 'Some matrix version failed',
-          // eslint-disable-next-line no-template-curly-in-string
-          if: "${{ contains(needs.*.result, 'failure') }}",
-          run: 'exit 1'
-        }
-      ]
-    });
+    const runner = any.word();
+    const job = any.simpleObject();
+    when(scaffoldJob)
+      .calledWith({
+        runner,
+        needs: ['verify'],
+        // eslint-disable-next-line no-template-curly-in-string
+        if: '${{ !cancelled() }}',
+        steps: [
+          {
+            name: 'All matrix versions passed',
+            // eslint-disable-next-line no-template-curly-in-string
+            if: "${{ !(contains(needs.*.result, 'failure')) }}",
+            run: 'exit 0'
+          },
+          {
+            name: 'Some matrix version failed',
+            // eslint-disable-next-line no-template-curly-in-string
+            if: "${{ contains(needs.*.result, 'failure') }}",
+            run: 'exit 1'
+          }
+        ]
+      })
+      .mockReturnValue(job);
+
+    expect(scaffoldWorkflowResultJob({runner})).toEqual(job);
   });
 });

test/integration/features/lift/result.feature

@@ -13,6 +13,14 @@ Feature: Overall Workflow Result
     When the project is lifted
     Then the workflow-result job exists
     And the workflow-result job depends on "verify"
+    And the workflow-result job uses "ubuntu-latest" as the runner
+
+  Scenario: custom runner
+    Given a CI workflow exists
+    And a "verify" job exists
+    And the project prefers to use the "foo" runner
+    When the project is lifted
+    Then the workflow-result job uses "foo" as the runner
 
   @wip
   Scenario: No existing result job, existing verify and verify-matrix

test/integration/features/step_definitions/ci-steps.js

@@ -12,6 +12,8 @@ import {Before, Given, Then} from '@cucumber/cucumber';
 import {assert} from 'chai';
 import any from '@travi/any';
 
+const ciWorkflowName = 'node-ci';
+
 Before(async function () {
   this.prTriggerConfig = any.simpleObject();
 
@@ -23,7 +25,7 @@ Given('a CI workflow exists', async function () {
 
   await writeWorkflowFile({
     projectRoot: this.projectRoot,
-    name: 'node-ci',
+    name: ciWorkflowName,
     config: {
       on: {
         push: {branches: this.existingBranches},
@@ -35,14 +37,14 @@ Given('a CI workflow exists', async function () {
 });
 
 Given('a {string} job exists', async function (jobName) {
-  const existingWorkflowContents = await loadWorkflowFile({projectRoot: this.projectRoot, name: 'node-ci'});
+  const existingWorkflowContents = await loadWorkflowFile({projectRoot: this.projectRoot, name: ciWorkflowName});
   const job = any.simpleObject();
 
   this.injectedJobs[jobName] = job;
 
   await writeWorkflowFile({
     projectRoot: this.projectRoot,
-    name: 'node-ci',
+    name: ciWorkflowName,
     config: {
       ...existingWorkflowContents,
       jobs: {
@@ -54,7 +56,7 @@ Given('a {string} job exists', async function (jobName) {
 });
 
 Then('the ci config remains unchanged', async function () {
-  const {on: triggers, jobs} = await loadWorkflowFile({projectRoot: this.projectRoot, name: 'node-ci'});
+  const {on: triggers, jobs} = await loadWorkflowFile({projectRoot: this.projectRoot, name: ciWorkflowName});
 
   assert.deepEqual(triggers.push.branches, this.existingBranches);
   assert.deepEqual(triggers.pull_request, this.prTriggerConfig);
@@ -65,7 +67,7 @@ Then('the ci config remains unchanged', async function () {
 });
 
 Then('dependency caching is enabled', async function () {
-  const {jobs} = await loadWorkflowFile({projectRoot: this.projectRoot, name: 'node-ci'});
+  const {jobs} = await loadWorkflowFile({projectRoot: this.projectRoot, name: ciWorkflowName});
 
   const setupNodeStep = jobs[this.existingJobName].steps.find(step => 'Setup node' === step.name);
   assert.equal(setupNodeStep.with.cache, 'npm');
@@ -78,7 +80,7 @@ Then('the verification workflow is created', async function () {
     env,
     permissions,
     jobs
-  } = await loadWorkflowFile({projectRoot: this.projectRoot, name: 'node-ci'});
+  } = await loadWorkflowFile({projectRoot: this.projectRoot, name: ciWorkflowName});
 
   assert.equal(name, 'Node.js CI');
   assert.deepEqual(
@@ -102,19 +104,26 @@ Then('the verification workflow is created', async function () {
 });
 
 Then('the workflow-result job exists', async function () {
-  const {jobs} = await loadWorkflowFile({projectRoot: this.projectRoot, name: 'node-ci'});
+  const {jobs} = await loadWorkflowFile({projectRoot: this.projectRoot, name: ciWorkflowName});
 
   assert.include(Object.keys(jobs), 'workflow-result');
 });
 
 Then('the {string} job is unchanged', async function (jobName) {
-  const {jobs} = await loadWorkflowFile({projectRoot: this.projectRoot, name: 'node-ci'});
+  const {jobs} = await loadWorkflowFile({projectRoot: this.projectRoot, name: ciWorkflowName});
 
   assert.deepEqual(jobs[jobName], this.injectedJobs[jobName]);
 });
 
 Then('the workflow-result job depends on {string}', async function (jobName) {
-  const {jobs} = await loadWorkflowFile({projectRoot: this.projectRoot, name: 'node-ci'});
+  const {jobs} = await loadWorkflowFile({projectRoot: this.projectRoot, name: ciWorkflowName});
 
   assert.include(jobs['workflow-result'].needs, jobName);
 });
+
+Then('the workflow-result job uses {string} as the runner', async function (runner) {
+  const {jobs} = await loadWorkflowFile({projectRoot: this.projectRoot, name: ciWorkflowName});
+  const {'workflow-result': resultJob} = jobs;
+
+  assert.equal(resultJob['runs-on'], runner);
+});