@omega.js/backend 0.1.0

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

@@ -0,0 +1,490 @@
+/**
+ * Test: Chargebee parseWebhook()
+ * Unit tests for the Chargebee webhook provider's event categorization and routing
+ *
+ * Verifies that parseWebhook() correctly determines category, resourceType, resourceId,
+ * and uid for each supported event type.
+ */
+const chargebeeProvider = require('../../../../dist/manager/routes/payments/webhook/providers/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');
+const defineCases = require('../../../../dist/vendor/devkit/test/define-cases.js');
+
+function parseWebhook(event) {
+  return chargebeeProvider.parseWebhook({ body: event });
+}
+
+module.exports = defineCases({
+  description: 'Chargebee parseWebhook() event categorization',
+  type: 'group',
+
+  tests: [
+    // ─── isSupported() ───
+
+    {
+      name: 'supports-subscription-created',
+      async run({ assert }) {
+        assert.ok(chargebeeProvider.isSupported('subscription_created'), 'Should support subscription_created');
+      },
+    },
+
+    {
+      name: 'supports-subscription-cancelled',
+      async run({ assert }) {
+        assert.ok(chargebeeProvider.isSupported('subscription_cancelled'), 'Should support subscription_cancelled');
+      },
+    },
+
+    {
+      name: 'supports-subscription-activated',
+      async run({ assert }) {
+        assert.ok(chargebeeProvider.isSupported('subscription_activated'), 'Should support subscription_activated');
+      },
+    },
+
+    {
+      name: 'supports-subscription-changed',
+      async run({ assert }) {
+        assert.ok(chargebeeProvider.isSupported('subscription_changed'), 'Should support subscription_changed');
+      },
+    },
+
+    {
+      name: 'supports-subscription-renewed',
+      async run({ assert }) {
+        assert.ok(chargebeeProvider.isSupported('subscription_renewed'), 'Should support subscription_renewed');
+      },
+    },
+
+    {
+      name: 'supports-subscription-reactivated',
+      async run({ assert }) {
+        assert.ok(chargebeeProvider.isSupported('subscription_reactivated'), 'Should support subscription_reactivated');
+      },
+    },
+
+    {
+      name: 'supports-cancellation-scheduled',
+      async run({ assert }) {
+        assert.ok(chargebeeProvider.isSupported('subscription_cancellation_scheduled'), 'Should support subscription_cancellation_scheduled');
+      },
+    },
+
+    {
+      name: 'supports-cancellation-removed',
+      async run({ assert }) {
+        assert.ok(chargebeeProvider.isSupported('subscription_scheduled_cancellation_removed'), 'Should support scheduled_cancellation_removed');
+      },
+    },
+
+    {
+      name: 'supports-payment-failed',
+      async run({ assert }) {
+        assert.ok(chargebeeProvider.isSupported('payment_failed'), 'Should support payment_failed');
+      },
+    },
+
+    {
+      name: 'supports-payment-succeeded',
+      async run({ assert }) {
+        // The paid signal for a one-time purchase. Without it subscribed, a
+        // Chargebee one-time sale reached the pipeline as `invoice_generated`
+        // alone — an event that says nothing about payment
+        // ([#729](https://github.com/Omega-JS-Stack/omega/issues/729)).
+        assert.ok(chargebeeProvider.isSupported('payment_succeeded'), 'Should support payment_succeeded');
+      },
+    },
+
+    {
+      name: 'supports-payment-refunded',
+      async run({ assert }) {
+        assert.ok(chargebeeProvider.isSupported('payment_refunded'), 'Should support payment_refunded');
+      },
+    },
+
+    {
+      name: 'supports-invoice-generated',
+      async run({ assert }) {
+        assert.ok(chargebeeProvider.isSupported('invoice_generated'), 'Should support invoice_generated');
+      },
+    },
+
+    {
+      name: 'rejects-unsupported-event',
+      async run({ assert }) {
+        assert.equal(chargebeeProvider.isSupported('customer_created'), false, 'Should not support customer_created');
+        assert.equal(chargebeeProvider.isSupported('coupon_created'), false, 'Should not support coupon_created');
+        assert.equal(chargebeeProvider.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_succeeded ───
+
+    {
+      name: 'payment-succeeded-one-time-category',
+      async run({ assert }) {
+        const result = parseWebhook({
+          id: 'ev_pay_ok_onetime',
+          event_type: 'payment_succeeded',
+          content: {
+            invoice: { id: 'inv_onetime_paid' },
+            customer: { id: 'cust_onetime', meta_data: '{"uid":"user-onetime-paid"}' },
+          },
+        });
+
+        assert.equal(result.category, 'one-time', 'No subscription → one-time');
+        assert.equal(result.resourceType, 'invoice', 'Should fetch invoice');
+        assert.equal(result.resourceId, 'inv_onetime_paid', 'Resource ID should be invoice ID');
+        assert.equal(result.uid, 'user-onetime-paid', 'UID from customer');
+      },
+    },
+
+    {
+      name: 'payment-succeeded-with-subscription-skipped',
+      async run({ assert }) {
+        // A renewal's charge. `subscription_renewed` already carries that revenue,
+        // so storing this one too would book the renewal twice — the same
+        // double-count the Stripe provider documents for `invoice.paid`
+        // ([#729](https://github.com/Omega-JS-Stack/omega/issues/729)).
+        const result = parseWebhook({
+          id: 'ev_pay_ok_sub',
+          event_type: 'payment_succeeded',
+          content: {
+            subscription: { id: 'sub_paid', meta_data: '{"uid":"user-paid"}' },
+            invoice: { id: 'inv_renewal', subscription_id: 'sub_paid' },
+          },
+        });
+
+        assert.equal(result.category, null, 'With a subscription → null (subscription_renewed owns it)');
+      },
+    },
+
+    // ─── 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-is-one-time',
+      async run({ assert }) {
+        // A refund with an invoice and no subscription is the refund of a one-time
+        // purchase — the same invoice the one-time payment_failed branch names.
+        // Dropping it meant that refund never entered the pipeline at all
+        // ([#212](https://github.com/Omega-JS-Stack/omega/issues/212)).
+        const result = parseWebhook({
+          id: 'ev_refund_onetime',
+          event_type: 'payment_refunded',
+          content: {
+            invoice: { id: 'inv_onetime_refund' },
+            transaction: { id: 'txn_refund' },
+            customer: { id: 'cust_onetime', meta_data: '{"uid":"user-onetime-refund"}' },
+          },
+        });
+
+        assert.equal(result.category, 'one-time', 'No subscription → one-time refund');
+        assert.equal(result.resourceType, 'invoice', 'Should fetch the invoice');
+        assert.equal(result.resourceId, 'inv_onetime_refund', 'Resource ID should be the invoice ID');
+        assert.equal(result.uid, 'user-onetime-refund', 'UID from customer');
+      },
+    },
+
+    {
+      name: 'payment-refunded-with-neither-subscription-nor-invoice-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, 'Nothing to resolve the purchase from → 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/refund-details.test.js

@@ -0,0 +1,198 @@
+/**
+ * Test: Chargebee getRefundDetails()
+ * ([#510](https://github.com/Omega-JS-Stack/omega/issues/510)).
+ *
+ * The refund's amount used to be read out of the webhook envelope — its credit
+ * note, or its transaction, whichever the caller posted — and written onto the
+ * order record and into the customer's refund email. The resource already in hand
+ * is no help: a Chargebee refund lives on the CREDIT NOTE, and the subscription or
+ * invoice the event resolves to carries none of its fields.
+ *
+ * So the credit note is read back by its id — and a refund issued WITHOUT one
+ * reads its transaction back the same way, rather than recording no amount at all
+ * ([#534](https://github.com/Omega-JS-Stack/omega/issues/534)). Only the id comes
+ * from the event, the same trust level as the resourceId every lookup here starts
+ * from, and whichever record answers has to link back to the resource the event
+ * named ([#532](https://github.com/Omega-JS-Stack/omega/issues/532)).
+ *
+ * The HTTP call is the one thing stubbed: reading a credit note back needs live
+ * Chargebee credentials. Everything under test runs for real.
+ *
+ * Run: npx omega test backend:helpers/payment/chargebee/refund-details
+ */
+const Chargebee = require('../../../../dist/manager/libraries/payment/providers/chargebee.js');
+const defineCases = require('../../../../dist/vendor/devkit/test/define-cases.js');
+
+const CREDIT_NOTE_ID = 'cn_test_refund_details';
+const ENDPOINT = `/credit_notes/${CREDIT_NOTE_ID}`;
+
+// The record a gateway refund issued without a credit note leaves behind
+const TRANSACTION_ID = 'txn_test_refund_details';
+const TRANSACTION_ENDPOINT = `/transactions/${TRANSACTION_ID}`;
+
+// The subscription the event resolved to — it knows nothing about the refund
+const SUBSCRIPTION_RESOURCE = { id: 'sub_test_refund', status: 'active' };
+
+/** Run fn with the library's HTTP call replaced by a stand-in, restored afterwards */
+async function withChargebeeRequest(request, fn) {
+  const realRequest = Chargebee.request;
+
+  Chargebee.request = request;
+
+  try {
+    return await fn();
+  } finally {
+    Chargebee.request = realRequest;
+  }
+}
+
+/** A stand-in that records every endpoint asked for and answers from `responses` */
+function requestReturning(responses, calls) {
+  return async (endpoint) => {
+    calls.push(endpoint);
+
+    const response = responses[endpoint];
+
+    if (!response) {
+      const error = new Error(`Chargebee API 404: no stand-in response for ${endpoint}`);
+      error.statusCode = 404;
+      throw error;
+    }
+
+    return JSON.parse(JSON.stringify(response));
+  };
+}
+
+/** The envelope a payment_refunded event arrives in, claiming an inflated total */
+function envelope({ total = 99999, transaction = null } = {}) {
+  return {
+    id: 'cb-evt-refund',
+    event_type: 'payment_refunded',
+    content: {
+      subscription: SUBSCRIPTION_RESOURCE,
+      credit_note: { id: CREDIT_NOTE_ID, total: total, currency_code: 'USD', reason_code: 'fraudulent' },
+      ...(transaction ? { transaction: transaction } : {}),
+    },
+  };
+}
+
+module.exports = defineCases({
+  description: 'Chargebee getRefundDetails() reads the credit note Chargebee answered for',
+  type: 'group',
+
+  tests: [
+    {
+      name: 'reads-the-credit-note-back-by-its-id',
+      async run({ assert }) {
+        const calls = [];
+        const responses = {
+          [ENDPOINT]: { credit_note: { id: CREDIT_NOTE_ID, total: 999, currency_code: 'usd', reason_code: 'product_unsatisfactory' } },
+        };
+
+        const details = await withChargebeeRequest(requestReturning(responses, calls), () => {
+          return Chargebee.getRefundDetails(SUBSCRIPTION_RESOURCE, { raw: envelope({}) });
+        });
+
+        assert.equal(calls.length, 1, 'The credit note is read once');
+        assert.equal(calls[0], ENDPOINT, 'By the id the payload names — an identifier, nothing more');
+        assert.equal(details.amount, '9.99', 'The amount is Chargebee\'s record of the credit note');
+        assert.equal(details.currency, 'USD', 'The currency comes off the same record');
+        assert.equal(details.reason, 'product_unsatisfactory', 'And so does the reason');
+      },
+    },
+
+    {
+      name: 'reads-the-transaction-back-when-there-is-no-credit-note',
+      async run({ assert }) {
+        // A gateway refund issued without a credit note has a trusted record too.
+        // Its id is the lookup KEY, exactly like the credit note's — the envelope's
+        // own transaction amount is still never read
+        // ([#534](https://github.com/Omega-JS-Stack/omega/issues/534)).
+        const calls = [];
+        const raw = envelope({ transaction: { id: TRANSACTION_ID, amount: 99999, currency_code: 'USD' } });
+        const responses = {
+          [TRANSACTION_ENDPOINT]: { transaction: { id: TRANSACTION_ID, type: 'refund', amount: 999, currency_code: 'usd', subscription_id: SUBSCRIPTION_RESOURCE.id } },
+        };
+
+        delete raw.content.credit_note;
+
+        const details = await withChargebeeRequest(requestReturning(responses, calls), () => {
+          return Chargebee.getRefundDetails(SUBSCRIPTION_RESOURCE, { raw: raw, resourceType: 'subscription' });
+        });
+
+        assert.equal(calls[0], TRANSACTION_ENDPOINT, 'The transaction is read back by the id the payload names');
+        assert.equal(details.amount, '9.99', 'The amount is Chargebee\'s record of the transaction');
+        assert.notEqual(details.amount, '999.99', 'Never the number the envelope carried');
+        assert.equal(details.currency, 'USD', 'The currency comes off the same record');
+      },
+    },
+
+    {
+      name: 'a-transaction-that-settled-another-subscription-is-refused',
+      async run({ assert }) {
+        // The fallback's id is the caller's, so it is linked back like every other
+        // refund lookup ([#532](https://github.com/Omega-JS-Stack/omega/issues/532)).
+        const raw = envelope({ transaction: { id: TRANSACTION_ID, amount: 99999, currency_code: 'USD' } });
+        const responses = {
+          [TRANSACTION_ENDPOINT]: { transaction: { id: TRANSACTION_ID, type: 'refund', amount: 999, currency_code: 'usd', subscription_id: 'cb_sub_someone_else' } },
+        };
+
+        delete raw.content.credit_note;
+
+        let threw = null;
+
+        try {
+          await withChargebeeRequest(requestReturning(responses, []), () => {
+            return Chargebee.getRefundDetails(SUBSCRIPTION_RESOURCE, { raw: raw, resourceType: 'subscription' });
+          });
+        } catch (e) {
+          threw = e;
+        }
+
+        assert.ok(threw, 'A record about another order must not answer for this one');
+        assert.equal(threw.refundNotLinked, true, 'It is a linkage refusal, not a lookup failure');
+        assert.equal(threw.linkedTo, 'cb_sub_someone_else', 'And it names what the transaction really settled');
+      },
+    },
+
+    {
+      name: 'an-event-naming-neither-record-reports-no-amount',
+      async run({ assert }) {
+        const warnings = [];
+        const calls = [];
+        const raw = envelope({});
+
+        delete raw.content.credit_note;
+
+        const details = await withChargebeeRequest(requestReturning({}, calls), () => {
+          return Chargebee.getRefundDetails(SUBSCRIPTION_RESOURCE, { raw: raw, ctx: { warn: (m) => warnings.push(m) } });
+        });
+
+        assert.equal(calls.length, 0, 'There is nothing to ask Chargebee about');
+        assert.equal(details.amount, null, 'The refund is recorded with no amount rather than with the payload\'s');
+        assert.equal(warnings.length, 1, 'And the gap is said out loud');
+      },
+    },
+
+    {
+      name: 'a-failed-credit-note-lookup-throws-rather-than-answering-with-the-payload',
+      async run({ assert }) {
+        // An amount that cannot be verified is not written at all ([#506]).
+        let threw = null;
+
+        try {
+          await withChargebeeRequest(requestReturning({}, []), () => {
+            return Chargebee.getRefundDetails(SUBSCRIPTION_RESOURCE, { raw: envelope({}) });
+          });
+        } catch (e) {
+          threw = e;
+        }
+
+        assert.ok(threw, 'A failed lookup must throw');
+        assert.equal(threw.notFound, true, 'A credit note Chargebee does not have is a terminal miss, classified by the same seam');
+        assert.equal(threw.resourceType, 'credit_note', 'The failure names the lookup that missed');
+        assert.equal(threw.resourceId, CREDIT_NOTE_ID, 'And the id it missed on');
+      },
+    },
+  ],
+});