dyo-tools 0.3.2 → 0.4.0

package/test/core/DTManager.spec.ts

@@ -2,51 +2,34 @@ import {afterEach, beforeEach, describe, expect, jest, test,} from '@jest/global
 import {
   checkManagerItem,
   DomainTest,
-  DTManagerStubDomain,
   DTManagerTest,
+  DTManagerTestDomain,
   IDTest,
   KeyTest,
-  populateManager,
   ScopesTest,
 } from './DTManager.double';
-import DTManager from '../../src/core/DTManager';
 import {
-  bunch1IdTest,
   bunch1toObjectTest,
-  bunch2IdTest,
   bunch2toObjectTest,
   bunch3toObjectTest,
   DTBunchStub,
   DTBunchStubLibrary,
-  DTBunchTest,
-  generateMockedElements,
+  generateStubElements,
   IDTest as IDTestBunch,
   IDTestLibrary,
   KeyTest as KeyTestBunch,
 } from './DTBunch.double';
-import {mockOverriddenMethods} from './DTComponent.double';
-import {DTComponent, DTComponentPhysical, DTElement} from '../../src';
-import DYOToolsError from '../../src/core/DTError';
-import {checkCallForMockedDTError, DTErrorStub} from './DTError.double';
-import {BunchMetaData, IMetaDataTest} from './DTComponentWithMeta.double';
-import {componentManagerDefaultFinderConfiguration, managerDefaultOptions} from '../../src/constants';
+import {DTBunch, DTComponent, DTError, DTManager} from '../../src';
+import {DTErrorStub} from './DTError.double';
+import {BunchMetaData} from './DTComponentWithMeta.double';
+import {bunchDefaultOptions} from '../../src/constants';
 import {FilterOperatorType} from '../../src/types';
 import {OwnerTest} from './DTComponentPhysical.double';
+import {DTElementStub} from "./DTElement.double";
 import MockedFunction = jest.MockedFunction;
 
-/** ****************** MOCK DEPENDENCIES
- * Dependencies used by the component are mocked with Jest
- * **** */
-jest.mock('../../src/core/DTElement');
-jest.mock('../../src/core/DTBunch');
-jest.mock('../../src/core/DTComponent');
-jest.mock('../../src/core/DTError');
-jest.mock('../../src/libs/DYOFinder');
-// Add specific mock for inherited methods to have a basic implementation
-mockOverriddenMethods(DTComponent);
-
 /** *********************** TESTS SUITES ****************************** */
-describe('class DYOToolsManager', () => {
+describe('class DTManager', () => {
   let managerTest: DTManagerTest;
 
   beforeEach(() => {
@@ -65,7 +48,7 @@ describe('class DYOToolsManager', () => {
 
   describe('_componentType', () => {
     test('componentType must be "manager"', () => {
-      expect(managerTest.th_get_componentType()).toBe('manager');
+      expect(managerTest.getComponentType()).toBe('manager');
     });
   });
 
@@ -75,94 +58,52 @@ describe('class DYOToolsManager', () => {
     });
 
     test('creation simple with key', () => {
-      const newManager = new DTManagerTest(KeyTest);
-      const parentConstructorMock = (DTComponentPhysical.prototype.constructor as MockedFunction<(key: string, options: any) => void>).mock;
-
-      expect(parentConstructorMock.calls.length).toBe(1);
-      expect(parentConstructorMock.calls[0][0]).toBe(KeyTest);
-      expect(parentConstructorMock.calls[0][1]).toStrictEqual(managerDefaultOptions);
+      const newManager = new DTManagerTest(IDTest, KeyTest, [], [], {}, false);
 
-      expect(newManager.th_get_items()).toStrictEqual({});
-      expect(newManager.th_get_scopes()).toStrictEqual(['default', 'virtual']);
+      expect(newManager._getItems()).toStrictEqual({});
+      expect(newManager.getScopes()).toStrictEqual(['default', 'virtual']);
 
       // Library tests
-      expect(newManager.th_get_library().constructor.mock.calls.length).toBe(1);
-      expect(newManager.th_get_library().constructor.mock.calls[0][0]).toBe('library');
-      expect(newManager.th_get_library().constructor.mock.calls[0][1]).toStrictEqual([]);
-      expect(newManager.th_get_library().constructor.mock.calls[0][2].virtualContainer).toBe(true);
-      expect(newManager.th_get_library().setContext.mock.calls.length).toBe(1);
-      expect(newManager.th_get_library().setContext.mock.calls[0][0]).toStrictEqual(newManager);
-
-      // Finder initialization
-      expect((newManager.th_get_finder() as any).constructor.mock.calls.length).toBe(1);
-      expect((newManager.th_get_finder() as any).constructor.mock.calls[0][0]).toStrictEqual(newManager);
-      expect((newManager.th_get_finder() as any).constructor.mock.calls[0][1]).toStrictEqual(componentManagerDefaultFinderConfiguration);
-    });
-
-    test('creation simple without key - use domain if defined', () => {
-      // Warning : this method doesn't really work because of Javascript
-      // The property _domain set is only available after constructing (not during)
-
-      const newManager = new DTManager();
-      const newManagerWithDomain = new DTManagerStubDomain();
-      const newManagerWithDomain2 = new DTManagerStubDomain(null);
-
-      jest.spyOn(newManager, 'getKey').mockImplementation(function () {
-        return this._key;
-      });
-      jest.spyOn(newManagerWithDomain, 'getKey').mockImplementation(function () {
-        return this._key;
-      });
-      jest.spyOn(newManagerWithDomain2, 'getKey').mockImplementation(function () {
-        return this._key;
+      const library = newManager.getLibrary();
+      expect(library).toBeDefined();
+      expect(library.getKey()).toBe('library');
+      expect(library.getAll()).toStrictEqual([]);
+      expect(library.getOptions()).toStrictEqual({
+        ...bunchDefaultOptions,
+        virtualContainer: true,
       });
-
-      expect(newManager.getKey() === DomainTest).toBe(false);
-      expect(newManagerWithDomain.getKey() === DomainTest).toStrictEqual(true);
-      expect(newManagerWithDomain2.getKey() === DomainTest).toStrictEqual(true);
+      expect(library.getContext()).toStrictEqual(newManager);
     });
 
-    test('creation with elements for library', () => {
-      const mockedElements = generateMockedElements(5);
-      const newManager = new DTManagerTest(KeyTest, mockedElements);
+    // test('creation simple without key - use domain if defined', () => {
+    //   const newManager = new DTManagerTest();
+    //   const newManagerWithDomain = new DTManagerTestDomain();
+    //   const newManagerWithDomain2 = new DTManagerTestDomain(IDTest, undefined);
+    //
+    //   expect(newManager.getKey() === DomainTest).toBe(false);
+    //   expect(newManagerWithDomain.getKey() === DomainTest).toStrictEqual(true);
+    //   expect(newManagerWithDomain2.getKey() === DomainTest).toStrictEqual(true);
+    // });
 
-      expect(newManager.th_get_items()).toStrictEqual({});
-      expect(newManager.th_get_scopes()).toStrictEqual(['default', 'virtual']);
+    test('creation with elements for library', () => {
+      const elements = generateStubElements(5);
+      const newManager = new DTManagerTest(IDTest, KeyTest, elements);
 
       // Library tests
-      expect(newManager.th_get_library().constructor.mock.calls.length).toBe(1);
-      expect(newManager.th_get_library().constructor.mock.calls[0][0]).toBe('library');
-      expect(newManager.th_get_library().constructor.mock.calls[0][1].length).toStrictEqual(5);
-      expect(newManager.th_get_library().constructor.mock.calls[0][1].map((item) => item.getId()))
-        .toStrictEqual(mockedElements.map((item) => item.getId()));
-      expect(newManager.th_get_library().constructor.mock.calls[0][2].virtualContainer).toBe(true);
-      expect(newManager.th_get_library().setContext.mock.calls.length).toBe(1);
-      expect(newManager.th_get_library().setContext.mock.calls[0][0]).toStrictEqual(newManager);
+      const library = newManager.getLibrary();
+      expect(library).toBeDefined();
+      expect(library.getAll()).toStrictEqual(elements);
     });
 
     test('creation with extended scopes', () => {
-      const mockedElements = generateMockedElements(5);
-      const newManager = new DTManagerTest(null, mockedElements, ScopesTest);
+      const newManager = new DTManagerTest(IDTest, KeyTest, [], ScopesTest);
 
-      expect(newManager.th_get_items()).toStrictEqual({});
-      expect(newManager.th_get_scopes()).toStrictEqual([
+      expect(newManager.getScopes()).toStrictEqual([
         'default',
         'virtual',
         ...ScopesTest,
       ]);
     });
-
-    test('creation with specific options', () => {
-      const mockedElements = generateMockedElements(5);
-      const options = { errors: true, libraryDeletion: true };
-      const parentConstructorMock = (DTComponentPhysical.prototype.constructor as MockedFunction<(key: string, options: any) => void>).mock;
-
-      const newManager = new DTManagerTest(null, mockedElements, ScopesTest, options);
-
-      expect(parentConstructorMock.calls.length).toBe(1);
-      expect(parentConstructorMock.calls[0][0]).toBe(null);
-      expect(parentConstructorMock.calls[0][1]).toStrictEqual(options);
-    });
   });
 
   describe('getFinderConfiguration()', () => {
@@ -243,34 +184,38 @@ describe('class DYOToolsManager', () => {
 
   describe('getLibrary()', () => {
     test('return current manager Library', () => {
-      managerTest.th_set_library(new DTBunchStubLibrary());
-
       const library: DTBunchStubLibrary = managerTest.getLibrary() as DTBunchStubLibrary;
-      expect(library).toBeTruthy();
+
+      expect(library).toBeDefined();
       expect(library.getId()).toBe(IDTestLibrary);
     });
   });
 
   describe('getScopes()', () => {
     test('return manager scopes', () => {
-      managerTest.th_set_scopes(ScopesTest);
+      managerTest = new DTManagerTest(IDTest, KeyTest, [], ScopesTest)
 
-      expect(managerTest.getScopes()).toStrictEqual(ScopesTest);
+      expect(managerTest.getScopes()).toStrictEqual([
+        'default',
+        'virtual',
+        ...ScopesTest,
+      ]);
     });
   });
 
   describe('getMaster()', () => {
     test('call get context with master accessor', () => {
+      const contextSpy = jest.spyOn(managerTest, 'getContext');
       managerTest.getMaster();
 
-      expect((managerTest.getContext as any).mock.calls.length).toBe(1);
-      expect((managerTest.getContext as any).mock.calls[0][0]).toBe('master');
+      expect(contextSpy.mock.calls.length).toBe(1);
+      expect(contextSpy.mock.calls[0][0]).toBe('master');
     });
   });
 
   describe('isValidScope()', () => {
     beforeEach(() => {
-      managerTest.th_set_scopes(ScopesTest);
+      managerTest = new DTManagerTest(IDTest, KeyTest, [], ScopesTest);
     });
 
     test('return true if scope exists', () => {
@@ -283,223 +228,191 @@ describe('class DYOToolsManager', () => {
   });
 
   describe('add()', () => {
-    let bunchToAdd: DTBunchStub;
+    let bunchToAdd: DTBunch<DTElementStub>;
 
     beforeEach(() => {
-      jest.spyOn(managerTest, 'getId').mockReturnValue(IDTest);
-      jest.spyOn(managerTest, 'isValidScope').mockReturnValue(true);
-
-      // Bunch to add
-      bunchToAdd = new DTBunchStub();
-      jest.spyOn(bunchToAdd, 'getAll').mockImplementation(function () {
-        return this._items;
-      });
-      jest.spyOn(bunchToAdd, 'getOptions').mockImplementation(function () {
-        return this._options;
-      });
-      jest.spyOn(bunchToAdd, 'getContext').mockImplementation(function () {
-        return this._context;
-      });
-
-      // Add tests scopes
-      managerTest.th_set_scopes([...managerTest.th_get_scopes(), ...ScopesTest]);
+      managerTest = new DTManagerTest(IDTest, KeyTest, [], ScopesTest);
+      bunchToAdd = new DTBunchStub() as DTBunch<DTElementStub>;
     });
 
     test('add a new item - empty bunch in default scope', () => {
       managerTest.add(bunchToAdd);
 
-      expect(Object.keys(managerTest.th_get_items()).length).toBe(1);
+      expect(Object.keys(managerTest._getItems()).length).toBe(1);
       checkManagerItem(managerTest, IDTestBunch, 'default');
     });
 
     test('add a new item - empty bunch in specific scope', () => {
       managerTest.add(bunchToAdd, ScopesTest[0]);
 
-      expect(Object.keys(managerTest.th_get_items()).length).toBe(1);
+      expect(Object.keys(managerTest._getItems()).length).toBe(1);
       checkManagerItem(managerTest, IDTestBunch, ScopesTest[0]);
     });
 
     test('add a new item - virtual bunch in virtual scope', () => {
-      bunchToAdd.th_set_options({ virtualContainer: true });
+      bunchToAdd = new DTBunchStub([], { virtualContainer: true }) as DTBunch<DTElementStub>;
 
       managerTest.add(bunchToAdd);
 
-      expect(Object.keys(managerTest.th_get_items()).length).toBe(1);
+      expect(Object.keys(managerTest._getItems()).length).toBe(1);
       checkManagerItem(managerTest, IDTestBunch, 'virtual');
     });
 
     test('trigger error if not existing scope for bunch', () => {
       const errorScope = 'not-existing-scope';
-      const mockedTriggerError = DTManager.prototype.triggerError as MockedFunction<(error: DYOToolsError) => void>;
-      jest.spyOn(managerTest, 'isValidScope').mockReturnValue(false);
-
-      managerTest.add(bunchToAdd, errorScope);
+      let errorThrown: DTError | undefined;
+      try {
+        managerTest.add(bunchToAdd, errorScope);
+      } catch(error) {
+        errorThrown = error;
+      }
 
-      expect(Object.keys(managerTest.th_get_items()).length).toBe(0);
-      expect((managerTest.isValidScope as any).mock.calls.length).toBe(1);
-      expect((managerTest.isValidScope as any).mock.calls[0][0]).toBe(errorScope);
-      expect(mockedTriggerError.mock.calls.length).toBe(1);
-      checkCallForMockedDTError(
-        'invalid_scope',
-        "Scope provided doesn't exist in the manager",
-        IDTest,
-        bunchToAdd.getId(),
-      );
+      expect(errorThrown).toBeDefined();
+      expect(Object.keys(managerTest._getItems()).length).toBe(0);
+      if (errorThrown) {
+        expect(errorThrown.getCode()).toBe('invalid_scope');
+        expect(errorThrown.getMessage()).toBe('Scope provided doesn\'t exist in the manager');
+        expect(errorThrown.getInitiator().getId()).toBe(IDTest);
+        expect(errorThrown.getConvicted().getId()).toBe(bunchToAdd.getId());
+      }
     });
 
     test('trigger error if invalid scope for virtual bunch', () => {
-      bunchToAdd.th_set_options({ virtualContainer: true });
-      const mockedTriggerError = DTManager.prototype.triggerError as MockedFunction<(error: DYOToolsError) => void>;
-
-      managerTest.add(bunchToAdd, ScopesTest[0]);
+      bunchToAdd = new DTBunchStub([], { virtualContainer: true }) as DTBunch<DTElementStub>;
+      let errorThrown: DTError | undefined;
+      try {
+        managerTest.add(bunchToAdd, ScopesTest[0]);
+      } catch(error) {
+        errorThrown = error;
+      }
 
-      expect(Object.keys(managerTest.th_get_items()).length).toBe(0);
-      expect(mockedTriggerError.mock.calls.length).toBe(1);
-      checkCallForMockedDTError(
-        'forbidden_scope',
-        'Scope provided cannot be associated to a virtual bunch',
-        IDTest,
-        bunchToAdd.getId(),
-      );
+      expect(errorThrown).toBeDefined();
+      expect(Object.keys(managerTest._getItems()).length).toBe(0);
+      if (errorThrown) {
+        expect(errorThrown.getCode()).toBe('forbidden_scope');
+        expect(errorThrown.getMessage()).toBe('Scope provided cannot be associated to a virtual bunch');
+        expect(errorThrown.getInitiator().getId()).toBe(IDTest);
+        expect(errorThrown.getConvicted().getId()).toBe(bunchToAdd.getId());
+      }
     });
 
     test('trigger error if invalid virtual scope for bunch', () => {
-      const mockedTriggerError = DTManager.prototype.triggerError as MockedFunction<(error: DYOToolsError) => void>;
-
-      managerTest.add(bunchToAdd, 'virtual');
+      let errorThrown: DTError | undefined;
+      try {
+        managerTest.add(bunchToAdd, 'virtual');
+      } catch(error) {
+        errorThrown = error;
+      }
 
-      expect(Object.keys(managerTest.th_get_items()).length).toBe(0);
-      expect(mockedTriggerError.mock.calls.length).toBe(1);
-      checkCallForMockedDTError(
-        'forbidden_virtual_scope',
-        'Virtual Scope provided cannot be associated to a physical bunch',
-        IDTest,
-        bunchToAdd.getId(),
-      );
+      expect(errorThrown).toBeDefined();
+      expect(Object.keys(managerTest._getItems()).length).toBe(0);
+      if (errorThrown) {
+        expect(errorThrown.getCode()).toBe('forbidden_virtual_scope');
+        expect(errorThrown.getMessage()).toBe('Virtual Scope provided cannot be associated to a physical bunch');
+        expect(errorThrown.getInitiator().getId()).toBe(IDTest);
+        expect(errorThrown.getConvicted().getId()).toBe(bunchToAdd.getId());
+      }
     });
 
     test('trigger conflict error when adding two same bunch ids', () => {
-      const mockedTriggerError = DTManager.prototype.triggerError as MockedFunction<(error: DYOToolsError) => void>;
-
-      managerTest.add(bunchToAdd);
       managerTest.add(bunchToAdd);
+      let errorThrown: DTError | undefined;
+      try {
+        managerTest.add(bunchToAdd);
+      } catch(error) {
+        errorThrown = error;
+      }
 
-      expect(Object.keys(managerTest.th_get_items()).length).toBe(1);
-      expect(mockedTriggerError.mock.calls.length).toBe(1);
-      checkCallForMockedDTError(
-        'id_conflict',
-        'Bunch with same id already exists in the manager',
-        IDTest,
-        bunchToAdd.getId(),
-      );
+      expect(errorThrown).toBeDefined();
+      expect(Object.keys(managerTest._getItems()).length).toBe(1);
+      if (errorThrown) {
+        expect(errorThrown.getCode()).toBe('id_conflict');
+        expect(errorThrown.getMessage()).toBe('Bunch with same id already exists in the manager');
+        expect(errorThrown.getInitiator().getId()).toBe(IDTest);
+        expect(errorThrown.getConvicted().getId()).toBe(bunchToAdd.getId());
+      }
     });
 
     test('add bunch elements into library - simple case', () => {
-      const bunchElements = generateMockedElements(5);
-      const bunchElementsKeys = bunchElements.map((item: DTElement<IMetaDataTest>) => item.getKey());
-      bunchToAdd.th_set_items(bunchElements);
+      const bunchElements = generateStubElements(5);
+      bunchToAdd = new DTBunchStub(bunchElements, { virtualContainer: true }) as DTBunch<DTElementStub>;
 
       managerTest.add(bunchToAdd);
 
-      expect(managerTest.th_get_single_item(IDTestBunch).item.getAllKeys()).toStrictEqual(bunchElementsKeys);
-      expect(managerTest.th_get_library().add.mock.calls.length).toBe(5);
-      let itemCount = 0;
-      for (const addCalls of managerTest.th_get_library().add.mock.calls) {
-        expect(addCalls[0].getKey()).toBe(bunchElements[itemCount].getKey());
-        expect(addCalls[1]).toBeUndefined();
-        itemCount += 1;
-      }
+      const library = managerTest.getLibrary();
+      expect(library.getAll()).toStrictEqual(bunchElements);
     });
 
     test('add bunch elements into library - not adding existing elements in library', () => {
-      const bunchElements = generateMockedElements(5);
-      const bunchElementsInLibrary = generateMockedElements(2);
-      const bunchElementsKeys = bunchElements.map((item: DTElement<IMetaDataTest>) => item.getKey());
-      bunchToAdd.th_set_items(bunchElements);
-      managerTest.th_set_library(new DTBunchStubLibrary(bunchElementsInLibrary));
+      const bunchElements = generateStubElements(5);
+      const bunchElementsInLibrary = generateStubElements(2);
+      managerTest = new DTManagerTest(IDTest, KeyTest, bunchElementsInLibrary);
+      bunchToAdd = new DTBunchStub(bunchElements, { virtualContainer: true }) as DTBunch<DTElementStub>;
 
       managerTest.add(bunchToAdd);
 
-      expect(managerTest.th_get_single_item(IDTestBunch).item.getAllKeys()).toStrictEqual(bunchElementsKeys);
-      expect(managerTest.th_get_library().add.mock.calls.length).toBe(3);
-      let itemCount = 2;
-      for (const addCalls of managerTest.th_get_library().add.mock.calls) {
-        expect(addCalls[0].getKey()).toBe(bunchElements[itemCount].getKey());
-        expect(addCalls[1]).toBeUndefined();
-        itemCount += 1;
-      }
+      const library = managerTest.getLibrary();
+      expect(library.getAll().map(e => e.getId())).toStrictEqual(bunchElements.map(e => e.getId()));
     });
 
     test('set context when adding an item - default case', () => {
-      managerTest.th_set_id(IDTest);
-
       managerTest.add(bunchToAdd);
 
-      expect((bunchToAdd.setContext as any).mock.calls.length).toBe(1);
-      expect((bunchToAdd.setContext as any).mock.calls[0][0].th_get_id()).toBe(IDTest);
+      expect(bunchToAdd.getContext()?.getId()).toBe(IDTest);
     });
 
     test('set context when adding an item - remove from old manager', () => {
-      const oldManagerTest = new DTManagerTest();
-      bunchToAdd.th_set_context(oldManagerTest);
-      oldManagerTest.th_set_items({ [bunchToAdd.getId()]: { scope: 'default', item: bunchToAdd } });
-      managerTest.th_set_id(IDTest);
-      oldManagerTest.th_set_id(`${IDTest}-old`);
-      jest.spyOn(oldManagerTest, 'remove');
-      jest.spyOn(oldManagerTest, 'getComponentType').mockImplementation(() => 'manager');
+      const oldManagerTest = new DTManagerTest(IDTest + '_old');
+      bunchToAdd.setContext(oldManagerTest);
+      const removeSpy = jest.spyOn(oldManagerTest, 'remove');
 
       managerTest.add(bunchToAdd);
 
-      expect((oldManagerTest.remove as any).mock.calls.length).toBe(1);
-      expect((oldManagerTest.remove as any).mock.calls[0][0]).toBe(bunchToAdd.getId());
-      expect(Object.keys(managerTest.th_get_items()).length).toBe(1);
-      checkManagerItem(managerTest, IDTestBunch, 'default');
+      expect(removeSpy.mock.calls.length).toBe(1);
+      expect(removeSpy.mock.calls[0][0]).toBe(bunchToAdd.getId());
+      expect(bunchToAdd.getContext()?.getId()).toBe(IDTest);
     });
 
     test('set context when adding an item - update context with manager for all library elements', () => {
-      const oldManagerTest = new DTManagerTest();
-      const bunchElements = generateMockedElements(5);
-      bunchToAdd.th_set_items(bunchElements);
-      bunchToAdd.th_set_context(oldManagerTest);
+      const elementAdded = generateStubElements(1);
+      const oldManagerTest = new DTManagerTest(IDTest + '_old', KeyTest);
+      bunchToAdd = new DTBunchStub(elementAdded) as DTBunch<DTElementStub>;
+      oldManagerTest.add(bunchToAdd);
+      const contextSpy = jest.spyOn(elementAdded[0], 'setContext');
 
       managerTest.add(bunchToAdd);
 
-      for (const element of bunchElements) {
-        expect((element.setContext as any).mock.calls.length).toBe(1);
-        expect((element.setContext as any).mock.calls[0][0]).toStrictEqual(managerTest);
-      }
+      expect(contextSpy.mock.calls.length).toBe(1);
+      expect(contextSpy.mock.calls[0][0]).toStrictEqual(managerTest);
     });
   });
 
   describe('addMany()', () => {
     let mockedAdd: MockedFunction<(item: any, scope?: string) => void>;
     let bunchesToAdd: DTBunchStub[];
+    let addSpy: any;
 
     beforeEach(() => {
-      jest.spyOn(managerTest, 'add').mockImplementation(() => {});
-      mockedAdd = managerTest.add as MockedFunction<(item: any, scope?: string) => void>;
+      managerTest = new DTManagerTest(IDTest, KeyTest, [], ScopesTest, { errors: false });
+      addSpy = jest.spyOn(managerTest, 'add').mockImplementation(() => {});
 
       // Bunches to add
       const bunchToAdd1 = new DTBunchStub();
-      bunchToAdd1.th_set_id(`${IDTestBunch}_1`);
+      bunchToAdd1._setId(`${IDTestBunch}_1`);
       const bunchToAdd2 = new DTBunchStub();
-      bunchToAdd2.th_set_id(`${IDTestBunch}_2`);
+      bunchToAdd2._setId(`${IDTestBunch}_2`);
       const bunchToAdd3 = new DTBunchStub();
-      bunchToAdd3.th_set_id(`${IDTestBunch}_3`);
+      bunchToAdd3._setId(`${IDTestBunch}_3`);
       bunchesToAdd = [bunchToAdd1, bunchToAdd2, bunchToAdd3];
-
-      // Add tests scopes and options
-      managerTest.th_set_scopes([...managerTest.th_get_scopes(), ...ScopesTest]);
-      managerTest.th_set_options({ errors: false });
     });
 
     test('add many items - use add method - default case', () => {
       managerTest.addMany(bunchesToAdd);
 
-      expect(mockedAdd.mock.calls.length).toBe(3);
+      expect(addSpy.mock.calls.length).toBe(3);
       let itemCount = 0;
-      for (const addCalls of mockedAdd.mock.calls) {
-        expect(addCalls[0].th_get_id()).toBe(bunchesToAdd[itemCount].th_get_id());
+      for (const addCalls of addSpy.mock.calls) {
+        expect(addCalls[0].getId()).toBe(bunchesToAdd[itemCount].getId());
         expect(addCalls[1]).toBeUndefined();
         itemCount += 1;
       }
@@ -508,17 +421,17 @@ describe('class DYOToolsManager', () => {
     test('add many items - use add method - with scope case', () => {
       managerTest.addMany(bunchesToAdd, ScopesTest[0]);
 
-      expect(mockedAdd.mock.calls.length).toBe(3);
+      expect(addSpy.mock.calls.length).toBe(3);
       let itemCount = 0;
-      for (const addCalls of mockedAdd.mock.calls) {
-        expect(addCalls[0].th_get_id()).toBe(bunchesToAdd[itemCount].th_get_id());
+      for (const addCalls of addSpy.mock.calls) {
+        expect(addCalls[0].getId()).toBe(bunchesToAdd[itemCount].getId());
         expect(addCalls[1]).toBe(ScopesTest[0]);
         itemCount += 1;
       }
     });
 
     test('errors when adding many items at index - default case - add no items and throw error', () => {
-      jest.spyOn(managerTest, 'add')
+      addSpy = jest.spyOn(managerTest, 'add')
         .mockImplementationOnce(function (item) {
           this._items[`${IDTestBunch}_1`] = {
             scope: 'default',
@@ -534,15 +447,19 @@ describe('class DYOToolsManager', () => {
             item,
           };
         });
+      let errorThrown: DTError | undefined;
+      try {
+        managerTest.addMany(bunchesToAdd);
+      } catch(error) {
+        errorThrown = error;
+      }
 
-      expect(() => { managerTest.addMany(bunchesToAdd); }).toThrow();
-      expect(mockedAdd.mock.calls.length).toBe(2);
-      expect(Object.keys(managerTest.th_get_items()).length).toBe(0);
+      expect(errorThrown).toBeDefined();
+      expect(Object.keys(managerTest._getItems()).length).toBe(0);
     });
 
     test('errors when adding many items at index - errors case - add success items and stack errors for others', () => {
-      managerTest.th_set_options({ errors: true });
-      jest.spyOn(managerTest, 'add')
+      addSpy = jest.spyOn(managerTest, 'add')
         .mockImplementationOnce(function (item) {
           this._items[`${IDTestBunch}_1`] = {
             scope: 'default',
@@ -561,111 +478,120 @@ describe('class DYOToolsManager', () => {
 
       managerTest.addMany(bunchesToAdd);
 
-      expect(mockedAdd.mock.calls.length).toBe(3);
-      expect(Object.keys(managerTest.th_get_items()).length).toBe(2);
+      expect(addSpy.mock.calls.length).toBe(3);
+      expect(Object.keys(managerTest._getItems()).length).toBe(2);
     });
   });
 
   describe('moveToScope()', () => {
     beforeEach(() => {
-      populateManager(managerTest);
-
-      jest.spyOn(managerTest, 'getId').mockReturnValue(IDTest);
-      jest.spyOn(managerTest, 'isValidScope').mockReturnValue(true);
+      managerTest = new DTManagerTest(IDTest, KeyTest, [], ScopesTest);
+      managerTest.populate();
     });
 
     test('move to default scope', () => {
       managerTest.moveToScope(`${IDTestBunch}_2`, 'default');
 
-      expect(Object.keys(managerTest.th_get_items()).length).toBe(3);
+      expect(Object.keys(managerTest._getItems()).length).toBe(3);
       checkManagerItem(managerTest, `${IDTestBunch}_2`, 'default');
     });
 
     test('move to existing scope', () => {
       managerTest.moveToScope(`${IDTestBunch}_2`, ScopesTest[1]);
 
-      expect(Object.keys(managerTest.th_get_items()).length).toBe(3);
+      expect(Object.keys(managerTest._getItems()).length).toBe(3);
       checkManagerItem(managerTest, `${IDTestBunch}_2`, ScopesTest[1]);
     });
 
     test('move to non-existing scope - trigger invalid_scope error', () => {
-      const mockedTriggerError = DTManager.prototype.triggerError as MockedFunction<(error: DYOToolsError) => void>;
-      jest.spyOn(managerTest, 'isValidScope').mockReturnValue(false);
-
-      managerTest.moveToScope(`${IDTestBunch}_2`, 'invalid_scope');
+      let errorThrown: DTError | undefined;
+      try {
+        managerTest.moveToScope(`${IDTestBunch}_2`, 'invalid_scope');
+      } catch(error) {
+        errorThrown = error;
+      }
 
-      expect(Object.keys(managerTest.th_get_items()).length).toBe(3);
-      expect(mockedTriggerError.mock.calls.length).toBe(1);
-      checkCallForMockedDTError(
-        'invalid_scope',
-        "Scope provided doesn't exist in the manager",
-        IDTest,
-        `${IDTestBunch}_2`,
-      );
+      expect(errorThrown).toBeDefined();
+      expect(Object.keys(managerTest._getItems()).length).toBe(3);
+      if (errorThrown) {
+        expect(errorThrown.getCode()).toBe('invalid_scope');
+        expect(errorThrown.getMessage()).toBe('Scope provided doesn\'t exist in the manager');
+        expect(errorThrown.getInitiator().getId()).toBe(IDTest);
+        expect(errorThrown.getConvicted().getId()).toBe(`${IDTestBunch}_2`);
+      }
     });
 
     test('move non-virtual bunch to virtual scope - trigger forbidden_virtual_scope error', () => {
-      const mockedTriggerError = DTManager.prototype.triggerError as MockedFunction<(error: DYOToolsError) => void>;
-
-      managerTest.moveToScope(`${IDTestBunch}_2`, 'virtual');
+      let errorThrown: DTError | undefined;
+      try {
+        managerTest.moveToScope(`${IDTestBunch}_2`, 'virtual');
+      } catch(error) {
+        errorThrown = error;
+      }
 
-      expect(Object.keys(managerTest.th_get_items()).length).toBe(3);
-      expect(mockedTriggerError.mock.calls.length).toBe(1);
-      checkCallForMockedDTError(
-        'forbidden_virtual_scope',
-        'Virtual Scope provided cannot be associated to a physical bunch',
-        IDTest,
-        `${IDTestBunch}_2`,
-      );
+      expect(errorThrown).toBeDefined();
+      expect(Object.keys(managerTest._getItems()).length).toBe(3);
+      if (errorThrown) {
+        expect(errorThrown.getCode()).toBe('forbidden_virtual_scope');
+        expect(errorThrown.getMessage()).toBe('Virtual Scope provided cannot be associated to a physical bunch');
+        expect(errorThrown.getInitiator().getId()).toBe(IDTest);
+        expect(errorThrown.getConvicted().getId()).toBe(`${IDTestBunch}_2`);
+      }
     });
 
     test('move virtual bunch to non-virtual scope - trigger forbidden_scope error', () => {
-      const mockedTriggerError = DTManager.prototype.triggerError as MockedFunction<(error: DYOToolsError) => void>;
-
-      managerTest.moveToScope(`${IDTestBunch}_3`, ScopesTest[0]);
+      let errorThrown: DTError | undefined;
+      try {
+        managerTest.moveToScope(`${IDTestBunch}_3`, ScopesTest[0]);
+      } catch(error) {
+        errorThrown = error;
+      }
 
-      expect(Object.keys(managerTest.th_get_items()).length).toBe(3);
-      expect(mockedTriggerError.mock.calls.length).toBe(1);
-      checkCallForMockedDTError(
-        'forbidden_scope',
-        'Scope provided cannot be associated to a virtual bunch',
-        IDTest,
-        `${IDTestBunch}_3`,
-      );
+      expect(errorThrown).toBeDefined();
+      expect(Object.keys(managerTest._getItems()).length).toBe(3);
+      if (errorThrown) {
+        expect(errorThrown.getCode()).toBe('forbidden_scope');
+        expect(errorThrown.getMessage()).toBe('Scope provided cannot be associated to a virtual bunch');
+        expect(errorThrown.getInitiator().getId()).toBe(IDTest);
+        expect(errorThrown.getConvicted().getId()).toBe(`${IDTestBunch}_3`);
+      }
     });
 
     test('move to same scope - nothing append', () => {
       managerTest.moveToScope(`${IDTestBunch}_1`, 'default');
 
-      expect(Object.keys(managerTest.th_get_items()).length).toBe(3);
+      expect(Object.keys(managerTest._getItems()).length).toBe(3);
       checkManagerItem(managerTest, `${IDTestBunch}_1`, 'default');
     });
 
     test('move an non-existing bunch id - trigger invalid_id error', () => {
-      const mockedTriggerError = DTManager.prototype.triggerError as MockedFunction<(error: DYOToolsError) => void>;
-
-      managerTest.moveToScope(`${IDTestBunch}_5`, ScopesTest[0]);
+      let errorThrown: DTError | undefined;
+      try {
+        managerTest.moveToScope(`${IDTestBunch}_5`, ScopesTest[0]);
+      } catch(error) {
+        errorThrown = error;
+      }
 
-      expect(Object.keys(managerTest.th_get_items()).length).toBe(3);
-      expect(mockedTriggerError.mock.calls.length).toBe(1);
-      checkCallForMockedDTError(
-        'invalid_id',
-        'Bunch id provided doesn\'t exist in the manager',
-        IDTest,
-      );
+      expect(errorThrown).toBeDefined();
+      expect(Object.keys(managerTest._getItems()).length).toBe(3);
+      if (errorThrown) {
+        expect(errorThrown.getCode()).toBe('invalid_id');
+        expect(errorThrown.getMessage()).toBe('Bunch id provided doesn\'t exist in the manager');
+        expect(errorThrown.getInitiator().getId()).toBe(IDTest);
+      }
     });
   });
 
   describe('get()', () => {
     beforeEach(() => {
-      populateManager(managerTest);
+      managerTest.populate();
     });
 
     test('return a bunch by its id', () => {
-      const bunch = managerTest.get(`${IDTestBunch}_1`) as DTBunchTest;
+      const bunch = managerTest.get(`${IDTestBunch}_1`) as DTBunchStub;
 
       expect(bunch).toBeDefined();
-      expect(bunch.th_get_id()).toBe(`${IDTestBunch}_1`);
+      expect(bunch.getId()).toBe(`${IDTestBunch}_1`);
     });
 
     test('return undefined if bunch is not found', () => {
@@ -677,13 +603,13 @@ describe('class DYOToolsManager', () => {
 
   describe('getAll()', () => {
     beforeEach(() => {
-      populateManager(managerTest);
+      managerTest.populate();
     });
 
     test('return all bunch items', () => {
-      const bunches = managerTest.getAll() as DTBunchTest[];
+      const bunches = managerTest.getAll() as DTBunchStub[];
 
-      const bunchesIds = bunches.map((bunch) => bunch.th_get_id());
+      const bunchesIds = bunches.map((bunch) => bunch.getId());
       expect(bunchesIds.length).toBe(3);
       expect(bunchesIds.includes(`${IDTestBunch}_1`)).toBeTruthy();
       expect(bunchesIds.includes(`${IDTestBunch}_2`)).toBeTruthy();
@@ -691,7 +617,7 @@ describe('class DYOToolsManager', () => {
     });
 
     test('return empty array if no bunch', () => {
-      managerTest.th_set_items({});
+      managerTest = new DTManagerTest();
 
       const bunches = managerTest.getAll();
 
@@ -699,9 +625,9 @@ describe('class DYOToolsManager', () => {
     });
 
     test('scope argument : return only bunches into the scope', () => {
-      const bunches = managerTest.getAll(ScopesTest[0]) as DTBunchTest[];
+      const bunches = managerTest.getAll(ScopesTest[0]) as DTBunchStub[];
 
-      const bunchesIds = bunches.map((bunch) => bunch.th_get_id());
+      const bunchesIds = bunches.map((bunch) => bunch.getId());
       expect(bunchesIds.length).toBe(1);
       expect(bunchesIds.includes(`${IDTestBunch}_2`)).toBeTruthy();
     });
@@ -721,7 +647,7 @@ describe('class DYOToolsManager', () => {
 
   describe('getScope()', () => {
     beforeEach(() => {
-      populateManager(managerTest);
+      managerTest.populate();
     });
 
     test('get scope for an existing bunch id', () => {
@@ -743,28 +669,28 @@ describe('class DYOToolsManager', () => {
 
   describe('remove()', () => {
     beforeEach(() => {
-      populateManager(managerTest);
-
-      jest.spyOn(managerTest, 'removeMany');
+      managerTest.populate();
     });
 
     test('remove one item using removeMany', () => {
+      const removeManySpy = jest.spyOn(managerTest, 'removeMany');
+
       managerTest.remove(`${IDTestBunch}_2`);
 
-      expect((managerTest.removeMany as any).mock.calls.length).toBe(1);
-      expect((managerTest.removeMany as any).mock.calls[0][0]).toStrictEqual([`${IDTestBunch}_2`]);
+      expect(removeManySpy.mock.calls.length).toBe(1);
+      expect(removeManySpy.mock.calls[0][0]).toStrictEqual([`${IDTestBunch}_2`]);
     });
   });
 
   describe('removeMany()', () => {
     beforeEach(() => {
-      populateManager(managerTest);
+      managerTest.populate();
     });
 
     test('remove multiple bunches from manager', () => {
       managerTest.removeMany([`${IDTestBunch}_1`, `${IDTestBunch}_2`]);
 
-      const newItems = managerTest.th_get_items();
+      const newItems = managerTest._getItems();
       expect(Object.keys(newItems).length).toBe(1);
       expect(Object.keys(newItems)).toStrictEqual([`${IDTestBunch}_3`]);
     });
@@ -772,7 +698,7 @@ describe('class DYOToolsManager', () => {
     test('remove non-existing bunches - nothing happen', () => {
       managerTest.removeMany([`${IDTestBunch}_5`, `${IDTestBunch}_7`]);
 
-      const newItems = managerTest.th_get_items();
+      const newItems = managerTest._getItems();
       expect(Object.keys(newItems).length).toBe(3);
       expect(Object.keys(newItems)).toStrictEqual([`${IDTestBunch}_1`, `${IDTestBunch}_2`, `${IDTestBunch}_3`]);
     });
@@ -780,123 +706,110 @@ describe('class DYOToolsManager', () => {
     test('remove multiple bunches from manager - no removal from library by default', () => {
       managerTest.removeMany([`${IDTestBunch}_1`, `${IDTestBunch}_2`]);
 
-      expect(managerTest.th_get_library().remove.mock.calls.length).toBe(0);
+      const library = managerTest.getLibrary();
+      expect(library.getAll().length).toBe(5);
     });
 
     test('remove multiple bunches from manager - libraryDeletion option', () => {
-      const libraryElementsIdToRemove = managerTest.th_get_library().th_get_items().map((item: any) => item.getId());
       managerTest.removeMany([`${IDTestBunch}_1`, `${IDTestBunch}_2`], { libraryDeletion: true });
 
-      expect(managerTest.th_get_library().remove.mock.calls.length).toBe(5);
-      expect(managerTest.th_get_library().remove.mock.calls.map((call: any) => call[0])).toEqual(libraryElementsIdToRemove);
+      const library = managerTest.getLibrary();
+      expect(library.getAll().length).toBe(0);
     });
 
     test('remove context when removing a bunch - standard case', () => {
-      const bunch1 = managerTest.th_get_single_item(`${IDTestBunch}_1`).item;
-      const bunch2 = managerTest.th_get_single_item(`${IDTestBunch}_2`).item;
+      const bunch1 = managerTest._getItem(`${IDTestBunch}_1`).item;
+      const bunch2 = managerTest._getItem(`${IDTestBunch}_2`).item;
+      const bunch1RemoveContextSpy = jest.spyOn(bunch1, 'removeContext');
+      const bunch2RemoveContextSpy = jest.spyOn(bunch2, 'removeContext');
 
       managerTest.removeMany([`${IDTestBunch}_1`, `${IDTestBunch}_2`]);
 
-      expect((bunch1.removeContext as any).mock.calls.length).toBe(1);
-      expect((bunch2.removeContext as any).mock.calls.length).toBe(1);
+      expect(bunch1RemoveContextSpy.mock.calls.length).toBe(1);
+      expect(bunch2RemoveContextSpy.mock.calls.length).toBe(1);
     });
 
-    test('remove context when removing a bunch - remove context for all library elements', () => {
-      const bunch1 = managerTest.th_get_single_item(`${IDTestBunch}_1`).item;
-      const bunchElements = generateMockedElements(5);
-      bunch1.th_set_items(bunchElements);
-      bunch1.th_set_context(managerTest);
-
+    test('remove a bunch with elements - remove container for all library elements', () => {
       managerTest.removeMany([`${IDTestBunch}_1`]);
 
-      for (let element of bunchElements) {
-        expect((element.removeContext as any).mock.calls.length).toBe(1);
+      const library = managerTest.getLibrary();
+      for (let element of library.getAll()) {
+        expect(element.getContext()?.getId()).toBe(IDTest);
+        expect(element.getContainer()).toBeUndefined();
       }
     });
   });
 
   describe('removeAll()', () => {
     beforeEach(() => {
-      populateManager(managerTest);
-
-      jest.spyOn(managerTest, 'removeMany');
+      managerTest.populate();
     });
 
     test('remove all items using removeMany', () => {
-      const bunchesIdToRemove = Object.keys(managerTest.th_get_items());
+      const removeManySpy = jest.spyOn(managerTest, 'removeMany');
       managerTest.removeAll();
 
       expect((managerTest.removeMany as any).mock.calls.length).toBe(1);
-      expect((managerTest.removeMany as any).mock.calls[0][0]).toStrictEqual(bunchesIdToRemove);
+      expect((managerTest.removeMany as any).mock.calls[0][0]).toStrictEqual([`${IDTestBunch}_1`, `${IDTestBunch}_2`, `${IDTestBunch}_3`]);
     });
   });
 
   describe('find()', () => {
+    let findSpy;
+
+    beforeEach(() => {
+      findSpy = jest.spyOn(managerTest._getFinder(), 'execute');
+    });
+
     test('find items using DYOFinder - empty case', () => {
       managerTest.find({});
 
-      expect((managerTest.th_get_finder() as any).execute.mock.calls.length).toBe(1);
-      expect((managerTest.th_get_finder() as any).execute.mock.calls[0][0]).toStrictEqual({});
+      expect((findSpy as any).mock.calls.length).toBe(1);
+      expect((findSpy as any).mock.calls[0][0]).toStrictEqual({});
     });
 
     test('find items using DYOFinder', () => {
       const testFilters = { id: { $eq: 'id_bunch' }, key: { $ne: 'key_test' } };
       managerTest.find(testFilters);
 
-      expect((managerTest.th_get_finder() as any).execute.mock.calls.length).toBe(1);
-      expect((managerTest.th_get_finder() as any).execute.mock.calls[0][0]).toStrictEqual(testFilters);
+      expect((findSpy as any).mock.calls.length).toBe(1);
+      expect((findSpy as any).mock.calls[0][0]).toStrictEqual(testFilters);
     });
   });
 
   describe('reloadLibrary()', () => {
     beforeEach(() => {
-      populateManager(managerTest);
+      managerTest.populate();
+      const library = managerTest.getLibrary();
+      library.removeAll();
     });
 
-    const extractIdsFromLibraryAddCalls = () => (managerTest.th_get_library().add as any).mock.calls.map((call) => call[0].getId());
-
     test('synchronize bunches items into an empty library - one bunch with items', () => {
-      const items = managerTest.th_get_library().th_get_items();
-      managerTest.th_get_library().th_set_items([]);
-      const expectedAddedItemIds = items.map((item: any) => item.getId());
-
-      managerTest.reloadLibrary();
-
-      expect(extractIdsFromLibraryAddCalls()).toEqual(expectedAddedItemIds);
-    });
-
-    test('synchronize bunches items into an empty library - multiple bunches with items', () => {
-      const items = managerTest.th_get_library().th_get_items();
-      managerTest.th_get_library().th_set_items([]);
-      managerTest.th_get_single_item(bunch1IdTest).item.th_set_items([items[0], items[1], items[2]]);
-      managerTest.th_get_single_item(bunch2IdTest).item.th_set_items([items[3], items[4]]);
-      const expectedAddedItemIds = items.map((item: any) => item.getId());
-
+      const expectedAddedItemIds = generateStubElements(5).map((e) => e.getId());
       managerTest.reloadLibrary();
 
-      expect(extractIdsFromLibraryAddCalls()).toEqual(expectedAddedItemIds);
+      const library = managerTest.getLibrary();
+      expect(library.getAll().map((e) => e.getId())).toEqual(expectedAddedItemIds);
     });
 
-    test('synchronize bunches items into an empty library - pass already existing ids', () => {
-      jest.spyOn(managerTest.th_get_library(), 'removeAll').mockImplementation(function () {
-        this._items = [];
-      });
-      const items = managerTest.th_get_library().th_get_items();
-      managerTest.th_get_library().th_set_items([items[0], items[1], items[2]]);
-      managerTest.th_get_single_item(bunch1IdTest).item.th_set_items(items);
-      const expectedAddedItemIds = items.map((item: any) => item.getId());
+    test('synchronize bunches items into an empty library - multiple bunches with items and existing ids', () => {
+      const newItems = generateStubElements(7);
+      const newBunch = new DTBunchStub(newItems);
+      newBunch._setId(IDTest + '_new');
+      const library = managerTest.getLibrary();
+      managerTest.add(newBunch);
+      library.removeAll();
 
       managerTest.reloadLibrary();
 
-      expect(extractIdsFromLibraryAddCalls()).toEqual(expectedAddedItemIds);
+      expect(library.getAll().map((e) => e.getId())).toEqual(newItems.map(e => e.getId()));
     });
   });
 
   describe('toObject()', () => {
     beforeEach(() => {
-      managerTest.th_set_id(IDTest);
-      managerTest.th_set_key(KeyTest);
-    });
+      managerTest = new DTManagerTest(IDTest, KeyTest);
+    })
 
     test('toObject output standard', () => {
       const toObjectManager = managerTest.toObject();
@@ -909,7 +822,7 @@ describe('class DYOToolsManager', () => {
     });
 
     test('toObject output with items', () => {
-      populateManager(managerTest);
+      managerTest.populate();
 
       const toObjectManager = managerTest.toObject();
 
@@ -925,20 +838,17 @@ describe('class DYOToolsManager', () => {
 
   describe('toString()', () => {
     beforeEach(() => {
-      managerTest.th_set_key(KeyTest);
-    });
+      managerTest = new DTManagerTest(IDTest, KeyTest);
+    })
 
     test('string output standard', () => {
-      managerTest.th_set_library(new DTBunchStubLibrary());
-
       const toStringManager = managerTest.toString();
 
       expect(toStringManager).toBe(`Component ${KeyTest} - Type: Manager - Library: 0 - Items: 0`);
     });
 
     test('string output with domain', () => {
-      managerTest.th_set_library(new DTBunchStubLibrary());
-      managerTest.th_set_domain(DomainTest);
+      managerTest = new DTManagerTestDomain(IDTest, KeyTest);
 
       const toStringManager = managerTest.toString();
 
@@ -946,8 +856,7 @@ describe('class DYOToolsManager', () => {
     });
 
     test('string output with library', () => {
-      populateManager(managerTest);
-      managerTest.th_set_items({});
+      managerTest = new DTManagerTest(IDTest, KeyTest, generateStubElements(5));
 
       const toStringManager = managerTest.toString();
 
@@ -955,7 +864,7 @@ describe('class DYOToolsManager', () => {
     });
 
     test('string output with library and items', () => {
-      populateManager(managerTest);
+      managerTest.populate();
 
       const toStringManager = managerTest.toString();