@mojaloop/sdk-scheme-adapter 18.0.0 → 18.0.1

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

@@ -1,481 +0,0 @@
-/**************************************************************************
- *  (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:                                                      *
- *       Kevin Leyow - kevin.leyow@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').TransfersModel;
-const PSM = require('~/lib/model/common').PersistentStateMachine;
-const { SDKStateEnum } = require('~/lib/model/common');
-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 putTransfersResponse = require('./data/putTransfersResponse.json');
-
-describe('TransfersModel', () => {
-    let cacheKey;
-    let data;
-    let modelConfig;
-
-    const subId = uuid();
-    let handler = null;
-    beforeEach(async () => {
-
-        modelConfig = {
-            logger: mockLogger({app: 'TransfersModel-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-transfers-${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(`TransfersModel model response being returned from an unexpected state: ${undefined}. Returning ERROR_OCCURRED state`);
-        });
-    });
-
-    describe('channelName', () => {
-        it('should validate input', () => {
-            expect(Model.channelName({})).toEqual('transfers-undefined');
-        });
-
-        it('should generate proper channel name', () => {
-            const transferId = uuid();
-            expect(Model.channelName({ transferId })).toEqual(`transfers-${transferId}`);
-        });
-
-    });
-
-    describe('generateKey', () => {
-        it('should generate proper cache key', () => {
-            const transferId = uuid();
-            expect(Model.generateKey({ transferId })).toEqual(`key-${Model.channelName({ transferId })}`);
-        });
-
-        it('should handle lack of transferId param', () => {
-            expect(() => Model.generateKey({ })).toThrowError(new Error('TransfersModel args requires \'transferId\' is nonempty string and mandatory property'));
-        });
-
-    });
-
-    describe('onRequestAction', () => {
-
-        it('should implement happy flow', async () => {
-            const transferId = uuid();
-            const fspId = uuid();
-            // our code takes care only about 'transferId' property
-            const transfer = { transferId };
-            const channel = Model.channelName({ transferId });
-            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 = {
-                body: { ...putTransfersResponse },
-                headers: {}
-            };
-
-            const onRequestActionPromise = new Promise((resolve, reject) => {
-                // manually invoke transition handler
-                model.onRequestAction(model.fsm, { transferId, fspId, transfer })
-                    .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.__postTransfers).toBeCalledWith(transfer, fspId);
-
-                        // check that this.context.data is updated
-                        expect(model.context.data).toEqual({
-                            transfer: { ...message },
-                            // current state will be updated by onAfterTransition which isn't called
-                            // when manual invocation of transition handler happens
-                            currentState: 'start'
-                        });
-                        // 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 transferId = uuid();
-            const fspId = uuid();
-            // our code takes care only about 'transferId' property
-            const transfer = { transferId };
-            const channel = Model.channelName({ transferId });
-
-            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 = {
-                body: { ...putTransfersResponse },
-                headers: {}
-            };
-
-            const onRequestActionPromise = new Promise((resolve, reject) => {
-                // manually invoke transition handler
-                model.onRequestAction(model.fsm, { transferId, fspId, transfer })
-                    .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.__postTransfers).toBeCalledWith(transfer, 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 transferId = uuid();
-            const fspId = uuid();
-            // our code takes care only about 'transferId' property
-            const transfer = { transferId };
-            const channel = Model.channelName({ transferId });
-            const model = await Model.create(data, cacheKey, modelConfig);
-            const { cache } = model.context;
-
-            const onRequestActionPromise = new Promise((resolve, reject) => {
-                // invoke transition handler
-                model.onRequestAction(model.fsm, { transferId, fspId, transfer })
-                    .then(() => reject())
-                    .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);
-                        resolve();
-                    });
-            });
-
-            // fire publication to channel with invalid message
-            // should throw the exception from JSON.parse
-            const df = deferredJob(cache, channel);
-            setImmediate(() => df.trigger(undefined));
-
-            // wait for onRequestAction
-            await onRequestActionPromise;
-        });
-
-        it('should unsubscribe from cache in case when error happens Mojaloop requests', async () => {
-            // simulate error
-            MojaloopRequests.__postTransfers = jest.fn(() => Promise.reject('postTransfers failed'));
-            const transferId = uuid();
-            const fspId = uuid();
-            // our code takes care only about 'transferId' property
-            const transfer = { transferId };
-            const channel = Model.channelName({ transferId });
-            const model = await Model.create(data, cacheKey, modelConfig);
-            const { cache } = model.context;
-
-            let theError = null;
-            // invoke transition handler
-            try {
-                await model.onRequestAction(model.fsm, { transferId, fspId, transfer });
-                throw new Error('this point should not be reached');
-            } catch (error) {
-                theError = error;
-                expect(theError).toEqual('postTransfers 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 transferId = uuid();
-            const fspId = uuid();
-            // our code takes care only about 'transferId' property
-            const transfer = { transferId };
-
-            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({ transferId, fspId, transfer });
-            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 transferId = uuid();
-            const fspId = uuid();
-            // our code takes care only about 'transferId' property
-            const transfer = { transferId };
-
-            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({ transferId, fspId, transfer });
-
-            expect(result).toEqual({the: 'response'});
-            expect(model.getResponse).toBeCalledTimes(1);
-            expect(model.context.logger.log).toBeCalledWith('Action called successfully');
-        });
-
-        it('errored', async () => {
-            const transferId = uuid();
-            const fspId = uuid();
-            // our code takes care only about 'transferId' property
-            const transfer = { transferId };
-
-            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({ transferId, fspId, transfer});
-
-            expect(result).toBeFalsy();
-            expect(model.getResponse).not.toBeCalled();
-            expect(model.context.logger.log).toBeCalledWith('State machine in errored state');
-        });
-
-        it('handling errors', async () => {
-            const transferId = uuid();
-            const fspId = uuid();
-            // our code takes care only about 'transferId' property
-            const transfer = { transferId };
-
-            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({ transferId, fspId, transfer });
-                throw new Error('this point should not be reached');
-            } catch (err) {
-                expect(model.context.data.currentState).toEqual('errored');
-                expect(err.requestActionState).toEqual( {
-                    ...data,
-                    currentState: SDKStateEnum.ERROR_OCCURRED,
-                });
-            }
-        });
-        it('should handle errors', async () => {
-            const transferId = uuid();
-            const fspId = uuid();
-            // our code takes care only about 'transferId' property
-            const transfer = { transferId };
-
-            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({ transferId, fspId, transfer });
-                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 transferId param', async () => {
-            const model = await Model.create(data, cacheKey, modelConfig);
-
-            expect(() => model.run({}))
-                .rejects.toEqual(
-                    new Error('TransfersModel args requires \'transferId\' is nonempty string and mandatory property')
-                );
-        });
-
-        it('should handle input validation for not transferId & transfer.transferId be in sync', async () => {
-            const transferId = uuid();
-            const model = await Model.create(data, cacheKey, modelConfig);
-
-            expect(() => model.run({transferId, transfer: { transferId: uuid()}}))
-                .rejects.toEqual(
-                    new Error('TransfersModel args requires properties \'transfer.transferId\' and \'transferId\' to be the equal in value')
-                );
-        });
-
-        it('should handle input validation for fspId param', async () => {
-            const transferId = uuid();
-            const model = await Model.create(data, cacheKey, modelConfig);
-
-            expect(() => model.run({transferId, fspId:'' }))
-                .rejects.toEqual(
-                    new Error('TransfersModel 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()
-            );
-        });
-    });
-});

package/test/unit/lib/model/common/PersistentStateMachine.test.js

@@ -1,178 +0,0 @@
-/**************************************************************************
- *  (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                         *
- **************************************************************************/
-
-'use strict';
-
-const Cache = jest.createMockFromModule('~/lib/cache');
-
-const PSM = require('~/lib/model').PersistentStateMachine;
-const mockLogger = require('../../../mockLogger');
-describe('PersistentStateMachine', () => {
-    let cache;
-    let data;
-    let smSpec;
-    const key = 'cache-key';
-
-    const logger = mockLogger({app: 'persistent-state-machine-test'});
-
-    function checkPSMLayout(psm, optData) {
-        expect(psm).toBeTruthy();
-
-        expect(psm.state).toEqual((optData && optData.currentState) || smSpec.init || 'none');
-
-        expect(psm.context).toEqual({
-            // allow passing optional data, elsewhere use default
-            data: optData || data,
-            cache,
-            key,
-            logger
-        });
-
-        expect(typeof psm.onAfterTransition).toEqual('function');
-        expect(typeof psm.onPendingTransition).toEqual('function');
-        expect(typeof psm.saveToCache).toEqual('function');
-        expect(typeof psm.init).toEqual('function');
-        expect(typeof psm.gogo).toEqual('function');
-        expect(typeof psm.error).toEqual('function');
-    }
-
-    function shouldNotBeExecuted() {
-        throw new Error('test failure enforced: this code should never be executed');
-    }
-
-    beforeEach(async () => {
-        smSpec = {
-            // init: 'start',
-            transitions: [
-                { name: 'init', from: 'none', to: 'start'},
-                { name: 'gogo', from: 'start', to: 'end' },
-                { name: 'error', from: '*', to: 'errored' }
-            ],
-            methods: {
-                onGogo: async () => {
-                    return new Promise( (resolved) => {
-                        setTimeout((() => resolved(true)), 100);
-                    } );
-                },
-                onError: () => {
-                    // eslint-disable-next-line no-console
-                    console.error('onError');
-                }
-            }
-        };
-
-        // test data
-        data = { the: 'data' };
-
-        cache = new Cache({
-                cacheUrl: 'redis://dummy:1234',
-                logger,
-            });
-        // mock cache set & get
-        cache.get = jest.fn(async () => data);
-        cache.set = jest.fn(async () => 'cache set replies');
-
-        await cache.connect();
-    });
-
-    afterEach(async () => {
-        await cache.disconnect();
-    });
-
-    test('module layout', () => {
-        expect(typeof PSM.create).toEqual('function');
-        expect(typeof PSM.loadFromCache).toEqual('function');
-    });
-
-    test('create', async () => {
-        const psm = await PSM.create(data, cache, key, logger, smSpec);
-        checkPSMLayout(psm);
-        expect(psm.state).toEqual('none');
-        await psm.init();
-        expect(psm.state).toEqual('start');
-    });
-
-    describe('onPendingTransition', () => {
-        it('should throw error if not `error` transition', async () => {
-            const psm = await PSM.create(data, cache, key, logger, smSpec);
-            checkPSMLayout(psm);
-
-            psm.init();
-            expect(() => psm.gogo()).toThrowError('Transition \'gogo\' requested while another transition is in progress');
-
-        });
-
-        it('should not throw error if `error` transition called when `gogo` is pending', (done) => {
-            PSM.create(data, cache, key, logger, smSpec).then((psm) => {
-                checkPSMLayout(psm);
-
-                psm.init()
-                    .then(() => {
-                        expect(psm.state).toEqual('start');
-                        psm.gogo();
-                        expect(psm.state).toEqual('end');
-                        return Promise.resolve();
-                    })
-                    .then(() => psm.error())
-                    .then(done)
-                    .catch(shouldNotBeExecuted);
-            });
-        });
-    });
-
-    describe('loadFromCache', () => {
-        it('should properly call cache.get, get expected data in `context.data` and setup state of machine', async () => {
-            const dataFromCache = { this_is: 'data from cache', currentState: 'end'};
-            cache.get = jest.fn( async () => dataFromCache);
-            const psm = await PSM.loadFromCache(cache, key, logger, smSpec);
-            checkPSMLayout(psm, dataFromCache);
-
-            // to get value from cache proper key should be used
-            expect(cache.get).toHaveBeenCalledWith(key);
-
-            // check what has been stored in `context.data`
-            expect(psm.context.data).toEqual(dataFromCache);
-
-        });
-
-        it('should throw when received invalid data from `cache.get`', async () => {
-            cache.get = jest.fn( async () => null);
-            try {
-                await PSM.loadFromCache(cache, key, logger, smSpec);
-                shouldNotBeExecuted();
-            } catch (error) {
-                expect(error.message).toEqual(`No cached data found for: ${key}`);
-            }
-        });
-
-        it('should propagate error received from `cache.get`', async () => {
-            cache.get = jest.fn( async () => { throw new Error('error from cache.get'); });
-            expect(() => PSM.loadFromCache(cache, key, logger, smSpec))
-                .rejects.toEqual(new Error('error from cache.get'));
-        });
-    });
-
-    describe('saveToCache', () => {
-
-        it('should rethrow error from cache.set', async () => {
-
-            // mock to simulate throwing error
-            cache.set = jest.fn(() => { throw new Error('error from cache.set'); });
-
-            const psm = await PSM.create(data, cache, key, logger, smSpec);
-            checkPSMLayout(psm);
-            await psm.init();
-
-            expect(() => psm.saveToCache())
-                .rejects.toEqual(new Error('error from cache.set'));
-        });
-    });
-
-});

package/test/unit/lib/model/data/authorizationsResponse.json

@@ -1,13 +0,0 @@
-{
-    "type": "otpResponse",
-    "data": {
-        "authenticationInfo": {
-            "authentication": "OTP",
-            "authenticationValue": "12334567"
-        },
-        "responseType": "ENTERED"
-    },
-    "headers": {
-      "fspiop-source": "foo"
-    }
-}