Initial Commit

packages/api-stack/api/api-plugin-webhook/tests/integration/full-boot.test.ts

@@ -0,0 +1,125 @@
+import { createServer, type Server } from "node:http";
+import { OpenAPIHono } from "@hono/zod-openapi";
+import { createOpenAPIRegistry } from "@suaveplan/api-openapi";
+import { createPluginContext } from "@suaveplan/api-plugin";
+import { EventBus } from "@suaveplan/events";
+import { describe, expect, it } from "@suaveplan/testing/runner";
+import {
+    createWebhookPlugin,
+    resetWebhookInstruments,
+    type WebhookPluginConfig,
+    type WebhookService,
+} from "../../src/index.js";
+
+interface Receiver {
+    readonly url: string;
+    readonly observed: { event: string; body: string }[];
+    close(): Promise<void>;
+}
+
+async function startReceiver(): Promise<Receiver> {
+    const observed: { event: string; body: string }[] = [];
+    const server: Server = createServer((req, res) => {
+        let body = "";
+        req.on("data", (c) => {
+            body += c;
+        });
+        req.on("end", () => {
+            const evt = req.headers["x-webhook-event"];
+            observed.push({
+                event: Array.isArray(evt) ? (evt[0] ?? "") : (evt ?? ""),
+                body,
+            });
+            res.writeHead(200);
+            res.end("ok");
+        });
+    });
+    await new Promise<void>((resolve) =>
+        server.listen(0, "127.0.0.1", resolve)
+    );
+    const address = server.address();
+    if (address === null || typeof address === "string") {
+        throw new Error("failed to bind");
+    }
+    return {
+        url: `http://127.0.0.1:${address.port}/hooks`,
+        observed,
+        close: () =>
+            new Promise<void>((resolve, reject) => {
+                server.close((err) => (err ? reject(err) : resolve()));
+            }),
+    };
+}
+
+const noopLogger = {
+    debug: () => undefined,
+    info: () => undefined,
+    warn: () => undefined,
+    error: () => undefined,
+};
+
+describe("integration: webhook plugin full boot", () => {
+    it("POST /webhooks/:id/test fires a synthetic webhook.ping", {
+        timeout: 30_000,
+    }, async () => {
+        const receiver = await startReceiver();
+        try {
+            resetWebhookInstruments();
+            const app = new OpenAPIHono();
+            app.onError((err, c) => {
+                const ctx = (err as { context?: { statusCode?: number } })
+                    .context;
+                const status = (ctx?.statusCode ?? 500) as
+                    | 401
+                    | 403
+                    | 404
+                    | 500;
+                return c.json({ message: err?.message ?? "error" }, status);
+            });
+            const registry = createOpenAPIRegistry({
+                info: { title: "test", version: "0.1.0" },
+            });
+            const services = new Map<string, unknown>();
+            services.set("app", app);
+            services.set("openAPIRegistry", registry);
+            // Install a permissive auth middleware ABOVE the plugin's
+            // /webhooks/* requireAuth so the integration test does not
+            // need a real auth plugin.
+            app.use("*", async (c, next) => {
+                c.set("user", { id: "u", tenantId: null });
+                await next();
+            });
+            const descriptor = createWebhookPlugin();
+            const ctx = createPluginContext<WebhookPluginConfig>({
+                logger: noopLogger,
+                eventBus: new EventBus(),
+                signal: new AbortController().signal,
+                config: descriptor.defaults as WebhookPluginConfig,
+                services,
+            });
+            await descriptor.onInit?.(ctx);
+
+            // Register an endpoint via the service that the plugin
+            // registered in ServiceRegistry.
+            const service = ctx.getService("webhookService") as WebhookService;
+            const endpoint = await service.register({
+                tenantId: null,
+                url: receiver.url,
+                secret: "shared-secret",
+                events: ["webhook.ping"],
+            });
+
+            // Fire via the test route.
+            const res = await app.request(`/webhooks/${endpoint.id}/test`, {
+                method: "POST",
+            });
+            expect(res.status).toBe(200);
+            const body = (await res.json()) as { status: string };
+            expect(body.status).toBe("delivered");
+            expect(receiver.observed).toHaveLength(1);
+            expect(receiver.observed[0]?.event).toBe("webhook.ping");
+        } finally {
+            await receiver.close();
+        }
+    });
+});