dyo-tools 0.2.0 → 0.3.2

package/test/core/DTManager.spec.ts

@@ -1,4 +1,4 @@
-import { afterEach, beforeEach, describe, expect, jest, test, } from '@jest/globals';
+import {afterEach, beforeEach, describe, expect, jest, test,} from '@jest/globals';
 import {
   checkManagerItem,
   DomainTest,
@@ -17,20 +17,21 @@ import {
   bunch2toObjectTest,
   bunch3toObjectTest,
   DTBunchStub,
-  DTBunchStubLibrary, DTBunchTest,
+  DTBunchStubLibrary,
+  DTBunchTest,
   generateMockedElements,
   IDTest as IDTestBunch,
   IDTestLibrary,
   KeyTest as KeyTestBunch,
 } from './DTBunch.double';
-import { mockOverriddenMethods } from './DTComponent.double';
-import { DTComponent, DTComponentPhysical, DTElement } from '../../src';
+import {mockOverriddenMethods} from './DTComponent.double';
+import {DTComponent, DTComponentPhysical, DTElement} from '../../src';
 import DYOToolsError from '../../src/core/DTError';
-import { checkCallForMockedDTError, DTErrorStub } from './DTError.double';
-import { BunchMetaData, IMetaDataTest } from './DTComponentWithMeta.double';
-import { componentManagerDefaultFinderConfiguration, managerDefaultOptions } from '../../src/constants';
-import { FilterOperatorType } from '../../src/types';
-import { DTPlayerStub, IDTest as IDTestPlayer } from './DTPlayer.double';
+import {checkCallForMockedDTError, DTErrorStub} from './DTError.double';
+import {BunchMetaData, IMetaDataTest} from './DTComponentWithMeta.double';
+import {componentManagerDefaultFinderConfiguration, managerDefaultOptions} from '../../src/constants';
+import {FilterOperatorType} from '../../src/types';
+import {OwnerTest} from './DTComponentPhysical.double';
 import MockedFunction = jest.MockedFunction;
 
 /** ****************** MOCK DEPENDENCIES
@@ -63,7 +64,7 @@ describe('class DYOToolsManager', () => {
   });
 
   describe('_componentType', () => {
-    test('componentType must be "bunch"', () => {
+    test('componentType must be "manager"', () => {
       expect(managerTest.th_get_componentType()).toBe('manager');
     });
   });
@@ -88,7 +89,9 @@ describe('class DYOToolsManager', () => {
       expect(newManager.th_get_library().constructor.mock.calls.length).toBe(1);
       expect(newManager.th_get_library().constructor.mock.calls[0][0]).toBe('library');
       expect(newManager.th_get_library().constructor.mock.calls[0][1]).toStrictEqual([]);
-      expect(newManager.th_get_library().constructor.mock.calls[0][2].virtualContext).toBe(true);
+      expect(newManager.th_get_library().constructor.mock.calls[0][2].virtualContainer).toBe(true);
+      expect(newManager.th_get_library().setContext.mock.calls.length).toBe(1);
+      expect(newManager.th_get_library().setContext.mock.calls[0][0]).toStrictEqual(newManager);
 
       // Finder initialization
       expect((newManager.th_get_finder() as any).constructor.mock.calls.length).toBe(1);
@@ -97,6 +100,9 @@ describe('class DYOToolsManager', () => {
     });
 
     test('creation simple without key - use domain if defined', () => {
+      // Warning : this method doesn't really work because of Javascript
+      // The property _domain set is only available after constructing (not during)
+
       const newManager = new DTManager();
       const newManagerWithDomain = new DTManagerStubDomain();
       const newManagerWithDomain2 = new DTManagerStubDomain(null);
@@ -129,7 +135,9 @@ describe('class DYOToolsManager', () => {
       expect(newManager.th_get_library().constructor.mock.calls[0][1].length).toStrictEqual(5);
       expect(newManager.th_get_library().constructor.mock.calls[0][1].map((item) => item.getId()))
         .toStrictEqual(mockedElements.map((item) => item.getId()));
-      expect(newManager.th_get_library().constructor.mock.calls[0][2].virtualContext).toBe(true);
+      expect(newManager.th_get_library().constructor.mock.calls[0][2].virtualContainer).toBe(true);
+      expect(newManager.th_get_library().setContext.mock.calls.length).toBe(1);
+      expect(newManager.th_get_library().setContext.mock.calls[0][0]).toStrictEqual(newManager);
     });
 
     test('creation with extended scopes', () => {
@@ -195,18 +203,18 @@ describe('class DYOToolsManager', () => {
       const finderConfigurationToCheck = managerTest.getFinderConfiguration().owner;
 
       expect(finderConfigurationToCheck.operators).toStrictEqual(baseOperators);
-      expect(finderConfigurationToCheck.getValue(bunch)).toBeNull();
+      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').mockImplementation(() => new DTPlayerStub());
+      jest.spyOn(bunch, 'getOwner').mockReturnValue(OwnerTest);
 
       const finderConfigurationToCheck = managerTest.getFinderConfiguration().owner;
 
       expect(finderConfigurationToCheck.operators).toStrictEqual(baseOperators);
-      expect(finderConfigurationToCheck.getValue(bunch)).toBe(IDTestPlayer);
+      expect(finderConfigurationToCheck.getValue(bunch)).toBe(OwnerTest);
       expect(finderConfigurationToCheck.objectSearch).toBe(false);
     });
 
@@ -251,6 +259,15 @@ describe('class DYOToolsManager', () => {
     });
   });
 
+  describe('getMaster()', () => {
+    test('call get context with master accessor', () => {
+      managerTest.getMaster();
+
+      expect((managerTest.getContext as any).mock.calls.length).toBe(1);
+      expect((managerTest.getContext as any).mock.calls[0][0]).toBe('master');
+    });
+  });
+
   describe('isValidScope()', () => {
     beforeEach(() => {
       managerTest.th_set_scopes(ScopesTest);
@@ -303,7 +320,7 @@ describe('class DYOToolsManager', () => {
     });
 
     test('add a new item - virtual bunch in virtual scope', () => {
-      bunchToAdd.th_set_options({ virtualContext: true });
+      bunchToAdd.th_set_options({ virtualContainer: true });
 
       managerTest.add(bunchToAdd);
 
@@ -331,7 +348,7 @@ describe('class DYOToolsManager', () => {
     });
 
     test('trigger error if invalid scope for virtual bunch', () => {
-      bunchToAdd.th_set_options({ virtualContext: true });
+      bunchToAdd.th_set_options({ virtualContainer: true });
       const mockedTriggerError = DTManager.prototype.triggerError as MockedFunction<(error: DYOToolsError) => void>;
 
       managerTest.add(bunchToAdd, ScopesTest[0]);
@@ -438,6 +455,20 @@ describe('class DYOToolsManager', () => {
       expect(Object.keys(managerTest.th_get_items()).length).toBe(1);
       checkManagerItem(managerTest, IDTestBunch, 'default');
     });
+
+    test('set context when adding an item - update context with manager for all library elements', () => {
+      const oldManagerTest = new DTManagerTest();
+      const bunchElements = generateMockedElements(5);
+      bunchToAdd.th_set_items(bunchElements);
+      bunchToAdd.th_set_context(oldManagerTest);
+
+      managerTest.add(bunchToAdd);
+
+      for (const element of bunchElements) {
+        expect((element.setContext as any).mock.calls.length).toBe(1);
+        expect((element.setContext as any).mock.calls[0][0]).toStrictEqual(managerTest);
+      }
+    });
   });
 
   describe('addMany()', () => {
@@ -759,6 +790,29 @@ describe('class DYOToolsManager', () => {
       expect(managerTest.th_get_library().remove.mock.calls.length).toBe(5);
       expect(managerTest.th_get_library().remove.mock.calls.map((call: any) => call[0])).toEqual(libraryElementsIdToRemove);
     });
+
+    test('remove context when removing a bunch - standard case', () => {
+      const bunch1 = managerTest.th_get_single_item(`${IDTestBunch}_1`).item;
+      const bunch2 = managerTest.th_get_single_item(`${IDTestBunch}_2`).item;
+
+      managerTest.removeMany([`${IDTestBunch}_1`, `${IDTestBunch}_2`]);
+
+      expect((bunch1.removeContext as any).mock.calls.length).toBe(1);
+      expect((bunch2.removeContext as any).mock.calls.length).toBe(1);
+    });
+
+    test('remove context when removing a bunch - remove context for all library elements', () => {
+      const bunch1 = managerTest.th_get_single_item(`${IDTestBunch}_1`).item;
+      const bunchElements = generateMockedElements(5);
+      bunch1.th_set_items(bunchElements);
+      bunch1.th_set_context(managerTest);
+
+      managerTest.removeMany([`${IDTestBunch}_1`]);
+
+      for (let element of bunchElements) {
+        expect((element.removeContext as any).mock.calls.length).toBe(1);
+      }
+    });
   });
 
   describe('removeAll()', () => {
@@ -882,6 +936,15 @@ describe('class DYOToolsManager', () => {
       expect(toStringManager).toBe(`Component ${KeyTest} - Type: Manager - Library: 0 - Items: 0`);
     });
 
+    test('string output with domain', () => {
+      managerTest.th_set_library(new DTBunchStubLibrary());
+      managerTest.th_set_domain(DomainTest);
+
+      const toStringManager = managerTest.toString();
+
+      expect(toStringManager).toBe(`Component ${DomainTest} ${KeyTest} - Type: Manager - Library: 0 - Items: 0`);
+    });
+
     test('string output with library', () => {
       populateManager(managerTest);
       managerTest.th_set_items({});

package/test/core/DTMaster.double.ts

@@ -0,0 +1,141 @@
+import {expect, jest} from "@jest/globals";
+import {DTAction, DTManager, DTMaster, DTModule} from "../../src";
+import {DTManagerStub, IDTest as IDManagerTest, manager1IDTest, manager1KeyTest} from "./DTManager.double";
+import {DTActionStub, IDTest as IDActionTest, action1IDTest, action1KeyTest} from "./DTAction.double";
+import {DTModuleStub, IDTest as IDModuleTest, module1IDTest, module1KeyTest} from "./DTModule.double";
+
+/** ****************** STUB PROPERTIES CONSTANTS
+ * Fixed properties to use with double classes, avoid auto generated and easy checking on test
+ * **** */
+export const IDTest = 'DTMaster-id-1234567';
+export const KeyTest = 'DTMaster-key-1234567';
+
+/** ****************** HELPER TEST CLASS
+ * Helper test class, inherits the main component
+ * Providing methods to property access and other facilities, in order to avoid using class methods
+ * **** */
+export class DTMasterTest extends DTMaster {
+  th_get_id(): string {
+    return this._id;
+  }
+
+  th_set_id(id: string): void {
+    this._id = id;
+  }
+
+  th_get_key(): string {
+    return this._key;
+  }
+
+  th_set_key(key: string): void {
+    this._key = key;
+  }
+
+  th_get_componentType(): string {
+    return this._componentType;
+  }
+
+  th_get_managers(): Record<string, DTManager<any>> {
+    return this._managers;
+  }
+
+  th_set_managers(managers: Record<string, DTManager<any>>): void {
+    this._managers = managers;
+  }
+
+  th_get_actions(): Record<string, DTAction> {
+    return this._actions;
+  }
+
+  th_set_actions(actions: Record<string, DTAction>): void {
+    this._actions = actions;
+  }
+
+  th_get_modules(): Record<string, DTModule> {
+    return this._modules;
+  }
+
+  th_set_modules(modules: Record<string, DTModule>): void {
+    this._modules = modules;
+  }
+}
+
+
+/** ****************** STUB CLASS
+ * Stub class, for using in other component
+ * **** */
+
+/** ****************** HELPER METHODS
+ * Additional helper methods to use with testing
+ * **** */
+export const checkMasterManagers = (master: DTMasterTest, ids: string[]) => {
+  let i = 0;
+  expect(Object.keys(master.th_get_managers()).length).toBe(ids.length);
+  for (let [id, manager] of Object.entries(master.th_get_managers())) {
+    expect(id).toBe(ids[i]);
+    expect(manager.getId()).toBe(ids[i]);
+    i++;
+  }
+}
+
+export const checkMasterActions = (master: DTMasterTest, ids: string[]) => {
+  let i = 0;
+  expect(Object.keys(master.th_get_actions()).length).toBe(ids.length);
+  for (let [id, action] of Object.entries(master.th_get_actions())) {
+    expect(id).toBe(ids[i]);
+    expect(action.getId()).toBe(ids[i]);
+    i++;
+  }
+}
+
+export const checkMasterModules = (master: DTMasterTest, ids: string[]) => {
+  let i = 0;
+  expect(Object.keys(master.th_get_modules()).length).toBe(ids.length);
+  for (let [id, module] of Object.entries(master.th_get_modules())) {
+    expect(id).toBe(ids[i]);
+    expect(module.getId()).toBe(ids[i]);
+    i++;
+  }
+}
+
+export const populateMaster = (master: DTMasterTest) => {
+  // Managers
+  const manager1 = new DTManagerStub();
+  const manager2 = new DTManagerStub();
+  manager2.th_set_id(manager1IDTest);
+  manager2.th_set_key(manager1KeyTest);
+  jest.spyOn(manager2, 'getId').mockReturnValue(manager1IDTest);
+  jest.spyOn(manager2, 'getKey').mockReturnValue(manager1KeyTest);
+
+  master.th_set_managers({
+    [IDManagerTest]: manager1,
+    [manager1IDTest]: manager2
+  });
+
+  // Actions
+  const action1 = new DTActionStub();
+  const action2 = new DTActionStub();
+  action2.th_set_id(action1IDTest);
+  action2.th_set_key(action1KeyTest);
+  jest.spyOn(action2, 'getId').mockReturnValue(action1IDTest);
+  jest.spyOn(action2, 'getKey').mockReturnValue(action1KeyTest);
+
+  master.th_set_actions({
+    [IDActionTest]: action1,
+    [action1IDTest]: action2
+  });
+
+  // Modules
+  const module1 = new DTModuleStub();
+  const module2 = new DTModuleStub();
+  module2.th_set_id(module1IDTest);
+  module2.th_set_key(module1KeyTest);
+  module2.th_set_enabled(false);
+  jest.spyOn(module2, 'getId').mockReturnValue(module1IDTest);
+  jest.spyOn(module2, 'getKey').mockReturnValue(module1KeyTest);
+
+  master.th_set_modules({
+    [IDModuleTest]: module1,
+    [module1IDTest]: module2
+  });
+}