backend-manager 5.9.6 → 5.9.8

package/test/helpers/payment/chargebee/parse-webhook.js

@@ -0,0 +1,413 @@
+/**
+ * Test: Chargebee parseWebhook()
+ * Unit tests for the Chargebee webhook processor's event categorization and routing
+ *
+ * Verifies that parseWebhook() correctly determines category, resourceType, resourceId,
+ * and uid for each supported event type.
+ */
+const chargebeeProcessor = require('../../../../src/manager/routes/payments/webhook/processors/chargebee.js');
+
+// Chargebee webhook fixtures
+const FIXTURE_SUB_CREATED = require('../../../fixtures/chargebee/webhook-subscription-created.json');
+const FIXTURE_PAYMENT_FAILED = require('../../../fixtures/chargebee/webhook-payment-failed.json');
+
+function parseWebhook(event) {
+  return chargebeeProcessor.parseWebhook({ body: event });
+}
+
+module.exports = {
+  description: 'Chargebee parseWebhook() event categorization',
+  type: 'group',
+
+  tests: [
+    // ─── isSupported() ───
+
+    {
+      name: 'supports-subscription-created',
+      async run({ assert }) {
+        assert.ok(chargebeeProcessor.isSupported('subscription_created'), 'Should support subscription_created');
+      },
+    },
+
+    {
+      name: 'supports-subscription-cancelled',
+      async run({ assert }) {
+        assert.ok(chargebeeProcessor.isSupported('subscription_cancelled'), 'Should support subscription_cancelled');
+      },
+    },
+
+    {
+      name: 'supports-subscription-activated',
+      async run({ assert }) {
+        assert.ok(chargebeeProcessor.isSupported('subscription_activated'), 'Should support subscription_activated');
+      },
+    },
+
+    {
+      name: 'supports-subscription-changed',
+      async run({ assert }) {
+        assert.ok(chargebeeProcessor.isSupported('subscription_changed'), 'Should support subscription_changed');
+      },
+    },
+
+    {
+      name: 'supports-subscription-renewed',
+      async run({ assert }) {
+        assert.ok(chargebeeProcessor.isSupported('subscription_renewed'), 'Should support subscription_renewed');
+      },
+    },
+
+    {
+      name: 'supports-subscription-reactivated',
+      async run({ assert }) {
+        assert.ok(chargebeeProcessor.isSupported('subscription_reactivated'), 'Should support subscription_reactivated');
+      },
+    },
+
+    {
+      name: 'supports-cancellation-scheduled',
+      async run({ assert }) {
+        assert.ok(chargebeeProcessor.isSupported('subscription_cancellation_scheduled'), 'Should support subscription_cancellation_scheduled');
+      },
+    },
+
+    {
+      name: 'supports-cancellation-removed',
+      async run({ assert }) {
+        assert.ok(chargebeeProcessor.isSupported('subscription_scheduled_cancellation_removed'), 'Should support scheduled_cancellation_removed');
+      },
+    },
+
+    {
+      name: 'supports-payment-failed',
+      async run({ assert }) {
+        assert.ok(chargebeeProcessor.isSupported('payment_failed'), 'Should support payment_failed');
+      },
+    },
+
+    {
+      name: 'supports-payment-refunded',
+      async run({ assert }) {
+        assert.ok(chargebeeProcessor.isSupported('payment_refunded'), 'Should support payment_refunded');
+      },
+    },
+
+    {
+      name: 'supports-invoice-generated',
+      async run({ assert }) {
+        assert.ok(chargebeeProcessor.isSupported('invoice_generated'), 'Should support invoice_generated');
+      },
+    },
+
+    {
+      name: 'rejects-unsupported-event',
+      async run({ assert }) {
+        assert.equal(chargebeeProcessor.isSupported('customer_created'), false, 'Should not support customer_created');
+        assert.equal(chargebeeProcessor.isSupported('coupon_created'), false, 'Should not support coupon_created');
+        assert.equal(chargebeeProcessor.isSupported('subscription_deleted'), false, 'Should not support subscription_deleted');
+      },
+    },
+
+    // ─── Validation ───
+
+    {
+      name: 'throws-on-empty-body',
+      async run({ assert }) {
+        try {
+          parseWebhook(null);
+          assert.fail('Should have thrown');
+        } catch (e) {
+          assert.match(e.message, /Invalid/, 'Should mention invalid payload');
+        }
+      },
+    },
+
+    {
+      name: 'throws-on-missing-id',
+      async run({ assert }) {
+        try {
+          parseWebhook({ event_type: 'subscription_created', content: {} });
+          assert.fail('Should have thrown');
+        } catch (e) {
+          assert.match(e.message, /Invalid/, 'Should mention invalid payload');
+        }
+      },
+    },
+
+    {
+      name: 'throws-on-missing-event-type',
+      async run({ assert }) {
+        try {
+          parseWebhook({ id: 'ev_123', content: {} });
+          assert.fail('Should have thrown');
+        } catch (e) {
+          assert.match(e.message, /Invalid/, 'Should mention invalid payload');
+        }
+      },
+    },
+
+    // ─── Subscription events ───
+
+    {
+      name: 'subscription-created-category',
+      async run({ assert }) {
+        const result = parseWebhook({
+          id: 'ev_sub_created',
+          event_type: 'subscription_created',
+          content: {
+            subscription: {
+              id: 'sub_123',
+              meta_data: '{"uid":"user-abc"}',
+            },
+            customer: { id: 'cust_123' },
+          },
+        });
+
+        assert.equal(result.category, 'subscription', 'Category should be subscription');
+        assert.equal(result.resourceType, 'subscription', 'Resource type should be subscription');
+        assert.equal(result.resourceId, 'sub_123', 'Resource ID should be subscription ID');
+        assert.equal(result.uid, 'user-abc', 'UID should come from meta_data');
+        assert.equal(result.eventId, 'ev_sub_created', 'Event ID should match');
+        assert.equal(result.eventType, 'subscription_created', 'Event type should match');
+      },
+    },
+
+    {
+      name: 'subscription-cancelled-category',
+      async run({ assert }) {
+        const result = parseWebhook({
+          id: 'ev_sub_cancelled',
+          event_type: 'subscription_cancelled',
+          content: {
+            subscription: {
+              id: 'sub_456',
+              meta_data: '{"uid":"user-def"}',
+            },
+          },
+        });
+
+        assert.equal(result.category, 'subscription', 'Category should be subscription');
+        assert.equal(result.resourceId, 'sub_456', 'Resource ID should match');
+        assert.equal(result.uid, 'user-def', 'UID should match');
+      },
+    },
+
+    {
+      name: 'subscription-cancellation-scheduled-category',
+      async run({ assert }) {
+        const result = parseWebhook({
+          id: 'ev_cancel_scheduled',
+          event_type: 'subscription_cancellation_scheduled',
+          content: {
+            subscription: {
+              id: 'sub_789',
+              meta_data: '{"uid":"user-ghi"}',
+              status: 'non_renewing',
+            },
+          },
+        });
+
+        assert.equal(result.category, 'subscription', 'Category should be subscription');
+        assert.equal(result.uid, 'user-ghi', 'UID should match');
+      },
+    },
+
+    {
+      name: 'subscription-event-uid-from-legacy-cf',
+      async run({ assert }) {
+        const result = parseWebhook({
+          id: 'ev_legacy_uid',
+          event_type: 'subscription_renewed',
+          content: {
+            subscription: {
+              id: 'sub_legacy',
+              cf_uid: 'legacy-user-123',
+            },
+          },
+        });
+
+        assert.equal(result.uid, 'legacy-user-123', 'UID should fall back to cf_uid');
+      },
+    },
+
+    {
+      name: 'subscription-event-null-uid-when-missing',
+      async run({ assert }) {
+        const result = parseWebhook({
+          id: 'ev_no_uid',
+          event_type: 'subscription_created',
+          content: {
+            subscription: { id: 'sub_no_uid' },
+          },
+        });
+
+        assert.equal(result.uid, null, 'UID should be null when not available');
+        assert.equal(result.category, 'subscription', 'Category should still be subscription');
+      },
+    },
+
+    // ─── payment_failed ───
+
+    {
+      name: 'payment-failed-subscription-category',
+      async run({ assert }) {
+        const result = parseWebhook({
+          id: 'ev_pay_fail',
+          event_type: 'payment_failed',
+          content: {
+            subscription: {
+              id: 'sub_fail',
+              meta_data: '{"uid":"user-fail"}',
+            },
+            invoice: { id: 'inv_fail', subscription_id: 'sub_fail' },
+          },
+        });
+
+        assert.equal(result.category, 'subscription', 'With subscription → subscription category');
+        assert.equal(result.resourceType, 'subscription', 'Should fetch subscription');
+        assert.equal(result.resourceId, 'sub_fail', 'Resource ID should be subscription ID');
+        assert.equal(result.uid, 'user-fail', 'UID from subscription');
+      },
+    },
+
+    {
+      name: 'payment-failed-one-time-category',
+      async run({ assert }) {
+        const result = parseWebhook({
+          id: 'ev_pay_fail_onetime',
+          event_type: 'payment_failed',
+          content: {
+            invoice: { id: 'inv_onetime_fail' },
+            customer: { id: 'cust_onetime' },
+          },
+        });
+
+        assert.equal(result.category, 'one-time', 'No subscription → one-time');
+        assert.equal(result.resourceType, 'invoice', 'Should fetch invoice');
+        assert.equal(result.resourceId, 'inv_onetime_fail', 'Resource ID should be invoice ID');
+      },
+    },
+
+    // ─── payment_refunded ───
+
+    {
+      name: 'payment-refunded-subscription-category',
+      async run({ assert }) {
+        const result = parseWebhook({
+          id: 'ev_refund',
+          event_type: 'payment_refunded',
+          content: {
+            subscription: {
+              id: 'sub_refund',
+              meta_data: '{"uid":"user-refund"}',
+            },
+          },
+        });
+
+        assert.equal(result.category, 'subscription', 'With subscription → subscription');
+        assert.equal(result.resourceId, 'sub_refund', 'Resource ID should be subscription');
+        assert.equal(result.uid, 'user-refund', 'UID from subscription');
+      },
+    },
+
+    {
+      name: 'payment-refunded-no-subscription-skipped',
+      async run({ assert }) {
+        const result = parseWebhook({
+          id: 'ev_refund_no_sub',
+          event_type: 'payment_refunded',
+          content: {
+            transaction: { id: 'txn_refund' },
+          },
+        });
+
+        assert.equal(result.category, null, 'No subscription → null (skipped)');
+      },
+    },
+
+    // ─── invoice_generated ───
+
+    {
+      name: 'invoice-generated-non-recurring-one-time',
+      async run({ assert }) {
+        const result = parseWebhook({
+          id: 'ev_inv_gen',
+          event_type: 'invoice_generated',
+          content: {
+            invoice: { id: 'inv_onetime_001' },
+            customer: { id: 'cust_onetime' },
+          },
+        });
+
+        assert.equal(result.category, 'one-time', 'Non-recurring invoice → one-time');
+        assert.equal(result.resourceType, 'invoice', 'Should fetch invoice');
+        assert.equal(result.resourceId, 'inv_onetime_001', 'Resource ID should be invoice ID');
+      },
+    },
+
+    {
+      name: 'invoice-generated-recurring-skipped',
+      async run({ assert }) {
+        const result = parseWebhook({
+          id: 'ev_inv_recurring',
+          event_type: 'invoice_generated',
+          content: {
+            invoice: { id: 'inv_recurring', subscription_id: 'sub_existing' },
+          },
+        });
+
+        assert.equal(result.category, null, 'Recurring invoice → null (skipped)');
+      },
+    },
+
+    // ─── Fixture tests ───
+
+    {
+      name: 'fixture-subscription-created',
+      async run({ assert }) {
+        const result = parseWebhook(FIXTURE_SUB_CREATED);
+
+        assert.equal(result.eventId, FIXTURE_SUB_CREATED.id, 'Event ID matches fixture');
+        assert.equal(result.eventType, 'subscription_created', 'Event type matches');
+        assert.equal(result.category, 'subscription', 'Category is subscription');
+        assert.equal(result.resourceType, 'subscription', 'Resource type is subscription');
+        assert.equal(result.resourceId, 'cb_sub_active_001', 'Resource ID from content.subscription.id');
+        assert.equal(result.uid, 'test-uid-001', 'UID from meta_data');
+      },
+    },
+
+    {
+      name: 'fixture-payment-failed',
+      async run({ assert }) {
+        const result = parseWebhook(FIXTURE_PAYMENT_FAILED);
+
+        assert.equal(result.eventId, FIXTURE_PAYMENT_FAILED.id, 'Event ID matches fixture');
+        assert.equal(result.eventType, 'payment_failed', 'Event type matches');
+        assert.equal(result.category, 'subscription', 'Category is subscription (has subscription)');
+        assert.equal(result.resourceType, 'subscription', 'Resource type is subscription');
+        assert.equal(result.resourceId, 'cb_sub_active_001', 'Resource ID from content.subscription.id');
+        assert.equal(result.uid, 'test-uid-001', 'UID from subscription meta_data');
+      },
+    },
+
+    // ─── raw passthrough ───
+
+    {
+      name: 'raw-contains-full-event',
+      async run({ assert }) {
+        const event = {
+          id: 'ev_raw',
+          event_type: 'subscription_changed',
+          content: {
+            subscription: { id: 'sub_raw', meta_data: '{"uid":"user-raw"}' },
+          },
+          extra_field: 'preserved',
+        };
+
+        const result = parseWebhook(event);
+        assert.equal(result.raw, event, 'Raw should be the full event object');
+        assert.equal(result.raw.extra_field, 'preserved', 'Extra fields preserved in raw');
+      },
+    },
+  ],
+};

package/test/helpers/payment/chargebee/to-unified-one-time.js

@@ -0,0 +1,147 @@
+/**
+ * Test: Chargebee toUnifiedOneTime()
+ * Unit tests for the Chargebee library's invoice → unified one-time transformation
+ */
+const Chargebee = require('../../../../src/manager/libraries/payment/processors/chargebee.js');
+
+const FIXTURE_INVOICE = require('../../../fixtures/chargebee/invoice-one-time.json');
+
+const MOCK_CONFIG = {
+  payment: {
+    products: [
+      { id: 'basic', name: 'Basic', type: 'subscription' },
+      {
+        id: 'credits-100', name: '100 Credits', type: 'one-time',
+        prices: { once: 9.99 },
+      },
+    ],
+  },
+};
+
+function toUnifiedOneTime(rawResource, options) {
+  return Chargebee.toUnifiedOneTime(rawResource, { config: MOCK_CONFIG, ...options });
+}
+
+module.exports = {
+  description: 'Chargebee toUnifiedOneTime() transformation',
+  type: 'group',
+
+  tests: [
+    {
+      name: 'status-paid-to-completed',
+      async run({ assert }) {
+        const result = toUnifiedOneTime({ status: 'paid' });
+        assert.equal(result.status, 'completed', 'paid → completed');
+      },
+    },
+
+    {
+      name: 'status-not-paid-to-failed',
+      async run({ assert }) {
+        const result = toUnifiedOneTime({ status: 'not_paid' });
+        assert.equal(result.status, 'failed', 'not_paid → failed');
+      },
+    },
+
+    {
+      name: 'status-payment-due-to-failed',
+      async run({ assert }) {
+        const result = toUnifiedOneTime({ status: 'payment_due' });
+        assert.equal(result.status, 'failed', 'payment_due → failed');
+      },
+    },
+
+    {
+      name: 'status-unknown-passthrough',
+      async run({ assert }) {
+        const result = toUnifiedOneTime({ status: 'pending' });
+        assert.equal(result.status, 'pending', 'Other statuses pass through');
+      },
+    },
+
+    {
+      name: 'processor-always-chargebee',
+      async run({ assert }) {
+        const result = toUnifiedOneTime({});
+        assert.equal(result.payment.processor, 'chargebee', 'Processor should be chargebee');
+      },
+    },
+
+    {
+      name: 'resource-id-from-invoice-id',
+      async run({ assert }) {
+        const result = toUnifiedOneTime({ id: 'inv_123' });
+        assert.equal(result.payment.resourceId, 'inv_123', 'resourceId from invoice id');
+      },
+    },
+
+    {
+      name: 'order-id-from-meta-data',
+      async run({ assert }) {
+        const result = toUnifiedOneTime({ meta_data: '{"orderId":"1234-5678-9012"}' });
+        assert.equal(result.payment.orderId, '1234-5678-9012', 'orderId from meta_data');
+      },
+    },
+
+    {
+      name: 'order-id-from-cf-legacy',
+      async run({ assert }) {
+        const result = toUnifiedOneTime({ cf_clientorderid: 'legacy-order' });
+        assert.equal(result.payment.orderId, 'legacy-order', 'orderId from cf_clientorderid');
+      },
+    },
+
+    {
+      name: 'product-resolves-from-meta-data',
+      async run({ assert }) {
+        const result = toUnifiedOneTime({
+          meta_data: '{"productId":"credits-100"}',
+          status: 'paid',
+        });
+        assert.equal(result.product.id, 'credits-100', 'Product resolved from meta_data');
+        assert.equal(result.product.name, '100 Credits', 'Product name resolved');
+      },
+    },
+
+    {
+      name: 'product-unknown-when-no-meta-data',
+      async run({ assert }) {
+        const result = toUnifiedOneTime({});
+        assert.equal(result.product.id, 'unknown', 'No productId → unknown');
+      },
+    },
+
+    {
+      name: 'event-metadata-passed-through',
+      async run({ assert }) {
+        const result = toUnifiedOneTime({}, { eventName: 'invoice_generated', eventId: 'ev_inv' });
+        assert.equal(result.payment.updatedBy.event.name, 'invoice_generated', 'Event name');
+        assert.equal(result.payment.updatedBy.event.id, 'ev_inv', 'Event ID');
+      },
+    },
+
+    {
+      name: 'fixture-invoice-one-time',
+      async run({ assert }) {
+        const result = toUnifiedOneTime(FIXTURE_INVOICE);
+        assert.equal(result.status, 'completed', 'Fixture paid → completed');
+        assert.equal(result.payment.processor, 'chargebee', 'Processor is chargebee');
+        assert.equal(result.payment.resourceId, FIXTURE_INVOICE.id, 'Resource ID matches fixture');
+        assert.equal(result.payment.orderId, '6789-0123-4567', 'Order ID from meta_data');
+        assert.equal(result.product.id, 'credits-100', 'Product from meta_data productId');
+      },
+    },
+
+    {
+      name: 'unified-shape-complete',
+      async run({ assert }) {
+        const result = toUnifiedOneTime(FIXTURE_INVOICE);
+        assert.ok(result.product, 'Should have product');
+        assert.ok(result.status, 'Should have status');
+        assert.ok(result.payment, 'Should have payment');
+        assert.ok(result.payment.updatedBy, 'Should have updatedBy');
+        assert.ok(result.payment.updatedBy.date, 'Should have updatedBy.date');
+      },
+    },
+  ],
+};