backend-manager 5.9.5 → 5.9.6

package/test/events/payments/journey-payments-trial.js

@@ -1,171 +0,0 @@
-/**
- * Test: Payment Journey - Trial
- * Simulates: basic user → trial activation via test intent → trial ends → active paid
- *
- * Uses the test processor for initial trial, then manual webhook for trial-to-active
- * Product-agnostic: resolves the first paid product from config.payment.products
- */
-module.exports = {
-  description: 'Payment journey: basic → trial → active paid via test processor',
-  type: 'suite',
-  timeout: 30000,
-
-  tests: [
-    {
-      name: 'verify-starts-as-basic',
-      async run({ accounts, firestore, assert, state, config, skip, payments }) {
-        const uid = accounts['journey-payments-trial'].uid;
-        const userDoc = await firestore.get(`users/${uid}`);
-
-        assert.ok(userDoc, 'User doc should exist');
-        assert.equal(userDoc.subscription?.product?.id, 'basic', 'Should start as basic');
-        assert.equal(userDoc.subscription?.trial?.claimed, false, 'Trial should not be claimed');
-
-        // Resolve first paid product WITH a trial from config. The test processor
-        // only creates a trialing subscription when product.trial.days > 0, so a
-        // brand whose paid products all have trial.days: 0 (e.g. trials disabled)
-        // has nothing to exercise here — skip the journey. This is a config-gap,
-        // not a code failure, and mirrors journey-payments-trial-cancel.js.
-        const paidProduct = config.payment.products.find(p => p.id !== 'basic' && p.prices && p.trial?.days);
-        if (!paidProduct) {
-          skip('No paid product with trial configured in this brand');
-        }
-
-        state.uid = uid;
-        state.paidProductId = paidProduct.id;
-        state.product = payments.products[paidProduct.id];
-      },
-    },
-
-    {
-      name: 'create-trial-intent',
-      async run({ http, assert, state }) {
-        const response = await http.as('journey-payments-trial').post('backend-manager/payments/intent', {
-          processor: 'test',
-          productId: state.paidProductId,
-          frequency: state.product.frequency,
-          trial: true,
-        });
-
-        assert.isSuccess(response, 'Intent should succeed');
-        assert.ok(response.data.id, 'Should return intent ID');
-        assert.ok(response.data.orderId, 'Should return orderId');
-
-        state.intentId = response.data.id;
-        state.orderId = response.data.orderId;
-
-        // Derive webhook event ID from intent ID (same timestamp)
-        state.eventId = response.data.id.replace('_test-cs-', '_test-evt-');
-      },
-    },
-
-    {
-      name: 'trial-activated',
-      async run({ firestore, assert, state, waitFor }) {
-        // Poll until trial subscription appears
-        await waitFor(async () => {
-          const userDoc = await firestore.get(`users/${state.uid}`);
-          return userDoc?.subscription?.trial?.claimed === true;
-        }, 15000, 500);
-
-        const userDoc = await firestore.get(`users/${state.uid}`);
-
-        assert.equal(userDoc.subscription.product.id, state.paidProductId, `Product should be ${state.paidProductId}`);
-        assert.equal(userDoc.subscription.status, 'active', 'Status should be active');
-        assert.equal(userDoc.subscription.trial.claimed, true, 'Trial should be claimed');
-        assert.equal(userDoc.subscription.payment.orderId, state.orderId, 'Order ID should match intent');
-
-        state.subscriptionId = userDoc.subscription.payment.resourceId;
-
-        // Verify the auto-fired webhook triggered new-subscription (trial is a property, not a separate transition)
-        const webhookDoc = await firestore.get(`payments-webhooks/${state.eventId}`);
-        assert.ok(webhookDoc, 'Webhook doc should exist');
-        assert.equal(webhookDoc.transition, 'new-subscription', 'Transition should be new-subscription (trial detected inside handler)');
-        assert.equal(webhookDoc.orderId, state.orderId, 'Webhook doc orderId should match intent');
-      },
-    },
-
-    {
-      name: 'intent-doc-completed',
-      async run({ firestore, assert, state }) {
-        const intentDoc = await firestore.get(`payments-intents/${state.orderId}`);
-
-        assert.ok(intentDoc, 'Intent doc should exist');
-        assert.equal(intentDoc.id, state.orderId, 'ID should match orderId');
-        assert.equal(intentDoc.status, 'completed', 'Intent status should be completed after webhook processing');
-        assert.ok(intentDoc.metadata?.completed?.timestampUNIX > 0, 'Completed timestamp should be set');
-      },
-    },
-
-    {
-      name: 'order-doc-created',
-      async run({ firestore, assert, state }) {
-        const orderDoc = await firestore.get(`payments-orders/${state.orderId}`);
-
-        assert.ok(orderDoc, 'Order doc should exist');
-        assert.equal(orderDoc.id, state.orderId, 'ID should match orderId');
-        assert.equal(orderDoc.type, 'subscription', 'Type should be subscription');
-        assert.equal(orderDoc.owner, state.uid, 'Owner should match');
-        assert.equal(orderDoc.unified.product.id, state.paidProductId, `Product should be ${state.paidProductId}`);
-        assert.equal(orderDoc.unified.trial.claimed, true, 'Trial should be claimed');
-        assert.ok(orderDoc.requests !== undefined, 'requests field should exist');
-        assert.equal(orderDoc.requests.cancellation, null, 'requests.cancellation should be null');
-        assert.equal(orderDoc.requests.refund, null, 'requests.refund should be null');
-      },
-    },
-
-    {
-      name: 'send-trial-to-active-webhook',
-      async run({ http, assert, state, config, payments }) {
-        const futureDate = new Date();
-        futureDate.setMonth(futureDate.getMonth() + 1);
-
-        state.eventId2 = `_test-evt-journey-trial-active-${Date.now()}`;
-
-        const response = await http.as('none').post(`backend-manager/payments/webhook?processor=test&key=${config.backendManagerWebhookKey}`, {
-          id: state.eventId2,
-          type: 'customer.subscription.updated',
-          data: {
-            object: {
-              id: state.subscriptionId,
-              object: 'subscription',
-              status: 'active',
-              metadata: { uid: state.uid, orderId: state.orderId },
-              cancel_at_period_end: false,
-              canceled_at: null,
-              current_period_end: Math.floor(futureDate.getTime() / 1000),
-              current_period_start: Math.floor(Date.now() / 1000),
-              start_date: Math.floor(Date.now() / 1000) - 86400 * 14,
-              trial_start: Math.floor(Date.now() / 1000) - 86400 * 14,
-              trial_end: Math.floor(Date.now() / 1000),
-              plan: { product: payments.stripeProductIds[state.paidProductId], interval: state.product.interval },
-            },
-          },
-        });
-
-        assert.isSuccess(response, 'Webhook should be accepted');
-      },
-    },
-
-    {
-      name: 'trial-transitioned-to-active',
-      async run({ firestore, assert, state, waitFor }) {
-        await waitFor(async () => {
-          const doc = await firestore.get(`payments-webhooks/${state.eventId2}`);
-          return doc?.status === 'completed';
-        }, 15000, 500);
-
-        // Trial → active paid is the same status/product, so no transition fires
-        const webhookDoc = await firestore.get(`payments-webhooks/${state.eventId2}`);
-        assert.equal(webhookDoc.transition, null, 'No transition (same status/product, trial already claimed)');
-
-        const userDoc = await firestore.get(`users/${state.uid}`);
-
-        assert.equal(userDoc.subscription.product.id, state.paidProductId, `Product should be ${state.paidProductId}`);
-        assert.equal(userDoc.subscription.status, 'active', 'Status should be active');
-        assert.equal(userDoc.subscription.trial.claimed, true, 'Trial should remain claimed (historical)');
-        assert.equal(userDoc.subscription.payment.frequency, state.product.frequency, `Frequency should be ${state.product.frequency}`);
-      },
-    },
-  ],
-};

package/test/events/payments/journey-payments-uid-resolution.js

@@ -1,132 +0,0 @@
-/**
- * Test: Payment Journey - UID Resolution Fallback
- * Simulates: paid active subscription → webhook with uid OMITTED from metadata
- *
- * Verifies Fix 1: when a webhook event doesn't carry uid in metadata (like PayPal's
- * PAYMENT.SALE events), the pipeline resolves uid from the fetched resource using
- * library.getUid() and persists it on the webhook doc.
- *
- * Flow:
- * 1. Set up paid subscription via test intent (establishes payments-orders doc with resourceId)
- * 2. Send customer.subscription.updated webhook WITHOUT uid in metadata
- * 3. Verify: webhook completes (not fails), uid resolved, subscription updated
- *
- * Product-agnostic: resolves the first paid product from config.payment.products
- */
-module.exports = {
-  description: 'Payment journey: webhook without uid → UID resolved from fetched resource',
-  type: 'suite',
-  timeout: 30000,
-
-  tests: [
-    {
-      name: 'setup-paid-subscription',
-      async run({ accounts, firestore, assert, state, config, http, waitFor, skip, payments }) {
-        const uid = accounts['journey-payments-uid-resolution'].uid;
-
-        // Resolve a paid product with a monthly price. If the brand has none configured,
-        // skip the entire journey — this is a config-gap, not a code failure.
-        const paidProduct = config.payment.products.find(p => p.id !== 'basic' && p.prices?.monthly);
-        if (!paidProduct) {
-          skip('No paid product with monthly price configured in this brand');
-        }
-
-        state.uid = uid;
-        state.paidProductId = paidProduct.id;
-        state.product = payments.products[paidProduct.id];
-        // Create subscription via test intent
-        const response = await http.as('journey-payments-uid-resolution').post('backend-manager/payments/intent', {
-          processor: 'test',
-          productId: paidProduct.id,
-          frequency: state.product.frequency,
-        });
-        assert.isSuccess(response, 'Intent should succeed');
-        state.orderId = response.data.orderId;
-
-        // Wait for subscription to activate
-        await waitFor(async () => {
-          const userDoc = await firestore.get(`users/${uid}`);
-          return userDoc?.subscription?.product?.id === paidProduct.id
-            && userDoc?.subscription?.status === 'active';
-        }, 15000, 500);
-
-        const userDoc = await firestore.get(`users/${uid}`);
-        state.subscriptionId = userDoc.subscription.payment.resourceId;
-
-        assert.ok(state.subscriptionId, 'Subscription resource ID should exist');
-      },
-    },
-
-    {
-      name: 'send-webhook-without-uid',
-      async run({ http, assert, state, config, payments }) {
-        // Send a subscription update webhook WITHOUT uid in metadata
-        // The test processor's fetchResource() will look up payments-orders by resourceId
-        // and reconstruct a Stripe-shaped subscription that includes metadata.uid
-        // Then library.getUid() extracts uid from the fetched resource
-        const futureDate = new Date();
-        futureDate.setMonth(futureDate.getMonth() + 1);
-
-        state.noUidEventId = `_test-evt-journey-uid-resolve-${Date.now()}`;
-
-        const response = await http.as('none').post(`backend-manager/payments/webhook?processor=test&key=${config.backendManagerWebhookKey}`, {
-          id: state.noUidEventId,
-          type: 'customer.subscription.updated',
-          data: {
-            object: {
-              id: state.subscriptionId,
-              object: 'subscription',
-              status: 'active',
-              // NO metadata.uid — this is the key part of the test
-              metadata: {},
-              cancel_at_period_end: true,
-              cancel_at: Math.floor(futureDate.getTime() / 1000),
-              canceled_at: null,
-              current_period_end: Math.floor(futureDate.getTime() / 1000),
-              current_period_start: Math.floor(Date.now() / 1000),
-              start_date: Math.floor(Date.now() / 1000) - 86400 * 30,
-              trial_start: null,
-              trial_end: null,
-              plan: { product: payments.stripeProductIds[state.paidProductId], interval: state.product.interval },
-            },
-          },
-        });
-
-        assert.isSuccess(response, 'Webhook should be accepted (even without uid)');
-      },
-    },
-
-    {
-      name: 'uid-resolved-and-webhook-completed',
-      async run({ firestore, assert, state, waitFor }) {
-        // Wait for the webhook to be processed
-        await waitFor(async () => {
-          const doc = await firestore.get(`payments-webhooks/${state.noUidEventId}`);
-          return doc?.status === 'completed' || doc?.status === 'failed';
-        }, 15000, 500);
-
-        const webhookDoc = await firestore.get(`payments-webhooks/${state.noUidEventId}`);
-
-        // Core assertions: UID was resolved from the fetched resource
-        assert.equal(webhookDoc.status, 'completed', 'Webhook should complete (not fail due to missing UID)');
-        assert.equal(webhookDoc.owner, state.uid, 'Owner should be resolved to the correct UID');
-        assert.equal(webhookDoc.orderId, state.orderId, 'Order ID should match');
-
-        // Transition should be cancellation-requested (we sent cancel_at_period_end: true)
-        assert.equal(webhookDoc.transition, 'cancellation-requested', 'Transition should be cancellation-requested');
-      },
-    },
-
-    {
-      name: 'subscription-updated-correctly',
-      async run({ firestore, assert, state }) {
-        const userDoc = await firestore.get(`users/${state.uid}`);
-
-        // The webhook should have updated the user doc even though uid wasn't in the webhook metadata
-        assert.equal(userDoc.subscription.status, 'active', 'Status should still be active');
-        assert.equal(userDoc.subscription.cancellation.pending, true, 'Cancellation should be pending');
-        assert.equal(userDoc.subscription.product.id, state.paidProductId, `Product should be ${state.paidProductId}`);
-      },
-    },
-  ],
-};

package/test/events/payments/journey-payments-upgrade.js

@@ -1,135 +0,0 @@
-/**
- * Test: Payment Journey - Upgrade
- * Simulates: basic user → test intent → auto-webhook → paid active subscription
- *
- * Uses the test processor to exercise the full intent→webhook→trigger pipeline
- * Product-agnostic: resolves the first paid product from config.payment.products
- */
-module.exports = {
-  description: 'Payment journey: basic → paid upgrade via test intent',
-  type: 'suite',
-  timeout: 30000,
-
-  tests: [
-    {
-      name: 'verify-starts-as-basic',
-      async run({ accounts, firestore, assert, state, config, skip, payments }) {
-        const uid = accounts['journey-payments-upgrade'].uid;
-        const userDoc = await firestore.get(`users/${uid}`);
-
-        assert.ok(userDoc, 'User doc should exist');
-        assert.equal(userDoc.subscription?.product?.id, 'basic', 'Should start as basic');
-        assert.equal(userDoc.subscription?.status, 'active', 'Should be active');
-
-        // Resolve first paid product from config. If the brand has none configured,
-        // skip the entire journey — this is a config-gap, not a code failure.
-        const paidProduct = config.payment.products.find(p => p.id !== 'basic' && p.prices);
-        if (!paidProduct) {
-          skip('No paid product configured in this brand');
-        }
-
-        state.uid = uid;
-        state.paidProductId = paidProduct.id;
-        state.product = payments.products[paidProduct.id];
-
-        state.paidProductName = paidProduct.name;
-      },
-    },
-
-    {
-      name: 'create-test-intent',
-      async run({ http, assert, state }) {
-        const response = await http.as('journey-payments-upgrade').post('backend-manager/payments/intent', {
-          processor: 'test',
-          productId: state.paidProductId,
-          frequency: state.product.frequency,
-        });
-
-        assert.isSuccess(response, 'Intent should succeed');
-        assert.ok(response.data.id, 'Should return intent ID');
-        assert.ok(response.data.orderId, 'Should return orderId');
-        assert.match(response.data.orderId, /^\d{4}-\d{4}-\d{4}$/, 'orderId should be XXXX-XXXX-XXXX format');
-        assert.ok(response.data.url, 'Should return URL');
-
-        state.intentId = response.data.id;
-        state.orderId = response.data.orderId;
-
-        // Derive webhook event ID from intent ID (same timestamp)
-        state.eventId = response.data.id.replace('_test-cs-', '_test-evt-');
-      },
-    },
-
-    {
-      name: 'subscription-activated',
-      async run({ firestore, assert, state, waitFor }) {
-        // Poll user doc until subscription changes from basic to paid
-        await waitFor(async () => {
-          const userDoc = await firestore.get(`users/${state.uid}`);
-          return userDoc?.subscription?.product?.id === state.paidProductId;
-        }, 15000, 500);
-
-        const userDoc = await firestore.get(`users/${state.uid}`);
-
-        assert.equal(userDoc.subscription.product.id, state.paidProductId, `Product should be ${state.paidProductId}`);
-        assert.equal(userDoc.subscription.status, 'active', 'Status should be active');
-        assert.equal(userDoc.subscription.payment.processor, 'test', 'Processor should be test');
-        assert.equal(userDoc.subscription.payment.orderId, state.orderId, 'Order ID should match intent');
-        assert.ok(userDoc.subscription.payment.resourceId, 'Resource ID should be set');
-        assert.equal(userDoc.subscription.payment.frequency, state.product.frequency, 'Frequency should be monthly');
-        assert.equal(userDoc.subscription.cancellation.pending, false, 'Should not be pending cancellation');
-
-        state.subscriptionId = userDoc.subscription.payment.resourceId;
-      },
-    },
-
-    {
-      name: 'order-doc-created',
-      async run({ firestore, assert, state }) {
-        const orderDoc = await firestore.get(`payments-orders/${state.orderId}`);
-
-        assert.ok(orderDoc, 'Order doc should exist');
-        assert.equal(orderDoc.id, state.orderId, 'ID should match orderId');
-        assert.equal(orderDoc.type, 'subscription', 'Type should be subscription');
-        assert.equal(orderDoc.owner, state.uid, 'Owner should match');
-        assert.equal(orderDoc.processor, 'test', 'Processor should be test');
-        assert.equal(orderDoc.resourceId, state.subscriptionId, 'Resource ID should match');
-        assert.equal(orderDoc.unified.product.id, state.paidProductId, `Product should be ${state.paidProductId}`);
-        assert.equal(orderDoc.unified.status, 'active', 'Status should be active');
-        assert.ok(orderDoc.requests !== undefined, 'requests field should exist');
-        assert.equal(orderDoc.requests.cancellation, null, 'requests.cancellation should be null initially');
-        assert.equal(orderDoc.requests.refund, null, 'requests.refund should be null initially');
-      },
-    },
-
-    {
-      name: 'webhook-transition-new-subscription',
-      async run({ firestore, assert, state, waitFor }) {
-        await waitFor(async () => {
-          const doc = await firestore.get(`payments-webhooks/${state.eventId}`);
-          return doc?.status === 'completed';
-        }, 15000, 500);
-
-        const webhookDoc = await firestore.get(`payments-webhooks/${state.eventId}`);
-        assert.ok(webhookDoc, 'Webhook doc should exist');
-        assert.equal(webhookDoc.transition, 'new-subscription', 'Transition should be new-subscription');
-        assert.equal(webhookDoc.orderId, state.orderId, 'Webhook doc orderId should match intent');
-      },
-    },
-
-    {
-      name: 'intent-doc-completed',
-      async run({ firestore, assert, state }) {
-        const intentDoc = await firestore.get(`payments-intents/${state.orderId}`);
-
-        assert.ok(intentDoc, 'Intent doc should exist');
-        assert.equal(intentDoc.id, state.orderId, 'ID should match orderId');
-        assert.equal(intentDoc.intentId, state.intentId, 'Intent ID should match processor session ID');
-        assert.equal(intentDoc.owner, state.uid, 'Owner should match');
-        assert.equal(intentDoc.processor, 'test', 'Processor should be test');
-        assert.equal(intentDoc.status, 'completed', 'Intent status should be completed after webhook processing');
-        assert.equal(intentDoc.productId, state.paidProductId, `Product should be ${state.paidProductId}`);
-        assert.ok(intentDoc.metadata?.completed?.timestampUNIX > 0, 'Completed timestamp should be set');
-      },
-    },
-  ],
-};

package/test/fixtures/chargebee/invoice-one-time.json

@@ -1,27 +0,0 @@
-{
-  "id": "inv_cb_onetime_001",
-  "customer_id": "cb_cust_006",
-  "status": "paid",
-  "total": 999,
-  "amount_paid": 999,
-  "amount_due": 0,
-  "recurring": false,
-  "date": 1700000000,
-  "paid_at": 1700000001,
-  "currency_code": "USD",
-  "object": "invoice",
-  "meta_data": "{\"uid\":\"test-uid-006\",\"orderId\":\"6789-0123-4567\",\"productId\":\"credits-100\"}",
-  "line_items": [
-    {
-      "id": "li_cb_001",
-      "date_from": 1700000000,
-      "date_to": 1700000000,
-      "unit_amount": 999,
-      "quantity": 1,
-      "amount": 999,
-      "description": "100 Credits",
-      "entity_type": "charge",
-      "object": "line_item"
-    }
-  ]
-}

package/test/fixtures/chargebee/subscription-active.json

@@ -1,44 +0,0 @@
-{
-  "id": "cb_sub_active_001",
-  "customer_id": "cb_cust_001",
-  "status": "active",
-  "current_term_start": 1700000000,
-  "current_term_end": 1702592000,
-  "next_billing_at": 1702592000,
-  "created_at": 1697321600,
-  "started_at": 1697321600,
-  "activated_at": 1697321600,
-  "updated_at": 1700000000,
-  "has_scheduled_changes": false,
-  "channel": "web",
-  "resource_version": 1700000000000,
-  "deleted": false,
-  "object": "subscription",
-  "currency_code": "USD",
-  "subscription_items": [
-    {
-      "item_price_id": "somiibo-pro-monthly",
-      "item_type": "plan",
-      "quantity": 1,
-      "unit_price": 499,
-      "amount": 499,
-      "object": "subscription_item"
-    }
-  ],
-  "meta_data": "{\"uid\":\"test-uid-001\",\"orderId\":\"1234-5678-9012\"}",
-  "shipping_address": {
-    "first_name": "Test",
-    "last_name": "User",
-    "line1": "123 Main Street",
-    "city": "San Francisco",
-    "state": "CA",
-    "country": "US",
-    "validation_status": "not_validated",
-    "object": "shipping_address"
-  },
-  "due_invoices_count": 0,
-  "mrr": 499,
-  "exchange_rate": 1,
-  "base_currency_code": "USD",
-  "has_scheduled_advance_invoices": false
-}

package/test/fixtures/chargebee/subscription-cancelled.json

@@ -1,42 +0,0 @@
-{
-  "id": "cb_sub_cancelled_001",
-  "customer_id": "cb_cust_002",
-  "status": "cancelled",
-  "current_term_start": 1697321600,
-  "current_term_end": 1700000000,
-  "created_at": 1694643200,
-  "started_at": 1694643200,
-  "activated_at": 1694643200,
-  "cancelled_at": 1699500000,
-  "updated_at": 1699500000,
-  "has_scheduled_changes": false,
-  "channel": "web",
-  "resource_version": 1699500000000,
-  "deleted": false,
-  "object": "subscription",
-  "currency_code": "USD",
-  "subscription_items": [
-    {
-      "item_price_id": "somiibo-pro-annually",
-      "item_type": "plan",
-      "quantity": 1,
-      "unit_price": 4999,
-      "amount": 4999,
-      "object": "subscription_item"
-    }
-  ],
-  "meta_data": "{\"uid\":\"test-uid-002\",\"orderId\":\"2345-6789-0123\"}",
-  "shipping_address": {
-    "first_name": "Cancelled",
-    "last_name": "User",
-    "line1": "456 Oak Avenue",
-    "city": "New York",
-    "state": "NY",
-    "country": "US",
-    "validation_status": "not_validated",
-    "object": "shipping_address"
-  },
-  "due_invoices_count": 0,
-  "mrr": 0,
-  "has_scheduled_advance_invoices": false
-}

package/test/fixtures/chargebee/subscription-in-trial.json

@@ -1,41 +0,0 @@
-{
-  "id": "cb_sub_trial_001",
-  "customer_id": "cb_cust_003",
-  "status": "in_trial",
-  "trial_start": 1700000000,
-  "trial_end": 1701209600,
-  "next_billing_at": 1701209600,
-  "created_at": 1700000000,
-  "started_at": 1700000000,
-  "updated_at": 1700000000,
-  "has_scheduled_changes": false,
-  "channel": "web",
-  "resource_version": 1700000000000,
-  "deleted": false,
-  "object": "subscription",
-  "currency_code": "USD",
-  "subscription_items": [
-    {
-      "item_price_id": "somiibo-pro-monthly",
-      "item_type": "plan",
-      "quantity": 1,
-      "unit_price": 499,
-      "amount": 499,
-      "object": "subscription_item"
-    }
-  ],
-  "meta_data": "{\"uid\":\"test-uid-003\",\"orderId\":\"3456-7890-1234\"}",
-  "shipping_address": {
-    "first_name": "Trial",
-    "last_name": "User",
-    "line1": "789 Elm Drive",
-    "city": "Chicago",
-    "state": "IL",
-    "country": "US",
-    "validation_status": "not_validated",
-    "object": "shipping_address"
-  },
-  "due_invoices_count": 0,
-  "mrr": 0,
-  "has_scheduled_advance_invoices": false
-}

package/test/fixtures/chargebee/subscription-legacy-plan.json

@@ -1,41 +0,0 @@
-{
-  "id": "AzZMxvTYTQUmw1Iw7",
-  "plan_id": "somiibo-premium-monthly-1",
-  "plan_quantity": 1,
-  "plan_unit_price": 1995,
-  "billing_period": 1,
-  "billing_period_unit": "month",
-  "customer_id": "AzZMxvTYTQUmw1Iw7",
-  "plan_amount": 1995,
-  "plan_free_quantity": 0,
-  "status": "active",
-  "current_term_start": 1692009453,
-  "current_term_end": 1694687853,
-  "next_billing_at": 1694687853,
-  "created_at": 1678790253,
-  "started_at": 1678790253,
-  "activated_at": 1678790253,
-  "updated_at": 1692009461,
-  "has_scheduled_changes": false,
-  "channel": "web",
-  "resource_version": 1692009461863,
-  "deleted": false,
-  "object": "subscription",
-  "currency_code": "USD",
-  "shipping_address": {
-    "first_name": "Legacy",
-    "last_name": "User",
-    "line1": "Kalograion",
-    "city": "Larnaca",
-    "state": "Larnaca",
-    "country": "CY",
-    "validation_status": "not_validated",
-    "object": "shipping_address"
-  },
-  "due_invoices_count": 0,
-  "mrr": 1995,
-  "exchange_rate": 1,
-  "base_currency_code": "USD",
-  "cf_clientorderid": "1678790168794-0784",
-  "has_scheduled_advance_invoices": false
-}