pcp-server-nodejs-sdk/dist/endpoints/PaymentExecutionApiClient.test.js

[](https://sonarcloud.io/summary/new_code?id=PAYONE-GmbH_PCP-server-nodeJS-SDK) [![Coverage](https://sonarcloud.io/api/pr

var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
    return new (P || (P = Promise))(function (resolve, reject) {
        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
        step((generator = generator.apply(thisArg, _arguments || [])).next());
    });
};
import fetch from 'node-fetch';
import { beforeEach, describe, expect, test, vi } from 'vitest';
import { CommunicatorConfiguration } from '../CommunicatorConfiguration.js';
import { ApiErrorResponseException } from '../errors/ApiErrorResponseException.js';
import { ApiResponseRetrievalException } from '../errors/ApiResponseRetrievalException.js';
import { ActionType } from '../models/ActionType.js';
import { CancellationReason, RefreshType, StatusValue, } from '../models/index.js';
import { createEmptyErrorResponseMock, createResponseMock } from '../testutils/mock-response.js';
import { PaymentExecutionApiClient } from './PaymentExecutionApiClient.js';
vi.mock('node-fetch', (importOriginal) => __awaiter(void 0, void 0, void 0, function* () {
    return Object.assign(Object.assign({}, (yield importOriginal())), { default: vi.fn() });
}));
const mockedFetch = vi.mocked(fetch, true);
describe('PaymentExecutionApiClient', () => {
    let paymentExecutionApiClient;
    beforeEach(() => {
        paymentExecutionApiClient = new PaymentExecutionApiClient(new CommunicatorConfiguration('apiKey', 'apiSecret', 'https://test.com'));
    });
    describe('createPayment', () => {
        test('given request was successful, should return response', () => __awaiter(void 0, void 0, void 0, function* () {
            const expectedResponse = {};
            mockedFetch.mockResolvedValueOnce(createResponseMock(200, expectedResponse));
            const payload = {
                paymentExecutionSpecificInput: {
                    paymentReferences: { merchantReference: 'invoice-123' },
                    amountOfMoney: { amount: 3720, currencyCode: 'EUR' },
                },
            };
            const res = yield paymentExecutionApiClient.createPayment('merchantId', 'commerceCaseId', 'checkoutId', payload);
            expect(res).toEqual(expectedResponse);
        }));
        test('given request was not successful (400), then return errorresponse', () => __awaiter(void 0, void 0, void 0, function* () {
            const expectedResponse = { errorId: 'error-id' };
            mockedFetch.mockResolvedValueOnce(createResponseMock(400, expectedResponse));
            expect.assertions(1);
            try {
                yield paymentExecutionApiClient.createPayment('merchantId', 'commerceCaseId', 'checkoutId', {});
            }
            catch (error) {
                expect(error).toEqual(new ApiErrorResponseException(400, JSON.stringify(expectedResponse)));
            }
        }));
        test('given request was not successful (500), throw ApiResponseRetrievalException', () => __awaiter(void 0, void 0, void 0, function* () {
            mockedFetch.mockResolvedValueOnce(createEmptyErrorResponseMock(500));
            expect.assertions(1);
            try {
                yield paymentExecutionApiClient.createPayment('merchantId', 'commerceCaseId', 'checkoutId', {});
            }
            catch (error) {
                expect(error).toEqual(new ApiResponseRetrievalException(500, ''));
            }
        }));
        test('a required param is empty, throw an error', () => __awaiter(void 0, void 0, void 0, function* () {
            yield expect(() => paymentExecutionApiClient.createPayment('', 'commerceCaseId', 'checkoutId', {})).rejects.toThrowError('Merchant ID is required');
            yield expect(() => paymentExecutionApiClient.createPayment('merchantId', '', 'checkoutId', {})).rejects.toThrowError('Commerce Case ID is required');
            yield expect(() => paymentExecutionApiClient.createPayment('merchantId', 'commerceCaseId', '', {})).rejects.toThrowError('Checkout ID is required');
        }));
    });
    describe('capturePayment', () => {
        test('given request was successful, should return response', () => __awaiter(void 0, void 0, void 0, function* () {
            const expectedResponse = {};
            mockedFetch.mockResolvedValueOnce(createResponseMock(200, expectedResponse));
            const payload = {
                isFinal: true,
                delivery: {
                    items: [],
                },
            };
            const res = yield paymentExecutionApiClient.capturePayment('merchantId', 'commerceCaseId', 'checkoutId', 'paymentId', payload);
            expect(res).toEqual(expectedResponse);
        }));
        test('given request was not successful (400), then return errorresponse', () => __awaiter(void 0, void 0, void 0, function* () {
            const expectedResponse = { errorId: 'error-id' };
            mockedFetch.mockResolvedValueOnce(createResponseMock(400, expectedResponse));
            expect.assertions(1);
            try {
                yield paymentExecutionApiClient.capturePayment('merchantId', 'commerceCaseId', 'checkoutId', 'paymentId', {
                    isFinal: false,
                });
            }
            catch (error) {
                expect(error).toEqual(new ApiErrorResponseException(400, JSON.stringify(expectedResponse)));
            }
        }));
        test('given request was not successful (500), throw ApiResponseRetrievalException', () => __awaiter(void 0, void 0, void 0, function* () {
            mockedFetch.mockResolvedValueOnce(createEmptyErrorResponseMock(500));
            expect.assertions(1);
            try {
                yield paymentExecutionApiClient.capturePayment('merchantId', 'commerceCaseId', 'checkoutId', 'paymentId', {
                    isFinal: false,
                });
            }
            catch (error) {
                expect(error).toEqual(new ApiResponseRetrievalException(500, ''));
            }
        }));
        test('a required param is empty, throw an error', () => __awaiter(void 0, void 0, void 0, function* () {
            yield expect(() => paymentExecutionApiClient.capturePayment('', 'commerceCaseId', 'checkoutId', 'paymentId', { isFinal: false })).rejects.toThrowError('Merchant ID is required');
            yield expect(() => paymentExecutionApiClient.capturePayment('merchantId', '', 'checkoutId', 'paymentId', { isFinal: false })).rejects.toThrowError('Commerce Case ID is required');
            yield expect(() => paymentExecutionApiClient.capturePayment('merchantId', 'commerceCaseId', '', 'paymentId', { isFinal: false })).rejects.toThrowError('Checkout ID is required');
            yield expect(() => paymentExecutionApiClient.capturePayment('merchantId', 'commerceCaseId', 'checkoutId', '', { isFinal: false })).rejects.toThrowError('Payment Execution ID is required');
        }));
    });
    describe('cancelPayment', () => {
        test('given request was successful, should return response', () => __awaiter(void 0, void 0, void 0, function* () {
            const expectedResponse = {
                payment: {
                    status: StatusValue.Cancelled,
                    statusOutput: {
                        isCancellable: false,
                        isRefundable: false,
                    },
                },
            };
            mockedFetch.mockResolvedValueOnce(createResponseMock(200, expectedResponse));
            const payload = {
                cancellationReason: CancellationReason.CONSUMER_REQUEST,
            };
            const res = yield paymentExecutionApiClient.cancelPayment('merchantId', 'commerceCaseId', 'checkoutId', 'paymentId', payload);
            expect(res).toEqual(expectedResponse);
        }));
        test('given request was not successful (400), then return errorresponse', () => __awaiter(void 0, void 0, void 0, function* () {
            const expectedResponse = { errorId: 'error-id' };
            mockedFetch.mockResolvedValueOnce(createResponseMock(400, expectedResponse));
            expect.assertions(1);
            try {
                yield paymentExecutionApiClient.cancelPayment('merchantId', 'commerceCaseId', 'checkoutId', 'paymentId', {});
            }
            catch (error) {
                expect(error).toEqual(new ApiErrorResponseException(400, JSON.stringify(expectedResponse)));
            }
        }));
        test('given request was not successful (500), throw ApiResponseRetrievalException', () => __awaiter(void 0, void 0, void 0, function* () {
            mockedFetch.mockResolvedValueOnce(createEmptyErrorResponseMock(500));
            expect.assertions(1);
            try {
                yield paymentExecutionApiClient.cancelPayment('merchantId', 'commerceCaseId', 'checkoutId', 'paymentId', {});
            }
            catch (error) {
                expect(error).toEqual(new ApiResponseRetrievalException(500, ''));
            }
        }));
        test('a required param is empty, throw an error', () => __awaiter(void 0, void 0, void 0, function* () {
            yield expect(() => paymentExecutionApiClient.cancelPayment('', 'commerceCaseId', 'checkoutId', 'paymentId', {})).rejects.toThrowError('Merchant ID is required');
            yield expect(() => paymentExecutionApiClient.cancelPayment('merchantId', '', 'checkoutId', 'paymentId', {})).rejects.toThrowError('Commerce Case ID is required');
            yield expect(() => paymentExecutionApiClient.cancelPayment('merchantId', 'commerceCaseId', '', 'paymentId', {})).rejects.toThrowError('Checkout ID is required');
            yield expect(() => paymentExecutionApiClient.cancelPayment('merchantId', 'commerceCaseId', 'checkoutId', '', {})).rejects.toThrowError('Payment Execution ID is required');
        }));
    });
    describe('refundPayment', () => {
        test('given request was successful, should return response', () => __awaiter(void 0, void 0, void 0, function* () {
            const expectedResponse = {
                status: StatusValue.Refunded,
                statusOutput: {
                    isCancellable: false,
                    isRefundable: false,
                    isAuthorized: true,
                },
            };
            mockedFetch.mockResolvedValueOnce(createResponseMock(200, expectedResponse));
            const payload = {
                return: {
                    returnReason: 'Customer unhappy',
                },
            };
            const res = yield paymentExecutionApiClient.refundPayment('merchantId', 'commerceCaseId', 'checkoutId', 'paymentId', payload);
            expect(res).toEqual(expectedResponse);
        }));
        test('given request was not successful (400), then return errorresponse', () => __awaiter(void 0, void 0, void 0, function* () {
            const expectedResponse = { errorId: 'error-id' };
            mockedFetch.mockResolvedValueOnce(createResponseMock(400, expectedResponse));
            expect.assertions(1);
            try {
                yield paymentExecutionApiClient.refundPayment('merchantId', 'commerceCaseId', 'checkoutId', 'paymentId', {});
            }
            catch (error) {
                expect(error).toEqual(new ApiErrorResponseException(400, JSON.stringify(expectedResponse)));
            }
        }));
        test('given request was not successful (500), throw ApiResponseRetrievalException', () => __awaiter(void 0, void 0, void 0, function* () {
            mockedFetch.mockResolvedValueOnce(createEmptyErrorResponseMock(500));
            expect.assertions(1);
            try {
                yield paymentExecutionApiClient.refundPayment('merchantId', 'commerceCaseId', 'checkoutId', 'paymentId', {});
            }
            catch (error) {
                expect(error).toEqual(new ApiResponseRetrievalException(500, ''));
            }
        }));
        test('a required param is empty, throw an error', () => __awaiter(void 0, void 0, void 0, function* () {
            yield expect(() => paymentExecutionApiClient.refundPayment('', 'commerceCaseId', 'checkoutId', 'paymentId', {})).rejects.toThrowError('Merchant ID is required');
            yield expect(() => paymentExecutionApiClient.refundPayment('merchantId', '', 'checkoutId', 'paymentId', {})).rejects.toThrowError('Commerce Case ID is required');
            yield expect(() => paymentExecutionApiClient.refundPayment('merchantId', 'commerceCaseId', '', 'paymentId', {})).rejects.toThrowError('Checkout ID is required');
            yield expect(() => paymentExecutionApiClient.refundPayment('merchantId', 'commerceCaseId', 'checkoutId', '', {})).rejects.toThrowError('Payment Execution ID is required');
        }));
    });
    describe('completePayment', () => {
        test('given request was successful, should return response', () => __awaiter(void 0, void 0, void 0, function* () {
            const expectedResponse = {
                merchantAction: {
                    actionType: ActionType.REDIRECT,
                    redirectData: {
                        redirectURL: 'https://redirect.com',
                    },
                },
            };
            mockedFetch.mockResolvedValueOnce(createResponseMock(200, expectedResponse));
            const payload = {
                order: {
                    amountOfMoney: { amount: 3720, currencyCode: 'EUR' },
                    references: {
                        merchantReference: 'order-5001',
                    },
                },
                device: {
                    ipAddress: '0.0.0.0',
                    deviceToken: 'tokentokentoken',
                },
            };
            const res = yield paymentExecutionApiClient.completePayment('merchantId', 'commerceCaseId', 'checkoutId', 'paymentId', payload);
            expect(res).toEqual(expectedResponse);
        }));
        test('given request was not successful (400), then return errorresponse', () => __awaiter(void 0, void 0, void 0, function* () {
            const expectedResponse = { errorId: 'error-id' };
            mockedFetch.mockResolvedValueOnce(createResponseMock(400, expectedResponse));
            expect.assertions(1);
            try {
                yield paymentExecutionApiClient.completePayment('merchantId', 'commerceCaseId', 'checkoutId', 'paymentId', {});
            }
            catch (error) {
                expect(error).toEqual(new ApiErrorResponseException(400, JSON.stringify(expectedResponse)));
            }
        }));
        test('given request was not successful (500), throw ApiResponseRetrievalException', () => __awaiter(void 0, void 0, void 0, function* () {
            mockedFetch.mockResolvedValueOnce(createEmptyErrorResponseMock(500));
            expect.assertions(1);
            try {
                yield paymentExecutionApiClient.completePayment('merchantId', 'commerceCaseId', 'checkoutId', 'paymentId', {});
            }
            catch (error) {
                expect(error).toEqual(new ApiResponseRetrievalException(500, ''));
            }
        }));
        test('a required param is empty, throw an error', () => __awaiter(void 0, void 0, void 0, function* () {
            yield expect(() => paymentExecutionApiClient.completePayment('', 'commerceCaseId', 'checkoutId', 'paymentId', {})).rejects.toThrowError('Merchant ID is required');
            yield expect(() => paymentExecutionApiClient.completePayment('merchantId', '', 'checkoutId', 'paymentId', {})).rejects.toThrowError('Commerce Case ID is required');
            yield expect(() => paymentExecutionApiClient.completePayment('merchantId', 'commerceCaseId', '', 'paymentId', {})).rejects.toThrowError('Checkout ID is required');
            yield expect(() => paymentExecutionApiClient.completePayment('merchantId', 'commerceCaseId', 'checkoutId', '', {})).rejects.toThrowError('Payment Execution ID is required');
        }));
    });
    describe('pausePayment', () => {
        const payload = {
            refreshType: RefreshType.PAYMENT_EVENTS,
        };
        test('given request was successful, should return response', () => __awaiter(void 0, void 0, void 0, function* () {
            const expectedResponse = {
                status: StatusValue.Paused,
            };
            mockedFetch.mockResolvedValueOnce(createResponseMock(200, expectedResponse));
            const res = yield paymentExecutionApiClient.pausePayment('merchantId', 'commerceCaseId', 'checkoutId', 'paymentExecutionId', payload);
            expect(res).toEqual(expectedResponse);
        }));
        test('given request was not successful (400), then return errorresponse', () => __awaiter(void 0, void 0, void 0, function* () {
            const expectedResponse = { errorId: 'error-id' };
            mockedFetch.mockResolvedValueOnce(createResponseMock(400, expectedResponse));
            expect.assertions(1);
            try {
                yield paymentExecutionApiClient.pausePayment('merchantId', 'commerceCaseId', 'checkoutId', 'paymentId', payload);
            }
            catch (error) {
                expect(error).toEqual(new ApiErrorResponseException(400, JSON.stringify(expectedResponse)));
            }
        }));
        test('given request was not successful (500), throw ApiResponseRetrievalException', () => __awaiter(void 0, void 0, void 0, function* () {
            mockedFetch.mockResolvedValueOnce(createEmptyErrorResponseMock(500));
            expect.assertions(1);
            try {
                yield paymentExecutionApiClient.pausePayment('merchantId', 'commerceCaseId', 'checkoutId', 'paymentId', payload);
            }
            catch (error) {
                expect(error).toEqual(new ApiResponseRetrievalException(500, ''));
            }
        }));
        test('a required param is empty, throw an error', () => __awaiter(void 0, void 0, void 0, function* () {
            yield expect(() => paymentExecutionApiClient.pausePayment('', 'commerceCaseId', 'checkoutId', 'paymentId', payload)).rejects.toThrowError('Merchant ID is required');
            yield expect(() => paymentExecutionApiClient.pausePayment('merchantId', '', 'checkoutId', 'paymentId', payload)).rejects.toThrowError('Commerce Case ID is required');
            yield expect(() => paymentExecutionApiClient.pausePayment('merchantId', 'commerceCaseId', '', 'paymentId', payload)).rejects.toThrowError('Checkout ID is required');
            yield expect(() => paymentExecutionApiClient.pausePayment('merchantId', 'commerceCaseId', 'checkoutId', '', payload)).rejects.toThrowError('Payment Execution ID is required');
        }));
    });
    describe('refreshPayment', () => {
        const payload = {
            refreshType: RefreshType.PAYMENT_EVENTS,
        };
        test('given request was successful, should return response', () => __awaiter(void 0, void 0, void 0, function* () {
            const expectedResponse = {
                paymentExecutionId: 'id',
            };
            mockedFetch.mockResolvedValueOnce(createResponseMock(200, expectedResponse));
            const res = yield paymentExecutionApiClient.refreshPayment('merchantId', 'commerceCaseId', 'checkoutId', 'paymentExecutionId', payload);
            expect(res).toEqual(expectedResponse);
        }));
        test('given request was not successful (400), then return errorresponse', () => __awaiter(void 0, void 0, void 0, function* () {
            const expectedResponse = { errorId: 'error-id' };
            mockedFetch.mockResolvedValueOnce(createResponseMock(400, expectedResponse));
            expect.assertions(1);
            try {
                yield paymentExecutionApiClient.refreshPayment('merchantId', 'commerceCaseId', 'checkoutId', 'paymentId', payload);
            }
            catch (error) {
                expect(error).toEqual(new ApiErrorResponseException(400, JSON.stringify(expectedResponse)));
            }
        }));
        test('given request was not successful (500), throw ApiResponseRetrievalException', () => __awaiter(void 0, void 0, void 0, function* () {
            mockedFetch.mockResolvedValueOnce(createEmptyErrorResponseMock(500));
            expect.assertions(1);
            try {
                yield paymentExecutionApiClient.refreshPayment('merchantId', 'commerceCaseId', 'checkoutId', 'paymentId', payload);
            }
            catch (error) {
                expect(error).toEqual(new ApiResponseRetrievalException(500, ''));
            }
        }));
        test('a required param is empty, throw an error', () => __awaiter(void 0, void 0, void 0, function* () {
            yield expect(() => paymentExecutionApiClient.refreshPayment('', 'commerceCaseId', 'checkoutId', 'paymentId', payload)).rejects.toThrowError('Merchant ID is required');
            yield expect(() => paymentExecutionApiClient.refreshPayment('merchantId', '', 'checkoutId', 'paymentId', payload)).rejects.toThrowError('Commerce Case ID is required');
            yield expect(() => paymentExecutionApiClient.refreshPayment('merchantId', 'commerceCaseId', '', 'paymentId', payload)).rejects.toThrowError('Checkout ID is required');
            yield expect(() => paymentExecutionApiClient.refreshPayment('merchantId', 'commerceCaseId', 'checkoutId', '', payload)).rejects.toThrowError('Payment Execution ID is required');
        }));
    });
});
//# sourceMappingURL=PaymentExecutionApiClient.test.js.map