@tonder.io/ionic-lite-sdk 0.0.3

package/tests/methods/getBusiness.test.ts

@@ -0,0 +1,102 @@
+import "../utils/defaultMock";
+import { LiteCheckout } from "../../src";
+import { ErrorResponse } from "../../src/classes/errorResponse";
+import { LiteCheckoutConstructor } from "../../src/classes/liteCheckout";
+import { IErrorResponse } from "../../src/types/responses";
+import { constructorFields } from "../utils/defaultMock";
+import { BusinessClass } from "../utils/mockClasses";
+
+declare global {
+    interface Window {
+        OpenPay: any;
+        Skyflow: any;
+    }
+}
+
+describe("getBusiness", () => {
+    let checkoutConstructor: LiteCheckoutConstructor,
+        liteCheckout: LiteCheckout,
+        fetchSpy: jest.SpyInstance,
+        liteCheckoutSpy: jest.SpyInstance;
+
+    beforeEach(async () => {
+        window.fetch = jest.fn();
+
+        checkoutConstructor = {
+            ...constructorFields,
+        };
+
+        liteCheckout = new LiteCheckout(constructorFields);
+
+        fetchSpy = jest.spyOn(global, "fetch");
+    });
+
+    afterEach(() => {
+        jest.restoreAllMocks();
+    });
+
+    it("getBusiness success", async () => {
+        liteCheckoutSpy = jest.spyOn(liteCheckout, "getBusiness");
+
+        fetchSpy.mockImplementation(() =>
+            Promise.resolve({
+                json: () =>
+                    Promise.resolve({
+                        ...new BusinessClass(),
+                    }),
+                ok: true,
+            })
+        );
+
+        const response = await liteCheckout.getBusiness();
+
+        expect(response).toStrictEqual({ ...new BusinessClass() });
+        expect(liteCheckoutSpy).toHaveBeenCalled();
+    });
+
+    it("getBusiness empty", async () => {
+        liteCheckoutSpy = jest.spyOn(liteCheckout, "getBusiness");
+
+        fetchSpy.mockImplementation(() =>
+            Promise.resolve({
+                json: () => Promise.resolve(),
+                ok: true,
+            })
+        );
+
+        const response = await liteCheckout.getBusiness();
+        expect(liteCheckoutSpy).toHaveBeenCalled();
+        expect(liteCheckoutSpy).toHaveReturned();
+        expect(response).toBeUndefined();
+    });
+
+    it("getBusiness errorResponse", async () => {
+        liteCheckoutSpy = jest.spyOn(liteCheckout, "getBusiness");
+
+        fetchSpy.mockImplementation(() =>
+            Promise.resolve({
+                json: () => Promise.resolve(),
+                ok: false,
+                status: 400,
+            })
+        );
+
+        const response = (await liteCheckout.getBusiness()) as IErrorResponse;
+        expect(response.code).toStrictEqual("400");
+        expect(response).toBeInstanceOf(ErrorResponse);
+    });
+
+    it("getBusiness errorCatch", async () => {
+        liteCheckoutSpy = jest.spyOn(liteCheckout, "getBusiness");
+
+        fetchSpy.mockRejectedValue("error");
+
+        const response = (await liteCheckout.getBusiness()) as ErrorResponse;
+        expect(liteCheckoutSpy).toHaveBeenCalled();
+        expect(response.message).toStrictEqual("error");
+        expect(response.name).toStrictEqual("catch");
+        expect(liteCheckoutSpy).rejects.toThrow();
+    });
+});
+
+

package/tests/methods/getCustomerCards.test.ts

@@ -0,0 +1,105 @@
+import "../utils/defaultMock";
+import { LiteCheckout } from "../../src";
+import { ErrorResponse } from "../../src/classes/errorResponse";
+import { LiteCheckoutConstructor } from "../../src/classes/liteCheckout";
+import { IErrorResponse } from "../../src/types/responses";
+import { constructorFields } from "../utils/defaultMock";
+import { GetCustomerCardsResponseClass } from "../utils/mockClasses";
+
+declare global {
+    interface Window {
+        OpenPay: any;
+        Skyflow: any;
+    }
+}
+
+describe("getCustomerCards", () => {
+    let checkoutConstructor: LiteCheckoutConstructor,
+        liteCheckout: LiteCheckout,
+        fetchSpy: jest.SpyInstance,
+        liteCheckoutSpy: jest.SpyInstance;
+
+    beforeEach(async () => {
+        window.fetch = jest.fn();
+
+        checkoutConstructor = {
+            ...constructorFields,
+        };
+
+        liteCheckout = new LiteCheckout(constructorFields);
+
+        fetchSpy = jest.spyOn(global, "fetch");
+    });
+
+    afterEach(() => {
+        jest.restoreAllMocks();
+    });
+
+    it("getCustomerCards success", async () => {
+        liteCheckoutSpy = jest.spyOn(liteCheckout, "getCustomerCards");
+
+        fetchSpy.mockImplementation(() =>
+            Promise.resolve({
+                json: () =>
+                    Promise.resolve({
+                        ...new GetCustomerCardsResponseClass(),
+                    }),
+                ok: true,
+            })
+        );
+
+        const response = await liteCheckout.getCustomerCards("1234", "1234");
+
+        expect(response).toStrictEqual({ ...new GetCustomerCardsResponseClass() });
+        expect(liteCheckoutSpy).toHaveBeenCalled();
+        expect(liteCheckoutSpy).toHaveBeenCalledWith("1234", "1234");
+    });
+
+    it("getCustomerCards empty", async () => {
+        liteCheckoutSpy = jest.spyOn(liteCheckout, "getCustomerCards");
+
+        fetchSpy.mockImplementation(() =>
+            Promise.resolve({
+                json: () => Promise.resolve(),
+                ok: true,
+            })
+        );
+
+        const response = await liteCheckout.getCustomerCards("1234", "1234");
+        expect(liteCheckoutSpy).toHaveBeenCalled();
+        expect(liteCheckoutSpy).toHaveReturned();
+        expect(response).toBeUndefined();
+    });
+
+    it("getCustomerCards errorResponse", async () => {
+        liteCheckoutSpy = jest.spyOn(liteCheckout, "getCustomerCards");
+
+        fetchSpy.mockImplementation(() =>
+            Promise.resolve({
+                json: () => Promise.resolve(),
+                ok: false,
+                status: 400,
+            })
+        );
+
+        const response = (await liteCheckout.getCustomerCards(
+            "1234", "1234"
+        )) as IErrorResponse;
+        expect(response.code).toStrictEqual("400");
+        expect(response).toBeInstanceOf(ErrorResponse);
+    });
+
+    it("getCustomerCards errorCatch", async () => {
+        liteCheckoutSpy = jest.spyOn(liteCheckout, "getCustomerCards");
+
+        fetchSpy.mockRejectedValue("error");
+
+        const response = (await liteCheckout.getCustomerCards(
+            "1234", "1234"
+        )) as IErrorResponse;
+        expect(liteCheckoutSpy).toHaveBeenCalled();
+        expect(response.message).toStrictEqual("error");
+        expect(response.name).toStrictEqual("catch");
+        expect(liteCheckoutSpy).rejects.toThrow();
+    });
+});

package/tests/methods/getOpenpayDeviceSessionID.test.ts

@@ -0,0 +1,95 @@
+import "../utils/defaultMock";
+import { LiteCheckout } from "../../src";
+import { ErrorResponse } from "../../src/classes/errorResponse";
+import { LiteCheckoutConstructor } from "../../src/classes/liteCheckout";
+import { IErrorResponse } from "../../src/types/responses";
+import { constructorFields } from "../utils/defaultMock";
+
+declare global {
+    interface Window {
+        OpenPay: any;
+        Skyflow: any;
+    }
+}
+
+describe("getOpenpayDeviceSessionID", () => {
+    let checkoutConstructor: LiteCheckoutConstructor,
+        liteCheckout: LiteCheckout,
+        fetchSpy: jest.SpyInstance,
+        liteCheckoutSpy: jest.SpyInstance;
+
+    beforeEach(async () => {
+        window.fetch = jest.fn();
+
+        checkoutConstructor = {
+            ...constructorFields,
+        };
+
+        liteCheckout = new LiteCheckout(constructorFields);
+
+        fetchSpy = jest.spyOn(global, "fetch");
+    });
+
+    afterEach(() => {
+        jest.restoreAllMocks();
+    });
+
+    it("getOpenpayDeviceSessionID success", async () => {
+        liteCheckoutSpy = jest.spyOn(liteCheckout, "getOpenpayDeviceSessionID");
+
+        window.OpenPay = {
+            setId: jest.fn(),
+            setApiKey: jest.fn(),
+            setSandboxMode: jest.fn(),
+            deviceData: {
+                setup: jest.fn().mockImplementation(() => Promise.resolve("test")),
+            },
+        };
+
+        expect(
+            liteCheckout.getOpenpayDeviceSessionID("4321", "1234")
+        ).resolves.toBe("test");
+        expect(liteCheckoutSpy).toHaveBeenCalledWith("4321", "1234");
+    });
+
+    it("getOpenpayDeviceSessionID empty", async () => {
+        liteCheckoutSpy = jest.spyOn(liteCheckout, "getOpenpayDeviceSessionID");
+
+        window.OpenPay = {
+            setId: jest.fn(),
+            setApiKey: jest.fn(),
+            setSandboxMode: jest.fn(),
+            deviceData: {
+                setup: jest.fn().mockImplementation(() => Promise.resolve()),
+            },
+        };
+
+        expect(
+            liteCheckout.getOpenpayDeviceSessionID("", "")
+        ).resolves.toBeUndefined();
+        expect(liteCheckoutSpy).toHaveBeenCalledWith("", "");
+    });
+
+    it("getOpenpayDeviceSessionID error", async () => {
+        liteCheckoutSpy = jest.spyOn(liteCheckout, "getOpenpayDeviceSessionID");
+
+        window.OpenPay = {
+            setId: jest.fn(),
+            setApiKey: jest.fn(),
+            setSandboxMode: jest.fn(),
+            deviceData: {
+                setup: jest.fn().mockRejectedValue("error"),
+            },
+        };
+
+        try {
+            await liteCheckout.getOpenpayDeviceSessionID("", "");
+        } catch (e) {
+            const error: IErrorResponse = e as IErrorResponse;
+            expect(liteCheckoutSpy).toHaveBeenCalledWith("", "");
+            expect(liteCheckoutSpy).toHaveReturned();
+            expect(error.message).toStrictEqual("error");
+            expect(error).toBeInstanceOf(ErrorResponse);
+        }
+    });
+});

package/tests/methods/getSkyflowToken.test.ts

@@ -0,0 +1,137 @@
+import "../utils/defaultMock";
+import Skyflow from "skyflow-js";
+import { LiteCheckout } from "../../src";
+import { ErrorResponse } from "../../src/classes/errorResponse";
+import { LiteCheckoutConstructor } from "../../src/classes/liteCheckout";
+import { IErrorResponse } from "../../src/types/responses";
+import { constructorFields } from "../utils/defaultMock";
+import { TokensRequestClass } from "../utils/mockClasses";
+
+
+declare global {
+    interface Window {
+        OpenPay: any;
+        Skyflow: any;
+    }
+}
+
+describe("getSkyflowToken", () => {
+    let checkoutConstructor: LiteCheckoutConstructor,
+        liteCheckout: LiteCheckout,
+        fetchSpy: jest.SpyInstance,
+        liteCheckoutSpy: jest.SpyInstance;
+
+    beforeEach(async () => {
+        window.fetch = jest.fn();
+
+        checkoutConstructor = {
+            ...constructorFields,
+        };
+
+        liteCheckout = new LiteCheckout(constructorFields);
+
+        fetchSpy = jest.spyOn(global, "fetch");
+    });
+
+    afterEach(() => {
+        jest.restoreAllMocks();
+    });
+
+    it("getSkyflowTokens success", async () => {
+        liteCheckout.getVaultToken = jest
+            .fn()
+            .mockImplementation(() => Promise.resolve("1234"));
+
+        liteCheckout.getFieldsPromise = jest
+            .fn()
+            .mockImplementation(() =>
+                Promise.resolve(new Array(5).fill(Promise.resolve(true)))
+            );
+
+        liteCheckoutSpy = jest.spyOn(liteCheckout, "getSkyflowTokens");
+
+        const response = await liteCheckout.getSkyflowTokens({
+            ...new TokensRequestClass(),
+        });
+        expect(response).toStrictEqual("1234");
+        expect(liteCheckoutSpy).toHaveBeenCalled();
+    });
+
+    it("getSkyflowTokens empty", async () => {
+        liteCheckout.getVaultToken = jest
+            .fn()
+            .mockImplementation(() => Promise.resolve(""));
+
+        jest.spyOn(Skyflow, "init").mockImplementation(jest.fn().mockImplementation(() => ({
+            container: () => ({
+                collect: jest.fn().mockResolvedValue(""),
+            }),
+        })));
+
+        liteCheckout.getFieldsPromise = jest
+            .fn()
+            .mockImplementation(() =>
+                Promise.resolve(new Array(5).fill(Promise.resolve(true)))
+            );
+
+        liteCheckoutSpy = jest.spyOn(liteCheckout, "getSkyflowTokens");
+
+        const response = await liteCheckout.getSkyflowTokens({
+            ...new TokensRequestClass(),
+        }) as IErrorResponse;
+        expect(response).toBeInstanceOf(ErrorResponse);
+        expect(response.message).toStrictEqual("Por favor, verifica todos los campos de tu tarjeta");
+    });
+
+    it("getSkyflowTokens error mount fields", async () => {
+        liteCheckout.getVaultToken = jest
+            .fn()
+            .mockImplementation(() => Promise.resolve(""));
+
+        jest.spyOn(Skyflow, "init").mockImplementation(jest.fn().mockImplementation(() => ({
+            container: () => ({
+                collect: jest.fn().mockResolvedValue(""),
+            }),
+        })));
+
+        liteCheckout.getFieldsPromise = jest
+            .fn()
+            .mockImplementation(() =>
+                new Array(5).fill(false)
+            );
+
+        liteCheckoutSpy = jest.spyOn(liteCheckout, "getSkyflowTokens");
+
+        const response = await liteCheckout.getSkyflowTokens({
+            ...new TokensRequestClass(),
+        }) as IErrorResponse;
+        expect(response).toBeInstanceOf(ErrorResponse);
+        expect(response.message).toStrictEqual("Ocurrió un error al montar los campos de la tarjeta");
+    });
+
+    it("getSkyflowTokens error collect catch", async () => {
+        liteCheckout.getVaultToken = jest
+            .fn()
+            .mockImplementation(() => Promise.resolve("1234"));
+
+        jest.spyOn(Skyflow, "init").mockImplementation(jest.fn().mockImplementation(() => ({
+            container: () => ({
+                collect: jest.fn().mockRejectedValue("error"),
+            }),
+        })));
+
+        liteCheckout.getFieldsPromise = jest
+            .fn()
+            .mockImplementation(() =>
+                Promise.resolve(new Array(5).fill(Promise.resolve(true)))
+            );
+
+        liteCheckoutSpy = jest.spyOn(liteCheckout, "getSkyflowTokens");
+
+        const response = (await liteCheckout.getSkyflowTokens({
+            ...new TokensRequestClass(),
+        })) as IErrorResponse;
+        expect(response.message).toStrictEqual("error");
+        expect(response).toBeInstanceOf(ErrorResponse);
+    });
+});

package/tests/methods/getVaultToken.test.ts

@@ -0,0 +1,107 @@
+import "../utils/defaultMock";
+import { LiteCheckout } from "../../src";
+import { LiteCheckoutConstructor } from "../../src/classes/liteCheckout";
+import { constructorFields } from "../utils/defaultMock";
+
+declare global {
+    interface Window {
+        OpenPay: any;
+        Skyflow: any;
+    }
+}
+
+describe("getVaultToken", () => {
+    let checkoutConstructor: LiteCheckoutConstructor,
+        liteCheckout: LiteCheckout,
+        fetchSpy: jest.SpyInstance,
+        liteCheckoutSpy: jest.SpyInstance;
+
+    beforeEach(async () => {
+        window.fetch = jest.fn();
+
+        checkoutConstructor = {
+            ...constructorFields,
+        };
+
+        liteCheckout = new LiteCheckout(constructorFields);
+
+        fetchSpy = jest.spyOn(global, "fetch");
+    });
+
+    afterEach(() => {
+        jest.restoreAllMocks();
+    });
+
+    it("getVaultToken success", async () => {
+        liteCheckoutSpy = jest.spyOn(liteCheckout, "getVaultToken");
+
+        fetchSpy.mockImplementation(() =>
+            Promise.resolve({
+                json: () => Promise.resolve({ token: "1234" }),
+                ok: true,
+            })
+        );
+
+        const response = await liteCheckout.getVaultToken();
+        expect(response).toStrictEqual("1234");
+        expect(liteCheckoutSpy).toHaveBeenCalled();
+    });
+
+    it("getVaultToken empty", async () => {
+        liteCheckoutSpy = jest.spyOn(liteCheckout, "getVaultToken");
+
+        fetchSpy.mockImplementation(() =>
+            Promise.resolve({
+                json: () => Promise.resolve(),
+                ok: true,
+            })
+        );
+
+        const response = await liteCheckout.getVaultToken();
+        expect(liteCheckoutSpy).toHaveBeenCalled();
+        expect(liteCheckoutSpy).toHaveReturned();
+        expect(response).toBeUndefined();
+    });
+
+    it("getVaultToken errorResponse", async () => {
+        liteCheckoutSpy = jest.spyOn(liteCheckout, "getVaultToken");
+
+        fetchSpy.mockImplementation(() =>
+            Promise.resolve({
+                json: () => Promise.resolve(),
+                ok: false,
+                status: 400,
+            })
+        );
+
+        try {
+            await liteCheckout.getVaultToken();
+        } catch (e) {
+            const error = e as Error;
+            expect(liteCheckoutSpy).toHaveBeenCalled();
+            expect(liteCheckoutSpy).rejects.toThrow();
+            expect(error.message).toStrictEqual(
+                "Failed to retrieve bearer token; HTTPCODE: 400"
+            );
+            expect(error).toBeInstanceOf(Error);
+        }
+    });
+
+    it("getVaultToken errorCatch", async () => {
+        liteCheckoutSpy = jest.spyOn(liteCheckout, "getVaultToken");
+
+        fetchSpy.mockRejectedValue("error");
+
+        try {
+            await liteCheckout.getVaultToken();
+        } catch (e) {
+            const error = e as Error;
+            expect(liteCheckoutSpy).toHaveBeenCalled();
+            expect(liteCheckoutSpy).rejects.toThrow();
+            expect(error.message).toStrictEqual(
+                "Failed to retrieve bearer token; error"
+            );
+            expect(e).toBeInstanceOf(Error);
+        }
+    });
+});

package/tests/methods/registerCustomerCard.test.ts

@@ -0,0 +1,105 @@
+import "../utils/defaultMock";
+import { LiteCheckout } from "../../src";
+import { LiteCheckoutConstructor } from "../../src/classes/liteCheckout";
+import { constructorFields } from "../utils/defaultMock";
+import { RegisterCustomerCardRequestClass, RegisterCustomerCardResponseClass } from "../utils/mockClasses";
+import { ErrorResponse } from "../../src/classes/errorResponse";
+import { IErrorResponse } from "../../src/types/responses";
+
+declare global {
+    interface Window {
+        OpenPay: any;
+        Skyflow: any;
+    }
+}
+
+describe("registerCustomerCard", () => {
+    let checkoutConstructor: LiteCheckoutConstructor,
+        liteCheckout: LiteCheckout,
+        fetchSpy: jest.SpyInstance,
+        liteCheckoutSpy: jest.SpyInstance;
+
+    beforeEach(async () => {
+        window.fetch = jest.fn();
+
+        checkoutConstructor = {
+            ...constructorFields,
+        };
+
+        liteCheckout = new LiteCheckout(constructorFields);
+
+        fetchSpy = jest.spyOn(global, "fetch");
+    });
+
+    afterEach(() => {
+        jest.restoreAllMocks();
+    });
+
+    it("registerCustomerCard success", async () => {
+        liteCheckoutSpy = jest.spyOn(liteCheckout, "registerCustomerCard");
+
+        fetchSpy.mockImplementation(() =>
+            Promise.resolve({
+                json: () =>
+                    Promise.resolve({
+                        ...new RegisterCustomerCardResponseClass(),
+                    }),
+                ok: true,
+            })
+        );
+
+        const response = await liteCheckout.registerCustomerCard("1234", { ...new RegisterCustomerCardRequestClass() });
+
+        expect(response).toStrictEqual({ ...new RegisterCustomerCardResponseClass() });
+        expect(liteCheckoutSpy).toHaveBeenCalled();
+        expect(liteCheckoutSpy).toHaveBeenCalledWith("1234", { ...new RegisterCustomerCardRequestClass() });
+    });
+
+    it("registerCustomerCard empty", async () => {
+        liteCheckoutSpy = jest.spyOn(liteCheckout, "registerCustomerCard");
+
+        fetchSpy.mockImplementation(() =>
+            Promise.resolve({
+                json: () => Promise.resolve(),
+                ok: true,
+            })
+        );
+
+        const response = await liteCheckout.registerCustomerCard("1234", { ...new RegisterCustomerCardRequestClass() });
+        expect(liteCheckoutSpy).toHaveBeenCalled();
+        expect(liteCheckoutSpy).toHaveReturned();
+        expect(response).toBeUndefined();
+    });
+
+    it("registerCustomerCard errorResponse", async () => {
+        liteCheckoutSpy = jest.spyOn(liteCheckout, "registerCustomerCard");
+
+        fetchSpy.mockImplementation(() =>
+            Promise.resolve({
+                json: () => Promise.resolve(),
+                ok: false,
+                status: 400,
+            })
+        );
+
+        const response = (await liteCheckout.registerCustomerCard(
+            "1234", { ...new RegisterCustomerCardRequestClass() }
+        )) as IErrorResponse;
+        expect(response.code).toStrictEqual("400");
+        expect(response).toBeInstanceOf(ErrorResponse);
+    });
+
+    it("registerCustomerCard errorCatch", async () => {
+        liteCheckoutSpy = jest.spyOn(liteCheckout, "registerCustomerCard");
+
+        fetchSpy.mockRejectedValue("error");
+
+        const response = (await liteCheckout.registerCustomerCard(
+            "1234", { ...new RegisterCustomerCardRequestClass() }
+        )) as IErrorResponse;
+        expect(liteCheckoutSpy).toHaveBeenCalled();
+        expect(response.message).toStrictEqual("error");
+        expect(response.name).toStrictEqual("catch");
+        expect(liteCheckoutSpy).rejects.toThrow();
+    });
+});