dyo-tools 0.3.2 → 0.4.0

package/test/core/DTBunch.spec.ts

@@ -1,5 +1,5 @@
-import { afterEach, beforeEach, describe, expect, jest, test, } from '@jest/globals';
-import { defaultOptions, DTBunchStub, DTBunchTest, generateMockedElements, IDTest, KeyTest, } from './DTBunch.double';
+import {afterEach, beforeEach, describe, expect, jest, test,} from '@jest/globals';
+import {DTBunchStub, DTBunchTest, generateStubElements, IDTest, KeyTest} from './DTBunch.double';
 import {
   DTElementStub,
   HaileiIdTest,
@@ -20,38 +20,19 @@ import {
   YssaliaKeyTest,
   YssaliaToObjectTest,
 } from './DTElement.double';
-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 { checkCallForMockedDTError, CodeTest as DTErrorCodeTest, DTErrorStub } from './DTError.double';
-import DYOToolsError from '../../src/core/DTError';
-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;
-
-/** ****************** MOCK DEPENDENCIES
- * All Dependencies used by the component are mocked with Jest
- * **** */
-jest.mock('../../src/core/DTElement');
-jest.mock('../../src/core/DTManager');
-jest.mock('../../src/core/DTError');
-jest.mock('../../src/core/DTComponent');
-jest.mock('../../src/core/DTComponentWithMeta');
-jest.mock('../../src/core/DTComponentPhysical');
-jest.mock('../../src/libs/DYOFinder');
-// Add specific mock for inherited methods to have a basic implementation
-mockOverriddenMethods(DTComponentPhysical);
+import {DTBunch, DTComponentPhysical, DTError} from '../../src';
+import {BunchMetaData, HaileiMetaData} from './DTComponentWithMeta.double';
+import {DTBunchOptions, FilterOperatorType} from '../../src/types';
+import {CodeTest as DTErrorCodeTest, DTErrorStub} from './DTError.double';
+import {OwnerTest} from './DTComponentPhysical.double';
+import {DTManagerStub, IDTest as managerIDTest} from './DTManager.double';
 
 /** *********************** TESTS SUITES ****************************** */
-describe('class DYOToolsBunch', () => {
+describe('class DTBunch', () => {
   let bunchTest: DTBunchTest;
 
   beforeEach(() => {
     bunchTest = new DTBunchTest();
-    bunchTest.th_set_options(defaultOptions);
   });
 
   afterEach(() => {
@@ -78,22 +59,15 @@ describe('class DYOToolsBunch', () => {
     });
 
     test('creation simple with key', () => {
-      const newBunch = new DTBunchTest(KeyTest);
-      const parentConstructorMock = (DTComponentPhysical.prototype.constructor as MockedFunction<(key: string, options: any) => void>).mock;
+      const newBunch = new DTBunchTest();
 
-      expect(parentConstructorMock.calls[0][0]).toBe(KeyTest);
-      expect(parentConstructorMock.calls[0][1]).toStrictEqual(defaultOptions);
-      expect(newBunch.th_get_items()).toStrictEqual([]);
-
-      // Finder initialization
-      expect((newBunch.th_get_finder() as any).constructor.mock.calls.length).toBe(1);
-      expect((newBunch.th_get_finder() as any).constructor.mock.calls[0][0]).toStrictEqual(newBunch);
-      expect((newBunch.th_get_finder() as any).constructor.mock.calls[0][1]).toStrictEqual(componentBunchDefaultFinderConfiguration);
+      expect(newBunch.getAll()).toStrictEqual([]);
     });
 
     test('creation with items', () => {
-      new DTBunchTest(KeyTest, generateMockedElements(3));
-      const mockedAddMany = DTBunch.prototype.addMany as MockedFunction<(items: Array<Mocked<DYOToolsElement<IMetaDataTest>>>) => void>;
+      const elements: DTElementStub[] = generateStubElements(3);
+      const newBunch = new DTBunchTest(IDTest, KeyTest, elements);
+      const mockedAddMany = DTBunch.prototype.addMany as any;
 
       expect(mockedAddMany.mock.calls.length).toBe(1);
       expect(mockedAddMany.mock.calls[0][0].length).toBe(3);
@@ -108,24 +82,23 @@ describe('class DYOToolsBunch', () => {
         uniqueKey: true,
         inheritOwner: true,
       };
-      const newBunch = new DTBunchTest(KeyTest, [], testOptions);
-      const parentConstructorMock = (DTComponentPhysical.prototype.constructor as MockedFunction<(key: string, options: any) => void>).mock;
+      const newBunch = new DTBunchTest(IDTest, KeyTest, [], testOptions);
 
-      expect(parentConstructorMock.calls[0][0]).toBe(KeyTest);
-      expect(parentConstructorMock.calls[0][1]).toStrictEqual({
+      expect(newBunch.getOptions()).toStrictEqual({
         errors: true,
+        syncId: undefined,
         uniqueKey: true,
         inheritOwner: true,
         replaceIndex: false,
         virtualContainer: false,
       });
-      expect(newBunch.th_get_items()).toStrictEqual([]);
+      expect(newBunch.getAll()).toStrictEqual([]);
     });
   });
 
   describe('_componentType', () => {
     test('componentType must be "bunch"', () => {
-      expect(bunchTest.th_get_componentType()).toBe('bunch');
+      expect(bunchTest.getComponentType()).toBe('bunch');
     });
   });
 
@@ -224,57 +197,41 @@ describe('class DYOToolsBunch', () => {
     });
 
     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 newBunch = new DTBunchTest(IDTest, KeyTest, generateStubElements(1), { inheritOwner: false});
 
-      bunchTest.setOwner(OwnerTest);
+      newBunch.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);
-      expect(bunchTest.th_get_items()[2].setOwner.mock.calls.length).toBe(0);
+      expect(newBunch.get(0).getOwner()).toBeUndefined();
     });
 
     test('add a new owner - updating elements owner when inheritOwner = true', () => {
-      bunchTest.th_set_options({ inheritOwner: true });
-      bunchTest.th_set_items(generateMockedElements(3));
+      const newBunch = new DTBunchTest(IDTest, KeyTest, generateStubElements(1), { inheritOwner: true});
 
-      bunchTest.setOwner(OwnerTest);
+      newBunch.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]).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]).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]).toBe(OwnerTest);
+      expect(newBunch.get(0).getOwner()).toBe(OwnerTest);
     });
   });
 
   describe('removeOwner()', () => {
     test('remove current Owner - not updating elements owner when inheritOwner = false', () => {
-      bunchTest.th_set_options({ inheritOwner: true });
-      bunchTest.th_set_items(generateMockedElements(2));
+      const newBunch = new DTBunchTest(IDTest, KeyTest, generateStubElements(1, OwnerTest), { inheritOwner: false}, OwnerTest);
+      newBunch.removeOwner();
 
-      bunchTest.th_set_options({ inheritOwner: false });
-      bunchTest.removeOwner();
-
-      expect(bunchTest.th_get_items()[0].removeOwner.mock.calls.length).toBe(0);
-      expect(bunchTest.th_get_items()[1].removeOwner.mock.calls.length).toBe(0);
+      expect(newBunch.get(0).getOwner()).toBe(OwnerTest);
     });
 
     test('remove current Owner - updating elements owner when inheritOwner = true', () => {
-      bunchTest.th_set_options({ inheritOwner: true });
-      bunchTest.th_set_items(generateMockedElements(2));
-
-      bunchTest.removeOwner();
+      const newBunch = new DTBunchTest(IDTest, KeyTest, generateStubElements(1, OwnerTest), { inheritOwner: true}, OwnerTest);
+      newBunch.removeOwner();
 
-      expect(bunchTest.th_get_items()[0].removeOwner.mock.calls.length).toBe(1);
-      expect(bunchTest.th_get_items()[1].removeOwner.mock.calls.length).toBe(1);
+      expect(newBunch.get(0).getOwner()).toBeUndefined();
     });
   });
 
   describe('get()', () => {
     beforeEach(() => {
-      bunchTest.th_set_items(generateMockedElements(5));
+      bunchTest = new DTBunchTest(IDTest, KeyTest, generateStubElements(5))
     });
 
     test('return an item by its id', () => {
@@ -306,7 +263,7 @@ describe('class DYOToolsBunch', () => {
     });
 
     test('return all items array', () => {
-      bunchTest.th_set_items(generateMockedElements(5));
+      bunchTest = new DTBunchTest(IDTest, KeyTest, generateStubElements(5));
 
       expect(bunchTest.getAll()[0].getKey()).toBe(HaileiKeyTest);
       expect(bunchTest.getAll()[1].getKey()).toBe(MeldrineKeyTest);
@@ -318,7 +275,7 @@ describe('class DYOToolsBunch', () => {
 
   describe('indexOf()', () => {
     beforeEach(() => {
-      bunchTest.th_set_items(generateMockedElements(5));
+      bunchTest = new DTBunchTest(IDTest, KeyTest, generateStubElements(5))
     });
 
     test('return index of an item by id', () => {
@@ -336,214 +293,191 @@ describe('class DYOToolsBunch', () => {
     let objectsToAdd;
 
     beforeEach(() => {
-      jest.spyOn(bunchTest, 'getId').mockReturnValue(IDTest);
-
-      bunchTest.th_set_items(generateMockedElements(5));
+      bunchTest = new DTBunchTest(IDTest, KeyTest, generateStubElements(5))
 
-      objectsToAdd = generateMockedElements(6);
+      objectsToAdd = generateStubElements(6);
       objectToAdd = objectsToAdd[5];
-      jest.spyOn(bunchTest, 'find').mockReturnValue([objectToAdd]);
     });
 
     test('add a new item at last index - simple case', () => {
       bunchTest.addAtIndex(objectToAdd, 5);
 
-      expect(bunchTest.th_get_items()[5].getId()).toBe(objectToAdd.getId());
+      expect(bunchTest.get(5).getId()).toBe(objectToAdd.getId());
     });
 
     test('add a new item at specified index and reindex - default case', () => {
       bunchTest.addAtIndex(objectToAdd, 2);
 
-      expect(bunchTest.th_get_items()[2].getId()).toBe(objectToAdd.getId());
-      expect(bunchTest.th_get_items()[3].getId()).toBe(`${MaydenaIdTest}-2`);
-      expect(bunchTest.th_get_items()[4].getId()).toBe(`${IldressIdTest}-3`);
-      expect(bunchTest.th_get_items()[5].getId()).toBe(`${YssaliaIdTest}-4`);
+      expect(bunchTest.get(2).getId()).toBe(objectToAdd.getId());
+      expect(bunchTest.get(3).getId()).toBe(`${MaydenaIdTest}-2`);
+      expect(bunchTest.get(4).getId()).toBe(`${IldressIdTest}-3`);
+      expect(bunchTest.get(5).getId()).toBe(`${YssaliaIdTest}-4`);
     });
 
     test('add a new item at specified index and replace - replace option', () => {
       bunchTest.addAtIndex(objectToAdd, 2, { replaceIndex: true });
 
-      expect(bunchTest.th_get_items()[2].getId()).toBe(objectToAdd.getId());
-      expect(bunchTest.th_get_items()[3].getId()).toBe(`${IldressIdTest}-3`);
-      expect(bunchTest.th_get_items()[4].getId()).toBe(`${YssaliaIdTest}-4`);
-      expect(bunchTest.th_get_items()[5]).toBeUndefined();
+      expect(bunchTest.get(2).getId()).toBe(objectToAdd.getId());
+      expect(bunchTest.get(3).getId()).toBe(`${IldressIdTest}-3`);
+      expect(bunchTest.get(4).getId()).toBe(`${YssaliaIdTest}-4`);
+      expect(bunchTest.get(5)).toBeUndefined();
     });
 
     test('add a new item at lower index', () => {
       bunchTest.addAtIndex(objectToAdd, -11);
 
-      expect(bunchTest.th_get_items()[0].getId()).toBe(objectToAdd.getId());
-      expect(bunchTest.th_get_items()[1].getId()).toBe(`${HaileiIdTest}-0`);
+      expect(bunchTest.get(0).getId()).toBe(objectToAdd.getId());
+      expect(bunchTest.get(1).getId()).toBe(`${HaileiIdTest}-0`);
     });
 
     test('add a new item at greater index', () => {
       bunchTest.addAtIndex(objectToAdd, 11);
 
-      expect(bunchTest.th_get_items()[5].getId()).toBe(objectToAdd.getId());
-      expect(bunchTest.th_get_items()[6]).toBeUndefined();
+      expect(bunchTest.get(5).getId()).toBe(objectToAdd.getId());
+      expect(bunchTest.get(6)).toBeUndefined();
     });
 
     test('trigger conflict when adding two same ids - parent triggerError', () => {
-      const mockedTriggerError = DTBunch.prototype.triggerError as MockedFunction<(error: DYOToolsError) => void>;
-
-      bunchTest.addAtIndex(objectsToAdd[0], 2);
+      let errorThrown: DTError | undefined;
+      try {
+        bunchTest.addAtIndex(objectsToAdd[0], 2);
+      } catch(error) {
+        errorThrown = error;
+      }
 
-      expect(mockedTriggerError.mock.calls.length).toBe(1);
-      checkCallForMockedDTError(
-        'id_conflict',
-        'Element with same id already exists in the bunch',
-        IDTest,
-        objectsToAdd[0].getId(),
-      );
+      expect(errorThrown).toBeDefined();
+      if (errorThrown) {
+        expect(errorThrown.getCode()).toBe('id_conflict');
+        expect(errorThrown.getMessage()).toBe('Element with same id already exists in the bunch');
+        expect(errorThrown.getInitiator().getId()).toBe(IDTest);
+        expect(errorThrown.getConvicted().getId()).toBe(objectsToAdd[0].getId());
+      }
     });
 
     test('no conflict when adding two same keys - default case', () => {
-      const mockedTriggerError = DTBunch.prototype.triggerError as MockedFunction<(error: DYOToolsError) => void>;
-
-      bunchTest.addAtIndex(objectToAdd, 2);
+      let errorThrown: DTError | undefined;
+      try {
+        bunchTest.addAtIndex(objectToAdd, 2);
+      } catch(error) {
+        errorThrown = error;
+      }
 
-      expect(mockedTriggerError.mock.calls.length).toBe(0);
-      expect((bunchTest.find as any).mock.calls.length).toBe(0);
-      expect(bunchTest.th_get_items()[0].getKey()).toBe(HaileiKeyTest);
-      expect(bunchTest.th_get_items()[2].getKey()).toBe(HaileiKeyTest);
+      expect(errorThrown).toBeUndefined();
+      expect(bunchTest.get(0).getKey()).toBe(HaileiKeyTest);
+      expect(bunchTest.get(2).getKey()).toBe(HaileiKeyTest);
     });
 
     test('trigger conflict when adding two same keys - uniqueKey option and parent triggerError', () => {
-      const mockedTriggerError = DTBunch.prototype.triggerError as MockedFunction<(error: DYOToolsError) => void>;
-
-      bunchTest.addAtIndex(objectToAdd, 2, { uniqueKey: true });
+      let errorThrown: DTError | undefined;
+      try {
+        bunchTest.addAtIndex(objectToAdd, 2, { uniqueKey: true });
+      } catch(error) {
+        errorThrown = error;
+      }
 
-      expect(mockedTriggerError.mock.calls.length).toBe(1);
-      checkCallForMockedDTError(
-        'key_conflict',
-        'Element with same key already exists in the bunch',
-        IDTest,
-        objectToAdd.getId(),
-      );
-      expect((bunchTest.find as any).mock.calls.length).toBe(1);
-      expect((bunchTest.find as any).mock.calls[0][0]).toStrictEqual({ key: { $eq: objectToAdd.getKey() } });
-      expect(bunchTest.th_get_items()[2].getId()).toBe(`${MaydenaIdTest}-2`);
+      expect(errorThrown).toBeDefined();
+      if (errorThrown) {
+        expect(errorThrown.getCode()).toBe('key_conflict');
+        expect(errorThrown.getMessage()).toBe('Element with same key already exists in the bunch');
+        expect(errorThrown.getInitiator().getKey()).toBe(KeyTest);
+        expect(errorThrown.getConvicted().getId()).toBe(objectToAdd.getId());
+      }
     });
 
     test('not inherit owner when adding an item - default case', () => {
-      bunchTest.th_set_owner(OwnerTest);
+      bunchTest.setOwner(OwnerTest);
 
       bunchTest.addAtIndex(objectToAdd, 2);
 
-      expect(bunchTest.th_get_owner()).toBe(OwnerTest);
-      expect(objectToAdd.setOwner.mock.calls.length).toBe(0);
+      expect(bunchTest.getOwner()).toBe(OwnerTest);
+      expect(objectToAdd.getOwner()).toBeUndefined();
     });
 
     test('inherit owner when adding an item - inheritOwner option', () => {
-      bunchTest.th_set_owner(OwnerTest);
+      bunchTest.setOwner(OwnerTest);
 
       bunchTest.addAtIndex(objectToAdd, 2, { inheritOwner: true });
 
-      expect(bunchTest.th_get_owner()).toBe(OwnerTest);
-      expect(objectToAdd.setOwner.mock.calls.length).toBe(1);
-      expect(objectToAdd.setOwner.mock.calls[0][0]).toBe(OwnerTest);
+      expect(bunchTest.getOwner()).toBe(OwnerTest);
+      expect(objectToAdd.getOwner()).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);
+      expect(bunchTest.get(2).getContext()).toBeUndefined();
     });
 
     test('set context with parent manager when adding an item', () => {
       const manager = new DTManagerStub();
-      bunchTest.th_set_context(manager);
+      bunchTest.setContext(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(managerIDTest);
+      expect(bunchTest.get(2).getContext()?.getId()).toBe(managerIDTest);
     });
 
     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);
+      expect(bunchTest.get(2).getContainer()?.getId()).toBe(IDTest);
     });
 
     test('not set container when adding an item - virtualContainer option', () => {
-      bunchTest.th_set_options({ virtualContainer: true });
+      bunchTest = new DTBunchTest(IDTest, KeyTest, generateStubElements(5), { virtualContainer: true });
 
       bunchTest.addAtIndex(objectToAdd, 2);
 
-      expect(bunchTest.th_get_items()[2].setContainer.mock.calls.length).toBe(0);
+      expect(bunchTest.get(2).getContainer()).toBeUndefined();
     });
 
     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];
+      const bunchTestOld = new DTBunchTest(IDTest + "_old", KeyTest, generateStubElements(6));
+      objectToAdd = bunchTestOld.get(5);
       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].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());
+      expect(objectToAdd.getContainer()?.getId()).toBe(IDTest);
+      expect(bunchTestOld.get(5)).toBeUndefined();
     });
 
     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(() => {});
+      const bunchTestOld = new DTBunchTest(IDTest + "_old", KeyTest, generateStubElements(6), { virtualContainer: true });
+      objectToAdd = bunchTestOld.get(5);
 
-      bunchTest.th_set_options({ virtualContainer: true });
       bunchTest.addAtIndex(objectToAdd, 2);
 
-      expect(bunchTest.th_get_items()[2].setContainer.mock.calls.length).toBe(0);
-      expect((bunchTestOld.remove as any).mock.calls.length).toBe(0);
+      expect(objectToAdd.getContainer()?.getId()).toBe(IDTest);
+      expect(bunchTestOld.get(5)?.getId()).toBe(objectToAdd.getId());
     });
 
     test('manager context - add item into the manager library', () => {
       const managerTest = new DTManagerStub();
-      jest.spyOn(bunchTest, 'getContext').mockImplementation(
-        (contextType) => contextType === 'manager' && managerTest,
-      );
-      jest.spyOn(managerTest, 'getLibrary').mockImplementation(() => managerTest.th_get_library());
-      jest.spyOn(managerTest.th_get_library(), 'add');
+      bunchTest.setContext(managerTest);
 
       bunchTest.addAtIndex(objectToAdd, 5);
 
-      expect((managerTest.th_get_library().add as any).mock.calls.length).toBe(1);
-      expect((managerTest.th_get_library().add as any).mock.calls[0][0]).toStrictEqual(objectToAdd);
+      expect(managerTest.getLibrary().get(objectToAdd.getId())).toBeDefined();
     });
 
     test('manager context - not add existing item into the manager library', () => {
       const managerTest = new DTManagerStub();
-      jest.spyOn(bunchTest, 'getContext').mockImplementation(
-        (contextType) => contextType === 'manager' && managerTest,
-      );
-      jest.spyOn(managerTest, 'getLibrary').mockImplementation(() => managerTest.th_get_library());
-      jest.spyOn(managerTest.th_get_library(), 'add');
-      managerTest.th_get_library().th_set_items([objectToAdd]);
+      bunchTest.setContext(managerTest);
+      managerTest.getLibrary().add(objectToAdd);
 
       bunchTest.addAtIndex(objectToAdd, 5);
 
-      expect((managerTest.th_get_library().add as any).mock.calls.length).toBe(0);
+      expect(managerTest.getLibrary().getAll().length).toBe(1);
     });
 
     test('manager context - not add item into the manager if the caller is the library', () => {
       const managerTest = new DTManagerStub();
-      jest.spyOn(bunchTest, 'getContext').mockImplementation(
-        (contextType) => contextType === 'manager' && managerTest,
-      );
-      jest.spyOn(managerTest, 'getLibrary').mockImplementation(() => managerTest.th_get_library());
-      jest.spyOn(managerTest.th_get_library(), 'add');
+      bunchTest.setContext(managerTest);
 
-      managerTest.th_get_library().addAtIndex(objectToAdd, 5);
+      managerTest.getLibrary().addAtIndex(objectToAdd, 5);
 
-      expect((managerTest.th_get_library().add as any).mock.calls.length).toBe(0);
+      expect(managerTest.getLibrary().getAll().length).toBe(1);
     });
   });
 
@@ -552,11 +486,10 @@ describe('class DYOToolsBunch', () => {
     let objectToAdd;
 
     beforeEach(() => {
+      bunchTest = new DTBunchTest(IDTest, KeyTest, generateStubElements(5));
       jest.spyOn(bunchTest, 'addAtIndex').mockImplementation(() => {});
 
-      bunchTest.th_set_items(generateMockedElements(5));
-
-      objectsToAdd = generateMockedElements(6);
+      objectsToAdd = generateStubElements(6);
       objectToAdd = objectsToAdd[5];
     });
 
@@ -579,11 +512,10 @@ describe('class DYOToolsBunch', () => {
     let itemLibrary;
 
     beforeEach(() => {
+      bunchTest = new DTBunchTest(IDTest, KeyTest, generateStubElements(5));
       jest.spyOn(bunchTest, 'addAtIndex').mockImplementation(() => {});
 
-      bunchTest.th_set_items(generateMockedElements(5));
-
-      itemLibrary = generateMockedElements(8);
+      itemLibrary = generateStubElements(8);
       itemsToAdd = [itemLibrary[5], itemLibrary[6], itemLibrary[7]];
     });
 
@@ -628,7 +560,6 @@ describe('class DYOToolsBunch', () => {
       }
 
       expect(errorThrown).toBeDefined();
-      expect(DTErrorStub).toHaveBeenCalled();
       expect(errorThrown.getCode()).toBe(DTErrorCodeTest);
       expect((bunchTest.addAtIndex as any).mock.calls.length).toBe(1);
       expect((bunchTest.addAtIndex as any).mock.calls[0][0].getId()).toBe(itemsToAdd[0].getId());
@@ -649,7 +580,6 @@ describe('class DYOToolsBunch', () => {
       bunchTest.addManyAtIndex(itemsToAdd, indexToAdd, { errors: true });
 
       expect(errors.length).toBe(2);
-      expect(DTErrorStub).toHaveBeenCalled();
       expect((bunchTest.addAtIndex as any).mock.calls.length).toBe(3);
       expect((bunchTest.addAtIndex as any).mock.calls[0][0].getId()).toBe(itemsToAdd[0].getId());
       expect((bunchTest.addAtIndex as any).mock.calls[1][0].getId()).toBe(itemsToAdd[1].getId());
@@ -662,11 +592,10 @@ describe('class DYOToolsBunch', () => {
     let itemLibrary;
 
     beforeEach(() => {
+      bunchTest = new DTBunchTest(IDTest, KeyTest, generateStubElements(5));
       jest.spyOn(bunchTest, 'addManyAtIndex').mockImplementation(() => {});
 
-      bunchTest.th_set_items(generateMockedElements(5));
-
-      itemLibrary = generateMockedElements(8);
+      itemLibrary = generateStubElements(8);
       itemsToAdd = [itemLibrary[5], itemLibrary[6], itemLibrary[7]];
     });
 
@@ -692,15 +621,15 @@ describe('class DYOToolsBunch', () => {
     const checkAllItemsInBunch = (bunch: DTBunchTest, itemRemoved = 3) => {
       const sup = itemRemoved;
       expect(bunchTest.getAll().length).toBe(5 - sup);
-      expect(bunchTest.th_get_items()[0].getId()).toBe(`${HaileiIdTest}-0`);
-      itemRemoved < 1 && expect(bunchTest.th_get_items()[1 - sup].getId()).toBe(`${MeldrineIdTest}-1`);
-      itemRemoved < 2 && expect(bunchTest.th_get_items()[2 - sup].getId()).toBe(`${MaydenaIdTest}-2`);
-      itemRemoved < 3 && expect(bunchTest.th_get_items()[3 - sup].getId()).toBe(`${IldressIdTest}-3`);
-      expect(bunchTest.th_get_items()[4 - sup].getId()).toBe(`${YssaliaIdTest}-4`);
+      expect(bunchTest.get(0).getId()).toBe(`${HaileiIdTest}-0`);
+      itemRemoved < 1 && expect(bunchTest.get(1 - sup).getId()).toBe(`${MeldrineIdTest}-1`);
+      itemRemoved < 2 && expect(bunchTest.get(2 - sup).getId()).toBe(`${MaydenaIdTest}-2`);
+      itemRemoved < 3 && expect(bunchTest.get(3 - sup).getId()).toBe(`${IldressIdTest}-3`);
+      expect(bunchTest.get(4 - sup).getId()).toBe(`${YssaliaIdTest}-4`);
     };
 
     beforeEach(() => {
-      bunchTest.th_set_items(generateMockedElements(5));
+      bunchTest = new DTBunchTest(IDTest, KeyTest, generateStubElements(5));
     });
 
     test('remove many items by ids', () => {
@@ -735,45 +664,36 @@ describe('class DYOToolsBunch', () => {
 
     test('define container at undefined for removed items - default case', () => {
       const items = [
-        bunchTest.th_get_items()[1],
-        bunchTest.th_get_items()[2],
+        bunchTest.get(1),
+        bunchTest.get(2),
       ];
 
       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].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);
+      expect(items[0].getContainer()).toBeUndefined();
+      expect(items[1].getContainer()).toBeUndefined();
     });
 
     test('not change container for removed items - virtual container option', () => {
+      bunchTest = new DTBunchTest(IDTest, KeyTest, generateStubElements(5), { virtualContainer: true });
+      let bunchTestPhysical = new DTBunchTest(IDTest + "_physical", KeyTest);
       const items = [
-        bunchTest.th_get_items()[1],
-        bunchTest.th_get_items()[2],
+        bunchTest.get(1),
+        bunchTest.get(2),
       ];
-      bunchTest.th_set_options({ virtualContainer: true });
+      bunchTestPhysical.addMany(items);
+
       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].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);
+      expect(items[0].getContainer().getId()).toBe(IDTest + "_physical");
+      expect(items[1].getContainer().getId()).toBe(IDTest + "_physical");
     });
   });
 
   describe('remove()', () => {
     beforeEach(() => {
-      jest.spyOn(bunchTest, 'removeMany').mockImplementation(() => {
-      });
-
-      bunchTest.th_set_items(generateMockedElements(5));
+      bunchTest = new DTBunchTest(IDTest, KeyTest, generateStubElements(5));
+      jest.spyOn(bunchTest, 'removeMany').mockImplementation(() => {});
     });
 
     test('remove one item by id using removeMany', () => {
@@ -793,10 +713,8 @@ describe('class DYOToolsBunch', () => {
 
   describe('removeAll()', () => {
     beforeEach(() => {
-      jest.spyOn(bunchTest, 'removeMany').mockImplementation(() => {
-      });
-
-      bunchTest.th_set_items(generateMockedElements(5));
+      bunchTest = new DTBunchTest(IDTest, KeyTest, generateStubElements(5));
+      jest.spyOn(bunchTest, 'removeMany').mockImplementation(() => {});
     });
 
     test('remove all items using removeMany', () => {
@@ -812,27 +730,29 @@ describe('class DYOToolsBunch', () => {
   });
 
   describe('find()', () => {
+    let findSpy;
+
+    beforeEach(() => {
+      findSpy = jest.spyOn(bunchTest._getFinder(), 'execute');
+    })
+
     test('find items using DYOFinder - empty case', () => {
       bunchTest.find({});
 
-      expect((bunchTest.th_get_finder() as any).execute.mock.calls.length).toBe(1);
-      expect((bunchTest.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' } };
       bunchTest.find(testFilters);
 
-      expect((bunchTest.th_get_finder() as any).execute.mock.calls.length).toBe(1);
-      expect((bunchTest.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('toObject()', () => {
-    beforeEach(() => {
-      bunchTest.th_set_id(IDTest);
-      bunchTest.th_set_key(KeyTest);
-    });
 
     test('toObject output standard', () => {
       const toObjectBunch = bunchTest.toObject();
@@ -845,7 +765,7 @@ describe('class DYOToolsBunch', () => {
     });
 
     test('toObject output standard with owner', () => {
-      bunchTest.th_set_owner(OwnerTest);
+      bunchTest.setOwner(OwnerTest);
 
       const toObjectBunch = bunchTest.toObject();
       expect(Object.keys(toObjectBunch)).toStrictEqual(['id', 'key', 'type', 'items', 'owner']);
@@ -853,12 +773,8 @@ describe('class DYOToolsBunch', () => {
     });
 
     test('toObject output standard with owner and meta', () => {
-      jest.spyOn(bunchTest, 'getManyMeta').mockImplementation(function () {
-        return this._meta;
-      });
-
-      bunchTest.th_set_owner(OwnerTest);
-      bunchTest.th_set_meta(BunchMetaData);
+      bunchTest.setOwner(OwnerTest);
+      bunchTest.setManyMeta(BunchMetaData);
 
       const toObjectBunch = bunchTest.toObject();
       expect(Object.keys(toObjectBunch)).toStrictEqual(['id', 'key', 'type', 'items', 'owner', 'meta']);
@@ -866,7 +782,7 @@ describe('class DYOToolsBunch', () => {
     });
 
     test('toObject output standard with items', () => {
-      bunchTest.th_set_items(generateMockedElements(5));
+      bunchTest = new DTBunchTest(IDTest, KeyTest, generateStubElements(5));
       const toObjectBunch = bunchTest.toObject();
 
       expect(Object.keys(toObjectBunch)).toStrictEqual(['id', 'key', 'type', 'items']);
@@ -882,10 +798,6 @@ describe('class DYOToolsBunch', () => {
   });
 
   describe('toString()', () => {
-    beforeEach(() => {
-      bunchTest.th_set_key(KeyTest);
-    });
-
     test('string output standard', () => {
       const toStringBunch = bunchTest.toString();
 
@@ -893,15 +805,15 @@ describe('class DYOToolsBunch', () => {
     });
 
     test('string output standard with items', () => {
-      bunchTest.th_set_items(generateMockedElements(5));
+      bunchTest = new DTBunchTest(IDTest, KeyTest, generateStubElements(5));
       const toStringBunch = bunchTest.toString();
 
       expect(toStringBunch).toBe(`Component ${KeyTest} - Type: Bunch - Items: 5`);
     });
 
     test('string output standard with items and owner', () => {
-      bunchTest.th_set_items(generateMockedElements(5));
-      bunchTest.th_set_owner(OwnerTest);
+      bunchTest = new DTBunchTest(IDTest, KeyTest, generateStubElements(5));
+      bunchTest.setOwner(OwnerTest);
 
       const toStringBunch = bunchTest.toString();
       expect(toStringBunch).toBe(`Component ${KeyTest} - Type: Bunch - Owner: ${OwnerTest} - Items: 5`);