feat(workflow-result): add a result rollup job to better enable required checks

Author: travi

src/jobs/missing-job-inserter.js

@@ -1,13 +1,20 @@
+import {scaffold as scaffoldWorkflowResultJob} from './workflow-result/index.js';
 import {matrixVerification} from './scaffolder.js';
 
 function noMatrixJobExistsIn(jobs) {
   return !jobs.filter(([, job]) => job.strategy?.matrix?.node).length;
 }
 
+function resultJobAlreadyExists(jobs) {
+  return jobs.some(([jobName]) => 'workflow-result' === jobName);
+}
+
 export default function ({versions: matrixOfNodeVersions, jobs, runner}) {
   if (matrixOfNodeVersions && noMatrixJobExistsIn(jobs)) {
     return [['verify-matrix', matrixVerification({versions: matrixOfNodeVersions, runner})], ...jobs];
   }
 
+  if (!resultJobAlreadyExists(jobs)) return [...jobs, ['workflow-result', scaffoldWorkflowResultJob()]];
+
   return jobs;
 }

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

@@ -4,8 +4,10 @@ import {when} from 'jest-when';
 
 import {matrixVerification} from './scaffolder.js';
 import insertMissingJobs from './missing-job-inserter.js';
+import {scaffold as scaffoldWorkflowResultJob} from './workflow-result/index.js';
 
 vi.mock('./scaffolder.js');
+vi.mock('./workflow-result/index.js');
 
 describe('missing job inserter', () => {
   describe('matrix verification', () => {
@@ -51,16 +53,26 @@ describe('missing job inserter', () => {
     it('should not insert a matrix verification job if a matrix job already exists for node', async () => {
       const jobs = [
         ...any.listOf(() => ([any.word(), any.simpleObject()])),
-        [any.word(), {strategy: {matrix: {node: {}}}}]
+        [any.word(), {strategy: {matrix: {node: {}}}}],
+        ['workflow-result', any.simpleObject()]
       ];
 
       expect(insertMissingJobs({versions: matrixOfNodeVersions, jobs})).toEqual(jobs);
     });
 
     it('should not insert a matrix verification job if no matrix of node versions is provided', async () => {
-      const jobs = any.listOf(() => ([any.word(), any.simpleObject()]));
+      const jobs = [...any.listOf(() => ([any.word(), any.simpleObject()])), ['workflow-result', any.simpleObject()]];
 
       expect(insertMissingJobs({versions: undefined, jobs})).toEqual(jobs);
     });
+
+    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);
+
+      expect(insertMissingJobs({jobs}))
+        .toEqual([...jobs, ['workflow-result', resultJob]]);
+    });
   });
 });

src/jobs/workflow-result/index.js

@@ -0,0 +1 @@
+export {default as scaffold} from './scaffolder.js';

src/jobs/workflow-result/scaffolder.js

@@ -0,0 +1,22 @@
+export default function () {
+  return {
+    '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'
+      }
+    ]
+  };
+}

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

@@ -0,0 +1,28 @@
+import {it, expect, describe} from 'vitest';
+
+import scaffoldWorkflowResultJob from './scaffolder.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'
+        }
+      ]
+    });
+  });
+});

test/integration/features/lift/result.feature

@@ -0,0 +1,25 @@
+Feature: Overall Workflow Result
+
+  Scenario: Existing result job
+    Given a CI workflow exists
+    And a "workflow-result" job exists
+    When the project is lifted
+    Then the workflow-result job exists
+    And the "workflow-result" job is unchanged
+
+  Scenario: No existing result job, existing verify
+    Given a CI workflow exists
+    And a "verify" job exists
+    When the project is lifted
+    Then the workflow-result job exists
+    And the workflow-result job depends on "verify"
+
+  @wip
+  Scenario: No existing result job, existing verify and verify-matrix
+    Given a CI workflow exists
+    And a "verify" job exists
+    And a "verify-matrix" job exists
+    When the project is lifted
+    Then the workflow-result job exists
+    And the workflow-result job depends on "verify"
+    And the workflow-result job depends on "verify-matrix"

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

@@ -14,6 +14,8 @@ import any from '@travi/any';
 
 Before(async function () {
   this.prTriggerConfig = any.simpleObject();
+
+  this.injectedJobs = [];
 });
 
 Given('a CI workflow exists', async function () {
@@ -32,6 +34,25 @@ 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 job = any.simpleObject();
+
+  this.injectedJobs[jobName] = job;
+
+  await writeWorkflowFile({
+    projectRoot: this.projectRoot,
+    name: 'node-ci',
+    config: {
+      ...existingWorkflowContents,
+      jobs: {
+        ...existingWorkflowContents.jobs,
+        [jobName]: job
+      }
+    }
+  });
+});
+
 Then('the ci config remains unchanged', async function () {
   const {on: triggers, jobs} = await loadWorkflowFile({projectRoot: this.projectRoot, name: 'node-ci'});
 
@@ -79,3 +100,21 @@ 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'});
+
+  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'});
+
+  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'});
+
+  assert.include(jobs['workflow-result'].needs, jobName);
+});