@stylusapparel/stylusop-api-node-wrapper/test/orders.test.js

This is the official NodeJs wrapper for connecting to the StylusOP API

const axios = require("axios");
const { __defaults } = require("../constants/url");
const __mockWrapper = require("..");
const { MOCK_SECRET_TOKEN, MOCK_VENDOR_NAME } = require("./__mocks__/auth.json");
const {
    MOCK_GET_ORDER_RESPONSE,
    MOCK_LIST_ORDERS_RESPONSE,
    MOCK_GET_ORDER_STATUS,
    MOCK_GET_ORDER_ACTIVITY,
    MOCK_CANCEL_ORDER_REQUEST,
    MOCK_CANCEL_ORDER_RESPONSE,
    MOCK_CREATE_ORDER_REQUEST,
    MOCK_CREATE_ORDER_RESPONSE,
    MOCK_UPDATE_ORDER_REQUEST,
    MOCK_UPDATE_ORDER_RESPONSE,
    MOCK_ORDER_ID
} = require("./__mocks__/order.json");
const { _errorConst } = require("../constants/const");

const _mockClient = __mockWrapper.createClient(MOCK_SECRET_TOKEN, { apiVersion: __defaults.LATEST_VERSION, sandBox: true, username: MOCK_VENDOR_NAME });

afterEach(() => {
    jest.clearAllMocks();
});

describe("ORDER MODULE  - Validating success scenarios", () => {
    it(" =>  stylusClient.orders.get(ORDER_REFERENCE_ID) ", async () => {
        axios.get.mockImplementationOnce(() => Promise.resolve({
            data: { ...MOCK_GET_ORDER_RESPONSE },
            status: 200
        }));
        const gen = await _mockClient.orders.get(MOCK_ORDER_ID);
        expect(axios.get).toHaveBeenCalledTimes(1);
        expect(gen).toEqual(MOCK_GET_ORDER_RESPONSE.order);
    });
    it(" =>  stylusClient.orders.list() ", async () => {
        axios.get.mockImplementationOnce(() => Promise.resolve({
            data: { ...MOCK_LIST_ORDERS_RESPONSE },
            status: 200
        }));
        const gen = await _mockClient.orders.list(MOCK_ORDER_ID); MOCK_GET_ORDER_ACTIVITY
        expect(axios.get).toHaveBeenCalledTimes(1);
        expect(gen).toEqual(MOCK_LIST_ORDERS_RESPONSE.orders);
    });
    it(" =>  stylusClient.orders.status(ORDER_REFERENCE_ID) ", async () => {
        axios.get.mockImplementationOnce(() => Promise.resolve({
            data: { ...MOCK_GET_ORDER_STATUS },
            status: 200
        }));
        const gen = await _mockClient.orders.status(MOCK_ORDER_ID);
        expect(axios.get).toHaveBeenCalledTimes(1);
        expect(gen).toEqual(MOCK_GET_ORDER_STATUS);
    });
    it(" =>  stylusClient.orders.activities(ORDER_REFERENCE_ID) ", async () => {
        axios.get.mockImplementationOnce(() => Promise.resolve({
            data: { ...MOCK_GET_ORDER_ACTIVITY },
            status: 200
        }));
        const gen = await _mockClient.orders.activities(MOCK_ORDER_ID);
        expect(axios.get).toHaveBeenCalledTimes(1);
        expect(gen).toEqual(MOCK_GET_ORDER_ACTIVITY.activity)
    });
    it(" => stylusClient.orders.cancel(ORDER_REFERENCE_ID) ", async () => {
        axios.post.mockImplementationOnce(() => Promise.resolve({
            data: {...MOCK_CANCEL_ORDER_RESPONSE},
            status: 200
        }));
        const gen = await _mockClient.orders.cancel(MOCK_ORDER_ID, MOCK_CREATE_ORDER_REQUEST);
        expect(axios.post).toHaveBeenCalledTimes(1);
        expect(gen).toEqual(true);
    });
    it(" =>  stylusClient.orders.create({ORDER_CREATE_OBJECT}) ", async () => {
        axios.post.mockImplementationOnce(() => Promise.resolve({
            data: { ...MOCK_CREATE_ORDER_RESPONSE },
            status: 201
        }));
        const gen = await _mockClient.orders.create(MOCK_CREATE_ORDER_REQUEST);
        expect(axios.post).toHaveBeenCalledTimes(1);
        expect(gen).toEqual({ "reference_id": MOCK_CREATE_ORDER_RESPONSE.reference_id })
    });
    it(" =>  stylusClient.orders.update(ORDER_REFERENCE_ID,{ORDER_UPDATE_OBJECT}) ", async () => {
        axios.patch.mockImplementationOnce(() => Promise.resolve({
            data:{
                ...MOCK_UPDATE_ORDER_RESPONSE
            },
            status: 200
        }));
        const gen = await _mockClient.orders.update(MOCK_ORDER_ID, MOCK_UPDATE_ORDER_REQUEST);
        expect(axios.patch).toHaveBeenCalledTimes(1);
        expect(gen).toEqual(true);
    });
});

describe("ORDER MODULE  - Validating failure scenarios", () => {
    it(" => stylusClient.orders.get(ORDER_REFERENCE_ID) ", async () => {
        axios.get.mockImplementationOnce(() => Promise.reject({
            response: {
                data: "No order found",
                status: 404
            }
        }));
        try {
            await _mockClient.orders.get(MOCK_ORDER_ID);
            expect(true).toEqual(false);
        } catch (err) {
            expect(axios.get).toHaveBeenCalledTimes(1);
            expect(err.errorCode).toEqual(_errorConst.ORDER_ID_INVALID);
        }
    });
    it(" => stylusClient.orders.list() ", async () => {
        axios.get.mockImplementationOnce(() => Promise.reject({
            response: {
                data: {
                    errorCode: _errorConst.UNKNOWN_ERROR
                },
                status: 500
            }
        }));
        try {
            await _mockClient.orders.list();
            expect(true).toEqual(false);
        } catch (err) {
            expect(axios.get).toHaveBeenCalledTimes(1);
            expect(err.errorCode).toEqual(_errorConst.UNKNOWN_ERROR);
        }
    });
    it(" =>  stylusClient.orders.status(ORDER_REFERENCE_ID) ", async () => {
        axios.get.mockImplementationOnce(() => Promise.reject({
            response: {
                data: "No order found",
                status: 500
            }
        }));
        try {
            await _mockClient.orders.get(MOCK_ORDER_ID);
            expect(true).toEqual(false);
        } catch (err) {
            expect(axios.get).toHaveBeenCalledTimes(1);
            expect(err.errorCode).toEqual(_errorConst.ORDER_ID_INVALID);
        }
    });
    it(" =>  stylusClient.orders.cancel(ORDER_REFERENCE_ID) ", async () => {
        axios.post.mockImplementationOnce(() => Promise.reject({
            data: {
                errorCode: _errorConst.UNKNOWN_ERROR
            },
            status: 500
        }));
        try {
            await _mockClient.orders.cancel(MOCK_ORDER_ID, MOCK_CANCEL_ORDER_REQUEST);
            expect(true).toEqual(false);
        } catch (err) {
            expect(axios.post).toHaveBeenCalledTimes(1);
            expect(err.errorCode).toEqual(_errorConst.UNKNOWN_ERROR);
        }
    });
    it(" =>  stylusClient.orders.cancel(ORDER_REFERENCE_ID) ", async () => {
        axios.post.mockImplementationOnce(() => Promise.reject({
            data: {
                errorCode:_errorConst.UNKNOWN_ERROR
            },
            status: 500
        }));
        try {
            await _mockClient.orders.cancel(MOCK_ORDER_ID, MOCK_CANCEL_ORDER_REQUEST);
            expect(true).toEqual(false);
        } catch (err) {
            expect(axios.post).toHaveBeenCalledTimes(1);
            expect(err.errorCode).toEqual(_errorConst.UNKNOWN_ERROR)
        }
    }); 
    it(" =>  stylusClient.orders.activities(ORDER_REFERENCE_ID) ", async () => {
        axios.get.mockImplementationOnce(() => Promise.reject({
            response: {
                data: "No order found",
                status: 404
            }
        }));
        try {
            await _mockClient.orders.activities(MOCK_ORDER_ID);
            expect(true).toEqual(false);
        } catch (err) {
            expect(axios.get).toHaveBeenCalledTimes(1);
            expect(err.errorCode).toEqual(_errorConst.ORDER_ID_INVALID);
        }
    });
    it(" =>  stylusClient.orders.create({ORDER_OBJECT}) ", async () => {
        axios.post.mockImplementationOnce(() => Promise.reject({
            response: {
                data: {
                    errorCode: "InvalidPayload"
                },
                status: 500
            }
        }));
        try {
            await _mockClient.orders.create(MOCK_CREATE_ORDER_REQUEST);
            expect(true).toEqual(false);
        } catch (err) {
            expect(axios.post).toHaveBeenCalledTimes(1);
            expect(err.errorCode).toEqual(_errorConst.ORDER_PAYLOAD_INVALID);
        }
    });
    it(" => stylusClient.orders.update(ORDER_REFERENCE_ID,{ORDER_UPDATE_OBJECT}) ", async () => {
        axios.patch.mockImplementationOnce(() => Promise.reject({
            response: {
                data: {
                    errorCode: "ProductNotFound"
                },
                status: 500
            }
        }));
        try {
            await _mockClient.orders.update(MOCK_ORDER_ID, MOCK_UPDATE_ORDER_REQUEST);
            expect(true).toEqual(false);
        } catch (err) {
            expect(axios.patch).toHaveBeenCalledTimes(1);
            expect(err.errorCode).toEqual(_errorConst.ORDER_PRODUCT_INVALID);
        }
    });
});