Merge pull request #40 from moyasar/feat/support-samsung-pay-tokenization

Author: Fghurayri

example/src/App.tsx

@@ -44,6 +44,7 @@ const paymentConfig = new PaymentConfig({
     merchantName: 'Test Samsung Pay from app',
     orderNumber: 'c553ed70-fb79-487c-b3d2-15aca6aff90c',
     manual: false,
+    saveCard: false,
   }),
   applyCoupon: true,
   // splits: [ publishableApiKey for testing: 'pk_test_uQra5pwtUo9GaenMSS4XgfAmeLhmjUTJwFdXJxsH', baseUrl: 'https://apimig.moyasar.com'

src/__tests__/__fixtures__/payment_response_fixture.ts

@@ -87,3 +87,30 @@ export const paymentResponseWithFailedStcFixture = PaymentResponse.fromJson(
   jsonFailed,
   PaymentType.stcPay
 );
+
+export const paymentResponseWithInitSamsungJsonFixture = {
+  ...paymentResponseWithInitJsonFixture,
+  source: {
+    type: 'samsungpay',
+    number: '966500000001',
+    gateway_id: 'samsung_gateway_123',
+    reference_number: 'ref_123',
+    message: 'approved',
+    token: 'samsung_token_123',
+  },
+};
+
+export const paymentResponseWithInitSamsungFixture = PaymentResponse.fromJson(
+  paymentResponseWithInitSamsungJsonFixture,
+  PaymentType.samsungPay
+);
+
+const jsonSamsungPaid = {
+  ...paymentResponseWithInitSamsungJsonFixture,
+  status: 'paid',
+};
+
+export const paymentResponseWithPaidSamsungFixture = PaymentResponse.fromJson(
+  jsonSamsungPaid,
+  PaymentType.samsungPay
+);

src/__tests__/models/payment_response.test.ts

@@ -1,6 +1,7 @@
 import { PaymentResponse } from '../../models/api/api_responses/payment_response';
 import { PaymentType } from '../../models/payment_type';
 import { CreditCardResponseSource } from '../../models/api/sources/credit_card/credit_card_response_source';
+import { SamsungPayPaymentResponseSource } from '../../models/api/sources/samsung_pay/samsung_pay_response_source';
 
 describe('PaymentResponse', () => {
   it('should create a PaymentResponse instance from JSON with credit card source with all params', () => {
@@ -155,6 +156,81 @@ describe('PaymentResponse', () => {
     expect((paymentResponse.source as any).message).toBe(json.source.message);
   });
 
+  it('should create a PaymentResponse instance from JSON with samsung pay source with all params', () => {
+    const json = {
+      id: '123',
+      status: 'paid',
+      amount: 1000,
+      fee: 50,
+      currency: 'SAR',
+      refunded: 0,
+      captured: 1000,
+      captured_at: '2023-01-01T00:00:00Z',
+      voided_at: '2023-01-01T00:00:00Z',
+      description: 'Payment for order #123',
+      amount_format: '10.00',
+      fee_format: '0.50',
+      refunded_format: '0.00',
+      captured_format: '10.00',
+      invoice_id: '123',
+      ip: '8.8.8.8',
+      callback_url: 'https://example.com/callback',
+      created_at: '2023-01-01T00:00:00Z',
+      updated_at: '2023-01-01T00:00:00Z',
+      metadata: { orderId: '12345' },
+      source: {
+        number: '123456',
+        gateway_id: '123',
+        reference_number: '123',
+        message: 'message123',
+        token: 'token123',
+      },
+    };
+
+    const paymentResponse = PaymentResponse.fromJson(
+      json,
+      PaymentType.samsungPay
+    );
+
+    expect(paymentResponse.id).toBe(json.id);
+    expect(paymentResponse.status).toBe(json.status);
+    expect(paymentResponse.amount).toBe(json.amount);
+    expect(paymentResponse.fee).toBe(json.fee);
+    expect(paymentResponse.currency).toBe(json.currency);
+    expect(paymentResponse.refunded).toBe(json.refunded);
+    expect(paymentResponse.captured).toBe(json.captured);
+    expect(paymentResponse.capturedAt).toBe(json.captured_at);
+    expect(paymentResponse.voidedAt).toBe(json.voided_at);
+    expect(paymentResponse.description).toBe(json.description);
+    expect(paymentResponse.amountFormat).toBe(json.amount_format);
+    expect(paymentResponse.feeFormat).toBe(json.fee_format);
+    expect(paymentResponse.refundedFormat).toBe(json.refunded_format);
+    expect(paymentResponse.capturedFormat).toBe(json.captured_format);
+    expect(paymentResponse.invoiceId).toBe(json.invoice_id);
+    expect(paymentResponse.ip).toBe(json.ip);
+    expect(paymentResponse.callbackUrl).toBe(json.callback_url);
+    expect(paymentResponse.createdAt).toBe(json.created_at);
+    expect(paymentResponse.updatedAt).toBe(json.updated_at);
+    expect(paymentResponse.metadata).toEqual(json.metadata);
+
+    expect(
+      (paymentResponse.source as SamsungPayPaymentResponseSource).number
+    ).toBe(json.source.number);
+    expect(
+      (paymentResponse.source as SamsungPayPaymentResponseSource).gatewayId
+    ).toBe(json.source.gateway_id);
+    expect(
+      (paymentResponse.source as SamsungPayPaymentResponseSource)
+        .referenceNumber
+    ).toBe(json.source.reference_number);
+    expect(
+      (paymentResponse.source as SamsungPayPaymentResponseSource).message
+    ).toBe(json.source.message);
+    expect(
+      (paymentResponse.source as SamsungPayPaymentResponseSource).token
+    ).toBe(json.source.token);
+  });
+
   it('should create a PaymentResponse instance from JSON with unknown source with all params', () => {
     const json = {
       id: '123',

src/__tests__/services/samsung_pay.test.ts

@@ -0,0 +1,113 @@
+import { PaymentRequest } from '../../models/api/api_requests/payment_request';
+import { GeneralError, NetworkError } from '../../models/errors/moyasar_errors';
+import { createPayment } from '../../services/payment_service';
+import { SamsungPayRequestSource } from '../../models/api/sources/samsung_pay/samsung_pay_request_source';
+import { onSamsungPayResponse } from '../../views/samsung_pay/samsung_pay';
+import { paymentConfigWithoutSaveOnlyFixture } from '../__fixtures__/payment_config_fixture';
+import { SamsungPayConfig } from '../../models/samsung_pay_config';
+import { paymentResponseWithPaidSamsungFixture } from '../__fixtures__/payment_response_fixture';
+
+jest.mock('../../services/payment_service');
+jest.mock('../../localizations/i18n', () => ({
+  getCurrentLang: jest.fn(() => 'en'),
+}));
+
+describe('onSamsungPayResponse', () => {
+  const mockSamsungPayToken = 'mockSamsungPayToken';
+  const mockOrderNumber = 'order-number-123';
+  const onPaymentResult = jest.fn();
+
+  beforeEach(() => {
+    jest.resetAllMocks();
+  });
+
+  it('should create a payment and call onPaymentResult with the response', async () => {
+    (createPayment as jest.Mock).mockResolvedValue(
+      paymentResponseWithPaidSamsungFixture
+    );
+
+    await onSamsungPayResponse(
+      mockSamsungPayToken,
+      mockOrderNumber,
+      paymentConfigWithoutSaveOnlyFixture,
+      onPaymentResult
+    );
+
+    expect(createPayment).toHaveBeenCalledWith(
+      expect.any(PaymentRequest),
+      paymentConfigWithoutSaveOnlyFixture.publishableApiKey
+    );
+    expect(onPaymentResult).toHaveBeenCalledWith(
+      paymentResponseWithPaidSamsungFixture
+    );
+  });
+
+  it('should pass manual and save_card from samsung config to source payload', async () => {
+    (createPayment as jest.Mock).mockResolvedValue(
+      paymentResponseWithPaidSamsungFixture
+    );
+
+    const configWithSamsungTokenization = {
+      ...paymentConfigWithoutSaveOnlyFixture,
+      samsungPay: new SamsungPayConfig({
+        serviceId: 'ea810dafb758408fa530b1',
+        merchantName: 'Test Samsung',
+        orderNumber: mockOrderNumber,
+        manual: true,
+        saveCard: true,
+      }),
+    };
+
+    await onSamsungPayResponse(
+      mockSamsungPayToken,
+      mockOrderNumber,
+      configWithSamsungTokenization,
+      onPaymentResult
+    );
+
+    const paymentRequest = (createPayment as jest.Mock).mock
+      .calls[0][0] as PaymentRequest;
+    const samsungSource = paymentRequest.source as SamsungPayRequestSource;
+
+    expect(samsungSource.toJson()).toEqual(
+      expect.objectContaining({
+        type: 'samsungpay',
+        token: mockSamsungPayToken,
+        manual: 'true',
+        save_card: true,
+      })
+    );
+    expect(paymentRequest.metadata).toEqual(
+      expect.objectContaining({ samsungpay_order_id: mockOrderNumber })
+    );
+  });
+
+  it('should handle MoyasarError and call onPaymentResult with the error', async () => {
+    const mockError = new GeneralError('Test Error');
+
+    (createPayment as jest.Mock).mockRejectedValue(mockError);
+
+    await onSamsungPayResponse(
+      mockSamsungPayToken,
+      mockOrderNumber,
+      paymentConfigWithoutSaveOnlyFixture,
+      onPaymentResult
+    );
+
+    expect(onPaymentResult).toHaveBeenCalledWith(mockError);
+  });
+
+  it('should handle non-MoyasarError and call onPaymentResult with NetworkError', async () => {
+    const mockError = new Error('Network Error');
+    (createPayment as jest.Mock).mockRejectedValue(mockError);
+
+    await onSamsungPayResponse(
+      mockSamsungPayToken,
+      mockOrderNumber,
+      paymentConfigWithoutSaveOnlyFixture,
+      onPaymentResult
+    );
+
+    expect(onPaymentResult).toHaveBeenCalledWith(expect.any(NetworkError));
+  });
+});

src/models/api/sources/samsung_pay/samsung_pay_request_source.ts

@@ -5,23 +5,28 @@ export class SamsungPayRequestSource implements PaymentRequestSource {
   type: PaymentType = PaymentType.samsungPay;
   samsungPayToken: string;
   manualPayment: string;
+  saveCard?: boolean;
 
   constructor({
     samsungPayToken,
     manualPayment = false,
+    saveCard = false,
   }: {
     samsungPayToken: string;
     manualPayment?: boolean;
+    saveCard?: boolean;
   }) {
     this.samsungPayToken = samsungPayToken;
     this.manualPayment = manualPayment ? 'true' : 'false';
+    this.saveCard = saveCard;
   }
 
   toJson(): Record<string, any> {
     return {
       type: this.type,
       token: this.samsungPayToken,
       manual: this.manualPayment,
+      save_card: this.saveCard,
     };
   }
 }

src/models/api/sources/samsung_pay/samsung_pay_response_source.ts

@@ -7,22 +7,26 @@ export class SamsungPayPaymentResponseSource implements PaymentResponseSource {
   gatewayId: string;
   referenceNumber?: string;
   message?: string;
+  token?: string;
 
   constructor({
     number,
     gatewayId,
     referenceNumber,
     message,
+    token,
   }: {
     number: string;
     gatewayId: string;
     referenceNumber?: string;
     message?: string;
+    token?: string;
   }) {
     this.number = number;
     this.gatewayId = gatewayId;
     this.referenceNumber = referenceNumber;
     this.message = message;
+    this.token = token;
   }
 
   static fromJson(json: Record<string, any>): SamsungPayPaymentResponseSource {
@@ -32,6 +36,7 @@ export class SamsungPayPaymentResponseSource implements PaymentResponseSource {
       gatewayId: json.gateway_id,
       referenceNumber: json.reference_number,
       message: json.message,
+      token: json.token,
     });
   }
 }

src/models/samsung_pay_config.ts

@@ -6,6 +6,7 @@ export class SamsungPayConfig {
   merchantName: string;
   orderNumber?: string | null;
   manual: boolean;
+  saveCard?: boolean;
 
   /**
    * Constructs a new SamsungPayConfig instance with the provided settings.
@@ -20,21 +21,25 @@ export class SamsungPayConfig {
    *   - Recommended format: Use a unique, traceable ID that can be linked to your system
    *   - Note: Make sure to regenerate a new order number for each transaction
    * @param manual - An option to enable the manual auth and capture.
+   * @param saveCard - An option to save (tokenize) the card after a successful payment.
    */
   constructor({
     serviceId,
     merchantName,
     orderNumber,
     manual = false,
+    saveCard = false,
   }: {
     serviceId: string;
     merchantName: string;
     orderNumber?: string | null;
     manual?: boolean;
+    saveCard?: boolean;
   }) {
     this.serviceId = serviceId;
     this.merchantName = merchantName;
     this.orderNumber = orderNumber;
     this.manual = manual;
+    this.saveCard = saveCard;
   }
 }

src/views/samsung_pay/samsung_pay.tsx

@@ -25,6 +25,7 @@ export async function onSamsungPayResponse(
   const source = new SamsungPayRequestSource({
     samsungPayToken: token,
     manualPayment: paymentConfig.samsungPay?.manual,
+    saveCard: paymentConfig.samsungPay?.saveCard,
   });
 
   const paymentRequest = new PaymentRequest({