Add more tests

.github/workflows/build.yml

@@ -9,7 +9,7 @@ on:
 jobs:
   build:
     name: Build and test
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v2
       - uses: actions/setup-node@v2
@@ -22,7 +22,9 @@ jobs:
       - name: Setup AWS credentials
         run: |
           mkdir ~/.aws
-          echo -e "[default]\naws_access_key_id=''\naws_secret_access_key=''" > ~/.aws/credentials
+          # DynamoDB Local now validates credentials and rejects empty/invalid
+          # ones with UnrecognizedClientException, so use non-empty placeholders.
+          echo -e "[default]\naws_access_key_id=fakeMyKeyId\naws_secret_access_key=fakeSecretAccessKey" > ~/.aws/credentials
       - name: Setup Serverless Offline & Run Tests
         run: yarn ci
       - name: Coveralls

.github/workflows/codeql-analysis.yml

@@ -9,7 +9,7 @@ on:
 jobs:
   analyse:
     name: Analyse
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-latest
 
     steps:
     - name: Checkout repository

.github/workflows/deploy.yml

@@ -7,7 +7,7 @@ on:
 jobs:
   deploy-dev:
     name: Deploy to dev
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-latest
     environment: dev
     steps:
       - uses: actions/checkout@v2
@@ -26,7 +26,7 @@ jobs:
           AWS_SECRET_ACCESS_KEY: ${{ secrets.AWS_SECRET_ACCESS_KEY }}
   deploy-prod:
     name: Deploy to prod
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-latest
     environment: prod
     steps:
       - uses: actions/checkout@v2

src/handlers/slack/infra.ts

@@ -5,6 +5,7 @@ import LockBot from "../../lock-bot";
 import DynamoDBLockRepo from "../../storage/dynamodb-lock-repo";
 import TokenAuthorizer from "../../token-authorizer";
 import DynamoDBAccessTokenRepo from "../../storage/dynamodb-token-repo";
+import createInstallationStore from "./installation-store";
 
 const documentClient = new DocumentClient();
 
@@ -20,58 +21,10 @@ export const expressReceiver = new ExpressReceiver({
   stateSecret: env.get("STATE_SECRET").required().asString(),
   scopes: ["commands"],
   processBeforeResponse: true,
-  installationStore: {
-    storeInstallation: async (installation, logger) => {
-      if (installation.isEnterpriseInstall && installation.enterprise) {
-        logger?.error("Enterprise storeInstallation attempt failed.");
-        throw new Error("Enterprise installation not supported");
-      } else if (installation.team) {
-        await documentClient
-          .put({
-            TableName: installationsTableName,
-            Item: {
-              Team: installation.team.id,
-              Installation: installation,
-            },
-          })
-          .promise();
-        const { team, user, bot } = installation;
-        logger?.info("Installation stored.", {
-          team,
-          userId: user.id,
-          botScopes: bot?.scopes,
-        });
-      } else {
-        throw new Error("Failed to store installation");
-      }
-    },
-    fetchInstallation: async (installQuery, logger) => {
-      if (
-        installQuery.isEnterpriseInstall &&
-        installQuery.enterpriseId !== undefined
-      ) {
-        logger?.error("Enterprise fetchInstallation attempt failed.");
-        throw new Error("Enterprise installation not supported");
-      } else if (installQuery.teamId !== undefined) {
-        const result = await documentClient
-          .get({
-            TableName: installationsTableName,
-            Key: { Team: installQuery.teamId },
-          })
-          .promise();
-        const installation = result.Item?.Installation;
-        const { team, user, bot } = installation;
-        logger?.info("Installation fetched.", {
-          team,
-          userId: user.id,
-          botScopes: bot?.scopes,
-        });
-        return Promise.resolve(installation);
-      } else {
-        throw new Error("Failed to fetch installation");
-      }
-    },
-  },
+  installationStore: createInstallationStore(
+    documentClient,
+    installationsTableName
+  ),
 });
 
 export const app = new App({

src/handlers/slack/installation-store.ts

@@ -0,0 +1,60 @@
+import { DocumentClient } from "aws-sdk/clients/dynamodb";
+import { InstallationStore } from "@slack/bolt";
+
+const createInstallationStore = (
+  documentClient: DocumentClient,
+  installationsTableName: string
+): InstallationStore => ({
+  storeInstallation: async (installation, logger) => {
+    if (installation.isEnterpriseInstall && installation.enterprise) {
+      logger?.error("Enterprise storeInstallation attempt failed.");
+      throw new Error("Enterprise installation not supported");
+    } else if (installation.team) {
+      await documentClient
+        .put({
+          TableName: installationsTableName,
+          Item: {
+            Team: installation.team.id,
+            Installation: installation,
+          },
+        })
+        .promise();
+      const { team, user, bot } = installation;
+      logger?.info("Installation stored.", {
+        team,
+        userId: user.id,
+        botScopes: bot?.scopes,
+      });
+    } else {
+      throw new Error("Failed to store installation");
+    }
+  },
+  fetchInstallation: async (installQuery, logger) => {
+    if (
+      installQuery.isEnterpriseInstall &&
+      installQuery.enterpriseId !== undefined
+    ) {
+      logger?.error("Enterprise fetchInstallation attempt failed.");
+      throw new Error("Enterprise installation not supported");
+    } else if (installQuery.teamId !== undefined) {
+      const result = await documentClient
+        .get({
+          TableName: installationsTableName,
+          Key: { Team: installQuery.teamId },
+        })
+        .promise();
+      const installation = result.Item?.Installation;
+      const { team, user, bot } = installation;
+      logger?.info("Installation fetched.", {
+        team,
+        userId: user.id,
+        botScopes: bot?.scopes,
+      });
+      return Promise.resolve(installation);
+    } else {
+      throw new Error("Failed to fetch installation");
+    }
+  },
+});
+
+export default createInstallationStore;

src/handlers/swagger/app.ts

@@ -0,0 +1,28 @@
+import express from "express";
+
+const createSwaggerApp = (
+  stage: string,
+  swaggerHtml: string,
+  openApiJson: Record<string, unknown>
+) => {
+  const openApiWithServers = {
+    ...openApiJson,
+    servers: [{ url: `/${stage}` }],
+  };
+
+  const app = express();
+
+  app.get("/api-docs", async (req, res) => {
+    res.set("Content-Type", "text/html; charset=utf-8");
+    res.send(swaggerHtml);
+  });
+
+  app.get(["/openapi.json", "/api-docs/openapi.json"], async (req, res) => {
+    res.set("Content-Type", "application/json; charset=utf-8");
+    res.send(openApiWithServers);
+  });
+
+  return app;
+};
+
+export default createSwaggerApp;

src/handlers/swagger/index.ts

@@ -1,23 +1,12 @@
-import express from "express";
 import * as env from "env-var";
 import serverlessExpress from "@vendia/serverless-express";
+import createSwaggerApp from "./app";
 
+// swagger.html is inlined as text by webpack's text-loader (webpack.config.js).
 const swaggerHtml = require("./swagger.html");
 const openApiJson = require("./openapi.json");
 
 const stage = env.get("SERVERLESS_STAGE").required().asString();
-openApiJson.servers = [{ url: `/${stage}` }];
-
-const app = express();
-
-app.get("/api-docs", async (req, res) => {
-  res.set("Content-Type", "text/html; charset=utf-8");
-  res.send(swaggerHtml);
-});
-
-app.get(["/openapi.json", "/api-docs/openapi.json"], async (req, res) => {
-  res.set("Content-Type", "application/json; charset=utf-8");
-  res.send(openApiJson);
-});
+const app = createSwaggerApp(stage, swaggerHtml, openApiJson);
 
 exports.handler = serverlessExpress({ app });

test/command-parsers.test.ts

@@ -0,0 +1,55 @@
+import {
+  parseUnlock,
+  getFirstParam,
+} from "../src/handlers/slack/command-parsers";
+
+describe("parseUnlock", () => {
+  test("parses a resource with no options as not forced", () => {
+    expect(parseUnlock("staging")).toEqual({
+      resource: "staging",
+      force: false,
+    });
+  });
+
+  test("parses the force option", () => {
+    expect(parseUnlock("staging force")).toEqual({
+      resource: "staging",
+      force: true,
+    });
+  });
+
+  test("treats an unrecognised second word as not forced", () => {
+    expect(parseUnlock("staging please")).toEqual({
+      resource: "staging",
+      force: false,
+    });
+  });
+
+  test("only the exact lowercase word 'force' enables force", () => {
+    expect(parseUnlock("staging FORCE")).toEqual({
+      resource: "staging",
+      force: false,
+    });
+  });
+
+  test("returns an empty resource for empty input", () => {
+    expect(parseUnlock("")).toEqual({
+      resource: "",
+      force: false,
+    });
+  });
+});
+
+describe("getFirstParam", () => {
+  test("returns the first space-separated word", () => {
+    expect(getFirstParam("staging extra args")).toEqual("staging");
+  });
+
+  test("returns the whole string when there is a single word", () => {
+    expect(getFirstParam("staging")).toEqual("staging");
+  });
+
+  test("returns an empty string for empty input", () => {
+    expect(getFirstParam("")).toEqual("");
+  });
+});