@j3r3mcdev/oast-server 1.0.0 → 1.1.0

package/src/core/http/__tests__/body-parser-multipart.test.ts

@@ -1,41 +1,41 @@
-import { bodyParserMultipart } from "../middleware";
-import { Request } from "../request";
-import { Response } from "../response";
-import { describe, it, expect } from "@jest/globals";
-
-describe("bodyParserMultipart", () => {
-  it("parse un champ texte et un fichier", async () => {
-    const boundary = "----1234";
-
-    const raw = {
-      headers: { "content-type": `multipart/form-data; boundary=${boundary}` },
-      [Symbol.asyncIterator]: async function* () {
-        yield Buffer.from(
-          `--${boundary}\r\n` +
-            `Content-Disposition: form-data; name="username"\r\n\r\n` +
-            `jeremy\r\n` +
-            `--${boundary}\r\n` +
-            `Content-Disposition: form-data; name="file"; filename="test.txt"\r\n` +
-            `Content-Type: text/plain\r\n\r\n` +
-            `Hello world\r\n` +
-            `--${boundary}--`,
-        );
-      },
-    };
-
-    const req = new Request({
-      method: "POST",
-      path: "/upload",
-      headers: raw.headers,
-      raw,
-    });
-
-    const res = new Response({});
-
-    await bodyParserMultipart(req, res);
-
-    expect(req.form?.username).toBe("jeremy");
-    expect(req.files?.[0].filename).toBe("test.txt");
-    expect(req.files?.[0].data.toString()).toBe("Hello world");
-  });
-});
+import { bodyParserMultipart } from "../middleware";
+import { Request } from "../request";
+import { Response } from "../response";
+import { describe, it, expect } from "@jest/globals";
+
+describe("bodyParserMultipart", () => {
+  it("parse un champ texte et un fichier", async () => {
+    const boundary = "----1234";
+
+    const raw = {
+      headers: { "content-type": `multipart/form-data; boundary=${boundary}` },
+      [Symbol.asyncIterator]: async function* () {
+        yield Buffer.from(
+          `--${boundary}\r\n` +
+            `Content-Disposition: form-data; name="username"\r\n\r\n` +
+            `jeremy\r\n` +
+            `--${boundary}\r\n` +
+            `Content-Disposition: form-data; name="file"; filename="test.txt"\r\n` +
+            `Content-Type: text/plain\r\n\r\n` +
+            `Hello world\r\n` +
+            `--${boundary}--`,
+        );
+      },
+    };
+
+    const req = new Request({
+      method: "POST",
+      path: "/upload",
+      headers: raw.headers,
+      raw,
+    });
+
+    const res = new Response({});
+
+    await bodyParserMultipart(req, res);
+
+    expect(req.form?.username).toBe("jeremy");
+    expect(req.files?.[0].filename).toBe("test.txt");
+    expect(req.files?.[0].data.toString()).toBe("Hello world");
+  });
+});

package/src/core/http/__tests__/body-parser-raw.test.ts

@@ -1,28 +1,28 @@
-import { bodyParserRaw } from "../middleware";
-import { Request } from "../request";
-import { Response } from "../response";
-import { describe, it, expect } from "@jest/globals";
-
-describe("bodyParserRaw", () => {
-  it("lit le body brut", async () => {
-    const raw = {
-      headers: { "content-type": "application/octet-stream" },
-      [Symbol.asyncIterator]: async function* () {
-        yield Buffer.from([1, 2, 3, 4]);
-      },
-    };
-
-    const req = new Request({
-      method: "POST",
-      path: "/",
-      headers: raw.headers,
-      raw,
-    });
-
-    const res = new Response({});
-
-    await bodyParserRaw(req, res);
-
-    expect(req.bodyRaw).toEqual(Buffer.from([1, 2, 3, 4]));
-  });
-});
+import { bodyParserRaw } from "../middleware";
+import { Request } from "../request";
+import { Response } from "../response";
+import { describe, it, expect } from "@jest/globals";
+
+describe("bodyParserRaw", () => {
+  it("lit le body brut", async () => {
+    const raw = {
+      headers: { "content-type": "application/octet-stream" },
+      [Symbol.asyncIterator]: async function* () {
+        yield Buffer.from([1, 2, 3, 4]);
+      },
+    };
+
+    const req = new Request({
+      method: "POST",
+      path: "/",
+      headers: raw.headers,
+      raw,
+    });
+
+    const res = new Response({});
+
+    await bodyParserRaw(req, res);
+
+    expect(req.bodyRaw).toEqual(Buffer.from([1, 2, 3, 4]));
+  });
+});

package/src/core/http/__tests__/body-parser-text.test.ts

@@ -1,28 +1,28 @@
-import { bodyParserText } from "../middleware";
-import { Request } from "../request";
-import { Response } from "../response";
-import { describe, it, expect } from "@jest/globals";
-
-describe("bodyParserText", () => {
-  it("lit le body text", async () => {
-    const raw = {
-      headers: { "content-type": "text/plain" },
-      [Symbol.asyncIterator]: async function* () {
-        yield Buffer.from("Hello world");
-      },
-    };
-
-    const req = new Request({
-      method: "POST",
-      path: "/",
-      headers: raw.headers,
-      raw,
-    });
-
-    const res = new Response({});
-
-    await bodyParserText(req, res);
-
-    expect(req.bodyText).toBe("Hello world");
-  });
-});
+import { bodyParserText } from "../middleware";
+import { Request } from "../request";
+import { Response } from "../response";
+import { describe, it, expect } from "@jest/globals";
+
+describe("bodyParserText", () => {
+  it("lit le body text", async () => {
+    const raw = {
+      headers: { "content-type": "text/plain" },
+      [Symbol.asyncIterator]: async function* () {
+        yield Buffer.from("Hello world");
+      },
+    };
+
+    const req = new Request({
+      method: "POST",
+      path: "/",
+      headers: raw.headers,
+      raw,
+    });
+
+    const res = new Response({});
+
+    await bodyParserText(req, res);
+
+    expect(req.bodyText).toBe("Hello world");
+  });
+});

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 }));
+  });
+});