vona-module-test-pay 5.0.2 → 5.0.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vona-module-test-pay",
-  "version": "5.0.2",
+  "version": "5.0.3",
   "description": "",
   "keywords": [
     "Vona Module"
@@ -30,8 +30,8 @@
     "postpack": "clean-package restore"
   },
   "dependencies": {
-    "vona-module-a-pay": "5.0.3",
-    "vona-module-pay-mock": "5.0.3"
+    "vona-module-a-pay": "5.0.4",
+    "vona-module-pay-mock": "5.0.4"
   },
   "title": "test-pay",
   "vonaModule": {
@@ -51,5 +51,5 @@
       }
     }
   },
-  "gitHead": "e86b8ee51b837417b7b28b2c67862877d4092371"
+  "gitHead": "c408492ce774644ac8a2530702db916986f52151"
 }

package/test/paymentSession.test.ts

@@ -79,6 +79,31 @@ describe('paymentSession.test.ts', { concurrency: false }, () => {
     });
   });
 
+  it('rejects an unavailable provider candidate instead of falling back', async () => {
+    await app.bean.executor.mockCtx(async () => {
+      const scope = app.scope('a-pay');
+      const suffix = randomUUID().slice(0, 12);
+      const user = await app.bean.user.register({ name: `payment-candidate-${suffix}` }, true);
+      const fixture: IFixture = { userId: user.id as number };
+      try {
+        await assert.rejects(
+          scope.service.paymentSession.create({
+            userId: user.id,
+            payScene: 'commerce-payment:commerceOrder',
+            businessReference: `business-${suffix}`,
+            amountMinor: 1299,
+            currency: 'USD',
+            correlationId: `payment-${suffix}`,
+            providerCandidateKey: 'stripe',
+          }),
+          { status: 422 },
+        );
+      } finally {
+        await cleanup(fixture);
+      }
+    });
+  });
+
   it('rejects a currency outside the payment scene policy', async () => {
     await app.bean.executor.mockCtx(async () => {
       const scope = app.scope('a-pay');
@@ -142,6 +167,83 @@ describe('paymentSession.test.ts', { concurrency: false }, () => {
     });
   });
 
+  it('returns a terminal payment session when confirmation is replayed', async () => {
+    await app.bean.executor.mockCtx(async () => {
+      const fixture = await createFixture(new Date(Date.now() + 60_000));
+      try {
+        const scope = app.scope('a-pay');
+        await scope.model.paymentSession.updateById(fixture.paymentSessionId!, {
+          state: 'succeeded',
+          finalizedAt: new Date(),
+        });
+        const session = await scope.service.providerOperation.confirm(fixture.paymentSessionId!);
+        assert.equal(session.state, 'succeeded');
+        assert.deepEqual(
+          await scope.model.providerOperation.select({
+            where: { paymentSessionId: fixture.paymentSessionId!, kind: 'confirm' },
+          }),
+          [],
+        );
+      } finally {
+        await cleanup(fixture);
+      }
+    });
+  });
+
+  it('schedules a pending refund for durable reconciliation', async () => {
+    await app.bean.executor.mockCtx(async () => {
+      const fixture = await createFixture(new Date(Date.now() + 60_000));
+      try {
+        const scope = app.scope('a-pay');
+        await scope.model.paymentSession.updateById(fixture.paymentSessionId!, {
+          state: 'succeeded',
+          providerCaptureId: `capture-${randomUUID().slice(0, 12)}`,
+          finalizedAt: new Date(),
+        });
+        const refund = await scope.service.refundOperation.create({
+          paymentSessionId: fixture.paymentSessionId!,
+          businessReference: `refund-${randomUUID().slice(0, 12)}`,
+          amountMinor: 1299,
+          currency: 'USD',
+          idempotencyKey: `refund-${randomUUID()}`,
+          correlationId: `refund-${randomUUID()}`,
+        });
+        const providerOperation = await scope.model.providerOperation.get({
+          refundOperationId: refund.id,
+          kind: 'refund',
+        });
+        assert.ok(providerOperation);
+        const claimed = await scope.service.providerOperation.claim(providerOperation.id);
+        assert.ok(claimed?.claimToken);
+        await scope.service.providerOperation.markSubmitted(
+          providerOperation.id,
+          claimed.claimToken,
+        );
+        await scope.service.refundOperation.settleProviderSnapshot(
+          providerOperation.id,
+          claimed.claimToken,
+          { state: 'pending', providerRefundId: `refund-${randomUUID().slice(0, 12)}` },
+        );
+        const [storedRefund, storedOperation, outbox] = await Promise.all([
+          scope.model.refundOperation.getById(refund.id),
+          scope.model.providerOperation.getById(providerOperation.id),
+          scope.model.outboxEvent.select({
+            where: { paymentSessionId: fixture.paymentSessionId! },
+          }),
+        ]);
+        assert.equal(storedRefund?.state, 'pending');
+        assert.equal(storedOperation?.state, 'reconciliation_required');
+        assert.equal(storedOperation?.providerResourceId, storedRefund?.providerRefundId);
+        assert.equal(storedOperation?.claimToken, undefined);
+        assert.equal(storedOperation?.claimExpiresAt, undefined);
+        assert.ok(storedOperation?.nextAttemptAt && storedOperation.nextAttemptAt > new Date());
+        assert.deepEqual(outbox, []);
+      } finally {
+        await cleanup(fixture);
+      }
+    });
+  });
+
   it('allows only one competing start to call the provider', async () => {
     const fixture = await app.bean.executor.mockCtx(async () => {
       return await createFixture(new Date(Date.now() + 60_000));

package/test/paypalProvider.test.ts

@@ -0,0 +1,118 @@
+import assert from 'node:assert';
+import { describe, it } from 'node:test';
+import { app } from 'vona-mock';
+
+describe('paypalProvider.test.ts', { concurrency: false }, () => {
+  it('maps SDK camelCase payment and refund facts through the PayPal gateway', async () => {
+    await app.bean.executor.mockCtx(async () => {
+      const calls: Array<{ kind: string; input: unknown }> = [];
+      const gateway = {
+        async createOrder(_options: unknown, input: unknown) {
+          calls.push({ kind: 'createOrder', input });
+          return {
+            id: 'order-1',
+            links: [
+              { rel: 'approve', href: 'https://www.sandbox.paypal.com/checkoutnow?token=order-1' },
+            ],
+          };
+        },
+        async captureOrder() {
+          throw new Error('unexpected captureOrder');
+        },
+        async getOrder(_options: unknown, input: unknown) {
+          calls.push({ kind: 'getOrder', input });
+          return {
+            id: 'order-1',
+            purchaseUnits: [
+              {
+                customId: '101',
+                invoiceId: 'business-1',
+                amount: { currencyCode: 'USD', value: '12.99' },
+                payee: { merchantId: 'merchant-1' },
+                payments: {
+                  captures: [
+                    {
+                      id: 'capture-1',
+                      status: 'COMPLETED',
+                      amount: { currencyCode: 'USD', value: '12.99' },
+                    },
+                  ],
+                },
+              },
+            ],
+          };
+        },
+        async refundCapturedPayment(_options: unknown, input: unknown) {
+          calls.push({ kind: 'refundCapturedPayment', input });
+          return {
+            id: 'refund-1',
+            customId: '201',
+            invoiceId: 'refund-business-1',
+            amount: { currencyCode: 'USD', value: '5.00' },
+            status: 'COMPLETED',
+            payee: { merchantId: 'merchant-1' },
+          };
+        },
+        async getRefund() {
+          throw new Error('unexpected getRefund');
+        },
+        async verifyWebhookSignature() {
+          throw new Error('unexpected verifyWebhookSignature');
+        },
+      };
+      const { provider, clientOptions } = app.bean.payProvider.resolveByName(
+        'pay-paypal:paypal',
+        'default',
+      );
+      const options = {
+        ...clientOptions,
+        secretCredential: { clientId: 'client-1', clientSecret: 'secret-1' },
+        webhookId: 'webhook-1',
+        merchantReference: 'merchant-1',
+        gateway,
+      };
+      const paymentInput = {
+        paymentSessionId: 101,
+        businessReference: 'business-1',
+        idempotencyKey: 'payment-key',
+        amountMinor: 1299,
+        currency: 'USD',
+        providerOrderId: 'order-1',
+      };
+      const payment = await provider.queryPayment(paymentInput, options as never);
+      assert.deepEqual(payment, {
+        state: 'succeeded',
+        providerPaymentId: 'order-1',
+        providerOrderId: 'order-1',
+        providerCaptureId: 'capture-1',
+        nextAction: { kind: 'completed' },
+      });
+      const refund = await provider.createRefund(
+        {
+          paymentSessionId: 101,
+          refundOperationId: 201,
+          businessReference: 'refund-business-1',
+          idempotencyKey: 'refund-key',
+          amountMinor: 500,
+          currency: 'USD',
+          providerCaptureId: 'capture-1',
+        },
+        options as never,
+      );
+      assert.deepEqual(refund, { state: 'succeeded', providerRefundId: 'refund-1' });
+      assert.deepEqual(
+        calls.map(item => item.kind),
+        ['getOrder', 'refundCapturedPayment'],
+      );
+      assert.deepEqual(calls[1]?.input, {
+        captureId: 'capture-1',
+        paypalRequestId: 'refund-key',
+        body: {
+          amount: { currencyCode: 'USD', value: '5.00' },
+          customId: '201',
+          invoiceId: 'refund-business-1',
+        },
+      });
+    });
+  });
+});