@mojaloop/sdk-scheme-adapter 11.18.8

package/test/unit/index.test.js

@@ -0,0 +1,55 @@
+/**************************************************************************
+ *  (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 { Logger } = require('@mojaloop/sdk-standard-components');
+const defaultConfig = require('./data/defaultConfig');
+
+jest.mock('dotenv', () => ({
+    config: jest.fn()
+}));
+
+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';
+
+const index = require('../../index.js');
+
+describe('index.js', () => {
+    test('WSO2 error events in OutboundServer propagate to top-level server', () => {
+        const logger = new Logger.Logger({ stringify: () => '' });
+        const svr = new index.Server(defaultConfig, logger);
+        const cb = jest.fn();
+        svr.on('error', cb);
+        svr.outboundServer._api._wso2.auth.emit('error', 'msg');
+        expect(cb).toHaveBeenCalledTimes(1);
+    });
+
+    test('WSO2 error events in InboundServer propagate to top-level server', () => {
+        const logger = new Logger.Logger({ stringify: () => '' });
+        const svr = new index.Server(defaultConfig, logger);
+        const cb = jest.fn();
+        svr.on('error', cb);
+        svr.inboundServer._api._wso2.auth.emit('error', 'msg');
+        expect(cb).toHaveBeenCalledTimes(1);
+    });
+
+    test('Exports expected modules', () => {
+        expect(typeof(index.Server)).toBe('function');
+        expect(typeof(index.InboundServerMiddleware)).toBe('object');
+        expect(typeof(index.OutboundServerMiddleware)).toBe('object');
+        expect(typeof(index.Router)).toBe('function');
+        expect(typeof(index.Validate)).toBe('function');
+        expect(typeof(index.RandomPhrase)).toBe('function');
+        expect(typeof(index.Cache)).toBe('function');
+    });
+});

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

@@ -0,0 +1,146 @@
+/**************************************************************************
+ *  (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';
+
+jest.mock('redis');
+
+const Cache = require('../../../lib/cache');
+const { Logger } = require('@mojaloop/sdk-standard-components');
+
+const createCache = async() => {
+    const logger = new Logger.Logger({ context: { app: 'model-unit-tests-cache' }, stringify: () => '' });
+    const cache = new Cache({
+        host: 'dummyhost',
+        port: 1234,
+        logger,
+    });
+    await cache.connect();
+    return cache;
+};
+
+describe('Cache', () => {
+    let dummyPubMessage;
+
+    beforeEach(() => {
+        dummyPubMessage = JSON.parse(JSON.stringify({
+            data: 12345,
+            test: '98765'
+        }));
+    });
+
+    test('Makes connections to redis server for cache operations', async () => {
+        const cache = await createCache();
+        expect(cache).not.toBeFalsy();
+        await cache.disconnect();
+    });
+
+
+    test('Makes subscriber callbacks on the correct channels when messages arrive', async () => {
+        const cache = await createCache();
+
+        const msg1 = dummyPubMessage;
+
+        // make the messages different
+        const msg2 = JSON.parse(JSON.stringify(dummyPubMessage));
+        msg2.abc = 'xyz';
+
+        const chan1 = 'dummychannel1';
+        const chan2 = 'dummychannel2';
+
+        // create a promise that only gets resoled if the subscription gets the
+        // correct message
+        const cb1Promise = new Promise((resolve) => {
+            const mockCb1 = jest.fn((cn, msg) => {
+                expect(cn).toBe(chan1);
+
+                const value = JSON.parse(msg);
+                // check we got the expected message
+                expect(value).toEqual(msg1);
+
+                //resolve the promise
+                resolve();
+            });
+
+            // subscribe to a ficticious channel
+            return cache.subscribe(chan1, mockCb1).then(cbId1 => {
+                // we should be the first callback registered (zero index)
+                expect(cbId1).toBe(0);
+
+                // now we have subscribed, inject a message.
+                cache.publish(chan1, msg1);
+            });
+        });
+
+        // create a second promise that only gets resoled if the second subscription gets the
+        // correct message
+        const cb2Promise = new Promise((resolve) => {
+            const mockCb2 = jest.fn((cn, msg) => {
+                expect(cn).toBe(chan2);
+
+                // check we got the expected message
+                const value = JSON.parse(msg);
+                expect(value).toEqual(msg2);
+
+                //resolve the promise
+                resolve();
+            });
+
+            // subscribe to a ficticious channel
+            return cache.subscribe(chan2, mockCb2).then(cbId2 => {
+                // we should be the second callback registered (zero index)
+                expect(cbId2).toBe(1);
+
+                // now we have subscribed, inject a message.
+                cache.publish(chan2, msg2);
+            });
+        });
+
+        await Promise.all([cb1Promise, cb2Promise]);
+
+        await cache.disconnect();
+    });
+
+
+    test('Unsubscribed callbacks do not get called when messages arrive', async () => {
+        const cache = await createCache();
+        const msg1 = dummyPubMessage;
+
+        const chan = 'dummychannel1';
+
+        // create a promise that only gets resoled if the subscription gets the
+        // correct message
+        await new Promise((resolve, reject) => {
+            const mockCb1 = jest.fn((cn, msg) => {  // eslint-disable-line no-unused-vars
+                //reject the outer promise if this func gets called!
+                reject();
+            });
+
+            // subscribe to a ficticious channel
+            return cache.subscribe(chan, mockCb1).then(cbId1 => {
+                // we should be the first callback registered (zero index)
+                expect(cbId1).toBe(0);
+
+                // now we have subscribed we unsubscribe
+                return cache.unsubscribe(chan, cbId1).then(() => {
+                    // now we have unsubscribed, inject a message
+                    cache.publish(chan, msg1);
+
+                    // wait 3 seconds and if the callback has not been called we assume a pass
+                    setTimeout(() => {
+                        expect(mockCb1.mock.calls.length).toBe(0);
+                        return resolve();
+                    }, 3000);
+                });
+            });
+        });
+        await cache.disconnect();
+    });
+});

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

@@ -0,0 +1,121 @@
+/**************************************************************************
+ *  (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';
+
+// we use a mock standard components lib to intercept and mock certain funcs
+jest.mock('@mojaloop/sdk-standard-components');
+jest.mock('redis');
+
+const Cache = require('../../../../lib/cache');
+const { AccountsModel } = require('../../../../lib/model');
+
+const StateMachine = require('javascript-state-machine');
+const { MojaloopRequests, Logger } = require('@mojaloop/sdk-standard-components');
+
+const defaultConfig = require('./data/defaultConfig');
+const transferRequest = require('./data/transferRequest');
+
+function generateAccounts(count, currencies) {
+    const accounts = [];
+    for (let currencyIndex = 0; currencyIndex < currencies.length; currencyIndex++) {
+        for (let i = 1; i <= count; i++) {
+            accounts.push({
+                idType: 'MSISDN',
+                idValue: String(i * (currencyIndex + 1)).padStart(9, '0'),
+                idSubValue: `Sub_${String(i * (currencyIndex + 1))}`.padStart(5, '0'),
+                currency: currencies[currencyIndex],
+            });
+        }
+    }
+    return accounts;
+}
+
+
+describe('AccountsModel', () => {
+    let logger;
+    let cache;
+
+    async function testCreateAccount(count, currencies) {
+        const MAX_ITEMS_PER_REQUEST = 10000; // As per API Spec 6.2.2.2 (partyList field)
+
+        MojaloopRequests.__postParticipants = jest.fn(request => {
+            // simulate a response from ALS
+            const response = {
+                type: 'accountsCreationSuccessfulResponse',
+                data: {
+                    partyList: request.partyList.map(party => ({
+                        partyId: party,
+                        // errorInformation: null
+                    })),
+                    currency: request.currency,
+                },
+            };
+            cache.publish(`ac_${request.requestId}`, JSON.stringify(response));
+            return Promise.resolve();
+        });
+
+        const model = new AccountsModel({
+            ...defaultConfig,
+            cache,
+            logger,
+        });
+
+        const accounts = generateAccounts(count, currencies);
+        await model.initialize({ accounts });
+
+        expect(StateMachine.__instance.state).toBe('start');
+
+        // wait for the model to reach a terminal state
+        const result = await model.run();
+
+        const expectedRequestsCount = currencies.length *
+            (Math.floor(count / MAX_ITEMS_PER_REQUEST) + ((count % MAX_ITEMS_PER_REQUEST) ? 1 : 0));
+        expect(MojaloopRequests.__postParticipants).toHaveBeenCalledTimes(expectedRequestsCount);
+
+        expect(result.currentState).toBe('COMPLETED');
+        expect(StateMachine.__instance.state).toBe('succeeded');
+    }
+
+    beforeAll(() => {
+        logger = new Logger.Logger({ context: { app: 'outbound-model-unit-tests-cache' }, stringify: () => '' });
+    });
+
+    beforeEach(async () => {
+        cache = new Cache({
+            host: 'dummycachehost',
+            port: 1234,
+            logger,
+        });
+        await cache.connect();
+    });
+
+    afterEach(async () => {
+        await cache.disconnect();
+    });
+
+    test('initializes to starting state', async () => {
+        const model = new AccountsModel({
+            ...defaultConfig,
+            cache,
+            logger,
+        });
+
+        await model.initialize(JSON.parse(JSON.stringify(transferRequest)));
+
+        expect(StateMachine.__instance.state).toBe('start');
+    });
+
+    test('create 100 accounts', () =>
+        testCreateAccount(100, ['USD', 'EUR', 'UAH']));
+
+    test('create 20000 accounts', () =>
+        testCreateAccount(20000, ['USD', 'EUR']));
+});

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

@@ -0,0 +1,460 @@
+/**************************************************************************
+ *  (C) Copyright ModusBox Inc. 2021 - All rights reserved.               *
+ *                                                                        *
+ *  This file is made available under the terms of the license agreement  *
+ *  specified in the corresponding source code repository.                *
+ *                                                                        *
+ *  ORIGINAL AUTHOR:                                                      *
+ *       Sridhar Voruganti - sridhar.voruganti@modusbox.com               *
+ **************************************************************************/
+
+'use strict';
+
+// we use a mock standard components lib to intercept and mock certain funcs
+jest.mock('@mojaloop/sdk-standard-components');
+
+const { uuid } = require('uuidv4');
+const Model = require('../../../../lib/model').AuthorizationsModel;
+const PSM = require('../../../../lib/model/common').PersistentStateMachine;
+const { MojaloopRequests } = require('@mojaloop/sdk-standard-components');
+const defaultConfig = require('./data/defaultConfig');
+const mockLogger = require('../../mockLogger');
+const deferredJob = require('../../../../lib/model/lib').deferredJob;
+const pt = require('promise-timeout');
+const authorizationsResponse = require('./data/putAuthorizationsResponse.json');
+
+describe('AuthorizationsModel', () => {
+    let cacheKey;
+    let data;
+    let modelConfig;
+
+    const subId = uuid();
+    let handler = null;
+    beforeEach(async () => {
+
+        modelConfig = {
+            logger: mockLogger({ app: 'authorizationsModel-test' }),
+
+            // there is no need to mock redis but only Cache
+            cache: {
+                get: jest.fn(() => Promise.resolve(data)),
+                set: jest.fn(() => Promise.resolve),
+
+                // mock subscription and store handler
+                subscribe: jest.fn(async (channel, h) => {
+                    handler = jest.fn(h);
+                    return subId;
+                }),
+
+                // mock publish and call stored handler
+                publish: jest.fn(async (channel, message) => await handler(channel, message, subId)),
+
+                unsubscribe: jest.fn(() => Promise.resolve())
+            },
+            ...defaultConfig
+        };
+        data = {
+            the: 'mocked data'
+        };
+
+        cacheKey = `key-authorizations-${uuid()}`;
+    });
+
+    describe('create', () => {
+        test('proper creation of model', async () => {
+            const model = await Model.create(data, cacheKey, modelConfig);
+
+            expect(model.state).toBe('start');
+
+            // model's methods layout
+            const methods = [
+                'run',
+                'getResponse',
+                'onRequestAction'
+            ];
+
+            methods.forEach((method) => expect(typeof model[method]).toEqual('function'));
+        });
+    });
+
+    describe('getResponse', () => {
+
+        it('should remap currentState', async () => {
+            const model = await Model.create(data, cacheKey, modelConfig);
+            const states = model.allStates();
+            // should remap for all states except 'init' and 'none'
+            states.filter((s) => s !== 'init' && s !== 'none').forEach((state) => {
+                model.context.data.currentState = state;
+                const result = model.getResponse();
+                expect(result.currentState).toEqual(Model.mapCurrentState[state]);
+            });
+
+        });
+
+        it('should handle unexpected state', async () => {
+            const model = await Model.create(data, cacheKey, modelConfig);
+
+            // simulate lack of state by undefined property
+            delete model.context.data.currentState;
+
+            const resp = model.getResponse();
+            expect(resp.currentState).toEqual(Model.mapCurrentState.errored);
+
+            // ensure that we log the problem properly
+            expect(modelConfig.logger.error).toHaveBeenCalledWith(`AuthorizationsModel model response being returned from an unexpected state: ${undefined}. Returning ERROR_OCCURRED state`);
+        });
+    });
+
+    describe('channelName', () => {
+        it('should validate input', () => {
+            expect(Model.channelName({})).toEqual('authorizations-undefined');
+        });
+
+        it('should generate proper channel name', () => {
+            const transactionRequestId = uuid();
+            expect(Model.channelName({ transactionRequestId })).toEqual(`authorizations-${transactionRequestId}`);
+        });
+
+    });
+
+    describe('generateKey', () => {
+        it('should generate proper cache key', () => {
+            const transactionRequestId = uuid();
+            expect(Model.generateKey({ transactionRequestId })).toEqual(`key-${Model.channelName({ transactionRequestId })}`);
+        });
+
+        it('should handle lack of transactionRequestId param', () => {
+            expect(() => Model.generateKey({})).toThrowError(new Error('AuthorizationsModel args requires \'transactionRequestId\' is nonempty string and mandatory property'));
+        });
+
+    });
+
+    describe('onRequestAction', () => {
+
+        it('should implement happy flow', async () => {
+            const transactionRequestId = uuid();
+            const fspId = uuid();
+            // our code takes care only about 'transactionRequestId' property
+            const authorization = { transactionRequestId };
+            const channel = Model.channelName({ transactionRequestId });
+            const model = await Model.create(data, cacheKey, modelConfig);
+            const { cache } = model.context;
+            // mock workflow execution which is tested in separate case
+            model.run = jest.fn(() => Promise.resolve());
+
+            const message = { ...authorizationsResponse };
+            
+            const onRequestActionPromise = new Promise((resolve, reject) => {
+                // manually invoke transition handler
+                model.onRequestAction(model.fsm, { transactionRequestId, fspId, authorization })
+                    .then(() => {
+                        // subscribe should be called only once
+                        expect(cache.subscribe).toBeCalledTimes(1);
+
+                        // subscribe should be done to proper notificationChannel
+                        expect(cache.subscribe.mock.calls[0][0]).toEqual(channel);
+
+                        // check invocation of request.getParties
+                        expect(MojaloopRequests.__postAuthorizations).toBeCalledWith(authorization, fspId);
+
+                        // check that this.context.data is updated
+                        expect(model.context.data).toEqual({
+                            authorizations: { ...message },
+                            currentState: 'start'
+                            //current state will be updated by onAfterTransition which isn't called 
+                            //when manual invocation of transition handler happens
+
+                        });
+                        // handler should be called only once
+                        expect(handler).toBeCalledTimes(1);
+
+                        // handler should unsubscribe from notification channel
+                        expect(cache.unsubscribe).toBeCalledTimes(1);
+                        expect(cache.unsubscribe).toBeCalledWith(channel, subId);
+                        resolve();
+                    }).catch((err) => { reject(err); } );
+            });
+
+            // ensure handler wasn't called before publishing the message
+            expect(handler).not.toBeCalled();
+
+            // ensure that cache.unsubscribe does not happened before fire the message
+            expect(cache.unsubscribe).not.toBeCalled();
+
+            // fire publication with given message
+            const df = deferredJob(cache, channel);
+            setImmediate(() => df.trigger(message));
+
+            // wait for onRequestAction
+            await onRequestActionPromise;
+        });
+
+        it('should handle timeouts', async () => {
+            const transactionRequestId = uuid();
+            const fspId = uuid();
+            // our code takes care only about 'transactionRequestId' property
+            const authorization = { transactionRequestId };
+            const channel = Model.channelName({ transactionRequestId });
+
+            const model = await Model.create(data, cacheKey, modelConfig);
+            const { cache } = model.context;
+            // mock workflow execution which is tested in separate case
+            model.run = jest.fn(() => Promise.resolve());
+
+            const message = { ...authorizationsResponse };
+
+            const onRequestActionPromise = new Promise((resolve, reject) => {
+                // manually invoke transition handler
+                model.onRequestAction(model.fsm, { transactionRequestId, fspId, authorization })
+                    .then(() => reject())
+                    .catch((err) => {
+                        // subscribe should be called only once
+                        expect(err instanceof pt.TimeoutError).toBeTruthy();
+
+                        // subscribe should be done to proper notificationChannel
+                        expect(cache.subscribe.mock.calls[0][0]).toEqual(channel);
+
+                        // check invocation of request.getParties
+                        expect(MojaloopRequests.__postAuthorizations).toBeCalledWith(authorization, fspId);
+
+                        // handler should be called only once
+                        expect(handler).toBeCalledTimes(0);
+
+                        // handler should unsubscribe from notification channel
+                        expect(cache.unsubscribe).toBeCalledTimes(1);
+                        expect(cache.unsubscribe).toBeCalledWith(channel, subId);
+                        resolve();
+                    });
+            });
+
+            // ensure handler wasn't called before publishing the message
+            expect(handler).not.toBeCalled();
+
+            // ensure that cache.unsubscribe does not happened before fire the message
+            expect(cache.unsubscribe).not.toBeCalled();
+
+            // fire publication with given message
+            const df = deferredJob(cache, channel);
+
+            setTimeout(
+                () => { df.trigger(message); },
+                // ensure that publication will be far long after timeout should be auto triggered
+                (modelConfig.requestProcessingTimeoutSeconds + 1) * 1000
+            );
+
+            // wait for onRequestAction
+            await onRequestActionPromise;
+        });
+
+        it('should unsubscribe from cache in case when error happens in workflow run', async () => {
+            const transactionRequestId = uuid();
+            const fspId = uuid();
+            // our code takes care only about 'transactionRequestId' property
+            const authorization = { transactionRequestId };
+            const channel = Model.channelName({ transactionRequestId });
+            const model = await Model.create(data, cacheKey, modelConfig);
+            const { cache } = model.context;
+
+            // fire publication to channel with invalid message 
+            // should throw the exception from JSON.parse
+            const df = deferredJob(cache, channel);
+            setImmediate(() => df.trigger(undefined));
+            
+            try {
+                await model.onRequestAction(model.fsm, { transactionRequestId, fspId, authorization });
+                throw new Error('this point should not be reached');
+            } catch(err) {
+                expect(err.message).toEqual('Unexpected token u in JSON at position 0');
+                expect(cache.unsubscribe).toBeCalledTimes(1);
+                expect(cache.unsubscribe).toBeCalledWith(channel, subId);
+            }
+        });
+
+        it('should unsubscribe from cache in case when error happens Mojaloop requests', async () => {
+            // simulate error
+            MojaloopRequests.__postAuthorizations = jest.fn(() => Promise.reject('postAuthorizations failed'));
+            const transactionRequestId = uuid();
+            const fspId = uuid();
+            // our code takes care only about 'transactionRequestId' property
+            const authorization = { transactionRequestId };
+            const channel = Model.channelName({ transactionRequestId });
+            const model = await Model.create(data, cacheKey, modelConfig);
+            const { cache } = model.context;
+
+            let theError = null;
+            // invoke transition handler
+            try {
+                await model.onRequestAction(model.fsm, { transactionRequestId, fspId, authorization });
+                throw new Error('this point should not be reached');
+            } catch (error) {
+                theError = error;
+                expect(theError).toEqual('postAuthorizations failed');
+                // handler should unsubscribe from notification channel
+                expect(cache.unsubscribe).toBeCalledTimes(1);
+                expect(cache.unsubscribe).toBeCalledWith(channel, subId);
+            }
+        });
+
+    });
+
+    describe('run workflow', () => {
+        it('start', async () => {
+            const transactionRequestId = uuid();
+            const fspId = uuid();
+            // our code takes care only about 'transactionRequestId' property
+            const authorization = { transactionRequestId };
+
+            const model = await Model.create(data, cacheKey, modelConfig);
+
+            model.requestAction = jest.fn();
+            model.getResponse = jest.fn(() => Promise.resolve({ the: 'response' }));
+
+            model.context.data.currentState = 'start';
+            const result = await model.run({ transactionRequestId, fspId, authorization });
+            expect(result).toEqual({ the: 'response' });
+            expect(model.requestAction).toBeCalledTimes(1);
+            expect(model.getResponse).toBeCalledTimes(1);
+            expect(model.context.logger.log.mock.calls).toEqual([
+                ['State machine transitioned \'init\': none -> start'],
+                ['Action called successfully'],
+                [`Persisted model in cache: ${cacheKey}`],
+            ]);
+        });
+        it('succeeded', async () => {
+            const transactionRequestId = uuid();
+            const fspId = uuid();
+            // our code takes care only about 'transactionRequestId' property
+            const authorization = { transactionRequestId };
+
+            const model = await Model.create(data, cacheKey, modelConfig);
+
+            model.getResponse = jest.fn(() => Promise.resolve({ the: 'response' }));
+
+            model.context.data.currentState = 'succeeded';
+            const result = await model.run({ transactionRequestId, fspId, authorization });
+
+            expect(result).toEqual({ the: 'response' });
+            expect(model.getResponse).toBeCalledTimes(1);
+            expect(model.context.logger.log).toBeCalledWith('Action called successfully');
+        });
+
+        it('errored', async () => {
+            const transactionRequestId = uuid();
+            const fspId = uuid();
+            // our code takes care only about 'transactionRequestId' property
+            const authorization = { transactionRequestId };
+
+            const model = await Model.create(data, cacheKey, modelConfig);
+
+            model.getResponse = jest.fn(() => Promise.resolve({ the: 'response' }));
+
+            model.context.data.currentState = 'errored';
+            const result = await model.run({ transactionRequestId, fspId, authorization });
+
+            expect(result).toBeFalsy();
+            expect(model.getResponse).not.toBeCalled();
+            expect(model.context.logger.log).toBeCalledWith('State machine in errored state');
+        });
+
+        it('handling errors', async () => {
+            const transactionRequestId = uuid();
+            const fspId = uuid();
+            // our code takes care only about 'transactionRequestId' property
+            const authorization = { transactionRequestId };
+
+            const model = await Model.create(data, cacheKey, modelConfig);
+
+            model.requestAction = jest.fn(() => { throw new Error('mocked error'); });
+
+            model.context.data.currentState = 'start';
+
+            try { 
+                await model.run({ transactionRequestId, fspId, authorization });
+                throw new Error('this point should not be reached');
+            } catch (err) {
+                expect(model.context.data.currentState).toEqual('errored');
+                expect(err.requestActionState).toEqual({
+                    ...data,
+                    currentState: 'ERROR_OCCURRED',
+                });
+            }
+        });
+
+        it('should handle errors', async () => {
+            const transactionRequestId = uuid();
+            const fspId = uuid();
+            // our code takes care only about 'transactionRequestId' property
+            const authorization = { transactionRequestId };
+
+            const model = await Model.create(data, cacheKey, modelConfig);
+
+            model.requestAction = jest.fn(() => {
+                const err = new Error('requestAction failed');
+                err.requestActionState = 'some';
+                return Promise.reject(err);
+            });
+            model.error = jest.fn();
+            model.context.data.currentState = 'start';
+
+            let theError = null;
+            try {
+                await model.run({ transactionRequestId, fspId, authorization });
+                throw new Error('this point should not be reached');
+            } catch (error) {
+                theError = error;
+            }
+            // check propagation of original error
+            expect(theError.message).toEqual('requestAction failed');
+
+            // ensure we start transition to errored state
+            expect(model.error).toBeCalledTimes(1);
+        });
+
+        it('should handle input validation for lack of transactionRequestId param', async () => {
+            const model = await Model.create(data, cacheKey, modelConfig);
+
+            expect(() => model.run({}))
+                .rejects.toEqual(
+                    new Error('AuthorizationsModel args requires \'transactionRequestId\' is nonempty string and mandatory property')
+                );
+        });
+
+        it('should handle input validation for fspId param', async () => {
+            const transactionRequestId = uuid();
+            const model = await Model.create(data, cacheKey, modelConfig);
+
+            expect(() => model.run({ transactionRequestId, fspId: '' }))
+                .rejects.toEqual(
+                    new Error('AuthorizationsModel args requires \'fspId\' to be nonempty string')
+                );
+        });
+
+    });
+
+    describe('loadFromCache', () => {
+        test('should use PSM.loadFromCache properly', async () => {
+            const spyLoadFromCache = jest.spyOn(PSM, 'loadFromCache');
+            const key = uuid();
+
+            // act
+            const model = await Model.loadFromCache(key, modelConfig);
+
+            // assert
+            // check does model is proper
+            expect(typeof model.requestAction).toEqual('function');
+
+            // check how cache.get has been called
+            expect(modelConfig.cache.get).toBeCalledWith(key);
+
+            // check how loadFromCache from parent PSM module was used
+            expect(spyLoadFromCache).toBeCalledTimes(1);
+            expect(spyLoadFromCache).toBeCalledWith(
+                modelConfig.cache,
+                key,
+                modelConfig.logger,
+                expect.anything(),
+                expect.anything()
+            );
+        });
+    });
+});