@tonder.io/ionic-lite-sdk 0.0.3

package/src/types/requests.ts

@@ -0,0 +1,61 @@
+import { OrderItem } from "./commons";
+import { SkyflowRecord } from "./skyflow";
+
+export interface CreateOrderRequest {
+    business: string,
+    client: string,
+    billing_address_id?: string | null,
+    shipping_address_id?: string | null,
+    amount: number,
+    status: string,
+    reference: string | number,
+    is_oneclick: boolean,
+    items: OrderItem[]
+}
+
+export type CreatePaymentRequest = {
+    business_pk: string | number,
+    amount: number,
+    date: string,
+    order: string | number
+}
+
+export type StartCheckoutRequest = {
+    card: any,
+    name: any,
+    last_name: string,
+    email_client: any,
+    phone_number: any,
+    return_url?: string,
+    id_product: string,
+    quantity_product: number,
+    id_ship: string,
+    instance_id_ship: string,
+    amount: any,
+    title_ship: string,
+    description: string,
+    device_session_id: any,
+    token_id: string,
+    order_id: any,
+    business_id: any,
+    payment_id: any,
+    source: string,
+}
+
+export interface VaultRequest extends SkyflowRecord {
+    records: SkyflowRecord[],
+    continueOnError?: boolean,
+    byot?: "DISABLE" | "ENABLE" | "ENABLE_STRICT"
+}
+
+export type RegisterCustomerCardRequest = {
+    skyflow_id: string;
+}
+
+export type TokensRequest = {
+    vault_id: string,
+    vault_url: string,
+    data: {
+        [key: string]: any;
+    }
+}

package/src/types/responses.ts

@@ -0,0 +1,186 @@
+import { Business } from "./commons";
+
+export interface IErrorResponse extends Error {
+    code?: string;
+    body?: string;
+}
+
+export interface GetBusinessResponse extends Business { }
+
+export type GetVaultTokenResponse = {
+    token: string;
+};
+
+export type CustomerRegisterResponse = {
+    id: number | string;
+    email: string;
+    auth_token: string;
+};
+
+export type CreateOrderResponse = {
+    id: number | string;
+    created: string;
+    amount: string;
+    status: string;
+    payment_method?: string;
+    reference?: string;
+    is_oneclick: boolean;
+    items: {
+        description: string;
+        product_reference: string;
+        quantity: string;
+        price_unit: string;
+        discount: string;
+        taxes: string;
+        amount_total: string;
+    }[];
+    billing_address?: string;
+    shipping_address?: string;
+    client: {
+        email: string;
+        name: string;
+        first_name: string;
+        last_name: string;
+        client_profile: {
+            gender: string;
+            date_birth?: string;
+            terms: boolean;
+            phone: string;
+        };
+    };
+};
+
+export type CreatePaymentResponse = {
+    pk: number | string;
+    order?: string;
+    amount: string;
+    status: string;
+    date: string;
+    paid_date?: string;
+    shipping_address: {
+        street: string;
+        number: string;
+        suburb: string;
+        city: {
+            name: string;
+        };
+        state: {
+            name: string;
+            country: {
+                name: string;
+            };
+        };
+        zip_code: string;
+    };
+    shipping_address_id?: string;
+    billing_address: {
+        street: string;
+        number: string;
+        suburb: string;
+        city: {
+            name: string;
+        };
+        state: {
+            name: string;
+            country: {
+                name: string;
+            };
+        };
+        zip_code: string;
+    };
+    billing_address_id?: string;
+    client?: string;
+    customer_order_reference?: string;
+};
+
+export type StartCheckoutResponse = {
+    status: number;
+    message: string;
+    psp_response: {
+        id: string;
+        authorization: number;
+        operation_type: string;
+        transaction_type: string;
+        status: string;
+        conciliated: boolean;
+        creation_date: string;
+        operation_date: string;
+        description: string;
+        error_message?: string;
+        order_id?: string;
+        card: {
+            type: string;
+            brand: string;
+            address?: string;
+            card_number: string;
+            holder_name: string;
+            expiration_year: string;
+            expiration_month: string;
+            allows_charges: boolean;
+            allows_payouts: boolean;
+            bank_name: string;
+            points_type: string;
+            points_card: boolean;
+            bank_code: number;
+        };
+        customer_id: string;
+        gateway_card_present: string;
+        amount: number;
+        fee: {
+            amount: number;
+            tax: number;
+            currency: string;
+        };
+        payment_method: {
+            type: string;
+            url: string;
+        };
+        currency: string;
+        method: string;
+        object: string;
+    };
+    transaction_status: string;
+    transaction_id: number;
+    payment_id: number;
+    provider: string;
+    next_action: {
+        redirect_to_url: {
+            url: string;
+            return_url: string;
+            verify_transaction_status_url: string;
+        };
+    };
+    actions: {
+        name: string;
+        url: string;
+        method: string;
+    }[];
+};
+
+export type TokensResponse = {
+    vaultID: string;
+    responses: {
+        [key: string]: string;
+    }[];
+};
+
+export type GetCustomerCardsResponse = {
+    user_id: number;
+    cards: {
+        records: {
+            fields: {
+                card_number: string;
+                cardholder_name: string;
+                cvv: string;
+                expiration_month: string;
+                expiration_year: string;
+                skyflow_id: string;
+            };
+        }[];
+    };
+};
+
+export type RegisterCustomerCardResponse = {
+    skyflow_id: string;
+    user_id: number;
+};

package/src/types/skyflow.ts

@@ -0,0 +1,17 @@
+export type SkyflowRecord = {
+    method: string;
+    quorum?: boolean;
+    tableName: string;
+    fields?: {
+        [key: string]: string;
+    },
+    ID?: string,
+    tokenization?: boolean,
+    batchID?: string,
+    redaction?: "DEFAULT" | "REDACTED" | "MASKED" | "PLAIN_TEXT",
+    downloadURL?: boolean,
+    upsert?: string,
+    tokens?: {
+        [key: string]: string;
+    }
+}

package/tests/classes/liteCheckout.test.ts

@@ -0,0 +1,57 @@
+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("LiteCheckout", () => {
+    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("Has required properties", () => {
+        expect(checkoutConstructor).toEqual(constructorFields);
+    });
+
+    it("Can instance LiteCheckout", () => {
+        expect(liteCheckout).toBeInstanceOf(LiteCheckout);
+        expect(liteCheckout.apiKeyTonder).toEqual(constructorFields.apiKeyTonder);
+        expect(liteCheckout.baseUrlTonder).toEqual(constructorFields.baseUrlTonder);
+        expect(liteCheckout.signal).toEqual(constructorFields.signal);
+    });
+
+
+
+
+
+ 
+
+
+
+
+
+
+});

package/tests/methods/createOrder.test.ts

@@ -0,0 +1,106 @@
+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 { OrderResponseClass, OrderClass } from "../utils/mockClasses";
+
+declare global {
+    interface Window {
+        OpenPay: any;
+        Skyflow: any;
+    }
+}
+
+describe("createOrder", () => {
+    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("createOrder success", async () => {
+        liteCheckoutSpy = jest.spyOn(liteCheckout, "createOrder");
+
+        fetchSpy.mockImplementation(() =>
+            Promise.resolve({
+                json: () => Promise.resolve([{ ...new OrderResponseClass() }]),
+                ok: true,
+            })
+        );
+
+        const response = await liteCheckout.createOrder({
+            ...new OrderClass(),
+        });
+
+        expect(response).toStrictEqual([{ ...new OrderResponseClass() }]);
+        expect(liteCheckoutSpy).toHaveBeenCalled();
+        expect(liteCheckoutSpy).toHaveBeenCalledWith({ ...new OrderClass() });
+    });
+
+    it("createOrder empty", async () => {
+        liteCheckoutSpy = jest.spyOn(liteCheckout, "createOrder");
+
+        fetchSpy.mockImplementation(() =>
+            Promise.resolve({
+                json: () => Promise.resolve(),
+                ok: true,
+            })
+        );
+
+        const response = await liteCheckout.createOrder({
+            ...new OrderClass(),
+        });
+        expect(liteCheckoutSpy).toHaveBeenCalled();
+        expect(liteCheckoutSpy).toHaveReturned();
+        expect(response).toBeUndefined();
+    });
+
+    it("createOrder errorResponse", async () => {
+        liteCheckoutSpy = jest.spyOn(liteCheckout, "createOrder");
+
+        fetchSpy.mockImplementation(() =>
+            Promise.resolve({
+                json: () => Promise.resolve(),
+                ok: false,
+                status: 400,
+            })
+        );
+
+        const response = (await liteCheckout.createOrder({
+            ...new OrderClass(),
+        })) as IErrorResponse;
+        expect(response.code).toStrictEqual("400");
+        expect(response).toBeInstanceOf(ErrorResponse);
+    });
+
+    it("createOrder errorCatch", async () => {
+        liteCheckoutSpy = jest.spyOn(liteCheckout, "createOrder");
+
+        fetchSpy.mockRejectedValue("error");
+
+        const response = (await liteCheckout.createOrder({
+            ...new OrderClass(),
+        })) as IErrorResponse;
+        expect(liteCheckoutSpy).toHaveBeenCalled();
+        expect(response.message).toStrictEqual("error");
+        expect(response.name).toStrictEqual("catch");
+        expect(liteCheckoutSpy).rejects.toThrow();
+    });
+});

package/tests/methods/createPayment.test.ts

@@ -0,0 +1,109 @@
+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 { CreatePaymentResponseClass, CreatePaymentRequestClass } from "../utils/mockClasses";
+
+
+declare global {
+    interface Window {
+        OpenPay: any;
+        Skyflow: any;
+    }
+}
+
+describe("createPayment", () => {
+    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("createPayment success", async () => {
+        liteCheckoutSpy = jest.spyOn(liteCheckout, "createPayment");
+
+        fetchSpy.mockImplementation(() =>
+            Promise.resolve({
+                json: () => Promise.resolve([{ ...new CreatePaymentResponseClass() }]),
+                ok: true,
+            })
+        );
+
+        const response = await liteCheckout.createPayment({
+            ...new CreatePaymentRequestClass(),
+        });
+
+        expect(response).toStrictEqual([{ ...new CreatePaymentResponseClass() }]);
+        expect(liteCheckoutSpy).toHaveBeenCalled();
+        expect(liteCheckoutSpy).toHaveBeenCalledWith({
+            ...new CreatePaymentRequestClass(),
+        });
+    });
+
+    it("createPayment empty", async () => {
+        liteCheckoutSpy = jest.spyOn(liteCheckout, "createPayment");
+
+        fetchSpy.mockImplementation(() =>
+            Promise.resolve({
+                json: () => Promise.resolve(),
+                ok: true,
+            })
+        );
+
+        const response = await liteCheckout.createPayment({
+            ...new CreatePaymentRequestClass(),
+        });
+        expect(liteCheckoutSpy).toHaveBeenCalled();
+        expect(liteCheckoutSpy).toHaveReturned();
+        expect(response).toBeUndefined();
+    });
+
+    it("createPayment errorResponse", async () => {
+        liteCheckoutSpy = jest.spyOn(liteCheckout, "createPayment");
+
+        fetchSpy.mockImplementation(() =>
+            Promise.resolve({
+                json: () => Promise.resolve(),
+                ok: false,
+                status: 400,
+            })
+        );
+
+        const response = (await liteCheckout.createPayment({
+            ...new CreatePaymentRequestClass(),
+        })) as IErrorResponse;
+        expect(response.code).toStrictEqual("400");
+        expect(response).toBeInstanceOf(ErrorResponse);
+    });
+
+    it("createPayment errorCatch", async () => {
+        liteCheckoutSpy = jest.spyOn(liteCheckout, "createPayment");
+
+        fetchSpy.mockRejectedValue("error");
+
+        const response = (await liteCheckout.createPayment({
+            ...new CreatePaymentRequestClass(),
+        })) as IErrorResponse;
+        expect(liteCheckoutSpy).toHaveBeenCalled();
+        expect(response.message).toStrictEqual("error");
+        expect(response.name).toStrictEqual("catch");
+        expect(liteCheckoutSpy).rejects.toThrow();
+    });
+});

package/tests/methods/customerRegister.test.ts

@@ -0,0 +1,106 @@
+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("customerRegister", () => {
+    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("customerRegister success", async () => {
+        liteCheckoutSpy = jest.spyOn(liteCheckout, "customerRegister");
+
+        fetchSpy.mockImplementation(() =>
+            Promise.resolve({
+                json: () =>
+                    Promise.resolve({
+                        ...new BusinessClass(),
+                    }),
+                ok: true,
+            })
+        );
+
+        const response = await liteCheckout.customerRegister("email@gmail.com");
+
+        expect(response).toStrictEqual({ ...new BusinessClass() });
+        expect(liteCheckoutSpy).toHaveBeenCalled();
+        expect(liteCheckoutSpy).toHaveBeenCalledWith("email@gmail.com");
+    });
+
+    it("customerRegister empty", async () => {
+        liteCheckoutSpy = jest.spyOn(liteCheckout, "customerRegister");
+
+        fetchSpy.mockImplementation(() =>
+            Promise.resolve({
+                json: () => Promise.resolve(),
+                ok: true,
+            })
+        );
+
+        const response = await liteCheckout.customerRegister("email@gmail.com");
+        expect(liteCheckoutSpy).toHaveBeenCalled();
+        expect(liteCheckoutSpy).toHaveReturned();
+        expect(response).toBeUndefined();
+    });
+
+    it("customerRegister errorResponse", async () => {
+        liteCheckoutSpy = jest.spyOn(liteCheckout, "customerRegister");
+
+        fetchSpy.mockImplementation(() =>
+            Promise.resolve({
+                json: () => Promise.resolve(),
+                ok: false,
+                status: 400,
+            })
+        );
+
+        const response = (await liteCheckout.customerRegister(
+            "email@gmail.com"
+        )) as IErrorResponse;
+        expect(response.code).toStrictEqual("400");
+        expect(response).toBeInstanceOf(ErrorResponse);
+    });
+
+    it("customerRegister errorCatch", async () => {
+        liteCheckoutSpy = jest.spyOn(liteCheckout, "customerRegister");
+
+        fetchSpy.mockRejectedValue("error");
+
+        const response = (await liteCheckout.customerRegister(
+            "email@gmail.com"
+        )) as IErrorResponse;
+        expect(liteCheckoutSpy).toHaveBeenCalled();
+        expect(response.message).toStrictEqual("error");
+        expect(response.name).toStrictEqual("catch");
+        expect(liteCheckoutSpy).rejects.toThrow();
+    });
+});