@xenterprises/fastify-xstripe 1.0.0

package/test/xStripe.integration.test.js

@@ -0,0 +1,409 @@
+// test/xStripe.integration.test.js
+import { test } from "node:test";
+import assert from "node:assert";
+import crypto from "node:crypto";
+import Fastify from "fastify";
+import xStripe from "../src/index.js";
+
+// Mock Stripe webhook signing key
+const mockWebhookSecret = "whsec_mock_key_12345678901234567890";
+
+// Helper to create a signed webhook
+function createSignedWebhook(payload, secret) {
+  const timestamp = Math.floor(Date.now() / 1000);
+  const signedContent = `${timestamp}.${JSON.stringify(payload)}`;
+  const signature = crypto
+    .createHmac("sha256", secret)
+    .update(signedContent)
+    .digest("base64");
+
+  return {
+    payload,
+    timestamp,
+    signature: `t=${timestamp},v1=${signature}`,
+  };
+}
+
+test("xStripe Plugin Integration", async (t) => {
+  await t.test("registers successfully with valid config", async () => {
+    const fastify = Fastify({ logger: false });
+    const config = {
+      apiKey: "sk_test_mock_api_key",
+      webhookSecret: mockWebhookSecret,
+      webhookPath: "/stripe/webhook",
+    };
+
+    try {
+      await fastify.register(xStripe, config);
+      assert.ok(fastify.stripe !== undefined, "stripe decorator should exist");
+    } finally {
+      try {
+        await fastify.close();
+      } catch {
+        // Ignore
+      }
+    }
+  });
+
+  await t.test("throws error without API key", async () => {
+    const fastify = Fastify({ logger: false });
+    const invalidConfig = {
+      webhookSecret: mockWebhookSecret,
+    };
+
+    try {
+      await assert.rejects(
+        async () => {
+          return fastify.register(xStripe, invalidConfig);
+        },
+        /Stripe API key is required/
+      );
+    } finally {
+      try {
+        await fastify.close();
+      } catch {
+        // Ignore
+      }
+    }
+  });
+
+  await t.test("throws error without webhook secret", async () => {
+    const fastify = Fastify({ logger: false });
+    const invalidConfig = {
+      apiKey: "sk_test_mock_api_key",
+    };
+
+    try {
+      await assert.rejects(
+        async () => {
+          return fastify.register(xStripe, invalidConfig);
+        },
+        /Webhook secret is required/
+      );
+    } finally {
+      try {
+        await fastify.close();
+      } catch {
+        // Ignore
+      }
+    }
+  });
+
+  await t.test("accepts custom webhook path", async () => {
+    const fastify = Fastify({ logger: false });
+    const config = {
+      apiKey: "sk_test_mock_api_key",
+      webhookSecret: mockWebhookSecret,
+      webhookPath: "/custom/stripe/webhook",
+    };
+
+    try {
+      await fastify.register(xStripe, config);
+      assert.ok(true, "should register with custom path");
+    } finally {
+      try {
+        await fastify.close();
+      } catch {
+        // Ignore
+      }
+    }
+  });
+
+  await t.test("webhook endpoint is created", async () => {
+    const fastify = Fastify({ logger: false });
+    const config = {
+      apiKey: "sk_test_mock_api_key",
+      webhookSecret: mockWebhookSecret,
+      webhookPath: "/stripe/webhook",
+    };
+
+    try {
+      await fastify.register(xStripe, config);
+
+      // Try to call the webhook endpoint
+      const mockEvent = {
+        type: "customer.subscription.created",
+        id: "evt_test_123",
+        data: {
+          object: {
+            id: "sub_123",
+            customer: "cus_123",
+            status: "active",
+          },
+        },
+      };
+
+      const signed = createSignedWebhook(mockEvent, mockWebhookSecret);
+
+      const response = await fastify.inject({
+        method: "POST",
+        url: "/stripe/webhook",
+        payload: JSON.stringify(signed.payload),
+        headers: {
+          "stripe-signature": signed.signature,
+          "content-type": "application/json",
+        },
+      });
+
+      // Should return 2xx or 3xx (webhook processed or already processed)
+      assert.ok(
+        response.statusCode >= 200 && response.statusCode < 400,
+        `webhook should be processed (got ${response.statusCode})`
+      );
+    } finally {
+      try {
+        await fastify.close();
+      } catch {
+        // Ignore
+      }
+    }
+  });
+});
+
+test("xStripe Webhook Validation", async (t) => {
+  await t.test("rejects webhook with invalid signature", async () => {
+    const fastify = Fastify({ logger: false });
+    const config = {
+      apiKey: "sk_test_mock_api_key",
+      webhookSecret: mockWebhookSecret,
+      webhookPath: "/stripe/webhook",
+    };
+
+    try {
+      await fastify.register(xStripe, config);
+
+      const mockEvent = {
+        type: "customer.subscription.created",
+        data: {
+          object: {
+            id: "sub_123",
+            customer: "cus_123",
+          },
+        },
+      };
+
+      const response = await fastify.inject({
+        method: "POST",
+        url: "/stripe/webhook",
+        payload: JSON.stringify(mockEvent),
+        headers: {
+          "stripe-signature": "invalid_signature",
+          "content-type": "application/json",
+        },
+      });
+
+      // Should reject invalid signature
+      assert.equal(response.statusCode, 401, "should reject invalid signature");
+    } finally {
+      try {
+        await fastify.close();
+      } catch {
+        // Ignore
+      }
+    }
+  });
+
+  await t.test("requires stripe-signature header", async () => {
+    const fastify = Fastify({ logger: false });
+    const config = {
+      apiKey: "sk_test_mock_api_key",
+      webhookSecret: mockWebhookSecret,
+      webhookPath: "/stripe/webhook",
+    };
+
+    try {
+      await fastify.register(xStripe, config);
+
+      const mockEvent = {
+        type: "customer.subscription.created",
+        data: {
+          object: {
+            id: "sub_123",
+          },
+        },
+      };
+
+      const response = await fastify.inject({
+        method: "POST",
+        url: "/stripe/webhook",
+        payload: JSON.stringify(mockEvent),
+        headers: {
+          "content-type": "application/json",
+          // No stripe-signature header
+        },
+      });
+
+      // Should reject missing signature header
+      assert.equal(response.statusCode, 401, "should require signature header");
+    } finally {
+      try {
+        await fastify.close();
+      } catch {
+        // Ignore
+      }
+    }
+  });
+});
+
+test("xStripe Handler Configuration", async (t) => {
+  await t.test("accepts custom event handlers", async () => {
+    const fastify = Fastify({ logger: false });
+
+    let handlerCalled = false;
+    const customHandler = async (event, fastify) => {
+      handlerCalled = true;
+    };
+
+    const config = {
+      apiKey: "sk_test_mock_api_key",
+      webhookSecret: mockWebhookSecret,
+      webhookPath: "/stripe/webhook",
+      handlers: {
+        "customer.subscription.created": customHandler,
+      },
+    };
+
+    try {
+      await fastify.register(xStripe, config);
+      assert.ok(true, "should register with custom handlers");
+    } finally {
+      try {
+        await fastify.close();
+      } catch {
+        // Ignore
+      }
+    }
+  });
+
+  await t.test("can override default handlers", async () => {
+    const fastify = Fastify({ logger: false });
+    const config = {
+      apiKey: "sk_test_mock_api_key",
+      webhookSecret: mockWebhookSecret,
+      webhookPath: "/stripe/webhook",
+      handlers: {
+        "invoice.payment_succeeded": async (event, fastify) => {
+          // Custom implementation
+        },
+      },
+    };
+
+    try {
+      await fastify.register(xStripe, config);
+      assert.ok(true, "should register with overridden handlers");
+    } finally {
+      try {
+        await fastify.close();
+      } catch {
+        // Ignore
+      }
+    }
+  });
+});
+
+test("xStripe Multiple Instances", async (t) => {
+  await t.test("can register multiple plugin instances", async () => {
+    const fastify1 = Fastify({ logger: false });
+    const fastify2 = Fastify({ logger: false });
+
+    const config = {
+      apiKey: "sk_test_mock_api_key",
+      webhookSecret: mockWebhookSecret,
+      webhookPath: "/stripe/webhook",
+    };
+
+    try {
+      await fastify1.register(xStripe, config);
+      await fastify2.register(xStripe, config);
+
+      assert.ok(fastify1.stripe !== undefined);
+      assert.ok(fastify2.stripe !== undefined);
+    } finally {
+      try {
+        await fastify1.close();
+        await fastify2.close();
+      } catch {
+        // Ignore
+      }
+    }
+  });
+});
+
+test("xStripe Error Handling", async (t) => {
+  await t.test("handles malformed JSON payload gracefully", async () => {
+    const fastify = Fastify({ logger: false });
+    const config = {
+      apiKey: "sk_test_mock_api_key",
+      webhookSecret: mockWebhookSecret,
+      webhookPath: "/stripe/webhook",
+    };
+
+    try {
+      await fastify.register(xStripe, config);
+
+      const signed = createSignedWebhook(
+        { type: "test", data: { object: {} } },
+        mockWebhookSecret
+      );
+
+      const response = await fastify.inject({
+        method: "POST",
+        url: "/stripe/webhook",
+        payload: "not json",
+        headers: {
+          "stripe-signature": signed.signature,
+          "content-type": "application/json",
+        },
+      });
+
+      // Should handle error gracefully
+      assert.ok(response.statusCode >= 400, "should handle error response");
+    } finally {
+      try {
+        await fastify.close();
+      } catch {
+        // Ignore
+      }
+    }
+  });
+
+  await t.test("handles unknown event types", async () => {
+    const fastify = Fastify({ logger: false });
+    const config = {
+      apiKey: "sk_test_mock_api_key",
+      webhookSecret: mockWebhookSecret,
+      webhookPath: "/stripe/webhook",
+    };
+
+    try {
+      await fastify.register(xStripe, config);
+
+      const unknownEvent = {
+        type: "unknown.event.type",
+        id: "evt_test_unknown",
+        data: { object: {} },
+      };
+
+      const signed = createSignedWebhook(unknownEvent, mockWebhookSecret);
+
+      const response = await fastify.inject({
+        method: "POST",
+        url: "/stripe/webhook",
+        payload: JSON.stringify(signed.payload),
+        headers: {
+          "stripe-signature": signed.signature,
+          "content-type": "application/json",
+        },
+      });
+
+      // Should handle unknown events (usually 200 ok, just not processed)
+      assert.ok(response.statusCode >= 200, "should handle unknown event");
+    } finally {
+      try {
+        await fastify.close();
+      } catch {
+        // Ignore
+      }
+    }
+  });
+});