dyo-tools 0.3.2 → 0.4.0

package/test/core/DTAction.double.ts

@@ -17,38 +17,22 @@ export const action1ToObject: DTComponentToObject = {
   type: 'action'
 }
 
-/******************** STUB ABSTRACT IMPLEMENTATION
- * Implementation of abstract component class for tests
- * *****/
-export class DTActionImpl extends DTAction<string> {
-  async execute(payload: string): Promise<void> {
-    throw `${this._key} : ${payload}`;
-  }
-}
-
 /** ****************** 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 DTActionTest extends DTActionImpl {
-  th_get_id(): string {
-    return this._id;
-  }
+export class DTActionTest extends DTAction<string> {
 
-  th_set_id(id: string): void {
+  constructor(
+    id: string = IDTest,
+    key: string = KeyTest,
+  ) {
+    super(key);
     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;
+  async execute(payload: string): Promise<void> {
+    throw `${this._key} : ${payload}`;
   }
 }
 
@@ -64,12 +48,12 @@ export class DTActionStub extends DTActionTest {
     this._errors = [];
   }
 
-  getId(): string {
-    return IDTest;
+  _setId(id: string) {
+    this._id = id;
   }
 
-  getKey(): string {
-    return KeyTest;
+  _setKey(key: string) {
+    this._key = key;
   }
 }
 

package/test/core/DTAction.spec.ts

@@ -1,24 +1,14 @@
-import {DTComponent, DTAction} from "../../src";
-import {mockOverriddenMethods} from "./DTComponent.double";
+import {DTAction, DTComponent} from "../../src";
 import {afterEach, beforeEach, describe, expect, jest, test} from "@jest/globals";
 import {DTActionTest, IDTest, KeyTest} from "./DTAction.double";
 
-/** ****************** MOCK DEPENDENCIES
- * Dependencies used by the component are mocked with Jest
- * **** */
-jest.mock('../../src/core/DTComponent');
-jest.mock('../../src/core/DTError');
-// Add specific mock for inherited methods to have a basic implementation
-mockOverriddenMethods(DTComponent);
-
 /** *********************** TESTS SUITES ****************************** */
-describe('class DYOToolsAction', () => {
+describe('class DTAction' +
+  '', () => {
   let actionTest: DTActionTest;
 
   beforeEach(() => {
     actionTest = new DTActionTest();
-    actionTest.th_set_id(IDTest);
-    actionTest.th_set_key(KeyTest);
   });
 
   afterEach(() => {
@@ -33,16 +23,18 @@ describe('class DYOToolsAction', () => {
 
   describe('_componentType', () => {
     test('componentType must be "action"', () => {
-      expect(actionTest.th_get_componentType()).toBe('action');
+      expect(actionTest.getComponentType()).toBe('action');
     });
   });
 
   describe('getMaster', () => {
     test('call get context with master accessor', () => {
+      const getContextSpy = jest.spyOn(actionTest, 'getContext');
+      
       actionTest.getMaster();
 
-      expect((actionTest.getContext as any).mock.calls.length).toBe(1);
-      expect((actionTest.getContext as any).mock.calls[0][0]).toBe('master');
+      expect(getContextSpy.mock.calls.length).toBe(1);
+      expect(getContextSpy.mock.calls[0][0]).toBe('master');
     });
   });
 

package/test/core/DTBunch.double.ts

@@ -1,5 +1,5 @@
-import {DTBunch, DTComponent} from '../../src';
-import {bunchDefaultOptions as DTBunchDefaultOptions} from '../../src/constants';
+import {DTBunch} from '../../src';
+import {bunchDefaultOptions, bunchDefaultOptions as DTBunchDefaultOptions} from '../../src/constants';
 import {
   HaileiMetaData,
   IldressMetaData,
@@ -8,9 +8,9 @@ import {
   MeldrineMetaData,
   YssaliaMetaData,
 } from './DTComponentWithMeta.double';
-import DYOToolsElement from '../../src/core/DTElement';
-import {DTBunchOptions, DTElementToObject} from '../../src/types';
+import {DIXObject, DTBunchOptions, DTElementToObject} from '../../src/types';
 import {
+  DTElementStub,
   HaileiIdTest,
   HaileiKeyTest,
   HaileiToObjectTest,
@@ -27,9 +27,6 @@ import {
   YssaliaKeyTest,
   YssaliaToObjectTest,
 } from './DTElement.double';
-import {DTErrorStub} from './DTError.double';
-import DYOFinder from '../../src/libs/DYOFinder';
-import Mocked = jest.Mocked;
 
 /** ****************** STUB PROPERTIES CONSTANTS
  * Fixed properties to use with double classes, avoid auto generated and easy checking on test
@@ -38,91 +35,47 @@ import Mocked = jest.Mocked;
 export const IDTest = 'DTBunch-id-1234567';
 export const IDTestLibrary = 'DTBunch-id-library-1234567';
 export const KeyTest = 'DTBunch-key-1234567';
-export const defaultOptions: DTBunchOptions = DTBunchDefaultOptions;
 
 // Specific Bunch constants
 export const bunch1IdTest = `${IDTest}_1`;
 export const bunch1toObjectTest = {
-  id: bunch1IdTest, key: 'bunch1-key-test', type: 'bunch', items: [HaileiToObjectTest],
+  id: bunch1IdTest, key: KeyTest, type: 'bunch', items: [
+    HaileiToObjectTest,
+    MeldrineToObjectTest,
+    MaydenaToObjectTest,
+    IldressToObjectTest,
+    YssaliaToObjectTest
+  ],
 };
 export const bunch2IdTest = `${IDTest}_2`;
 export const bunch2toObjectTest = {
-  id: bunch2IdTest, key: 'bunch2-key-test', type: 'bunch', items: [],
+  id: bunch2IdTest, key: KeyTest, type: 'bunch', items: [],
 };
 export const bunch3IdTest = `${IDTest}_3`;
 export const bunch3toObjectTest = {
-  id: bunch3IdTest, key: 'bunch3-key-test', type: 'bunch', items: [],
+  id: bunch3IdTest, key: KeyTest, type: 'bunch', items: [],
 };
 
+
 /** ****************** 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 DTBunchTest extends DTBunch<Mocked<DYOToolsElement<IMetaDataTest>>, IMetaDataTest> {
-  th_get_id(): string {
-    return this._id;
-  }
-
-  th_set_id(id: string): void {
+export class DTBunchTest extends DTBunch<DTElementStub, IMetaDataTest> {
+
+  constructor(
+    id: string = IDTest,
+    key: string = KeyTest,
+    items: DTElementStub[] = [],
+    options: Partial<DTBunchOptions> = bunchDefaultOptions,
+    owner: string | undefined = undefined,
+  ) {
+    super(key, items, options);
     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_context(): DTComponent | undefined {
-    return this._context;
-  }
-
-  th_set_context(context: DTComponent): void {
-    this._context = context;
-  }
-
-  th_get_items(): Mocked<DYOToolsElement<IMetaDataTest>>[] {
-    return this._items;
-  }
-
-  th_set_items(items: Mocked<DYOToolsElement<IMetaDataTest>>[]): void {
-    this._items = items;
-  }
-
-  th_set_errors(errors: Array<DTErrorStub>): void {
-    this._errors = errors;
-  }
-
-  th_get_options(): any {
-    return this._options;
-  }
-
-  th_set_options(options: any): void {
-    this._options = {
-      ...this._options,
-      ...options,
-    };
-  }
-
-  th_get_owner(): string {
-    return this._owner;
-  }
-
-  th_set_owner(owner: string): void {
     this._owner = owner;
   }
 
-  th_set_meta(meta: IMetaDataTest): void {
-    this._meta = meta;
-  }
-
-  th_get_finder(): DYOFinder {
+  _getFinder() {
     return this._finder;
   }
 }
@@ -130,37 +83,28 @@ export class DTBunchTest extends DTBunch<Mocked<DYOToolsElement<IMetaDataTest>>,
 /** ****************** STUB CLASS
  * Stub class, for using in other component
  * **** */
-export class DTBunchStub extends DTBunchTest {
-  constructor(items: Array<Mocked<DYOToolsElement<IMetaDataTest>>> = []) {
+export class DTBunchStub extends DTBunch<DTElementStub> {
+  constructor(items: Array<DTElementStub> = [], options: Partial<DTBunchOptions> = {}) {
     super();
     this._id = IDTest;
     this._key = KeyTest;
     this._errors = [];
     this._items = items;
-    this._options = DTBunchDefaultOptions;
-  }
-
-  getId(): string {
-    return IDTest;
-  }
-
-  getKey(): string {
-    return KeyTest;
-  }
-
-  getAll(): Array<Mocked<DYOToolsElement<IMetaDataTest>>> {
-    return this._items;
+    this._options = {
+      ...DTBunchDefaultOptions,
+      ...options,
+    };
   }
 
-  getAllKeys(): string[] {
-    return this._items.map((item: DYOToolsElement<IMetaDataTest>) => item.getKey());
+  _setId(id: string) {
+    this._id = id;
   }
 }
 
 // Specific Stub Library for Manager
-export class DTBunchStubLibrary extends DTBunchStub {
-  constructor(items: Array<Mocked<DYOToolsElement<IMetaDataTest>>> = []) {
-    super(items);
+export class DTBunchStubLibrary extends DTBunch<DTElementStub> {
+  constructor(items: Array<DTElementStub> = []) {
+    super();
     this._id = IDTestLibrary;
     this._key = 'library';
     this._errors = [];
@@ -170,29 +114,15 @@ export class DTBunchStubLibrary extends DTBunchStub {
       virtualContainer: true,
     };
   }
-
-  getId(): string {
-    return IDTestLibrary;
-  }
-
-  getKey(): string {
-    return 'library';
-  }
-
-  get(id: string): Mocked<DYOToolsElement<IMetaDataTest>> | undefined {
-    const itemFiltered = this._items.filter((item: Mocked<DYOToolsElement<IMetaDataTest>>) => item.getId() === id);
-    return itemFiltered.length > 0 ? itemFiltered[0] : undefined;
-  }
 }
 
 /** ****************** HELPER METHODS
  * Additional helper methods to use with testing
  * **** */
 
-// Function to generate Mocked DTElement collection
-// Warning : DYOToolsElement class must be MOCKED to use this !
-export const generateMockedElements = (numberElements: number): Array<Mocked<DYOToolsElement<IMetaDataTest>>> => {
-  const mockedElements = [];
+// Function to generate Stub DTElement collection
+export const generateStubElements = (numberElements: number, owner?: string): DTElementStub[] => {
+  const mockedElements: DTElementStub[] = [];
   const mockedData: Array<{ id: string, key: string, meta: IMetaDataTest, toObject: DTElementToObject<IMetaDataTest> }> = [
     {
       id: HaileiIdTest,
@@ -227,35 +157,19 @@ export const generateMockedElements = (numberElements: number): Array<Mocked<DYO
   ];
 
   for (let i = 0; i < numberElements; i++) {
-    const mockedElement = new DYOToolsElement() as Mocked<DYOToolsElement<IMetaDataTest>>;
-    const selectedMock = i % 5;
-
-    mockedElement.getId.mockReturnValue(`${mockedData[selectedMock].id}-${i}`);
-    mockedElement.getKey.mockReturnValue(mockedData[selectedMock].key);
-    mockedElement.getManyMeta.mockReturnValue(mockedData[selectedMock].meta);
-    mockedElement.setContext.mockImplementation(function (context) {
-      this._context = context;
-    });
-    mockedElement.getContext.mockImplementation(function () {
-      return this._context;
-    });
-    mockedElement.setOwner.mockImplementation(function (owner) {
-      this._owner = owner;
-    });
-    mockedElement.getOwner.mockImplementation(function () {
-      return this._owner;
-    });
-    mockedElement.setContainer.mockImplementation(function (container) {
-      this._container = container;
-    });
-    mockedElement.getContainer.mockImplementation(function () {
-      return this._container;
-    });
-    mockedElement.copy.mockReturnValue(mockedElement);
-    mockedElement.toObject.mockReturnValue(mockedData[selectedMock].toObject);
+    const selectedData = i % 5;
+    const mockedElement = new DTElementStub(
+      0,
+      (mockedData[selectedData].id + "-" + i),
+      mockedData[selectedData].key,
+      mockedData[selectedData].meta,
+      owner,
+      mockedData[selectedData].toObject,
+    );
 
     mockedElements.push(mockedElement);
   }
 
   return mockedElements;
 };
+