chore: start fleshing out testing a little further

Author: nlf

.env.test

@@ -0,0 +1 @@
+NODE_OPTIONS="--experimental-strip-types --disable-warning=ExperimentalWarning"

.gitignore

@@ -1 +1,2 @@
 node_modules
+test/generated.ts

bin/generate-test-fixture.ts

@@ -0,0 +1,7 @@
+import { writeFile } from "node:fs/promises";
+import { resolve } from "node:path";
+import { generateClientType } from "../lib/build/index.ts";
+import { server } from "../test/fixture.ts";
+
+const fixtureTypes = generateClientType(server);
+await writeFile(resolve(import.meta.dirname, "../test/generated.ts"), fixtureTypes, { encoding: "utf8" });

package.json

@@ -13,7 +13,8 @@
   ],
   "scripts": {
     "clean": "rm -f lib/*.js lib/*.d.ts lib/**/*.js lib/**/*.d.ts",
-    "test": "node --experimental-strip-types --test",
+    "pretest": "node --env-file=.env.test bin/generate-test-fixture.ts",
+    "test": "node --env-file=.env.test --test",
     "posttest": "npm run lint",
     "lint": "eslint .",
     "prelint": "tsc",

test/fetch.ts

@@ -0,0 +1,35 @@
+import { test, type TestContext } from "node:test";
+import { server, Client } from "./fixture.ts";
+import type { RouteMap } from "./generated.ts";
+
+await test("GET - fetch", async (t) => {
+  let client: Client;
+  t.before(async () => {
+    await server.start();
+    client = new Client({ url: server.info.uri });
+  });
+
+  t.after(async () => {
+    await server.stop();
+  });
+
+  await t.test("/simple", async (t: TestContext) => {
+    const res = await client.get("/simple");
+    t.assert.equal(res.status, 200);
+    t.assert.equal(res.url, `${server.info.uri}/simple`);
+    t.assert.deepStrictEqual<RouteMap["GET"]["/simple"]["response"]>(res.data, { success: true });
+  });
+
+  await t.test("/query", async (t: TestContext) => {
+    const withoutQueryRes = await client.get("/query");
+    t.assert.equal(withoutQueryRes.status, 200);
+    t.assert.equal(withoutQueryRes.url, `${server.info.uri}/query`);
+    t.assert.deepStrictEqual<RouteMap["GET"]["/query"]["response"]>(withoutQueryRes.data, { flag: false });
+
+    const query: RouteMap["GET"]["/query"]["query"] = { flag: true };
+    const withQueryRes = await client.get("/query", { query });
+    t.assert.equal(withQueryRes.status, 200);
+    t.assert.equal(withQueryRes.url, `${server.info.uri}/query?flag=true`);
+    t.assert.deepStrictEqual<RouteMap["GET"]["/query"]["response"]>(withQueryRes.data, { flag: true });
+  });
+});

test/fixture.ts

@@ -0,0 +1,48 @@
+import Hapi, { type Request } from "@hapi/hapi";
+import Joi from "joi";
+import { Client as BaseClient } from "../lib/index.ts";
+import type { RouteMap } from "./generated.ts";
+
+export const expectType = <T>(_: T): void => void 0;
+export type TypeEqual<Target, Value> = (<T>() => T extends Target ? 1 : 2) extends <T>() => T extends Value ? 1 : 2 ? true : false;
+
+export const server = Hapi.server();
+server.route([
+  {
+    method: "GET",
+    path: "/simple",
+    options: {
+      response: {
+        status: {
+          200: Joi.object({ success: Joi.boolean().required() }),
+        },
+      },
+      handler() {
+        return { success: true };
+      },
+    },
+  },
+  {
+    method: "GET",
+    path: "/query",
+    options: {
+      validate: {
+        query: Joi.object({
+          flag: Joi.boolean().default(false),
+        }),
+      },
+      response: {
+        status: {
+          200: Joi.object({ flag: Joi.boolean().required() }),
+        },
+      },
+      handler(request: Request<{ Query: { flag: boolean } }>) {
+        return { flag: request.query.flag };
+      },
+    },
+  },
+]);
+
+// TODO: test the types in here somehow
+
+export class Client extends BaseClient<RouteMap> {};

test/inject.ts

@@ -1,69 +1,27 @@
-import Hapi, { type Request } from "@hapi/hapi";
-import Joi from "joi";
 import { test, type TestContext } from "node:test";
-import { Client } from "../lib/index.ts";
+import { server, Client } from "./fixture.ts";
+import type { RouteMap } from "./generated.ts";
 
-const expectType = <T>(_: T): void => void 0;
-type TypeEqual<Target, Value> = (<T>() => T extends Target ? 1 : 2) extends <T>() => T extends Value ? 1 : 2 ? true : false;
+await test("GET - server.inject", async (t) => {
+  const client = new Client({ server });
 
-await test("server.inject", async (t) => {
-  await t.test("can send strongly typed requests", async (t: TestContext) => {
-    const server = Hapi.server();
-    server.route({
-      method: "GET",
-      path: "/test",
-      options: {
-        validate: {
-          query: Joi.object({
-            success: Joi.boolean().default(true),
-          }),
-        },
-        response: {
-          status: {
-            200: Joi.object({ success: Joi.boolean() }),
-          },
-        },
-        handler(req: Request<{ Query: { success: boolean } }>) {
-          return { success: req.query.success };
-        },
-      },
-    });
-
-    type TestRoutes = {
-      GET: {
-        "/test": {
-          query?: {
-            success?: boolean;
-          };
-          response: {
-            success: boolean;
-          };
-        };
-      };
-    };
-
-    const client = new Client<TestRoutes>({ server });
-
-    type availablePaths = Parameters<typeof client.get>[0];
-    type expectedPaths = "/test";
-    expectType<TypeEqual<availablePaths, expectedPaths>>(true);
-
-    type availableOptions = Parameters<typeof client.get>[1];
-    type expectedOptions = {
-      headers?: HeadersInit;
-      params?: never;
-      query?: {
-        success?: boolean;
-      };
-      payload?: never;
-    };
-    expectType<TypeEqual<availableOptions, expectedOptions>>(true);
-
-    const res = await client.get("/test");
+  await t.test("/simple", async (t: TestContext) => {
+    const res = await client.get("/simple");
     t.assert.equal(res.status, 200);
-    t.assert.equal(res.url, "/test");
+    t.assert.equal(res.url, "/simple");
+    t.assert.deepStrictEqual<RouteMap["GET"]["/simple"]["response"]>(res.data, { success: true });
+  });
 
-    expectType<{ success: boolean }>(res.data);
-    t.assert.deepStrictEqual(res.data, { success: true });
+  await t.test("/query", async (t: TestContext) => {
+    const withoutQueryRes = await client.get("/query");
+    t.assert.equal(withoutQueryRes.status, 200);
+    t.assert.equal(withoutQueryRes.url, "/query");
+    t.assert.deepStrictEqual<RouteMap["GET"]["/query"]["response"]>(withoutQueryRes.data, { flag: false });
+
+    const query: RouteMap["GET"]["/query"]["query"] = { flag: true };
+    const withQueryRes = await client.get("/query", { query });
+    t.assert.equal(withQueryRes.status, 200);
+    t.assert.equal(withQueryRes.url, "/query?flag=true");
+    t.assert.deepStrictEqual<RouteMap["GET"]["/query"]["response"]>(withQueryRes.data, { flag: true });
   });
 });