@j3r3mcdev/oast-server 1.1.8 → 1.1.9

package/src/core/http/__tests__/compile-path.test.ts

@@ -1,39 +1,39 @@
-import { compilePath } from "../compile-path";
-import { describe, it, expect } from "@jest/globals";
-
-describe("compilePath", () => {
-  it("compile un chemin simple avec segment statique", () => {
-    const result = compilePath("/tasks");
-
-    expect(result).toEqual([{ type: "static", value: "tasks" }]);
-  });
-
-  it("compile un chemin avec paramètre", () => {
-    const result = compilePath("/tasks/:id");
-
-    expect(result).toEqual([
-      { type: "static", value: "tasks" },
-      { type: "param", name: "id" },
-    ]);
-  });
-
-  it("compile un chemin avec paramètre", () => {
-    const result = compilePath("/tasks/:id");
-
-    expect(result).toEqual([
-      { type: "static", value: "tasks" },
-      { type: "param", name: "id" },
-    ]);
-  });
-
-  it("compile un chemin complexe avec static, param et wildcard", () => {
-    const result = compilePath("/a/:b/*/c");
-
-    expect(result).toEqual([
-      { type: "static", value: "a" },
-      { type: "param", name: "b" },
-      { type: "wildcard" },
-      { type: "static", value: "c" },
-    ]);
-  });
-});
+import { compilePath } from "../compile-path";
+import { describe, it, expect } from "@jest/globals";
+
+describe("compilePath", () => {
+  it("compile un chemin simple avec segment statique", () => {
+    const result = compilePath("/tasks");
+
+    expect(result).toEqual([{ type: "static", value: "tasks" }]);
+  });
+
+  it("compile un chemin avec paramètre", () => {
+    const result = compilePath("/tasks/:id");
+
+    expect(result).toEqual([
+      { type: "static", value: "tasks" },
+      { type: "param", name: "id" },
+    ]);
+  });
+
+  it("compile un chemin avec paramètre", () => {
+    const result = compilePath("/tasks/:id");
+
+    expect(result).toEqual([
+      { type: "static", value: "tasks" },
+      { type: "param", name: "id" },
+    ]);
+  });
+
+  it("compile un chemin complexe avec static, param et wildcard", () => {
+    const result = compilePath("/a/:b/*/c");
+
+    expect(result).toEqual([
+      { type: "static", value: "a" },
+      { type: "param", name: "b" },
+      { type: "wildcard" },
+      { type: "static", value: "c" },
+    ]);
+  });
+});

package/src/core/http/__tests__/middleware-pipeline.test.ts

@@ -1,51 +1,51 @@
-import { MiddlewarePipeline } from "../../http/middleware";
-import { Request } from "../../http/request";
-import { Response } from "../../http/response";
-import { describe, it, expect, jest } from "@jest/globals";
-
-describe("MiddlewarePipeline", () => {
-  it("exécute les middlewares dans l'ordre", async () => {
-    const pipeline = new MiddlewarePipeline();
-
-    const calls: string[] = [];
-
-    pipeline.use(async (req, res, next) => {
-      calls.push("mw1");
-      await next();
-    });
-
-    pipeline.use(async (req, res, next) => {
-      calls.push("mw2");
-      await next();
-    });
-
-    const req = new Request({ method: "GET", path: "/", headers: {} });
-    const res = new Response({ setHeader: jest.fn(), end: jest.fn() });
-
-    await pipeline.run(req, res);
-
-    expect(calls).toEqual(["mw1", "mw2"]);
-  });
-
-  it("arrête la chaîne si next() n'est pas appelé", async () => {
-    const pipeline = new MiddlewarePipeline();
-
-    const calls: string[] = [];
-
-    pipeline.use(async () => {
-      calls.push("mw1");
-      // pas de next()
-    });
-
-    pipeline.use(async () => {
-      calls.push("mw2");
-    });
-
-    const req = new Request({ method: "GET", path: "/", headers: {} });
-    const res = new Response({ setHeader: jest.fn(), end: jest.fn() });
-
-    await pipeline.run(req, res);
-
-    expect(calls).toEqual(["mw1"]);
-  });
-});
+import { MiddlewarePipeline } from "../../http/middleware";
+import { Request } from "../../http/request";
+import { Response } from "../../http/response";
+import { describe, it, expect, jest } from "@jest/globals";
+
+describe("MiddlewarePipeline", () => {
+  it("exécute les middlewares dans l'ordre", async () => {
+    const pipeline = new MiddlewarePipeline();
+
+    const calls: string[] = [];
+
+    pipeline.use(async (req, res, next) => {
+      calls.push("mw1");
+      await next();
+    });
+
+    pipeline.use(async (req, res, next) => {
+      calls.push("mw2");
+      await next();
+    });
+
+    const req = new Request({ method: "GET", path: "/", headers: {} });
+    const res = new Response({ setHeader: jest.fn(), end: jest.fn() });
+
+    await pipeline.run(req, res);
+
+    expect(calls).toEqual(["mw1", "mw2"]);
+  });
+
+  it("arrête la chaîne si next() n'est pas appelé", async () => {
+    const pipeline = new MiddlewarePipeline();
+
+    const calls: string[] = [];
+
+    pipeline.use(async () => {
+      calls.push("mw1");
+      // pas de next()
+    });
+
+    pipeline.use(async () => {
+      calls.push("mw2");
+    });
+
+    const req = new Request({ method: "GET", path: "/", headers: {} });
+    const res = new Response({ setHeader: jest.fn(), end: jest.fn() });
+
+    await pipeline.run(req, res);
+
+    expect(calls).toEqual(["mw1"]);
+  });
+});

package/src/core/http/__tests__/request.test.ts

@@ -1,34 +1,34 @@
-import { Request } from "../request";
-import { describe, it, expect } from "@jest/globals";
-
-describe("Request", () => {
-  it("crée une requête immuable avec les bonnes propriétés", () => {
-    const req = new Request({
-      method: "GET",
-      path: "/test",
-      headers: { "content-type": "application/json" },
-      query: { a: "1" },
-      params: { id: "123" },
-      body: { x: 1 },
-      ip: "127.0.0.1",
-    });
-
-    expect(req.method).toBe("GET");
-    expect(req.path).toBe("/test");
-    expect(req.headers["content-type"]).toBe("application/json");
-    expect(req.query.a).toBe("1");
-    expect(req.params.id).toBe("123");
-    expect(req.body.x).toBe(1);
-    expect(req.ip).toBe("127.0.0.1");
-  });
-
-  it("retourne un header via header()", () => {
-    const req = new Request({
-      method: "GET",
-      path: "/",
-      headers: { "x-test": "ok" },
-    });
-
-    expect(req.header("x-test")).toBe("ok");
-  });
-});
+import { Request } from "../request";
+import { describe, it, expect } from "@jest/globals";
+
+describe("Request", () => {
+  it("crée une requête immuable avec les bonnes propriétés", () => {
+    const req = new Request({
+      method: "GET",
+      path: "/test",
+      headers: { "content-type": "application/json" },
+      query: { a: "1" },
+      params: { id: "123" },
+      body: { x: 1 },
+      ip: "127.0.0.1",
+    });
+
+    expect(req.method).toBe("GET");
+    expect(req.path).toBe("/test");
+    expect(req.headers["content-type"]).toBe("application/json");
+    expect(req.query.a).toBe("1");
+    expect(req.params.id).toBe("123");
+    expect(req.body.x).toBe(1);
+    expect(req.ip).toBe("127.0.0.1");
+  });
+
+  it("retourne un header via header()", () => {
+    const req = new Request({
+      method: "GET",
+      path: "/",
+      headers: { "x-test": "ok" },
+    });
+
+    expect(req.header("x-test")).toBe("ok");
+  });
+});

package/src/core/http/__tests__/response.test.ts

@@ -1,35 +1,35 @@
-import { Response } from "../../http/response";
-import { describe, it, expect, jest } from "@jest/globals";
-
-describe("Response", () => {
-  it("enregistre le status et les headers", () => {
-    const raw = {
-      setHeader: jest.fn(),
-      end: jest.fn(),
-    };
-
-    const res = new Response(raw);
-
-    res.status(201).header("x-test", "ok").send("hello");
-
-    expect(raw.setHeader).toHaveBeenCalledWith("x-test", "ok");
-    expect(raw.end).toHaveBeenCalledWith("hello");
-  });
-
-  it("envoie du JSON", () => {
-    const raw = {
-      setHeader: jest.fn(),
-      end: jest.fn(),
-    };
-
-    const res = new Response(raw);
-
-    res.json({ a: 1 });
-
-    expect(raw.setHeader).toHaveBeenCalledWith(
-      "content-type",
-      "application/json",
-    );
-    expect(raw.end).toHaveBeenCalledWith(JSON.stringify({ a: 1 }));
-  });
-});
+import { Response } from "../../http/response";
+import { describe, it, expect, jest } from "@jest/globals";
+
+describe("Response", () => {
+  it("enregistre le status et les headers", () => {
+    const raw = {
+      setHeader: jest.fn(),
+      end: jest.fn(),
+    };
+
+    const res = new Response(raw);
+
+    res.status(201).header("x-test", "ok").send("hello");
+
+    expect(raw.setHeader).toHaveBeenCalledWith("x-test", "ok");
+    expect(raw.end).toHaveBeenCalledWith("hello");
+  });
+
+  it("envoie du JSON", () => {
+    const raw = {
+      setHeader: jest.fn(),
+      end: jest.fn(),
+    };
+
+    const res = new Response(raw);
+
+    res.json({ a: 1 });
+
+    expect(raw.setHeader).toHaveBeenCalledWith(
+      "content-type",
+      "application/json",
+    );
+    expect(raw.end).toHaveBeenCalledWith(JSON.stringify({ a: 1 }));
+  });
+});

package/src/core/http/__tests__/router-match.test.ts

@@ -1,171 +1,171 @@
-import { Router } from "../router";
-import { describe, it, expect } from "@jest/globals";
-
-describe("Router.match", () => {
-  it("match une route statique", () => {
-    const router = new Router();
-
-    router.register("GET", "/tasks", () => "ok");
-
-    const result = router.match("GET", "/tasks");
-
-    expect(result).not.toBeNull();
-    expect(result?.handler()).toBe("ok");
-    expect(result?.params).toEqual({});
-    expect(result?.middlewares).toEqual([]);
-  });
-
-  it("match une route avec paramètre", () => {
-    const router = new Router();
-
-    router.register("GET", "/tasks/:id", () => "task");
-
-    const result = router.match("GET", "/tasks/42");
-
-    expect(result).not.toBeNull();
-    expect(result?.handler()).toBe("task");
-    expect(result?.params).toEqual({ id: "42" });
-    expect(result?.middlewares).toEqual([]);
-  });
-
-  it("match une route avec wildcard", () => {
-    const router = new Router();
-
-    router.register("GET", "/files/*", () => "wild");
-
-    const result = router.match("GET", "/files/any/path/here");
-
-    expect(result).not.toBeNull();
-    expect(result?.handler()).toBe("wild");
-    expect(result?.params).toEqual({});
-    expect(result?.middlewares).toEqual([]);
-  });
-
-  it("match un chemin complexe avec static, param et wildcard", () => {
-    const router = new Router();
-
-    router.register("GET", "/a/:b/*/c", () => "complex");
-
-    const result = router.match("GET", "/a/hello/anything/here/c");
-
-    expect(result).not.toBeNull();
-    expect(result?.handler()).toBe("complex");
-    expect(result?.params).toEqual({ b: "hello" });
-    expect(result?.middlewares).toEqual([]);
-  });
-
-  it("ne match pas quand le chemin ne correspond pas", () => {
-    const router = new Router();
-
-    router.register("GET", "/tasks/:id", () => "ok");
-
-    const result = router.match("GET", "/tasks");
-
-    expect(result).toBeNull();
-  });
-
-  it("ne match pas quand le chemin est trop long", () => {
-    const router = new Router();
-
-    router.register("GET", "/tasks/:id", () => "ok");
-
-    const result = router.match("GET", "/tasks/42/extra");
-
-    expect(result).toBeNull();
-  });
-
-  it("ne match pas quand la méthode HTTP ne correspond pas", () => {
-    const router = new Router();
-
-    router.register("GET", "/tasks", () => "ok");
-
-    const result = router.match("POST", "/tasks");
-
-    expect(result).toBeNull();
-  });
-
-  it("match une route avec plusieurs paramètres", () => {
-    const router = new Router();
-
-    router.register("GET", "/users/:userId/tasks/:taskId", () => "multi");
-
-    const result = router.match("GET", "/users/12/tasks/99");
-
-    expect(result).not.toBeNull();
-    expect(result?.handler()).toBe("multi");
-    expect(result?.params).toEqual({
-      userId: "12",
-      taskId: "99",
-    });
-    expect(result?.middlewares).toEqual([]);
-  });
-
-  it("match une route complexe avec plusieurs paramètres et un wildcard", () => {
-    const router = new Router();
-
-    router.register("GET", "/users/:userId/*/tasks/:taskId", () => "mw");
-
-    const result = router.match("GET", "/users/12/any/path/here/tasks/99");
-
-    expect(result).not.toBeNull();
-    expect(result?.handler()).toBe("mw");
-    expect(result?.params).toEqual({
-      userId: "12",
-      taskId: "99",
-    });
-    expect(result?.middlewares).toEqual([]);
-  });
-
-  it("ne match pas un chemin complexe si la fin ne correspond pas", () => {
-    const router = new Router();
-
-    router.register("GET", "/users/:userId/*/tasks/:taskId", () => "mw");
-
-    const result = router.match("GET", "/users/12/any/path/here/taskz/99");
-
-    expect(result).toBeNull();
-  });
-
-  it("ne match pas si le paramètre final est manquant", () => {
-    const router = new Router();
-
-    router.register("GET", "/users/:userId/*/tasks/:taskId", () => "mw");
-
-    const result = router.match("GET", "/users/12/any/path/here/tasks/");
-
-    expect(result).toBeNull();
-  });
-
-  it("ne match pas si le paramètre du début est manquant", () => {
-    const router = new Router();
-
-    router.register("GET", "/users/:userId/*/tasks/:taskId", () => "mw");
-
-    const result = router.match("GET", "/users//any/path/tasks/99");
-
-    expect(result).toBeNull();
-  });
-
-  it("ne match pas si le wildcard est vide", () => {
-    const router = new Router();
-
-    router.register("GET", "/users/:userId/*/tasks/:taskId", () => "mw");
-
-    const result = router.match("GET", "/users/12//tasks/99");
-
-    expect(result).toBeNull();
-  });
-
-  it("match une route avec wildcard en fin de chemin", () => {
-    const router = new Router();
-
-    router.register("GET", "/files/*", () => "end");
-
-    const result = router.match("GET", "/files/path/to/something");
-
-    expect(result).not.toBeNull();
-    expect(result?.handler()).toBe("end");
-    expect(result?.params).toEqual({});
-    expect(result?.middlewares).toEqual([]);
-  });
-});
+import { Router } from "../router";
+import { describe, it, expect } from "@jest/globals";
+
+describe("Router.match", () => {
+  it("match une route statique", () => {
+    const router = new Router();
+
+    router.register("GET", "/tasks", () => "ok");
+
+    const result = router.match("GET", "/tasks");
+
+    expect(result).not.toBeNull();
+    expect(result?.handler()).toBe("ok");
+    expect(result?.params).toEqual({});
+    expect(result?.middlewares).toEqual([]);
+  });
+
+  it("match une route avec paramètre", () => {
+    const router = new Router();
+
+    router.register("GET", "/tasks/:id", () => "task");
+
+    const result = router.match("GET", "/tasks/42");
+
+    expect(result).not.toBeNull();
+    expect(result?.handler()).toBe("task");
+    expect(result?.params).toEqual({ id: "42" });
+    expect(result?.middlewares).toEqual([]);
+  });
+
+  it("match une route avec wildcard", () => {
+    const router = new Router();
+
+    router.register("GET", "/files/*", () => "wild");
+
+    const result = router.match("GET", "/files/any/path/here");
+
+    expect(result).not.toBeNull();
+    expect(result?.handler()).toBe("wild");
+    expect(result?.params).toEqual({});
+    expect(result?.middlewares).toEqual([]);
+  });
+
+  it("match un chemin complexe avec static, param et wildcard", () => {
+    const router = new Router();
+
+    router.register("GET", "/a/:b/*/c", () => "complex");
+
+    const result = router.match("GET", "/a/hello/anything/here/c");
+
+    expect(result).not.toBeNull();
+    expect(result?.handler()).toBe("complex");
+    expect(result?.params).toEqual({ b: "hello" });
+    expect(result?.middlewares).toEqual([]);
+  });
+
+  it("ne match pas quand le chemin ne correspond pas", () => {
+    const router = new Router();
+
+    router.register("GET", "/tasks/:id", () => "ok");
+
+    const result = router.match("GET", "/tasks");
+
+    expect(result).toBeNull();
+  });
+
+  it("ne match pas quand le chemin est trop long", () => {
+    const router = new Router();
+
+    router.register("GET", "/tasks/:id", () => "ok");
+
+    const result = router.match("GET", "/tasks/42/extra");
+
+    expect(result).toBeNull();
+  });
+
+  it("ne match pas quand la méthode HTTP ne correspond pas", () => {
+    const router = new Router();
+
+    router.register("GET", "/tasks", () => "ok");
+
+    const result = router.match("POST", "/tasks");
+
+    expect(result).toBeNull();
+  });
+
+  it("match une route avec plusieurs paramètres", () => {
+    const router = new Router();
+
+    router.register("GET", "/users/:userId/tasks/:taskId", () => "multi");
+
+    const result = router.match("GET", "/users/12/tasks/99");
+
+    expect(result).not.toBeNull();
+    expect(result?.handler()).toBe("multi");
+    expect(result?.params).toEqual({
+      userId: "12",
+      taskId: "99",
+    });
+    expect(result?.middlewares).toEqual([]);
+  });
+
+  it("match une route complexe avec plusieurs paramètres et un wildcard", () => {
+    const router = new Router();
+
+    router.register("GET", "/users/:userId/*/tasks/:taskId", () => "mw");
+
+    const result = router.match("GET", "/users/12/any/path/here/tasks/99");
+
+    expect(result).not.toBeNull();
+    expect(result?.handler()).toBe("mw");
+    expect(result?.params).toEqual({
+      userId: "12",
+      taskId: "99",
+    });
+    expect(result?.middlewares).toEqual([]);
+  });
+
+  it("ne match pas un chemin complexe si la fin ne correspond pas", () => {
+    const router = new Router();
+
+    router.register("GET", "/users/:userId/*/tasks/:taskId", () => "mw");
+
+    const result = router.match("GET", "/users/12/any/path/here/taskz/99");
+
+    expect(result).toBeNull();
+  });
+
+  it("ne match pas si le paramètre final est manquant", () => {
+    const router = new Router();
+
+    router.register("GET", "/users/:userId/*/tasks/:taskId", () => "mw");
+
+    const result = router.match("GET", "/users/12/any/path/here/tasks/");
+
+    expect(result).toBeNull();
+  });
+
+  it("ne match pas si le paramètre du début est manquant", () => {
+    const router = new Router();
+
+    router.register("GET", "/users/:userId/*/tasks/:taskId", () => "mw");
+
+    const result = router.match("GET", "/users//any/path/tasks/99");
+
+    expect(result).toBeNull();
+  });
+
+  it("ne match pas si le wildcard est vide", () => {
+    const router = new Router();
+
+    router.register("GET", "/users/:userId/*/tasks/:taskId", () => "mw");
+
+    const result = router.match("GET", "/users/12//tasks/99");
+
+    expect(result).toBeNull();
+  });
+
+  it("match une route avec wildcard en fin de chemin", () => {
+    const router = new Router();
+
+    router.register("GET", "/files/*", () => "end");
+
+    const result = router.match("GET", "/files/path/to/something");
+
+    expect(result).not.toBeNull();
+    expect(result?.handler()).toBe("end");
+    expect(result?.params).toEqual({});
+    expect(result?.middlewares).toEqual([]);
+  });
+});