@mojaloop/sdk-scheme-adapter 12.0.0 → 12.1.0

package/test/unit/ControlServer/index.js

@@ -0,0 +1,231 @@
+/**************************************************************************
+ *  (C) Copyright ModusBox Inc. 2020 - All rights reserved.               *
+ *                                                                        *
+ *  This file is made available under the terms of the license agreement  *
+ *  specified in the corresponding source code repository.                *
+ *                                                                        *
+ *  ORIGINAL AUTHOR:                                                      *
+ *       Matt Kingston - matt.kingston@modusbox.com                       *
+ **************************************************************************/
+'use strict';
+
+const ws = require('ws');
+const jsonPatch = require('fast-json-patch');
+const randomPhrase = require('~/lib/randomphrase');
+const { getInternalEventEmitter, INTERNAL_EVENTS } = require('./events');
+
+const ControlServerEventEmitter = getInternalEventEmitter();
+
+
+/**************************************************************************
+ * The message protocol messages, verbs, and errors
+ *************************************************************************/
+const MESSAGE = {
+    CONFIGURATION: 'CONFIGURATION',
+    ERROR: 'ERROR',
+};
+
+const VERB = {
+    READ: 'READ',
+    NOTIFY: 'NOTIFY',
+    PATCH: 'PATCH'
+};
+
+const ERROR = {
+    UNSUPPORTED_MESSAGE: 'UNSUPPORTED_MESSAGE',
+    UNSUPPORTED_VERB: 'UNSUPPORTED_VERB',
+    JSON_PARSE_ERROR: 'JSON_PARSE_ERROR',
+};
+
+/**************************************************************************
+ * Private convenience functions
+ *************************************************************************/
+const serialise = JSON.stringify;
+const deserialise = (msg) => {
+    //reviver function
+    return JSON.parse(msg.toString(), (k, v) => {
+        if (
+            v !== null &&
+            typeof v === 'object' &&
+            'type' in v &&
+            v.type === 'Buffer' &&
+            'data' in v &&
+            Array.isArray(v.data)) {
+            return new Buffer(v.data);
+        }
+        return v;
+    });
+};
+
+
+const buildMsg = (verb, msg, data, id = randomPhrase()) => serialise({
+    verb,
+    msg,
+    data,
+    id,
+});
+
+const buildPatchConfiguration = (oldConf, newConf, id) => {
+    const patches = jsonPatch.compare(oldConf, newConf);
+    return buildMsg(VERB.PATCH, MESSAGE.CONFIGURATION, patches, id);
+};
+
+/**************************************************************************
+ * build
+ *
+ * Public object exposing an API to build valid protocol messages.
+ * It is not the only way to build valid messages within the protocol.
+ *************************************************************************/
+const build = {
+    CONFIGURATION: {
+        PATCH: buildPatchConfiguration,
+        READ: (id) => buildMsg(VERB.READ, MESSAGE.CONFIGURATION, {}, id),
+        NOTIFY: (config, id) => buildMsg(VERB.NOTIFY, MESSAGE.CONFIGURATION, config, id),
+    },
+    ERROR: {
+        NOTIFY: {
+            UNSUPPORTED_MESSAGE: (id) => buildMsg(VERB.NOTIFY, MESSAGE.ERROR, ERROR.UNSUPPORTED_MESSAGE, id),
+            UNSUPPORTED_VERB: (id) => buildMsg(VERB.NOTIFY, MESSAGE.ERROR, ERROR.UNSUPPORTED_VERB, id),
+            JSON_PARSE_ERROR: (id) => buildMsg(VERB.NOTIFY, MESSAGE.ERROR, ERROR.JSON_PARSE_ERROR, id),
+        }
+    },
+};
+
+/**************************************************************************
+ * Server
+ *
+ * The Control Server. Exposes a websocket control API.
+ * Used to hot-restart the SDK.
+ *
+ * logger    - Logger- see SDK logger used elsewhere
+ * port      - HTTP port to host on
+ * appConfig - The configuration for the entire application- supplied here as this class uses it to
+ *             validate reconfiguration requests- it is not used for configuration here, however
+ * server    - optional HTTP/S server on which to serve the websocket
+ *************************************************************************/
+class Server extends ws.Server {
+    constructor({ logger, appConfig = {} }) {
+        super({ clientTracking: true, port: appConfig.control.port });
+
+        this._logger = logger;
+        this._port = appConfig.control.port;
+        this._appConfig = appConfig;
+        this._clientData = new Map();
+
+        this.on('error', err => {
+            this._logger.push({ err })
+                .log('Unhandled websocket error occurred. Shutting down.');
+            process.exit(1);
+        });
+
+        this.on('connection', (socket, req) => {
+            const logger = this._logger.push({
+                url: req.url,
+                ip: 'localhost',
+                remoteAddress: req.socket.remoteAddress,
+            });
+            logger.log('Websocket connection received');
+            this._clientData.set(socket, { ip: req.connection.remoteAddress, logger });
+
+            socket.on('close', (code, reason) => {
+                logger.push({ code, reason }).log('Websocket connection closed');
+                this._clientData.delete(socket);
+            });
+
+            socket.on('message', this._handle(socket, logger));
+        });
+        this._logger.push(this.address()).log('running on');
+    }
+
+    // Close the server then wait for all the client sockets to close
+    async stop() {
+        await new Promise(this.close.bind(this));
+        this._logger.log('Control server shutdown complete');
+    }
+
+    _handle(client, logger) {
+        return (data) => {
+            // TODO: json-schema validation of received message- should be pretty straight-forward
+            // and will allow better documentation of the API
+            let msg;
+            try {
+                msg = deserialise(data);
+            } catch (err) {
+                logger.push({ data }).log('Couldn\'t parse received message');
+                client.send(build.ERROR.NOTIFY.JSON_PARSE_ERROR());
+            }
+            logger.push({ msg }).log('Handling received message');
+            switch (msg.msg) {
+                case MESSAGE.CONFIGURATION:
+                    switch (msg.verb) {
+                        case VERB.READ:
+                            (async () => {
+                                const jwsCerts = await this.populateConfig();
+                                client.send(build.CONFIGURATION.NOTIFY(jwsCerts, msg.id));
+                            })();
+                            break;
+                        default:
+                            client.send(build.ERROR.NOTIFY.UNSUPPORTED_VERB(msg.id));
+                            break;
+                    }
+                    break;
+                default:
+                    client.send(build.ERROR.NOTIFY.UNSUPPORTED_MESSAGE(msg.id));
+                    break;
+            }
+        };
+    }
+
+    async populateConfig(){
+        return this._appConfig;
+    }
+
+
+    /**
+     * Register this server instance to receive internal server messages
+     * from other modules.
+     */
+    registerInternalEvents() {
+        ControlServerEventEmitter.on(INTERNAL_EVENTS.SERVER.BROADCAST_CONFIG_CHANGE, (params) => {
+            this.broadcastConfigChange(params);
+        });
+    }
+
+    /**
+     * Broadcast configuration change to all connected clients.
+     *
+     * @param {object} params Updated configuration
+     */
+    async broadcastConfigChange(updatedConfig) {
+        const updateConfMsg = build.CONFIGURATION.PATCH({}, updatedConfig, randomPhrase());
+        const errorLogger = (socket, message) => (err) =>
+            this._logger
+                .push({ message, ip: this._clientData.get(socket).ip, err })
+                .log('Error sending JWS keys notification to client');
+        return await this.broadcast(updateConfMsg, errorLogger);
+    }
+
+    /**
+    * Broadcasts a protocol message to all connected clients.
+    *
+    * @param {string} msg
+    * @param {object} errorLogger
+    */
+    async broadcast(msg, errorLogger) {
+        const sendToAllClients = (msg, errorLogger) => Promise.all(
+            [...this.clients.values()].map((socket) =>
+                (new Promise((resolve) => socket.send(msg, resolve))).catch(errorLogger(socket, msg))
+            )
+        );
+        return await sendToAllClients(msg, errorLogger);
+    }
+}
+
+
+module.exports = {
+    Server,
+    build,
+    MESSAGE,
+    VERB,
+    ERROR,
+};

package/test/unit/ControlServer.test.js

@@ -0,0 +1,126 @@
+
+const ControlServer = require('~/ControlServer');
+const InboundServer = require('~/InboundServer');
+const OutboundServer = require('~/OutboundServer');
+const TestServer = require('~/TestServer');
+const defaultConfig = require('./data/defaultConfig.json');
+const { Logger } = require('@mojaloop/sdk-standard-components');
+
+jest.mock('~/lib/cache');
+const Cache = require('~/lib/cache');
+
+// TODO:
+// - diff against master to determine what else needs testing
+// - especially look for assertions in the code
+// - err.. grep the code for TODO
+
+describe('ControlServer', () => {
+    it('exposes a valid message API', () => {
+        expect(Object.keys(ControlServer.build).sort()).toEqual(
+            Object.keys(ControlServer.MESSAGE).sort(),
+            'The API exposed by the builder object must contain as top-level keys all of the message types exposed in the MESSAGE constant. Check that ControlServer.MESSAGE has the same keys as ControlServer.build.'
+        );
+        Object.entries(ControlServer.build).forEach(([messageType, builders]) => {
+            expect(Object.keys(ControlServer.VERB)).toEqual(
+                expect.arrayContaining(Object.keys(builders)),
+                `For message type '${messageType}' every builder must correspond to a verb. Check that ControlServer.build.${messageType} has the same keys as ControlServer.VERB.`
+            );
+        });
+        expect(Object.keys(ControlServer.build.ERROR.NOTIFY).sort()).toEqual(
+            Object.keys(ControlServer.ERROR).sort(),
+            'ControlServer.ERROR.NOTIFY should contain the same keys as ControlServer.ERROR'
+        );
+    });
+
+    describe('API', () => {
+        let server, logger, client;
+        const appConfig = { what: 'ever' };
+        const changedConfig = { ...appConfig, some: 'thing' };
+
+        beforeEach(async () => {
+            logger = new Logger.Logger({ stringify: () => '' });
+            server = new ControlServer.Server({ logger, appConfig });
+            client = await ControlServer.Client.Create({
+                address: 'localhost',
+                port: server.address().port,
+                logger
+            });
+        });
+
+        afterEach(async () => {
+            await server.stop();
+        });
+
+        it('supplies config when requested', async () => {
+            await client.send(ControlServer.build.CONFIGURATION.READ());
+            const response = await client.receive();
+            expect(response).toEqual({
+                ...JSON.parse(ControlServer.build.CONFIGURATION.NOTIFY(appConfig, response.id)),
+            });
+        });
+
+        it('emits new config when received', async () => {
+            const newConfigEvent = new Promise(
+                (resolve) => server.on(ControlServer.EVENT.RECONFIGURE, resolve)
+            );
+            await client.send(ControlServer.build.CONFIGURATION.PATCH(appConfig, changedConfig));
+            const newConfEventData = await newConfigEvent;
+            expect(newConfEventData).toEqual(changedConfig);
+        });
+
+        it('sends new config to clients when instructed', async () => {
+            const client2 = await ControlServer.Client.Create({
+                address: 'localhost',
+                port: server.address().port,
+                logger
+            });
+            const changedConfig = { ...appConfig, some: 'thing' };
+            await client.send(ControlServer.build.CONFIGURATION.PATCH(appConfig, changedConfig));
+            const restart = server.reconfigure({ appConfig: changedConfig });
+            restart();
+            await server.notifyClientsOfCurrentConfig();
+            const [notification, notification2] =
+                await Promise.all([client.receive(), client2.receive()]);
+            const expected = ControlServer.build.CONFIGURATION.NOTIFY(changedConfig, notification.id);
+            expect(JSON.stringify(notification)).toEqual(expected);
+            expect(JSON.stringify(notification2)).toEqual(expected);
+        });
+    });
+});
+
+describe('Server reconfigure methods', () => {
+    let conf, logger, cache;
+
+    const isPromise = (o) => Promise.resolve(o) === o;
+
+    beforeEach(() => {
+        conf = JSON.parse(JSON.stringify(defaultConfig));
+        logger = new Logger.Logger({ stringify: () => '' });
+        cache = new Cache({ ...conf.cacheConfig, logger: logger.push({ component: 'cache' }) });
+    });
+
+    test('InboundServer reconfigure method returns sync function', async () => {
+        const server = new InboundServer(conf, logger, cache);
+        const res = await server.reconfigure(conf, logger, cache);
+        expect(isPromise(res)).toEqual(false);
+    });
+
+    test('OutboundServer reconfigure method returns sync function', async () => {
+        const server = new OutboundServer(conf, logger, cache);
+        const res = await server.reconfigure(conf, logger, cache);
+        expect(isPromise(res)).toEqual(false);
+    });
+
+    test('TestServer reconfigure method returns sync function', async () => {
+        const server = new TestServer({ logger, cache });
+        const res = await server.reconfigure({ logger, cache });
+        expect(isPromise(res)).toEqual(false);
+    });
+
+    test('ControlServer reconfigure method returns sync function', async () => {
+        const server = new ControlServer.Server({ logger, appConfig: {} });
+        const res = await server.reconfigure({ logger, appConfig: {} });
+        expect(isPromise(res)).toEqual(false);
+        await server.close();
+    });
+});

package/test/unit/InboundServer.test.js

@@ -18,11 +18,11 @@ const postQuotesBody = require('./data/postQuotesBody');
 const putParticipantsBody = require('./data/putParticipantsBody');
 const commonHttpHeaders = require('./data/commonHttpHeaders');
 
-jest.mock('../../lib/cache');
+jest.mock('~/lib/cache');
 jest.mock('@mojaloop/sdk-standard-components');
-jest.mock('../../lib/model/lib/requests', () => require('./lib/model/mockedLibRequests'));
+jest.mock('~/lib/model/lib/requests', () => require('./lib/model/mockedLibRequests'));
 
-const Cache = require('../../lib/cache');
+const Cache = require('~/lib/cache');
 const { Jws, Logger } = require('@mojaloop/sdk-standard-components');
 const path = require('path');
 const fs = require('fs');
@@ -30,7 +30,7 @@ const os = require('os');
 const http = require('http');
 const https = require('https');
 
-const InboundServer = require('../../InboundServer');
+const InboundServer = require('~/InboundServer');
 
 describe('Inbound Server', () => {
     describe('PUT /parties', () => {
@@ -376,7 +376,7 @@ describe('Inbound Server', () => {
 
         afterEach(async () => {
             await svr.stop();
-            fs.rmdirSync(keysDir, { recursive: true });
+            fs.rmSync(keysDir, { recursive: true });
         });
 
         it('updates server configuration when a new JWS verification key '

package/test/unit/TestServer.test.js

@@ -20,13 +20,13 @@ const commonHttpHeaders = require('./data/commonHttpHeaders');
 const WebSocket = require('ws');
 const { Logger } = require('@mojaloop/sdk-standard-components');
 
-jest.mock('../../lib/cache');
+jest.mock('~/lib/cache');
 jest.mock('@mojaloop/sdk-standard-components');
-jest.mock('../../lib/model/lib/requests', () => require('./lib/model/mockedLibRequests'));
+jest.mock('~/lib/model/lib/requests', () => require('./lib/model/mockedLibRequests'));
 
-const Cache = require('../../lib/cache');
-const InboundServer = require('../../InboundServer');
-const TestServer = require('../../TestServer');
+const Cache = require('~/lib/cache');
+const InboundServer = require('~/InboundServer');
+const TestServer = require('~/TestServer');
 
 const createWsClient = async (port, path) => {
     const result = new WebSocket(`ws://127.0.0.1:${port}${path}`);

package/test/unit/api/utils.js

@@ -2,12 +2,12 @@ const fs = require('fs');
 const path = require('path');
 const yaml = require('js-yaml');
 const supertest = require('supertest');
-const Validate = require('../../../lib/validate');
+const Validate = require('~/lib/validate');
 
-const InboundServer = require('../../../InboundServer');
-const OutboundServer = require('../../../OutboundServer');
+const InboundServer = require('~/InboundServer');
+const OutboundServer = require('~/OutboundServer');
 const { Logger } = require('@mojaloop/sdk-standard-components');
-const Cache = require('../../../lib/cache');
+const Cache = require('~/lib/cache');
 
 /**
  * Get OpenAPI spec and Validator for specified server
@@ -15,7 +15,7 @@ const Cache = require('../../../lib/cache');
  * @return {Promise<{apiSpecs: Object, validator: Validator}>}
  */
 const readApiInfo = async (serverType) => {
-    const specPath = path.join(__dirname, `../../../${serverType}/api.yaml`);
+    const specPath = path.join(__dirname, `../../../src/${serverType}/api.yaml`);
     const apiSpecs = yaml.load(fs.readFileSync(specPath));
     const validator = new Validate();
     await validator.initialise(apiSpecs);

package/test/unit/config.test.js

@@ -28,36 +28,37 @@ describe('config', () => {
         process.env.BACKEND_ENDPOINT = '172.17.0.5:4000';
         process.env.CACHE_HOST = '172.17.0.2';
         process.env.CACHE_PORT = '6379';
+        process.env.MGMT_API_WS_URL = '0.0.0.0';
         certDir = fs.mkdtempSync(path.join(os.tmpdir(), 'jest-'));
     });
 
     afterEach(() => {
         process.env = { ...env };
-        fs.rmdirSync(certDir, { recursive: true });
+        fs.rmSync(certDir, { recursive: true });
         jest.resetModules();
     });
 
     it('correctly parses OUTBOUND_ERROR_STATUSCODE_EXTENSION_KEY when set', () => {
         process.env.OUTBOUND_ERROR_STATUSCODE_EXTENSION_KEY = outErrorStatusKey;
-        const config = require('../../config');
+        const config = require('~/config');
         expect(config.outboundErrorStatusCodeExtensionKey).toEqual(outErrorStatusKey);
     });
 
     it('correctly parses OUTBOUND_ERROR_STATUSCODE_EXTENSION_KEY when NOT set', () => {
         delete process.env.OUTBOUND_ERROR_STATUSCODE_EXTENSION_KEY;
-        const config = require('../../config');
+        const config = require('~/config');
         expect(config.outboundErrorStatusCodeExtensionKey).toBeUndefined();
     });
 
     it('correctly parses VALIDATE_INBOUND_PUT_PARTIES_JWS when NOT set', () => {
         delete process.env.VALIDATE_INBOUND_PUT_PARTIES_JWS;
-        const config = require('../../config');
+        const config = require('~/config');
         expect(config.validateInboundPutPartiesJws).toBeFalsy();
     });
 
     it('correctly parses VALIDATE_INBOUND_PUT_PARTIES_JWS when set', () => {
         process.env.VALIDATE_INBOUND_PUT_PARTIES_JWS = 'true';
-        const config = require('../../config');
+        const config = require('~/config');
         expect(config.validateInboundPutPartiesJws).toBeTruthy();
     });
 
@@ -66,7 +67,7 @@ describe('config', () => {
         const certContent = 'cert-data';
         fs.writeFileSync(cert, certContent);
         process.env.IN_SERVER_CERT_PATH = cert;
-        const config = require('../../config');
+        const config = require('~/config');
         const content = config.mutualTLS.inboundRequests.creds.cert.toString();
         expect(content).toBe(certContent);
     });
@@ -82,14 +83,14 @@ describe('config', () => {
         ];
         certs.forEach((cert, index) => fs.writeFileSync(cert, certContent[index]));
         process.env.IN_CA_CERT_PATH = certs.join(',');
-        const config = require('../../config');
+        const config = require('~/config');
         const content = config.mutualTLS.inboundRequests.creds.ca.map(ca => ca.toString());
         expect(content).toStrictEqual(certContent);
     });
 
     it('should parse proxy config yaml file as json object', () => {
         process.env.PROXY_CONFIG_PATH = path.join(__dirname, './data/testFile.yaml');
-        const config = require('../../config');
+        const config = require('~/config');
         const proxyConfig = require('./data/testFile');
         expect(config.proxyConfig).toEqual(proxyConfig);
     });
@@ -107,12 +108,12 @@ describe('config', () => {
             },
 
         };
-        const parseResourceVersion = require('../../config').__parseResourceVersion;
+        const parseResourceVersion = require('~/config').__parseResourceVersion;
         expect(parseResourceVersion('resourceOneName=1.0,resourceTwoName=1.1')).toEqual(resourceVersions);
     });
 
     it('should throw an err if the resource string is not correctly formed', () => {
-        const parseResourceVersion = require('../../config').__parseResourceVersion;
+        const parseResourceVersion = require('~/config').__parseResourceVersion;
         expect(() => parseResourceVersion('resourceOneName=1.0;resourceTwoName=1.1')).toThrowError(new Error('Resource versions format should be in format: "resouceOneName=1.0,resourceTwoName=1.1"'));
     });
 

package/test/unit/inboundApi/handlers.test.js

@@ -10,13 +10,13 @@
 
 'use strict';
 
-jest.mock('../../../lib/model');
+jest.mock('~/lib/model');
 
-const handlers = require('../../../InboundServer/handlers');
-const Model = require('../../../lib/model').InboundTransfersModel;
-const QuotesModel = require('../../../lib/model').QuotesModel;
-const PartiesModel = require('../../../lib/model').PartiesModel;
-const TransfersModel = require('../../../lib/model').TransfersModel;
+const handlers = require('~/InboundServer/handlers');
+const Model = require('~/lib/model').InboundTransfersModel;
+const QuotesModel = require('~/lib/model').QuotesModel;
+const PartiesModel = require('~/lib/model').PartiesModel;
+const TransfersModel = require('~/lib/model').TransfersModel;
 
 const mockArguments = require('./data/mockArguments');
 const mockTransactionRequestData = require('./data/mockTransactionRequest');

package/test/unit/index.test.js

@@ -21,8 +21,9 @@ process.env.PEER_ENDPOINT = '172.17.0.3:4000';
 process.env.BACKEND_ENDPOINT = '172.17.0.5:4000';
 process.env.CACHE_HOST = '172.17.0.2';
 process.env.CACHE_PORT = '6379';
+process.env.MGMT_API_WS_URL = '0.0.0.0';
 
-const index = require('../../index.js');
+const index = require('~/index.js');
 
 describe('index.js', () => {
     test('WSO2 error events in OutboundServer propagate to top-level server', () => {

package/test/unit/lib/cache.test.js

@@ -12,7 +12,7 @@
 
 jest.mock('redis');
 
-const Cache = require('../../../lib/cache');
+const Cache = require('~/lib/cache');
 const { Logger } = require('@mojaloop/sdk-standard-components');
 
 const createCache = async() => {

package/test/unit/lib/model/AccountsModel.test.js

@@ -14,8 +14,8 @@
 jest.mock('@mojaloop/sdk-standard-components');
 jest.mock('redis');
 
-const Cache = require('../../../../lib/cache');
-const { AccountsModel } = require('../../../../lib/model');
+const Cache = require('~/lib/cache');
+const { AccountsModel } = require('~/lib/model');
 
 const StateMachine = require('javascript-state-machine');
 const { MojaloopRequests, Logger } = require('@mojaloop/sdk-standard-components');

package/test/unit/lib/model/InboundTransfersModel.test.js

@@ -12,16 +12,16 @@
 // we use a mock standard components lib to intercept and mock certain funcs
 jest.mock('@mojaloop/sdk-standard-components');
 jest.mock('redis');
-jest.mock('../../../../lib/model/lib/requests',() => require('./mockedLibRequests'));
+jest.mock('~/lib/model/lib/requests',() => require('./mockedLibRequests'));
 
 const defaultConfig = require('./data/defaultConfig');
-const Model = require('../../../../lib/model').InboundTransfersModel;
+const Model = require('~/lib/model').InboundTransfersModel;
 const mockArguments = require('./data/mockArguments');
 const mockTxnReqquestsArguments = require('./data/mockTxnRequestsArguments');
 const { MojaloopRequests, Ilp, Logger } = require('@mojaloop/sdk-standard-components');
-const { BackendRequests, HTTPResponseError } = require('../../../../lib/model/lib/requests');
-const Cache = require('../../../../lib/cache');
-const shared = require('../../../../lib/model/lib/shared');
+const { BackendRequests, HTTPResponseError } = require('~/lib/model/lib/requests');
+const Cache = require('~/lib/cache');
+const shared = require('~/lib/model/lib/shared');
 
 const getTransfersBackendResponse = require('./data/getTransfersBackendResponse');
 const getTransfersMojaloopResponse = require('./data/getTransfersMojaloopResponse');

package/test/unit/lib/model/OutboundBulkQuotesModel.test.js

@@ -14,8 +14,8 @@
 jest.mock('@mojaloop/sdk-standard-components');
 jest.mock('redis');
 
-const Cache = require('../../../../lib/cache');
-const Model = require('../../../../lib/model').OutboundBulkQuotesModel;
+const Cache = require('~/lib/cache');
+const Model = require('~/lib/model').OutboundBulkQuotesModel;
 
 const { MojaloopRequests, Logger } = require('@mojaloop/sdk-standard-components');
 const StateMachine = require('javascript-state-machine');

package/test/unit/lib/model/OutboundBulkTransfersModel.test.js

@@ -14,8 +14,8 @@
 jest.mock('@mojaloop/sdk-standard-components');
 jest.mock('redis');
 
-const Cache = require('../../../../lib/cache');
-const Model = require('../../../../lib/model').OutboundBulkTransfersModel;
+const Cache = require('~/lib/cache');
+const Model = require('~/lib/model').OutboundBulkTransfersModel;
 
 const { MojaloopRequests, Logger } = require('@mojaloop/sdk-standard-components');
 const StateMachine = require('javascript-state-machine');

package/test/unit/lib/model/OutboundRequestToPayModel.test.js

@@ -14,9 +14,9 @@
 jest.mock('@mojaloop/sdk-standard-components');
 jest.mock('redis');
 
-const Cache = require('../../../../lib/cache');
-const Model = require('../../../../lib/model').OutboundRequestToPayModel;
-const PartiesModel = require('../../../../lib/model').PartiesModel;
+const Cache = require('~/lib/cache');
+const Model = require('~/lib/model').OutboundRequestToPayModel;
+const PartiesModel = require('~/lib/model').PartiesModel;
 
 const { MojaloopRequests, Logger } = require('@mojaloop/sdk-standard-components');
 const StateMachine = require('javascript-state-machine');

package/test/unit/lib/model/OutboundRequestToPayTransferModel.test.js

@@ -14,8 +14,8 @@
 jest.mock('@mojaloop/sdk-standard-components');
 jest.mock('redis');
 
-const Cache = require('../../../../lib/cache');
-const Model = require('../../../../lib/model').OutboundRequestToPayTransferModel;
+const Cache = require('~/lib/cache');
+const Model = require('~/lib/model').OutboundRequestToPayTransferModel;
 
 const { MojaloopRequests, Logger } = require('@mojaloop/sdk-standard-components');
 const StateMachine = require('javascript-state-machine');

package/test/unit/lib/model/OutboundTransfersModel.test.js

@@ -14,9 +14,9 @@
 jest.mock('@mojaloop/sdk-standard-components');
 jest.mock('redis');
 
-const Cache = require('../../../../lib/cache');
-const Model = require('../../../../lib/model').OutboundTransfersModel;
-const PartiesModel = require('../../../../lib/model').PartiesModel;
+const Cache = require('~/lib/cache');
+const Model = require('~/lib/model').OutboundTransfersModel;
+const PartiesModel = require('~/lib/model').PartiesModel;
 
 const { MojaloopRequests, Logger } = require('@mojaloop/sdk-standard-components');
 const StateMachine = require('javascript-state-machine');