dyo-tools 0.3.2 → 0.4.0

package/test/core/DTMaster.spec.ts

@@ -1,58 +1,42 @@
 import {afterEach, beforeEach, describe, expect, jest, test} from "@jest/globals";
-import {DTAction, DTComponent, DTManager, DTMaster, DTModule} from "../../src";
+import {DTComponent, DTError, DTMaster} from "../../src";
 import {
   checkMasterActions,
-  checkMasterManagers, checkMasterModules,
+  checkMasterManagers,
+  checkMasterModules,
   DTMasterTest,
   IDTest,
-  KeyTest,
-  populateMaster
+  KeyTest
 } from "./DTMaster.double";
-import {mockOverriddenMethods} from "./DTComponent.double";
 import {
-  DTManagerStub, IDTest as IDManagerTest,
+  DTManagerStub,
   IDTest as manager1IDTest,
   manager1IDTest as manager2IDTest,
-  manager1KeyTest as manager2KeyTest, manager1ToObject
+  manager1KeyTest as manager2KeyTest,
+  manager1ToObject
 } from "./DTManager.double";
 import {
+  action1IDTest as action2IDTest,
+  action1KeyTest as action2KeyTest,
+  action1ToObject,
   DTActionStub,
   IDTest as action1IDTest,
-  KeyTest as action1KeyTest,
-  action1IDTest as action2IDTest,
-  action1KeyTest as action2KeyTest, action1ToObject
+  KeyTest as action1KeyTest
 } from "./DTAction.double";
 import {
   DTModuleStub,
   IDTest as module1IDTest,
-  KeyTest as module1KeyTest,
   module1IDTest as module2IDTest,
-  module1KeyTest as module2KeyTest, module1ToObject
+  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', () => {
+describe('class DTMaster', () => {
   let masterTest: DTMasterTest;
 
   beforeEach(() => {
     masterTest = new DTMasterTest();
-    masterTest.th_set_id(IDTest);
-    masterTest.th_set_key(KeyTest);
   });
 
   afterEach(() => {
@@ -67,7 +51,7 @@ describe('class DYOToolsMaster', () => {
 
   describe('_componentType', () => {
     test('componentType must be "master"', () => {
-      expect(masterTest.th_get_componentType()).toBe('master');
+      expect(masterTest.getComponentType()).toBe('master');
     });
   });
 
@@ -77,15 +61,11 @@ describe('class DYOToolsMaster', () => {
     });
 
     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);
+      const newMaster = new DTMasterTest(IDTest, KeyTest);
 
-      expect(newMaster.th_get_managers()).toStrictEqual({});
-      expect(newMaster.th_get_actions()).toStrictEqual({});
-      expect(newMaster.th_get_modules()).toStrictEqual({});
+      expect(newMaster._getManagers()).toStrictEqual({});
+      expect(newMaster._getActions()).toStrictEqual({});
+      expect(newMaster._getModules()).toStrictEqual({});
     });
 
   });
@@ -95,8 +75,6 @@ describe('class DYOToolsMaster', () => {
 
     beforeEach(() => {
       managerToAdd = new DTManagerStub();
-
-      jest.spyOn(masterTest, 'getId').mockReturnValue(IDTest);
     });
 
     test('add a new manager - standard case', () => {
@@ -106,64 +84,72 @@ describe('class DYOToolsMaster', () => {
     });
 
     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(),
-      );
+      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 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(),
-      );
+      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((managerToAdd.setContext as any).mock.calls.length).toBe(1);
-      expect((managerToAdd.setContext as any).mock.calls[0][0].th_get_id()).toBe(IDTest);
+      expect(setContextSpy.mock.calls.length).toBe(1);
+      expect(setContextSpy.mock.calls[0][0].getId()).toBe(IDTest);
     });
   });
 
   describe('getManager()', () => {
     beforeEach(() => {
-      populateMaster(masterTest);
+      masterTest.populate();
     });
 
     test('return a manager by its id', () => {
-      const manager = masterTest.getManager(manager1IDTest) as DTManagerStub;
+      const manager = masterTest.getManager(manager1IDTest);
 
       expect(manager).toBeDefined();
-      expect(manager.th_get_id()).toBe(manager1IDTest);
+      expect(manager.getId()).toBe(manager1IDTest);
     });
 
     test('return a manager by its key', () => {
-      const manager = masterTest.getManager(manager2KeyTest) as DTManagerStub;
+      const manager = masterTest.getManager(manager2KeyTest);
 
       expect(manager).toBeDefined();
-      expect(manager.th_get_id()).toBe(manager2IDTest);
+      expect(manager.getKey()).toBe(manager2KeyTest);
     });
 
     test('return undefined if manager is not found', () => {
@@ -175,40 +161,29 @@ describe('class DYOToolsMaster', () => {
 
   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];
-        }
-      });
+      masterTest.populate();
     });
 
     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);
+      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.th_get_managers()).length).toBe(1);
-      expect(Object.keys(masterTest.th_get_managers())[0]).toBe(manager1IDTest);
+      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.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);
+      expect(Object.keys(masterTest._getManagers()).length).toBe(2);
+      expect(Object.keys(masterTest._getManagers())[0]).toBe(manager1IDTest);
+      expect(Object.keys(masterTest._getManagers())[1]).toBe(manager2IDTest);
     });
   });
 
@@ -217,8 +192,6 @@ describe('class DYOToolsMaster', () => {
 
     beforeEach(() => {
       actionToAdd = new DTActionStub();
-
-      jest.spyOn(masterTest, 'getId').mockReturnValue(IDTest);
     });
 
     test('add a new action - standard case', () => {
@@ -228,64 +201,72 @@ describe('class DYOToolsMaster', () => {
     });
 
     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(),
-      );
+      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 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(),
-      );
+      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((actionToAdd.setContext as any).mock.calls.length).toBe(1);
-      expect((actionToAdd.setContext as any).mock.calls[0][0].th_get_id()).toBe(IDTest);
+      expect(setContextSpy.mock.calls.length).toBe(1);
+      expect(setContextSpy.mock.calls[0][0].getId()).toBe(IDTest);
     });
   });
 
   describe('getAction()', () => {
     beforeEach(() => {
-      populateMaster(masterTest);
+      masterTest.populate();
     });
 
     test('return an action by its id', () => {
-      const action = masterTest.getAction(action1IDTest) as DTActionStub;
+      const action = masterTest.getAction(action1IDTest);
 
       expect(action).toBeDefined();
-      expect(action.th_get_id()).toBe(action1IDTest);
+      expect(action.getId()).toBe(action1IDTest);
     });
 
     test('return an action by its key', () => {
-      const action = masterTest.getAction(action2KeyTest) as DTActionStub;
+      const action = masterTest.getAction(action2KeyTest);
 
       expect(action).toBeDefined();
-      expect(action.th_get_id()).toBe(action2IDTest);
+      expect(action.getId()).toBe(action2IDTest);
     });
 
     test('return undefined if action is not found', () => {
@@ -297,57 +278,35 @@ describe('class DYOToolsMaster', () => {
 
   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];
-        }
-      });
+      masterTest.populate();
     });
 
     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);
+      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.th_get_actions()).length).toBe(1);
-      expect(Object.keys(masterTest.th_get_actions())[0]).toBe(action1IDTest);
+      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.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);
+      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(() => {
-      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];
-        }
-      });
+      masterTest.populate();
     });
 
     test('call execute method with payload for action by its id', async () => {
@@ -377,8 +336,6 @@ describe('class DYOToolsMaster', () => {
 
     beforeEach(() => {
       moduleToAdd = new DTModuleStub();
-
-      jest.spyOn(masterTest, 'getId').mockReturnValue(IDTest);
     });
 
     test('add a new module - standard case', () => {
@@ -388,64 +345,72 @@ describe('class DYOToolsMaster', () => {
     });
 
     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(),
-      );
+      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 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(),
-      );
+      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((moduleToAdd.setContext as any).mock.calls.length).toBe(1);
-      expect((moduleToAdd.setContext as any).mock.calls[0][0].th_get_id()).toBe(IDTest);
+      expect(setContextSpy.mock.calls.length).toBe(1);
+      expect(setContextSpy.mock.calls[0][0].getId()).toBe(IDTest);
     });
   });
 
   describe('getModule()', () => {
     beforeEach(() => {
-      populateMaster(masterTest);
+      masterTest.populate();
     });
 
     test('return a module by its id', () => {
-      const module = masterTest.getModule(module1IDTest) as DTModuleStub;
+      const module = masterTest.getModule(module1IDTest);
 
       expect(module).toBeDefined();
-      expect(module.th_get_id()).toBe(module1IDTest);
+      expect(module.getId()).toBe(module1IDTest);
     });
 
     test('return a module by its key', () => {
-      const module = masterTest.getModule(module2KeyTest) as DTModuleStub;
+      const module = masterTest.getModule(module2KeyTest);
 
       expect(module).toBeDefined();
-      expect(module.th_get_id()).toBe(module2IDTest);
+      expect(module.getId()).toBe(module2IDTest);
     });
 
     test('return undefined if module is not found', () => {
@@ -457,48 +422,33 @@ describe('class DYOToolsMaster', () => {
 
   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];
-        }
-      });
+      masterTest.populate();
     });
 
     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);
+      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.th_get_modules()).length).toBe(1);
-      expect(Object.keys(masterTest.th_get_modules())[0]).toBe(module1IDTest);
+      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.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);
+      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()', () => {
-    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`;
@@ -507,7 +457,7 @@ describe('class DYOToolsMaster', () => {
     });
 
     test('string output standard with all components', () => {
-      populateMaster(masterTest);
+      masterTest.populate();
 
       const toStringMaster = masterTest.toString();
       const expectedString = `Component ${KeyTest} - Type: Master - Managers: 2 - Actions: 2 - Modules: 2`;
@@ -516,9 +466,10 @@ describe('class DYOToolsMaster', () => {
     });
 
     test('string output without actions and modules', () => {
-      populateMaster(masterTest);
-      masterTest.th_set_actions({});
-      masterTest.th_set_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`;
@@ -528,10 +479,6 @@ describe('class DYOToolsMaster', () => {
   });
 
   describe('toObject()', () => {
-    beforeEach(() => {
-      masterTest.th_set_id(IDTest);
-      masterTest.th_set_key(KeyTest);
-    });
 
     test('toObject output standard', () => {
       const toObjectMaster = masterTest.toObject();
@@ -548,7 +495,9 @@ describe('class DYOToolsMaster', () => {
     test('toObject output with managers', () => {
       const manager1 = new DTManagerStub();
       jest.spyOn(manager1, 'toObject').mockImplementation(() => manager1ToObject);
-      masterTest.th_set_managers({ [manager1IDTest]: manager1 });
+      masterTest = new DTMasterTest(IDTest, KeyTest, {
+        [manager1IDTest]: manager1,
+      });
 
       const toObjectMaster = masterTest.toObject();
 
@@ -563,13 +512,17 @@ describe('class DYOToolsMaster', () => {
     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 });
+      masterTest = new DTMasterTest(IDTest, KeyTest, {
+        [manager1IDTest]: manager1,
+      }, {
+        [action1IDTest]: action1,
+      }, {
+        [module1IDTest]: module1,
+      });
 
       const toObjectMaster = masterTest.toObject();