cabloy 5.1.202 → 5.1.203

package/vona/src/suite/a-commerce/modules/commerce-trade/test/e2eFixture.test.ts

@@ -0,0 +1,434 @@
+import type { EntityOutboxEvent, EntityWebhookInbox } from 'vona-module-a-pay';
+
+import assert from 'node:assert/strict';
+import { describe, it } from 'node:test';
+
+import {
+  createOwnedFixtureName,
+  fixtureAdvancedPaymentAuditMatches,
+  fixtureEventNeedsDispatch,
+  fixtureReservationMatchesLine,
+  isFixtureCustomer,
+  isOwnedFixtureName,
+  selectPaymentFixtureEvent,
+  selectRefundFixtureEvent,
+} from '../src/lib/e2eFixture.ts';
+
+const eventId = 'mock-payment-owned';
+const payment = {
+  eventId,
+  paymentSessionId: 101,
+  businessReference: '201', // Basic points to payment attempt, not the order.
+  providerName: 'pay-mock:mock',
+  state: 'succeeded',
+  providerCaptureId: 'mock-capture-owned',
+  amountMinor: 4599,
+  currency: 'USD',
+} as const;
+const expected = {
+  paymentSessionId: 101,
+  businessReference: '201',
+  amountMinor: 4599,
+  currency: 'USD',
+  clientName: 'default',
+  environment: 'sandbox',
+} as const;
+
+function event(overrides: Record<string, unknown> = {}): EntityOutboxEvent {
+  return {
+    id: 301,
+    paymentSessionId: 101,
+    eventType: 'payment.outcome.v1',
+    payload: payment,
+    state: 'pending',
+    attemptCount: 0,
+    nextAttemptAt: new Date(0),
+    ...overrides,
+  } as EntityOutboxEvent;
+}
+
+function inbox(overrides: Record<string, unknown> = {}): EntityWebhookInbox {
+  return {
+    id: 401,
+    paymentSessionId: 101,
+    providerEventId: eventId,
+    providerName: 'pay-mock:mock',
+    clientName: 'default',
+    environment: 'sandbox',
+    eventType: 'payment.succeeded',
+    paymentState: 'succeeded',
+    amountMinor: 4599,
+    currency: 'USD',
+    providerCaptureId: 'mock-capture-owned',
+    payloadHash: 'a'.repeat(64),
+    state: 'processed',
+    retryCount: 0,
+    processedAt: new Date(),
+    ...overrides,
+  } as EntityWebhookInbox;
+}
+
+function selectPayment(events = [event()], inboxes = [inbox()]) {
+  return selectPaymentFixtureEvent(events, inboxes, expected);
+}
+
+describe('owned Commerce E2E webhook fixture selection', { concurrency: false }, () => {
+  it('requires a generated Admin-owned fixture name and the exact payment attempt relationship', () => {
+    const generatedName = createOwnedFixtureName(123);
+    assert.match(generatedName, /^e2e-fixture-123-[0-9a-f]{12}$/);
+    assert.equal(isOwnedFixtureName(generatedName, 123), true);
+    assert.equal(isOwnedFixtureName(generatedName, 12), false);
+    assert.equal(isOwnedFixtureName('e2e-fixture-123-a1b2c3d4e5f6', 123), true);
+    assert.equal(isOwnedFixtureName('e2e-fixture-123-a1b2c3d4e5f6', 12), false);
+    assert.equal(isOwnedFixtureName('e2e-fixture-123-invalid', 123), false);
+    assert.equal(isFixtureCustomer(undefined), false);
+    assert.equal(
+      isFixtureCustomer({ id: 123, name: 'e2e-fixture-customer', anonymous: true }),
+      false,
+    );
+    assert.equal(isFixtureCustomer({ id: 123, name: 'ordinary', anonymous: false }), false);
+    assert.equal(
+      isFixtureCustomer({ id: 123, name: 'e2e-fixture-customer', anonymous: false }),
+      true,
+    );
+    assert.equal(selectPayment().payload.businessReference, '201');
+    assert.throws(
+      () =>
+        selectPaymentFixtureEvent([event()], [inbox()], {
+          ...expected,
+          businessReference: '202',
+        }),
+      /payload conflicts/,
+    );
+    assert.throws(
+      () => selectPayment([event({ payload: { ...payment, providerName: 'pay-paypal:paypal' } })]),
+      /payload conflicts/,
+    );
+    assert.throws(() => selectPayment([event({ paymentSessionId: 102 })]), /missing or ambiguous/);
+    assert.throws(
+      () => selectPayment([event({ payload: { ...payment, paymentSessionId: 102 } })]),
+      /payload conflicts/,
+    );
+    assert.throws(() => selectPayment([event({ refundOperationId: 501 })]), /missing or ambiguous/);
+  });
+
+  it('rejects missing and ambiguous outbox events or processed inboxes', () => {
+    assert.throws(() => selectPayment([]), /missing or ambiguous/);
+    assert.throws(() => selectPayment([event(), event({ id: 302 })]), /missing or ambiguous/);
+    assert.throws(() => selectPayment([event()], []), /missing or ambiguous/);
+    assert.throws(
+      () => selectPayment([event()], [inbox(), inbox({ id: 402 })]),
+      /missing or ambiguous/,
+    );
+    assert.throws(
+      () => selectPayment([event()], [inbox({ state: 'received' })]),
+      /processed matching/,
+    );
+    assert.throws(
+      () => selectPayment([event()], [inbox({ errorSummary: 'ignored' })]),
+      /processed matching/,
+    );
+    assert.throws(
+      () => selectPayment([event()], [inbox({ providerCaptureId: 'other' })]),
+      /processed matching/,
+    );
+  });
+
+  it('accepts a missing capture for cancelled and failed payments without accepting a conflicting capture', () => {
+    for (const state of ['cancelled', 'failed'] as const) {
+      const outcome = { ...payment, state, providerCaptureId: undefined };
+      const outcomeEvent = event({ payload: outcome });
+      const outcomeInbox = inbox({
+        eventType: `payment.${state}`,
+        paymentState: state,
+        providerCaptureId: null,
+      });
+      assert.equal(selectPayment([outcomeEvent], [outcomeInbox]).payload.state, state);
+      assert.throws(
+        () =>
+          selectPayment([outcomeEvent], [inbox({ ...outcomeInbox, providerCaptureId: 'other' })]),
+        /processed matching/,
+      );
+      assert.throws(
+        () => selectPayment([event({ payload: { ...payment, state } })], [outcomeInbox]),
+        /processed matching/,
+      );
+    }
+  });
+
+  it('requires the refund attempt, mock operation, inbox and outbox to agree', () => {
+    const refund = {
+      eventId: 'mock-refund-owned',
+      paymentSessionId: 101,
+      refundOperationId: 501,
+      businessReference: '601',
+      providerName: 'pay-mock:mock',
+      state: 'cancelled',
+      providerRefundId: 'mock-refund-owned',
+      amountMinor: 4599,
+      currency: 'USD',
+    } as const;
+    const refundEvent = event({
+      eventType: 'refund.outcome.v1',
+      refundOperationId: 501,
+      payload: refund,
+    });
+    const refundInbox = inbox({
+      providerEventId: refund.eventId,
+      eventType: 'refund.cancelled',
+      refundOperationId: 501,
+      refundState: 'cancelled',
+      paymentState: undefined,
+      providerRefundId: refund.providerRefundId,
+    });
+    const select = (events = [refundEvent], inboxes = [refundInbox]) =>
+      selectRefundFixtureEvent(events, inboxes, {
+        ...expected,
+        refundOperationId: 501,
+        businessReference: '601',
+      });
+    assert.equal(select().payload.state, 'cancelled');
+    assert.throws(
+      () => select([event({ ...refundEvent, refundOperationId: 502 })]),
+      /missing or ambiguous/,
+    );
+    assert.throws(
+      () => select([event({ ...refundEvent, payload: { ...refund, refundOperationId: 502 } })]),
+      /payload conflicts/,
+    );
+    assert.throws(
+      () => select([refundEvent], [inbox({ ...refundInbox, refundOperationId: 502 })]),
+      /processed matching/,
+    );
+    assert.throws(
+      () => select([event({ ...refundEvent, payload: { ...refund, businessReference: '602' } })]),
+      /payload conflicts/,
+    );
+    assert.throws(
+      () => select([refundEvent, event({ ...refundEvent, id: 302 })]),
+      /missing or ambiguous/,
+    );
+  });
+
+  it('requires reservation and balance identities before deleting owned stock', () => {
+    const line = { id: 10, skuId: 20, quantity: 1 };
+    const balance = { id: 30, skuId: 20 };
+    const reservation = { orderLineId: 10, skuId: 20, stockBalanceId: 30, quantity: 1 };
+    assert.equal(fixtureReservationMatchesLine(reservation, line, balance), true);
+    for (const mismatch of [
+      { orderLineId: 11 },
+      { skuId: 21 },
+      { stockBalanceId: 31 },
+      { quantity: 2 },
+    ]) {
+      assert.equal(
+        fixtureReservationMatchesLine({ ...reservation, ...mismatch }, line, balance),
+        false,
+      );
+    }
+    assert.equal(fixtureReservationMatchesLine(reservation, line, { id: 30, skuId: 21 }), false);
+  });
+
+  it('accepts only the exact persisted payment-to-shipment or payment-to-refund audit chain', () => {
+    const paid = {
+      id: 10,
+      orderId: 1,
+      operation: 'paid' as const,
+      fromState: 'awaiting_payment' as const,
+      toState: 'paid' as const,
+      correlationId: 'payment-owned',
+    };
+    const shipped = {
+      id: 11,
+      orderId: 1,
+      operation: 'shipped' as const,
+      fromState: 'paid' as const,
+      toState: 'shipped' as const,
+      correlationId: 'shipment-owned',
+    };
+    const requested = {
+      id: 11,
+      orderId: 1,
+      operation: 'refund_requested' as const,
+      fromState: 'paid' as const,
+      toState: 'refund_requested' as const,
+      correlationId: 'request-owned',
+    };
+    const approved = {
+      id: 12,
+      orderId: 1,
+      operation: 'refund_approved' as const,
+      fromState: 'refund_requested' as const,
+      toState: 'refund_approved' as const,
+      correlationId: 'approval-owned',
+    };
+    const refunded = {
+      id: 13,
+      orderId: 1,
+      operation: 'refunded' as const,
+      fromState: 'refund_approved' as const,
+      toState: 'refunded' as const,
+      correlationId: 'refund-owned',
+    };
+    const shippedAudits = [paid, shipped];
+    const refundedAudits = [paid, requested, approved, refunded];
+    assert.equal(
+      fixtureAdvancedPaymentAuditMatches(
+        shippedAudits,
+        1,
+        'shipped',
+        'payment-owned',
+        'shipment-owned',
+      ),
+      true,
+    );
+    assert.equal(
+      fixtureAdvancedPaymentAuditMatches(
+        refundedAudits,
+        1,
+        'refunded',
+        'payment-owned',
+        undefined,
+        'refund-owned',
+      ),
+      true,
+    );
+    assert.equal(
+      fixtureAdvancedPaymentAuditMatches(
+        shippedAudits,
+        2,
+        'shipped',
+        'payment-owned',
+        'shipment-owned',
+      ),
+      false,
+    );
+    assert.equal(
+      fixtureAdvancedPaymentAuditMatches(
+        shippedAudits,
+        1,
+        'shipped',
+        'other-payment',
+        'shipment-owned',
+      ),
+      false,
+    );
+    assert.equal(
+      fixtureAdvancedPaymentAuditMatches(
+        shippedAudits,
+        1,
+        'shipped',
+        'payment-owned',
+        'other-shipment',
+      ),
+      false,
+    );
+    assert.equal(
+      fixtureAdvancedPaymentAuditMatches(
+        refundedAudits,
+        1,
+        'refunded',
+        'payment-owned',
+        undefined,
+        'other-refund',
+      ),
+      false,
+    );
+    assert.equal(
+      fixtureAdvancedPaymentAuditMatches(
+        [paid, { ...requested, fromState: 'awaiting_payment' }, approved, refunded],
+        1,
+        'refunded',
+        'payment-owned',
+        undefined,
+        'refund-owned',
+      ),
+      false,
+    );
+    assert.equal(
+      fixtureAdvancedPaymentAuditMatches(
+        [paid, requested, approved, { ...refunded, orderId: 2 }],
+        1,
+        'refunded',
+        'payment-owned',
+        undefined,
+        'refund-owned',
+      ),
+      false,
+    );
+    assert.equal(
+      fixtureAdvancedPaymentAuditMatches(
+        [paid, requested, approved],
+        1,
+        'refunded',
+        'payment-owned',
+        undefined,
+        'refund-owned',
+      ),
+      false,
+    );
+    assert.equal(
+      fixtureAdvancedPaymentAuditMatches(
+        [paid, shipped, requested],
+        1,
+        'shipped',
+        'payment-owned',
+        'shipment-owned',
+      ),
+      false,
+    );
+  });
+
+  it('allows only first-time eligible dispatch and consistent settled replays', () => {
+    assert.equal(fixtureEventNeedsDispatch(event()), true);
+    assert.equal(
+      fixtureEventNeedsDispatch(
+        event({ state: 'dispatched', dispatchedAt: new Date(), attemptCount: 1 }),
+      ),
+      false,
+    );
+    for (const state of ['claimed', 'failed'] as const) {
+      assert.throws(() => fixtureEventNeedsDispatch(event({ state })), /not eligible/);
+    }
+    assert.throws(
+      () => fixtureEventNeedsDispatch(event({ state: 'pending', attemptCount: 1 })),
+      /not eligible/,
+    );
+    assert.throws(
+      () =>
+        fixtureEventNeedsDispatch(event({ state: 'pending', errorSummary: 'settlement failed' })),
+      /not eligible/,
+    );
+    assert.throws(
+      () => fixtureEventNeedsDispatch(event({ nextAttemptAt: new Date(Date.now() + 60_000) })),
+      /not eligible/,
+    );
+    assert.throws(
+      () => fixtureEventNeedsDispatch(event({ state: 'dispatched' })),
+      /inconsistent dispatched/,
+    );
+    for (const stale of [
+      { claimToken: 'busy' },
+      { claimedAt: new Date() },
+      { claimExpiresAt: new Date() },
+      { errorSummary: 'failure' },
+      { attemptCount: 0 },
+    ]) {
+      assert.throws(
+        () =>
+          fixtureEventNeedsDispatch(
+            event({ state: 'dispatched', dispatchedAt: new Date(), attemptCount: 1, ...stale }),
+          ),
+        /inconsistent dispatched/,
+      );
+    }
+    assert.throws(
+      () => fixtureEventNeedsDispatch(event({ state: 'pending', claimExpiresAt: new Date() })),
+      /not eligible/,
+    );
+    assert.throws(
+      () => fixtureEventNeedsDispatch(event({ state: 'pending', dispatchedAt: new Date() })),
+      /not eligible/,
+    );
+  });
+});