@j3r3mcdev/oast-server 1.1.1 → 1.1.3

package/src/core/__tests__/core-server.test.ts

@@ -1,44 +1,44 @@
-import { CoreServer } from "../../core/server";
-import { StorageManager } from "../../core/storage";
-import { Logger } from "../../core/logger";
-import { describe, it, expect } from "@jest/globals";
-
-class FakeListener {
-  started = false;
-  stopped = false;
-
-  async start() {
-    this.started = true;
-  }
-
-  async stop() {
-    this.stopped = true;
-  }
-}
-
-describe("CoreServer", () => {
-  it("démarre et arrête les listeners", async () => {
-    const listener = new FakeListener();
-
-    const server = new CoreServer({
-      storage: new StorageManager(),
-      logger: new Logger({ enabled: false }),
-      listeners: [listener],
-    });
-
-    await server.start();
-    expect(listener.started).toBe(true);
-
-    await server.stop();
-    expect(listener.stopped).toBe(true);
-  });
-
-  it("expose le router", () => {
-    const server = new CoreServer({
-      storage: new StorageManager(),
-    });
-
-    const router = server.getRouter();
-    expect(router).toBeDefined();
-  });
-});
+import { CoreServer } from "../../core/server";
+import { StorageManager } from "../../core/storage";
+import { Logger } from "../../core/logger";
+import { describe, it, expect } from "@jest/globals";
+
+class FakeListener {
+  started = false;
+  stopped = false;
+
+  async start() {
+    this.started = true;
+  }
+
+  async stop() {
+    this.stopped = true;
+  }
+}
+
+describe("CoreServer", () => {
+  it("démarre et arrête les listeners", async () => {
+    const listener = new FakeListener();
+
+    const server = new CoreServer({
+      storage: new StorageManager(),
+      logger: new Logger({ enabled: false }),
+      listeners: [listener],
+    });
+
+    await server.start();
+    expect(listener.started).toBe(true);
+
+    await server.stop();
+    expect(listener.stopped).toBe(true);
+  });
+
+  it("expose le router", () => {
+    const server = new CoreServer({
+      storage: new StorageManager(),
+    });
+
+    const router = server.getRouter();
+    expect(router).toBeDefined();
+  });
+});

package/src/core/__tests__/event.normalizer.test.ts

@@ -1,56 +1,56 @@
-import { EventNormalizer } from "../event.normalizer";
-import { describe, it, expect, jest } from "@jest/globals";
-import { IdGenerator } from "../id-generator";
-
-describe("EventNormalizer.normalizeHttp", () => {
-  it("normalise correctement une requête HTTP", () => {
-    // Mock du timestamp
-    const fakeNow = 1234567890;
-    jest.spyOn(Date, "now").mockReturnValue(fakeNow);
-
-    // Mock de l'ID
-    jest.spyOn(IdGenerator, "generate").mockReturnValue("uuid-test");
-
-    const req = {
-      ip: "9.9.9.9",
-      method: "POST",
-      path: "/test",
-      headers: { "x-forwarded-for": "9.9.9.9" },
-      query: { a: "1" },
-      body: { hello: "world" },
-      raw: {}, // obligatoire
-    };
-
-    const event = EventNormalizer.normalizeHttp(req);
-
-    expect(event).toEqual({
-      id: "uuid-test",
-      type: "http",
-      timestamp: fakeNow,
-      sourceIp: "9.9.9.9",
-      request: {
-        method: "POST",
-        path: "/test",
-        headers: { "x-forwarded-for": "9.9.9.9" },
-        query: { a: "1" },
-        body: { hello: "world" },
-      },
-    });
-  });
-
-  it("retourne 'unknown' si aucune IP n'est trouvée", () => {
-    const req = {
-      ip: "",
-      method: "GET",
-      path: "/",
-      headers: {},
-      query: {},
-      body: {},
-      raw: {},
-    };
-
-    const event = EventNormalizer.normalizeHttp(req);
-
-    expect(event.sourceIp).toBe("unknown");
-  });
-});
+import { EventNormalizer } from "../event.normalizer";
+import { describe, it, expect, jest } from "@jest/globals";
+import { IdGenerator } from "../id-generator";
+
+describe("EventNormalizer.normalizeHttp", () => {
+  it("normalise correctement une requête HTTP", () => {
+    // Mock du timestamp
+    const fakeNow = 1234567890;
+    jest.spyOn(Date, "now").mockReturnValue(fakeNow);
+
+    // Mock de l'ID
+    jest.spyOn(IdGenerator, "generate").mockReturnValue("uuid-test");
+
+    const req = {
+      ip: "9.9.9.9",
+      method: "POST",
+      path: "/test",
+      headers: { "x-forwarded-for": "9.9.9.9" },
+      query: { a: "1" },
+      body: { hello: "world" },
+      raw: {}, // obligatoire
+    };
+
+    const event = EventNormalizer.normalizeHttp(req);
+
+    expect(event).toEqual({
+      id: "uuid-test",
+      type: "http",
+      timestamp: fakeNow,
+      sourceIp: "9.9.9.9",
+      request: {
+        method: "POST",
+        path: "/test",
+        headers: { "x-forwarded-for": "9.9.9.9" },
+        query: { a: "1" },
+        body: { hello: "world" },
+      },
+    });
+  });
+
+  it("retourne 'unknown' si aucune IP n'est trouvée", () => {
+    const req = {
+      ip: "",
+      method: "GET",
+      path: "/",
+      headers: {},
+      query: {},
+      body: {},
+      raw: {},
+    };
+
+    const event = EventNormalizer.normalizeHttp(req);
+
+    expect(event.sourceIp).toBe("unknown");
+  });
+});

package/src/core/__tests__/event.router.test.ts

@@ -1,89 +1,89 @@
-import {
-  AnyNormalizedEvent,
-  NormalizedHttpEvent,
-} from "../../types/event.types";
-import {
-  StorageListParams,
-  Storage,
-} from "../../storage-adapters/storage.interface";
-import { EventRouter } from "../event.router";
-import { EventNormalizer } from "../event.normalizer";
-import { describe, it, expect, jest } from "@jest/globals";
-
-class MockStorage implements Storage {
-  save = jest.fn<(event: AnyNormalizedEvent) => Promise<void>>();
-  getEvent = jest.fn<(id: string) => Promise<AnyNormalizedEvent | null>>();
-  listEvents =
-    jest.fn<(params: StorageListParams) => Promise<AnyNormalizedEvent[]>>();
-  deleteEvent = jest.fn<(id: string) => Promise<boolean>>();
-  clearEvents = jest.fn<() => Promise<void>>();
-  getStats =
-    jest.fn<() => Promise<{ total: number; byType: Record<string, number> }>>();
-  getAll = jest.fn<() => Promise<AnyNormalizedEvent[]>>();
-}
-
-describe("EventRouter", () => {
-  it("enregistre un événement HTTP normalisé", async () => {
-    const mockStorage = new MockStorage();
-
-    const fakeEvent: NormalizedHttpEvent = {
-      id: "123",
-      type: "http",
-      timestamp: 111,
-      sourceIp: "1.1.1.1",
-      request: {
-        method: "GET",
-        path: "/",
-        headers: {},
-        query: {},
-        body: {},
-      },
-    };
-
-    jest.spyOn(EventNormalizer, "normalizeHttp").mockReturnValue(fakeEvent);
-
-    const router = new EventRouter(mockStorage);
-
-    const req = {
-      ip: "1.1.1.1",
-      method: "GET",
-      path: "/",
-      headers: {},
-      query: {},
-      body: {},
-      raw: {},
-    };
-
-    const result = await router.handleHttp(req);
-
-    expect(EventNormalizer.normalizeHttp).toHaveBeenCalledWith(req);
-    expect(mockStorage.save).toHaveBeenCalledWith(fakeEvent);
-    expect(result).toEqual(fakeEvent);
-  });
-
-  it("propagate une erreur si normalizeHttp throw", async () => {
-    const mockStorage = new MockStorage();
-
-    jest.spyOn(EventNormalizer, "normalizeHttp").mockImplementation(() => {
-      throw new Error("Boom");
-    });
-
-    const router = new EventRouter(mockStorage);
-
-    await expect(router.handleHttp({} as any)).rejects.toThrow("Boom");
-    expect(mockStorage.save).not.toHaveBeenCalled();
-  });
-
-  it("propagate une erreur si storage.save throw", async () => {
-    const mockStorage = new MockStorage();
-
-    const fakeEvent = { id: "x", type: "http" } as any;
-
-    jest.spyOn(EventNormalizer, "normalizeHttp").mockReturnValue(fakeEvent);
-    mockStorage.save.mockRejectedValue(new Error("DB error"));
-
-    const router = new EventRouter(mockStorage);
-
-    await expect(router.handleHttp({} as any)).rejects.toThrow("DB error");
-  });
-});
+import {
+  AnyNormalizedEvent,
+  NormalizedHttpEvent,
+} from "../../types/event.types";
+import {
+  StorageListParams,
+  Storage,
+} from "../../storage-adapters/storage.interface";
+import { EventRouter } from "../event.router";
+import { EventNormalizer } from "../event.normalizer";
+import { describe, it, expect, jest } from "@jest/globals";
+
+class MockStorage implements Storage {
+  save = jest.fn<(event: AnyNormalizedEvent) => Promise<void>>();
+  getEvent = jest.fn<(id: string) => Promise<AnyNormalizedEvent | null>>();
+  listEvents =
+    jest.fn<(params: StorageListParams) => Promise<AnyNormalizedEvent[]>>();
+  deleteEvent = jest.fn<(id: string) => Promise<boolean>>();
+  clearEvents = jest.fn<() => Promise<void>>();
+  getStats =
+    jest.fn<() => Promise<{ total: number; byType: Record<string, number> }>>();
+  getAll = jest.fn<() => Promise<AnyNormalizedEvent[]>>();
+}
+
+describe("EventRouter", () => {
+  it("enregistre un événement HTTP normalisé", async () => {
+    const mockStorage = new MockStorage();
+
+    const fakeEvent: NormalizedHttpEvent = {
+      id: "123",
+      type: "http",
+      timestamp: 111,
+      sourceIp: "1.1.1.1",
+      request: {
+        method: "GET",
+        path: "/",
+        headers: {},
+        query: {},
+        body: {},
+      },
+    };
+
+    jest.spyOn(EventNormalizer, "normalizeHttp").mockReturnValue(fakeEvent);
+
+    const router = new EventRouter(mockStorage);
+
+    const req = {
+      ip: "1.1.1.1",
+      method: "GET",
+      path: "/",
+      headers: {},
+      query: {},
+      body: {},
+      raw: {},
+    };
+
+    const result = await router.handleHttp(req);
+
+    expect(EventNormalizer.normalizeHttp).toHaveBeenCalledWith(req);
+    expect(mockStorage.save).toHaveBeenCalledWith(fakeEvent);
+    expect(result).toEqual(fakeEvent);
+  });
+
+  it("propagate une erreur si normalizeHttp throw", async () => {
+    const mockStorage = new MockStorage();
+
+    jest.spyOn(EventNormalizer, "normalizeHttp").mockImplementation(() => {
+      throw new Error("Boom");
+    });
+
+    const router = new EventRouter(mockStorage);
+
+    await expect(router.handleHttp({} as any)).rejects.toThrow("Boom");
+    expect(mockStorage.save).not.toHaveBeenCalled();
+  });
+
+  it("propagate une erreur si storage.save throw", async () => {
+    const mockStorage = new MockStorage();
+
+    const fakeEvent = { id: "x", type: "http" } as any;
+
+    jest.spyOn(EventNormalizer, "normalizeHttp").mockReturnValue(fakeEvent);
+    mockStorage.save.mockRejectedValue(new Error("DB error"));
+
+    const router = new EventRouter(mockStorage);
+
+    await expect(router.handleHttp({} as any)).rejects.toThrow("DB error");
+  });
+});

package/src/core/__tests__/logger.test.ts

@@ -1,32 +1,32 @@
-import { Logger, LogEntry } from "../../core/logger";
-import { describe, it, expect, jest } from "@jest/globals";
-
-describe("Logger", () => {
-  it("appelle les hooks", () => {
-    const hook = jest.fn<(entry: LogEntry) => void>();
-    const logger = new Logger({ hooks: [hook], enabled: true });
-
-    logger.info("hello");
-
-    expect(hook).toHaveBeenCalled();
-    expect(hook.mock.calls[0][0].message).toBe("hello");
-  });
-
-  it("respecte le niveau de logs", () => {
-    const hook = jest.fn<(entry: LogEntry) => void>();
-    const logger = new Logger({ level: "warn", hooks: [hook] });
-
-    logger.info("should not log");
-    logger.error("should log");
-
-    expect(hook).toHaveBeenCalledTimes(1);
-    expect(hook.mock.calls[0][0].level).toBe("error");
-  });
-
-  it("crée un logger enfant avec contexte", () => {
-    const logger = new Logger({ context: "root" });
-    const child = logger.withContext("child");
-
-    expect(child).not.toBe(logger);
-  });
-});
+import { Logger, LogEntry } from "../../core/logger";
+import { describe, it, expect, jest } from "@jest/globals";
+
+describe("Logger", () => {
+  it("appelle les hooks", () => {
+    const hook = jest.fn<(entry: LogEntry) => void>();
+    const logger = new Logger({ hooks: [hook], enabled: true });
+
+    logger.info("hello");
+
+    expect(hook).toHaveBeenCalled();
+    expect(hook.mock.calls[0][0].message).toBe("hello");
+  });
+
+  it("respecte le niveau de logs", () => {
+    const hook = jest.fn<(entry: LogEntry) => void>();
+    const logger = new Logger({ level: "warn", hooks: [hook] });
+
+    logger.info("should not log");
+    logger.error("should log");
+
+    expect(hook).toHaveBeenCalledTimes(1);
+    expect(hook.mock.calls[0][0].level).toBe("error");
+  });
+
+  it("crée un logger enfant avec contexte", () => {
+    const logger = new Logger({ context: "root" });
+    const child = logger.withContext("child");
+
+    expect(child).not.toBe(logger);
+  });
+});

package/src/core/__tests__/storage-manager.test.ts

@@ -1,74 +1,74 @@
-import { describe, test, expect } from "@jest/globals";
-import { StorageManager } from "../storage"; // si ton fichier s'appelle storage-manager.ts
-import { NormalizedHttpEvent } from "../../types/event.types";
-
-function makeHttpEvent(id: string): NormalizedHttpEvent {
-  return {
-    id,
-    type: "http",
-    timestamp: Date.now(),
-    sourceIp: "127.0.0.1",
-    request: {
-      method: "GET",
-      path: "/",
-      headers: {},
-      query: {},
-      body: "",
-    },
-  };
-}
-
-describe("StorageManager", () => {
-  test("save + getEvent", async () => {
-    const storage = new StorageManager();
-
-    const event = makeHttpEvent("1");
-    await storage.save(event);
-
-    const found = await storage.getEvent("1");
-    expect(found).not.toBeNull();
-    expect(found?.id).toBe("1");
-  });
-
-  test("listEvents returns events", async () => {
-    const storage = new StorageManager();
-
-    await storage.save(makeHttpEvent("1"));
-
-    const list = await storage.listEvents({});
-    expect(list.length).toBe(1);
-  });
-
-  test("deleteEvent removes event", async () => {
-    const storage = new StorageManager();
-
-    await storage.save(makeHttpEvent("1"));
-
-    let list = await storage.listEvents({});
-    expect(list.length).toBe(1);
-
-    await storage.deleteEvent("1");
-
-    list = await storage.listEvents({});
-    expect(list.length).toBe(0);
-  });
-
-  test("clearEvents empties storage", async () => {
-    const storage = new StorageManager();
-
-    await storage.save(makeHttpEvent("1"));
-    await storage.clearEvents();
-
-    const list = await storage.listEvents({});
-    expect(list.length).toBe(0);
-  });
-
-  test("getStats returns correct structure", async () => {
-    const storage = new StorageManager();
-
-    const stats = await storage.getStats();
-
-    expect(stats.total).toBe(0);
-    expect(stats.byType).toEqual({});
-  });
-});
+import { describe, test, expect } from "@jest/globals";
+import { StorageManager } from "../storage"; // si ton fichier s'appelle storage-manager.ts
+import { NormalizedHttpEvent } from "../../types/event.types";
+
+function makeHttpEvent(id: string): NormalizedHttpEvent {
+  return {
+    id,
+    type: "http",
+    timestamp: Date.now(),
+    sourceIp: "127.0.0.1",
+    request: {
+      method: "GET",
+      path: "/",
+      headers: {},
+      query: {},
+      body: "",
+    },
+  };
+}
+
+describe("StorageManager", () => {
+  test("save + getEvent", async () => {
+    const storage = new StorageManager();
+
+    const event = makeHttpEvent("1");
+    await storage.save(event);
+
+    const found = await storage.getEvent("1");
+    expect(found).not.toBeNull();
+    expect(found?.id).toBe("1");
+  });
+
+  test("listEvents returns events", async () => {
+    const storage = new StorageManager();
+
+    await storage.save(makeHttpEvent("1"));
+
+    const list = await storage.listEvents({});
+    expect(list.length).toBe(1);
+  });
+
+  test("deleteEvent removes event", async () => {
+    const storage = new StorageManager();
+
+    await storage.save(makeHttpEvent("1"));
+
+    let list = await storage.listEvents({});
+    expect(list.length).toBe(1);
+
+    await storage.deleteEvent("1");
+
+    list = await storage.listEvents({});
+    expect(list.length).toBe(0);
+  });
+
+  test("clearEvents empties storage", async () => {
+    const storage = new StorageManager();
+
+    await storage.save(makeHttpEvent("1"));
+    await storage.clearEvents();
+
+    const list = await storage.listEvents({});
+    expect(list.length).toBe(0);
+  });
+
+  test("getStats returns correct structure", async () => {
+    const storage = new StorageManager();
+
+    const stats = await storage.getStats();
+
+    expect(stats.total).toBe(0);
+    expect(stats.byType).toEqual({});
+  });
+});