dyo-tools 0.3.2 → 0.4.0

package/test/core/DTElement.spec.ts

@@ -1,22 +1,13 @@
 import {beforeEach, describe, expect, jest, test} from '@jest/globals';
 import {DomainTest, DTElementTest, IDTest, KeyTest} from './DTElement.double';
 import {MeldrineMetaData} from './DTComponentWithMeta.double';
-import {DTComponentPhysical, DTElement} from "../../src";
-import {mockOverriddenMethods, OwnerTest} from "./DTComponentPhysical.double";
+import {DTBunch, DTComponentPhysical, DTElement} from "../../src";
+import {OwnerTest} from "./DTComponentPhysical.double";
 import {DTBunchStub, IDTest as bunchIdTest} from "./DTBunch.double";
 
-/******************** MOCK DEPENDENCIES
- * All Dependencies used by the component are mocked with Jest
- * *****/
-jest.mock('../../src/core/DTComponent');
-jest.mock('../../src/core/DTComponentWithMeta');
-jest.mock('../../src/core/DTComponentPhysical');
-jest.mock('../../src/core/DTBunch');
-// Add specific mock for inherited methods to have a basic implementation
-mockOverriddenMethods(DTComponentPhysical);
 
 /************************* TESTS SUITES *******************************/
-describe('class DYOToolsElement', () => {
+describe('class DTElement', () => {
   let elementTest: DTElementTest;
 
   beforeEach(() => {
@@ -35,7 +26,7 @@ describe('class DYOToolsElement', () => {
 
   describe('_componentType', () => {
     test('componentType must be "element"', () => {
-      expect(elementTest.th_get_componentType()).toBe('element');
+      expect(elementTest.getComponentType()).toBe('element');
     });
   });
 
@@ -46,7 +37,7 @@ describe('class DYOToolsElement', () => {
 
     test('return container', () => {
       const container = new DTBunchStub();
-      elementTest.th_set_container(container);
+      elementTest = new DTElementTest(IDTest, KeyTest, container);
 
       expect(elementTest.getContainer()).toBeDefined();
       expect(elementTest.getContainer().getId()).toStrictEqual(bunchIdTest);
@@ -57,32 +48,24 @@ describe('class DYOToolsElement', () => {
     test('set a new container for element', () => {
       const container = new DTBunchStub();
 
-      elementTest.setContainer(container);
+      elementTest.setContainer(container as DTBunch);
 
-      expect(elementTest.th_get_container()).toBeDefined();
-      expect(elementTest.th_get_container().getId()).toStrictEqual(bunchIdTest);
+      expect(elementTest.getContainer()).toBeDefined();
+      expect(elementTest.getContainer().getId()).toStrictEqual(bunchIdTest);
     });
   });
 
   describe('removeContainer()', () => {
     test('remove the current container', () => {
       const bunchContainer = new DTBunchStub();
-      elementTest.th_set_container(bunchContainer);
+      elementTest = new DTElementTest(IDTest, KeyTest, bunchContainer);
 
       elementTest.removeContainer();
-      expect(elementTest.th_get_container()).toBeUndefined();
+      expect(elementTest.getContainer()).toBeUndefined();
     });
   });
 
-  describe('copy()', () => {
-    // @see copy.spec.ts for unit tests about copy method
-  })
-
   describe('toObject()', () => {
-    beforeEach(() => {
-      elementTest.th_set_id(IDTest);
-      elementTest.th_set_key(KeyTest);
-    })
 
     test('toObject output standard', () => {
       const toObjectElement = elementTest.toObject();
@@ -94,7 +77,7 @@ describe('class DYOToolsElement', () => {
     });
 
     test('toObject output standard with owner', () => {
-      elementTest.th_set_owner(OwnerTest);
+      elementTest.setOwner(OwnerTest);
 
       const toObjectElement = elementTest.toObject();
 
@@ -103,11 +86,8 @@ describe('class DYOToolsElement', () => {
     });
 
     test('toObject output standard with owner and meta', () => {
-      jest.spyOn(elementTest, 'getManyMeta').mockImplementation(function () {
-        return this._meta;
-      });
-      elementTest.th_set_owner(OwnerTest);
-      elementTest.th_set_meta(MeldrineMetaData);
+      elementTest.setOwner(OwnerTest);
+      elementTest.setManyMeta(MeldrineMetaData);
 
       const toObjectElement = elementTest.toObject();
 
@@ -117,9 +97,6 @@ describe('class DYOToolsElement', () => {
   });
 
   describe('toString()', () => {
-    beforeEach(() => {
-      elementTest.th_set_key(KeyTest);
-    })
 
     test('string output standard', () => {
       const toStringElement = elementTest.toString();
@@ -128,7 +105,7 @@ describe('class DYOToolsElement', () => {
     });
 
     test('string output standard with domain', () => {
-      elementTest.th_set_domain(DomainTest);
+      elementTest = new DTElementTest(IDTest, KeyTest, undefined, DomainTest);
 
       const toStringElement = elementTest.toString();
 
@@ -136,7 +113,7 @@ describe('class DYOToolsElement', () => {
     });
 
     test('string output standard with owner', () => {
-      elementTest.th_set_owner(OwnerTest);
+      elementTest.setOwner(OwnerTest);
 
       const toStringElement = elementTest.toString();
 

package/test/core/DTError.double.ts

@@ -1,7 +1,8 @@
 import {DTError} from '../../src';
 import {expect} from "@jest/globals";
-import DYOToolsComponent from "../../src/core/DTComponent";
+import DTComponent from "../../src/core/DTComponent";
 import MockedFunction = jest.MockedFunction;
+import {DTComponentStub} from "./DTComponent.double";
 
 /******************** STUB PROPERTIES CONSTANTS
  * Fixed properties to use with double classes, avoid auto generated and easy checking on test
@@ -15,36 +16,25 @@ export const TimestampTest = 1500000000000;
  * Providing methods to property access and other facilities, in order to avoid using class methods
  * *****/
 export class DTErrorTest extends DTError {
-  th_get_code(): string {
-    return this.code;
-  }
-
-  th_get_message(): string {
-    return this.message;
-  }
-
-  th_get_timestamp(): Date {
-    return this.timestamp;
-  }
-
-  th_set_timestamp(timestamp: Date): void {
-    this.timestamp = timestamp;
-  }
-
-  th_get_initiator(): DYOToolsComponent {
-    return this.initiator;
-  }
-
-  th_set_initiator(initiator: DYOToolsComponent): void {
-    this.initiator = initiator;
+  constructor(
+    code: string,
+    message: string,
+    initiator?: DTComponentStub,
+    convicted?: DTComponentStub,
+    timestamp?: Date,
+  ) {
+    super(code, message, initiator, convicted);
+    if (timestamp) {
+      this.timestamp = timestamp;
+    }
   }
 
-  th_get_convicted(): DYOToolsComponent {
-    return this.convicted;
+  _getConvictedId(): string | undefined {
+    return (this.convicted as DTComponentStub)._getStubId();
   }
 
-  th_set_convicted(convicted: DYOToolsComponent): void {
-    this.convicted = convicted;
+  _getInitiatorId(): string | undefined {
+    return (this.initiator as DTComponentStub)._getStubId();
   }
 }
 
@@ -58,35 +48,10 @@ export class DTErrorStub extends DTError {
     this.message = MessageTest;
     this.timestamp = new Date(Math.random() * 100000000);
   }
-
-  getCode(): string {
-    return CodeTest;
-  }
-
-  getMessage(): string {
-    return MessageTest;
-  }
-
-  getTimestamp(): Date {
-    return this.timestamp;
-  }
 }
 
 /******************** HELPER METHODS
  * Additional helper methods to use with testing
  * *****/
-export const checkCallForMockedDTError = (code, message, initiatorId, convictedId?) => {
-  const mockedErrorConstructor = DTError.prototype.constructor as MockedFunction<(code: string, message: string, initiator?: DYOToolsComponent, convicted?: DYOToolsComponent) => DTError>;
-  if (!mockedErrorConstructor.mock) {
-    throw new Error('The DTError Constructor is not a mock');
-  } else {
-    expect(mockedErrorConstructor.mock.calls.length).toBe(1);
-    expect(mockedErrorConstructor.mock.calls[0][0]).toBe(code);
-    expect(mockedErrorConstructor.mock.calls[0][1]).toBe(message);
-    expect(mockedErrorConstructor.mock.calls[0][2].getId()).toBe(initiatorId);
-    if (convictedId) {
-      expect(mockedErrorConstructor.mock.calls[0][3].getId()).toBe(convictedId);
-    }
-  }
-};
+
 

package/test/core/DTError.spec.ts

@@ -1,13 +1,16 @@
 import {afterEach, beforeEach, describe, expect, jest, test,} from '@jest/globals';
 import {CodeTest, DTErrorTest, MessageTest, TimestampTest,} from './DTError.double';
 import {DTComponentStub, IDTest as ComponentIdTest} from './DTComponent.double';
+import {DTError} from "../../src";
 
 /************************* TESTS SUITES *******************************/
-describe('class DYOToolsError', () => {
+describe('class DTError', () => {
   let errorTest: DTErrorTest;
 
   beforeEach(() => {
-    errorTest = new DTErrorTest(CodeTest, MessageTest);
+    const initiatorStub = new DTComponentStub('initiator');
+    const convictedStub = new DTComponentStub('convicted');
+    errorTest = new DTErrorTest(CodeTest, MessageTest, initiatorStub, convictedStub, new Date(TimestampTest));
   });
 
   afterEach(() => {
@@ -16,30 +19,30 @@ describe('class DYOToolsError', () => {
 
   describe('constructor()', () => {
     test('creation with standard field (code, message and timestamp)', () => {
-      const newError = new DTErrorTest(CodeTest, MessageTest);
+      const newError = new DTError(CodeTest, MessageTest);
       const currentDate = new Date();
 
-      expect(newError.th_get_code()).toBe(CodeTest);
-      expect(newError.th_get_message()).toBe(MessageTest);
-      expect(newError.th_get_timestamp().toDateString()).toBe(currentDate.toDateString());
-      expect(newError.th_get_timestamp().toTimeString()).toBe(currentDate.toTimeString());
-      expect(newError.th_get_initiator()).toBeUndefined();
-      expect(newError.th_get_convicted()).toBeUndefined();
+      expect(newError.getCode()).toBe(CodeTest);
+      expect(newError.getMessage()).toBe(MessageTest);
+      expect(newError.getTimestamp().toDateString()).toBe(currentDate.toDateString());
+      expect(newError.getTimestamp().toTimeString()).toBe(currentDate.toTimeString());
+      expect(newError.getInitiator()).toBeUndefined();
+      expect(newError.getConvicted()).toBeUndefined();
     });
 
     test('creation with initiator component', () => {
-      const initiatorMock = new DTComponentStub('initiator');
-      const newError = new DTErrorTest(CodeTest, MessageTest, initiatorMock);
+      const initiatorStub = new DTComponentStub('initiator');
+      const newError = new DTErrorTest(CodeTest, MessageTest, initiatorStub);
 
-      expect(newError.th_get_initiator().getId()).toBe(`${ComponentIdTest}-initiator`);
+      expect(newError._getInitiatorId()).toBe(`${ComponentIdTest}-initiator`);
     });
 
     test('creation with initiator and convicted component', () => {
-      const initiatorMock = new DTComponentStub('initiator');
-      const convictedMock = new DTComponentStub('convicted');
-      const newError = new DTErrorTest(CodeTest, MessageTest, initiatorMock, convictedMock);
+      const initiatorStub = new DTComponentStub('initiator');
+      const convictedStub = new DTComponentStub('convicted');
+      const newError = new DTErrorTest(CodeTest, MessageTest, initiatorStub, convictedStub);
 
-      expect(newError.th_get_convicted().getId()).toBe(`${ComponentIdTest}-convicted`);
+      expect(newError._getConvictedId()).toBe(`${ComponentIdTest}-convicted`);
     });
   });
 
@@ -57,33 +60,19 @@ describe('class DYOToolsError', () => {
 
   describe('getTimestamp()', () => {
     test('return timestamp property', () => {
-      errorTest.th_set_timestamp(new Date(TimestampTest));
-
       expect(errorTest.getTimestamp().getTime()).toBe(TimestampTest);
     });
   });
 
   describe('getInitiator()', () => {
-    test('return empty initiator component by default', () => {
-      expect(errorTest.getInitiator()).toBeUndefined();
-    });
-
     test('return initiator component when set', () => {
-      errorTest.th_set_initiator(new DTComponentStub('initiator'));
-
-      expect(errorTest.getInitiator().getId()).toBe(`${ComponentIdTest}-initiator`);
+      expect(errorTest._getInitiatorId()).toBe(`${ComponentIdTest}-initiator`);
     });
   });
 
   describe('getConvicted()', () => {
-    test('return empty convicted component by default', () => {
-      expect(errorTest.getConvicted()).toBeUndefined();
-    });
-
     test('return convicted component when set', () => {
-      errorTest.th_set_convicted(new DTComponentStub('convicted'));
-
-      expect(errorTest.getConvicted().getId()).toBe(`${ComponentIdTest}-convicted`);
+      expect(errorTest._getConvictedId()).toBe(`${ComponentIdTest}-convicted`);
     });
   });
 });

package/test/core/DTManager.double.ts

@@ -1,19 +1,15 @@
 import {expect} from '@jest/globals';
-import {DTElement, DTManager} from '../../src';
+import {DTBunch, DTManager} from '../../src';
 import {
-  bunch1IdTest,
   bunch1toObjectTest,
-  bunch2IdTest,
-  bunch2toObjectTest,
-  bunch3IdTest,
-  bunch3toObjectTest,
-  defaultOptions,
+  DTBunchStub,
   DTBunchStubLibrary,
-  DTBunchTest,
-  generateMockedElements,
+  generateStubElements,
+  IDTest as IDTestBunch,
 } from './DTBunch.double';
-import {DTAcceptedMetaData, DTManagerItemsType, DTManagerOptions, DTManagerToObject} from '../../src/types';
-import DYOFinder from '../../src/libs/DYOFinder';
+import {DTManagerItemsType, DTManagerItemType, DTManagerOptions, DTManagerToObject} from '../../src/types';
+import {DTElementStub,} from "./DTElement.double";
+import {managerDefaultOptions} from "../../src/constants";
 
 /** ****************** STUB PROPERTIES CONSTANTS
  * Fixed properties to use with double classes, avoid auto generated and easy checking on test
@@ -43,83 +39,86 @@ export const manager1ToObject: DTManagerToObject = {
  * Helper test class, inherits the main component
  * Providing methods to property access and other facilities, in order to avoid using class methods
  * **** */
-export class DTManagerTest extends DTManager<DTElement<DTAcceptedMetaData>> {
-  th_get_id(): string {
-    return this._id;
-  }
-
-  th_set_id(id: string): void {
+export class DTManagerTest extends DTManager<DTElementStub> {
+  constructor(
+    id: string = IDTest,
+    key: string | undefined = undefined,
+    elements: DTElementStub[] = [],
+    scopes: string[] = [],
+    options: Partial<DTManagerOptions> = managerDefaultOptions,
+    stubLibrary: boolean = true,
+  ) {
+    super(key, elements, scopes, options);
     this._id = id;
+    if (stubLibrary) {
+      this._library = new DTBunchStubLibrary(elements);
+    }
   }
 
-  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_domain(): string {
-    return this._domain;
-  }
-
-  th_set_domain(domain: string): void {
-    this._domain = domain;
-  }
-
-  th_get_items(): any {
+  _getItems(): DTManagerItemsType<DTElementStub> {
     return this._items;
   }
 
-  th_set_items(items: DTManagerItemsType<DTElement<DTAcceptedMetaData>>): void {
-    this._items = items;
-  }
-
-  th_get_single_item(id: string): any {
+  _getItem(id: string): DTManagerItemType<DTElementStub> | undefined {
     return this._items[id];
   }
 
-  th_get_scopes(): any {
-    return this._scopes;
-  }
-
-  th_set_scopes(scopes: any): void {
-    this._scopes = scopes;
-  }
-
-  th_get_library(): any {
-    return this._library;
-  }
-
-  th_set_library(library: any): void {
-    this._library = library;
+  _getFinder() {
+    return this._finder;
   }
 
-  th_set_options(options: any): void {
-    this._options = {
-      ...this._options,
-      ...options,
+  populate() {
+    const stubElements = generateStubElements(5);
+
+    // Library
+    this._library = new DTBunchStubLibrary(stubElements);
+    this._library.setContext<DTManagerTest>(this);
+
+    // Bunches
+    const bunch1 = new DTBunchStub();
+    bunch1._setId(`${IDTestBunch}_1`);
+    bunch1.setContext<DTManagerTest>(this);
+    const bunch2 = new DTBunchStub();
+    bunch2._setId(`${IDTestBunch}_2`);
+    bunch2.setContext<DTManagerTest>(this);
+    const bunch3 = new DTBunchStub([], { virtualContainer: true });
+    bunch3._setId(`${IDTestBunch}_3`);
+    bunch3.setContext<DTManagerTest>(this);
+    this._items = {
+      [bunch1.getId()]: {
+        scope: 'default',
+        item: bunch1 as DTBunch<DTElementStub>,
+      },
+      [bunch2.getId()]: {
+        scope: ScopesTest[0],
+        item: bunch2 as DTBunch<DTElementStub>,
+      },
+      [bunch3.getId()]: {
+        scope: 'virtual',
+        item: bunch3 as DTBunch<DTElementStub>,
+      },
     };
-  }
 
-  th_get_finder(): DYOFinder {
-    return this._finder;
+    // Add items in Bunch
+    bunch1.addMany(stubElements);
   }
+}
+
+export class DTManagerTestDomain extends DTManagerTest {
+  protected _domain = DomainTest;
 
-  th_get_options(): DTManagerOptions {
-    return this._options;
+  constructor(
+    id: string = IDTest,
+    key: string | undefined = undefined,
+  ) {
+    super(id, key);
   }
 }
 
 /** ****************** STUB CLASS
  * Stub class, for using in other component
  * **** */
-export class DTManagerStub extends DTManagerTest {
+export class DTManagerStub extends DTManager<DTElementStub> {
   constructor() {
     super();
     this._id = IDTest;
@@ -133,84 +132,18 @@ export class DTManagerStub extends DTManagerTest {
     ];
   }
 
-  getId(): string {
-    return IDTest;
-  }
-
-  getKey(): string {
-    return KeyTest;
+  _setId(id: string) {
+    this._id = id;
   }
-}
 
-export class DTManagerStubDomain extends DTManagerTest {
-  protected _domain = DomainTest;
-
-  getDomain(): string {
-    return DomainTest;
+  _setKey(key: string) {
+    this._key = key;
   }
 }
 
-/** ****************** HELPER METHODS
- * Additional helper methods to use with testing
- * **** */
-// Add mocked bunches and elements to a Manager
-export function populateManager(manager: DTManagerTest): DTManagerTest {
-  const mockedElements = generateMockedElements(5);
-
-  // Library
-  manager.th_set_library(new DTBunchStubLibrary(mockedElements));
-
-  // Scopes
-  manager.th_set_scopes(ScopesTest);
-
-  // Bunches
-  const bunch1 = new DTBunchTest();
-  bunch1.th_set_items(mockedElements);
-  bunch1.th_set_id(bunch1IdTest);
-  jest.spyOn(bunch1, 'getId').mockImplementation(() => bunch1IdTest);
-  jest.spyOn(bunch1, 'getOptions').mockImplementation(() => ({ ...defaultOptions }));
-  jest.spyOn(bunch1, 'getAll').mockImplementation(function () { return this._items; });
-  jest.spyOn(bunch1, 'toObject').mockImplementation(() => bunch1toObjectTest);
-
-  const bunch2 = new DTBunchTest();
-  bunch2.th_set_items([]);
-  bunch2.th_set_id(bunch2IdTest);
-  jest.spyOn(bunch2, 'getId').mockImplementation(() => bunch2IdTest);
-  jest.spyOn(bunch2, 'getOptions').mockImplementation(() => ({ ...defaultOptions }));
-  jest.spyOn(bunch2, 'getAll').mockImplementation(function () { return this._items; });
-  jest.spyOn(bunch2, 'toObject').mockImplementation(() => bunch2toObjectTest);
-
-  const bunch3 = new DTBunchTest();
-  bunch3.th_set_items([]);
-  bunch3.th_set_id(bunch3IdTest);
-  bunch3.th_set_options({ virtualContainer: true });
-  jest.spyOn(bunch3, 'getId').mockImplementation(() => bunch3IdTest);
-  jest.spyOn(bunch3, 'getOptions').mockImplementation(() => ({ ...defaultOptions, virtualContainer: true }));
-  jest.spyOn(bunch3, 'getAll').mockImplementation(function () { return this._items; });
-  jest.spyOn(bunch3, 'toObject').mockImplementation(() => bunch3toObjectTest);
-
-  const items: DTManagerItemsType<DTElement<DTAcceptedMetaData>> = {
-    [bunch1.th_get_id()]: {
-      scope: 'default',
-      item: bunch1,
-    },
-    [bunch2.th_get_id()]: {
-      scope: ScopesTest[0],
-      item: bunch2,
-    },
-    [bunch3.th_get_id()]: {
-      scope: 'virtual',
-      item: bunch3,
-    },
-  };
-  manager.th_set_items(items);
-
-  return manager;
-}
-
 export const checkManagerItem = (managerTest: DTManagerTest, bunchId: string, scope: string): void => {
-  expect(managerTest.th_get_single_item(bunchId)).toBeDefined();
-  expect(Object.keys(managerTest.th_get_single_item(bunchId))).toStrictEqual(['scope', 'item']);
-  expect(managerTest.th_get_single_item(bunchId).scope).toBe(scope);
-  expect(managerTest.th_get_single_item(bunchId).item.th_get_id()).toBe(bunchId);
+  expect(managerTest._getItem(bunchId)).toBeDefined();
+  expect(Object.keys(managerTest._getItem(bunchId))).toStrictEqual(['scope', 'item']);
+  expect(managerTest._getItem(bunchId)?.scope).toBe(scope);
+  expect(managerTest._getItem(bunchId)?.item?.getId()).toBe(bunchId);
 };