dyo-tools 0.1.0 → 0.3.0

package/test/core/DTMaster.spec.ts

@@ -0,0 +1,584 @@
+import {afterEach, beforeEach, describe, expect, jest, test} from "@jest/globals";
+import {DTAction, DTComponent, DTManager, DTMaster, DTModule} from "../../src";
+import {
+  checkMasterActions,
+  checkMasterManagers, checkMasterModules,
+  DTMasterTest,
+  IDTest,
+  KeyTest,
+  populateMaster
+} from "./DTMaster.double";
+import {mockOverriddenMethods} from "./DTComponent.double";
+import {
+  DTManagerStub, IDTest as IDManagerTest,
+  IDTest as manager1IDTest,
+  manager1IDTest as manager2IDTest,
+  manager1KeyTest as manager2KeyTest, manager1ToObject
+} from "./DTManager.double";
+import {
+  DTActionStub,
+  IDTest as action1IDTest,
+  KeyTest as action1KeyTest,
+  action1IDTest as action2IDTest,
+  action1KeyTest as action2KeyTest, action1ToObject
+} from "./DTAction.double";
+import {
+  DTModuleStub,
+  IDTest as module1IDTest,
+  KeyTest as module1KeyTest,
+  module1IDTest as module2IDTest,
+  module1KeyTest as module2KeyTest, module1ToObject
+} from "./DTModule.double";
+import DYOToolsError from "../../src/core/DTError";
+import {checkCallForMockedDTError} from "./DTError.double";
+import MockedFunction = jest.MockedFunction;
+import {DTBunchStubLibrary} from "./DTBunch.double";
+
+/** ****************** MOCK DEPENDENCIES
+ * Dependencies used by the component are mocked with Jest
+ * **** */
+jest.mock('../../src/core/DTManager');
+jest.mock('../../src/core/DTAction');
+jest.mock('../../src/core/DTModule');
+jest.mock('../../src/core/DTComponent');
+jest.mock('../../src/core/DTError');
+// Add specific mock for inherited methods to have a basic implementation
+mockOverriddenMethods(DTComponent);
+
+/** *********************** TESTS SUITES ****************************** */
+describe('class DYOToolsMaster', () => {
+  let masterTest: DTMasterTest;
+
+  beforeEach(() => {
+    masterTest = new DTMasterTest();
+    masterTest.th_set_id(IDTest);
+    masterTest.th_set_key(KeyTest);
+  });
+
+  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.th_get_componentType()).toBe('master');
+    });
+  });
+
+  describe('constructor()', () => {
+    beforeEach(() => {
+      jest.resetAllMocks();
+    });
+
+    test('simple creation with key', () => {
+      const newMaster = new DTMasterTest(KeyTest);
+      const parentConstructorMock = (DTComponent.prototype.constructor as MockedFunction<(key: string, options: any) => void>).mock;
+
+      expect(parentConstructorMock.calls.length).toBe(1);
+      expect(parentConstructorMock.calls[0][0]).toBe(KeyTest);
+
+      expect(newMaster.th_get_managers()).toStrictEqual({});
+      expect(newMaster.th_get_actions()).toStrictEqual({});
+      expect(newMaster.th_get_modules()).toStrictEqual({});
+    });
+
+  });
+
+  describe('addManager()', () => {
+    let managerToAdd: DTManagerStub;
+
+    beforeEach(() => {
+      managerToAdd = new DTManagerStub();
+
+      jest.spyOn(masterTest, 'getId').mockReturnValue(IDTest);
+    });
+
+    test('add a new manager - standard case', () => {
+      masterTest.addManager(managerToAdd);
+
+      checkMasterManagers(masterTest, [manager1IDTest]);
+    });
+
+    test('trigger error when adding two managers with same id', () => {
+      const mockedTriggerError: MockedFunction<(error: DYOToolsError) => void> = DTMaster.prototype.triggerError as MockedFunction<(error: DYOToolsError) => void>;
+
+      masterTest.addManager(managerToAdd);
+      masterTest.addManager(managerToAdd);
+
+      expect(Object.keys(masterTest.th_get_managers()).length).toBe(1);
+      expect(mockedTriggerError.mock.calls.length).toBe(1);
+      checkCallForMockedDTError(
+        'id_conflict',
+        'Manager with same id already exists in the Master instance',
+        IDTest,
+        managerToAdd.getId(),
+      );
+    });
+
+    test('trigger error when adding two managers with same key', () => {
+      const mockedTriggerError: MockedFunction<(error: DYOToolsError) => void> = DTMaster.prototype.triggerError as MockedFunction<(error: DYOToolsError) => void>;
+      const managerToAdd2 = new DTManagerStub();
+      jest.spyOn(managerToAdd2, 'getId').mockReturnValue(manager2IDTest);
+
+      masterTest.addManager(managerToAdd);
+      masterTest.addManager(managerToAdd2);
+
+      expect(Object.keys(masterTest.th_get_managers()).length).toBe(1);
+      expect(mockedTriggerError.mock.calls.length).toBe(1);
+      checkCallForMockedDTError(
+        'key_conflict',
+        'Manager with same key already exists in the Master instance',
+        IDTest,
+        managerToAdd2.getId(),
+      );
+    });
+
+    test('set context when adding a new manager', () => {
+      masterTest.addManager(managerToAdd);
+
+      expect((managerToAdd.setContext as any).mock.calls.length).toBe(1);
+      expect((managerToAdd.setContext as any).mock.calls[0][0].th_get_id()).toBe(IDTest);
+    });
+  });
+
+  describe('getManager()', () => {
+    beforeEach(() => {
+      populateMaster(masterTest);
+    });
+
+    test('return a manager by its id', () => {
+      const manager = masterTest.getManager(manager1IDTest) as DTManagerStub;
+
+      expect(manager).toBeDefined();
+      expect(manager.th_get_id()).toBe(manager1IDTest);
+    });
+
+    test('return a manager by its key', () => {
+      const manager = masterTest.getManager(manager2KeyTest) as DTManagerStub;
+
+      expect(manager).toBeDefined();
+      expect(manager.th_get_id()).toBe(manager2IDTest);
+    });
+
+    test('return undefined if manager is not found', () => {
+      const manager = masterTest.getManager('unexisting-id');
+
+      expect(manager).toBeUndefined();
+    });
+  });
+
+  describe('removeManager()', () => {
+    beforeEach(() => {
+      populateMaster(masterTest);
+
+      const managers = masterTest.th_get_managers();
+      jest.spyOn(masterTest, 'getManager').mockImplementation(function(idOrKey: string): DTManager<any> | undefined {
+        if (idOrKey === manager2KeyTest) {
+          return managers[manager2IDTest];
+        } else if (idOrKey === 'unexisting-id') {
+          return undefined;
+        } else {
+          return managers[manager1IDTest];
+        }
+      });
+    });
+
+    test('remove a manager by its id', () => {
+      masterTest.removeManager(manager1IDTest);
+
+      expect(Object.keys(masterTest.th_get_managers()).length).toBe(1);
+      expect(Object.keys(masterTest.th_get_managers())[0]).toBe(manager2IDTest);
+    });
+
+    test('remove a manager by its key', () => {
+      masterTest.removeManager(manager2KeyTest);
+
+      expect(Object.keys(masterTest.th_get_managers()).length).toBe(1);
+      expect(Object.keys(masterTest.th_get_managers())[0]).toBe(manager1IDTest);
+    });
+
+    test('no removal if manager is not found', () => {
+      masterTest.removeManager('unexisting-id');
+
+      expect(Object.keys(masterTest.th_get_managers()).length).toBe(2);
+      expect(Object.keys(masterTest.th_get_managers())[0]).toBe(manager1IDTest);
+      expect(Object.keys(masterTest.th_get_managers())[1]).toBe(manager2IDTest);
+    });
+  });
+
+  describe('addAction()', () => {
+    let actionToAdd: DTActionStub;
+
+    beforeEach(() => {
+      actionToAdd = new DTActionStub();
+
+      jest.spyOn(masterTest, 'getId').mockReturnValue(IDTest);
+    });
+
+    test('add a new action - standard case', () => {
+      masterTest.addAction(actionToAdd);
+
+      checkMasterActions(masterTest, [action1IDTest]);
+    });
+
+    test('trigger error when adding two actions with same id', () => {
+      const mockedTriggerError: MockedFunction<(error: DYOToolsError) => void> = DTMaster.prototype.triggerError as MockedFunction<(error: DYOToolsError) => void>;
+
+      masterTest.addAction(actionToAdd);
+      masterTest.addAction(actionToAdd);
+
+      expect(Object.keys(masterTest.th_get_actions()).length).toBe(1);
+      expect(mockedTriggerError.mock.calls.length).toBe(1);
+      checkCallForMockedDTError(
+          'id_conflict',
+          'Action with same id already exists in the Master instance',
+          IDTest,
+          actionToAdd.getId(),
+      );
+    });
+
+    test('trigger error when adding two actions with same key', () => {
+      const mockedTriggerError: MockedFunction<(error: DYOToolsError) => void> = DTMaster.prototype.triggerError as MockedFunction<(error: DYOToolsError) => void>;
+      const actionToAdd2 = new DTActionStub();
+      jest.spyOn(actionToAdd2, 'getId').mockReturnValue(action2IDTest);
+
+      masterTest.addAction(actionToAdd);
+      masterTest.addAction(actionToAdd2);
+
+      expect(Object.keys(masterTest.th_get_actions()).length).toBe(1);
+      expect(mockedTriggerError.mock.calls.length).toBe(1);
+      checkCallForMockedDTError(
+          'key_conflict',
+          'Action with same key already exists in the Master instance',
+          IDTest,
+          actionToAdd2.getId(),
+      );
+    });
+
+    test('set context when adding a new action', () => {
+      masterTest.addAction(actionToAdd);
+
+      expect((actionToAdd.setContext as any).mock.calls.length).toBe(1);
+      expect((actionToAdd.setContext as any).mock.calls[0][0].th_get_id()).toBe(IDTest);
+    });
+  });
+
+  describe('getAction()', () => {
+    beforeEach(() => {
+      populateMaster(masterTest);
+    });
+
+    test('return an action by its id', () => {
+      const action = masterTest.getAction(action1IDTest) as DTActionStub;
+
+      expect(action).toBeDefined();
+      expect(action.th_get_id()).toBe(action1IDTest);
+    });
+
+    test('return an action by its key', () => {
+      const action = masterTest.getAction(action2KeyTest) as DTActionStub;
+
+      expect(action).toBeDefined();
+      expect(action.th_get_id()).toBe(action2IDTest);
+    });
+
+    test('return undefined if action is not found', () => {
+      const action = masterTest.getAction('unexisting-id');
+
+      expect(action).toBeUndefined();
+    });
+  });
+
+  describe('removeAction()', () => {
+    beforeEach(() => {
+      populateMaster(masterTest);
+
+      const actions = masterTest.th_get_actions();
+      jest.spyOn(masterTest, 'getAction').mockImplementation(function(idOrKey: string): DTAction | undefined {
+        if (idOrKey === action2KeyTest) {
+          return actions[action2IDTest];
+        } else if (idOrKey === 'unexisting-id') {
+          return undefined;
+        } else {
+          return actions[action1IDTest];
+        }
+      });
+    });
+
+    test('remove an action by its id', () => {
+      masterTest.removeAction(action1IDTest);
+
+      expect(Object.keys(masterTest.th_get_actions()).length).toBe(1);
+      expect(Object.keys(masterTest.th_get_actions())[0]).toBe(action2IDTest);
+    });
+
+    test('remove an action by its key', () => {
+      masterTest.removeAction(action2KeyTest);
+
+      expect(Object.keys(masterTest.th_get_actions()).length).toBe(1);
+      expect(Object.keys(masterTest.th_get_actions())[0]).toBe(action1IDTest);
+    });
+
+    test('no removal if action is not found', () => {
+      masterTest.removeAction('unexisting-id');
+
+      expect(Object.keys(masterTest.th_get_actions()).length).toBe(2);
+      expect(Object.keys(masterTest.th_get_actions())[0]).toBe(action1IDTest);
+      expect(Object.keys(masterTest.th_get_actions())[1]).toBe(action2IDTest);
+    });
+  });
+
+  describe('executeAction()', () => {
+    beforeEach(() => {
+      populateMaster(masterTest);
+      const actions = masterTest.th_get_actions();
+
+      jest.spyOn(masterTest, 'getAction').mockImplementation(function(idOrKey: string): DTAction | undefined {
+        if (idOrKey === action2KeyTest) {
+          return actions[action2IDTest];
+        } else if (idOrKey === 'unexisting-id') {
+          return undefined;
+        } else {
+          return actions[action1IDTest];
+        }
+      });
+    });
+
+    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();
+
+      jest.spyOn(masterTest, 'getId').mockReturnValue(IDTest);
+    });
+
+    test('add a new module - standard case', () => {
+      masterTest.addModule(moduleToAdd);
+
+      checkMasterModules(masterTest, [module1IDTest]);
+    });
+
+    test('trigger error when adding two modules with same id', () => {
+      const mockedTriggerError: MockedFunction<(error: DYOToolsError) => void> = DTMaster.prototype.triggerError as MockedFunction<(error: DYOToolsError) => void>;
+
+      masterTest.addModule(moduleToAdd);
+      masterTest.addModule(moduleToAdd);
+
+      expect(Object.keys(masterTest.th_get_modules()).length).toBe(1);
+      expect(mockedTriggerError.mock.calls.length).toBe(1);
+      checkCallForMockedDTError(
+          'id_conflict',
+          'Module with same id already exists in the Master instance',
+          IDTest,
+          moduleToAdd.getId(),
+      );
+    });
+
+    test('trigger error when adding two modules with same key', () => {
+      const mockedTriggerError: MockedFunction<(error: DYOToolsError) => void> = DTMaster.prototype.triggerError as MockedFunction<(error: DYOToolsError) => void>;
+      const moduleToAdd2 = new DTModuleStub();
+      jest.spyOn(moduleToAdd2, 'getId').mockReturnValue(module2IDTest);
+
+      masterTest.addModule(moduleToAdd);
+      masterTest.addModule(moduleToAdd2);
+
+      expect(Object.keys(masterTest.th_get_modules()).length).toBe(1);
+      expect(mockedTriggerError.mock.calls.length).toBe(1);
+      checkCallForMockedDTError(
+          'key_conflict',
+          'Module with same key already exists in the Master instance',
+          IDTest,
+          moduleToAdd2.getId(),
+      );
+    });
+
+    test('set context when adding a new module', () => {
+      masterTest.addModule(moduleToAdd);
+
+      expect((moduleToAdd.setContext as any).mock.calls.length).toBe(1);
+      expect((moduleToAdd.setContext as any).mock.calls[0][0].th_get_id()).toBe(IDTest);
+    });
+  });
+
+  describe('getModule()', () => {
+    beforeEach(() => {
+      populateMaster(masterTest);
+    });
+
+    test('return a module by its id', () => {
+      const module = masterTest.getModule(module1IDTest) as DTModuleStub;
+
+      expect(module).toBeDefined();
+      expect(module.th_get_id()).toBe(module1IDTest);
+    });
+
+    test('return a module by its key', () => {
+      const module = masterTest.getModule(module2KeyTest) as DTModuleStub;
+
+      expect(module).toBeDefined();
+      expect(module.th_get_id()).toBe(module2IDTest);
+    });
+
+    test('return undefined if module is not found', () => {
+      const module = masterTest.getModule('unexisting-id');
+
+      expect(module).toBeUndefined();
+    });
+  });
+
+  describe('removeModule()', () => {
+    beforeEach(() => {
+      populateMaster(masterTest);
+
+      const modules = masterTest.th_get_modules();
+      jest.spyOn(masterTest, 'getModule').mockImplementation(function(idOrKey: string): DTModule | undefined {
+        if (idOrKey === module2KeyTest) {
+          return modules[module2IDTest];
+        } else if (idOrKey === 'unexisting-id') {
+          return undefined;
+        } else {
+          return modules[module1IDTest];
+        }
+      });
+    });
+
+    test('remove a module by its id', () => {
+      masterTest.removeModule(module1IDTest);
+
+      expect(Object.keys(masterTest.th_get_modules()).length).toBe(1);
+      expect(Object.keys(masterTest.th_get_modules())[0]).toBe(module2IDTest);
+    });
+
+    test('remove a module by its key', () => {
+      masterTest.removeModule(module2KeyTest);
+
+      expect(Object.keys(masterTest.th_get_modules()).length).toBe(1);
+      expect(Object.keys(masterTest.th_get_modules())[0]).toBe(module1IDTest);
+    });
+
+    test('no removal if module is not found', () => {
+      masterTest.removeModule('unexisting-id');
+
+      expect(Object.keys(masterTest.th_get_modules()).length).toBe(2);
+      expect(Object.keys(masterTest.th_get_modules())[0]).toBe(module1IDTest);
+      expect(Object.keys(masterTest.th_get_modules())[1]).toBe(module2IDTest);
+    });
+  });
+
+  describe('toString()', () => {
+    beforeEach(() => {
+      masterTest.th_set_key(KeyTest);
+    });
+
+    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', () => {
+      populateMaster(masterTest);
+
+      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', () => {
+      populateMaster(masterTest);
+      masterTest.th_set_actions({});
+      masterTest.th_set_modules({});
+
+      const toStringMaster = masterTest.toString();
+      const expectedString = `Component ${KeyTest} - Type: Master - Managers: 2 - Actions: 0 - Modules: 0`;
+
+      expect(toStringMaster).toBe(expectedString);
+    });
+  });
+
+  describe('toObject()', () => {
+    beforeEach(() => {
+      masterTest.th_set_id(IDTest);
+      masterTest.th_set_key(KeyTest);
+    });
+
+    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.th_set_managers({ [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);
+      masterTest.th_set_managers({ [manager1IDTest]: manager1 });
+      const action1 = new DTActionStub();
+      jest.spyOn(action1, 'toObject').mockImplementation(() => action1ToObject);
+      masterTest.th_set_actions({ [action1IDTest]: action1 });
+      const module1 = new DTModuleStub();
+      jest.spyOn(module1, 'toObject').mockImplementation(() => module1ToObject);
+      masterTest.th_set_modules({ [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 ]);
+    });
+  });
+});

package/test/core/DTModule.double.ts

@@ -0,0 +1,80 @@
+import {DTAction, DTModule} from "../../src";
+import {HaileiToObjectTest} from "./DTElement.double";
+import {bunch1IdTest} from "./DTBunch.double";
+import {DTModuleToObject} from "../../src/types";
+
+/** ****************** STUB PROPERTIES CONSTANTS
+ * Fixed properties to use with double classes, avoid auto generated and easy checking on test
+ * **** */
+export const IDTest = 'DTModule-id-1234567';
+export const KeyTest = 'DTModule-key-1234567';
+
+// Specific Module constants
+export const module1IDTest = `${IDTest}_1`;
+export const module1KeyTest = `${KeyTest}_1`;
+
+export const module1ToObject: DTModuleToObject = {
+  id: module1IDTest,
+  key: module1KeyTest,
+  type: 'module',
+  enabled: true
+};
+
+/** ****************** 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 DTModuleTest extends DTModule {
+  th_get_id(): string {
+    return this._id;
+  }
+
+  th_set_id(id: string): void {
+    this._id = id;
+  }
+
+  th_get_key(): string {
+    return this._key;
+  }
+
+  th_set_key(key: string): void {
+    this._key = key;
+  }
+
+  th_get_componentType(): string {
+    return this._componentType;
+  }
+
+  th_get_enabled(): boolean {
+    return this._enabled;
+  }
+
+  th_set_enabled(enabled: boolean): void {
+    this._enabled = enabled;
+  }
+}
+
+
+/** ****************** STUB CLASS
+ * Stub class, for using in other component
+ * **** */
+export class DTModuleStub extends DTModuleTest {
+  constructor() {
+    super();
+    this._id = IDTest;
+    this._key = KeyTest;
+    this._errors = [];
+  }
+
+  getId(): string {
+    return IDTest;
+  }
+
+  getKey(): string {
+    return KeyTest;
+  }
+}
+
+/** ****************** HELPER METHODS
+ * Additional helper methods to use with testing
+ * **** */