@stylusapparel/opv3-merchant-api-nodejs
Version:
This is the official NodeJs wrapper for connecting to the StylusOP API V3
216 lines (210 loc) • 8.01 kB
JavaScript
const axios = require("axios");
const { __defaults } = require("../constants/url");
const __mockWrapper = require("../index");
const { MOCK_SECRET_TOKEN, MOCK_MERCHANT_ID, MOCK_MERCHANT_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 {OAUTH_TOKEN_RESPONSE} = require("./__mocks__/auth.json");
const { _errorConst } = require("../constants/const");
const error = require("../lib/error");
// Set the API URL to the local API for testing in development
process.env.STYLUSOP_API_URL = 'http://localhost:3600/api/';
const _mockClient = __mockWrapper.createClient(MOCK_MERCHANT_ID, MOCK_SECRET_TOKEN,
{ apiVersion: __defaults.LATEST_VERSION, sandbox: true, merchantName: MOCK_MERCHANT_NAME, maxRetries: 0 }
);
afterEach(() => {
jest.clearAllMocks();
});
beforeEach(async () => {
axios.post.mockImplementationOnce(() =>
Promise.resolve({
data: { ...OAUTH_TOKEN_RESPONSE },
status: 200,
}),
);
await _mockClient.oauthToken();
});
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();
expect(axios.get).toHaveBeenCalledTimes(1);
const { orders, page, count } = MOCK_LIST_ORDERS_RESPONSE;
expect(gen).toEqual({ orders, page, count });
});
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.activities)
});
it(" => stylusClient.orders.cancel(ORDER_REFERENCE_ID) ", async () => {
axios.patch.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.patch).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(2);
expect(gen).toEqual({ "orderKey": MOCK_CREATE_ORDER_RESPONSE.orderKey })
});
it(" => stylusClient.orders.update(ORDER_REFERENCE_ID,{ORDER_UPDATE_OBJECT}) ", async () => {
axios.put.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.put).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: {
error: {
errorCode: "OrderNotFound"
}
},
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: {
error: {
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.cancel(ORDER_KEY) ", async () => {
axios.patch.mockImplementationOnce(() => Promise.reject({
data: {
error: {
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.patch).toHaveBeenCalledTimes(1);
expect(err.errorCode).toEqual(_errorConst.UNKNOWN_ERROR);
}
});
it(" => stylusClient.orders.activities(ORDER_KEY) ", async () => {
axios.get.mockImplementationOnce(() => Promise.reject({
response: {
data: {
error: {
errorCode: "OrderNotFound"
}
},
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: {
error: {
errorCode: "InvalidPayload"
}
},
status: 500
}
}));
try {
await _mockClient.orders.create(MOCK_CREATE_ORDER_REQUEST);
expect(true).toEqual(false);
} catch (err) {
expect(axios.post).toHaveBeenCalledTimes(2);
expect(err.errorCode).toEqual(_errorConst.ORDER_PAYLOAD_INVALID);
}
});
it(" => stylusClient.orders.update(ORDER_REFERENCE_ID,{ORDER_UPDATE_OBJECT}) ", async () => {
axios.put.mockImplementationOnce(() => Promise.reject({
response: {
data: {
error: {
errorCode: "ProductNotFound"
}
},
status: 500
}
}));
try {
await _mockClient.orders.update(MOCK_ORDER_ID, MOCK_UPDATE_ORDER_REQUEST);
expect(true).toEqual(false);
} catch (err) {
expect(axios.put).toHaveBeenCalledTimes(1);
expect(err.errorCode).toEqual(_errorConst.ORDER_PRODUCT_INVALID);
}
});
});