dyo-tools 0.2.0 → 0.3.0

package/test/core/DTBunch.spec.ts

@@ -24,17 +24,10 @@ import { DTBunch, DTComponentPhysical } from '../../src';
 import DYOToolsElement from '../../src/core/DTElement';
 import { BunchMetaData, HaileiMetaData, IMetaDataTest } from './DTComponentWithMeta.double';
 import { DTBunchOptions, FilterOperatorType } from '../../src/types';
-import {
-  DTPlayerStub,
-  IDTest as IDTestPlayer,
-  IDTest as IDPlayerTest,
-  KeyTest as KeyPlayerTest,
-  toStringTest as toStringPlayerTest,
-} from './DTPlayer.double';
 import { checkCallForMockedDTError, CodeTest as DTErrorCodeTest, DTErrorStub } from './DTError.double';
 import DYOToolsError from '../../src/core/DTError';
-import { mockOverriddenMethods } from './DTComponentPhysical.double';
-import { DTManagerStub } from './DTManager.double';
+import { mockOverriddenMethods, OwnerTest } from './DTComponentPhysical.double';
+import { DTManagerStub, IDTest as managerIDTest } from './DTManager.double';
 import { componentBunchDefaultFinderConfiguration } from '../../src/constants';
 import Mocked = jest.Mocked;
 import MockedFunction = jest.MockedFunction;
@@ -124,7 +117,7 @@ describe('class DYOToolsBunch', () => {
         uniqueKey: true,
         inheritOwner: true,
         replaceIndex: false,
-        virtualContext: false,
+        virtualContainer: false,
       });
       expect(newBunch.th_get_items()).toStrictEqual([]);
     });
@@ -174,42 +167,42 @@ describe('class DYOToolsBunch', () => {
       const finderConfigurationToCheck = bunchTest.getFinderConfiguration().owner;
 
       expect(finderConfigurationToCheck.operators).toStrictEqual(baseOperators);
-      expect(finderConfigurationToCheck.getValue(element)).toBeNull();
+      expect(finderConfigurationToCheck.getValue(element)).toBeUndefined();
       expect(finderConfigurationToCheck.objectSearch).toBe(false);
     });
 
     test('check finder configuration for owner attribute - with owner', () => {
       const element = new DTElementStub();
-      jest.spyOn(element, 'getOwner').mockImplementation(() => new DTPlayerStub());
+      jest.spyOn(element, 'getOwner').mockReturnValue(OwnerTest);
 
       const finderConfigurationToCheck = bunchTest.getFinderConfiguration().owner;
 
       expect(finderConfigurationToCheck.operators).toStrictEqual(baseOperators);
-      expect(finderConfigurationToCheck.getValue(element)).toBe(IDTestPlayer);
+      expect(finderConfigurationToCheck.getValue(element)).toBe(OwnerTest);
       expect(finderConfigurationToCheck.objectSearch).toBe(false);
     });
 
-    test('check finder configuration for context attribute - empty context', () => {
+    test('check finder configuration for container attribute - empty container', () => {
       const element = new DTElementStub();
-      jest.spyOn(element, 'getContext').mockImplementation(() => undefined);
+      jest.spyOn(element, 'getContainer').mockImplementation(() => undefined);
 
-      const finderConfigurationToCheck = bunchTest.getFinderConfiguration().context;
+      const finderConfigurationToCheck = bunchTest.getFinderConfiguration().container;
 
       expect(finderConfigurationToCheck.operators).toStrictEqual(baseOperators);
       expect(finderConfigurationToCheck.getValue(element)).toBeNull();
       expect(finderConfigurationToCheck.objectSearch).toBe(false);
     });
 
-    test('check finder configuration for context attribute - with context', () => {
+    test('check finder configuration for container attribute - with container', () => {
       const element = new DTElementStub();
       const bunch = new DTBunchStub();
-      jest.spyOn(bunch, 'getId').mockImplementation(() => `${IDTest}_other_context`);
-      jest.spyOn(element, 'getContext').mockImplementation(() => bunch);
+      jest.spyOn(bunch, 'getId').mockImplementation(() => `${IDTest}_other_container`);
+      jest.spyOn(element, 'getContainer').mockImplementation(() => bunch);
 
-      const finderConfigurationToCheck = bunchTest.getFinderConfiguration().context;
+      const finderConfigurationToCheck = bunchTest.getFinderConfiguration().container;
 
       expect(finderConfigurationToCheck.operators).toStrictEqual(baseOperators);
-      expect(finderConfigurationToCheck.getValue(element)).toBe(`${IDTest}_other_context`);
+      expect(finderConfigurationToCheck.getValue(element)).toBe(`${IDTest}_other_container`);
       expect(finderConfigurationToCheck.objectSearch).toBe(false);
     });
 
@@ -227,15 +220,14 @@ describe('class DYOToolsBunch', () => {
 
   describe('setOwner()', () => {
     beforeEach(() => {
-      jest.spyOn(bunchTest, 'getOwner').mockImplementation(() => new DTPlayerStub());
+      jest.spyOn(bunchTest, 'getOwner').mockReturnValue(OwnerTest);
     });
 
     test('add a new owner - not updating elements owner when inheritOwner = false', () => {
       bunchTest.th_set_options({ inheritOwner: false });
       bunchTest.th_set_items(generateMockedElements(3));
 
-      const owner = new DTPlayerStub();
-      bunchTest.setOwner(owner);
+      bunchTest.setOwner(OwnerTest);
 
       expect(bunchTest.th_get_items()[0].setOwner.mock.calls.length).toBe(0);
       expect(bunchTest.th_get_items()[1].setOwner.mock.calls.length).toBe(0);
@@ -246,15 +238,14 @@ describe('class DYOToolsBunch', () => {
       bunchTest.th_set_options({ inheritOwner: true });
       bunchTest.th_set_items(generateMockedElements(3));
 
-      const owner = new DTPlayerStub();
-      bunchTest.setOwner(owner);
+      bunchTest.setOwner(OwnerTest);
 
       expect(bunchTest.th_get_items()[0].setOwner.mock.calls.length).toBe(1);
-      expect(bunchTest.th_get_items()[0].setOwner.mock.calls[0][0].getId()).toBe(IDPlayerTest);
+      expect(bunchTest.th_get_items()[0].setOwner.mock.calls[0][0]).toBe(OwnerTest);
       expect(bunchTest.th_get_items()[1].setOwner.mock.calls.length).toBe(1);
-      expect(bunchTest.th_get_items()[1].setOwner.mock.calls[0][0].getId()).toBe(IDPlayerTest);
+      expect(bunchTest.th_get_items()[1].setOwner.mock.calls[0][0]).toBe(OwnerTest);
       expect(bunchTest.th_get_items()[2].setOwner.mock.calls.length).toBe(1);
-      expect(bunchTest.th_get_items()[2].setOwner.mock.calls[0][0].getId()).toBe(IDPlayerTest);
+      expect(bunchTest.th_get_items()[2].setOwner.mock.calls[0][0]).toBe(OwnerTest);
     });
   });
 
@@ -340,7 +331,6 @@ describe('class DYOToolsBunch', () => {
     });
   });
 
-  // TODO : Add test cases for updating Library from manager
   describe('addAtIndex()', () => {
     let objectToAdd;
     let objectsToAdd;
@@ -436,68 +426,82 @@ describe('class DYOToolsBunch', () => {
     });
 
     test('not inherit owner when adding an item - default case', () => {
-      const owner = new DTPlayerStub();
-      bunchTest.th_set_owner(owner);
+      bunchTest.th_set_owner(OwnerTest);
 
       bunchTest.addAtIndex(objectToAdd, 2);
 
-      expect(bunchTest.th_get_owner().getId()).toBe(IDPlayerTest);
+      expect(bunchTest.th_get_owner()).toBe(OwnerTest);
       expect(objectToAdd.setOwner.mock.calls.length).toBe(0);
     });
 
     test('inherit owner when adding an item - inheritOwner option', () => {
-      const owner = new DTPlayerStub();
-      bunchTest.th_set_owner(owner);
+      bunchTest.th_set_owner(OwnerTest);
 
       bunchTest.addAtIndex(objectToAdd, 2, { inheritOwner: true });
 
-      expect(bunchTest.th_get_owner().getId()).toBe(IDPlayerTest);
+      expect(bunchTest.th_get_owner()).toBe(OwnerTest);
       expect(objectToAdd.setOwner.mock.calls.length).toBe(1);
-      expect(objectToAdd.setOwner.mock.calls[0][0].getId()).toBe(IDPlayerTest);
+      expect(objectToAdd.setOwner.mock.calls[0][0]).toBe(OwnerTest);
+    });
+
+    test('not set context if undefined when adding an item', () => {
+      bunchTest.addAtIndex(objectToAdd, 2);
+
+      expect(bunchTest.th_get_items()[2].setContext.mock.calls.length).toBe(0);
     });
 
-    test('set context when adding an item - default case', () => {
+    test('set context with parent manager when adding an item', () => {
+      const manager = new DTManagerStub();
+      bunchTest.th_set_context(manager);
+
       bunchTest.addAtIndex(objectToAdd, 2);
 
       expect(bunchTest.th_get_items()[2].setContext.mock.calls.length).toBe(1);
-      expect(bunchTest.th_get_items()[2].setContext.mock.calls[0][0].getId()).toBe(IDTest);
+      expect(bunchTest.th_get_items()[2].setContext.mock.calls[0][0].getId()).toBe(managerIDTest);
     });
 
-    test('not set context when adding an item - virtualContext option', () => {
-      bunchTest.th_set_options({ virtualContext: true });
+    test('set container when adding an item', () => {
+      bunchTest.addAtIndex(objectToAdd, 2);
+
+      expect(bunchTest.th_get_items()[2].setContainer.mock.calls.length).toBe(1);
+      expect(bunchTest.th_get_items()[2].setContainer.mock.calls[0][0].getId()).toBe(IDTest);
+    });
+
+    test('not set container when adding an item - virtualContainer option', () => {
+      bunchTest.th_set_options({ virtualContainer: true });
 
       bunchTest.addAtIndex(objectToAdd, 2);
 
-      expect(bunchTest.th_get_items()[2].setContext.mock.calls.length).toBe(0);
+      expect(bunchTest.th_get_items()[2].setContainer.mock.calls.length).toBe(0);
     });
 
-    test('set context when adding an item - remove from old bunch', () => {
+    test('set container when adding an item - remove from old bunch', () => {
       const bunchTestOld = new DTBunchTest();
       bunchTestOld.th_set_items(generateMockedElements(6));
       objectToAdd = bunchTestOld.th_get_items()[5];
-      objectToAdd.setContext(bunchTestOld);
-      objectToAdd.setContext.mockClear();
+      objectToAdd.setContainer(bunchTestOld);
+      objectToAdd.setContainer.mockClear();
       jest.spyOn(bunchTestOld, 'remove').mockImplementation(() => {});
       jest.spyOn(bunchTestOld, 'getComponentType').mockImplementation(() => 'bunch');
 
       bunchTest.addAtIndex(objectToAdd, 2);
 
-      expect(bunchTest.th_get_items()[2].setContext.mock.calls.length).toBe(1);
-      expect(bunchTest.th_get_items()[2].setContext.mock.calls[0][0].getId()).toBe(IDTest);
+      expect(bunchTest.th_get_items()[2].setContainer.mock.calls.length).toBe(1);
+      expect(bunchTest.th_get_items()[2].setContainer.mock.calls[0][0].getId()).toBe(IDTest);
       expect((bunchTestOld.remove as any).mock.calls.length).toBe(1);
       expect((bunchTestOld.remove as any).mock.calls[0][0]).toBe(objectToAdd.getId());
     });
 
-    test('set context when adding an item - dont remove if virtualContext option', () => {
+    test('set container when adding an item - dont remove if virtualContainer option', () => {
       const bunchTestOld = new DTBunchTest();
       bunchTestOld.th_set_items(generateMockedElements(6));
       objectToAdd = bunchTestOld.th_get_items()[5];
       jest.spyOn(bunchTestOld, 'remove').mockImplementation(() => {});
 
-      bunchTest.th_set_options({ virtualContext: true });
+      bunchTest.th_set_options({ virtualContainer: true });
       bunchTest.addAtIndex(objectToAdd, 2);
 
-      expect(bunchTest.th_get_items()[2].setContext.mock.calls.length).toBe(0);
+      expect(bunchTest.th_get_items()[2].setContainer.mock.calls.length).toBe(0);
       expect((bunchTestOld.remove as any).mock.calls.length).toBe(0);
     });
 
@@ -683,8 +687,6 @@ describe('class DYOToolsBunch', () => {
     };
 
     beforeEach(() => {
-      jest.spyOn(bunchTest, 'removeContext').mockImplementation(() => {});
-
       bunchTest.th_set_items(generateMockedElements(5));
     });
 
@@ -718,7 +720,7 @@ describe('class DYOToolsBunch', () => {
       checkAllItemsInBunch(bunchTest, 2);
     });
 
-    test('define context at undefined for removed items - default case', () => {
+    test('define container at undefined for removed items - default case', () => {
       const items = [
         bunchTest.th_get_items()[1],
         bunchTest.th_get_items()[2],
@@ -729,27 +731,27 @@ describe('class DYOToolsBunch', () => {
       items.push(bunchTest.th_get_items()[1]);
       bunchTest.removeMany([0, 1]);
 
-      expect(items[0].removeContext.mock.calls.length).toBe(1);
-      expect(items[1].removeContext.mock.calls.length).toBe(1);
-      expect(items[2].removeContext.mock.calls.length).toBe(1);
-      expect(items[3].removeContext.mock.calls.length).toBe(1);
+      expect(items[0].removeContainer.mock.calls.length).toBe(1);
+      expect(items[1].removeContainer.mock.calls.length).toBe(1);
+      expect(items[2].removeContainer.mock.calls.length).toBe(1);
+      expect(items[3].removeContainer.mock.calls.length).toBe(1);
     });
 
-    test('not change context for removed items - virtual context option', () => {
+    test('not change container for removed items - virtual container option', () => {
       const items = [
         bunchTest.th_get_items()[1],
         bunchTest.th_get_items()[2],
       ];
-      bunchTest.th_set_options({ virtualContext: true });
+      bunchTest.th_set_options({ virtualContainer: true });
       bunchTest.removeMany([`${MeldrineIdTest}-1`, `${MaydenaIdTest}-2`]);
       items.push(bunchTest.th_get_items()[0]);
       items.push(bunchTest.th_get_items()[1]);
       bunchTest.removeMany([0, 1]);
 
-      expect(items[0].removeContext.mock.calls.length).toBe(0);
-      expect(items[1].removeContext.mock.calls.length).toBe(0);
-      expect(items[2].removeContext.mock.calls.length).toBe(0);
-      expect(items[3].removeContext.mock.calls.length).toBe(0);
+      expect(items[0].removeContainer.mock.calls.length).toBe(0);
+      expect(items[1].removeContainer.mock.calls.length).toBe(0);
+      expect(items[2].removeContainer.mock.calls.length).toBe(0);
+      expect(items[3].removeContainer.mock.calls.length).toBe(0);
     });
   });
 
@@ -830,11 +832,11 @@ describe('class DYOToolsBunch', () => {
     });
 
     test('toObject output standard with owner', () => {
-      bunchTest.th_set_owner(new DTPlayerStub());
+      bunchTest.th_set_owner(OwnerTest);
 
       const toObjectBunch = bunchTest.toObject();
       expect(Object.keys(toObjectBunch)).toStrictEqual(['id', 'key', 'type', 'items', 'owner']);
-      expect(toObjectBunch.owner.toString()).toBe(toStringPlayerTest);
+      expect(toObjectBunch.owner).toBe(OwnerTest);
     });
 
     test('toObject output standard with owner and meta', () => {
@@ -842,7 +844,7 @@ describe('class DYOToolsBunch', () => {
         return this._meta;
       });
 
-      bunchTest.th_set_owner(new DTPlayerStub());
+      bunchTest.th_set_owner(OwnerTest);
       bunchTest.th_set_meta(BunchMetaData);
 
       const toObjectBunch = bunchTest.toObject();
@@ -886,10 +888,10 @@ describe('class DYOToolsBunch', () => {
 
     test('string output standard with items and owner', () => {
       bunchTest.th_set_items(generateMockedElements(5));
-      bunchTest.th_set_owner(new DTPlayerStub());
+      bunchTest.th_set_owner(OwnerTest);
 
       const toStringBunch = bunchTest.toString();
-      expect(toStringBunch).toBe(`Component ${KeyTest} - Type: Bunch - Owner: ${KeyPlayerTest} - Items: 5`);
+      expect(toStringBunch).toBe(`Component ${KeyTest} - Type: Bunch - Owner: ${OwnerTest} - Items: 5`);
     });
   });
 });

package/test/core/DTComponentPhysical.double.ts

@@ -1,6 +1,5 @@
 import {DTComponentPhysical} from "../../src";
 import {IMetaDataTest} from "./DTComponentWithMeta.double";
-import {DTPlayerStub} from "./DTPlayer.double";
 
 /******************** STUB PROPERTIES CONSTANTS
  * Fixed properties to use with double classes, avoid auto generated and easy checking on test
@@ -10,6 +9,7 @@ export const KeyTest = "DTComponentPhysical-key-1234567";
 export const ComponentTypeTest = "DTComponentPhysical-componentType-test";
 export const ToObjectTest = { type: "DTComponentPhysical-test-toObject" };
 export const ToStringTest = "DTComponentPhysical-test-toString";
+export const OwnerTest = "owner-12345";
 
 /******************** STUB ABSTRACT IMPLEMENTATION
  * Implementation of abstract component class for tests
@@ -38,11 +38,11 @@ export class DTComponentPhysicalImpl extends DTComponentPhysical<IMetaDataTest>
  * Providing methods to property access and other facilities, in order to avoid using class methods
  * *****/
 export class DTComponentPhysicalTest extends DTComponentPhysicalImpl {
-    th_get_owner(): DTPlayerStub {
+    th_get_owner(): string {
         return this._owner;
     }
 
-    th_set_owner(owner: DTPlayerStub): void {
+    th_set_owner(owner: string): void {
         this._owner = owner;
     }
 }

package/test/core/DTComponentPhysical.spec.ts

@@ -1,7 +1,6 @@
-import {beforeEach, describe, jest, test} from '@jest/globals';
-import {DTPlayerStub, IDTest as IDPlayerTest,} from './DTPlayer.double';
+import {beforeEach, describe, expect, jest, test} from '@jest/globals';
 import {mockOverriddenMethods} from "./DTComponentWithMeta.double";
-import {DTComponentPhysicalTest} from './DTComponentPhysical.double';
+import {DTComponentPhysicalTest, OwnerTest} from './DTComponentPhysical.double';
 import {DTComponentPhysical, DTComponentWithMeta} from "../../src";
 
 /******************** MOCK DEPENDENCIES
@@ -30,32 +29,47 @@ describe('class DYOToolsComponentPhysical', () => {
     });
   });
 
+  describe('getManager()', () => {
+    test('call get context with manager accessor', () => {
+      componentPhysicalTest.getManager();
+
+      expect((componentPhysicalTest.getContext as any).mock.calls.length).toBe(1);
+      expect((componentPhysicalTest.getContext as any).mock.calls[0][0]).toBe('manager');
+    });
+  });
+
+  describe('getMaster()', () => {
+    test('call get context with master accessor', () => {
+      componentPhysicalTest.getMaster();
+
+      expect((componentPhysicalTest.getContext as any).mock.calls.length).toBe(1);
+      expect((componentPhysicalTest.getContext as any).mock.calls[0][0]).toBe('master');
+    });
+  });
+
   describe('getOwner()', () => {
     test('return empty owner by default', () => {
       expect(componentPhysicalTest.getOwner()).toBeUndefined();
     });
 
     test('return owner when set', () => {
-      const owner = new DTPlayerStub();
-      componentPhysicalTest.th_set_owner(owner);
+      componentPhysicalTest.th_set_owner(OwnerTest);
 
-      expect(componentPhysicalTest.getOwner().getId()).toBe(IDPlayerTest);
+      expect(componentPhysicalTest.getOwner()).toBe(OwnerTest);
     });
   });
 
   describe('setOwner()', () => {
     test('add a new owner', () => {
-      const owner = new DTPlayerStub();
-      componentPhysicalTest.setOwner(owner);
+      componentPhysicalTest.setOwner(OwnerTest);
 
-      expect(componentPhysicalTest.th_get_owner().getId()).toBe(IDPlayerTest);
+      expect(componentPhysicalTest.th_get_owner()).toBe(OwnerTest);
     });
   });
 
   describe('removeOwner()', () => {
     test('remove the current Owner', () => {
-      const owner = new DTPlayerStub();
-      componentPhysicalTest.th_set_owner(owner);
+      componentPhysicalTest.th_set_owner(OwnerTest);
 
       componentPhysicalTest.removeOwner();
       expect(componentPhysicalTest.th_get_owner()).toBeUndefined();

package/test/core/DTElement.double.ts

@@ -1,6 +1,5 @@
-import { DTElement } from '../../src';
-import { IMetaDataTest } from './DTComponentWithMeta.double';
-import { DTPlayerStub } from './DTPlayer.double';
+import {DTBunch, DTElement} from '../../src';
+import {IMetaDataTest} from './DTComponentWithMeta.double';
 
 /** ****************** STUB PROPERTIES CONSTANTS
  * Fixed properties to use with double classes, avoid auto generated and easy checking on test
@@ -8,6 +7,7 @@ import { DTPlayerStub } from './DTPlayer.double';
 // Global constants
 export const IDTest = 'DTElement-id-1234567';
 export const KeyTest = 'DTElement-key-1234567';
+export const DomainTest = 'DTElement-domain-test';
 
 // Specific elements constants
 export const HaileiIdTest = 'DTElement-id-Hailei';
@@ -51,17 +51,33 @@ export class DTElementTest extends DTElement<IMetaDataTest> {
     return this._componentType;
   }
 
-  th_get_owner(): DTPlayerStub {
+  th_get_domain(): string {
+    return this._domain;
+  }
+
+  th_set_domain(domain: string): void {
+    this._domain = domain;
+  }
+
+  th_get_owner(): string {
     return this._owner;
   }
 
-  th_set_owner(owner: DTPlayerStub): void {
+  th_set_owner(owner: string): void {
     this._owner = owner;
   }
 
   th_set_meta(meta: IMetaDataTest): void {
     this._meta = meta;
   }
+
+  th_get_container(): DTBunch<any> | undefined {
+    return this._container;
+  }
+
+  th_set_container(container: DTBunch<any>): void {
+    this._container = container;
+  }
 }
 /** ****************** STUB CLASS
  * Stub class, for using in other component

package/test/core/DTElement.spec.ts

@@ -1,9 +1,9 @@
 import {beforeEach, describe, expect, jest, test} from '@jest/globals';
-import {DTPlayerStub, KeyTest as KeyPlayerTest, toStringTest as toStringPlayerTest,} from './DTPlayer.double';
-import {DTElementTest, IDTest, KeyTest} from './DTElement.double';
+import {DomainTest, DTElementTest, IDTest, KeyTest} from './DTElement.double';
 import {MeldrineMetaData} from './DTComponentWithMeta.double';
 import {DTComponentPhysical, DTElement} from "../../src";
-import {mockOverriddenMethods} from "./DTComponentPhysical.double";
+import {mockOverriddenMethods, OwnerTest} from "./DTComponentPhysical.double";
+import {DTBunchStub, IDTest as bunchIdTest} from "./DTBunch.double";
 
 /******************** MOCK DEPENDENCIES
  * All Dependencies used by the component are mocked with Jest
@@ -11,6 +11,7 @@ import {mockOverriddenMethods} from "./DTComponentPhysical.double";
 jest.mock('../../src/core/DTComponent');
 jest.mock('../../src/core/DTComponentWithMeta');
 jest.mock('../../src/core/DTComponentPhysical');
+jest.mock('../../src/core/DTBunch');
 // Add specific mock for inherited methods to have a basic implementation
 mockOverriddenMethods(DTComponentPhysical);
 
@@ -38,6 +39,41 @@ describe('class DYOToolsElement', () => {
     });
   });
 
+  describe('getContainer()', () => {
+    test('return undefined if no container - default case', () => {
+      expect(elementTest.getContainer()).toBeUndefined();
+    });
+
+    test('return container', () => {
+      const container = new DTBunchStub();
+      elementTest.th_set_container(container);
+
+      expect(elementTest.getContainer()).toBeDefined();
+      expect(elementTest.getContainer().getId()).toStrictEqual(bunchIdTest);
+    });
+  });
+
+  describe('setContainer()', () => {
+    test('set a new container for element', () => {
+      const container = new DTBunchStub();
+
+      elementTest.setContainer(container);
+
+      expect(elementTest.th_get_container()).toBeDefined();
+      expect(elementTest.th_get_container().getId()).toStrictEqual(bunchIdTest);
+    });
+  });
+
+  describe('removeContainer()', () => {
+    test('remove the current container', () => {
+      const bunchContainer = new DTBunchStub();
+      elementTest.th_set_container(bunchContainer);
+
+      elementTest.removeContainer();
+      expect(elementTest.th_get_container()).toBeUndefined();
+    });
+  });
+
   describe('copy()', () => {
     // @see copy.spec.ts for unit tests about copy method
   })
@@ -58,19 +94,19 @@ describe('class DYOToolsElement', () => {
     });
 
     test('toObject output standard with owner', () => {
-      elementTest.th_set_owner(new DTPlayerStub());
+      elementTest.th_set_owner(OwnerTest);
 
       const toObjectElement = elementTest.toObject();
 
       expect(Object.keys(toObjectElement)).toStrictEqual(['id', 'key', 'type', 'owner']);
-      expect(toObjectElement.owner.toString()).toBe(toStringPlayerTest);
+      expect(toObjectElement.owner).toBe(OwnerTest);
     });
 
     test('toObject output standard with owner and meta', () => {
       jest.spyOn(elementTest, 'getManyMeta').mockImplementation(function () {
         return this._meta;
       });
-      elementTest.th_set_owner(new DTPlayerStub());
+      elementTest.th_set_owner(OwnerTest);
       elementTest.th_set_meta(MeldrineMetaData);
 
       const toObjectElement = elementTest.toObject();
@@ -91,12 +127,20 @@ describe('class DYOToolsElement', () => {
       expect(toStringElement).toBe(`Component ${KeyTest} - Type: Element`);
     });
 
+    test('string output standard with domain', () => {
+      elementTest.th_set_domain(DomainTest);
+
+      const toStringElement = elementTest.toString();
+
+      expect(toStringElement).toBe(`Component ${DomainTest} ${KeyTest} - Type: Element`);
+    });
+
     test('string output standard with owner', () => {
-      elementTest.th_set_owner(new DTPlayerStub());
+      elementTest.th_set_owner(OwnerTest);
 
       const toStringElement = elementTest.toString();
 
-      expect(toStringElement).toBe(`Component ${KeyTest} - Type: Element - Owner: ${KeyPlayerTest}`);
+      expect(toStringElement).toBe(`Component ${KeyTest} - Type: Element - Owner: ${OwnerTest}`);
     });
   });
 });

package/test/core/DTError.double.ts

@@ -1,7 +1,7 @@
 import {DTError} from '../../src';
 import {expect} from "@jest/globals";
-import {MockedFunction} from "ts-jest";
 import DYOToolsComponent from "../../src/core/DTComponent";
+import MockedFunction = jest.MockedFunction;
 
 /******************** STUB PROPERTIES CONSTANTS
  * Fixed properties to use with double classes, avoid auto generated and easy checking on test

package/test/core/DTManager.double.ts

@@ -1,5 +1,5 @@
-import { expect } from '@jest/globals';
-import { DTManager, DTElement } from '../../src';
+import {expect} from '@jest/globals';
+import {DTElement, DTManager} from '../../src';
 import {
   bunch1IdTest,
   bunch1toObjectTest,
@@ -12,7 +12,7 @@ import {
   DTBunchTest,
   generateMockedElements,
 } from './DTBunch.double';
-import { DTAcceptedMetaData, DTManagerItemsType, DTManagerOptions } from '../../src/types';
+import {DTAcceptedMetaData, DTManagerItemsType, DTManagerOptions, DTManagerToObject} from '../../src/types';
 import DYOFinder from '../../src/libs/DYOFinder';
 
 /** ****************** STUB PROPERTIES CONSTANTS
@@ -23,6 +23,22 @@ export const KeyTest = 'DTManager-key-1234567';
 export const DomainTest = 'DTManager-domain-test';
 export const ScopesTest = ['DTManager-scope-test1', 'DTManager-scope-test2'];
 
+// Specific Manager constants
+export const manager1IDTest = `${IDTest}_1`;
+export const manager1KeyTest = `${KeyTest}_1`;
+
+export const manager1ToObject: DTManagerToObject = {
+  id: manager1IDTest,
+  key: manager1KeyTest,
+  type: 'manager',
+  items: [
+    {
+      scope: 'default',
+      ...bunch1toObjectTest
+    }
+  ]
+}
+
 /** ****************** 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
@@ -48,6 +64,14 @@ export class DTManagerTest extends DTManager<DTElement<DTAcceptedMetaData>> {
     return this._componentType;
   }
 
+  th_get_domain(): string {
+    return this._domain;
+  }
+
+  th_set_domain(domain: string): void {
+    this._domain = domain;
+  }
+
   th_get_items(): any {
     return this._items;
   }
@@ -159,9 +183,9 @@ export function populateManager(manager: DTManagerTest): DTManagerTest {
   const bunch3 = new DTBunchTest();
   bunch3.th_set_items([]);
   bunch3.th_set_id(bunch3IdTest);
-  bunch3.th_set_options({ virtualContext: true });
+  bunch3.th_set_options({ virtualContainer: true });
   jest.spyOn(bunch3, 'getId').mockImplementation(() => bunch3IdTest);
-  jest.spyOn(bunch3, 'getOptions').mockImplementation(() => ({ ...defaultOptions, virtualContext: true }));
+  jest.spyOn(bunch3, 'getOptions').mockImplementation(() => ({ ...defaultOptions, virtualContainer: true }));
   jest.spyOn(bunch3, 'getAll').mockImplementation(function () { return this._items; });
   jest.spyOn(bunch3, 'toObject').mockImplementation(() => bunch3toObjectTest);