dyo-tools 0.4.0 → 0.4.1

package/test/core/DTManager.spec.ts

@@ -1,874 +0,0 @@
-import {afterEach, beforeEach, describe, expect, jest, test,} from '@jest/globals';
-import {
-  checkManagerItem,
-  DomainTest,
-  DTManagerTest,
-  DTManagerTestDomain,
-  IDTest,
-  KeyTest,
-  ScopesTest,
-} from './DTManager.double';
-import {
-  bunch1toObjectTest,
-  bunch2toObjectTest,
-  bunch3toObjectTest,
-  DTBunchStub,
-  DTBunchStubLibrary,
-  generateStubElements,
-  IDTest as IDTestBunch,
-  IDTestLibrary,
-  KeyTest as KeyTestBunch,
-} from './DTBunch.double';
-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;
-
-/** *********************** TESTS SUITES ****************************** */
-describe('class DTManager', () => {
-  let managerTest: DTManagerTest;
-
-  beforeEach(() => {
-    managerTest = new DTManagerTest();
-  });
-
-  afterEach(() => {
-    jest.resetAllMocks();
-  });
-
-  describe('inheritance', () => {
-    test('check good inheritance for class', () => {
-      expect(DTManager.prototype instanceof DTComponent).toBeTruthy();
-    });
-  });
-
-  describe('_componentType', () => {
-    test('componentType must be "manager"', () => {
-      expect(managerTest.getComponentType()).toBe('manager');
-    });
-  });
-
-  describe('constructor()', () => {
-    beforeEach(() => {
-      jest.resetAllMocks();
-    });
-
-    test('creation simple with key', () => {
-      const newManager = new DTManagerTest(IDTest, KeyTest, [], [], {}, false);
-
-      expect(newManager._getItems()).toStrictEqual({});
-      expect(newManager.getScopes()).toStrictEqual(['default', 'virtual']);
-
-      // Library tests
-      const library = newManager.getLibrary();
-      expect(library).toBeDefined();
-      expect(library.getKey()).toBe('library');
-      expect(library.getAll()).toStrictEqual([]);
-      expect(library.getOptions()).toStrictEqual({
-        ...bunchDefaultOptions,
-        virtualContainer: true,
-      });
-      expect(library.getContext()).toStrictEqual(newManager);
-    });
-
-    // 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);
-    // });
-
-    test('creation with elements for library', () => {
-      const elements = generateStubElements(5);
-      const newManager = new DTManagerTest(IDTest, KeyTest, elements);
-
-      // Library tests
-      const library = newManager.getLibrary();
-      expect(library).toBeDefined();
-      expect(library.getAll()).toStrictEqual(elements);
-    });
-
-    test('creation with extended scopes', () => {
-      const newManager = new DTManagerTest(IDTest, KeyTest, [], ScopesTest);
-
-      expect(newManager.getScopes()).toStrictEqual([
-        'default',
-        'virtual',
-        ...ScopesTest,
-      ]);
-    });
-  });
-
-  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 = managerTest.getFinderConfiguration().id;
-
-      expect(finderConfigurationToCheck.operators).toStrictEqual(baseOperators);
-      expect(finderConfigurationToCheck.getValue(new DTBunchStub())).toBe(IDTestBunch);
-      expect(finderConfigurationToCheck.objectSearch).toBe(false);
-    });
-
-    test('check finder configuration for key attribute', () => {
-      const finderConfigurationToCheck = managerTest.getFinderConfiguration().key;
-
-      expect(finderConfigurationToCheck.operators).toStrictEqual(baseOperators);
-      expect(finderConfigurationToCheck.getValue(new DTBunchStub())).toBe(KeyTestBunch);
-      expect(finderConfigurationToCheck.objectSearch).toBe(false);
-    });
-
-    test('check finder configuration for owner attribute - empty owner', () => {
-      const bunch = new DTBunchStub();
-      jest.spyOn(bunch, 'getOwner').mockImplementation(() => undefined);
-
-      const finderConfigurationToCheck = managerTest.getFinderConfiguration().owner;
-
-      expect(finderConfigurationToCheck.operators).toStrictEqual(baseOperators);
-      expect(finderConfigurationToCheck.getValue(bunch)).toBeUndefined();
-      expect(finderConfigurationToCheck.objectSearch).toBe(false);
-    });
-
-    test('check finder configuration for owner attribute - with owner', () => {
-      const bunch = new DTBunchStub();
-      jest.spyOn(bunch, 'getOwner').mockReturnValue(OwnerTest);
-
-      const finderConfigurationToCheck = managerTest.getFinderConfiguration().owner;
-
-      expect(finderConfigurationToCheck.operators).toStrictEqual(baseOperators);
-      expect(finderConfigurationToCheck.getValue(bunch)).toBe(OwnerTest);
-      expect(finderConfigurationToCheck.objectSearch).toBe(false);
-    });
-
-    test('check finder configuration for meta attribute', () => {
-      const bunch = new DTBunchStub();
-      jest.spyOn(bunch, 'getManyMeta').mockImplementation(() => BunchMetaData);
-
-      const finderConfigurationToCheck = managerTest.getFinderConfiguration().meta;
-
-      expect(finderConfigurationToCheck.operators).toStrictEqual(advancedOperators);
-      expect(finderConfigurationToCheck.getValue(bunch)).toStrictEqual(BunchMetaData);
-      expect(finderConfigurationToCheck.objectSearch).toBe(true);
-    });
-
-    test('check finder configuration for scope attribute', () => {
-      const bunch = new DTBunchStub();
-      jest.spyOn(managerTest, 'getScope').mockImplementation(() => ScopesTest[0]);
-
-      const finderConfigurationToCheck = managerTest.getFinderConfiguration().scope;
-
-      expect(finderConfigurationToCheck.operators).toStrictEqual(baseOperators);
-      expect(finderConfigurationToCheck.getValue(bunch, managerTest)).toStrictEqual(ScopesTest[0]);
-      expect(finderConfigurationToCheck.objectSearch).toBe(false);
-    });
-  });
-
-  describe('getLibrary()', () => {
-    test('return current manager Library', () => {
-      const library: DTBunchStubLibrary = managerTest.getLibrary() as DTBunchStubLibrary;
-
-      expect(library).toBeDefined();
-      expect(library.getId()).toBe(IDTestLibrary);
-    });
-  });
-
-  describe('getScopes()', () => {
-    test('return manager scopes', () => {
-      managerTest = new DTManagerTest(IDTest, KeyTest, [], 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(contextSpy.mock.calls.length).toBe(1);
-      expect(contextSpy.mock.calls[0][0]).toBe('master');
-    });
-  });
-
-  describe('isValidScope()', () => {
-    beforeEach(() => {
-      managerTest = new DTManagerTest(IDTest, KeyTest, [], ScopesTest);
-    });
-
-    test('return true if scope exists', () => {
-      expect(managerTest.isValidScope(ScopesTest[0])).toBe(true);
-    });
-
-    test('return false if scope doesn\'t exist', () => {
-      expect(managerTest.isValidScope('invalid_scope')).toBe(false);
-    });
-  });
-
-  describe('add()', () => {
-    let bunchToAdd: DTBunch<DTElementStub>;
-
-    beforeEach(() => {
-      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._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._getItems()).length).toBe(1);
-      checkManagerItem(managerTest, IDTestBunch, ScopesTest[0]);
-    });
-
-    test('add a new item - virtual bunch in virtual scope', () => {
-      bunchToAdd = new DTBunchStub([], { virtualContainer: true }) as DTBunch<DTElementStub>;
-
-      managerTest.add(bunchToAdd);
-
-      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';
-      let errorThrown: DTError | undefined;
-      try {
-        managerTest.add(bunchToAdd, errorScope);
-      } catch(error) {
-        errorThrown = error;
-      }
-
-      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 = new DTBunchStub([], { virtualContainer: true }) as DTBunch<DTElementStub>;
-      let errorThrown: DTError | undefined;
-      try {
-        managerTest.add(bunchToAdd, ScopesTest[0]);
-      } catch(error) {
-        errorThrown = error;
-      }
-
-      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', () => {
-      let errorThrown: DTError | undefined;
-      try {
-        managerTest.add(bunchToAdd, 'virtual');
-      } catch(error) {
-        errorThrown = error;
-      }
-
-      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', () => {
-      managerTest.add(bunchToAdd);
-      let errorThrown: DTError | undefined;
-      try {
-        managerTest.add(bunchToAdd);
-      } catch(error) {
-        errorThrown = error;
-      }
-
-      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 = generateStubElements(5);
-      bunchToAdd = new DTBunchStub(bunchElements, { virtualContainer: true }) as DTBunch<DTElementStub>;
-
-      managerTest.add(bunchToAdd);
-
-      const library = managerTest.getLibrary();
-      expect(library.getAll()).toStrictEqual(bunchElements);
-    });
-
-    test('add bunch elements into library - not adding existing elements in library', () => {
-      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);
-
-      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.add(bunchToAdd);
-
-      expect(bunchToAdd.getContext()?.getId()).toBe(IDTest);
-    });
-
-    test('set context when adding an item - remove from old manager', () => {
-      const oldManagerTest = new DTManagerTest(IDTest + '_old');
-      bunchToAdd.setContext(oldManagerTest);
-      const removeSpy = jest.spyOn(oldManagerTest, 'remove');
-
-      managerTest.add(bunchToAdd);
-
-      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 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);
-
-      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(() => {
-      managerTest = new DTManagerTest(IDTest, KeyTest, [], ScopesTest, { errors: false });
-      addSpy = jest.spyOn(managerTest, 'add').mockImplementation(() => {});
-
-      // Bunches to add
-      const bunchToAdd1 = new DTBunchStub();
-      bunchToAdd1._setId(`${IDTestBunch}_1`);
-      const bunchToAdd2 = new DTBunchStub();
-      bunchToAdd2._setId(`${IDTestBunch}_2`);
-      const bunchToAdd3 = new DTBunchStub();
-      bunchToAdd3._setId(`${IDTestBunch}_3`);
-      bunchesToAdd = [bunchToAdd1, bunchToAdd2, bunchToAdd3];
-    });
-
-    test('add many items - use add method - default case', () => {
-      managerTest.addMany(bunchesToAdd);
-
-      expect(addSpy.mock.calls.length).toBe(3);
-      let itemCount = 0;
-      for (const addCalls of addSpy.mock.calls) {
-        expect(addCalls[0].getId()).toBe(bunchesToAdd[itemCount].getId());
-        expect(addCalls[1]).toBeUndefined();
-        itemCount += 1;
-      }
-    });
-
-    test('add many items - use add method - with scope case', () => {
-      managerTest.addMany(bunchesToAdd, ScopesTest[0]);
-
-      expect(addSpy.mock.calls.length).toBe(3);
-      let itemCount = 0;
-      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', () => {
-      addSpy = jest.spyOn(managerTest, 'add')
-        .mockImplementationOnce(function (item) {
-          this._items[`${IDTestBunch}_1`] = {
-            scope: 'default',
-            item,
-          };
-        })
-        .mockImplementationOnce(() => {
-          throw new DTErrorStub();
-        })
-        .mockImplementationOnce(function (item) {
-          this._items[`${IDTestBunch}_3`] = {
-            scope: 'default',
-            item,
-          };
-        });
-      let errorThrown: DTError | undefined;
-      try {
-        managerTest.addMany(bunchesToAdd);
-      } catch(error) {
-        errorThrown = error;
-      }
-
-      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', () => {
-      addSpy = jest.spyOn(managerTest, 'add')
-        .mockImplementationOnce(function (item) {
-          this._items[`${IDTestBunch}_1`] = {
-            scope: 'default',
-            item,
-          };
-        })
-        .mockImplementationOnce(function () {
-          this._errors = [new DTErrorStub()];
-        })
-        .mockImplementationOnce(function (item) {
-          this._items[`${IDTestBunch}_3`] = {
-            scope: 'default',
-            item,
-          };
-        });
-
-      managerTest.addMany(bunchesToAdd);
-
-      expect(addSpy.mock.calls.length).toBe(3);
-      expect(Object.keys(managerTest._getItems()).length).toBe(2);
-    });
-  });
-
-  describe('moveToScope()', () => {
-    beforeEach(() => {
-      managerTest = new DTManagerTest(IDTest, KeyTest, [], ScopesTest);
-      managerTest.populate();
-    });
-
-    test('move to default scope', () => {
-      managerTest.moveToScope(`${IDTestBunch}_2`, 'default');
-
-      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._getItems()).length).toBe(3);
-      checkManagerItem(managerTest, `${IDTestBunch}_2`, ScopesTest[1]);
-    });
-
-    test('move to non-existing scope - trigger invalid_scope error', () => {
-      let errorThrown: DTError | undefined;
-      try {
-        managerTest.moveToScope(`${IDTestBunch}_2`, 'invalid_scope');
-      } catch(error) {
-        errorThrown = error;
-      }
-
-      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', () => {
-      let errorThrown: DTError | undefined;
-      try {
-        managerTest.moveToScope(`${IDTestBunch}_2`, 'virtual');
-      } catch(error) {
-        errorThrown = error;
-      }
-
-      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', () => {
-      let errorThrown: DTError | undefined;
-      try {
-        managerTest.moveToScope(`${IDTestBunch}_3`, ScopesTest[0]);
-      } catch(error) {
-        errorThrown = error;
-      }
-
-      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._getItems()).length).toBe(3);
-      checkManagerItem(managerTest, `${IDTestBunch}_1`, 'default');
-    });
-
-    test('move an non-existing bunch id - trigger invalid_id error', () => {
-      let errorThrown: DTError | undefined;
-      try {
-        managerTest.moveToScope(`${IDTestBunch}_5`, ScopesTest[0]);
-      } catch(error) {
-        errorThrown = error;
-      }
-
-      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(() => {
-      managerTest.populate();
-    });
-
-    test('return a bunch by its id', () => {
-      const bunch = managerTest.get(`${IDTestBunch}_1`) as DTBunchStub;
-
-      expect(bunch).toBeDefined();
-      expect(bunch.getId()).toBe(`${IDTestBunch}_1`);
-    });
-
-    test('return undefined if bunch is not found', () => {
-      const bunch = managerTest.get(`${IDTestBunch}_5`);
-
-      expect(bunch).toBeUndefined();
-    });
-  });
-
-  describe('getAll()', () => {
-    beforeEach(() => {
-      managerTest.populate();
-    });
-
-    test('return all bunch items', () => {
-      const bunches = managerTest.getAll() as DTBunchStub[];
-
-      const bunchesIds = bunches.map((bunch) => bunch.getId());
-      expect(bunchesIds.length).toBe(3);
-      expect(bunchesIds.includes(`${IDTestBunch}_1`)).toBeTruthy();
-      expect(bunchesIds.includes(`${IDTestBunch}_2`)).toBeTruthy();
-      expect(bunchesIds.includes(`${IDTestBunch}_3`)).toBeTruthy();
-    });
-
-    test('return empty array if no bunch', () => {
-      managerTest = new DTManagerTest();
-
-      const bunches = managerTest.getAll();
-
-      expect(bunches.length).toBe(0);
-    });
-
-    test('scope argument : return only bunches into the scope', () => {
-      const bunches = managerTest.getAll(ScopesTest[0]) as DTBunchStub[];
-
-      const bunchesIds = bunches.map((bunch) => bunch.getId());
-      expect(bunchesIds.length).toBe(1);
-      expect(bunchesIds.includes(`${IDTestBunch}_2`)).toBeTruthy();
-    });
-
-    test('scope argument : return empty array if no bunch into the scope', () => {
-      const bunches = managerTest.getAll(ScopesTest[1]);
-
-      expect(bunches.length).toBe(0);
-    });
-
-    test('scope argument : return empty array if invalid scope is passed', () => {
-      const bunches = managerTest.getAll('invalid_scope');
-
-      expect(bunches.length).toBe(0);
-    });
-  });
-
-  describe('getScope()', () => {
-    beforeEach(() => {
-      managerTest.populate();
-    });
-
-    test('get scope for an existing bunch id', () => {
-      const scope1 = managerTest.getScope(`${IDTestBunch}_1`);
-      const scope2 = managerTest.getScope(`${IDTestBunch}_2`);
-      const scope3 = managerTest.getScope(`${IDTestBunch}_3`);
-
-      expect(scope1).toBe('default');
-      expect(scope2).toBe(ScopesTest[0]);
-      expect(scope3).toBe('virtual');
-    });
-
-    test('get undefined scope for an non-existing bunch id', () => {
-      const scope = managerTest.getScope(`${IDTestBunch}_5`);
-
-      expect(scope).toBeUndefined();
-    });
-  });
-
-  describe('remove()', () => {
-    beforeEach(() => {
-      managerTest.populate();
-    });
-
-    test('remove one item using removeMany', () => {
-      const removeManySpy = jest.spyOn(managerTest, 'removeMany');
-
-      managerTest.remove(`${IDTestBunch}_2`);
-
-      expect(removeManySpy.mock.calls.length).toBe(1);
-      expect(removeManySpy.mock.calls[0][0]).toStrictEqual([`${IDTestBunch}_2`]);
-    });
-  });
-
-  describe('removeMany()', () => {
-    beforeEach(() => {
-      managerTest.populate();
-    });
-
-    test('remove multiple bunches from manager', () => {
-      managerTest.removeMany([`${IDTestBunch}_1`, `${IDTestBunch}_2`]);
-
-      const newItems = managerTest._getItems();
-      expect(Object.keys(newItems).length).toBe(1);
-      expect(Object.keys(newItems)).toStrictEqual([`${IDTestBunch}_3`]);
-    });
-
-    test('remove non-existing bunches - nothing happen', () => {
-      managerTest.removeMany([`${IDTestBunch}_5`, `${IDTestBunch}_7`]);
-
-      const newItems = managerTest._getItems();
-      expect(Object.keys(newItems).length).toBe(3);
-      expect(Object.keys(newItems)).toStrictEqual([`${IDTestBunch}_1`, `${IDTestBunch}_2`, `${IDTestBunch}_3`]);
-    });
-
-    test('remove multiple bunches from manager - no removal from library by default', () => {
-      managerTest.removeMany([`${IDTestBunch}_1`, `${IDTestBunch}_2`]);
-
-      const library = managerTest.getLibrary();
-      expect(library.getAll().length).toBe(5);
-    });
-
-    test('remove multiple bunches from manager - libraryDeletion option', () => {
-      managerTest.removeMany([`${IDTestBunch}_1`, `${IDTestBunch}_2`], { libraryDeletion: true });
-
-      const library = managerTest.getLibrary();
-      expect(library.getAll().length).toBe(0);
-    });
-
-    test('remove context when removing a bunch - standard case', () => {
-      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(bunch1RemoveContextSpy.mock.calls.length).toBe(1);
-      expect(bunch2RemoveContextSpy.mock.calls.length).toBe(1);
-    });
-
-    test('remove a bunch with elements - remove container for all library elements', () => {
-      managerTest.removeMany([`${IDTestBunch}_1`]);
-
-      const library = managerTest.getLibrary();
-      for (let element of library.getAll()) {
-        expect(element.getContext()?.getId()).toBe(IDTest);
-        expect(element.getContainer()).toBeUndefined();
-      }
-    });
-  });
-
-  describe('removeAll()', () => {
-    beforeEach(() => {
-      managerTest.populate();
-    });
-
-    test('remove all items using removeMany', () => {
-      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([`${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((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((findSpy as any).mock.calls.length).toBe(1);
-      expect((findSpy as any).mock.calls[0][0]).toStrictEqual(testFilters);
-    });
-  });
-
-  describe('reloadLibrary()', () => {
-    beforeEach(() => {
-      managerTest.populate();
-      const library = managerTest.getLibrary();
-      library.removeAll();
-    });
-
-    test('synchronize bunches items into an empty library - one bunch with items', () => {
-      const expectedAddedItemIds = generateStubElements(5).map((e) => e.getId());
-      managerTest.reloadLibrary();
-
-      const library = managerTest.getLibrary();
-      expect(library.getAll().map((e) => e.getId())).toEqual(expectedAddedItemIds);
-    });
-
-    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(library.getAll().map((e) => e.getId())).toEqual(newItems.map(e => e.getId()));
-    });
-  });
-
-  describe('toObject()', () => {
-    beforeEach(() => {
-      managerTest = new DTManagerTest(IDTest, KeyTest);
-    })
-
-    test('toObject output standard', () => {
-      const toObjectManager = managerTest.toObject();
-
-      expect(Object.keys(toObjectManager)).toStrictEqual(['id', 'key', 'type', 'items']);
-      expect(toObjectManager.id).toBe(IDTest);
-      expect(toObjectManager.key).toBe(KeyTest);
-      expect(toObjectManager.type).toBe('manager');
-      expect(toObjectManager.items.length).toBe(0);
-    });
-
-    test('toObject output with items', () => {
-      managerTest.populate();
-
-      const toObjectManager = managerTest.toObject();
-
-      expect(Object.keys(toObjectManager)).toStrictEqual(['id', 'key', 'type', 'items']);
-      expect(toObjectManager.items.length).toBe(3);
-      expect(toObjectManager.items).toStrictEqual([
-        { scope: 'default', ...bunch1toObjectTest },
-        { scope: ScopesTest[0], ...bunch2toObjectTest },
-        { scope: 'virtual', ...bunch3toObjectTest },
-      ]);
-    });
-  });
-
-  describe('toString()', () => {
-    beforeEach(() => {
-      managerTest = new DTManagerTest(IDTest, KeyTest);
-    })
-
-    test('string output standard', () => {
-      const toStringManager = managerTest.toString();
-
-      expect(toStringManager).toBe(`Component ${KeyTest} - Type: Manager - Library: 0 - Items: 0`);
-    });
-
-    test('string output with domain', () => {
-      managerTest = new DTManagerTestDomain(IDTest, KeyTest);
-
-      const toStringManager = managerTest.toString();
-
-      expect(toStringManager).toBe(`Component ${DomainTest} ${KeyTest} - Type: Manager - Library: 0 - Items: 0`);
-    });
-
-    test('string output with library', () => {
-      managerTest = new DTManagerTest(IDTest, KeyTest, generateStubElements(5));
-
-      const toStringManager = managerTest.toString();
-
-      expect(toStringManager).toBe(`Component ${KeyTest} - Type: Manager - Library: 5 - Items: 0`);
-    });
-
-    test('string output with library and items', () => {
-      managerTest.populate();
-
-      const toStringManager = managerTest.toString();
-
-      expect(toStringManager).toBe(`Component ${KeyTest} - Type: Manager - Library: 5 - Items: 3`);
-    });
-  });
-});