backend-manager 5.0.103 → 5.0.105

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

@@ -0,0 +1,382 @@
+/**
+ * Test: PayPal toUnifiedOneTime()
+ * Unit tests for the PayPal library's raw resource → unified one-time payment transformation
+ *
+ * Tests the pure function directly — no emulator, no Firestore, no HTTP
+ * Mirrors stripe/to-unified-one-time.js for consistent coverage
+ */
+const PayPal = require('../../../../src/manager/libraries/payment/processors/paypal.js');
+
+// Real PayPal sandbox fixtures
+const FIXTURE_ORDER_APPROVED = require('../../../fixtures/paypal/order-approved.json');
+const FIXTURE_ORDER_COMPLETED = require('../../../fixtures/paypal/order-completed.json');
+
+// Mock config matching the BEM template (new flat price structure)
+const MOCK_CONFIG = {
+  payment: {
+    products: [
+      { id: 'basic', name: 'Basic', type: 'subscription', limits: { requests: 100 } },
+      {
+        id: 'credits-100', name: '100 Credits', type: 'one-time',
+        prices: { once: 9.99 },
+        paypal: { productId: 'PROD-credits-100' },
+      },
+      {
+        id: 'credits-500', name: '500 Credits', type: 'one-time',
+        prices: { once: 39.99 },
+        paypal: { productId: 'PROD-credits-500' },
+      },
+    ],
+  },
+};
+
+function toUnifiedOneTime(rawResource, options) {
+  return PayPal.toUnifiedOneTime(rawResource, { config: MOCK_CONFIG, ...options });
+}
+
+module.exports = {
+  description: 'PayPal toUnifiedOneTime() transformation',
+  type: 'group',
+
+  tests: [
+    // ─── Status mapping ───
+
+    {
+      name: 'status-completed',
+      async run({ assert }) {
+        const result = toUnifiedOneTime({ status: 'COMPLETED' });
+        assert.equal(result.status, 'complete', 'PayPal COMPLETED → unified complete');
+      },
+    },
+
+    {
+      name: 'status-created-lowercased',
+      async run({ assert }) {
+        const result = toUnifiedOneTime({ status: 'CREATED' });
+        assert.equal(result.status, 'created', 'PayPal CREATED → lowercase created');
+      },
+    },
+
+    {
+      name: 'status-approved-lowercased',
+      async run({ assert }) {
+        const result = toUnifiedOneTime({ status: 'APPROVED' });
+        assert.equal(result.status, 'approved', 'PayPal APPROVED → lowercase approved');
+      },
+    },
+
+    {
+      name: 'status-voided-lowercased',
+      async run({ assert }) {
+        const result = toUnifiedOneTime({ status: 'VOIDED' });
+        assert.equal(result.status, 'voided', 'PayPal VOIDED → lowercase voided');
+      },
+    },
+
+    {
+      name: 'status-unknown-when-missing',
+      async run({ assert }) {
+        const result = toUnifiedOneTime({});
+        assert.equal(result.status, 'unknown', 'Missing status → unknown');
+      },
+    },
+
+    // ─── Product resolution ───
+
+    {
+      name: 'product-resolves-from-custom-id-product-id',
+      async run({ assert }) {
+        const result = toUnifiedOneTime({ custom_id: 'uid:user1,orderId:ord1,productId:credits-100' });
+        assert.equal(result.product.id, 'credits-100', 'Should resolve from custom_id productId');
+        assert.equal(result.product.name, '100 Credits', 'Should have correct name');
+      },
+    },
+
+    {
+      name: 'product-resolves-second-product',
+      async run({ assert }) {
+        const result = toUnifiedOneTime({ custom_id: 'uid:user1,productId:credits-500' });
+        assert.equal(result.product.id, 'credits-500', 'Should resolve credits-500');
+        assert.equal(result.product.name, '500 Credits', 'Should have correct name');
+      },
+    },
+
+    {
+      name: 'product-resolves-from-purchase-units-structured',
+      async run({ assert }) {
+        const result = toUnifiedOneTime({
+          purchase_units: [{ custom_id: 'uid:user1,orderId:ord1,productId:credits-100' }],
+        });
+        assert.equal(result.product.id, 'credits-100', 'Should resolve from purchase_units structured custom_id');
+        assert.equal(result.product.name, '100 Credits', 'Should have correct name');
+      },
+    },
+
+    {
+      name: 'product-purchase-units-takes-priority-over-top-level',
+      async run({ assert }) {
+        const result = toUnifiedOneTime({
+          custom_id: 'productId:credits-500',
+          purchase_units: [{ custom_id: 'uid:user1,productId:credits-100' }],
+        });
+        assert.equal(result.product.id, 'credits-100', 'purchase_units custom_id takes priority over top-level');
+      },
+    },
+
+    {
+      name: 'product-falls-back-to-unknown-on-missing-metadata',
+      async run({ assert }) {
+        const result = toUnifiedOneTime({});
+        assert.equal(result.product.id, 'unknown', 'No metadata → unknown');
+        assert.equal(result.product.name, 'Unknown', 'No metadata → Unknown name');
+      },
+    },
+
+    {
+      name: 'product-falls-back-to-product-id-on-unknown-product',
+      async run({ assert }) {
+        const result = toUnifiedOneTime({ custom_id: 'productId:nonexistent-product' });
+        assert.equal(result.product.id, 'nonexistent-product', 'Unknown product → uses ID as-is');
+        assert.equal(result.product.name, 'nonexistent-product', 'Unknown product → ID as name');
+      },
+    },
+
+    {
+      name: 'product-without-config',
+      async run({ assert }) {
+        const result = PayPal.toUnifiedOneTime({ custom_id: 'productId:credits-100' }, {});
+        assert.equal(result.product.id, 'credits-100', 'Without config → uses productId');
+        assert.equal(result.product.name, 'Unknown', 'Without config → Unknown name');
+      },
+    },
+
+    // ─── Payment metadata ───
+
+    {
+      name: 'payment-processor-always-paypal',
+      async run({ assert }) {
+        const result = toUnifiedOneTime({});
+        assert.equal(result.payment.processor, 'paypal', 'Processor should always be paypal');
+      },
+    },
+
+    {
+      name: 'payment-resource-id-from-resource-id',
+      async run({ assert }) {
+        const result = toUnifiedOneTime({ id: 'PAYID-ABC123' });
+        assert.equal(result.payment.resourceId, 'PAYID-ABC123', 'resourceId should be PayPal resource ID');
+      },
+    },
+
+    {
+      name: 'payment-resource-id-null-when-missing',
+      async run({ assert }) {
+        const result = toUnifiedOneTime({});
+        assert.equal(result.payment.resourceId, null, 'Missing ID → null resourceId');
+      },
+    },
+
+    {
+      name: 'payment-order-id-from-custom-id',
+      async run({ assert }) {
+        const result = toUnifiedOneTime({ custom_id: 'uid:user1,orderId:1234-5678-9012' });
+        assert.equal(result.payment.orderId, '1234-5678-9012', 'orderId should come from custom_id');
+      },
+    },
+
+    {
+      name: 'payment-order-id-null-when-missing',
+      async run({ assert }) {
+        const result = toUnifiedOneTime({});
+        assert.equal(result.payment.orderId, null, 'Missing custom_id → null orderId');
+      },
+    },
+
+    {
+      name: 'payment-price-resolves-from-config',
+      async run({ assert }) {
+        const result = toUnifiedOneTime({ custom_id: 'productId:credits-100' });
+        assert.equal(result.payment.price, 9.99, 'Should resolve price from config');
+      },
+    },
+
+    {
+      name: 'payment-price-zero-on-unknown-product',
+      async run({ assert }) {
+        const result = toUnifiedOneTime({ custom_id: 'productId:nonexistent' });
+        assert.equal(result.payment.price, 0, 'Unknown product → price 0');
+      },
+    },
+
+    {
+      name: 'payment-price-zero-when-no-metadata',
+      async run({ assert }) {
+        const result = toUnifiedOneTime({});
+        assert.equal(result.payment.price, 0, 'No metadata → price 0');
+      },
+    },
+
+    {
+      name: 'payment-event-metadata-passed-through',
+      async run({ assert }) {
+        const result = toUnifiedOneTime({}, { eventName: 'CHECKOUT.ORDER.APPROVED', eventId: 'WH-123' });
+        assert.equal(result.payment.updatedBy.event.name, 'CHECKOUT.ORDER.APPROVED', 'Event name passed through');
+        assert.equal(result.payment.updatedBy.event.id, 'WH-123', 'Event ID passed through');
+      },
+    },
+
+    {
+      name: 'payment-event-metadata-null-when-missing',
+      async run({ assert }) {
+        const result = toUnifiedOneTime({});
+        assert.equal(result.payment.updatedBy.event.name, null, 'Missing event name → null');
+        assert.equal(result.payment.updatedBy.event.id, null, 'Missing event ID → null');
+      },
+    },
+
+    // ─── Full unified shape ───
+
+    {
+      name: 'full-completed-shape',
+      async run({ assert }) {
+        const result = toUnifiedOneTime({
+          id: 'PAYID-FULL',
+          status: 'COMPLETED',
+          custom_id: 'uid:user1,orderId:1234-5678-9012,productId:credits-100',
+        }, { eventName: 'CHECKOUT.ORDER.APPROVED', eventId: 'WH-FULL' });
+
+        assert.ok(result.product, 'Should have product');
+        assert.ok(result.status, 'Should have status');
+        assert.ok(result.payment, 'Should have payment');
+
+        assert.equal(result.product.id, 'credits-100', 'Product should be credits-100');
+        assert.equal(result.status, 'complete', 'Status should be complete');
+        assert.equal(result.payment.processor, 'paypal', 'Processor should be paypal');
+        assert.equal(result.payment.resourceId, 'PAYID-FULL', 'Resource ID should match');
+        assert.equal(result.payment.orderId, '1234-5678-9012', 'orderId should match');
+        assert.equal(result.payment.price, 9.99, 'Price should be resolved');
+        assert.equal(result.payment.updatedBy.event.name, 'CHECKOUT.ORDER.APPROVED', 'Event name should match');
+      },
+    },
+
+    {
+      name: 'empty-input-gets-safe-defaults',
+      async run({ assert }) {
+        const result = toUnifiedOneTime({});
+
+        assert.equal(result.product.id, 'unknown', 'Empty → unknown product');
+        assert.equal(result.status, 'unknown', 'Empty → unknown status');
+        assert.equal(result.payment.processor, 'paypal', 'Empty → still paypal');
+        assert.equal(result.payment.orderId, null, 'Empty → null orderId');
+        assert.equal(result.payment.resourceId, null, 'Empty → null resourceId');
+        assert.equal(result.payment.price, 0, 'Empty → price 0');
+      },
+    },
+
+    {
+      name: 'no-expires-or-trial-on-one-time',
+      async run({ assert }) {
+        const result = toUnifiedOneTime({ id: 'PAYID-SHAPE' });
+        // One-time payments do not have subscription-specific fields
+        assert.equal(result.expires, undefined, 'No expires on one-time');
+        assert.equal(result.trial, undefined, 'No trial on one-time');
+        assert.equal(result.cancellation, undefined, 'No cancellation on one-time');
+      },
+    },
+
+    // ─── Custom ID parsing edge cases ───
+
+    {
+      name: 'custom-id-with-colon-in-values',
+      async run({ assert }) {
+        const result = toUnifiedOneTime({
+          custom_id: 'uid:firebase:auth:user123,orderId:ord-c,productId:credits-100',
+        });
+        assert.equal(result.payment.orderId, 'ord-c', 'orderId parsed correctly');
+        assert.equal(result.product.id, 'credits-100', 'productId parsed correctly');
+      },
+    },
+
+    {
+      name: 'custom-id-product-id-only',
+      async run({ assert }) {
+        const result = toUnifiedOneTime({
+          custom_id: 'productId:credits-500',
+        });
+        assert.equal(result.product.id, 'credits-500', 'Should parse productId without uid/orderId');
+        assert.equal(result.payment.orderId, null, 'No orderId → null');
+      },
+    },
+
+    {
+      name: 'custom-id-empty-string',
+      async run({ assert }) {
+        const result = toUnifiedOneTime({ custom_id: '' });
+        assert.equal(result.product.id, 'unknown', 'Empty custom_id → unknown product');
+        assert.equal(result.payment.orderId, null, 'Empty custom_id → null orderId');
+      },
+    },
+
+    // ─── updatedBy.date shape ───
+
+    {
+      name: 'updated-by-date-has-both-formats',
+      async run({ assert }) {
+        const result = toUnifiedOneTime({});
+        assert.ok(result.payment.updatedBy.date, 'Should have updatedBy.date');
+        assert.isType(result.payment.updatedBy.date.timestamp, 'string', 'timestamp should be string');
+        assert.isType(result.payment.updatedBy.date.timestampUNIX, 'number', 'timestampUNIX should be number');
+      },
+    },
+
+    // ─── Real PayPal sandbox fixtures ───
+
+    {
+      name: 'fixture-order-completed-produces-valid-shape',
+      async run({ assert }) {
+        const result = toUnifiedOneTime(FIXTURE_ORDER_COMPLETED);
+
+        assert.equal(result.status, 'complete', 'COMPLETED fixture → complete');
+        assert.equal(result.payment.processor, 'paypal', 'Processor is paypal');
+        assert.equal(result.payment.resourceId, '5UX02069M9686893E', 'Resource ID from fixture');
+        assert.equal(result.payment.orderId, 'ord-test-456', 'orderId from purchase_units custom_id');
+        assert.equal(result.product.id, 'credits-100', 'Product resolved from purchase_units custom_id');
+        assert.equal(result.product.name, '100 Credits', 'Product name from config');
+        assert.equal(result.payment.price, 9.99, 'Price from config');
+      },
+    },
+
+    {
+      name: 'fixture-order-approved-produces-valid-shape',
+      async run({ assert }) {
+        const result = toUnifiedOneTime(FIXTURE_ORDER_APPROVED);
+
+        assert.equal(result.status, 'approved', 'APPROVED fixture → approved');
+        assert.equal(result.payment.resourceId, '5UX02069M9686893E', 'Resource ID from fixture');
+        assert.equal(result.product.id, 'credits-100', 'Product resolved from purchase_units custom_id');
+        assert.equal(result.payment.orderId, 'ord-test-456', 'orderId from purchase_units custom_id');
+      },
+    },
+
+    {
+      name: 'fixture-all-orders-produce-valid-unified-keys',
+      async run({ assert }) {
+        const fixtures = [FIXTURE_ORDER_APPROVED, FIXTURE_ORDER_COMPLETED];
+
+        for (let i = 0; i < fixtures.length; i++) {
+          const result = toUnifiedOneTime(fixtures[i]);
+          assert.ok(result.product, `Fixture ${i}: should have product`);
+          assert.ok(result.status, `Fixture ${i}: should have status`);
+          assert.ok(result.payment, `Fixture ${i}: should have payment`);
+          assert.equal(result.payment.processor, 'paypal', `Fixture ${i}: processor is paypal`);
+          assert.isType(result.payment.updatedBy.date.timestamp, 'string', `Fixture ${i}: updatedBy.date.timestamp is string`);
+          assert.isType(result.payment.updatedBy.date.timestampUNIX, 'number', `Fixture ${i}: updatedBy.date.timestampUNIX is number`);
+          // One-time payments should NOT have subscription fields
+          assert.equal(result.expires, undefined, `Fixture ${i}: no expires`);
+          assert.equal(result.trial, undefined, `Fixture ${i}: no trial`);
+          assert.equal(result.cancellation, undefined, `Fixture ${i}: no cancellation`);
+        }
+      },
+    },
+  ],
+};