#8 Add router unit tests using supertest

Also moved the template processing from index to router.

3 files changed, 273 insertions, 35 deletions

diff --git a/src/index.ts b/src/index.ts
index 71da73c..76620e8 100644
--- a/src/index.ts
+++ b/src/index.ts
@@ -9,7 +9,6 @@ import expressWinston from "express-winston";
 
 dotenv.config();
 
-import processTemplate, { Template } from "./templates";
 import routes from "./routes";
 import Metadata from "./metadata";
 import loggerConfig from "./util/logger";
@@ -18,7 +17,6 @@ import { configOrError, handleShutdown } from "./util/config";
 // Start-up configuration
 const BIND_ADDRESS = process.env.BIND_ADDRESS ?? "localhost";
 const PORT = Number(process.env.PORT ?? 3000);
-const TARGET_URL = process.env.TARGET_URL ?? "http://localhost:3000";
 
 const logger = winston.createLogger(loggerConfig("ROOT"));
 
@@ -32,39 +30,6 @@ if (!path.isAbsolute(HOST_DIR)) {
   process.exit(1);
 }
 
-// prepare template files
-const bashTemplate = {
-  inputFile: path.join(__dirname, "..", "public", "templates", "bash.template"),
-  outputFile: path.join(HOST_DIR, "bash"),
-  context: { TARGET_URL }
-} as Template;
-const indexTemplate = {
-  inputFile: path.join(__dirname, "..", "public", "templates", "index.html.template"),
-  outputFile: path.join(HOST_DIR, "index.html"),
-  context: { TARGET_URL }
-} as Template;
-
-processTemplate(bashTemplate)
-  .then(template => {
-    logger.debug("Generated '%s' from template file", template.outputFile);
-  })
-  .then(() => processTemplate(indexTemplate))
-  .then(template => {
-    logger.debug("Generated '%s' from template file", template.outputFile);
-  })
-  .catch(err => {
-    logger.error("Unable to process template file: %s", err);
-
-    // if the output file exists, then we are fine with continuing without
-    return fs.promises.access(bashTemplate.outputFile, fs.constants.R_OK);
-  })
-  .then(() => fs.promises.access(indexTemplate.outputFile, fs.constants.R_OK))
-  .catch(err => {
-    logger.error("Cannot proceed: %s", err);
-
-    process.exit(1);
-  });
-
 new MongoClient(MONGO_URI, { useUnifiedTopology: true }).connect(
   (err, mongo) => {
     if (err !== null) {
diff --git a/src/routes.test.ts b/src/routes.test.ts
new file mode 100644
index 0000000..b4979d6
--- /dev/null
+++ b/src/routes.test.ts
@@ -0,0 +1,239 @@
+import _request from "supertest";
+import express from "express";
+import dotenv from "dotenv";
+import fs from "fs";
+import path from "path";
+
+dotenv.config();
+
+process.env.UPLOAD_LIMIT = "40000";
+
+import { configOrError } from "./util/config";
+import routes from "./routes";
+import Metadata from "./metadata";
+import { Db } from "mongodb";
+import { badgen } from "badgen";
+import { BranchNotFoundError } from "./errors";
+
+type MetadataMockType = {
+  database: Db;
+  getHeadCommit: jest.Mock;
+  updateBranch: jest.Mock;
+  createRepository: jest.Mock;
+};
+
+const mock = (headCommit: jest.Mock = jest.fn(() => new Promise(solv => solv("testcommit"))), updateBranch: jest.Mock = jest.fn(() => new Promise(solv => solv(true)))): MetadataMockType => ({
+  database: {} as Db,
+  getHeadCommit: headCommit,
+  updateBranch: updateBranch,
+  createRepository: jest.fn()
+});
+
+const request = (mockMeta: MetadataMockType = mock()) => {
+  const app = express();
+
+  app.use(routes(mockMeta as Metadata));
+  return _request(app);
+}
+
+const HOST_DIR = configOrError("HOST_DIR");
+const TARGET_URL = process.env.TARGET_URL ?? "http://localhost:3000";
+const TOKEN = process.env.TOKEN ?? "";
+
+describe("templates", () => {
+
+  describe("GET /bash", () => {
+    it("should return the bash file containing tbe curl command", async () => {
+      const res = await request()
+        .get("/bash")
+        .expect(200);
+      expect(res.text).toMatch("curl -X POST");
+      expect(res.text).toMatch(`url="${TARGET_URL}"`);
+    });
+  });
+
+  describe("GET /", () => {
+    it("should return the index HTML file containing the bash command", async () => {
+      const res = await request()
+        .get("/")
+        .expect("Content-Type", /html/)
+        .expect(200);
+      expect(res.text).toMatch(`bash <(curl -s ${TARGET_URL}/bash)`);
+    })
+  });
+});
+
+describe("Badges and reports", () => {
+
+  const report_path = path.join(HOST_DIR, "testorg", "testrepo", "testbranch", "testcommit");
+  const actual_report = path.join(__dirname, "..", "example_reports", "tarpaulin-report.html");
+  const fake_badge = badgen({
+    label: "coverage",
+    status: "120%",
+    color: "#E1C"
+  });
+
+  beforeAll(async () => {
+    // place test files on HOST_DIR
+    await fs.promises.mkdir(report_path, { recursive: true });
+    await fs.promises.copyFile(actual_report, path.join(report_path, "index.html"));
+    await fs.promises.writeFile(path.join(report_path, "badge.svg"), fake_badge);
+  });
+
+  describe("GET /v1/:org/:repo/:branch/:commit.html", () => {
+    it("should retrieve the stored report file", async () => {
+      const res = await request()
+        .get("/v1/testorg/testrepo/testbranch/testcommit.html")
+        .expect("Content-Type", /html/)
+        .expect(200);
+      const buffer = await fs.promises.readFile(actual_report);
+
+      expect(res.text).toEqual(buffer.toString("utf-8"));
+    });
+
+    it("should return 404 if file does not exist", async () => {
+      await request().get("/v1/neorg/nerepo/nebranch/necommit.html").expect(404);
+    });
+  });
+
+  describe("GET /v1/:org/:repo/:branch.html", () => {
+    it("should retrieve the stored report file with the associated head commit", async () => {
+      const mockMeta = mock();
+      const res = await request(mockMeta)
+        .get("/v1/testorg/testrepo/testbranch.html")
+        .expect("Content-Type", /html/)
+        .expect(200);
+      const buffer = await fs.promises.readFile(actual_report);
+
+      expect(mockMeta.getHeadCommit).toHaveBeenCalledTimes(1);
+      expect(res.text).toEqual(buffer.toString("utf-8"));
+    });
+
+    it("should return 404 if file does not exist", async () => {
+      await request().get("/v1/neorg/nerepo/nebranch.html").expect(404);
+    });
+
+    it("should return 404 if head commit not found", async () => {
+      const head = jest.fn(() => new Promise(solv => solv(new BranchNotFoundError())));
+      await request(mock(head)).get("/v1/testorg/testrepo/testbranch.html").expect(404);
+    });
+
+    it("should return 500 if promise is rejected", async () => {
+      const head = jest.fn(() => new Promise((_, rej) => rej("fooey")));
+      await request(mock(head)).get("/v1/testorg/testrepo/testbranch.html").expect(500);
+    });
+  });
+
+  describe("GET /v1/:org/:repo/:branch/:commit.svg", () => {
+    it("should retrieve the stored report badge", async () => {
+      const res = await request()
+        .get("/v1/testorg/testrepo/testbranch/testcommit.svg")
+        .expect("Content-Type", /svg/)
+        .expect(200);
+
+      expect(res.body.toString("utf-8")).toEqual(fake_badge);
+    });
+
+    it("should return 404 if file does not exist", async () => {
+      await request().get("/v1/neorg/nerepo/nebranch/necommit.svg").expect(404);
+    });
+  });
+
+  describe("GET /v1/:org/:repo/:branch.svg", () => {
+    it("should retrieve the stored report badge with the associated head commit", async () => {
+      const mockMeta = mock();
+      const res = await request(mockMeta)
+        .get("/v1/testorg/testrepo/testbranch.svg")
+        .expect("Content-Type", /svg/)
+        .expect(200);
+
+      expect(mockMeta.getHeadCommit).toHaveBeenCalledTimes(1);
+      expect(res.body.toString("utf-8")).toEqual(fake_badge);
+    });
+
+    it("should return 404 if file does not exist", async () => {
+      await request().get("/v1/neorg/nerepo/nebranch.svg").expect(404);
+    });
+
+    it("should return 404 if head commit not found", async () => {
+      const head = jest.fn(() => new Promise(solv => solv(new BranchNotFoundError())));
+      await request(mock(head)).get("/v1/testorg/testrepo/testbranch.svg").expect(404);
+    });
+
+    it("should return 500 if promise is rejected", async () => {
+      const head = jest.fn(() => new Promise((_, rej) => rej("fooey")));
+      await request(mock(head)).get("/v1/testorg/testrepo/testbranch.svg").expect(500);
+    });
+  });
+});
+
+describe("Uploads", () => {
+
+  const report_path = path.join(HOST_DIR, "testorg", "testrepo", "newthis", "newthat");
+  const data = fs.promises.readFile(path.join(__dirname, "..", "example_reports", "tarpaulin-report.html"));
+
+  beforeEach(async () => {
+    await fs.promises.rmdir(report_path).catch(() => { });
+  });
+
+  describe("POST /v1/:org/:repo/:branch/:commit.html", () => {
+    it("should upload the report and generate a badge", async () => {
+      const mockMeta = mock();
+      await request(mockMeta)
+        .post(`/v1/testorg/testrepo/newthis/newthat.html?token=${TOKEN}&format=tarpaulin`)
+        .send(await data)
+        .expect(200);
+
+      expect(mockMeta.updateBranch).toBeCalledWith({ organization: "testorg", repository: "testrepo", branch: "newthis", head: "newthat" });
+      expect(mockMeta.updateBranch).toHaveBeenCalledTimes(1);
+      await fs.promises.access(path.join(report_path, "index.html"), fs.constants.R_OK);
+      await fs.promises.access(path.join(report_path, "badge.svg"), fs.constants.R_OK);
+    });
+
+    it("should return 401 when token is not correct", async () => {
+      await request()
+        .post(`/v1/testorg/testrepo/newthis/newthat.html?token=wrong&format=tarpaulin`)
+        .send(await data)
+        .expect(401);
+    });
+
+    it("should return 406 with an invalid format", async () => {
+      await request()
+        .post(`/v1/testorg/testrepo/newthis/newthat.html?token=${TOKEN}&format=pepperoni`)
+        .send(await data)
+        .expect(406);
+    });
+
+    it("should return 400 when request body is not the appropriate format", async () => {
+      await request()
+        .post(`/v1/testorg/testrepo/newthis/newthat.html?token=${TOKEN}&format=tarpaulin`)
+        .send("This is not a file")
+        .expect(400);
+    });
+
+    it("should return 413 when request body is not the appropriate format", async () => {
+      const file = await data;
+      const big_data = Buffer.concat([file, file]);
+      await request()
+        .post(`/v1/testorg/testrepo/newthis/newthat.html?token=${TOKEN}&format=tarpaulin`)
+        .send(big_data)
+        .expect(413);
+    });
+
+    it("should return 500 when Metadata does not create branch", async () => {
+      const update = jest.fn(() => new Promise(solv => solv(false)));
+      await request(mock(jest.fn(), update))
+        .post(`/v1/testorg/testrepo/newthis/newthat.html?token=${TOKEN}&format=tarpaulin`)
+        .send(await data)
+        .expect(500);
+    });
+
+    it("should return 500 when promise chain is rejected", async () => {
+      const update = jest.fn(() => new Promise((_, rej) => rej("fooey 2")));
+      await request(mock(jest.fn(), update))
+        .post(`/v1/testorg/testrepo/newthis/newthat.html?token=${TOKEN}&format=tarpaulin`)
+        .send(await data)
+        .expect(500);
+    });
+  });
+});
\ No newline at end of file
diff --git a/src/routes.ts b/src/routes.ts
index 9ce3bbc..92d3542 100644
--- a/src/routes.ts
+++ b/src/routes.ts
@@ -5,6 +5,7 @@ import winston from "winston";
 import path from "path";
 import fs from "fs";
 
+import processTemplate, { Template } from "./templates";
 import formats, { GradientStyle } from "./formats";
 import Metadata, { HeadIdentity } from "./metadata";
 import { configOrError } from "./util/config";
@@ -14,12 +15,45 @@ import { Messages } from "./errors";
 const TOKEN = process.env.TOKEN ?? "";
 const UPLOAD_LIMIT = Number(process.env.UPLOAD_LIMIT ?? 4194304);
 const HOST_DIR = configOrError("HOST_DIR");
+const TARGET_URL = process.env.TARGET_URL ?? "http://localhost:3000";
 
 const logger = winston.createLogger(loggerConfig("HTTP"));
 
 export default (metadata: Metadata): Router => {
   const router = Router();
 
+  const bashTemplate = {
+    inputFile: path.join(__dirname, "..", "public", "templates", "bash.template"),
+    outputFile: path.join(HOST_DIR, "bash"),
+    context: { TARGET_URL }
+  } as Template;
+  const indexTemplate = {
+    inputFile: path.join(__dirname, "..", "public", "templates", "index.html.template"),
+    outputFile: path.join(HOST_DIR, "index.html"),
+    context: { TARGET_URL }
+  } as Template;
+
+  processTemplate(bashTemplate)
+    .then(template => {
+      logger.debug("Generated '%s' from template file", template.outputFile);
+    })
+    .then(() => processTemplate(indexTemplate))
+    .then(template => {
+      logger.debug("Generated '%s' from template file", template.outputFile);
+    })
+    .catch(err => {
+      logger.error("Unable to process template file: %s", err);
+
+      // if the output file exists, then we are fine with continuing without
+      return fs.promises.access(bashTemplate.outputFile, fs.constants.R_OK);
+    })
+    .then(() => fs.promises.access(indexTemplate.outputFile, fs.constants.R_OK))
+    .catch(err => {
+      logger.error("Cannot proceed: %s", err);
+
+      process.exit(1);
+    });
+
   // serve landing page
   router.get("/", (_, res) => {
     res.sendFile(path.join(HOST_DIR, "index.html"))