dyo-tools 0.4.0 → 0.4.1

package/test/core/DTMaster.double.ts

@@ -1,117 +0,0 @@
-import {expect, jest} from "@jest/globals";
-import {DTMaster} from "../../src";
-import {DTManagerStub, IDTest as IDManagerTest, manager1IDTest, manager1KeyTest} from "./DTManager.double";
-import {action1IDTest, action1KeyTest, DTActionStub, IDTest as IDActionTest} from "./DTAction.double";
-import {DTModuleStub, IDTest as IDModuleTest, module1IDTest, module1KeyTest} from "./DTModule.double";
-
-/** ****************** STUB PROPERTIES CONSTANTS
- * Fixed properties to use with double classes, avoid auto generated and easy checking on test
- * **** */
-export const IDTest = 'DTMaster-id-1234567';
-export const KeyTest = 'DTMaster-key-1234567';
-
-/** ****************** HELPER TEST CLASS
- * Helper test class, inherits the main component
- * Providing methods to property access and other facilities, in order to avoid using class methods
- * **** */
-export class DTMasterTest extends DTMaster {
-  constructor(
-    id: string = IDTest,
-    key: string = KeyTest,
-    managers: Record<string, DTManagerStub> = {},
-    actions: Record<string, DTActionStub> = {},
-    modules: Record<string, DTModuleStub> = {},
-  ) {
-    super(key);
-    this._id = id;
-    this._managers = managers;
-    this._actions = actions;
-    this._modules = modules;
-  }
-
-  _getManagers() {
-    return this._managers;
-  }
-
-  _getActions() {
-    return this._actions;
-  }
-
-  _getModules() {
-    return this._modules;
-  }
-
-  populate() {
-    // Managers
-    const manager1 = new DTManagerStub();
-    const manager2 = new DTManagerStub();
-    manager2._setId(manager1IDTest);
-    manager2._setKey(manager1KeyTest);
-
-    this._managers = {
-      [IDManagerTest]: manager1,
-      [manager1IDTest]: manager2
-    };
-
-    // Actions
-    const action1 = new DTActionStub();
-    const action2 = new DTActionStub();
-    action2._setId(action1IDTest);
-    action2._setKey(action1KeyTest);
-
-    this._actions = {
-      [IDActionTest]: action1,
-      [action1IDTest]: action2
-    };
-
-    // Modules
-    const module1 = new DTModuleStub();
-    const module2 = new DTModuleStub();
-    module2._setId(module1IDTest);
-    module2._setKey(module1KeyTest);
-    module2.disable();
-
-    this._modules = {
-      [IDModuleTest]: module1,
-      [module1IDTest]: module2
-    };
-  }
-}
-
-
-/** ****************** STUB CLASS
- * Stub class, for using in other component
- * **** */
-
-/** ****************** HELPER METHODS
- * Additional helper methods to use with testing
- * **** */
-export const checkMasterManagers = (master: DTMasterTest, ids: string[]) => {
-  let i = 0;
-  expect(Object.keys(master._getManagers()).length).toBe(ids.length);
-  for (let [id, manager] of Object.entries(master._getManagers())) {
-    expect(id).toBe(ids[i]);
-    expect(manager.getId()).toBe(ids[i]);
-    i++;
-  }
-}
-
-export const checkMasterActions = (master: DTMasterTest, ids: string[]) => {
-  let i = 0;
-  expect(Object.keys(master._getActions()).length).toBe(ids.length);
-  for (let [id, action] of Object.entries(master._getActions())) {
-    expect(id).toBe(ids[i]);
-    expect(action.getId()).toBe(ids[i]);
-    i++;
-  }
-}
-
-export const checkMasterModules = (master: DTMasterTest, ids: string[]) => {
-  let i = 0;
-  expect(Object.keys(master._getModules()).length).toBe(ids.length);
-  for (let [id, module] of Object.entries(master._getModules())) {
-    expect(id).toBe(ids[i]);
-    expect(module.getId()).toBe(ids[i]);
-    i++;
-  }
-}

package/test/core/DTMaster.spec.ts

@@ -1,537 +0,0 @@
-import {afterEach, beforeEach, describe, expect, jest, test} from "@jest/globals";
-import {DTComponent, DTError, DTMaster} from "../../src";
-import {
-  checkMasterActions,
-  checkMasterManagers,
-  checkMasterModules,
-  DTMasterTest,
-  IDTest,
-  KeyTest
-} from "./DTMaster.double";
-import {
-  DTManagerStub,
-  IDTest as manager1IDTest,
-  manager1IDTest as manager2IDTest,
-  manager1KeyTest as manager2KeyTest,
-  manager1ToObject
-} from "./DTManager.double";
-import {
-  action1IDTest as action2IDTest,
-  action1KeyTest as action2KeyTest,
-  action1ToObject,
-  DTActionStub,
-  IDTest as action1IDTest,
-  KeyTest as action1KeyTest
-} from "./DTAction.double";
-import {
-  DTModuleStub,
-  IDTest as module1IDTest,
-  module1IDTest as module2IDTest,
-  module1KeyTest as module2KeyTest,
-  module1ToObject
-} from "./DTModule.double";
-
-/** *********************** TESTS SUITES ****************************** */
-describe('class DTMaster', () => {
-  let masterTest: DTMasterTest;
-
-  beforeEach(() => {
-    masterTest = new DTMasterTest();
-  });
-
-  afterEach(() => {
-    jest.resetAllMocks();
-  });
-
-  describe('inheritance', () => {
-    test('check good inheritance for class', () => {
-      expect(DTMaster.prototype instanceof DTComponent).toBeTruthy();
-    });
-  });
-
-  describe('_componentType', () => {
-    test('componentType must be "master"', () => {
-      expect(masterTest.getComponentType()).toBe('master');
-    });
-  });
-
-  describe('constructor()', () => {
-    beforeEach(() => {
-      jest.resetAllMocks();
-    });
-
-    test('simple creation with key', () => {
-      const newMaster = new DTMasterTest(IDTest, KeyTest);
-
-      expect(newMaster._getManagers()).toStrictEqual({});
-      expect(newMaster._getActions()).toStrictEqual({});
-      expect(newMaster._getModules()).toStrictEqual({});
-    });
-
-  });
-
-  describe('addManager()', () => {
-    let managerToAdd: DTManagerStub;
-
-    beforeEach(() => {
-      managerToAdd = new DTManagerStub();
-    });
-
-    test('add a new manager - standard case', () => {
-      masterTest.addManager(managerToAdd);
-
-      checkMasterManagers(masterTest, [manager1IDTest]);
-    });
-
-    test('trigger error when adding two managers with same id', () => {
-      masterTest.addManager(managerToAdd);
-      let errorThrown: DTError | undefined;
-      try {
-        masterTest.addManager(managerToAdd);
-      } catch(error) {
-        errorThrown = error;
-      }
-
-      expect(errorThrown).toBeDefined();
-      expect(Object.keys(masterTest._getManagers()).length).toBe(1);
-      if (errorThrown) {
-        expect(errorThrown.getCode()).toBe('id_conflict');
-        expect(errorThrown.getMessage()).toBe('Manager with same id already exists in the Master instance');
-        expect(errorThrown.getInitiator().getId()).toBe(IDTest);
-        expect(errorThrown.getConvicted().getId()).toBe(managerToAdd.getId());
-      }
-    });
-
-    test('trigger error when adding two managers with same key', () => {
-      const firstManager = new DTManagerStub();
-      firstManager._setId(manager2IDTest);
-      masterTest.addManager(firstManager);
-      let errorThrown: DTError | undefined;
-      try {
-        masterTest.addManager(managerToAdd);
-      } catch(error) {
-        errorThrown = error;
-      }
-
-      expect(errorThrown).toBeDefined();
-      expect(Object.keys(masterTest._getManagers()).length).toBe(1);
-      if (errorThrown) {
-        expect(errorThrown.getCode()).toBe('key_conflict');
-        expect(errorThrown.getMessage()).toBe('Manager with same key already exists in the Master instance');
-        expect(errorThrown.getInitiator().getId()).toBe(IDTest);
-        expect(errorThrown.getConvicted().getId()).toBe(managerToAdd.getId());
-      }
-    });
-
-    test('set context when adding a new manager', () => {
-      const setContextSpy = jest.spyOn(managerToAdd, 'setContext');
-
-      masterTest.addManager(managerToAdd);
-
-      expect(setContextSpy.mock.calls.length).toBe(1);
-      expect(setContextSpy.mock.calls[0][0].getId()).toBe(IDTest);
-    });
-  });
-
-  describe('getManager()', () => {
-    beforeEach(() => {
-      masterTest.populate();
-    });
-
-    test('return a manager by its id', () => {
-      const manager = masterTest.getManager(manager1IDTest);
-
-      expect(manager).toBeDefined();
-      expect(manager.getId()).toBe(manager1IDTest);
-    });
-
-    test('return a manager by its key', () => {
-      const manager = masterTest.getManager(manager2KeyTest);
-
-      expect(manager).toBeDefined();
-      expect(manager.getKey()).toBe(manager2KeyTest);
-    });
-
-    test('return undefined if manager is not found', () => {
-      const manager = masterTest.getManager('unexisting-id');
-
-      expect(manager).toBeUndefined();
-    });
-  });
-
-  describe('removeManager()', () => {
-    beforeEach(() => {
-      masterTest.populate();
-    });
-
-    test('remove a manager by its id', () => {
-      masterTest.removeManager(manager1IDTest);
-
-      expect(Object.keys(masterTest._getManagers()).length).toBe(1);
-      expect(Object.keys(masterTest._getManagers())[0]).toBe(manager2IDTest);
-    });
-
-    test('remove a manager by its key', () => {
-      masterTest.removeManager(manager2KeyTest);
-
-      expect(Object.keys(masterTest._getManagers()).length).toBe(1);
-      expect(Object.keys(masterTest._getManagers())[0]).toBe(manager1IDTest);
-    });
-
-    test('no removal if manager is not found', () => {
-      masterTest.removeManager('unexisting-id');
-
-      expect(Object.keys(masterTest._getManagers()).length).toBe(2);
-      expect(Object.keys(masterTest._getManagers())[0]).toBe(manager1IDTest);
-      expect(Object.keys(masterTest._getManagers())[1]).toBe(manager2IDTest);
-    });
-  });
-
-  describe('addAction()', () => {
-    let actionToAdd: DTActionStub;
-
-    beforeEach(() => {
-      actionToAdd = new DTActionStub();
-    });
-
-    test('add a new action - standard case', () => {
-      masterTest.addAction(actionToAdd);
-
-      checkMasterActions(masterTest, [action1IDTest]);
-    });
-
-    test('trigger error when adding two actions with same id', () => {
-      masterTest.addAction(actionToAdd);
-      let errorThrown: DTError | undefined;
-      try {
-        masterTest.addAction(actionToAdd);
-      } catch(error) {
-        errorThrown = error;
-      }
-
-      expect(errorThrown).toBeDefined();
-      expect(Object.keys(masterTest._getActions()).length).toBe(1);
-      if (errorThrown) {
-        expect(errorThrown.getCode()).toBe('id_conflict');
-        expect(errorThrown.getMessage()).toBe('Action with same id already exists in the Master instance');
-        expect(errorThrown.getInitiator().getId()).toBe(IDTest);
-        expect(errorThrown.getConvicted().getId()).toBe(actionToAdd.getId());
-      }
-    });
-
-    test('trigger error when adding two actions with same key', () => {
-      const firstAction = new DTActionStub();
-      firstAction._setId(action2IDTest);
-      masterTest.addAction(firstAction);
-      let errorThrown: DTError | undefined;
-      try {
-        masterTest.addAction(actionToAdd);
-      } catch(error) {
-        errorThrown = error;
-      }
-
-      expect(errorThrown).toBeDefined();
-      expect(Object.keys(masterTest._getActions()).length).toBe(1);
-      if (errorThrown) {
-        expect(errorThrown.getCode()).toBe('key_conflict');
-        expect(errorThrown.getMessage()).toBe('Action with same key already exists in the Master instance');
-        expect(errorThrown.getInitiator().getId()).toBe(IDTest);
-        expect(errorThrown.getConvicted().getId()).toBe(actionToAdd.getId());
-      }
-    });
-
-    test('set context when adding a new action', () => {
-      const setContextSpy = jest.spyOn(actionToAdd, 'setContext');
-
-      masterTest.addAction(actionToAdd);
-
-      expect(setContextSpy.mock.calls.length).toBe(1);
-      expect(setContextSpy.mock.calls[0][0].getId()).toBe(IDTest);
-    });
-  });
-
-  describe('getAction()', () => {
-    beforeEach(() => {
-      masterTest.populate();
-    });
-
-    test('return an action by its id', () => {
-      const action = masterTest.getAction(action1IDTest);
-
-      expect(action).toBeDefined();
-      expect(action.getId()).toBe(action1IDTest);
-    });
-
-    test('return an action by its key', () => {
-      const action = masterTest.getAction(action2KeyTest);
-
-      expect(action).toBeDefined();
-      expect(action.getId()).toBe(action2IDTest);
-    });
-
-    test('return undefined if action is not found', () => {
-      const action = masterTest.getAction('unexisting-id');
-
-      expect(action).toBeUndefined();
-    });
-  });
-
-  describe('removeAction()', () => {
-    beforeEach(() => {
-      masterTest.populate();
-    });
-
-    test('remove an action by its id', () => {
-      masterTest.removeAction(action1IDTest);
-
-      expect(Object.keys(masterTest._getActions()).length).toBe(1);
-      expect(Object.keys(masterTest._getActions())[0]).toBe(action2IDTest);
-    });
-
-    test('remove an action by its key', () => {
-      masterTest.removeAction(action2KeyTest);
-
-      expect(Object.keys(masterTest._getActions()).length).toBe(1);
-      expect(Object.keys(masterTest._getActions())[0]).toBe(action1IDTest);
-    });
-
-    test('no removal if action is not found', () => {
-      masterTest.removeAction('unexisting-id');
-
-      expect(Object.keys(masterTest._getActions()).length).toBe(2);
-      expect(Object.keys(masterTest._getActions())[0]).toBe(action1IDTest);
-      expect(Object.keys(masterTest._getActions())[1]).toBe(action2IDTest);
-    });
-  });
-
-  describe('executeAction()', () => {
-    beforeEach(() => {
-      masterTest.populate();
-    });
-
-    test('call execute method with payload for action by its id', async () => {
-      const payload = 'execute action from master by id';
-      const expectedPayload = `${action1KeyTest} : execute action from master by id`;
-
-      await expect(masterTest.executeAction(action1IDTest, payload)).rejects.toBe(expectedPayload);
-    });
-
-    test('call execute method with payload for action by its key', async () => {
-      const payload = 'execute action from master by key';
-      const expectedPayload = `${action2KeyTest} : execute action from master by key`;
-
-      await expect(masterTest.executeAction(action2KeyTest, payload)).rejects.toBe(expectedPayload);
-    });
-
-    test('no call of execute if action not found', async () => {
-      const payload = 'execute action from master';
-
-      // The assertion here only test that the execute method is not called, so there is no promise rejection
-      await expect(masterTest.executeAction('unexisting-id', payload)).resolves.toBeUndefined();
-    });
-  });
-
-  describe('addModule()', () => {
-    let moduleToAdd: DTModuleStub;
-
-    beforeEach(() => {
-      moduleToAdd = new DTModuleStub();
-    });
-
-    test('add a new module - standard case', () => {
-      masterTest.addModule(moduleToAdd);
-
-      checkMasterModules(masterTest, [module1IDTest]);
-    });
-
-    test('trigger error when adding two modules with same id', () => {
-      masterTest.addModule(moduleToAdd);
-      let errorThrown: DTError | undefined;
-      try {
-        masterTest.addModule(moduleToAdd);
-      } catch(error) {
-        errorThrown = error;
-      }
-
-      expect(errorThrown).toBeDefined();
-      expect(Object.keys(masterTest._getModules()).length).toBe(1);
-      if (errorThrown) {
-        expect(errorThrown.getCode()).toBe('id_conflict');
-        expect(errorThrown.getMessage()).toBe('Module with same id already exists in the Master instance');
-        expect(errorThrown.getInitiator().getId()).toBe(IDTest);
-        expect(errorThrown.getConvicted().getId()).toBe(moduleToAdd.getId());
-      }
-    });
-
-    test('trigger error when adding two modules with same key', () => {
-      const firstModule = new DTModuleStub();
-      firstModule._setId(module2IDTest);
-      masterTest.addModule(firstModule);
-      let errorThrown: DTError | undefined;
-      try {
-        masterTest.addModule(moduleToAdd);
-      } catch(error) {
-        errorThrown = error;
-      }
-
-      expect(errorThrown).toBeDefined();
-      expect(Object.keys(masterTest._getModules()).length).toBe(1);
-      if (errorThrown) {
-        expect(errorThrown.getCode()).toBe('key_conflict');
-        expect(errorThrown.getMessage()).toBe('Module with same key already exists in the Master instance');
-        expect(errorThrown.getInitiator().getId()).toBe(IDTest);
-        expect(errorThrown.getConvicted().getId()).toBe(moduleToAdd.getId());
-      }
-    });
-
-    test('set context when adding a new module', () => {
-      const setContextSpy = jest.spyOn(moduleToAdd, 'setContext');
-      
-      masterTest.addModule(moduleToAdd);
-
-      expect(setContextSpy.mock.calls.length).toBe(1);
-      expect(setContextSpy.mock.calls[0][0].getId()).toBe(IDTest);
-    });
-  });
-
-  describe('getModule()', () => {
-    beforeEach(() => {
-      masterTest.populate();
-    });
-
-    test('return a module by its id', () => {
-      const module = masterTest.getModule(module1IDTest);
-
-      expect(module).toBeDefined();
-      expect(module.getId()).toBe(module1IDTest);
-    });
-
-    test('return a module by its key', () => {
-      const module = masterTest.getModule(module2KeyTest);
-
-      expect(module).toBeDefined();
-      expect(module.getId()).toBe(module2IDTest);
-    });
-
-    test('return undefined if module is not found', () => {
-      const module = masterTest.getModule('unexisting-id');
-
-      expect(module).toBeUndefined();
-    });
-  });
-
-  describe('removeModule()', () => {
-    beforeEach(() => {
-      masterTest.populate();
-    });
-
-    test('remove a module by its id', () => {
-      masterTest.removeModule(module1IDTest);
-
-      expect(Object.keys(masterTest._getModules()).length).toBe(1);
-      expect(Object.keys(masterTest._getModules())[0]).toBe(module2IDTest);
-    });
-
-    test('remove a module by its key', () => {
-      masterTest.removeModule(module2KeyTest);
-
-      expect(Object.keys(masterTest._getModules()).length).toBe(1);
-      expect(Object.keys(masterTest._getModules())[0]).toBe(module1IDTest);
-    });
-
-    test('no removal if module is not found', () => {
-      masterTest.removeModule('unexisting-id');
-
-      expect(Object.keys(masterTest._getModules()).length).toBe(2);
-      expect(Object.keys(masterTest._getModules())[0]).toBe(module1IDTest);
-      expect(Object.keys(masterTest._getModules())[1]).toBe(module2IDTest);
-    });
-  });
-
-  describe('toString()', () => {
-    test('string output standard', () => {
-      const toStringMaster = masterTest.toString();
-      const expectedString = `Component ${KeyTest} - Type: Master - Managers: 0 - Actions: 0 - Modules: 0`;
-
-      expect(toStringMaster).toBe(expectedString);
-    });
-
-    test('string output standard with all components', () => {
-      masterTest.populate();
-
-      const toStringMaster = masterTest.toString();
-      const expectedString = `Component ${KeyTest} - Type: Master - Managers: 2 - Actions: 2 - Modules: 2`;
-
-      expect(toStringMaster).toBe(expectedString);
-    });
-
-    test('string output without actions and modules', () => {
-      masterTest = new DTMasterTest(IDTest, KeyTest, {
-        [manager1IDTest]: new DTManagerStub(),
-        [manager2IDTest]: new DTManagerStub(),
-      });
-
-      const toStringMaster = masterTest.toString();
-      const expectedString = `Component ${KeyTest} - Type: Master - Managers: 2 - Actions: 0 - Modules: 0`;
-
-      expect(toStringMaster).toBe(expectedString);
-    });
-  });
-
-  describe('toObject()', () => {
-
-    test('toObject output standard', () => {
-      const toObjectMaster = masterTest.toObject();
-
-      expect(Object.keys(toObjectMaster)).toStrictEqual(['id', 'key', 'type', 'managers', 'actions', 'modules']);
-      expect(toObjectMaster.id).toBe(IDTest);
-      expect(toObjectMaster.key).toBe(KeyTest);
-      expect(toObjectMaster.type).toBe('master');
-      expect(toObjectMaster.managers).toStrictEqual([]);
-      expect(toObjectMaster.actions).toStrictEqual([]);
-      expect(toObjectMaster.modules).toStrictEqual([]);
-    });
-
-    test('toObject output with managers', () => {
-      const manager1 = new DTManagerStub();
-      jest.spyOn(manager1, 'toObject').mockImplementation(() => manager1ToObject);
-      masterTest = new DTMasterTest(IDTest, KeyTest, {
-        [manager1IDTest]: manager1,
-      });
-
-      const toObjectMaster = masterTest.toObject();
-
-      expect(toObjectMaster.id).toBe(IDTest);
-      expect(toObjectMaster.key).toBe(KeyTest);
-      expect(toObjectMaster.type).toBe('master');
-      expect(toObjectMaster.managers).toStrictEqual([ manager1ToObject ]);
-      expect(toObjectMaster.actions).toStrictEqual([]);
-      expect(toObjectMaster.modules).toStrictEqual([]);
-    });
-
-    test('toObject output with managers, actions and modules', () => {
-      const manager1 = new DTManagerStub();
-      jest.spyOn(manager1, 'toObject').mockImplementation(() => manager1ToObject);
-      const action1 = new DTActionStub();
-      jest.spyOn(action1, 'toObject').mockImplementation(() => action1ToObject);
-      const module1 = new DTModuleStub();
-      jest.spyOn(module1, 'toObject').mockImplementation(() => module1ToObject);
-      masterTest = new DTMasterTest(IDTest, KeyTest, {
-        [manager1IDTest]: manager1,
-      }, {
-        [action1IDTest]: action1,
-      }, {
-        [module1IDTest]: module1,
-      });
-
-      const toObjectMaster = masterTest.toObject();
-
-      expect(toObjectMaster.id).toBe(IDTest);
-      expect(toObjectMaster.key).toBe(KeyTest);
-      expect(toObjectMaster.type).toBe('master');
-      expect(toObjectMaster.managers).toStrictEqual([ manager1ToObject ]);
-      expect(toObjectMaster.actions).toStrictEqual([ action1ToObject ]);
-      expect(toObjectMaster.modules).toStrictEqual([ module1ToObject ]);
-    });
-  });
-});