diff --git a/.github/workflows/test-and-push.yml b/.github/workflows/test-and-push.yml
index 61dcfe7..6ffd329 100644
--- a/.github/workflows/test-and-push.yml
+++ b/.github/workflows/test-and-push.yml
@@ -12,6 +12,11 @@ jobs:
   test-and-push:
     runs-on: ubuntu-latest
     steps:
+      - name: Set Pull Request Head SHA
+        if: ${{ github.event_name == 'pull_request' }}
+        run: |
+          long_sha=${{ github.event.pull_request.head.sha }}
+          echo "PR_HEAD_SHA=${long_sha:0:7}" >> $GITHUB_ENV
       - uses: actions/checkout@v4
       - uses: actions/setup-node@v4
         with:
diff --git a/docker/common b/docker/common
index e660d95..5a3d5b4 100644
--- a/docker/common
+++ b/docker/common
@@ -1,7 +1,11 @@
 REGISTRY=ghcr.io
 PACKAGE_ORG=mrc-ide
 PACKAGE_NAME=grout
-GIT_SHA=$(git -C "$PACKAGE_ROOT" rev-parse --short=7 HEAD)
+if [[ -z "${PR_HEAD_SHA}" ]]; then
+  GIT_SHA=$(git -C "$PACKAGE_ROOT" rev-parse --short=7 HEAD)
+else
+  GIT_SHA=${PR_HEAD_SHA}
+fi
 if [[ -v "BRANCH_NAME" ]]; then
     GIT_BRANCH=${BRANCH_NAME}
 else
diff --git a/docker/run b/docker/run
index b71a4cd..c1c6f26 100755
--- a/docker/run
+++ b/docker/run
@@ -7,5 +7,6 @@ docker run -d --rm \
     --pull=always \
     -p 5000:5000 \
     -v ./data:/data \
+    -e GROUT_ERROR_TEST=true \
     --name=$PACKAGE_NAME \
     $TAG_SHA
\ No newline at end of file
diff --git a/package-lock.json b/package-lock.json
index cfd1181..d61e4c3 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -13,7 +13,8 @@
         "express": "^4.21.1",
         "morgan": "^1.10.0",
         "sqlite": "^5.1.1",
-        "sqlite3": "^5.1.7"
+        "sqlite3": "^5.1.7",
+        "uid": "^2.0.2"
       },
       "devDependencies": {
         "@types/cors": "^2.8.17",
@@ -829,6 +830,15 @@
         "tslib": "2"
       }
     },
+    "node_modules/@lukeed/csprng": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/@lukeed/csprng/-/csprng-1.1.0.tgz",
+      "integrity": "sha512-Z7C/xXCiGWsg0KuKsHTKJxbWhpI3Vs5GwLfOean7MGyVFGqdRgBbAjOCh6u4bbjPc/8MJ2pZmK/0DLdCbivLDA==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=8"
+      }
+    },
     "node_modules/@nodelib/fs.scandir": {
       "version": "2.1.5",
       "resolved": "https://registry.npmjs.org/@nodelib/fs.scandir/-/fs.scandir-2.1.5.tgz",
@@ -6111,6 +6121,18 @@
         }
       }
     },
+    "node_modules/uid": {
+      "version": "2.0.2",
+      "resolved": "https://registry.npmjs.org/uid/-/uid-2.0.2.tgz",
+      "integrity": "sha512-u3xV3X7uzvi5b1MncmZo3i2Aw222Zk1keqLA1YkHldREkAhAqi65wuPfe7lHx8H/Wzy+8CE7S7uS3jekIM5s8g==",
+      "license": "MIT",
+      "dependencies": {
+        "@lukeed/csprng": "^1.0.0"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
     "node_modules/undefsafe": {
       "version": "2.0.5",
       "resolved": "https://registry.npmjs.org/undefsafe/-/undefsafe-2.0.5.tgz",
diff --git a/package.json b/package.json
index 86724e9..0392f77 100644
--- a/package.json
+++ b/package.json
@@ -26,7 +26,8 @@
     "express": "^4.21.1",
     "morgan": "^1.10.0",
     "sqlite": "^5.1.1",
-    "sqlite3": "^5.1.7"
+    "sqlite3": "^5.1.7",
+    "uid": "^2.0.2"
   },
   "devDependencies": {
     "@types/cors": "^2.8.17",
diff --git a/src/controllers/indexController.ts b/src/controllers/indexController.ts
index 8c70d80..cc8a495 100644
--- a/src/controllers/indexController.ts
+++ b/src/controllers/indexController.ts
@@ -1,8 +1,9 @@
 import { Request, Response } from "express";
+import { jsonResponseSuccess } from "../jsonResponse";
 
 export class IndexController {
     static getIndex = (_req: Request, res: Response) => {
         const version = process.env.npm_package_version;
-        res.status(200).json({ version });
+        jsonResponseSuccess({ version }, res);
     };
 }
diff --git a/src/controllers/tileController.ts b/src/controllers/tileController.ts
index 892c054..01bf479 100644
--- a/src/controllers/tileController.ts
+++ b/src/controllers/tileController.ts
@@ -1,28 +1,49 @@
-import { Request, Response } from "express";
+import { NextFunction, Request, Response } from "express";
 import { AppLocals } from "../types/app";
+import asyncControllerHandler from "../errors/asyncControllerHandler";
+import notFound from "../errors/notFound";
+import { GroutError } from "../errors/groutError";
+import { ErrorType } from "../errors/errorType";
+
+const parseIntParam = (param: string): number => {
+    // Native parseInt is not strict (ignores whitespace and trailing chars) so test with a regex
+    if (!/^\d+$/.test(param)) {
+        throw new GroutError(
+            `"${param}" is not an integer`,
+            ErrorType.BAD_REQUEST
+        );
+    }
+    return parseInt(param, 10);
+};
 
 export class TileController {
-    static getTile = async (req: Request, res: Response) => {
-        const { dataset, level, z, x, y } = req.params;
-        const { tileDatasets } = req.app.locals as AppLocals;
+    static getTile = async (
+        req: Request,
+        res: Response,
+        next: NextFunction
+    ) => {
+        await asyncControllerHandler(next, async () => {
+            const { dataset, level, z, x, y } = req.params;
+            const { tileDatasets } = req.app.locals as AppLocals;
 
-        let tileData = null;
-        if (tileDatasets[dataset] && tileDatasets[dataset][level]) {
-            const db = tileDatasets[dataset][level];
-            tileData = await db.getTileData(
-                parseInt(z),
-                parseInt(x),
-                parseInt(y)
-            );
-        }
+            let tileData = null;
+            if (tileDatasets[dataset] && tileDatasets[dataset][level]) {
+                const db = tileDatasets[dataset][level];
+                tileData = await db.getTileData(
+                    parseIntParam(z),
+                    parseIntParam(x),
+                    parseIntParam(y)
+                );
+            }
 
-        if (tileData) {
-            res.writeHead(200, {
-                "Content-Type": "application/octet-stream",
-                "Content-Encoding": "gzip"
-            }).end(tileData);
-        } else {
-            res.writeHead(404).end();
-        }
+            if (tileData) {
+                res.writeHead(200, {
+                    "Content-Type": "application/octet-stream",
+                    "Content-Encoding": "gzip"
+                }).end(tileData);
+            } else {
+                notFound(req);
+            }
+        });
     };
 }
diff --git a/src/errors/asyncControllerHandler.ts b/src/errors/asyncControllerHandler.ts
new file mode 100644
index 0000000..8500c4d
--- /dev/null
+++ b/src/errors/asyncControllerHandler.ts
@@ -0,0 +1,10 @@
+import { NextFunction } from "express";
+
+// This method should be used to wrap any async controller methods to ensure error handling is applied
+export default async (next: NextFunction, method: () => void) => {
+    try {
+        await method();
+    } catch (error) {
+        next(error);
+    }
+};
diff --git a/src/errors/errorType.ts b/src/errors/errorType.ts
new file mode 100644
index 0000000..dcf30bf
--- /dev/null
+++ b/src/errors/errorType.ts
@@ -0,0 +1,11 @@
+export const enum ErrorType {
+    BAD_REQUEST = "BAD_REQUEST",
+    NOT_FOUND = "NOT_FOUND",
+    UNEXPECTED_ERROR = "UNEXPECTED_ERROR"
+}
+
+export const ErrorTypeStatuses: { [key in ErrorType]: number } = {
+    [ErrorType.BAD_REQUEST]: 400,
+    [ErrorType.NOT_FOUND]: 404,
+    [ErrorType.UNEXPECTED_ERROR]: 500
+};
diff --git a/src/errors/groutError.ts b/src/errors/groutError.ts
new file mode 100644
index 0000000..30bfb01
--- /dev/null
+++ b/src/errors/groutError.ts
@@ -0,0 +1,16 @@
+import { ErrorType, ErrorTypeStatuses } from "./errorType";
+
+export class GroutError extends Error {
+    errorType: ErrorType;
+
+    constructor(message: string, errorType: ErrorType) {
+        super(message);
+
+        this.name = "GroutError";
+        this.errorType = errorType;
+    }
+
+    get status() {
+        return ErrorTypeStatuses[this.errorType];
+    }
+}
diff --git a/src/errors/handleError.ts b/src/errors/handleError.ts
new file mode 100644
index 0000000..e9ab13d
--- /dev/null
+++ b/src/errors/handleError.ts
@@ -0,0 +1,31 @@
+import { NextFunction, Response } from "express";
+import { uid } from "uid";
+import { GroutError } from "./groutError";
+import { ErrorType } from "./errorType";
+import { RequestWithError } from "../logging";
+import { jsonResponseError } from "../jsonResponse";
+
+// We need to include the unused next var for this to be used correctly as an error handler
+export const handleError = (
+    err: Error,
+    req: RequestWithError,
+    res: Response,
+    _: NextFunction // eslint-disable-line @typescript-eslint/no-unused-vars
+) => {
+    const groutError = err instanceof GroutError;
+
+    const status = groutError ? err.status : 500;
+    const type = groutError ? err.errorType : ErrorType.UNEXPECTED_ERROR;
+
+    // Do not return raw messages from unexpected errors to the front end
+    const detail = groutError
+        ? err.message
+        : `An unexpected error occurred. Please contact support and quote error code ${uid()}`;
+
+    // Set error type, detail and stack on req so morgan logs them
+    req.errorType = type;
+    req.errorDetail = detail;
+    req.errorStack = err.stack;
+
+    jsonResponseError(status, type, detail, res);
+};
diff --git a/src/errors/notFound.ts b/src/errors/notFound.ts
new file mode 100644
index 0000000..4323ae4
--- /dev/null
+++ b/src/errors/notFound.ts
@@ -0,0 +1,8 @@
+import { Request } from "express";
+import { ErrorType } from "./errorType";
+import { GroutError } from "./groutError";
+
+export default (req: Request) => {
+    const { url } = req;
+    throw new GroutError(`Route not found: ${url}`, ErrorType.NOT_FOUND);
+};
diff --git a/src/jsonResponse.ts b/src/jsonResponse.ts
new file mode 100644
index 0000000..cb085ab
--- /dev/null
+++ b/src/jsonResponse.ts
@@ -0,0 +1,31 @@
+import { Response } from "express";
+
+const addContentType = (res: Response) => {
+    res.header("Content-Type", "application/json");
+};
+
+export const jsonResponseSuccess = (data: object | string, res: Response) => {
+    addContentType(res);
+    const responseObject = {
+        status: "success",
+        errors: null,
+        data
+    };
+    res.end(JSON.stringify(responseObject));
+};
+
+export const jsonResponseError = (
+    httpStatus: number,
+    error: string,
+    detail: string,
+    res: Response
+) => {
+    addContentType(res);
+    const responseObject = {
+        status: "failure",
+        errors: [{ error, detail }],
+        data: null
+    };
+    res.status(httpStatus);
+    res.end(JSON.stringify(responseObject));
+};
diff --git a/src/logging.ts b/src/logging.ts
index 80171f5..0e83d51 100644
--- a/src/logging.ts
+++ b/src/logging.ts
@@ -2,9 +2,20 @@ import { Application, Request, Response } from "express";
 import morgan from "morgan";
 import { Dict } from "./types/utils";
 
+export type RequestWithError = Request & {
+    errorType?: string;
+    errorDetail?: string;
+    errorStack?: string;
+};
+
 export const initialiseLogging = (app: Application) => {
+    // Log error details appended to request by handleError
+    morgan.token("error-type", (req: RequestWithError) => req.errorType);
+    morgan.token("error-detail", (req: RequestWithError) => req.errorDetail);
+    morgan.token("error-stack", (req: RequestWithError) => req.errorStack);
+
     const customFormat = (
-        tokens: Dict<(req: Request, res: Response, header?: string) => string>,
+        tokens: Dict<(req: Request, res?: Response, header?: string) => string>,
         req: Request,
         res: Response
     ) => {
@@ -17,7 +28,10 @@ export const initialiseLogging = (app: Application) => {
             tokens.res(req, res, "content-length"),
             "-",
             tokens["response-time"](req, res),
-            "ms"
+            "ms",
+            tokens["error-type"](req),
+            tokens["error-detail"](req),
+            tokens["error-stack"](req)
         ].join(" ");
     };
 
diff --git a/src/routes.ts b/src/routes.ts
index 1564e66..b23e6cb 100644
--- a/src/routes.ts
+++ b/src/routes.ts
@@ -1,10 +1,23 @@
 import { Router } from "express";
 import { IndexController } from "./controllers/indexController";
 import { TileController } from "./controllers/tileController";
+import notFound from "./errors/notFound";
 
 export const registerRoutes = () => {
     const router = Router();
     router.get("/", IndexController.getIndex);
     router.get("/tile/:dataset/:level/:z/:x/:y", TileController.getTile);
+
+    // provide an endpoint we can use to test 500 response behaviour by throwing an "unexpected error" - but only if we
+    // are running in a non-production mode indicated by an env var
+    if (process.env.GROUT_ERROR_TEST) {
+        router.get("/error-test", () => {
+            throw Error("Testing error behaviour");
+        });
+    }
+
+    // Throw 404 error for any unmatched routes
+    router.use(notFound);
+
     return router;
 };
diff --git a/src/server.ts b/src/server.ts
index b26b5ba..f2892bf 100644
--- a/src/server.ts
+++ b/src/server.ts
@@ -7,6 +7,7 @@ import { GroutConfig } from "./types/app";
 import { registerRoutes } from "./routes";
 import { initialiseLogging } from "./logging";
 import { discoverTileDatasets } from "./discover";
+import { handleError } from "./errors/handleError";
 
 // Wrap the main server set-up functionality in a non-top-level method so we can use async - we can revert this in
 // https://mrc-ide.myjetbrains.com/youtrack/issue/mrc-6134/Add-Vite-build-and-related-tidy-up
@@ -32,7 +33,7 @@ const main = async () => {
     Object.freeze(app.locals); // We don't expect anything else to modify app.locals
 
     app.use("/", registerRoutes());
-
+    app.use(handleError);
     app.listen(port, () => {
         console.log(`Grout is running on port ${port}`);
     });
diff --git a/test.html b/test.html
index 09d4173..67dd61c 100644
--- a/test.html
+++ b/test.html
@@ -27,7 +27,7 @@
         </style>
     </head>
     <body>
-        <h1>GROUT</h1>
+        <h1>GROUT Test Page</h1>
         <div id="map"></div>
         <script>
             const map = L.map("map").setView({lon: 0, lat: 0}, 3);
@@ -79,7 +79,7 @@ <h1>GROUT</h1>
                 style: {
                     weight: 1,
                     fill: false,
-                    color: "#000000"
+                    color: "#777"
                 },
                 ...options
             };
diff --git a/tests/integration/errors.spec.ts b/tests/integration/errors.spec.ts
new file mode 100644
index 0000000..61e8fee
--- /dev/null
+++ b/tests/integration/errors.spec.ts
@@ -0,0 +1,80 @@
+import { describe, expect, test, beforeAll, afterAll } from "vitest";
+import { grout } from "./integrationTest";
+import * as fs from "fs";
+
+const expect404Response = async (url: string) => {
+    const response = await grout.get(url);
+    expect(response.status).toBe(404);
+    expect(response.body).toStrictEqual({
+        status: "failure",
+        data: null,
+        errors: [{ error: "NOT_FOUND", detail: `Route not found: ${url}` }]
+    });
+};
+
+const expect400Response = async (url: string, error: string) => {
+    const response = await grout.get(url);
+    expect(response.status).toBe(400);
+    expect(response.body).toStrictEqual({
+        status: "failure",
+        data: null,
+        errors: [{ error: "BAD_REQUEST", detail: error }]
+    });
+};
+
+describe("404 error response", () => {
+    test("from nonexistent endpoint", async () => {
+        await expect404Response("/notAnEndpoint");
+    });
+
+    test("from unknown dataset", async () => {
+        await expect404Response("/tile/unknown/admin0/3/1/4");
+    });
+
+    test("from unknown level", async () => {
+        await expect404Response("/tile/gadm41/unknown/3/1/4");
+    });
+
+    test("from unknown tile", async () => {
+        await expect404Response("/tile/gadm41/admin0/3/1/4000");
+    });
+});
+
+describe("400 error response", () => {
+    test("from non-integer z value", async () => {
+        await expect400Response(
+            "/tile/gadm41/admin0/a/1/4",
+            '"a" is not an integer'
+        );
+    });
+
+    test("from non-integer x value", async () => {
+        await expect400Response(
+            "/tile/gadm41/admin0/3/1a/4",
+            '"1a" is not an integer'
+        );
+    });
+
+    test("from non-integer y value", async () => {
+        await expect400Response(
+            "/tile/gadm41/admin0/3/1/4.3",
+            '"4.3" is not an integer'
+        );
+    });
+});
+
+describe("500 error response", () => {
+    test("when request error test endpoint", async () => {
+        // NB The error-test endpoint is only enabled when the GROUT_ERROR_TEST env var is set when the server starts
+        // up, e.g. when running through ./docker/run
+        const response = await grout.get("/error-test");
+        expect(response.status).toBe(500);
+        expect(response.body.status).toBe("failure");
+        expect(response.body.data).toBe(null);
+        expect(response.body.errors.length).toBe(1);
+        expect(response.body.errors[0].error).toBe("UNEXPECTED_ERROR");
+        expect(response.body.errors[0].detail).toMatch(
+            /^An unexpected error occurred. Please contact support and quote error code [0-9a-f]{11}$/
+        );
+    });
+});
diff --git a/tests/integration/index.spec.ts b/tests/integration/index.spec.ts
index 77c3c74..3babcfa 100644
--- a/tests/integration/index.spec.ts
+++ b/tests/integration/index.spec.ts
@@ -5,7 +5,9 @@ describe("index endpoint", () => {
     test("returns package version", async () => {
         const response = await grout.get("/");
         expect(response.status).toBe(200);
-        const data = response.body;
+        expect(response.body.status).toBe("success");
+        expect(response.body.errors).toBe(null);
+        const data = response.body.data;
 
         const expectedVersion = process.env.npm_package_version;
         expect(data.version).toBe(expectedVersion);
diff --git a/tests/unit/controllers/indexController.spec.ts b/tests/unit/controllers/indexController.spec.ts
index 74e8e1e..d3468f6 100644
--- a/tests/unit/controllers/indexController.spec.ts
+++ b/tests/unit/controllers/indexController.spec.ts
@@ -3,15 +3,21 @@ import { IndexController } from "../../../src/controllers/indexController";
 
 vi.stubEnv("npm_package_version", "1.2.3");
 
+const mockJsonResponseSuccess = vi.hoisted(() => vi.fn());
+vi.mock("../../../src/jsonResponse", () => ({
+    jsonResponseSuccess: mockJsonResponseSuccess
+}));
+vi.mock("uid", () => ({
+    uid: () => "123"
+}));
+
 describe("IndexController", () => {
     test("returns expected content and status", () => {
-        const mockResponse = {
-            json: vi.fn()
-        };
-        mockResponse.status = vi.fn().mockImplementation(() => mockResponse);
-
+        const mockResponse = {};
         IndexController.getIndex({}, mockResponse);
-        expect(mockResponse.status).toHaveBeenCalledWith(200);
-        expect(mockResponse.json).toHaveBeenCalledWith({ version: "1.2.3" });
+        expect(mockJsonResponseSuccess).toHaveBeenCalledWith(
+            { version: "1.2.3" },
+            mockResponse
+        );
     });
 });
diff --git a/tests/unit/controllers/tileController.spec.ts b/tests/unit/controllers/tileController.spec.ts
index 6edf65a..aa69a3d 100644
--- a/tests/unit/controllers/tileController.spec.ts
+++ b/tests/unit/controllers/tileController.spec.ts
@@ -1,5 +1,7 @@
 import { describe, expect, test, vi, beforeEach } from "vitest";
 import { TileController } from "../../../src/controllers/tileController";
+import { GroutError } from "../../../src/errors/groutError";
+import { ErrorType } from "../../../src/errors/errorType";
 
 const params = {
     dataset: "testDataset",
@@ -17,6 +19,7 @@ const mockDb = {
 };
 const mockRequest = {
     params,
+    url: "/mockUrl",
     app: {
         locals: {
             tileDatasets: {
@@ -33,13 +36,15 @@ const mockResponse = {
 } as any;
 mockResponse.writeHead = vi.fn().mockImplementation(() => mockResponse);
 
+const mockNext = vi.fn();
+
 describe("TileController", () => {
     beforeEach(() => {
         vi.clearAllMocks();
     });
 
     test("adds expected tile data and headers to response", async () => {
-        await TileController.getTile(mockRequest, mockResponse);
+        await TileController.getTile(mockRequest, mockResponse, mockNext);
         expect(mockDb.getTileData).toHaveBeenCalledWith(3, 1, 2);
         const expectedHeaders = {
             "Content-Type": "application/octet-stream",
@@ -52,10 +57,22 @@ describe("TileController", () => {
         expect(mockResponse.end).toHaveBeenCalledWith(mockTileData);
     });
 
-    const expect404Response = async (request: any) => {
-        await TileController.getTile(request, mockResponse);
-        expect(mockResponse.writeHead).toHaveBeenCalledWith(404);
-        expect(mockResponse.end).toHaveBeenCalledWith();
+    const expectThrowsNotFound = async (request: any) => {
+        await TileController.getTile(request, mockResponse, mockNext);
+        // expect the async controller handler to have been used, so the error will be caught and passed to next
+        expect(mockNext).toHaveBeenCalledWith(
+            new GroutError("Route not found: /mockUrl", ErrorType.NOT_FOUND)
+        );
+    };
+
+    const expectThrowsBadRequest = async (request: any, badParam: string) => {
+        await TileController.getTile(request, mockResponse, mockNext);
+        expect(mockNext).toHaveBeenCalledWith(
+            new GroutError(
+                `"${badParam}" is not an integer`,
+                ErrorType.BAD_REQUEST
+            )
+        );
     };
 
     test("returns 404 if dataset not found", async () => {
@@ -66,7 +83,7 @@ describe("TileController", () => {
                 dataset: "notadataset"
             }
         };
-        await expect404Response(requestUnknownDataset);
+        await expectThrowsNotFound(requestUnknownDataset);
     });
 
     test("returns 404 if level not found", async () => {
@@ -77,7 +94,7 @@ describe("TileController", () => {
                 level: "notalevel"
             }
         };
-        await expect404Response(requestUnknownLevel);
+        await expectThrowsNotFound(requestUnknownLevel);
     });
 
     test("returns 404 if tile not found", async () => {
@@ -88,6 +105,39 @@ describe("TileController", () => {
                 z: "0"
             }
         };
-        await expect404Response(requestUnknownTile);
+        await expectThrowsNotFound(requestUnknownTile);
+    });
+
+    test("returns 400 if non-integer z, x, or y", async () => {
+        await expectThrowsBadRequest(
+            {
+                ...mockRequest,
+                params: {
+                    ...mockRequest.params,
+                    z: "abc"
+                }
+            },
+            "abc"
+        );
+        await expectThrowsBadRequest(
+            {
+                ...mockRequest,
+                params: {
+                    ...mockRequest.params,
+                    x: "1a"
+                }
+            },
+            "1a"
+        );
+        await expectThrowsBadRequest(
+            {
+                ...mockRequest,
+                params: {
+                    ...mockRequest.params,
+                    y: "1.2"
+                }
+            },
+            "1.2"
+        );
     });
 });
diff --git a/tests/unit/errors/asyncControllerHandler.spec.ts b/tests/unit/errors/asyncControllerHandler.spec.ts
new file mode 100644
index 0000000..413a9dd
--- /dev/null
+++ b/tests/unit/errors/asyncControllerHandler.spec.ts
@@ -0,0 +1,27 @@
+import { describe, expect, test, vi, beforeEach } from "vitest";
+import asyncControllerHandler from "../../../src/errors/asyncControllerHandler";
+
+const mockNext = vi.fn();
+
+describe("asyncControllerHandler", () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+
+    test("calls controller method, catches error and passes to next", async () => {
+        const err = new Error("nope");
+        const method = async () => {
+            throw err;
+        };
+        await asyncControllerHandler(mockNext, method);
+        expect(mockNext).toHaveBeenCalledWith(err);
+    });
+
+    test("does not call next if no error thrown by controller method", async () => {
+        const method = async () => {
+            const s = 1 + 1;
+        };
+        await asyncControllerHandler(mockNext, method);
+        expect(mockNext).not.toHaveBeenCalled();
+    });
+});
diff --git a/tests/unit/errors/groutError.spec.ts b/tests/unit/errors/groutError.spec.ts
new file mode 100644
index 0000000..2f134ae
--- /dev/null
+++ b/tests/unit/errors/groutError.spec.ts
@@ -0,0 +1,13 @@
+import { describe, expect, test, vi, beforeEach } from "vitest";
+import { GroutError } from "../../../src/errors/groutError";
+import { ErrorType } from "../../../src/errors/errorType";
+
+describe("GroutError", () => {
+    test("is constructed with expected status value", () => {
+        expect(new GroutError("test", ErrorType.BAD_REQUEST).status).toBe(400);
+        expect(new GroutError("test", ErrorType.NOT_FOUND).status).toBe(404);
+        expect(new GroutError("test", ErrorType.UNEXPECTED_ERROR).status).toBe(
+            500
+        );
+    });
+});
diff --git a/tests/unit/errors/handleError.spec.ts b/tests/unit/errors/handleError.spec.ts
new file mode 100644
index 0000000..02b1713
--- /dev/null
+++ b/tests/unit/errors/handleError.spec.ts
@@ -0,0 +1,56 @@
+import { describe, expect, test, vi, beforeEach } from "vitest";
+import { GroutError } from "../../../src/errors/groutError";
+import { handleError } from "../../../src/errors/handleError";
+import { ErrorType } from "../../../src/errors/errorType";
+
+const mockJsonResponseError = vi.hoisted(() => vi.fn());
+vi.mock("../../../src/jsonResponse", () => ({
+    jsonResponseError: mockJsonResponseError
+}));
+vi.mock("uid", () => ({
+    uid: () => "123"
+}));
+
+describe("handleError", () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+
+    test("handles GroutError", () => {
+        const err = new GroutError("test message", ErrorType.BAD_REQUEST);
+        const mockReq = {} as any;
+        const mockRes = {} as any;
+
+        handleError(err, mockReq, mockRes, vi.fn());
+        expect(mockReq.errorType).toBe(ErrorType.BAD_REQUEST);
+        expect(mockReq.errorDetail).toBe("test message");
+        expect(mockReq.errorStack).toBe(err.stack);
+
+        expect(mockJsonResponseError).toHaveBeenCalledWith(
+            400,
+            ErrorType.BAD_REQUEST,
+            "test message",
+            mockRes
+        );
+    });
+
+    test("handles unexpected error", () => {
+        const err = new Error("Embarrassing catastrophe!");
+        const mockReq = {} as any;
+        const mockRes = {} as any;
+
+        handleError(err, mockReq, mockRes, vi.fn());
+        expect(mockReq.errorType).toBe(ErrorType.UNEXPECTED_ERROR);
+        const expectedDetail =
+            "An unexpected error occurred. Please contact support and quote error code 123";
+        expect(mockReq.errorDetail).toBe(expectedDetail);
+        expect(mockReq.errorStack).toBe(err.stack);
+
+        expect(mockJsonResponseError).toHaveBeenCalledWith(
+            500,
+            ErrorType.UNEXPECTED_ERROR,
+            expectedDetail,
+            mockRes
+        );
+    });
+});
diff --git a/tests/unit/errors/notFound.spec.ts b/tests/unit/errors/notFound.spec.ts
new file mode 100644
index 0000000..ff778af
--- /dev/null
+++ b/tests/unit/errors/notFound.spec.ts
@@ -0,0 +1,19 @@
+import { describe, expect, test, vi, beforeEach } from "vitest";
+import notFound from "../../../src/errors/notFound";
+import { ErrorType } from "../../../src/errors/errorType";
+
+describe("notFound", () => {
+    test("throws expected error", () => {
+        const mockReq = { url: "/testUrl" } as any;
+        // Don't use expect..toThrowError as we want to test more than the message
+        let err = null;
+        try {
+            notFound(mockReq);
+        } catch (e) {
+            err = e;
+        }
+        expect(err.message).toBe("Route not found: /testUrl");
+        expect(err.status).toBe(404);
+        expect(err.errorType).toBe(ErrorType.NOT_FOUND);
+    });
+});
diff --git a/tests/unit/jsonResponse.spec.ts b/tests/unit/jsonResponse.spec.ts
new file mode 100644
index 0000000..dbfd4a3
--- /dev/null
+++ b/tests/unit/jsonResponse.spec.ts
@@ -0,0 +1,53 @@
+import { describe, expect, test, vi, beforeEach } from "vitest";
+import { jsonResponseError, jsonResponseSuccess } from "../../src/jsonResponse";
+
+const mockResponse = {
+    header: vi.fn(),
+    status: vi.fn(),
+    end: vi.fn()
+} as any;
+
+beforeEach(() => {
+    vi.clearAllMocks();
+});
+
+describe("jsonResponseSuccess", () => {
+    test("adds expected header and content", () => {
+        const data = { value: "test" };
+        jsonResponseSuccess(data, mockResponse);
+        expect(mockResponse.header).toHaveBeenCalledWith(
+            "Content-Type",
+            "application/json"
+        );
+        expect(mockResponse.end).toHaveBeenCalled();
+        const responseObj = JSON.parse(mockResponse.end.mock.calls[0][0]);
+        expect(responseObj).toStrictEqual({
+            status: "success",
+            errors: null,
+            data
+        });
+    });
+});
+
+describe("jsonResponseError", () => {
+    test("adds expected header and content", () => {
+        jsonResponseError(400, "BAD_REQUEST", "test error", mockResponse);
+        expect(mockResponse.header).toHaveBeenCalledWith(
+            "Content-Type",
+            "application/json"
+        );
+        expect(mockResponse.status).toHaveBeenCalledWith(400);
+        expect(mockResponse.end).toHaveBeenCalled();
+        const responseObj = JSON.parse(mockResponse.end.mock.calls[0][0]);
+        expect(responseObj).toStrictEqual({
+            status: "failure",
+            errors: [
+                {
+                    error: "BAD_REQUEST",
+                    detail: "test error"
+                }
+            ],
+            data: null
+        });
+    });
+});
diff --git a/tests/unit/logging.spec.ts b/tests/unit/logging.spec.ts
index adc7242..90f2269 100644
--- a/tests/unit/logging.spec.ts
+++ b/tests/unit/logging.spec.ts
@@ -1,10 +1,12 @@
 import { describe, expect, test, vi } from "vitest";
 import { initialiseLogging } from "../../src/logging";
 
-const { mockMorganResult, mockMorgan } = vi.hoisted(() => {
+const { mockMorganResult, mockMorgan, mockToken } = vi.hoisted(() => {
     const mockMorganResult = { morgan: "mock result" };
     const mockMorgan = vi.fn().mockImplementation(() => mockMorganResult);
-    return { mockMorganResult, mockMorgan };
+    const mockToken = vi.fn();
+    mockMorgan.token = mockToken;
+    return { mockMorganResult, mockMorgan, mockToken };
 });
 
 vi.mock("morgan", () => ({ default: mockMorgan }));
@@ -49,12 +51,15 @@ describe("initialiseLogging", () => {
             status: (req: any, res: any) => `${req.status}:${res.status}`,
             res: (req: any, res: any, name: string) =>
                 `${req.res}:${res.res}:${name}`,
-            "response-time": (req: any, res: any) => `${req.time}:${res.time}`
+            "response-time": (req: any, res: any) => `${req.time}:${res.time}`,
+            "error-type": (req: any, res: any) => req.errorType,
+            "error-detail": (req: any, res: any) => req.errorDetail,
+            "error-stack": (req: any, res: any) => req.errorStack
         };
 
         const expectedLog =
             "remoteReq:remoteRes remoteUReq:remoteURes methodReq:methodRes urlReq:urlRes " +
-            "statusReq:statusRes resReq:resRes:content-length - timeReq:timeRes ms";
+            "statusReq:statusRes resReq:resRes:content-length - timeReq:timeRes ms errTypeReq errDetailReq errStackReq";
         expect(customFormatParam(tokens, testReq, testRes)).toBe(expectedLog);
     });
 });
diff --git a/tests/unit/routes.spec.ts b/tests/unit/routes.spec.ts
index 8150e38..cade70a 100644
--- a/tests/unit/routes.spec.ts
+++ b/tests/unit/routes.spec.ts
@@ -2,10 +2,12 @@ import { beforeEach, describe, expect, test, vi } from "vitest";
 import { registerRoutes } from "../../src/routes";
 import { IndexController } from "../../src/controllers/indexController";
 import { TileController } from "../../src/controllers/tileController";
+import notFound from "../../src/errors/notFound";
 
 const { mockRouterConstructor, mockRouter } = vi.hoisted(() => {
     const mockRouter = {
-        get: vi.fn()
+        get: vi.fn(),
+        use: vi.fn()
     };
     const mockRouterConstructor = vi.fn().mockImplementation(() => mockRouter);
     return { mockRouterConstructor, mockRouter };
@@ -30,5 +32,6 @@ describe("registerRoutes", () => {
             "/tile/:dataset/:level/:z/:x/:y",
             TileController.getTile
         );
+        expect(mockRouter.use).toHaveBeenCalledWith(notFound);
     });
 });