Merge pull request #4790 from cloud-gov/feat-add-editor-site-build-webhook

feat: Add webhook to create editor site builds

Author: apburnes

api/controllers/webhook.js

@@ -44,4 +44,13 @@ module.exports = wrapHandlers({
 
     return res.ok();
   },
+
+  async siteBuild(req, res) {
+    const { body } = req;
+    const siteId = decrypt(body.siteId, encryption.key);
+
+    await Webhooks.createBuildForEditor(siteId);
+
+    return res.ok();
+  },
 });

api/routers/webhook.js

@@ -32,32 +32,47 @@ function verifySignature(req, res, next) {
   next();
 }
 
-function verifySiteRequest(req, res, next) {
-  const { body: payload } = req;
-  const expectedKeys = ['userEmail', 'apiKey', 'siteId', 'siteName', 'org'].sort();
+function verifySiteRequest(expectedKeys) {
+  return (req, res, next) => {
+    const { body: payload } = req;
+    const sortedExpectedKeys = expectedKeys.sort();
 
-  // ToDo Add additional headers to check if request is legit
+    // ToDo Add additional headers to check if request is legit
 
-  try {
-    const payloadKeys = Object.keys(payload).sort();
+    try {
+      const payloadKeys = Object.keys(payload).sort();
 
-    if (payloadKeys.length !== expectedKeys.length) {
-      throw new Error('Invalid request payload');
-    }
+      if (payloadKeys.length !== sortedExpectedKeys.length) {
+        throw new Error('Invalid request payload');
+      }
 
-    const hasKeys = payloadKeys.every((value, index) => value === expectedKeys[index]);
+      const hasKeys = payloadKeys.every(
+        (value, index) => value === sortedExpectedKeys[index],
+      );
 
-    if (!hasKeys) throw new Error('Invalid request payload');
-  } catch (err) {
-    res.badRequest();
-    next(err);
-  }
+      if (!hasKeys) throw new Error('Invalid request payload');
+    } catch (err) {
+      res.badRequest();
+      next(err);
+    }
 
-  next();
+    next();
+  };
 }
 
+const verifyNewEditorSite = verifySiteRequest([
+  'userEmail',
+  'apiKey',
+  'siteId',
+  'siteName',
+  'org',
+]);
+
+const verifyEditorSiteBuild = verifySiteRequest(['siteId']);
+
 router.post('/webhook/github', verifySignature, WebhookController.github);
 router.post('/webhook/organization', verifySignature, WebhookController.organization);
-router.post('/webhook/site', verifySiteRequest, WebhookController.site);
+router.post('/webhook/site', verifyNewEditorSite, WebhookController.site);
+router.post('/webhook/site/build', verifyEditorSiteBuild, WebhookController.siteBuild);
 
 module.exports = router;

api/services/Webhooks.js

@@ -3,6 +3,8 @@ const { Build, User, Site, Event, Organization } = require('../models');
 const GithubBuildHelper = require('./GithubBuildHelper');
 const EventCreator = require('./EventCreator');
 
+const { OPS_EMAIL } = process.env;
+
 const findSiteForWebhookRequest = (payload) => {
   const [owner, repository] = payload.repository.full_name.split('/');
 
@@ -15,6 +17,32 @@ const findSiteForWebhookRequest = (payload) => {
   });
 };
 
+const createBuildForEditor = async (siteId) => {
+  const branch = 'main';
+  const { id: userId, username } = await User.byUAAEmail(OPS_EMAIL).findOne();
+
+  const queuedBuild = await Build.findOne({
+    where: {
+      branch,
+      state: ['created', 'queued'],
+      site: siteId,
+    },
+  });
+
+  if (queuedBuild) {
+    return;
+  }
+
+  const build = await Build.create({
+    branch,
+    site: siteId,
+    user: userId,
+    username,
+  });
+
+  return build.enqueue();
+};
+
 const shouldBuildForSite = (site) =>
   site?.isActive && (!site.Organization || site.Organization.isActive);
 
@@ -116,6 +144,7 @@ const pushWebhookRequest = async (payload) => {
 };
 
 module.exports = {
+  createBuildForEditor,
   organizationWebhookRequest,
   pushWebhookRequest,
 };

test/api/requests/webhook.test.js

@@ -1,3 +1,4 @@
+const { expect } = require('chai');
 const crypto = require('crypto');
 const sinon = require('sinon');
 const request = require('supertest');
@@ -7,6 +8,9 @@ const factory = require('../support/factory');
 const { createSiteUserOrg } = require('../support/site-user');
 const EventCreator = require('../../../api/services/EventCreator');
 const Webhooks = require('../../../api/services/Webhooks');
+const Encryptor = require('../../../api/services/Encryptor');
+const { encryption } = require('../../../config');
+const QueueJobs = require('../../../api/queue-jobs');
 
 describe('Webhook API', () => {
   const signWebhookPayload = (payload) => {
@@ -229,10 +233,56 @@ describe('Webhook API', () => {
   });
 
   describe('POST /webhook/site', () => {
+    it('should respon with a 200 with valid payload', async () => {
+      const userEmail = '[email protected]';
+      const apiKey = 'an-api-key';
+      const siteId = '123';
+      const siteName = 'site';
+      const org = 'org';
+      const payload = Encryptor.encryptObjectValues(
+        { userEmail, apiKey, siteId, siteName, org },
+        encryption.key,
+      );
+
+      const stub = sinon
+        .stub(QueueJobs.prototype, 'startCreateEditorSiteTask')
+        .resolves();
+
+      await request(app).post('/webhook/site').send(payload).expect(200);
+
+      expect(
+        stub.calledOnceWith({
+          userEmail,
+          apiKey,
+          siteId,
+          siteName,
+          orgName: org,
+        }),
+      ).to.be.equal(true);
+    });
+
     it('should respond with a 400 if payload is invalid', async () => {
       const payload = { bad: 'payload' };
 
       await request(app).post('/webhook/site').send(payload).expect(400);
     });
   });
+
+  describe('POST /webhook/site/build', () => {
+    it('should respon with a 200 with valid payload', async () => {
+      const siteId = '123';
+      const payload = Encryptor.encryptObjectValues({ siteId }, encryption.key);
+
+      const stub = sinon.stub(Webhooks, 'createBuildForEditor').resolves();
+
+      await request(app).post('/webhook/site/build').send(payload).expect(200);
+      expect(stub.calledOnceWith(siteId)).to.be.equal(true);
+    });
+
+    it('should respond with a 400 if payload is invalid', async () => {
+      const payload = { bad: 'payload' };
+
+      await request(app).post('/webhook/site/build').send(payload).expect(400);
+    });
+  });
 });

test/api/unit/services/Webhooks.test.js

@@ -57,6 +57,65 @@ describe('Webhooks Service', () => {
     sinon.restore();
   });
 
+  describe('createBuildForEditor', () => {
+    // Generate Ops User
+    before(() => factory.userWithUAAIdentity.create({ email: process.env.OPS_EMAIL }));
+    after(() => User.truncate());
+
+    it('should start a site build', async () => {
+      const site = await factory.site();
+      const stub = sinon.stub(Build.prototype, 'enqueue').resolves();
+      const numBuildsBefore = await Build.count({
+        where: {
+          site: site.id,
+        },
+      });
+      expect(numBuildsBefore).to.eq(0);
+
+      await Webhooks.createBuildForEditor(site.id);
+
+      expect(stub.calledOnce).to.be.equal(true);
+
+      const numBuildsAfter = await Build.count({
+        where: {
+          site: site.id,
+        },
+      });
+      expect(numBuildsAfter).to.eq(1);
+
+      const build = await Build.findOne({ where: { site: site.id } });
+      expect(build.branch).to.equal('main');
+    });
+
+    it('should not start a new build if one is created or queued', async () => {
+      const site = await factory.site();
+      const stub = sinon.stub(Build.prototype, 'enqueue').resolves();
+      await Build.create({
+        branch: 'main',
+        site: site.id,
+        username: 'test',
+        state: 'queued',
+      });
+      const numBuildsBefore = await Build.count({
+        where: {
+          site: site.id,
+        },
+      });
+      expect(numBuildsBefore).to.eq(1);
+
+      await Webhooks.createBuildForEditor(site.id);
+
+      expect(stub.notCalled).to.be.equal(true);
+
+      const numBuildsAfter = await Build.count({
+        where: {
+          site: site.id,
+        },
+      });
+      expect(numBuildsAfter).to.eq(1);
+    });
+  });
+
   describe('pushWebhookRequest', () => {
     beforeEach(() => {
       nock.cleanAll();