feat(lift): migrated the legacy release job to instead trigger the separate workflow

Author: travi

README.md

@@ -54,7 +54,7 @@ import {scaffold, test, lift} from '@form8ion/commit-convention';
   await scaffold({projectRoot, configs: {}});
 
   if (await test({projectRoot})) {
-    await lift({projectRoot, packageManager: packageManagers.NPM});
+    await lift({projectRoot, packageManager: packageManagers.NPM, vcs: {owner: 'foo', name: 'bar'}});
   }
 })();
 ```

src/semantic-release/ci-providers/github-workflows/lifter-test.js

@@ -1,3 +1,5 @@
+import {promises as fs} from 'fs';
+import jsYaml from 'js-yaml';
 import * as core from '@form8ion/core';
 
 import any from '@travi/any';
@@ -10,29 +12,83 @@ import lift from './lifter';
 suite('github-workflows lifter for semantic-release', () => {
   let sandbox;
   const projectRoot = any.string();
+  const workflowsDirectory = `${projectRoot}/.github/workflows`;
+  const vcsName = any.word();
+  const vcsOwner = any.word();
+  const vcsDetails = {name: vcsName, owner: vcsOwner};
 
   setup(() => {
     sandbox = sinon.createSandbox();
 
+    sandbox.stub(fs, 'readFile');
+    sandbox.stub(fs, 'writeFile');
+    sandbox.stub(jsYaml, 'load');
+    sandbox.stub(jsYaml, 'dump');
     sandbox.stub(core, 'fileExists');
     sandbox.stub(scaffolder, 'default');
+
+    const commonVerificationWorkflowContents = any.string();
+    fs.readFile.withArgs(`${workflowsDirectory}/node-ci.yml`, 'utf-8').resolves(commonVerificationWorkflowContents);
+    jsYaml.load.withArgs(commonVerificationWorkflowContents).returns({jobs: {}});
   });
 
   teardown(() => sandbox.restore());
 
   test('that the release workflow is added if it doesnt already exist', async () => {
     core.fileExists.resolves(false);
 
-    await lift({projectRoot});
+    await lift({projectRoot, vcs: vcsDetails});
 
     assert.calledWith(scaffolder.default, {projectRoot});
   });
 
   test('that the release workflow is not added if it already exists', async () => {
-    core.fileExists.withArgs(`${projectRoot}/.github/workflows/release.yml`).resolves(true);
+    core.fileExists.withArgs(`${workflowsDirectory}/release.yml`).resolves(true);
 
-    await lift({projectRoot});
+    await lift({projectRoot, vcs: vcsDetails});
 
     assert.notCalled(scaffolder.default);
   });
+
+  test('that the legacy release job is removed', async () => {
+    const verificationWorkflowContents = any.string();
+    const parsedVerificationWorkflowContents = any.simpleObject();
+    const jobs = any.simpleObject();
+    const legacyReleaseJob = any.simpleObject();
+    const updatedVerificationWorkflowContents = any.string();
+    core.fileExists.resolves(true);
+    fs.readFile.withArgs(`${workflowsDirectory}/node-ci.yml`, 'utf-8').resolves(verificationWorkflowContents);
+    jsYaml.load
+      .withArgs(verificationWorkflowContents)
+      .returns({...parsedVerificationWorkflowContents, jobs: {...jobs, release: legacyReleaseJob}});
+    jsYaml.dump
+      .withArgs({
+        ...parsedVerificationWorkflowContents,
+        jobs: {
+          ...jobs,
+          'trigger-release': {
+            'runs-on': 'ubuntu-latest',
+            if: "github.event_name == 'push'",
+            steps: [{
+              uses: 'octokit/[email protected]',
+              with: {
+                route: 'POST /repos/{owner}/{repo}/actions/workflows/{workflow_id}/dispatches',
+                owner: vcsOwner,
+                repo: vcsName,
+                ref: '${{ github.ref }}',                       // eslint-disable-line no-template-curly-in-string
+                workflow_id: 'release.yml',
+                env: {
+                  GITHUB_TOKEN: '${{ secrets.GH_PAT }}'         // eslint-disable-line no-template-curly-in-string
+                }
+              }
+            }]
+          }
+        }
+      })
+      .returns(updatedVerificationWorkflowContents);
+
+    await lift({projectRoot, vcs: vcsDetails});
+
+    assert.calledWith(fs.writeFile, `${workflowsDirectory}/node-ci.yml`, updatedVerificationWorkflowContents);
+  });
 });

src/semantic-release/ci-providers/github-workflows/lifter.js

@@ -1,9 +1,39 @@
+import {promises as fs} from 'fs';
+import {load, dump} from 'js-yaml';
 import {fileExists} from '@form8ion/core';
 
 import scaffoldReleaseWorkflow from './scaffolder';
 
-export default async function ({projectRoot}) {
+export default async function ({projectRoot, vcs: {name: vcsProjectName, owner: vcsOwner}}) {
+  const pathToVerificationWorkflow = `${projectRoot}/.github/workflows/node-ci.yml`;
+
   if (!await fileExists(`${projectRoot}/.github/workflows/release.yml`)) {
     await scaffoldReleaseWorkflow({projectRoot});
   }
+
+  const parsedVerificationWorkflowDetails = load(await fs.readFile(pathToVerificationWorkflow, 'utf-8'));
+  const {release, ...otherJobs} = parsedVerificationWorkflowDetails.jobs;
+  parsedVerificationWorkflowDetails.jobs = {
+    ...otherJobs,
+    'trigger-release': {
+      'runs-on': 'ubuntu-latest',
+      if: "github.event_name == 'push'",
+      steps: [{
+        uses: 'octokit/[email protected]',
+        with: {
+          route: 'POST /repos/{owner}/{repo}/actions/workflows/{workflow_id}/dispatches',
+          owner: vcsOwner,
+          repo: vcsProjectName,
+          ref: '${{ github.ref }}',                       // eslint-disable-line no-template-curly-in-string
+          workflow_id: 'release.yml',
+          env: {
+            GITHUB_TOKEN: '${{ secrets.GH_PAT }}'         // eslint-disable-line no-template-curly-in-string
+          }
+        }
+      }]
+
+    }
+  };
+
+  await fs.writeFile(pathToVerificationWorkflow, dump(parsedVerificationWorkflowDetails));
 }

src/semantic-release/lifter-test.js

@@ -27,9 +27,10 @@ suite('semantic-release lifter', () => {
   });
 
   test('that the ci provider is lifted when supported', async () => {
+    const vcsDetails = any.simpleObject();
     githubWorkflowsTester.default.withArgs({projectRoot}).resolves(true);
 
-    assert.deepEqual(await lift({projectRoot}), {});
-    assert.calledWith(githubWorkflowsLifter.default, {projectRoot});
+    assert.deepEqual(await lift({projectRoot, vcs: vcsDetails}), {});
+    assert.calledWith(githubWorkflowsLifter.default, {projectRoot, vcs: vcsDetails});
   });
 });

src/semantic-release/lifter.js

@@ -1,7 +1,7 @@
 import {test as ciProviderCanBeLifted, lift as liftCiProvider} from './ci-providers';
 
-export default async function ({projectRoot}) {
-  if (await ciProviderCanBeLifted({projectRoot})) await liftCiProvider({projectRoot});
+export default async function ({projectRoot, vcs}) {
+  if (await ciProviderCanBeLifted({projectRoot})) await liftCiProvider({projectRoot, vcs});
 
   return {};
 }

test/integration/features/lifter.feature

@@ -4,4 +4,24 @@ Feature: Lift
     Given semantic-release is configured
     And legacy releases are configured in a GitHub workflow
     When the project is lifted
-    Then the release workflow if defined
+    Then the release workflow is defined
+    And the verification workflow triggers the release workflow
+
+  Scenario: modern semantic-release in GitHub workflows
+    Given semantic-release is configured
+    And modern releases are configured in a GitHub workflow
+    When the project is lifted
+    Then the release workflow is defined
+
+  Scenario: no existing release
+    Given semantic-release is not configured
+    And no release is configured in a GitHub workflow
+    When the project is lifted
+    Then the release workflow is not defined
+    And the verification workflow does not trigger the release workflow
+
+  Scenario: no GitHub workflows
+    Given semantic-release is configured
+    But no GitHub workflows exist
+    When the project is lifted
+    Then the release workflow is not defined

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

@@ -1,4 +1,5 @@
 import {resolve} from 'path';
+import {dump} from 'js-yaml';
 
 import {After, When} from '@cucumber/cucumber';
 import stubbedFs from 'mock-fs';
@@ -26,8 +27,31 @@ When('the project is lifted', async function () {
   // eslint-disable-next-line import/no-extraneous-dependencies,import/no-unresolved
   const {test, lift} = require('@form8ion/commit-convention');
 
+  this.projectName = any.word();
+  this.vcsOwner = any.word();
+
   stubbedFs({
-    ...this.semanticReleaseGithubWorkflow && {'.github': {workflows: {}}},
+    ...this.githubWorkflows && {
+      '.github': {
+        workflows: {
+          ...this.verificationWorkflow && {
+            'node-ci.yml': dump({
+              jobs: {
+                ...this.nodeCiWithReleaseJob && {
+                  release: {}
+                },
+                ...this.nodeCiWithTriggerReleaseJob && {
+                  'trigger-release': {}
+                }
+              }
+            })
+          },
+          ...this.releaseWorkflow && {
+            'release.yml': dump({})
+          }
+        }
+      }
+    },
     node_modules: stubbedNodeModules,
     'package.json': JSON.stringify({
       ...any.simpleObject(),
@@ -36,6 +60,6 @@ When('the project is lifted', async function () {
   });
 
   if (await test({projectRoot})) {
-    await lift({projectRoot});
+    await lift({projectRoot, vcs: {owner: this.vcsOwner, name: this.projectName}});
   }
 });

test/integration/features/step_definitions/github-workflows-steps.js

@@ -1,12 +1,69 @@
+import {promises as fs} from 'fs';
 import {fileExists} from '@form8ion/core';
 
 import {Given, Then} from '@cucumber/cucumber';
 import {assert} from 'chai';
+import {load} from 'js-yaml';
 
 Given('legacy releases are configured in a GitHub workflow', async function () {
-  this.semanticReleaseGithubWorkflow = 'legacy';
+  this.githubWorkflows = true;
+  this.verificationWorkflow = true;
+  this.nodeCiWithReleaseJob = true;
 });
 
-Then('the release workflow if defined', async function () {
+Given('modern releases are configured in a GitHub workflow', async function () {
+  this.githubWorkflows = true;
+  this.verificationWorkflow = true;
+  this.releaseWorkflow = true;
+  this.nodeCiWithTriggerReleaseJob = true;
+});
+
+Given('no release is configured in a GitHub workflow', async function () {
+  this.githubWorkflows = true;
+  this.verificationWorkflow = true;
+  this.nodeCiWithReleaseJob = false;
+  this.nodeCiWithTriggerReleaseJob = false;
+});
+
+Given('no GitHub workflows exist', async function () {
+  this.githubWorkflows = false;
+});
+
+Then('the release workflow is defined', async function () {
   assert.isTrue(await fileExists(`${process.cwd()}/.github/workflows/release.yml`));
 });
+
+Then('the release workflow is not defined', async function () {
+  assert.isFalse(await fileExists(`${process.cwd()}/.github/workflows/release.yml`));
+});
+
+Then('the verification workflow triggers the release workflow', async function () {
+  const verificationWorkflowDefinition = load(await fs.readFile(
+    `${process.cwd()}/.github/workflows/node-ci.yml`,
+    'utf-8'
+  ));
+
+  const verificationWorkflowJobs = verificationWorkflowDefinition.jobs;
+  const triggerReleaseJob = verificationWorkflowJobs['trigger-release'];
+
+  assert.isUndefined(verificationWorkflowJobs.release);
+  assert.equal(triggerReleaseJob.if, "github.event_name == 'push'");
+
+  const releaseTriggerRequest = triggerReleaseJob.steps[0];
+  assert.equal(releaseTriggerRequest.uses, 'octokit/[email protected]');
+  assert.equal(
+    releaseTriggerRequest.with.route,
+    'POST /repos/{owner}/{repo}/actions/workflows/{workflow_id}/dispatches'
+  );
+  assert.equal(releaseTriggerRequest.with.owner, this.vcsOwner);
+  assert.equal(releaseTriggerRequest.with.repo, this.projectName);
+});
+
+Then('the verification workflow does not trigger the release workflow', async function () {
+  const verificationWorkflowDefinition = load(await fs.readFile(
+    `${process.cwd()}/.github/workflows/node-ci.yml`,
+    'utf-8'
+  ));
+
+  assert.isUndefined(verificationWorkflowDefinition.jobs['trigger-release']);
+});

test/integration/features/step_definitions/semantic-release-steps.js

@@ -3,3 +3,7 @@ import {Given} from '@cucumber/cucumber';
 Given('semantic-release is configured', async function () {
   this.semanticReleaseConfigured = true;
 });
+
+Given('semantic-release is not configured', async function () {
+  this.semanticReleaseConfigured = false;
+});