dyo-tools 0.4.0 → 0.4.1

package/test/core/DTBunch.spec.ts

@@ -1,822 +0,0 @@
-import {afterEach, beforeEach, describe, expect, jest, test,} from '@jest/globals';
-import {DTBunchStub, DTBunchTest, generateStubElements, IDTest, KeyTest} from './DTBunch.double';
-import {
-  DTElementStub,
-  HaileiIdTest,
-  HaileiKeyTest,
-  HaileiToObjectTest,
-  IDTest as IDElementTest,
-  IldressIdTest,
-  IldressKeyTest,
-  IldressToObjectTest,
-  KeyTest as KeyElementTest,
-  MaydenaIdTest,
-  MaydenaKeyTest,
-  MaydenaToObjectTest,
-  MeldrineIdTest,
-  MeldrineKeyTest,
-  MeldrineToObjectTest,
-  YssaliaIdTest,
-  YssaliaKeyTest,
-  YssaliaToObjectTest,
-} from './DTElement.double';
-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 DTBunch', () => {
-  let bunchTest: DTBunchTest;
-
-  beforeEach(() => {
-    bunchTest = new DTBunchTest();
-  });
-
-  afterEach(() => {
-    jest.resetAllMocks();
-  });
-
-  describe('inheritance', () => {
-    test('check good inheritance for class', () => {
-      expect(DTBunch.prototype instanceof DTComponentPhysical).toBeTruthy();
-    });
-  });
-
-  describe('constructor()', () => {
-    let addManyImpl;
-
-    beforeEach(() => {
-      jest.resetAllMocks();
-      addManyImpl = DTBunch.prototype.addMany;
-      DTBunch.prototype.addMany = jest.fn();
-    });
-
-    afterEach(() => {
-      DTBunch.prototype.addMany = addManyImpl;
-    });
-
-    test('creation simple with key', () => {
-      const newBunch = new DTBunchTest();
-
-      expect(newBunch.getAll()).toStrictEqual([]);
-    });
-
-    test('creation with items', () => {
-      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);
-      expect(mockedAddMany.mock.calls[0][0][0].getKey()).toBe(HaileiKeyTest);
-      expect(mockedAddMany.mock.calls[0][0][1].getKey()).toBe(MeldrineKeyTest);
-      expect(mockedAddMany.mock.calls[0][0][2].getKey()).toBe(MaydenaKeyTest);
-    });
-
-    test('creations with options', () => {
-      const testOptions: Partial<DTBunchOptions> = {
-        errors: true,
-        uniqueKey: true,
-        inheritOwner: true,
-      };
-      const newBunch = new DTBunchTest(IDTest, KeyTest, [], testOptions);
-
-      expect(newBunch.getOptions()).toStrictEqual({
-        errors: true,
-        syncId: undefined,
-        uniqueKey: true,
-        inheritOwner: true,
-        replaceIndex: false,
-        virtualContainer: false,
-      });
-      expect(newBunch.getAll()).toStrictEqual([]);
-    });
-  });
-
-  describe('_componentType', () => {
-    test('componentType must be "bunch"', () => {
-      expect(bunchTest.getComponentType()).toBe('bunch');
-    });
-  });
-
-  describe('getFinderConfiguration()', () => {
-    const baseOperators = [
-      FilterOperatorType.EQ,
-      FilterOperatorType.IN,
-      FilterOperatorType.NIN,
-      FilterOperatorType.NE,
-    ];
-    const advancedOperators = [
-      ...baseOperators,
-      FilterOperatorType.GTE,
-      FilterOperatorType.LTE,
-      FilterOperatorType.CONTAINS,
-      FilterOperatorType.NCONTAINS,
-    ];
-
-    test('check finder configuration for id attribute', () => {
-      const finderConfigurationToCheck = bunchTest.getFinderConfiguration().id;
-
-      expect(finderConfigurationToCheck.operators).toStrictEqual(baseOperators);
-      expect(finderConfigurationToCheck.getValue(new DTElementStub())).toBe(IDElementTest);
-      expect(finderConfigurationToCheck.objectSearch).toBe(false);
-    });
-
-    test('check finder configuration for key attribute', () => {
-      const finderConfigurationToCheck = bunchTest.getFinderConfiguration().key;
-
-      expect(finderConfigurationToCheck.operators).toStrictEqual(baseOperators);
-      expect(finderConfigurationToCheck.getValue(new DTElementStub())).toBe(KeyElementTest);
-      expect(finderConfigurationToCheck.objectSearch).toBe(false);
-    });
-
-    test('check finder configuration for owner attribute - empty owner', () => {
-      const element = new DTElementStub();
-      jest.spyOn(element, 'getOwner').mockImplementation(() => undefined);
-
-      const finderConfigurationToCheck = bunchTest.getFinderConfiguration().owner;
-
-      expect(finderConfigurationToCheck.operators).toStrictEqual(baseOperators);
-      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').mockReturnValue(OwnerTest);
-
-      const finderConfigurationToCheck = bunchTest.getFinderConfiguration().owner;
-
-      expect(finderConfigurationToCheck.operators).toStrictEqual(baseOperators);
-      expect(finderConfigurationToCheck.getValue(element)).toBe(OwnerTest);
-      expect(finderConfigurationToCheck.objectSearch).toBe(false);
-    });
-
-    test('check finder configuration for container attribute - empty container', () => {
-      const element = new DTElementStub();
-      jest.spyOn(element, 'getContainer').mockImplementation(() => undefined);
-
-      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 container attribute - with container', () => {
-      const element = new DTElementStub();
-      const bunch = new DTBunchStub();
-      jest.spyOn(bunch, 'getId').mockImplementation(() => `${IDTest}_other_container`);
-      jest.spyOn(element, 'getContainer').mockImplementation(() => bunch);
-
-      const finderConfigurationToCheck = bunchTest.getFinderConfiguration().container;
-
-      expect(finderConfigurationToCheck.operators).toStrictEqual(baseOperators);
-      expect(finderConfigurationToCheck.getValue(element)).toBe(`${IDTest}_other_container`);
-      expect(finderConfigurationToCheck.objectSearch).toBe(false);
-    });
-
-    test('check finder configuration for meta attribute', () => {
-      const element = new DTElementStub();
-      jest.spyOn(element, 'getManyMeta').mockImplementation(() => HaileiMetaData);
-
-      const finderConfigurationToCheck = bunchTest.getFinderConfiguration().meta;
-
-      expect(finderConfigurationToCheck.operators).toStrictEqual(advancedOperators);
-      expect(finderConfigurationToCheck.getValue(element)).toStrictEqual(HaileiMetaData);
-      expect(finderConfigurationToCheck.objectSearch).toBe(true);
-    });
-  });
-
-  describe('setOwner()', () => {
-    beforeEach(() => {
-      jest.spyOn(bunchTest, 'getOwner').mockReturnValue(OwnerTest);
-    });
-
-    test('add a new owner - not updating elements owner when inheritOwner = false', () => {
-      const newBunch = new DTBunchTest(IDTest, KeyTest, generateStubElements(1), { inheritOwner: false});
-
-      newBunch.setOwner(OwnerTest);
-
-      expect(newBunch.get(0).getOwner()).toBeUndefined();
-    });
-
-    test('add a new owner - updating elements owner when inheritOwner = true', () => {
-      const newBunch = new DTBunchTest(IDTest, KeyTest, generateStubElements(1), { inheritOwner: true});
-
-      newBunch.setOwner(OwnerTest);
-
-      expect(newBunch.get(0).getOwner()).toBe(OwnerTest);
-    });
-  });
-
-  describe('removeOwner()', () => {
-    test('remove current Owner - not updating elements owner when inheritOwner = false', () => {
-      const newBunch = new DTBunchTest(IDTest, KeyTest, generateStubElements(1, OwnerTest), { inheritOwner: false}, OwnerTest);
-      newBunch.removeOwner();
-
-      expect(newBunch.get(0).getOwner()).toBe(OwnerTest);
-    });
-
-    test('remove current Owner - updating elements owner when inheritOwner = true', () => {
-      const newBunch = new DTBunchTest(IDTest, KeyTest, generateStubElements(1, OwnerTest), { inheritOwner: true}, OwnerTest);
-      newBunch.removeOwner();
-
-      expect(newBunch.get(0).getOwner()).toBeUndefined();
-    });
-  });
-
-  describe('get()', () => {
-    beforeEach(() => {
-      bunchTest = new DTBunchTest(IDTest, KeyTest, generateStubElements(5))
-    });
-
-    test('return an item by its id', () => {
-      expect(bunchTest.get(`${MaydenaIdTest}-2`).getKey()).toBe(MaydenaKeyTest);
-      expect(bunchTest.get(`${YssaliaIdTest}-4`).getKey()).toBe(YssaliaKeyTest);
-    });
-
-    test('return an item by its index', () => {
-      expect(bunchTest.get(2).getKey()).toBe(MaydenaKeyTest);
-      expect(bunchTest.get(4).getKey()).toBe(YssaliaKeyTest);
-    });
-
-    test('return undefined if item not found by id', () => {
-      expect(bunchTest.get('id-123456')).toBeUndefined();
-    });
-
-    test('return undefined if item not found by index', () => {
-      expect(bunchTest.get(11)).toBeUndefined();
-    });
-
-    test('return undefined if item not found by index - incoherent index', () => {
-      expect(bunchTest.get(-11)).toBeUndefined();
-    });
-  });
-
-  describe('getAll()', () => {
-    test('return empty array if no items', () => {
-      expect(bunchTest.getAll()).toStrictEqual([]);
-    });
-
-    test('return all items array', () => {
-      bunchTest = new DTBunchTest(IDTest, KeyTest, generateStubElements(5));
-
-      expect(bunchTest.getAll()[0].getKey()).toBe(HaileiKeyTest);
-      expect(bunchTest.getAll()[1].getKey()).toBe(MeldrineKeyTest);
-      expect(bunchTest.getAll()[2].getKey()).toBe(MaydenaKeyTest);
-      expect(bunchTest.getAll()[3].getKey()).toBe(IldressKeyTest);
-      expect(bunchTest.getAll()[4].getKey()).toBe(YssaliaKeyTest);
-    });
-  });
-
-  describe('indexOf()', () => {
-    beforeEach(() => {
-      bunchTest = new DTBunchTest(IDTest, KeyTest, generateStubElements(5))
-    });
-
-    test('return index of an item by id', () => {
-      expect(bunchTest.indexOf(`${MaydenaIdTest}-2`)).toBe(2);
-      expect(bunchTest.indexOf(`${YssaliaIdTest}-4`)).toBe(4);
-    });
-
-    test('return -1 if id is not found', () => {
-      expect(bunchTest.indexOf('id-123456')).toBe(-1);
-    });
-  });
-
-  describe('addAtIndex()', () => {
-    let objectToAdd;
-    let objectsToAdd;
-
-    beforeEach(() => {
-      bunchTest = new DTBunchTest(IDTest, KeyTest, generateStubElements(5))
-
-      objectsToAdd = generateStubElements(6);
-      objectToAdd = objectsToAdd[5];
-    });
-
-    test('add a new item at last index - simple case', () => {
-      bunchTest.addAtIndex(objectToAdd, 5);
-
-      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.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.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.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.get(5).getId()).toBe(objectToAdd.getId());
-      expect(bunchTest.get(6)).toBeUndefined();
-    });
-
-    test('trigger conflict when adding two same ids - parent triggerError', () => {
-      let errorThrown: DTError | undefined;
-      try {
-        bunchTest.addAtIndex(objectsToAdd[0], 2);
-      } catch(error) {
-        errorThrown = error;
-      }
-
-      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', () => {
-      let errorThrown: DTError | undefined;
-      try {
-        bunchTest.addAtIndex(objectToAdd, 2);
-      } catch(error) {
-        errorThrown = error;
-      }
-
-      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', () => {
-      let errorThrown: DTError | undefined;
-      try {
-        bunchTest.addAtIndex(objectToAdd, 2, { uniqueKey: true });
-      } catch(error) {
-        errorThrown = error;
-      }
-
-      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.setOwner(OwnerTest);
-
-      bunchTest.addAtIndex(objectToAdd, 2);
-
-      expect(bunchTest.getOwner()).toBe(OwnerTest);
-      expect(objectToAdd.getOwner()).toBeUndefined();
-    });
-
-    test('inherit owner when adding an item - inheritOwner option', () => {
-      bunchTest.setOwner(OwnerTest);
-
-      bunchTest.addAtIndex(objectToAdd, 2, { inheritOwner: true });
-
-      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.get(2).getContext()).toBeUndefined();
-    });
-
-    test('set context with parent manager when adding an item', () => {
-      const manager = new DTManagerStub();
-      bunchTest.setContext(manager);
-
-      bunchTest.addAtIndex(objectToAdd, 2);
-
-      expect(bunchTest.get(2).getContext()?.getId()).toBe(managerIDTest);
-    });
-
-    test('set container when adding an item', () => {
-      bunchTest.addAtIndex(objectToAdd, 2);
-
-      expect(bunchTest.get(2).getContainer()?.getId()).toBe(IDTest);
-    });
-
-    test('not set container when adding an item - virtualContainer option', () => {
-      bunchTest = new DTBunchTest(IDTest, KeyTest, generateStubElements(5), { virtualContainer: true });
-
-      bunchTest.addAtIndex(objectToAdd, 2);
-
-      expect(bunchTest.get(2).getContainer()).toBeUndefined();
-    });
-
-    test('set container when adding an item - remove from old bunch', () => {
-      const bunchTestOld = new DTBunchTest(IDTest + "_old", KeyTest, generateStubElements(6));
-      objectToAdd = bunchTestOld.get(5);
-      objectToAdd.setContainer(bunchTestOld);
-
-      bunchTest.addAtIndex(objectToAdd, 2);
-
-      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(IDTest + "_old", KeyTest, generateStubElements(6), { virtualContainer: true });
-      objectToAdd = bunchTestOld.get(5);
-
-      bunchTest.addAtIndex(objectToAdd, 2);
-
-      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();
-      bunchTest.setContext(managerTest);
-
-      bunchTest.addAtIndex(objectToAdd, 5);
-
-      expect(managerTest.getLibrary().get(objectToAdd.getId())).toBeDefined();
-    });
-
-    test('manager context - not add existing item into the manager library', () => {
-      const managerTest = new DTManagerStub();
-      bunchTest.setContext(managerTest);
-      managerTest.getLibrary().add(objectToAdd);
-
-      bunchTest.addAtIndex(objectToAdd, 5);
-
-      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();
-      bunchTest.setContext(managerTest);
-
-      managerTest.getLibrary().addAtIndex(objectToAdd, 5);
-
-      expect(managerTest.getLibrary().getAll().length).toBe(1);
-    });
-  });
-
-  describe('add()', () => {
-    let objectsToAdd;
-    let objectToAdd;
-
-    beforeEach(() => {
-      bunchTest = new DTBunchTest(IDTest, KeyTest, generateStubElements(5));
-      jest.spyOn(bunchTest, 'addAtIndex').mockImplementation(() => {});
-
-      objectsToAdd = generateStubElements(6);
-      objectToAdd = objectsToAdd[5];
-    });
-
-    test('add as last item using addAtIndex', () => {
-      const testBunchOptions = {
-        replaceIndex: true,
-        inheritOwner: true,
-      };
-      bunchTest.add(objectToAdd, testBunchOptions);
-
-      expect((bunchTest.addAtIndex as any).mock.calls.length).toBe(1);
-      expect((bunchTest.addAtIndex as any).mock.calls[0][0].getId()).toBe(objectToAdd.getId());
-      expect((bunchTest.addAtIndex as any).mock.calls[0][1]).toBe(5);
-      expect((bunchTest.addAtIndex as any).mock.calls[0][2]).toStrictEqual(testBunchOptions);
-    });
-  });
-
-  describe('addManyAtIndex()', () => {
-    let itemsToAdd;
-    let itemLibrary;
-
-    beforeEach(() => {
-      bunchTest = new DTBunchTest(IDTest, KeyTest, generateStubElements(5));
-      jest.spyOn(bunchTest, 'addAtIndex').mockImplementation(() => {});
-
-      itemLibrary = generateStubElements(8);
-      itemsToAdd = [itemLibrary[5], itemLibrary[6], itemLibrary[7]];
-    });
-
-    test('add many items at index using addAtIndex - simple case', () => {
-      const testBunchOptions = {
-        replaceIndex: true,
-        inheritOwner: true,
-      };
-      const indexToAdd = 2;
-      bunchTest.addManyAtIndex(itemsToAdd, indexToAdd, testBunchOptions);
-
-      expect((bunchTest.addAtIndex as any).mock.calls.length).toBe(3);
-      for (let i = 0; i < 3; i++) {
-        expect((bunchTest.addAtIndex as any).mock.calls[i][0].getId()).toBe(itemsToAdd[i].getId());
-        expect((bunchTest.addAtIndex as any).mock.calls[i][1]).toBe(i + indexToAdd);
-        expect((bunchTest.addAtIndex as any).mock.calls[i][2]).toStrictEqual(testBunchOptions);
-      }
-    });
-
-    test('add many items at index using addAtIndex - index lower than 0', () => {
-      const indexToAdd = -11;
-      bunchTest.addManyAtIndex(itemsToAdd, indexToAdd);
-
-      expect((bunchTest.addAtIndex as any).mock.calls.length).toBe(3);
-      for (let i = 0; i < 3; i++) {
-        expect((bunchTest.addAtIndex as any).mock.calls[i][0].getId()).toBe(itemsToAdd[i].getId());
-        expect((bunchTest.addAtIndex as any).mock.calls[i][1]).toBe(i);
-      }
-    });
-
-    test('errors when adding many items at index - default case - add no items and throw error', () => {
-      const indexToAdd = 2;
-      let errorThrown: DTErrorStub;
-      jest.spyOn(bunchTest, 'addAtIndex').mockImplementationOnce((item, index, options) => {
-        throw new DTErrorStub();
-      });
-
-      try {
-        bunchTest.addManyAtIndex(itemsToAdd, indexToAdd);
-      } catch (error: unknown) {
-        errorThrown = error as DTErrorStub;
-      }
-
-      expect(errorThrown).toBeDefined();
-      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());
-      expect((bunchTest.addAtIndex as any).mock.calls[0][1]).toBe(indexToAdd);
-    });
-
-    test('errors when adding many items at index - errors case - add success items and stack errors for others', () => {
-      const indexToAdd = 2;
-      const errors = [];
-      jest.spyOn(bunchTest, 'addAtIndex')
-        .mockImplementationOnce((item, index, options) => {
-          errors.push(new DTErrorStub());
-        })
-        .mockImplementationOnce((item, index, options) => {
-          errors.push(new DTErrorStub());
-        });
-
-      bunchTest.addManyAtIndex(itemsToAdd, indexToAdd, { errors: true });
-
-      expect(errors.length).toBe(2);
-      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());
-      expect((bunchTest.addAtIndex as any).mock.calls[2][0].getId()).toBe(itemsToAdd[2].getId());
-    });
-  });
-
-  describe('addMany()', () => {
-    let itemsToAdd;
-    let itemLibrary;
-
-    beforeEach(() => {
-      bunchTest = new DTBunchTest(IDTest, KeyTest, generateStubElements(5));
-      jest.spyOn(bunchTest, 'addManyAtIndex').mockImplementation(() => {});
-
-      itemLibrary = generateStubElements(8);
-      itemsToAdd = [itemLibrary[5], itemLibrary[6], itemLibrary[7]];
-    });
-
-    test('add many items as last item using addManyAtIndex', () => {
-      const testBunchOptions = {
-        replaceIndex: true,
-        inheritOwner: true,
-      };
-
-      bunchTest.addMany(itemsToAdd, testBunchOptions);
-
-      expect((bunchTest.addManyAtIndex as any).mock.calls.length).toBe(1);
-      expect((bunchTest.addManyAtIndex as any).mock.calls[0][0].length).toBe(3);
-      expect((bunchTest.addManyAtIndex as any).mock.calls[0][0][0].getId()).toBe(`${HaileiIdTest}-5`);
-      expect((bunchTest.addManyAtIndex as any).mock.calls[0][0][1].getId()).toBe(`${MeldrineIdTest}-6`);
-      expect((bunchTest.addManyAtIndex as any).mock.calls[0][0][2].getId()).toBe(`${MaydenaIdTest}-7`);
-      expect((bunchTest.addManyAtIndex as any).mock.calls[0][1]).toBe(5);
-      expect((bunchTest.addManyAtIndex as any).mock.calls[0][2]).toStrictEqual(testBunchOptions);
-    });
-  });
-
-  describe('removeMany()', () => {
-    const checkAllItemsInBunch = (bunch: DTBunchTest, itemRemoved = 3) => {
-      const sup = itemRemoved;
-      expect(bunchTest.getAll().length).toBe(5 - sup);
-      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 = new DTBunchTest(IDTest, KeyTest, generateStubElements(5));
-    });
-
-    test('remove many items by ids', () => {
-      bunchTest.removeMany([`${MeldrineIdTest}-1`, `${MaydenaIdTest}-2`, `${IldressIdTest}-3`]);
-
-      checkAllItemsInBunch(bunchTest);
-    });
-
-    test('remove many items by indexes', () => {
-      bunchTest.removeMany([1, 2, 3]);
-
-      checkAllItemsInBunch(bunchTest);
-    });
-
-    test('remove only item with corresponding ids', () => {
-      bunchTest.removeMany([`${MeldrineIdTest}-1`, `${MaydenaIdTest}-2`, 'id-12345']);
-
-      checkAllItemsInBunch(bunchTest, 2);
-    });
-
-    test('remove only item with corresponding indexes', () => {
-      bunchTest.removeMany([1, 2, 11]);
-
-      checkAllItemsInBunch(bunchTest, 2);
-    });
-
-    test('remove only item with corresponding indexes - incoherent index', () => {
-      bunchTest.removeMany([-11, 2, 1, -13]);
-
-      checkAllItemsInBunch(bunchTest, 2);
-    });
-
-    test('define container at undefined for removed items - default case', () => {
-      const items = [
-        bunchTest.get(1),
-        bunchTest.get(2),
-      ];
-
-      bunchTest.removeMany([`${MeldrineIdTest}-1`, `${MaydenaIdTest}-2`]);
-
-      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.get(1),
-        bunchTest.get(2),
-      ];
-      bunchTestPhysical.addMany(items);
-
-      bunchTest.removeMany([`${MeldrineIdTest}-1`, `${MaydenaIdTest}-2`]);
-
-      expect(items[0].getContainer().getId()).toBe(IDTest + "_physical");
-      expect(items[1].getContainer().getId()).toBe(IDTest + "_physical");
-    });
-  });
-
-  describe('remove()', () => {
-    beforeEach(() => {
-      bunchTest = new DTBunchTest(IDTest, KeyTest, generateStubElements(5));
-      jest.spyOn(bunchTest, 'removeMany').mockImplementation(() => {});
-    });
-
-    test('remove one item by id using removeMany', () => {
-      bunchTest.remove(`${MaydenaIdTest}-2`);
-
-      expect((bunchTest.removeMany as any).mock.calls.length).toBe(1);
-      expect((bunchTest.removeMany as any).mock.calls[0][0]).toStrictEqual([`${MaydenaIdTest}-2`]);
-    });
-
-    test('remove one item by index using removeMany', () => {
-      bunchTest.remove(2);
-
-      expect((bunchTest.removeMany as any).mock.calls.length).toBe(1);
-      expect((bunchTest.removeMany as any).mock.calls[0][0]).toStrictEqual([2]);
-    });
-  });
-
-  describe('removeAll()', () => {
-    beforeEach(() => {
-      bunchTest = new DTBunchTest(IDTest, KeyTest, generateStubElements(5));
-      jest.spyOn(bunchTest, 'removeMany').mockImplementation(() => {});
-    });
-
-    test('remove all items using removeMany', () => {
-      bunchTest.removeAll();
-
-      expect((bunchTest.removeMany as any).mock.calls.length).toBe(1);
-      expect((bunchTest.removeMany as any).mock.calls[0][0]).toStrictEqual([0, 1, 2, 3, 4]);
-    });
-  });
-
-  describe('copy()', () => {
-    // @see copy.spec.ts for unit tests about copy method
-  });
-
-  describe('find()', () => {
-    let findSpy;
-
-    beforeEach(() => {
-      findSpy = jest.spyOn(bunchTest._getFinder(), 'execute');
-    })
-
-    test('find items using DYOFinder - empty case', () => {
-      bunchTest.find({});
-
-      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((findSpy as any).mock.calls.length).toBe(1);
-      expect((findSpy as any).mock.calls[0][0]).toStrictEqual(testFilters);
-    });
-  });
-
-  describe('toObject()', () => {
-
-    test('toObject output standard', () => {
-      const toObjectBunch = bunchTest.toObject();
-
-      expect(Object.keys(toObjectBunch)).toStrictEqual(['id', 'key', 'type', 'items']);
-      expect(toObjectBunch.id).toBe(IDTest);
-      expect(toObjectBunch.key).toBe(KeyTest);
-      expect(toObjectBunch.type).toBe('bunch');
-      expect(toObjectBunch.items.length).toBe(0);
-    });
-
-    test('toObject output standard with owner', () => {
-      bunchTest.setOwner(OwnerTest);
-
-      const toObjectBunch = bunchTest.toObject();
-      expect(Object.keys(toObjectBunch)).toStrictEqual(['id', 'key', 'type', 'items', 'owner']);
-      expect(toObjectBunch.owner).toBe(OwnerTest);
-    });
-
-    test('toObject output standard with owner and meta', () => {
-      bunchTest.setOwner(OwnerTest);
-      bunchTest.setManyMeta(BunchMetaData);
-
-      const toObjectBunch = bunchTest.toObject();
-      expect(Object.keys(toObjectBunch)).toStrictEqual(['id', 'key', 'type', 'items', 'owner', 'meta']);
-      expect(toObjectBunch.meta).toStrictEqual(BunchMetaData);
-    });
-
-    test('toObject output standard with items', () => {
-      bunchTest = new DTBunchTest(IDTest, KeyTest, generateStubElements(5));
-      const toObjectBunch = bunchTest.toObject();
-
-      expect(Object.keys(toObjectBunch)).toStrictEqual(['id', 'key', 'type', 'items']);
-      expect(toObjectBunch.items.length).toBe(5);
-      expect(toObjectBunch.items).toStrictEqual([
-        HaileiToObjectTest,
-        MeldrineToObjectTest,
-        MaydenaToObjectTest,
-        IldressToObjectTest,
-        YssaliaToObjectTest,
-      ]);
-    });
-  });
-
-  describe('toString()', () => {
-    test('string output standard', () => {
-      const toStringBunch = bunchTest.toString();
-
-      expect(toStringBunch).toBe(`Component ${KeyTest} - Type: Bunch - Items: 0`);
-    });
-
-    test('string output standard with items', () => {
-      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 = new DTBunchTest(IDTest, KeyTest, generateStubElements(5));
-      bunchTest.setOwner(OwnerTest);
-
-      const toStringBunch = bunchTest.toString();
-      expect(toStringBunch).toBe(`Component ${KeyTest} - Type: Bunch - Owner: ${OwnerTest} - Items: 5`);
-    });
-  });
-});