@mojaloop/sdk-scheme-adapter 11.18.8

package/test/unit/api/accounts/data/postAccountsBody.json

@@ -0,0 +1,7 @@
+[
+  {
+    "idType": "MSISDN",
+    "idValue": "123456789",
+    "currency": "USD"
+  }
+]

package/test/unit/api/accounts/data/postAccountsErrorMojaloopResponse.json

@@ -0,0 +1,25 @@
+{
+  "executionState": {
+    "accounts": [
+      {
+        "currency": "USD",
+        "idType": "MSISDN",
+        "idValue": "123456789"
+      }
+    ],
+    "currentState": "ERROR_OCCURRED",
+    "lastError": {
+      "httpStatusCode": 500,
+      "mojaloopError": {
+        "errorInformation": {
+          "errorCode": "3204",
+          "errorDescription": "Party not found"
+        }
+      }
+    },
+    "modelId": "00000000-0000-1000-8000-000000000001",
+    "response": []
+  },
+  "message": "Got an error response creating accounts: {\n  errorInformation: { errorCode: '3204', errorDescription: 'Party not found' }\n}",
+  "statusCode": "3204"
+}

package/test/unit/api/accounts/data/postAccountsErrorTimeoutResponse.json

@@ -0,0 +1,19 @@
+{
+  "executionState": {
+    "accounts": [
+      {
+        "currency": "USD",
+        "idType": "MSISDN",
+        "idValue": "123456789"
+      }
+    ],
+    "currentState": "ERROR_OCCURRED",
+    "lastError": {
+      "httpStatusCode": 504
+    },
+    "modelId": "00000000-0000-1000-8000-000000000001",
+    "response": []
+  },
+  "message": "Timeout waiting for response to account creation request 00000000-0000-1000-8000-000000000002",
+  "statusCode": "504"
+}

package/test/unit/api/accounts/data/postAccountsSuccessResponse.json

@@ -0,0 +1,17 @@
+{
+  "accounts": [
+    {
+      "currency": "USD",
+      "idType": "MSISDN",
+      "idValue": "123456789"
+    }
+  ],
+  "currentState": "COMPLETED",
+  "modelId": "00000000-0000-1000-8000-000000000001",
+  "response": [
+    {
+      "idType": "MSISDN",
+      "idValue": "123456789"
+    }
+  ]
+}

package/test/unit/api/accounts/data/postAccountsSuccessResponseWithError1.json

@@ -0,0 +1,21 @@
+{
+  "accounts": [
+    {
+      "currency": "USD",
+      "idType": "MSISDN",
+      "idValue": "123456789"
+    }
+  ],
+  "currentState": "COMPLETED",
+  "modelId": "00000000-0000-1000-8000-000000000001",
+  "response": [
+    {
+      "error": {
+        "message": "Provided currency not supported",
+        "statusCode": "3000"
+      },
+      "idType": "MSISDN",
+      "idValue": "123456789"
+    }
+  ]
+}

package/test/unit/api/accounts/data/postAccountsSuccessResponseWithError2.json

@@ -0,0 +1,21 @@
+{
+  "accounts": [
+    {
+      "currency": "USD",
+      "idType": "MSISDN",
+      "idValue": "123456789"
+    }
+  ],
+  "currentState": "COMPLETED",
+  "modelId": "00000000-0000-1000-8000-000000000001",
+  "response": [
+    {
+      "error": {
+        "message": "Party not found",
+        "statusCode": "3204"
+      },
+      "idType": "MSISDN",
+      "idValue": "123456789"
+    }
+  ]
+}

package/test/unit/api/accounts/utils.js

@@ -0,0 +1,65 @@
+const nock = require('nock');
+const OpenAPIResponseValidator = require('openapi-response-validator').default;
+
+const defaultConfig = require('../../data/defaultConfig');
+const postAccountsBody = require('./data/postAccountsBody');
+
+/**
+ *
+ * @param reqInbound
+ * @param reqOutbound
+ * @param apiSpecsOutbound
+ * @returns Function(putBodyFn:function, responseCode:number, responseBody:object) => Promise
+ */
+function createPostAccountsTester({ reqInbound, reqOutbound, apiSpecsOutbound }) {
+    /**
+     *
+     * @param putBodyFn {function}
+     * @param responseCode {number}
+     * @param responseBody {object}
+     *
+     * @return {Promise<any>}
+     */
+    return async (putBodyFn, responseCode, responseBody) => {
+        let pendingRequest = Promise.resolve();
+        const endpoint = new URL(`http://${defaultConfig.alsEndpoint}`).host;
+        const switchEndpoint = `http://${endpoint}`;
+
+        const sendPutParticipants = async (requestBody) => {
+            const body = JSON.parse(requestBody);
+            const putBody = await Promise.resolve(putBodyFn(body));
+            let putUrl = `/participants/${body.requestId}`;
+            if (putBody.errorInformation) {
+                putUrl += '/error';
+            }
+
+            return reqInbound.put(putUrl)
+                .send(putBody)
+                .set('Date', new Date().toISOString())
+                .set('content-type', 'application/vnd.interoperability.participants+json;version=1.0')
+                .set('fspiop-source', 'mojaloop-sdk')
+                .expect(200);
+        };
+
+        await nock(switchEndpoint)
+            .post('/participants')
+            .reply(202, (_, requestBody) => {
+                pendingRequest = sendPutParticipants(requestBody).then();
+            });
+
+        const res = await reqOutbound.post('/accounts').send(postAccountsBody);
+        const {body} = res;
+        expect(res.statusCode).toEqual(responseCode);
+        expect(body).toEqual(responseBody);
+        const responseValidator = new OpenAPIResponseValidator(apiSpecsOutbound.paths['/accounts'].post);
+        const err = responseValidator.validateResponse(responseCode, body);
+        if (err) {
+            throw err;
+        }
+        await pendingRequest;
+    };
+}
+
+module.exports = {
+    createPostAccountsTester,
+};

package/test/unit/api/proxy/data/proxyConfig.yaml

@@ -0,0 +1,82 @@
+version: 1.0
+routes:
+  - description: 'Routing by URL path as string'
+    match:
+      - path: /sdk-path-test-1
+    destination:
+      path: /switch-path-test-1
+
+  - description: 'Routing by URL path as regexp'
+    match:
+      - path: ~ ^\/sdk-.*2$
+    destination:
+      path: /switch-path-test-2
+
+  - description: 'Routing by Query params with regexp'
+    match:
+      - path: /sdk-path-test-3
+        query:
+          - key: queryString1One
+            value: Value1
+          - key: ~ query.*2Two
+            value: ~ val.*2
+    destination:
+      path: /switch-path-test-3
+
+  - description: 'Routing by Query params'
+    match:
+      - query:
+          - key: testParam3
+            value: testValue3
+    destination:
+      path: /switch-path-test-3-1
+
+  - description: 'Routing by Header params with regexp'
+    match:
+      - headers:
+          - name: customHeader2
+            value: ~ .*stomval.*
+          - name: ~ cus.*header3
+            value: ~ .*
+    destination:
+      path: /switch-path-test-4
+
+  - description: 'Routing by Header params should work'
+    match:
+      - path: /sdk-path-test-4
+        headers:
+          - name: customReq-Header2
+            value: ~ .*eq-va.*
+          - name: ~ .*header3
+            value: ~ .*
+    destination:
+      path: /switch-path-test-4
+
+  - description: 'Routing by Header values'
+    match:
+      - headers:
+          - name: ~ *
+            value: ~ .*st.*val.*
+          - name: ~ *
+            value: ~ .*st.*value5
+    destination:
+      path: '/switch-path-test-5'
+
+  - description: 'Routing by multiple match rules'
+    match:
+      - path: ~ /sdk-.*-8
+        headers:
+          - name: requiredName
+            value: yes
+      - headers:
+          - name: ~ .*hkey81
+            value: ~ *
+      - headers:
+          - name: ~ .*hkey82
+            value: ~ *
+      - query:
+          - key: ~ .*qkey81
+            value: ~ *
+
+    destination:
+      path: '/switch-path-test-8'

package/test/unit/api/proxy/data/requestBody.json

@@ -0,0 +1,22 @@
+{
+  "pipe": {
+    "gate": {
+      "wonder": "pie",
+      "motion": -1954091019.282176,
+      "sat": -1408621945.196569,
+      "paint": false,
+      "mass": "cool",
+      "ship": 301008758.9371433
+    },
+    "rear": false,
+    "kept": true,
+    "shape": "bottle",
+    "shine": 190280734.75563002,
+    "shown": -822072188
+  },
+  "trip": -995941977,
+  "anybody": -1773044919,
+  "shoe": -1775269105,
+  "market": "room",
+  "your": "pilot"
+}

package/test/unit/api/proxy/data/requestHeaders.json

@@ -0,0 +1,5 @@
+{
+  "ReqHeader1": "re11",
+  "Req-Header2": "some-req-value",
+  "Req-header3": "22"
+}

package/test/unit/api/proxy/data/requestQuery.json

@@ -0,0 +1,6 @@
+{
+  "queryString1One": "Value1",
+  "queryString2Two": "Value2",
+  "queryString3Three": "Value3",
+  "queryString4Four": "Value4"
+}

package/test/unit/api/proxy/data/responseBody.json

@@ -0,0 +1,21 @@
+{
+  "sample": "pick",
+  "drop": [
+    {
+      "stretch": "raise",
+      "cloud": "area",
+      "mysterious": "slide",
+      "system": "headed",
+      "human": -935415263.1668315
+    },
+    -1910628437.0222688,
+    1097437779,
+    728983216,
+    true,
+    "percent"
+  ],
+  "low": "material",
+  "discussion": "studying",
+  "leather": -1095320503,
+  "spent": true
+}

package/test/unit/api/proxy/data/responseHeaders.json

@@ -0,0 +1,5 @@
+{
+  "CustomHeader1": "*",
+  "Custom-Header2": "some-value",
+  "custom-header3": "ddd"
+}

package/test/unit/api/proxy/proxy.test.js

@@ -0,0 +1,220 @@
+/**************************************************************************
+ *  (C) Copyright ModusBox Inc. 2019 - All rights reserved.               *
+ *                                                                        *
+ *  This file is made available under the terms of the license agreement  *
+ *  specified in the corresponding source code repository.                *
+ *                                                                        *
+ *  ORIGINAL AUTHOR:                                                      *
+ *       Yevhen Kyriukha - yevhen.kyriukha@modusbox.com                   *
+ **************************************************************************/
+
+'use strict';
+
+jest.unmock('@mojaloop/sdk-standard-components');
+jest.mock('redis');
+
+const yaml = require('js-yaml');
+const path = require('path');
+const fs = require('fs');
+
+const { createTestServers, destroyTestServers } = require('../utils');
+const { createProxyTester } = require('./utils');
+
+const defaultConfig = require('../../data/defaultConfig');
+
+defaultConfig.peerEndpoint = `${defaultConfig.peerEndpoint}/abc/def`;
+
+describe('Proxy', () => {
+    let serversInfo;
+    let testProxy;
+
+    const configPath = path.join(__dirname, 'data', 'proxyConfig.yaml');
+    const proxyConfig = yaml.load(fs.readFileSync(configPath));
+
+    beforeEach(async () => {
+        serversInfo = await createTestServers({
+            ...defaultConfig,
+            proxyConfig,
+        });
+        testProxy = createProxyTester({
+            reqOutbound: serversInfo.reqOutbound,
+        });
+    });
+
+    afterEach(async () => {
+        await destroyTestServers(serversInfo);
+    });
+
+    test('should return success POST response', async () =>
+        testProxy({
+            sdkUrlPath: '/sdk-path-test-1',
+            method: 'POST',
+            query: {},
+            headers: {},
+            switchUrlPath: '/switch-path-test-1',
+            shouldForward: true,
+        }));
+
+    test('should return success PUT response', async () =>
+        testProxy({
+            sdkUrlPath: '/sdk-path-test-1',
+            method: 'PUT',
+            query: {},
+            headers: {},
+            switchUrlPath: '/switch-path-test-1',
+            shouldForward: true,
+        }));
+
+    test('should return success GET response', async () =>
+        testProxy({
+            sdkUrlPath: '/sdk-path-test-1',
+            method: 'GET',
+            query: {},
+            headers: {},
+            switchUrlPath: '/switch-path-test-1',
+            shouldForward: true,
+        }));
+
+    test('should return error response', async () =>
+        testProxy({
+            sdkUrlPath: '/unknown-sdk-path-test-1',
+            method: 'POST',
+            query: {},
+            headers: {},
+            switchUrlPath: '/switch-path-test-1',
+            shouldForward: false,
+        }));
+
+    test('should forward by path regexp', async () =>
+        testProxy({
+            sdkUrlPath: '/sdk-path-test-2',
+            method: 'POST',
+            query: {},
+            headers: {},
+            switchUrlPath: '/switch-path-test-2',
+            shouldForward: true,
+        }));
+
+    test('should forward by query params', async () =>
+        testProxy({
+            sdkUrlPath: '/sdk-path-test',
+            method: 'POST',
+            query: { testParam3: 'testValue3' },
+            headers: {},
+            switchUrlPath: '/switch-path-test-3-1',
+            shouldForward: true,
+        }));
+
+    test('should not forward by query params', async () =>
+        testProxy({
+            sdkUrlPath: '/sdk-path-test',
+            method: 'POST',
+            query: { testParam3: 'testValue4' },
+            headers: {},
+            switchUrlPath: '/switch-path-test-3-1',
+            shouldForward: false,
+        }));
+
+    test('should forward by header params', async () =>
+        testProxy({
+            sdkUrlPath: '/sdk-path-test',
+            method: 'POST',
+            query: { },
+            headers: {
+                customHeader2: 'customValue2',
+                customHeader3: 'other value'
+            },
+            switchUrlPath: '/switch-path-test-4',
+            shouldForward: true,
+        }));
+
+    test('should not forward by header params', async () =>
+        testProxy({
+            sdkUrlPath: '/sdk-path-test',
+            method: 'POST',
+            query: { },
+            headers: {
+                customHeader2: 'customValue2',
+            },
+            switchUrlPath: '/switch-path-test-4',
+            shouldForward: false,
+        }));
+
+    test('should forward by header values', async () =>
+        testProxy({
+            sdkUrlPath: '/sdk-path-test',
+            method: 'POST',
+            query: { },
+            headers: {
+                someHeader1: 'someCustomValue',
+                someHeader2: 'customValue5',
+            },
+            switchUrlPath: '/switch-path-test-5',
+            shouldForward: true,
+        }));
+
+    test('should forward using multi-match rule (path and headers)', async () =>
+        testProxy({
+            sdkUrlPath: '/sdk-path-test-8',
+            method: 'POST',
+            query: { },
+            headers: {
+                requiredName: 'yes',
+            },
+            switchUrlPath: '/switch-path-test-8',
+            shouldForward: true,
+        }));
+
+    test('should not forward using multi-match rule (wrong headers)', async () =>
+        testProxy({
+            sdkUrlPath: '/sdk-path-test-8',
+            method: 'POST',
+            query: { },
+            headers: {
+                requiredName: 'no',
+            },
+            switchUrlPath: '/switch-path-test-8',
+            shouldForward: false,
+        }));
+
+    test('should forward using multi-match rule (query)', async () =>
+        testProxy({
+            sdkUrlPath: '/sdk-path-test-8',
+            method: 'POST',
+            query: { customQkey81: 'some qval' },
+            headers: {
+                requiredName: 'no',
+            },
+            switchUrlPath: '/switch-path-test-8',
+            shouldForward: true,
+        }));
+
+    test('should forward using multi-match rule (headers)', async () =>
+        testProxy({
+            sdkUrlPath: '/sdk-path-test-8',
+            method: 'POST',
+            query: { customQkey81Unknown: 'some qval' },
+            headers: {
+                requiredName: 'no',
+                SomeHKEY82: 'some val',
+                'content-type': 'application/json',
+            },
+            switchUrlPath: '/switch-path-test-8',
+            shouldForward: true,
+        }));
+
+    test('should handle binary response', async () =>
+        testProxy({
+            sdkUrlPath: '/sdk-path-test-8',
+            method: 'POST',
+            query: { customQkey81Unknown: 'some qval' },
+            headers: {
+                requiredName: 'no',
+                SomeHKEY82: 'some val',
+                'content-type': 'application/json',
+            },
+            switchUrlPath: '/switch-path-test-8',
+            shouldForward: true,
+            binary: true,
+        }));
+});