pcp-server-nodejs-sdk/dist/endpoints/CheckoutApiClient.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 { StatusCheckout, } from '../models/index.js';
import { CheckoutApiClient } from '../endpoints/CheckoutApiClient.js';
import { createResponseMock, createEmptyErrorResponseMock } from '../testutils/mock-response.js';
import { ApiErrorResponseException } from '../errors/ApiErrorResponseException.js';
import { ApiResponseRetrievalException } from '../errors/ApiResponseRetrievalException.js';
import { GetCheckoutsQuery } from '../queries/GetCheckoutsQuery.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('CheckoutApiClient', () => {
    let checkoutApiClient;
    beforeEach(() => {
        checkoutApiClient = new CheckoutApiClient(new CommunicatorConfiguration('apiKey', 'apiSecret', 'https://test.com'));
    });
    describe('createCheckoutRequest', () => {
        test('given request was successful, then return response', () => __awaiter(void 0, void 0, void 0, function* () {
            const expectedResponse = {
                checkoutId: 'checkoutId',
                amountOfMoney: {
                    currencyCode: 'USD',
                    amount: 799,
                },
                shoppingCart: {
                    items: [{ invoiceData: { description: 'A smoothie' }, orderLineDetails: { productPrice: 799, quantity: 1 } }],
                },
            };
            mockedFetch.mockResolvedValueOnce(createResponseMock(200, expectedResponse));
            const res = yield checkoutApiClient.createCheckoutRequest('merchantId', 'commerceCaseId', {});
            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 checkoutApiClient.createCheckoutRequest('merchantId', 'commerceCaseId', {});
            }
            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 checkoutApiClient.createCheckoutRequest('merchantId', 'commerceCaseId', {});
            }
            catch (error) {
                expect(error).toEqual(new ApiResponseRetrievalException(500, ''));
            }
        }));
        test('a required params is empty, throw an error', () => __awaiter(void 0, void 0, void 0, function* () {
            yield expect(() => checkoutApiClient.createCheckoutRequest('', 'commerceCaseId', {})).rejects.toThrow('Merchant ID is required');
            yield expect(() => checkoutApiClient.createCheckoutRequest('merchantId', '', {})).rejects.toThrow('Commerce Case ID is required');
        }));
    });
    describe('getCheckoutRequest', () => {
        test('given request was successful, then return response', () => __awaiter(void 0, void 0, void 0, function* () {
            const expectedResponse = {
                commerceCaseId: 'commerceCaseId',
                checkoutId: 'checkoutId',
                merchantCustomerId: 'cust-1234',
                references: { merchantReference: 'com-12345' },
                amountOfMoney: { currencyCode: 'YEN', amount: 1000 },
                checkoutStatus: StatusCheckout.OPEN,
            };
            mockedFetch.mockResolvedValueOnce(createResponseMock(200, expectedResponse));
            const res = yield checkoutApiClient.getCheckoutRequest('merchantId', 'commerceCaseId', 'checkoutId');
            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 checkoutApiClient.getCheckoutRequest('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 checkoutApiClient.getCheckoutRequest('merchantId', 'commerceCaseId', 'checkoutId');
            }
            catch (error) {
                expect(error).toEqual(new ApiResponseRetrievalException(500, ''));
            }
        }));
        test('a required params is empty, throw an error', () => __awaiter(void 0, void 0, void 0, function* () {
            yield expect(() => checkoutApiClient.getCheckoutRequest('', 'commerceCaseId', 'checkoutId')).rejects.toThrow('Merchant ID is required');
            yield expect(() => checkoutApiClient.getCheckoutRequest('merchantId', '', 'checkoutId')).rejects.toThrow('Commerce Case ID is required');
            yield expect(() => checkoutApiClient.getCheckoutRequest('merchantId', 'commerceCaseId', '')).rejects.toThrow('Checkout ID is required');
        }));
    });
    describe('getCheckoutsRequest', () => {
        const queryParams = new GetCheckoutsQuery();
        queryParams.setSize(20);
        queryParams.setOffset(60);
        queryParams.setCheckoutId('checkoutId');
        test('given request was successful, then return response', () => __awaiter(void 0, void 0, void 0, function* () {
            const expectedResponse = {
                numberOfCheckouts: 1,
                checkouts: [
                    {
                        commerceCaseId: 'commerceCaseId',
                        checkoutId: 'checkoutId',
                        merchantCustomerId: 'cust-1100',
                        amountOfMoney: { currencyCode: 'USD', amount: 1250 },
                    },
                ],
            };
            mockedFetch.mockResolvedValueOnce(createResponseMock(200, expectedResponse));
            const res = yield checkoutApiClient.getCheckoutsRequest('merchantId', queryParams);
            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 checkoutApiClient.getCheckoutsRequest('merchantId', queryParams);
            }
            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 checkoutApiClient.getCheckoutsRequest('merchantId', queryParams);
            }
            catch (error) {
                expect(error).toEqual(new ApiResponseRetrievalException(500, ''));
            }
        }));
        test('a required params is empty, throw an error', () => __awaiter(void 0, void 0, void 0, function* () {
            yield expect(() => checkoutApiClient.getCheckoutsRequest('')).rejects.toThrow('Merchant ID is required');
        }));
    });
    describe('updateCheckoutRequest', () => __awaiter(void 0, void 0, void 0, function* () {
        const payload = {
            amountOfMoney: { currencyCode: 'YEN', amount: 1000 },
        };
        test('given request was successful, then return response', () => __awaiter(void 0, void 0, void 0, function* () {
            mockedFetch.mockResolvedValueOnce(createResponseMock(200, undefined));
            const res = yield checkoutApiClient.updateCheckoutRequest('merchantId', 'commerceCaseId', 'checkoutId', payload);
            expect(res).toEqual(undefined);
        }));
        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 checkoutApiClient.updateCheckoutRequest('merchantId', 'commerceCaseId', 'checkoutId', 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 checkoutApiClient.updateCheckoutRequest('merchantId', 'commerceCaseId', 'checkoutId', payload);
            }
            catch (error) {
                expect(error).toEqual(new ApiResponseRetrievalException(500, ''));
            }
        }));
        test('a required params is empty, throw an error', () => __awaiter(void 0, void 0, void 0, function* () {
            yield expect(() => checkoutApiClient.updateCheckoutRequest('', 'commerceCaseId', 'checkoutId', payload)).rejects.toThrow('Merchant ID is required');
            yield expect(() => checkoutApiClient.updateCheckoutRequest('merchantId', '', 'checkoutId', payload)).rejects.toThrow('Commerce Case ID is required');
            yield expect(() => checkoutApiClient.updateCheckoutRequest('merchantId', 'commerceCaseId', '', payload)).rejects.toThrow('Checkout ID is required');
        }));
    }));
    describe('removeCheckoutRequest', () => __awaiter(void 0, void 0, void 0, function* () {
        test('given request was successful, then return response', () => __awaiter(void 0, void 0, void 0, function* () {
            mockedFetch.mockResolvedValueOnce(createResponseMock(200, undefined));
            const res = yield checkoutApiClient.removeCheckoutRequest('merchantId', 'commerceCaseId', 'checkoutId');
            expect(res).toEqual(undefined);
        }));
        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 checkoutApiClient.removeCheckoutRequest('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 checkoutApiClient.removeCheckoutRequest('merchantId', 'commerceCaseId', 'checkoutId');
            }
            catch (error) {
                expect(error).toEqual(new ApiResponseRetrievalException(500, ''));
            }
        }));
        test('a required params is empty, throw an error', () => __awaiter(void 0, void 0, void 0, function* () {
            yield expect(() => checkoutApiClient.removeCheckoutRequest('', 'commerceCaseId', 'checkoutId')).rejects.toThrow('Merchant ID is required');
            yield expect(() => checkoutApiClient.removeCheckoutRequest('merchantId', '', 'checkoutId')).rejects.toThrow('Commerce Case ID is required');
            yield expect(() => checkoutApiClient.removeCheckoutRequest('merchantId', 'commerceCaseId', '')).rejects.toThrow('Checkout ID is required');
        }));
    }));
    describe('completeCheckoutRequest', () => __awaiter(void 0, void 0, void 0, function* () {
        const payload = {
            completePaymentMethodSpecificInput: {},
        };
        test('given request was successful, then return response', () => __awaiter(void 0, void 0, void 0, function* () {
            const expectedResponse = {};
            mockedFetch.mockResolvedValueOnce(createResponseMock(200, expectedResponse));
            const res = yield checkoutApiClient.completeCheckoutRequest('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 checkoutApiClient.completeCheckoutRequest('merchantId', 'commerceCaseId', 'checkoutId', 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 checkoutApiClient.completeCheckoutRequest('merchantId', 'commerceCaseId', 'checkoutId', payload);
            }
            catch (error) {
                expect(error).toEqual(new ApiResponseRetrievalException(500, ''));
            }
        }));
        test('a required params is empty, throw an error', () => __awaiter(void 0, void 0, void 0, function* () {
            yield expect(() => checkoutApiClient.completeCheckoutRequest('', 'commerceCaseId', 'checkoutId', payload)).rejects.toThrow('Merchant ID is required');
            yield expect(() => checkoutApiClient.completeCheckoutRequest('merchantId', '', 'checkoutId', payload)).rejects.toThrow('Commerce Case ID is required');
            yield expect(() => checkoutApiClient.completeCheckoutRequest('merchantId', 'commerceCaseId', '', payload)).rejects.toThrow('Checkout ID is required');
        }));
    }));
});
//# sourceMappingURL=CheckoutApiClient.test.js.map