test(billing): add unit tests for webhook service and controller

Cover all webhook event handlers (checkout.session.completed,
subscription.updated, subscription.deleted, invoice.payment_failed)
and controller endpoint to meet global coverage thresholds.

Author: PierreBrisorgueil

modules/billing/tests/billing.controller.unit.tests.js

@@ -0,0 +1,192 @@
+/**
+ * Module dependencies.
+ */
+import { jest, beforeEach, afterEach } from '@jest/globals';
+
+/**
+ * Unit tests for billing webhook controller
+ */
+describe('Billing webhook controller unit tests:', () => {
+  let BillingWebhookController;
+  let mockBillingWebhookService;
+  let mockStripeInstance;
+  let res;
+
+  beforeEach(async () => {
+    jest.resetModules();
+
+    mockBillingWebhookService = {
+      handleCheckoutCompleted: jest.fn().mockResolvedValue(),
+      handleSubscriptionUpdated: jest.fn().mockResolvedValue(),
+      handleSubscriptionDeleted: jest.fn().mockResolvedValue(),
+      handleInvoicePaymentFailed: jest.fn().mockResolvedValue(),
+    };
+
+    jest.unstable_mockModule('../services/billing.webhook.service.js', () => ({
+      default: mockBillingWebhookService,
+    }));
+
+    mockStripeInstance = {
+      webhooks: {
+        constructEvent: jest.fn(),
+      },
+    };
+
+    jest.unstable_mockModule('stripe', () => ({
+      default: jest.fn(() => mockStripeInstance),
+    }));
+
+    res = {
+      status: jest.fn().mockReturnThis(),
+      json: jest.fn().mockReturnThis(),
+    };
+  });
+
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  test('should return 400 when stripe is not configured', async () => {
+    jest.unstable_mockModule('../../../config/index.js', () => ({
+      default: { stripe: {} },
+    }));
+
+    const mod = await import('../controllers/billing.webhook.controller.js');
+    BillingWebhookController = mod.default;
+
+    const req = { headers: {}, body: '' };
+    await BillingWebhookController.handleWebhook(req, res);
+
+    expect(res.status).toHaveBeenCalledWith(400);
+    expect(res.json).toHaveBeenCalledWith({ error: 'Stripe is not configured' });
+  });
+
+  test('should return 400 when signature verification fails', async () => {
+    jest.unstable_mockModule('../../../config/index.js', () => ({
+      default: { stripe: { secretKey: 'sk_test_1', webhookSecret: 'whsec_1' } },
+    }));
+
+    mockStripeInstance.webhooks.constructEvent.mockImplementation(() => {
+      throw new Error('bad signature');
+    });
+
+    const mod = await import('../controllers/billing.webhook.controller.js');
+    BillingWebhookController = mod.default;
+
+    const req = { headers: { 'stripe-signature': 'sig_bad' }, body: 'raw' };
+    await BillingWebhookController.handleWebhook(req, res);
+
+    expect(res.status).toHaveBeenCalledWith(400);
+    expect(res.json).toHaveBeenCalledWith({ error: 'Webhook signature verification failed: bad signature' });
+  });
+
+  test('should handle checkout.session.completed event', async () => {
+    jest.unstable_mockModule('../../../config/index.js', () => ({
+      default: { stripe: { secretKey: 'sk_test_2', webhookSecret: 'whsec_2' } },
+    }));
+
+    const eventData = { type: 'checkout.session.completed', data: { object: { id: 'cs_123' } } };
+    mockStripeInstance.webhooks.constructEvent.mockReturnValue(eventData);
+
+    const mod = await import('../controllers/billing.webhook.controller.js');
+    BillingWebhookController = mod.default;
+
+    const req = { headers: { 'stripe-signature': 'sig_ok' }, body: 'raw' };
+    await BillingWebhookController.handleWebhook(req, res);
+
+    expect(mockBillingWebhookService.handleCheckoutCompleted).toHaveBeenCalledWith({ id: 'cs_123' });
+    expect(res.status).toHaveBeenCalledWith(200);
+    expect(res.json).toHaveBeenCalledWith({ received: true });
+  });
+
+  test('should handle customer.subscription.updated event', async () => {
+    jest.unstable_mockModule('../../../config/index.js', () => ({
+      default: { stripe: { secretKey: 'sk_test_3', webhookSecret: 'whsec_3' } },
+    }));
+
+    const eventData = { type: 'customer.subscription.updated', data: { object: { id: 'sub_123' } } };
+    mockStripeInstance.webhooks.constructEvent.mockReturnValue(eventData);
+
+    const mod = await import('../controllers/billing.webhook.controller.js');
+    BillingWebhookController = mod.default;
+
+    const req = { headers: { 'stripe-signature': 'sig_ok' }, body: 'raw' };
+    await BillingWebhookController.handleWebhook(req, res);
+
+    expect(mockBillingWebhookService.handleSubscriptionUpdated).toHaveBeenCalledWith({ id: 'sub_123' });
+    expect(res.status).toHaveBeenCalledWith(200);
+  });
+
+  test('should handle customer.subscription.deleted event', async () => {
+    jest.unstable_mockModule('../../../config/index.js', () => ({
+      default: { stripe: { secretKey: 'sk_test_4', webhookSecret: 'whsec_4' } },
+    }));
+
+    const eventData = { type: 'customer.subscription.deleted', data: { object: { id: 'sub_del' } } };
+    mockStripeInstance.webhooks.constructEvent.mockReturnValue(eventData);
+
+    const mod = await import('../controllers/billing.webhook.controller.js');
+    BillingWebhookController = mod.default;
+
+    const req = { headers: { 'stripe-signature': 'sig_ok' }, body: 'raw' };
+    await BillingWebhookController.handleWebhook(req, res);
+
+    expect(mockBillingWebhookService.handleSubscriptionDeleted).toHaveBeenCalledWith({ id: 'sub_del' });
+    expect(res.status).toHaveBeenCalledWith(200);
+  });
+
+  test('should handle invoice.payment_failed event', async () => {
+    jest.unstable_mockModule('../../../config/index.js', () => ({
+      default: { stripe: { secretKey: 'sk_test_5', webhookSecret: 'whsec_5' } },
+    }));
+
+    const eventData = { type: 'invoice.payment_failed', data: { object: { id: 'inv_fail' } } };
+    mockStripeInstance.webhooks.constructEvent.mockReturnValue(eventData);
+
+    const mod = await import('../controllers/billing.webhook.controller.js');
+    BillingWebhookController = mod.default;
+
+    const req = { headers: { 'stripe-signature': 'sig_ok' }, body: 'raw' };
+    await BillingWebhookController.handleWebhook(req, res);
+
+    expect(mockBillingWebhookService.handleInvoicePaymentFailed).toHaveBeenCalledWith({ id: 'inv_fail' });
+    expect(res.status).toHaveBeenCalledWith(200);
+  });
+
+  test('should return 200 for unknown event types', async () => {
+    jest.unstable_mockModule('../../../config/index.js', () => ({
+      default: { stripe: { secretKey: 'sk_test_6', webhookSecret: 'whsec_6' } },
+    }));
+
+    const eventData = { type: 'unknown.event', data: { object: {} } };
+    mockStripeInstance.webhooks.constructEvent.mockReturnValue(eventData);
+
+    const mod = await import('../controllers/billing.webhook.controller.js');
+    BillingWebhookController = mod.default;
+
+    const req = { headers: { 'stripe-signature': 'sig_ok' }, body: 'raw' };
+    await BillingWebhookController.handleWebhook(req, res);
+
+    expect(res.status).toHaveBeenCalledWith(200);
+    expect(res.json).toHaveBeenCalledWith({ received: true });
+  });
+
+  test('should return 500 when handler throws', async () => {
+    jest.unstable_mockModule('../../../config/index.js', () => ({
+      default: { stripe: { secretKey: 'sk_test_7', webhookSecret: 'whsec_7' } },
+    }));
+
+    const eventData = { type: 'checkout.session.completed', data: { object: { id: 'cs_err' } } };
+    mockStripeInstance.webhooks.constructEvent.mockReturnValue(eventData);
+    mockBillingWebhookService.handleCheckoutCompleted.mockRejectedValue(new Error('DB error'));
+
+    const mod = await import('../controllers/billing.webhook.controller.js');
+    BillingWebhookController = mod.default;
+
+    const req = { headers: { 'stripe-signature': 'sig_ok' }, body: 'raw' };
+    await BillingWebhookController.handleWebhook(req, res);
+
+    expect(res.status).toHaveBeenCalledWith(500);
+    expect(res.json).toHaveBeenCalledWith({ error: 'Webhook handler failed' });
+  });
+});