راهبرد سندباکس و تست

import { describe, it, expect } from 'vitest';
import { UnoPay, ZarinpalAdapter, GatewayProviderError,
  PaymentValidationError, toRials } from 'unopay';

describe('sandbox integration', () => {
  const unopay = new UnoPay({
    zarinpal: new ZarinpalAdapter({ merchantId: 'sandbox-merchant', sandbox: true }),
  });

  it('normalises Toman to Rials', () => {
    expect(toRials(50_000, 'IRT')).toBe(500_000);
    expect(toRials(500_000, 'IRR')).toBe(500_000);
    // a typo is silently IRR — assert the behaviour you actually get
    expect(toRials(50_000, 'TOMN')).toBe(50_000);
  });

  it('creates a payment against the sandbox', async () => {
    const payment = await unopay.createPayment('zarinpal', {
      amount: 1000,
      currency: 'IRT',
      callbackUrl: 'https://example.com/callback',
    });

    expect(payment.redirectUrl).toContain('sandbox.zarinpal.com');
    expect(payment.transactionId.startsWith('S')).toBe(true);
    expect(payment.providerToken).toBe(payment.transactionId);
  });

  it('rejects a callback with no Authority before any network call', async () => {
    await expect(
      unopay.verifyCallback('zarinpal', { method: 'GET', query: {}, body: {} }),
    ).rejects.toBeInstanceOf(PaymentValidationError);
  });

  it('surfaces a gateway rejection as GatewayProviderError', async () => {
    await expect(
      unopay.createPayment('zarinpal', {
        amount: 1000,
        currency: 'IRT',
        callbackUrl: 'https://example.com/callback',
        metadata: { description: 'x'.repeat(300) }, // over the gateway limit
      }),
    ).rejects.toBeInstanceOf(GatewayProviderError);
  });
});

import {
  UnoPay, PaymentError, GatewayNetworkError,
  type GatewayAdapter, type PaymentRequest, type PaymentResult,
  type CallbackRequest, type VerificationResult,
} from 'unopay';

// Scripted outcomes so you can exercise every branch without a gateway.
export function makeStub(outcome: 'paid' | 'declined' | 'fault'): GatewayAdapter {
  return {
    async createPayment(req: PaymentRequest): Promise<PaymentResult> {
      if (outcome === 'fault') throw new GatewayNetworkError('stub network failure');
      return {
        redirectUrl: 'https://stub.test/start/STUB-1',
        transactionId: 'STUB-1',
        providerToken: 'STUB-1',
      };
    },
    async verifyCallback(req: CallbackRequest): Promise<VerificationResult> {
      if (outcome === 'fault') throw new GatewayNetworkError('stub network failure');
      const ok = outcome === 'paid';
      return {
        isSuccessful: ok,
        transactionId: ok ? 'REF-1' : req.query.Authority ?? 'unknown',
        settledAmount: Number(req.query.amount ?? 0),
        errorReason: ok ? undefined : 'stubbed decline',
      };
    },
  };
}

// Your handler code is unchanged — only the adapter differs.
export const stubbed = new UnoPay({ gateway: makeStub('paid') });
// stubbed.createPayment('gateway', …)   // 'gateway' is the only legal key