@mojaloop/sdk-scheme-adapter 11.18.8

package/test/unit/mockLogger.js

@@ -0,0 +1,39 @@
+/**************************************************************************
+ *  (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:                                                      *
+ *       Paweł Marzec - pawel.marzec@modusbox.com                         *
+ **************************************************************************/
+
+const { Logger } = require('@mojaloop/sdk-standard-components');
+
+function mockLogger(context, keepQuiet) {
+    // if keepQuite is undefined then be quiet
+    if (keepQuiet || typeof keepQuiet === 'undefined') {
+        const methods = {
+            // log methods
+            log: jest.fn(),
+      
+            configure: jest.fn(),
+      
+            // generated methods from default levels
+            verbose: jest.fn(),
+            debug: jest.fn(),
+            warn: jest.fn(),
+            error: jest.fn(),
+            trace: jest.fn(),
+            info: jest.fn(),
+            fatal: jest.fn()
+        };
+        return {
+            ...methods,
+            push: jest.fn(() => methods)
+        };
+    }
+    return new Logger.Logger();
+}
+
+module.exports = mockLogger;

package/test/unit/outboundApi/data/bulkQuoteRequest.json

@@ -0,0 +1,28 @@
+{
+  "homeTransactionId": "123ABC",
+  "from": {
+    "displayName": "James Bush",
+    "idType": "MSISDN",
+    "idValue": "447710066017",
+    "extensionList": [
+      {
+        "key": "accountType",
+        "value": "Wallet"
+      }
+    ]
+  },
+  "individualQuotes": [
+    {
+      "quoteId": "12346789",
+      "to": {
+        "idType": "MSISDN",
+        "idValue": "1234567890"
+      },
+      "amountType": "SEND",
+      "currency": "USD",
+      "amount": "100",
+      "transactionType": "TRANSFER",
+      "note": "test payment"
+    }
+  ]
+}

package/test/unit/outboundApi/data/bulkTransferRequest.json

@@ -0,0 +1,28 @@
+{
+  "homeTransactionId": "123ABC",
+  "from": {
+    "displayName": "James Bush",
+    "idType": "MSISDN",
+    "idValue": "447710066017",
+    "extensionList": [
+      {
+        "key": "accountType",
+        "value": "Wallet"
+      }
+    ]
+  },
+  "individualTransfers": [
+    {
+      "transferId": "132435",
+      "to": {
+        "idType": "MSISDN",
+        "idValue": "1234567890"
+      },
+      "amountType": "SEND",
+      "currency": "USD",
+      "amount": "100",
+      "transactionType": "TRANSFER",
+      "note": "test payment"
+    }
+  ]
+}

package/test/unit/outboundApi/data/mockBulkQuoteError.json

@@ -0,0 +1,45 @@
+{
+  "message": "Mock error",
+  "httpStatusCode": 500,
+  "bulkQuoteState":  {
+    "from": {
+      "displayName": "James Bush",
+      "idType": "MSISDN",
+      "idValue": "447710066017"
+    },
+    "individualQuoteResults": [
+      {
+        "to": {
+          "idType": "MSISDN",
+          "idValue": "1234567890"
+        },
+        "amountType": "SEND",
+        "currency": "USD",
+        "amount": "100",
+        "transactionType": "TRANSFER",
+        "note": "test payment",
+        "homeTransactionId": "123ABC",
+        "transferId": "5a2ad5dc-4ab1-4a22-8c5b-62f75252a8d5",
+        "currentState": "ERROR_OCCURRED"  
+      }
+    ],
+    "lastError": {
+      "httpStatusCode": 500,
+      "mojaloopError": {
+        "errorInformation": {
+          "errorCode": "3204",
+          "errorDescription": "Party not found",
+          "extensionList": {
+            "extension": [{
+              "key": "someKey",
+              "value": "someValue"
+            }, {
+              "key": "extErrorKey",
+              "value": "9999"
+            }]
+          }
+        }
+      }
+    } 
+  }
+}

package/test/unit/outboundApi/data/mockBulkTransferError.json

@@ -0,0 +1,48 @@
+{
+  "message": "Mock error",
+  "statusCode": 500,
+  "bulkTransferState": {
+    "from": {
+      "displayName": "James Bush",
+      "idType": "MSISDN",
+      "idValue": "447710066017"
+    },
+    "to": {
+      "idType": "MSISDN",
+      "idValue": "1234567890"
+    },
+    "individualTransferResults": [
+      {
+        "transferId": "5a2ad5dc-4ab1-4a22-8c5b-62f75252a8d5",
+        "amountType": "SEND",
+        "currency": "USD",
+        "amount": "100",
+        "transactionType": "TRANSFER",
+        "note": "test payment",
+        "homeTransactionId": "123ABC",
+        "currentState": "ERROR_OCCURRED"
+      }
+    ],
+    "lastError": {
+      "httpStatusCode": 500,
+      "mojaloopError": {
+        "errorInformation": {
+          "errorCode": "3204",
+          "errorDescription": "Party not found",
+          "extensionList": {
+            "extension": [
+              {
+                "key": "someKey",
+                "value": "someValue"
+              },
+              {
+                "key": "extErrorKey",
+                "value": "9999"
+              }
+            ]
+          }
+        }
+      }
+    }
+  }
+}

package/test/unit/outboundApi/data/mockError.json

@@ -0,0 +1,41 @@
+{
+  "message": "Mock error",
+  "httpStatusCode": 500,
+  "transferState":  {
+    "from": {
+      "displayName": "James Bush",
+      "idType": "MSISDN",
+      "idValue": "447710066017"
+    },
+    "to": {
+      "idType": "MSISDN",
+      "idValue": "1234567890"
+    },
+    "amountType": "SEND",
+    "currency": "USD",
+    "amount": "100",
+    "transactionType": "TRANSFER",
+    "note": "test payment",
+    "homeTransactionId": "123ABC",
+    "transferId": "5a2ad5dc-4ab1-4a22-8c5b-62f75252a8d5",
+    "currentState": "ERROR_OCCURRED",
+    "lastError": {
+      "httpStatusCode": 500,
+      "mojaloopError": {
+        "errorInformation": {
+          "errorCode": "3204",
+          "errorDescription": "Party not found",
+          "extensionList": {
+            "extension": [{
+              "key": "someKey",
+              "value": "someValue"
+            }, {
+              "key": "extErrorKey",
+              "value": "9999"
+            }]
+          }
+        }
+      }
+    }
+  }
+}

package/test/unit/outboundApi/data/mockGetPartiesError.json

@@ -0,0 +1,4 @@
+{
+  "message": "Mock error",
+  "httpStatusCode": 500
+}

package/test/unit/outboundApi/data/mockRequestToPayError.json

@@ -0,0 +1,32 @@
+{
+  "message": "Mock error",
+  "httpStatusCode": 500,
+  "requestToPayState":  {
+    "from": {
+      "displayName": "James Bush",
+      "idType": "MSISDN",
+      "idValue": "447710066017"
+    },
+    "to": {
+      "idType": "MSISDN",
+      "idValue": "1234567890"
+    },
+    "amountType": "SEND",
+    "currency": "USD",
+    "amount": "100",
+    "transactionType": "TRANSFER",
+    "note": "test payment",
+    "homeTransactionId": "123ABC",
+    "transferId": "5a2ad5dc-4ab1-4a22-8c5b-62f75252a8d5",
+    "currentState": "ERROR_OCCURRED",
+    "lastError": {
+      "httpStatusCode": 500,
+      "mojaloopError": {
+        "errorInformation": {
+          "errorCode": "3204",
+          "errorDescription": "Party not found"
+        }
+      }
+    }
+  }
+}

package/test/unit/outboundApi/data/mockRequestToPayTransferError.json

@@ -0,0 +1,39 @@
+{
+  "message": "Mock error",
+  "httpStatusCode": 500,
+  "requestToPayTransferState":  {
+    "from": {
+      "displayName": "James Bush",
+      "idType": "MSISDN",
+      "idValue": "447710066017"
+    },
+    "to": {
+      "idType": "MSISDN",
+      "idValue": "1234567890"
+    },
+    "amountType": "SEND",
+    "currency": "USD",
+    "amount": "100",
+    "transactionType": "TRANSFER",
+    "note": "test payment",
+    "homeTransactionId": "123ABC",
+    "transferId": "5a2ad5dc-4ab1-4a22-8c5b-62f75252a8d5",
+    "currentState": "ERROR_OCCURRED",
+    "lastError": {
+      "httpStatusCode": 500,
+      "mojaloopError": {
+        "errorInformation": {
+          "errorCode": "3204",
+          "errorDescription": "Quote failed",
+          "extensionList": [{
+            "key": "someKey",
+            "value": "someValue"
+          }, {
+            "key": "extErrorKey",
+            "value": "9999"
+          }]
+        }
+      }
+    }
+  }
+}

package/test/unit/outboundApi/data/requestToPay.json

@@ -0,0 +1,21 @@
+{
+  "from": {
+    "displayName": "Murthy Kakarlamudi",
+    "idType": "MSISDN",
+    "idValue": "17855501914",
+    "extensionList": [
+      {"key": "accountType",
+        "value": "Wallet"}
+    ]
+  },
+  "to": {
+    "idType": "MSISDN",
+    "idValue": "1234567890"
+  },
+  "amountType": "SEND",
+  "currency": "USD",
+  "amount": "100",
+  "transactionType": "TRANSFER",
+  "note": "test payment",
+  "homeTransactionId": "123ABC"
+}

package/test/unit/outboundApi/data/requestToPayTransferRequest.json

@@ -0,0 +1,20 @@
+{
+  "requestToPayTransactionId": "c85e581e-fccf-4f55-8bea-96192ee2a32b",
+  "from": {
+    "displayName": "CustomerName",
+    "idType": "MSISDN",
+    "idValue": "17855501914"
+  },
+  "to": {
+    "idType": "BUSINESS",
+    "idValue": "Starbucks",
+    "fspId": "payeefsp"
+  },
+  "amountType": "SEND",
+  "currency": "USD",
+  "amount": "100",
+  "scenario":"PAYMENT",
+  "initiator":"PAYEE",
+  "initiatorType":"DEVICE",
+  "note": "test payment"
+}

package/test/unit/outboundApi/data/transferRequest.json

@@ -0,0 +1,21 @@
+{
+  "from": {
+    "displayName": "James Bush",
+    "idType": "MSISDN",
+    "idValue": "447710066017",
+    "extensionList": [
+      {"key": "accountType",
+        "value": "Wallet"}
+    ]
+  },
+  "to": {
+    "idType": "MSISDN",
+    "idValue": "1234567890"
+  },
+  "amountType": "SEND",
+  "currency": "USD",
+  "amount": "100",
+  "transactionType": "TRANSFER",
+  "note": "test payment",
+  "homeTransactionId": "123ABC"
+}

package/test/unit/outboundApi/handlers.test.js

@@ -0,0 +1,986 @@
+/**************************************************************************
+ *  (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:                                                      *
+ *       James Bush - james.bush@modusbox.com                             *
+ **************************************************************************/
+
+'use strict';
+
+const mockError = require('./data/mockError');
+const mockBulkQuoteError = require('./data/mockBulkQuoteError');
+const mockBulkTransferError = require('./data/mockBulkTransferError');
+const mockRequestToPayError = require('./data/mockRequestToPayError');
+const mockRequestToPayTransferError = require('./data/mockRequestToPayTransferError');
+const mockGetPartiesError = require('./data/mockGetPartiesError');
+const transferRequest = require('./data/transferRequest');
+const bulkTransferRequest = require('./data/bulkTransferRequest');
+const bulkQuoteRequest = require('./data/bulkQuoteRequest');
+const requestToPayPayload = require('./data/requestToPay');
+const requestToPayTransferRequest = require('./data/requestToPayTransferRequest');
+const mockLogger = require('../mockLogger');
+const { uuid } = require('uuidv4');
+
+jest.mock('../../../lib/model');
+
+const handlers = require('../../../OutboundServer/handlers');
+const {
+    OutboundTransfersModel,
+    OutboundBulkTransfersModel,
+    OutboundBulkQuotesModel,
+    OutboundRequestToPayTransferModel,
+    OutboundRequestToPayModel,
+    PartiesModel,
+    QuotesModel,
+    TransfersModel,
+    AuthorizationsModel
+} = require('../../../lib/model');
+
+/**
+ * Mock the outbound transfer model to simulate throwing errors
+ */
+OutboundTransfersModel.mockImplementation(() => {
+    return {
+        run: async () => {
+            // throw the mockError object when the model is run
+            throw mockError;
+        },
+        initialize: async () => {
+            // nothing needed here
+            return;
+        },
+        load: async () => {
+            // nothing needed here
+            return;
+        }
+    };
+});
+
+/**
+ * Mock the outbound bulk transfers model to simulate throwing errors
+ */
+OutboundBulkTransfersModel.mockImplementation(() => {
+    return {
+        run: async () => {
+            throw mockBulkTransferError;
+        },
+        initialize: async () => {
+            return;
+        },
+        load: async () => {
+            return;
+        }
+    };
+});
+
+/**
+ * Mock the outbound bulk quotes model to simulate throwing errors
+ */
+OutboundBulkQuotesModel.mockImplementation(() => {
+    return {
+        run: async () => {
+            throw mockBulkQuoteError;
+        },
+        initialize: async () => {
+            return;
+        },
+        load: async () => {
+            return;
+        }
+    };
+});
+
+/**
+ * Mock the outbound transfer model to simulate throwing errors
+ */
+OutboundRequestToPayTransferModel.mockImplementation(() => {
+    return {
+        run: async () => {
+            // throw the mockError object when the model is run
+            throw mockRequestToPayTransferError;
+        },
+        initialize: async () => {
+            // nothing needed here
+            return;
+        },
+        load: async () => {
+            // nothing needed here
+            return;
+        }
+    };
+});
+
+/**
+ * Mock the outbound request to pay model to simulate throwing errors
+ */
+OutboundRequestToPayModel.mockImplementation(() => {
+    return {
+        run: async () => {
+            // throw the mockError object when the model is run
+            throw mockRequestToPayError;
+        },
+        initialize: async () => {
+            // nothing needed here
+            return;
+        },
+        load: async () => {
+            // nothing needed here
+            return;
+        }
+    };
+});
+
+
+describe('Outbound API handlers:', () => {
+    describe('POST /transfers', () => {
+        test('returns correct error response body when model throws mojaloop error', async () => {
+            const mockContext = {
+                request: {
+                    body: transferRequest,
+                    headers: {
+                        'fspiop-source': 'foo'
+                    }
+                },
+                response: {},
+                state: {
+                    conf: {},
+                    logger: { log: () => {} },
+                }
+            };
+
+            await handlers['/transfers'].post(mockContext);
+
+            // check response is correct
+            expect(mockContext.response.status).toEqual(500);
+            expect(mockContext.response.body).toBeTruthy();
+            expect(mockContext.response.body.message).toEqual('Mock error');
+            expect(mockContext.response.body.statusCode)
+                .toEqual(mockError.transferState.lastError.mojaloopError.errorInformation.errorCode);
+            expect(mockContext.response.body.transferState).toEqual(mockError.transferState);
+        });
+
+        test('uses correct extension list error code for response body statusCode when configured to do so', async () => {
+            const mockContext = {
+                request: {
+                    body: transferRequest,
+                    headers: {
+                        'fspiop-source': 'foo'
+                    }
+                },
+                response: {},
+                state: {
+                    conf: {
+                        outboundErrorStatusCodeExtensionKey: 'extErrorKey'  // <- tell the handler to use this extensionList item as source of statusCode
+                    },
+                    logger: { log: () => {} },
+                }
+            };
+
+            await handlers['/transfers'].post(mockContext);
+
+            // check response is correct
+            expect(mockContext.response.status).toEqual(500);
+            expect(mockContext.response.body).toBeTruthy();
+            expect(mockContext.response.body.message).toEqual('Mock error');
+
+            // in this case, where we have set outboundErrorExtensionKey config we expect the error body statusCode
+            // property to come from the extensionList item with the corresponding key 'extErrorKey'
+            expect(mockContext.response.body.statusCode).toEqual('9999');
+            expect(mockContext.response.body.transferState).toEqual(mockError.transferState);
+        });
+    });
+
+    describe('PUT /transfers', () => {
+        test('returns correct error response body when model throws mojaloop error', async () => {
+            const mockContext = {
+                request: {
+                    body: {
+                        acceptQuote: true
+                    },
+                    headers: {
+                        'fspiop-source': 'foo'
+                    }
+                },
+                response: {},
+                state: {
+                    conf: {},
+                    logger: { log: () => {} },
+                    path: {
+                        params: {
+                            transferId: '12345'
+                        }
+                    }
+                }
+            };
+
+            await handlers['/transfers/{transferId}'].put(mockContext);
+
+            // check response is correct
+            expect(mockContext.response.status).toEqual(500);
+            expect(mockContext.response.body).toBeTruthy();
+            expect(mockContext.response.body.message).toEqual('Mock error');
+            expect(mockContext.response.body.statusCode).toEqual('3204');
+            expect(mockContext.response.body.transferState).toEqual(mockError.transferState);
+        });
+    });
+
+    describe('POST /bulkTransfers', () => {
+        test('returns correct error response body when model throws mojaloop error', async () => {
+            const mockContext = {
+                request: {
+                    body: bulkTransferRequest,
+                    headers: {
+                        'fspiop-source': 'foo'
+                    }
+                },
+                response: {},
+                state: {
+                    conf: {},
+                    logger: { log: () => {} },
+                }
+            };
+
+            await handlers['/bulkTransfers'].post(mockContext);
+
+            // check response is correct
+            expect(mockContext.response.status).toEqual(500);
+            expect(mockContext.response.body).toBeTruthy();
+            expect(mockContext.response.body.message).toEqual('Mock error');
+            expect(mockContext.response.body.statusCode)
+                .toEqual(mockBulkTransferError.bulkTransferState.lastError.mojaloopError.errorInformation.errorCode);
+            expect(mockContext.response.body.bulkTransferState).toEqual(mockBulkTransferError.bulkTransferState);
+        });
+
+        test('uses correct extension list error code for response body statusCode when configured to do so', async () => {
+            const mockContext = {
+                request: {
+                    body: bulkTransferRequest,
+                    headers: {
+                        'fspiop-source': 'foo'
+                    }
+                },
+                response: {},
+                state: {
+                    conf: {
+                        outboundErrorStatusCodeExtensionKey: 'extErrorKey'  // <- tell the handler to use this extensionList item as source of statusCode
+                    },
+                    logger: { log: () => {} },
+                }
+            };
+
+            await handlers['/bulkTransfers'].post(mockContext);
+
+            // check response is correct
+            expect(mockContext.response.status).toEqual(500);
+            expect(mockContext.response.body).toBeTruthy();
+            expect(mockContext.response.body.message).toEqual('Mock error');
+
+            // in this case, where we have set outboundErrorExtensionKey config we expect the error body statusCode
+            // property to come from the extensionList item with the corresponding key 'extErrorKey'
+            expect(mockContext.response.body.statusCode).toEqual('9999');
+            expect(mockContext.response.body.bulkTransferState).toEqual(mockBulkTransferError.bulkTransferState);
+        });
+    });
+
+    describe('POST /bulkQuotes', () => {
+        test('returns correct error response body when model throws mojaloop error', async () => {
+            const mockContext = {
+                request: {
+                    body: bulkQuoteRequest,
+                    headers: {
+                        'fspiop-source': 'foo'
+                    }
+                },
+                response: {},
+                state: {
+                    conf: {},
+                    logger: { log: () => {} },
+                }
+            };
+
+            await handlers['/bulkQuotes'].post(mockContext);
+
+            // check response is correct
+            expect(mockContext.response.status).toEqual(500);
+            expect(mockContext.response.body).toBeTruthy();
+            expect(mockContext.response.body.message).toEqual('Mock error');
+            expect(mockContext.response.body.statusCode)
+                .toEqual(mockBulkQuoteError.bulkQuoteState.lastError.mojaloopError.errorInformation.errorCode);
+            expect(mockContext.response.body.bulkQuoteState).toEqual(mockBulkQuoteError.bulkQuoteState);
+        });
+
+        test('uses correct extension list error code for response body statusCode when configured to do so', async () => {
+            const mockContext = {
+                request: {
+                    body: bulkQuoteRequest,
+                    headers: {
+                        'fspiop-source': 'foo'
+                    }
+                },
+                response: {},
+                state: {
+                    conf: {
+                        outboundErrorStatusCodeExtensionKey: 'extErrorKey'  // <- tell the handler to use this extensionList item as source of statusCode
+                    },
+                    logger: { log: () => {} },
+                }
+            };
+
+            await handlers['/bulkQuotes'].post(mockContext);
+
+            // check response is correct
+            expect(mockContext.response.status).toEqual(500);
+            expect(mockContext.response.body).toBeTruthy();
+            expect(mockContext.response.body.message).toEqual('Mock error');
+
+            // in this case, where we have set outboundErrorExtensionKey config we expect the error body statusCode
+            // property to come from the extensionList item with the corresponding key 'extErrorKey'
+            expect(mockContext.response.body.statusCode).toEqual('9999');
+            expect(mockContext.response.body.bulkQuoteState).toEqual(mockBulkQuoteError.bulkQuoteState);
+        });
+    });
+
+    describe('POST /requestToPayTransfer', () => {
+        test('returns correct error response body when model throws mojaloop error', async () => {
+            const mockContext = {
+                request: {
+                    body: requestToPayTransferRequest,
+                    headers: {
+                        'fspiop-source': 'foo'
+                    }
+                },
+                response: {},
+                state: {
+                    conf: {},
+                    logger: { log: () => {} },
+                }
+            };
+
+            await handlers['/requestToPayTransfer'].post(mockContext);
+            // check response is correct
+            expect(mockContext.response.status).toEqual(500);
+            expect(mockContext.response.body).toBeTruthy();
+            expect(mockContext.response.body.message).toEqual('Mock error');
+            expect(mockContext.response.body.statusCode)
+                .toEqual(mockRequestToPayTransferError.requestToPayTransferState.lastError.mojaloopError.errorInformation.errorCode);
+            expect(mockContext.response.body.requestToPayTransferState).toEqual(mockRequestToPayTransferError.requestToPayTransferState);
+        });
+    });
+
+    describe('POST /requestToPay', () => {
+        test('returns correct error response body when model throws mojaloop error', async () => {
+            const mockContext = {
+                request: {
+                    body: requestToPayPayload,
+                    headers: {
+                        'fspiop-source': 'foo'
+                    }
+                },
+                response: {},
+                state: {
+                    conf: {},
+                    logger: { log: () => {} }
+                }
+            };
+
+            await handlers['/requestToPay'].post(mockContext);
+
+            // check response is correct
+            expect(mockContext.response.status).toEqual(500);
+            expect(mockContext.response.body).toBeTruthy();
+            expect(mockContext.response.body.message).toEqual('Mock error');
+            expect(mockContext.response.body.statusCode).toEqual('3204');
+            expect(mockContext.response.body.requestToPayState).toEqual(mockRequestToPayError.requestToPayState);
+        });
+    });
+
+    describe('GET /parties/{Type}/{ID}/{SubId}', () => {
+        test('happy flow', async() => {
+
+            const mockContext = {
+                request: {},
+                response: {},
+                state: {
+                    conf: {},
+                    wso2Auth: 'mocked wso2Auth',
+                    logger: mockLogger({ app: 'outbound-api-handlers-test'}),
+                    cache: { the: 'mocked cache' },
+                    path: {
+                        params: {
+                            'Type': 'MSISDN',
+                            'ID': '1234567890',
+                            'SubId': 'abcdefgh'
+                        },
+                    },
+                },
+            };
+
+            // mock state machine
+            const mockedPSM = {
+                run: jest.fn(async () => ({ the: 'run response' }))
+            };
+
+            const createSpy = jest.spyOn(PartiesModel, 'create')
+                .mockImplementationOnce(async () => mockedPSM);
+
+            // invoke handler
+            await handlers['/parties/{Type}/{ID}/{SubId}'].get(mockContext);
+
+            // PSM model creation
+            const state = mockContext.state;
+            const cacheKey = PartiesModel.channelName({
+                type: 'MSISDN',
+                id: '1234567890',
+                subId: 'abcdefgh'
+            });
+            const expectedConfig = {
+                cache: state.cache,
+                logger: state.logger,
+                wso2Auth: state.wso2Auth
+            };
+            expect(createSpy).toBeCalledWith({}, cacheKey, expectedConfig);
+
+            // run workflow
+            expect(mockedPSM.run).toBeCalledWith({
+                type: 'MSISDN',
+                id: '1234567890',
+                subId: 'abcdefgh'
+            });
+
+            // response
+            expect(mockContext.response.status).toBe(200);
+            expect(mockContext.response.body).toEqual({ the: 'run response' });
+        });
+
+        test('error flow', async() => {
+            const mockContext = {
+                request: {},
+                response: {},
+                state: {
+                    conf: {},
+                    wso2Auth: 'mocked wso2Auth',
+                    logger: mockLogger({ app: 'outbound-api-handlers-test'}),
+                    cache: { the: 'mocked cache' },
+                    path: {
+                        params: {
+                            'Type': 'MSISDN',
+                            'ID': '1234567890',
+                            'SubId': 'abcdefgh'
+                        },
+                    },
+                },
+            };
+
+            // mock state machine
+            const mockedPSM = {
+                run: jest.fn(async () => ({ errorInformation: { Iam: 'the-error'} }))
+            };
+
+            const createSpy = jest.spyOn(PartiesModel, 'create')
+                .mockImplementationOnce(async () => mockedPSM);
+
+            // invoke handler
+            await handlers['/parties/{Type}/{ID}/{SubId}'].get(mockContext);
+
+            // PSM model creation
+            const state = mockContext.state;
+            const cacheKey = PartiesModel.channelName({
+                type: 'MSISDN',
+                id: '1234567890',
+                subId: 'abcdefgh'
+            });
+            const expectedConfig = {
+                cache: state.cache,
+                logger: state.logger,
+                wso2Auth: state.wso2Auth
+            };
+            expect(createSpy).toBeCalledWith({}, cacheKey, expectedConfig);
+
+            // run workflow
+            expect(mockedPSM.run).toBeCalledWith({
+                type: 'MSISDN',
+                id: '1234567890',
+                subId: 'abcdefgh'
+            });
+
+            // response
+            expect(mockContext.response.status).toBe(404);
+            expect(mockContext.response.body).toEqual({ errorInformation: { Iam: 'the-error'} });
+        });
+    });
+    describe('GET /parties/{Type}/{ID}', () => {
+        const mockContext = {
+            request: {},
+            response: {},
+            state: {
+                conf: {},
+                wso2Auth: 'mocked wso2Auth',
+                logger: mockLogger({ app: 'outbound-api-handlers-test'}),
+                cache: {
+                    subscribe: jest.fn(() => Promise.resolve())
+                },
+                path: {
+                    params: {
+                        'Type': 'MSISDN',
+                        'ID': '1234567890'
+                    },
+                },
+            },
+        };
+        test('happy flow', async() => {
+
+
+            // mock state machine
+            const mockedPSM = {
+                run: jest.fn(async () => ({ the: 'run response' }))
+            };
+
+            const createSpy = jest.spyOn(PartiesModel, 'create')
+                .mockImplementationOnce(async () => mockedPSM);
+
+            // invoke handler
+            await handlers['/parties/{Type}/{ID}'].get(mockContext);
+
+            // PSM model creation
+            const state = mockContext.state;
+            const cacheKey = PartiesModel.channelName({
+                type: 'MSISDN',
+                id: '1234567890'
+            });
+            const expectedConfig = {
+                cache: state.cache,
+                logger: state.logger,
+                wso2Auth: state.wso2Auth
+            };
+            expect(createSpy).toBeCalledWith({}, cacheKey, expectedConfig);
+
+            // run workflow
+            expect(mockedPSM.run).toBeCalledWith({ type: 'MSISDN', id: '1234567890', subId: undefined });
+
+            // response
+            expect(mockContext.response.status).toBe(200);
+            expect(mockContext.response.body).toEqual({ the: 'run response' });
+        });
+
+        test('not found error flow', async() => {
+
+            // mock state machine
+            const mockedPSM = {
+                run: jest.fn(async () => ({ errorInformation: { Iam: 'the-error'} }))
+            };
+
+            const createSpy = jest.spyOn(PartiesModel, 'create')
+                .mockImplementationOnce(async () => mockedPSM);
+
+            // invoke handler
+            await handlers['/parties/{Type}/{ID}'].get(mockContext);
+
+            // PSM model creation
+            const state = mockContext.state;
+            const cacheKey = PartiesModel.channelName({
+                type: 'MSISDN',
+                id: '1234567890'
+            });
+            const expectedConfig = {
+                cache: state.cache,
+                logger: state.logger,
+                wso2Auth: state.wso2Auth
+            };
+            expect(createSpy).toBeCalledWith({}, cacheKey, expectedConfig);
+
+            // run workflow
+            expect(mockedPSM.run).toBeCalledWith({
+                type: 'MSISDN',
+                id: '1234567890',
+                subId: undefined
+            });
+
+            // response
+            expect(mockContext.response.status).toBe(404);
+            expect(mockContext.response.body).toEqual({ errorInformation: { Iam: 'the-error'} });
+        });
+
+        test('mojaloop error propagation for /parties/{Type}/{ID}', async() => {
+
+            // mock state machine
+            const mockedPSM = {
+                run: jest.fn(async () => { throw mockGetPartiesError; })
+            };
+
+            const createSpy = jest.spyOn(PartiesModel, 'create')
+                .mockImplementationOnce(async () => mockedPSM);
+
+            // invoke handler
+            await handlers['/parties/{Type}/{ID}'].get(mockContext);
+
+            // PSM model creation
+            const state = mockContext.state;
+            const cacheKey = PartiesModel.channelName({
+                type: 'MSISDN',
+                id: '1234567890'
+            });
+            const expectedConfig = {
+                cache: state.cache,
+                logger: state.logger,
+                wso2Auth: state.wso2Auth
+            };
+            expect(createSpy).toBeCalledWith({}, cacheKey, expectedConfig);
+
+            // run workflow
+            expect(mockedPSM.run).toBeCalledWith({
+                type: 'MSISDN',
+                id: '1234567890',
+                subId: undefined
+            });
+
+            // response
+            expect(mockContext.response.status).toBe(500);
+            expect(mockContext.response.body).toEqual({
+                message: 'Mock error',
+                statusCode: '500',
+                requestPartiesInformationState: {}
+            });
+        });
+        test('mojaloop error propagation for /parties/{Type}/{ID}/{SubId}', async() => {
+
+            // mock state machine
+            const mockedPSM = {
+                run: jest.fn(async () => { throw mockGetPartiesError; })
+            };
+
+            const createSpy = jest.spyOn(PartiesModel, 'create')
+                .mockImplementationOnce(async () => mockedPSM);
+
+            // invoke handler
+            await handlers['/parties/{Type}/{ID}/{SubId}'].get(mockContext);
+
+            // PSM model creation
+            const state = mockContext.state;
+            const cacheKey = PartiesModel.channelName({
+                type: 'MSISDN',
+                id: '1234567890'
+            });
+            const expectedConfig = {
+                cache: state.cache,
+                logger: state.logger,
+                wso2Auth: state.wso2Auth
+            };
+            expect(createSpy).toBeCalledWith({}, cacheKey, expectedConfig);
+
+            // run workflow
+            expect(mockedPSM.run).toBeCalledWith({
+                type: 'MSISDN',
+                id: '1234567890',
+                subId: undefined
+            });
+
+            // response
+            expect(mockContext.response.status).toBe(500);
+            expect(mockContext.response.body).toEqual({
+                message: 'Mock error',
+                statusCode: '500',
+                requestPartiesInformationState: {}
+            });
+        });
+    });
+
+    describe('POST /quotes', () => {
+        const mockContext = {
+            request: {
+                body: {
+                    fspId: uuid(),
+                    quotesPostRequest: {
+                        quoteId: uuid()
+                    }
+                }
+            },
+            response: {},
+            state: {
+                conf: {},
+                wso2Auth: 'mocked wso2Auth',
+                logger: mockLogger({ app: 'outbound-api-handlers-test' }),
+                cache: {
+                    subscribe: jest.fn(() => Promise.resolve())
+                }
+            },
+        };
+        test('happy flow', async () => {
+
+
+            // mock state machine
+            const mockedPSM = {
+                run: jest.fn(async () => ({ the: 'run response' }))
+            };
+
+            const createSpy = jest.spyOn(QuotesModel, 'create')
+                .mockImplementationOnce(async () => mockedPSM);
+
+            // invoke handler
+            await handlers['/quotes'].post(mockContext);
+
+            // PSM model creation
+            const state = mockContext.state;
+            const cacheKey = QuotesModel.channelName({
+                quoteId: mockContext.request.body.quotesPostRequest.quoteId
+            });
+            const expectedConfig = {
+                cache: state.cache,
+                logger: state.logger,
+                wso2Auth: state.wso2Auth
+            };
+            expect(createSpy).toBeCalledWith({}, cacheKey, expectedConfig);
+
+            // run workflow
+            expect(mockedPSM.run).toBeCalledWith({
+                quoteId: mockContext.request.body.quotesPostRequest.quoteId,
+                fspId: mockContext.request.body.fspId,
+                quote: mockContext.request.body.quotesPostRequest
+            });
+
+            // response
+            expect(mockContext.response.status).toBe(200);
+            expect(mockContext.response.body).toEqual({ the: 'run response' });
+        });
+
+        test('mojaloop error propagation for /parties/{Type}/{ID}', async() => {
+
+            // mock state machine
+            const mockedPSM = {
+                run: jest.fn(async () => { throw { mocked: 'error' }; })
+            };
+
+            const createSpy = jest.spyOn(QuotesModel, 'create')
+                .mockImplementationOnce(async () => mockedPSM);
+
+            // invoke handler
+            await handlers['/quotes'].post(mockContext);
+
+            // PSM model creation
+            const state = mockContext.state;
+            const cacheKey = QuotesModel.channelName({
+                quoteId: mockContext.request.body.quotesPostRequest.quoteId
+            });
+            const expectedConfig = {
+                cache: state.cache,
+                logger: state.logger,
+                wso2Auth: state.wso2Auth
+            };
+            expect(createSpy).toBeCalledWith({}, cacheKey, expectedConfig);
+
+            // run workflow
+            expect(mockedPSM.run).toBeCalledWith({
+                quoteId: mockContext.request.body.quotesPostRequest.quoteId,
+                fspId: mockContext.request.body.fspId,
+                quote: mockContext.request.body.quotesPostRequest
+            });
+
+            // response
+            expect(mockContext.response.status).toBe(500);
+            expect(mockContext.response.body).toEqual({
+                message: 'Unspecified error',
+                requestQuotesInformationState: {},
+                statusCode: '500',
+            });
+        });
+    });
+    describe('POST /simpleTransfers', () => {
+        const mockContext = {
+            request: {
+                body: {
+                    fspId: uuid(),
+                    transfersPostRequest: {
+                        transferId: uuid()
+                    }
+                }
+            },
+            response: {},
+            state: {
+                conf: {},
+                wso2Auth: 'mocked wso2Auth',
+                logger: mockLogger({ app: 'outbound-api-handlers-test' }),
+                cache: {
+                    subscribe: jest.fn(() => Promise.resolve())
+                }
+            },
+        };
+        test('happy flow', async () => {
+
+
+            // mock state machine
+            const mockedPSM = {
+                run: jest.fn(async () => ({ the: 'run response' }))
+            };
+
+            const createSpy = jest.spyOn(TransfersModel, 'create')
+                .mockImplementationOnce(async () => mockedPSM);
+
+            // invoke handler
+            await handlers['/simpleTransfers'].post(mockContext);
+
+            // PSM model creation
+            const state = mockContext.state;
+            const cacheKey = TransfersModel.channelName({
+                transferId: mockContext.request.body.transfersPostRequest.transferId
+            });
+            const expectedConfig = {
+                cache: state.cache,
+                logger: state.logger,
+                wso2Auth: state.wso2Auth
+            };
+            expect(createSpy).toBeCalledWith({}, cacheKey, expectedConfig);
+
+            // run workflow
+            expect(mockedPSM.run).toBeCalledWith({
+                transferId: mockContext.request.body.transfersPostRequest.transferId,
+                fspId: mockContext.request.body.fspId,
+                transfer: mockContext.request.body.transfersPostRequest
+            });
+
+            // response
+            expect(mockContext.response.status).toBe(200);
+            expect(mockContext.response.body).toEqual({ the: 'run response' });
+        });
+
+        test('mojaloop error propagation for /simpleTransfers', async() => {
+
+            // mock state machine
+            const mockedPSM = {
+                run: jest.fn(async () => { throw { mocked: 'error' }; })
+            };
+
+            const createSpy = jest.spyOn(TransfersModel, 'create')
+                .mockImplementationOnce(async () => mockedPSM);
+
+            // invoke handler
+            await handlers['/simpleTransfers'].post(mockContext);
+
+            // PSM model creation
+            const state = mockContext.state;
+            const cacheKey = TransfersModel.channelName({
+                transferId: mockContext.request.body.transfersPostRequest.transferId
+            });
+            const expectedConfig = {
+                cache: state.cache,
+                logger: state.logger,
+                wso2Auth: state.wso2Auth
+            };
+            expect(createSpy).toBeCalledWith({}, cacheKey, expectedConfig);
+
+            // run workflow
+            expect(mockedPSM.run).toBeCalledWith({
+                transferId: mockContext.request.body.transfersPostRequest.transferId,
+                fspId: mockContext.request.body.fspId,
+                transfer: mockContext.request.body.transfersPostRequest
+            });
+
+            // response
+            expect(mockContext.response.status).toBe(500);
+            expect(mockContext.response.body).toEqual({
+                message: 'Unspecified error',
+                requestSimpleTransfersInformationState: {},
+                statusCode: '500',
+            });
+        });
+    });
+    describe('POST /authorizations', () => {
+        const mockContext = {
+            request: {
+                body: {
+                    fspId: uuid(),
+                    authorizationsPostRequest: {
+                        transactionRequestId: uuid()
+                    }
+                }
+            },
+            response: {},
+            state: {
+                conf: {},
+                wso2Auth: 'mocked wso2Auth',
+                logger: mockLogger({ app: 'outbound-api-handlers-test' }),
+                cache: { 
+                    subscribe: jest.fn(() => Promise.resolve())
+                }
+            },
+        };
+        test('happy flow', async () => {
+            
+            // mock state machine
+            const mockedPSM = {
+                run: jest.fn(async () => ({ the: 'run response' }))
+            };
+            
+            const createSpy = jest.spyOn(AuthorizationsModel, 'create')
+                .mockImplementationOnce(async () => mockedPSM);
+
+            // invoke handler
+            await handlers['/authorizations'].post(mockContext);
+
+            // PSM model creation
+            const state = mockContext.state;
+            const cacheKey = AuthorizationsModel.channelName({
+                transactionRequestId: mockContext.request.body.authorizationsPostRequest.transactionRequestId
+            });
+            const expectedConfig = {
+                cache: state.cache,
+                logger: state.logger,
+                wso2Auth: state.wso2Auth
+            };
+            expect(createSpy).toBeCalledWith({}, cacheKey, expectedConfig);
+
+            // run workflow
+            expect(mockedPSM.run).toBeCalledWith({ 
+                transactionRequestId: mockContext.request.body.authorizationsPostRequest.transactionRequestId,
+                fspId: mockContext.request.body.fspId,
+                authorization: mockContext.request.body.authorizationsPostRequest
+            });
+
+            // response
+            expect(mockContext.response.status).toBe(200);
+            expect(mockContext.response.body).toEqual({ the: 'run response' });
+        });
+
+        test('mojaloop error propagation for /authorizations/{ID}', async() => {    
+            
+            // mock state machine
+            const mockedPSM = {
+                run: jest.fn(async () => { throw { mocked: 'error' }; })
+            };
+            
+            const createSpy = jest.spyOn(AuthorizationsModel, 'create')
+                .mockImplementationOnce(async () => mockedPSM);
+
+            // invoke handler
+            await handlers['/authorizations'].post(mockContext);
+
+            // PSM model creation
+            const state = mockContext.state;
+            const cacheKey = AuthorizationsModel.channelName({
+                transactionRequestId: mockContext.request.body.authorizationsPostRequest.transactionRequestId
+            });
+            const expectedConfig = {
+                cache: state.cache,
+                logger: state.logger,
+                wso2Auth: state.wso2Auth
+            };
+            expect(createSpy).toBeCalledWith({}, cacheKey, expectedConfig);
+
+            // run workflow
+            expect(mockedPSM.run).toBeCalledWith({ 
+                transactionRequestId: mockContext.request.body.authorizationsPostRequest.transactionRequestId, 
+                fspId: mockContext.request.body.fspId,
+                authorization: mockContext.request.body.authorizationsPostRequest
+            });
+
+            // response
+            expect(mockContext.response.status).toBe(500);
+            expect(mockContext.response.body).toEqual({
+                message: 'Unspecified error',
+                requestAuthorizationsInformationState: {},
+                statusCode: '500',
+            });
+        });
+    });    
+});