vona-module-test-pay 5.0.1 → 5.0.3

package/package.json

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

package/test/outbox.test.ts

@@ -2,8 +2,8 @@ import type { IPaymentOutcomeEvent } from 'vona-module-a-pay';
 
 import assert from 'node:assert';
 import { randomUUID } from 'node:crypto';
-import { describe, it } from 'node:test';
-import { app } from 'vona-mock';
+import { after, before, describe, it } from 'node:test';
+import { acquireTestLock, app } from 'vona-mock';
 
 interface IFixture {
   userId?: number;
@@ -79,6 +79,16 @@ async function cleanup(fixture: IFixture) {
 }
 
 describe('outbox.test.ts', { concurrency: false }, () => {
+  let releaseTestLock: (() => void) | undefined;
+
+  before(async () => {
+    releaseTestLock = await acquireTestLock('a-pay');
+  });
+
+  after(() => {
+    releaseTestLock?.();
+  });
+
   it('claims, backs off, and exhausts durable delivery attempts', async () => {
     await app.bean.executor.mockCtx(async () => {
       const fixture = await createFixture(randomUUID().slice(0, 12));
@@ -100,7 +110,7 @@ describe('outbox.test.ts', { concurrency: false }, () => {
         assert.ok((persisted?.nextAttemptAt?.getTime() ?? 0) >= releaseStart + 900);
         assert.equal(await scope.service.outbox.claim(event.id), undefined);
         await scope.model.outboxEvent.updateById(event.id, {
-          nextAttemptAt: new Date(Date.now() - 1),
+          nextAttemptAt: new Date(Date.now() - 1_000),
         });
         const second = await scope.service.outbox.claim(event.id);
         assert.equal(second?.attemptCount, 2);
@@ -150,7 +160,7 @@ describe('outbox.test.ts', { concurrency: false }, () => {
         const scope = app.scope('a-pay');
         const first = await scope.service.outbox.claim(event.id);
         await scope.model.outboxEvent.updateById(event.id, {
-          claimExpiresAt: new Date(Date.now() - 1),
+          claimExpiresAt: new Date(Date.now() - 1_000),
         });
         const second = await scope.service.outbox.claim(event.id);
         assert.ok(second?.claimToken);

package/test/payMock.test.ts

@@ -1,7 +1,7 @@
 import assert from 'node:assert';
 import { randomUUID } from 'node:crypto';
-import { describe, it } from 'node:test';
-import { app } from 'vona-mock';
+import { after, before, describe, it } from 'node:test';
+import { acquireTestLock, app } from 'vona-mock';
 
 interface IFixture {
   userId?: number;
@@ -38,7 +38,17 @@ async function cleanup(fixture: IFixture) {
   await app.bean.passport.signout();
 }
 
-describe('payMock.test.ts', { concurrency: false }, () => {
+describe('payMock.test.ts', { concurrency: false, sequential: true }, () => {
+  let releaseTestLock: (() => void) | undefined;
+
+  before(async () => {
+    releaseTestLock = await acquireTestLock('a-pay');
+  });
+
+  after(() => {
+    releaseTestLock?.();
+  });
+
   it('captures Vona env secrets in the mock Provider options', () => {
     const options = app.bean.payProvider.getOptions('pay-mock:mock', 'default');
     assert.equal(options.secretCredential, app.meta.env.PAY_MOCK_DEFAULT_CREDENTIAL);

package/test/paymentSession.test.ts

@@ -1,7 +1,7 @@
 import assert from 'node:assert';
 import { randomUUID } from 'node:crypto';
-import { describe, it } from 'node:test';
-import { app } from 'vona-mock';
+import { after, before, describe, it } from 'node:test';
+import { acquireTestLock, app } from 'vona-mock';
 
 interface IFixture {
   userId?: number;
@@ -27,6 +27,10 @@ async function createFixture(expiresAt: Date): Promise<IFixture> {
 async function cleanup(fixture: IFixture) {
   const scope = app.scope('a-pay');
   if (fixture.paymentSessionId !== undefined) {
+    await scope.model.outboxEvent.delete({ paymentSessionId: fixture.paymentSessionId });
+    await scope.model.webhookInbox.delete({ paymentSessionId: fixture.paymentSessionId });
+    await scope.model.providerOperation.delete({ paymentSessionId: fixture.paymentSessionId });
+    await scope.model.refundOperation.delete({ paymentSessionId: fixture.paymentSessionId });
     await scope.model.paymentAudit.delete({ paymentSessionId: fixture.paymentSessionId });
     await scope.model.paymentSession.delete({ id: fixture.paymentSessionId });
   }
@@ -37,6 +41,16 @@ async function cleanup(fixture: IFixture) {
 }
 
 describe('paymentSession.test.ts', { concurrency: false }, () => {
+  let releaseTestLock: (() => void) | undefined;
+
+  before(async () => {
+    releaseTestLock = await acquireTestLock('a-pay');
+  });
+
+  after(() => {
+    releaseTestLock?.();
+  });
+
   it('derives provider facts and expiry from the payment scene', async () => {
     await app.bean.executor.mockCtx(async () => {
       const scope = app.scope('a-pay');
@@ -65,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');
@@ -102,9 +141,8 @@ describe('paymentSession.test.ts', { concurrency: false }, () => {
         const scope = app.scope('a-pay');
         const session = await scope.service.paymentSession.start(fixture.paymentSessionId!);
         assert.equal(session.state, 'requires_action');
-        await assert.rejects(scope.service.paymentSession.start(fixture.paymentSessionId!), {
-          status: 409,
-        });
+        const replayed = await scope.service.paymentSession.start(fixture.paymentSessionId!);
+        assert.equal(replayed.state, 'requires_action');
       } finally {
         await cleanup(fixture);
       }
@@ -113,7 +151,7 @@ describe('paymentSession.test.ts', { concurrency: false }, () => {
 
   it('does not start an expired payment session', async () => {
     await app.bean.executor.mockCtx(async () => {
-      const fixture = await createFixture(new Date(Date.now() - 1));
+      const fixture = await createFixture(new Date(Date.now() - 1_000));
       try {
         const scope = app.scope('a-pay');
         await assert.rejects(scope.service.paymentSession.start(fixture.paymentSessionId!), {
@@ -129,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));
@@ -142,8 +257,13 @@ describe('paymentSession.test.ts', { concurrency: false }, () => {
           return await app.scope('a-pay').service.paymentSession.start(fixture.paymentSessionId!);
         }),
       ]);
-      assert.equal(results.filter(result => result.status === 'fulfilled').length, 1);
-      assert.equal(results.filter(result => result.status === 'rejected').length, 1);
+      assert.equal(results.filter(result => result.status === 'fulfilled').length, 2);
+      const operations = await app.bean.executor.mockCtx(async () => {
+        return await app.scope('a-pay').model.providerOperation.select({
+          where: { paymentSessionId: fixture.paymentSessionId, kind: 'start' },
+        });
+      });
+      assert.equal(operations.length, 1);
     } finally {
       await app.bean.executor.mockCtx(async () => {
         await cleanup(fixture);

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',
+        },
+      });
+    });
+  });
+});

package/test/webhook.test.ts

@@ -1,7 +1,7 @@
 import assert from 'node:assert';
 import { createHmac, randomUUID } from 'node:crypto';
-import { describe, it } from 'node:test';
-import { app } from 'vona-mock';
+import { after, before, describe, it } from 'node:test';
+import { acquireTestLock, app } from 'vona-mock';
 
 interface IFixture {
   userId?: number;
@@ -100,6 +100,16 @@ async function countFacts(paymentSessionId: number) {
 }
 
 describe('webhook.test.ts', { concurrency: false, sequential: true }, () => {
+  let releaseTestLock: (() => void) | undefined;
+
+  before(async () => {
+    releaseTestLock = await acquireTestLock('a-pay');
+  });
+
+  after(() => {
+    releaseTestLock?.();
+  });
+
   it('accepts a raw-body signed HTTP webhook and rejects an invalid signature without mutation', async () => {
     const fixture: IFixture = {};
     try {