@rnw-community/react-native-payments 0.83.1 → 1.2.0

package/src/class/payment-request/payment-request.spec.ts

@@ -0,0 +1,691 @@
+/* eslint-disable max-lines */
+import { beforeEach, describe, expect, it, jest } from '@jest/globals';
+import { Platform } from 'react-native';
+
+import { IosPKPaymentMethodType } from '../../@standard/ios/enum/ios-pk-payment-method-type.enum';
+import { EnvironmentEnum } from '../../enum/environment.enum';
+import { PaymentMethodNameEnum } from '../../enum/payment-method-name.enum';
+import { PaymentsErrorEnum } from '../../enum/payments-error.enum';
+import { SupportedNetworkEnum } from '../../enum/supported-networks.enum';
+import { ConstructorError } from '../../error/constructor.error';
+import { DOMException } from '../../error/dom.exception';
+import { PaymentsError } from '../../error/payments.error';
+import { NativePayments } from '../native-payments/native-payments';
+
+import { PaymentRequest } from './payment-request';
+
+import type { AndroidPaymentMethodDataInterface } from '../../@standard/android/mapping/android-payment-method-data.interface';
+import type { AndroidPaymentData } from '../../@standard/android/response/android-payment-data';
+import type { IosPaymentMethodDataInterface } from '../../@standard/ios/mapping/ios-payment-method-data.interface';
+import type { IosPKPayment } from '../../@standard/ios/response/ios-pk-payment';
+import type { PaymentDetailsInit } from '../../@standard/w3c/payment-details-init';
+import type { PaymentItem } from '../../@standard/w3c/payment-item';
+import type { PaymentMethodData } from '../../@standard/w3c/payment-method-data';
+
+jest.mock('../native-payments/native-payments', () => ({
+    NativePayments: {
+        canMakePayments: jest.fn(),
+        show: jest.fn(),
+        abort: jest.fn(),
+    },
+}));
+
+jest.mock('react-native', () => ({
+    Platform: {
+        OS: 'android',
+    },
+}));
+
+// eslint-disable-next-line max-lines-per-function
+describe('PaymentRequest', () => {
+    const paymentDetails = {
+        total: {
+            label: 'Total',
+            amount: { currency: 'USD', value: '10.00' },
+        },
+    };
+
+    // eslint-disable-next-line jest/no-hooks
+    beforeEach(() => {
+        jest.clearAllMocks();
+    });
+
+    // eslint-disable-next-line max-lines-per-function
+    describe('validation', () => {
+        const methodData: AndroidPaymentMethodDataInterface = {
+            supportedMethods: PaymentMethodNameEnum.AndroidPay,
+            data: {
+                currencyCode: 'USD',
+                countryCode: 'US',
+                supportedNetworks: [SupportedNetworkEnum.Visa, SupportedNetworkEnum.Mastercard],
+                environment: EnvironmentEnum.TEST,
+                gatewayConfig: {
+                    gateway: 'exampleGateway',
+                    gatewayMerchantId: 'exampleMerchantId',
+                },
+            },
+        };
+
+        it('should throw when payment methods not passed', () => {
+            expect.assertions(2);
+
+            expect(() => new PaymentRequest([], {} as unknown as PaymentDetailsInit)).toThrow(
+                new PaymentsError(`Failed to construct 'PaymentRequest':  At least one payment method is required`)
+            );
+
+            expect(() => new PaymentRequest(undefined as unknown as PaymentMethodData[], paymentDetails)).toThrow(
+                new PaymentsError(`Failed to construct 'PaymentRequest':  At least one payment method is required`)
+            );
+        });
+
+        it('should throw when payment methods supportedMethods not passed', () => {
+            expect.assertions(2);
+
+            expect(
+                () => new PaymentRequest([{ supportedMethods: undefined } as unknown as PaymentMethodData], paymentDetails)
+            ).toThrow(
+                new PaymentsError(`Failed to construct 'PaymentRequest':  required member supportedMethods is undefined.`)
+            );
+
+            expect(() => new PaymentRequest([{} as unknown as PaymentMethodData], paymentDetails)).toThrow(
+                new PaymentsError(`Failed to construct 'PaymentRequest':  required member supportedMethods is undefined.`)
+            );
+        });
+
+        describe(`payment details total`, () => {
+            it('should throw when total is not defined', () => {
+                expect.assertions(1);
+
+                const invalidPaymentDetails = {} as unknown as PaymentDetailsInit;
+
+                expect(() => new PaymentRequest([methodData], invalidPaymentDetails)).toThrow(
+                    new PaymentsError(`Failed to construct 'PaymentRequest':  required member total is undefined.`)
+                );
+            });
+
+            it('should throw when total.amount is not defined', () => {
+                expect.assertions(1);
+
+                const invalidPaymentDetails = {
+                    total: {
+                        label: 'Total',
+                    },
+                } as unknown as PaymentDetailsInit;
+
+                expect(() => new PaymentRequest([methodData], invalidPaymentDetails)).toThrow(
+                    new PaymentsError(`Failed to construct 'PaymentRequest':  Missing required member(s): amount, label.`)
+                );
+            });
+
+            it('should throw when total.amount.value is not defined', () => {
+                expect.assertions(1);
+
+                const invalidPaymentDetails = {
+                    total: {
+                        label: 'Total',
+                        amount: {},
+                    },
+                } as unknown as PaymentDetailsInit;
+
+                expect(() => new PaymentRequest([methodData], invalidPaymentDetails)).toThrow(
+                    new PaymentsError(`Failed to construct 'PaymentRequest':  Missing required member(s): amount, label.`)
+                );
+            });
+
+            it('should throw when total.amount.value is not monetary', () => {
+                expect.assertions(1);
+
+                const invalidPaymentDetails = {
+                    total: {
+                        label: 'Total',
+                        amount: {
+                            currency: 'USD',
+                            value: true,
+                        },
+                    },
+                } as unknown as PaymentDetailsInit;
+
+                expect(() => new PaymentRequest([methodData], invalidPaymentDetails)).toThrow(
+                    new PaymentsError(`Failed to construct 'PaymentRequest':  'true' is not a valid amount format for total`)
+                );
+            });
+
+            it('should throw when total.amount.value is negative', () => {
+                expect.assertions(1);
+
+                const invalidPaymentDetails = {
+                    total: {
+                        label: 'Total',
+                        amount: {
+                            currency: 'USD',
+                            value: '-10.00',
+                        },
+                    },
+                };
+
+                expect(() => new PaymentRequest([methodData], invalidPaymentDetails)).toThrow(
+                    new PaymentsError(`Failed to construct 'PaymentRequest':  Total amount value should be non-negative`)
+                );
+            });
+
+            it('should throw when total.amount.value ends with dot', () => {
+                expect.assertions(1);
+
+                const invalidPaymentDetails = {
+                    total: {
+                        label: 'Total',
+                        amount: {
+                            currency: 'USD',
+                            value: '10.00.',
+                        },
+                    },
+                };
+
+                expect(() => new PaymentRequest([methodData], invalidPaymentDetails)).toThrow(
+                    new PaymentsError(
+                        `Failed to construct 'PaymentRequest':  '10.00.' is not a valid amount format for total`
+                    )
+                );
+            });
+        });
+
+        describe(`payment details displayItems`, () => {
+            const paymentDetailsWithTotal: PaymentDetailsInit = {
+                total: {
+                    label: 'Total',
+                    amount: {
+                        currency: 'USD',
+                        value: '10.00',
+                    },
+                },
+            };
+
+            it('should NOT throw when displayItems is not defined or empty', () => {
+                expect.assertions(2);
+
+                expect(() => new PaymentRequest([methodData], paymentDetailsWithTotal)).not.toThrow();
+                expect(
+                    () => new PaymentRequest([methodData], { ...paymentDetailsWithTotal, displayItems: [] })
+                ).not.toThrow();
+            });
+
+            it('should throw when displayItems item has in proper shape', () => {
+                expect.assertions(3);
+
+                expect(
+                    () =>
+                        new PaymentRequest([methodData], {
+                            ...paymentDetailsWithTotal,
+                            displayItems: [undefined as unknown as PaymentItem],
+                        })
+                ).toThrow(new ConstructorError(`required member value is undefined.`));
+
+                expect(
+                    () =>
+                        new PaymentRequest([methodData], {
+                            ...paymentDetailsWithTotal,
+                            displayItems: [{} as unknown as PaymentItem],
+                        })
+                ).toThrow(new ConstructorError(`required member value is undefined.`));
+
+                expect(
+                    () =>
+                        new PaymentRequest([methodData], {
+                            ...paymentDetailsWithTotal,
+                            displayItems: [{ amount: {} } as unknown as PaymentItem],
+                        })
+                ).toThrow(new ConstructorError(`required member value is undefined.`));
+            });
+
+            it('should throw when displayItems item.amount.value is not monetary', () => {
+                expect.assertions(1);
+
+                expect(
+                    () =>
+                        new PaymentRequest([methodData], {
+                            ...paymentDetailsWithTotal,
+                            displayItems: [{ amount: { currency: 'USD', value: true } } as unknown as PaymentItem],
+                        })
+                ).toThrow(new ConstructorError(`'true' is not a valid amount format for display items`));
+            });
+        });
+    });
+
+    // eslint-disable-next-line max-lines-per-function,max-statements
+    describe('PaymentRequest on Android', () => {
+        const androidMethodData: AndroidPaymentMethodDataInterface = {
+            supportedMethods: PaymentMethodNameEnum.AndroidPay,
+            data: {
+                currencyCode: 'USD',
+                countryCode: 'US',
+                supportedNetworks: [SupportedNetworkEnum.Visa, SupportedNetworkEnum.Mastercard],
+                environment: EnvironmentEnum.TEST,
+                gatewayConfig: {
+                    gateway: 'exampleGateway',
+                    gatewayMerchantId: 'exampleMerchantId',
+                },
+            },
+        };
+
+        // eslint-disable-next-line jest/no-hooks
+        beforeEach(() => {
+            Platform.OS = 'android';
+        });
+
+        it('should initialize with the correct id', () => {
+            expect.assertions(2);
+
+            const request = new PaymentRequest([androidMethodData], paymentDetails);
+
+            expect(request.id).toBeDefined();
+            expect(request.state).toBe('created');
+        });
+
+        it('should throw when `canMakePayment` is called in invalid state', async () => {
+            expect.assertions(1);
+
+            const request = new PaymentRequest([androidMethodData], paymentDetails);
+            request.state = 'closed';
+
+            await expect(request.canMakePayment()).rejects.toThrow(new DOMException(PaymentsErrorEnum.InvalidStateError));
+        });
+
+        it('should throw when NativePayments.show rejects', async () => {
+            expect.assertions(2);
+
+            const request = new PaymentRequest([androidMethodData], paymentDetails);
+            request.state = 'created';
+            jest.mocked(NativePayments.show).mockRejectedValue(new DOMException(PaymentsErrorEnum.NotAllowedError));
+
+            await expect(request.show()).rejects.toThrow(new DOMException(PaymentsErrorEnum.NotAllowedError));
+            expect(NativePayments.show).toHaveBeenCalledWith(expect.any(String), expect.any(Object));
+        });
+
+        it('should return true from `canMakePayment` when valid', async () => {
+            expect.assertions(2);
+
+            const request = new PaymentRequest([androidMethodData], paymentDetails);
+            jest.mocked(NativePayments.canMakePayments).mockResolvedValue(true);
+
+            const result = await request.canMakePayment();
+
+            expect(NativePayments.canMakePayments).toHaveBeenCalledWith(expect.any(String));
+            expect(result).toBe(true);
+        });
+
+        it('should throw when `show` is called in invalid state', async () => {
+            expect.assertions(1);
+
+            const request = new PaymentRequest([androidMethodData], paymentDetails);
+            request.state = 'closed';
+
+            await expect(request.show()).rejects.toThrow(new DOMException(PaymentsErrorEnum.InvalidStateError));
+        });
+
+        it(`should handle 'examplePaymentMethodToken' tokenization type`, async () => {
+            expect.assertions(3);
+
+            jest.mocked(NativePayments.show).mockResolvedValue(
+                JSON.stringify({
+                    apiVersion: 2,
+                    apiVersionMinor: 0,
+                    email: 'test@example.com',
+                    paymentMethodData: {
+                        info: {},
+                        tokenizationData: {
+                            type: 'PAYMENT_GATEWAY',
+                            token: 'examplePaymentMethodToken',
+                        },
+                    },
+                })
+            );
+
+            const request = new PaymentRequest([androidMethodData], paymentDetails);
+            request.state = 'created';
+            const result = await request.show();
+
+            expect(NativePayments.show).toHaveBeenCalledWith(expect.any(String), expect.any(Object));
+            expect(result).toBeDefined();
+            expect(request.state).toBe('interactive');
+        });
+
+        it('should throw when `NativePayments.show` returns invalid data', async () => {
+            expect.assertions(1);
+
+            jest.mocked(NativePayments.show).mockResolvedValue(`...`);
+            const expectedError = new PaymentsError(`Failed parsing PaymentRequest details`);
+
+            const request = new PaymentRequest([androidMethodData], paymentDetails);
+            request.state = 'created';
+
+            await expect(request.show()).rejects.toThrow(expectedError);
+        });
+
+        it('should call NativePayments.show and resolve correctly', async () => {
+            expect.assertions(3);
+
+            const request = new PaymentRequest([androidMethodData], paymentDetails);
+            request.state = 'created';
+            jest.mocked(NativePayments.show).mockResolvedValue(
+                JSON.stringify({
+                    apiVersion: 2,
+                    apiVersionMinor: 0,
+                    email: 'test@example.com',
+                    paymentMethodData: {
+                        info: {
+                            billingAddress: {
+                                countryCode: 'US',
+                                name: 'John Doe',
+                                phoneNumber: '+1234567890',
+                                postalCode: '12345',
+                                address1: '123 Main St',
+                                address2: 'Suite 1',
+                                address3: 'Building B',
+                                administrativeArea: 'CA',
+                                locality: 'Mountain View',
+                                sortingCode: '123',
+                            },
+                            cardDetails: '1234',
+                            cardNetwork: 'VISA',
+                            assuranceDetails: {
+                                accountVerified: true,
+                                cardHolderAuthenticated: true,
+                            },
+                        },
+                        tokenizationData: {
+                            type: 'PAYMENT_GATEWAY',
+                            token: JSON.stringify({
+                                protocolVersion: 'ECv2',
+                                signature: 'testSignature',
+                                signedMessage: JSON.stringify({
+                                    encryptedMessage: 'testEncryptedMessage',
+                                    ephemeralPublicKey: 'testEphemeralPublicKey',
+                                    tag: 'testTag',
+                                }),
+                                intermediateSigningKey: {
+                                    signatures: ['testSignature'],
+                                    signedKey: JSON.stringify({
+                                        keyExpiration: '2024-01-01T00:00:00.000Z',
+                                        keyValue: 'testKeyValue',
+                                    }),
+                                },
+                            }),
+                        },
+                    },
+                    shippingAddress: {
+                        countryCode: 'US',
+                        name: 'Jane Doe',
+                        phoneNumber: '+9876543210',
+                        postalCode: '54321',
+                        address1: '456 Elm St',
+                        address2: 'Apt 2',
+                        address3: '',
+                        administrativeArea: 'NY',
+                        locality: 'New York',
+                        sortingCode: '',
+                    },
+                } as AndroidPaymentData)
+            );
+
+            const result = await request.show();
+
+            expect(NativePayments.show).toHaveBeenCalledWith(expect.any(String), expect.any(Object));
+            expect(result).toBeDefined();
+            expect(request.state).toBe('interactive');
+        });
+
+        it('should throw when `abort` is called in invalid state', async () => {
+            expect.assertions(1);
+
+            const request = new PaymentRequest([androidMethodData], paymentDetails);
+
+            await expect(request.abort()).rejects.toThrow(new DOMException(PaymentsErrorEnum.InvalidStateError));
+        });
+
+        it('should throw when `NativePayments.abort` rejects', async () => {
+            expect.assertions(1);
+
+            const expectedError = new PaymentsError(`Failed aborting PaymentRequest`);
+            jest.mocked(NativePayments.abort).mockRejectedValue(expectedError);
+
+            const request = new PaymentRequest([androidMethodData], paymentDetails);
+            request.state = 'interactive';
+
+            await expect(request.abort()).rejects.toThrow(expectedError);
+        });
+
+        it('should call NativePayments.abort and reject correctly when aborted', async () => {
+            expect.assertions(2);
+
+            const request = new PaymentRequest([androidMethodData], paymentDetails);
+            request.state = 'interactive';
+            jest.mocked(NativePayments.abort).mockResolvedValue(undefined);
+
+            await request.abort();
+
+            expect(NativePayments.abort).toHaveBeenCalledWith();
+            expect(request.state).toBe('closed');
+        });
+
+        it('should throw NotSupportedError if platform payment method is not found', () => {
+            expect.assertions(1);
+
+            const invalidMethodData = [
+                {
+                    supportedMethods: 'unsupported-method',
+                    data: {},
+                },
+            ] as unknown as PaymentMethodData[];
+
+            expect(() => new PaymentRequest(invalidMethodData, paymentDetails)).toThrow(
+                new DOMException(PaymentsErrorEnum.NotSupportedError)
+            );
+        });
+    });
+
+    // eslint-disable-next-line max-lines-per-function,max-statements
+    describe('PaymentRequest on iOS', () => {
+        const iosMethodData: IosPaymentMethodDataInterface = {
+            supportedMethods: PaymentMethodNameEnum.ApplePay,
+            data: {
+                requestBillingAddress: true,
+                requestPayerEmail: true,
+                requestPayerName: true,
+                requestPayerPhone: true,
+                requestShipping: true,
+                currencyCode: 'USD',
+                countryCode: 'US',
+                merchantIdentifier: 'merchant.com.example',
+                supportedNetworks: [SupportedNetworkEnum.Visa, SupportedNetworkEnum.Mastercard],
+            },
+        };
+
+        // eslint-disable-next-line jest/no-hooks
+        beforeEach(() => {
+            Platform.OS = 'ios';
+        });
+
+        it('should initialize with the correct id', () => {
+            expect.assertions(2);
+
+            const request = new PaymentRequest([iosMethodData], paymentDetails);
+
+            expect(request.id).toBeDefined();
+            expect(request.state).toBe('created');
+        });
+
+        it('should throw when `canMakePayment` is called in invalid state', async () => {
+            expect.assertions(1);
+
+            const request = new PaymentRequest([iosMethodData], paymentDetails);
+            request.state = 'closed';
+
+            await expect(request.canMakePayment()).rejects.toThrow(new DOMException(PaymentsErrorEnum.InvalidStateError));
+        });
+
+        it('should return true from `canMakePayment` when valid', async () => {
+            expect.assertions(2);
+
+            const request = new PaymentRequest([iosMethodData], paymentDetails);
+            jest.mocked(NativePayments.canMakePayments).mockResolvedValue(true);
+
+            const result = await request.canMakePayment();
+
+            expect(NativePayments.canMakePayments).toHaveBeenCalledWith(expect.any(String));
+            expect(result).toBe(true);
+        });
+
+        it('should throw when `show` is called in invalid state', async () => {
+            expect.assertions(1);
+
+            const request = new PaymentRequest([iosMethodData], paymentDetails);
+            request.state = 'closed';
+
+            await expect(request.show()).rejects.toThrow(new DOMException(PaymentsErrorEnum.InvalidStateError));
+        });
+
+        it('should throw when NativePayments.show rejects', async () => {
+            expect.assertions(2);
+
+            const request = new PaymentRequest([iosMethodData], paymentDetails);
+            request.state = 'created';
+            jest.mocked(NativePayments.show).mockRejectedValue(new DOMException(PaymentsErrorEnum.NotAllowedError));
+
+            await expect(request.show()).rejects.toThrow(new DOMException(PaymentsErrorEnum.NotAllowedError));
+            expect(NativePayments.show).toHaveBeenCalledWith(expect.any(String), expect.any(Object));
+        });
+
+        it('should throw when `NativePayments.show` returns invalid data', async () => {
+            expect.assertions(1);
+
+            jest.mocked(NativePayments.show).mockResolvedValue(`...`);
+            const expectedError = new PaymentsError(`Failed parsing PaymentRequest details`);
+
+            const request = new PaymentRequest([iosMethodData], paymentDetails);
+            request.state = 'created';
+
+            await expect(request.show()).rejects.toThrow(expectedError);
+        });
+
+        it('should call NativePayments.show and resolve correctly', async () => {
+            expect.assertions(3);
+
+            const request = new PaymentRequest([iosMethodData], paymentDetails);
+            request.state = 'created';
+            jest.mocked(NativePayments.show).mockResolvedValue(
+                JSON.stringify({
+                    billingContact: {
+                        postalAddress: {
+                            street: '1 Infinite Loop',
+                            city: 'Cupertino',
+                            state: 'CA',
+                            postalCode: '95014',
+                            country: 'USA',
+                            ISOCountryCode: 'US',
+                            subAdministrativeArea: '',
+                            subLocality: '',
+                        },
+                    },
+                    shippingContact: {
+                        name: {
+                            givenName: 'John',
+                            familyName: 'Doe',
+                            middleName: '',
+                            namePrefix: '',
+                            nameSuffix: '',
+                            nickname: '',
+                        },
+                        emailAddress: 'johndoe@example.com',
+                        phoneNumber: { stringValue: '+1-555-555-5555' },
+                        postalAddress: {
+                            street: '1 Infinite Loop',
+                            city: 'Cupertino',
+                            state: 'CA',
+                            postalCode: '95014',
+                            country: 'USA',
+                            ISOCountryCode: 'US',
+                            subAdministrativeArea: '',
+                            subLocality: '',
+                        },
+                    },
+                    shippingMethod: {
+                        identifier: 'standard',
+                        detail: 'Standard Shipping (3-5 business days)',
+                    },
+                    token: {
+                        paymentData: JSON.stringify({
+                            version: 'EC_v1',
+                            data: 'enHx9XCGOPE...',
+                            signature: 'abcd1234...',
+                            header: {
+                                ephemeralPublicKey: 'AbCdEf...',
+                                publicKeyHash: 'gHiJkL...',
+                                transactionId: 'txn01',
+                            },
+                        }),
+                        paymentMethod: {
+                            displayName: 'Visa',
+                            network: 'Visa',
+                            type: IosPKPaymentMethodType.PKPaymentMethodTypeDebit,
+                        },
+                        transactionIdentifier: 'txn123456789',
+                    },
+                } as IosPKPayment)
+            );
+
+            const result = await request.show();
+
+            expect(NativePayments.show).toHaveBeenCalledWith(expect.any(String), expect.any(Object));
+            expect(result).toBeDefined();
+            expect(request.state).toBe('interactive');
+        });
+
+        it('should throw when `abort` is called in invalid state', async () => {
+            expect.assertions(1);
+
+            const request = new PaymentRequest([iosMethodData], paymentDetails);
+
+            await expect(request.abort()).rejects.toThrow(new DOMException(PaymentsErrorEnum.InvalidStateError));
+        });
+
+        it('should throw when `NativePayments.abort` rejects', async () => {
+            expect.assertions(1);
+
+            const expectedError = new PaymentsError(`Failed aborting PaymentRequest`);
+            jest.mocked(NativePayments.abort).mockRejectedValue(expectedError);
+
+            const request = new PaymentRequest([iosMethodData], paymentDetails);
+            request.state = 'interactive';
+
+            await expect(request.abort()).rejects.toThrow(expectedError);
+        });
+
+        it('should call NativePayments.abort and reject correctly when aborted', async () => {
+            expect.assertions(2);
+
+            const request = new PaymentRequest([iosMethodData], paymentDetails);
+            request.state = 'interactive';
+            jest.mocked(NativePayments.abort).mockResolvedValue(undefined);
+
+            await request.abort();
+
+            expect(NativePayments.abort).toHaveBeenCalledWith();
+            expect(request.state).toBe('closed');
+        });
+
+        it('should throw NotSupportedError if platform payment method is not found', () => {
+            expect.assertions(1);
+
+            const invalidMethodData = [
+                {
+                    supportedMethods: 'unsupported-method',
+                    data: {},
+                },
+            ] as unknown as PaymentMethodData[];
+
+            expect(() => new PaymentRequest(invalidMethodData, paymentDetails)).toThrow(
+                new DOMException(PaymentsErrorEnum.NotSupportedError)
+            );
+        });
+    });
+});