@mojaloop/sdk-scheme-adapter 11.18.8

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

@@ -0,0 +1,468 @@
+/**************************************************************************
+ *  (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:                                                      *
+ *       Paweł Marzec - pawel.marzec@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').PartiesModel;
+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');
+
+describe('PartiesModel', () => {
+    let cacheKey;
+    let data;
+    let modelConfig;
+  
+    const subId = 123;
+    let handler = null;
+    beforeEach(async () => {
+
+        modelConfig = {
+            logger: mockLogger({app: 'PartiesModel-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 = 'cache-key';
+    });
+
+    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(`PartiesModel model response being returned from an unexpected state: ${undefined}. Returning ERROR_OCCURRED state`);
+        });
+    });
+
+    describe('channelName', () => {
+        it('should validate input', () => {
+            expect(Model.channelName({})).toEqual('parties-undefined-undefined-undefined');
+        });
+
+        it('should generate proper channel name', () => {
+            const type = uuid();
+            const id = uuid();
+            expect(Model.channelName({ type, id })).toEqual(`parties-${type}-${id}-undefined`);
+        });
+
+        it('should generate proper channel name when all params specified', () => {
+            const type = uuid();
+            const id = uuid();
+            const subId = uuid();
+            expect(Model.channelName({ type, id, subId })).toEqual(`parties-${type}-${id}-${subId}`);
+        });
+    });
+
+    describe('generateKey', () => {
+        it('should generate proper cache key', () => {
+            const type = uuid();
+            const id = uuid();
+            expect(Model.generateKey({ type, id })).toEqual(`key-${Model.channelName({ type, id })}`);
+        });
+
+        it('should handle lack of id param', () => {
+            const type = uuid();
+            expect(() => Model.generateKey({ type })).toThrowError(new Error('PartiesModel args required at least two string arguments: \'type\' and \'id\''));
+        });
+
+        it('should handle all params', () => {
+            const type = uuid();
+            const id = uuid();
+            const subId = uuid();
+            expect(Model.generateKey({ type, id, subId })).toEqual(`key-${Model.channelName({ type, id, subId })}`);
+        });
+    });
+
+    describe('onRequestAction', () => {
+
+        it('should implement happy flow', async () => {
+            const type = uuid();
+            const id = uuid();
+            const subIdValue = uuid();
+
+            const channel = Model.channelName({ type, id, subId: subIdValue });
+            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 = {
+                party: {
+                    Iam: 'the-body'
+                }
+            };
+
+            const onRequestActionPromise = new Promise((resolve, reject) => {
+                // manually invoke transition handler
+                model.onRequestAction(model.fsm, { type, id, subId: subIdValue })
+                    .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.__getParties).toBeCalledWith(type, id, subIdValue);
+
+                        // check that this.context.data is updated
+                        expect(model.context.data).toEqual({
+                            ...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 type = uuid();
+            const id = uuid();
+            const subIdValue = uuid();
+
+            const channel = Model.channelName({ type, id, subId: subIdValue });
+            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 = {
+                party: {
+                    Iam: 'the-body'
+                }
+            };
+
+            const onRequestActionPromise = new Promise((resolve, reject) => {
+                // manually invoke transition handler
+                model.onRequestAction(model.fsm, { type, id, subId: subIdValue })
+                    .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.__getParties).toBeCalledWith(type, id, subIdValue);
+
+                        // 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 type = uuid();
+            const id = uuid();
+            const subIdValue = uuid();
+
+            const channel = Model.channelName({ type, id, subId: subIdValue });
+            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, { type, id, subId: subIdValue })
+                    .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.__getParties = jest.fn(() => Promise.reject('getParties failed'));
+            const type = uuid();
+            const id = uuid();
+            const subIdValue = uuid();
+
+            const channel = Model.channelName({ type, id, subId: subIdValue });
+            const model = await Model.create(data, cacheKey, modelConfig);
+            const { cache } = model.context;
+
+            let theError = null;
+            // invoke transition handler
+            try {
+                await model.onRequestAction(model.fsm, { type, id, subId: subIdValue });
+                throw new Error('this point should not be reached');
+            } catch (error) {
+                theError = error;
+                expect(theError).toEqual('getParties 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 type = uuid();
+            const id = uuid();
+            const subIdValue = uuid();
+
+            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({ type, id, subId: subIdValue });
+            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 type = uuid();
+            const id = uuid();
+            const subIdValue = uuid();
+
+            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({ type, id, subId: subIdValue });
+            
+            expect(result).toEqual({the: 'response'});
+            expect(model.getResponse).toBeCalledTimes(1);
+            expect(model.context.logger.log).toBeCalledWith('Action called successfully');
+        });
+
+        it('errored', async () => {
+            const type = uuid();
+            const id = uuid();
+            const subIdValue = uuid();
+
+            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({ type, id, subId: subIdValue });
+            
+            expect(result).toBeFalsy();
+            expect(model.getResponse).not.toBeCalled();
+            expect(model.context.logger.log).toBeCalledWith('State machine in errored state');
+        });
+
+        it('handling errors', async () => {
+            const type = uuid();
+            const id = uuid();
+            const subIdValue = uuid();
+
+            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({ type, id, subId: subIdValue });
+                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 type = uuid();
+            const id = uuid();
+            const subIdValue = uuid();
+
+            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({ type, id, subId: subIdValue });
+                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 id/subId params', async () => {
+            const type = uuid();
+            const model = await Model.create(data, cacheKey, modelConfig);
+            
+            expect(() => model.run(type))
+                .rejects.toEqual(
+                    new Error('PartiesModel args required at least two string arguments: \'type\' and \'id\'')
+                );
+        });
+    });
+
+    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()
+            );
+        });
+    });
+});