test: setup tests for http handlers

Author: cheatsnake

test/handlers/config.ts

@@ -0,0 +1,30 @@
+import { Server } from "node:http";
+import { AddressInfo } from "node:net";
+import { createStep } from "../../src/scene/step";
+import { createScene } from "../../src/scene/scene";
+import { SimpleLogger } from "../../src/logger/logger";
+import { createCommand } from "../../src/scene/command";
+import { MemoryDatabase } from "../../src/database/memory/memory";
+
+export const testAppServerSetup = {
+    logger: new SimpleLogger({ levels: [] }),
+    db: new MemoryDatabase(),
+    config: { port: 0 }, // random free port
+};
+
+const TEST = "test";
+
+export const getTestHost = (s: Server) => `http://localhost:${(s.address() as AddressInfo).port}`;
+
+export const testCommand = createCommand({ value: TEST, description: TEST, label: TEST });
+
+export const testStep = createStep({
+    key: TEST,
+    prompt: { type: "text", content: TEST },
+    reply: { bodyType: "text" },
+});
+
+export const testScene = createScene({
+    steps: [],
+    handler: async () => ({ type: "text", content: TEST }),
+});

test/handlers/get-commands-handler.test.ts

@@ -0,0 +1,57 @@
+import assert from "node:assert";
+import { Server } from "node:http";
+import { afterEach, beforeEach, describe, it } from "node:test";
+import { getTestHost, testAppServerSetup, testCommand, testScene } from "./config";
+import { Command } from "../../src/scene/command";
+import { AppServer } from "../../src/server/server";
+
+describe("getCommandsHandler", () => {
+    let app: AppServer;
+    let server: Server | null = null;
+
+    beforeEach(async () => {
+        app = new AppServer(testAppServerSetup);
+    });
+
+    afterEach(async () => {
+        if (server) {
+            await new Promise((resolve) => server!.close(resolve));
+            server = null;
+        }
+    });
+
+    it("should return empty array", async () => {
+        server = await app.start();
+        const res = await fetch(`${getTestHost(server)}/api/commands`);
+
+        const got = await res.json();
+        const expected: Command[] = [];
+
+        assert.deepStrictEqual(got, expected);
+    });
+
+    it("should return one command", async () => {
+        app.addScene(testCommand, testScene);
+        server = await app.start();
+        const res = await fetch(`${getTestHost(server)}/api/commands`);
+
+        const got = await res.json();
+        const expected = [testCommand];
+
+        assert.deepStrictEqual(got, expected);
+    });
+
+    it("should return multiple commands", async () => {
+        const command1: Command = { value: "test1", description: "test command 1", label: "Test 1" };
+        const command2: Command = { value: "test2", description: "test command 2", label: "Test 2" };
+        app.addScene(command1, testScene);
+        app.addScene(command2, testScene);
+        server = await app.start();
+        const res = await fetch(`${getTestHost(server)}/api/commands`);
+
+        const got = await res.json();
+        const expected = [command1, command2];
+
+        assert.deepStrictEqual(got, expected);
+    });
+});

test/handlers/get-config-handler.test.ts

@@ -0,0 +1,45 @@
+import assert from "node:assert";
+import { Server } from "node:http";
+import { afterEach, describe, it } from "node:test";
+import { getTestHost, testAppServerSetup } from "./config";
+import { defaultConfig, ServerConfig } from "../../src/server/config";
+import { AppServer } from "../../src/server/server";
+import { DeepPartial } from "../../src/utils/types";
+
+describe("getConfigHandler", () => {
+    let app: AppServer;
+    let server: Server | null = null;
+
+    afterEach(async () => {
+        if (server) {
+            await new Promise((resolve) => server!.close(resolve));
+            server = null;
+        }
+    });
+
+    it("should return default config", async () => {
+        app = new AppServer(testAppServerSetup);
+        server = await app.start();
+        const res = await fetch(`${getTestHost(server)}/api/config`);
+
+        const got = await res.json();
+        const expected = { app: defaultConfig.app, defaultPageLimit: defaultConfig.defaultPageLimit };
+
+        assert.deepStrictEqual(got, expected);
+    });
+
+    it("should return custom config", async () => {
+        const expected: DeepPartial<ServerConfig> = {
+            app: { name: "Test", description: "Test Description" },
+            defaultPageLimit: 5,
+        };
+
+        app = new AppServer({ ...testAppServerSetup, config: expected });
+        server = await app.start();
+        const res = await fetch(`${getTestHost(server)}/api/config`);
+
+        const got = await res.json();
+
+        assert.deepStrictEqual(got, expected);
+    });
+});

test/handlers/public/index.html

@@ -0,0 +1,9 @@
+<!doctype html>
+<html>
+  <head>
+    <title>test</title>
+  </head>
+  <body>
+    <p>test</p>
+  </body>
+</html>

test/handlers/public/test/test.txt

@@ -0,0 +1 @@
+test

test/handlers/static-handler.test.ts

@@ -0,0 +1,77 @@
+import assert from "node:assert";
+import { describe, it, beforeEach, afterEach } from "node:test";
+import { Server } from "node:http";
+import { resolve } from "node:path";
+import { readFile } from "node:fs/promises";
+import { AppServer } from "../../src/server/server";
+import { testAppServerSetup, getTestHost } from "./config";
+
+describe("staticHandler", () => {
+    let app: AppServer;
+    let server: Server | null = null;
+    const publicRoot = resolve(process.cwd(), "test", "handlers", "public");
+
+    beforeEach(() => {
+        app = new AppServer({ ...testAppServerSetup, config: { publicRoot, port: 0 } });
+    });
+
+    afterEach(async () => {
+        if (server) {
+            await new Promise((resolve) => server!.close(resolve));
+            server = null;
+        }
+    });
+
+    it("should serve index.html for /", async () => {
+        server = await app.start();
+        const host = getTestHost(server);
+
+        const res = await fetch(`${host}/`);
+        const text = await res.text();
+        const expected = await readFile(resolve(publicRoot, "index.html"), "utf8");
+
+        assert.strictEqual(res.status, 200);
+        assert.strictEqual(res.headers.get("content-type"), "text/html");
+        assert.strictEqual(text.trim(), expected.trim());
+    });
+
+    it("should serve a static text file", async () => {
+        server = await app.start();
+        const host = getTestHost(server);
+
+        const res = await fetch(`${host}/test/test.txt`);
+        const text = await res.text();
+        const expected = await readFile(resolve(publicRoot, "test", "test.txt"), "utf8");
+
+        assert.strictEqual(res.status, 200);
+        assert.strictEqual(res.headers.get("content-type"), "text/plain");
+        assert.strictEqual(text.trim(), expected.trim());
+    });
+
+    it("should return 404 for missing file", async () => {
+        server = await app.start();
+        const host = getTestHost(server);
+
+        const res = await fetch(`${host}/no-such-file.xyz`);
+
+        assert.strictEqual(res.status, 404);
+    });
+
+    it("should prevent path traversal attempts", async () => {
+        server = await app.start();
+        const host = getTestHost(server);
+
+        const res = await fetch(`${host}/../../.env`);
+
+        assert.strictEqual(res.status, 404);
+    });
+
+    it("should return 404 when accessing not existing directory", async () => {
+        server = await app.start();
+        const host = getTestHost(server);
+
+        const res = await fetch(`${host}/folder`);
+
+        assert.strictEqual(res.status, 404);
+    });
+});