dyo-tools 0.3.2 → 0.4.0

package/test/core/DTModule.double.ts

@@ -25,33 +25,20 @@ export const module1ToObject: DTModuleToObject = {
  * Providing methods to property access and other facilities, in order to avoid using class methods
  * **** */
 export class DTModuleTest extends DTModule {
-  th_get_id(): string {
-    return this._id;
-  }
 
-  th_set_id(id: string): void {
+  constructor(
+    id: string = IDTest,
+    key: string = KeyTest,
+    enabled: boolean = true,
+  ) {
+    super(key);
     this._id = id;
+    this._enabled = enabled
   }
 
-  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_enabled(): boolean {
+  _getEnabled(): boolean {
     return this._enabled;
   }
-
-  th_set_enabled(enabled: boolean): void {
-    this._enabled = enabled;
-  }
 }
 
 
@@ -66,12 +53,12 @@ export class DTModuleStub extends DTModuleTest {
     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/DTModule.spec.ts

@@ -1,25 +1,13 @@
 import {DTComponent, DTModule} from "../../src";
-import {mockOverriddenMethods} from "./DTComponent.double";
 import {afterEach, beforeEach, describe, expect, jest, test} from "@jest/globals";
 import {DTModuleTest, IDTest, KeyTest} from "./DTModule.double";
-import MockedFunction = jest.MockedFunction;
-
-/** ****************** 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 DYOToolsModule', () => {
+describe('class DTModule', () => {
   let moduleTest: DTModuleTest;
 
   beforeEach(() => {
     moduleTest = new DTModuleTest();
-    moduleTest.th_set_id(IDTest);
-    moduleTest.th_set_key(KeyTest);
   });
 
   afterEach(() => {
@@ -34,7 +22,7 @@ describe('class DYOToolsModule', () => {
 
   describe('_componentType', () => {
     test('componentType must be "action"', () => {
-      expect(moduleTest.th_get_componentType()).toBe('module');
+      expect(moduleTest.getComponentType()).toBe('module');
     });
   });
 
@@ -45,21 +33,19 @@ describe('class DYOToolsModule', () => {
 
     test('simple creation with key', () => {
       const newModule = new DTModuleTest(KeyTest);
-      const parentConstructorMock = (DTComponent.prototype.constructor as MockedFunction<(key: string, options: any) => void>).mock;
-
-      expect(parentConstructorMock.calls.length).toBe(1);
-      expect(parentConstructorMock.calls[0][0]).toBe(KeyTest);
 
-      expect(newModule.th_get_enabled()).toStrictEqual(true);
+      expect(newModule._getEnabled()).toStrictEqual(true);
     });
   });
 
   describe('getMaster()', () => {
     test('call get context with master accessor', () => {
+      const getContextSpy = jest.spyOn(moduleTest, 'getContext');
+      
       moduleTest.getMaster();
 
-      expect((moduleTest.getContext as any).mock.calls.length).toBe(1);
-      expect((moduleTest.getContext as any).mock.calls[0][0]).toBe('master');
+      expect(getContextSpy.mock.calls.length).toBe(1);
+      expect(getContextSpy.mock.calls[0][0]).toBe('master');
     });
   });
 
@@ -71,7 +57,7 @@ describe('class DYOToolsModule', () => {
     });
 
     test('return false if the module is disabled', () => {
-      moduleTest.th_set_enabled(false);
+      moduleTest = new DTModuleTest(IDTest, KeyTest, false);
 
       const enabledModule = moduleTest.isEnabled();
 
@@ -81,21 +67,21 @@ describe('class DYOToolsModule', () => {
 
   describe('enable()', () => {
     test('change enable to true', () => {
-      moduleTest.th_set_enabled(false);
+      moduleTest = new DTModuleTest(IDTest, KeyTest, false);
 
       moduleTest.enable();
 
-      expect(moduleTest.th_get_enabled()).toBe(true);
+      expect(moduleTest._getEnabled()).toBe(true);
     });
   });
 
   describe('disable()', () => {
     test('change enable to false', () => {
-      moduleTest.th_set_enabled(true);
+      moduleTest = new DTModuleTest(IDTest, KeyTest, true);
 
       moduleTest.disable();
 
-      expect(moduleTest.th_get_enabled()).toBe(false);
+      expect(moduleTest._getEnabled()).toBe(false);
     });
   });
 
@@ -107,7 +93,7 @@ describe('class DYOToolsModule', () => {
     });
 
     test('string output standard when disabled', () => {
-      moduleTest.th_set_enabled(false);
+      moduleTest = new DTModuleTest(IDTest, KeyTest, false);
 
       const toStringAction = moduleTest.toString();
 
@@ -127,7 +113,7 @@ describe('class DYOToolsModule', () => {
     });
 
     test('toObject output standard when disabled', () => {
-      moduleTest.th_set_enabled(false);
+      moduleTest = new DTModuleTest(IDTest, KeyTest, false);
 
       const toObjectAction: any = moduleTest.toObject();
 

package/test/core/copy.spec.ts

@@ -7,18 +7,9 @@ import {OwnerTest} from './DTComponentPhysical.double';
 import {
   BunchMetaData, HaileiMetaData, IMetaDataTest, PlayerMetaData,
 } from './DTComponentWithMeta.double';
-import { defaultOptions, KeyTest } from './DTBunch.double';
+import { KeyTest } from './DTBunch.double';
 import { DTErrorStub } from './DTError.double';
-
-/**
- * Special test suite for copy overridden method
- * Unfortunately copy is very hard to mock correctly in Javascript, due to constructor mocks
- * These test doesn't handle the DOC
- * Mock for :
- *   - DTBunch
- *   - DTElement
- *   - DTPlayer
- */
+import {bunchDefaultOptions} from "../../src/constants";
 
 describe('Inherited method copy', () => {
   describe('DTBunch copy()', () => {
@@ -71,7 +62,7 @@ describe('Inherited method copy', () => {
 
       expect(bunchCopy.getManyMeta()).toStrictEqual(BunchMetaData);
       expect(bunchCopy.getOptions()).toStrictEqual({
-        ...defaultOptions,
+        ...bunchDefaultOptions,
         ...copiedOptions,
       });
     });
@@ -156,28 +147,22 @@ describe('Inherited method copy', () => {
 
     test('copy an element - not copy container', () => {
       const element = new DTElement(KeyTest);
-      jest.spyOn(element, 'setContainer').mockImplementation(function (container) {
-        this._container = container;
-      });
 
       element.setContext(new DTComponentStub());
 
       const elementCopy = element.copy();
-      jest.spyOn(elementCopy, 'getContainer').mockImplementation(function () {
-        return this._container;
-      });
 
       expect(elementCopy.getContainer()).toBeUndefined();
     });
 
     test('copy an element - copy meta-data and options', () => {
-      const element = new DTElement(KeyTest, { errors: true });
-      jest.spyOn(element, 'getManyMeta').mockImplementation(() => HaileiMetaData);
+      const element = new DTElement(KeyTest, { errors: true, syncId: "123" });
+      element.setManyMeta(HaileiMetaData);
 
       const elementCopy = element.copy();
 
       expect(elementCopy.getManyMeta()).toStrictEqual(HaileiMetaData);
-      expect(elementCopy.getOptions()).toStrictEqual({ errors: true });
+      expect(elementCopy.getOptions()).toStrictEqual({ errors: true, syncId: "123" });
     });
 
     test('copy an element - empty errors', () => {
@@ -206,28 +191,22 @@ describe('Inherited method copy', () => {
 
     test('copy a player - not copy context', () => {
       const player = new DTPlayer(KeyTest);
-      jest.spyOn(player, 'setContext').mockImplementation(function (context) {
-        this._context = context;
-      });
 
       player.setContext(new DTComponentStub());
 
       const playerCopy = player.copy();
-      jest.spyOn(playerCopy, 'getContext').mockImplementation(function () {
-        return this._context;
-      });
 
       expect(playerCopy.getContext()).toBeUndefined();
     });
 
     test('copy a player - copy meta-data and options', () => {
-      const player = new DTPlayer(KeyTest, { errors: true });
-      jest.spyOn(player, 'getManyMeta').mockImplementation(() => PlayerMetaData);
+      const player = new DTPlayer(KeyTest, { errors: true, syncId: "123" });
+      player.setManyMeta(PlayerMetaData);
 
       const playerCopy = player.copy();
 
       expect(playerCopy.getManyMeta()).toStrictEqual(PlayerMetaData);
-      expect(playerCopy.getOptions()).toStrictEqual({ errors: true });
+      expect(playerCopy.getOptions()).toStrictEqual({ errors: true, syncId: "123" });
     });
 
     test('copy a player - empty errors', () => {

package/tsconfig.dev.json

@@ -1,20 +1,17 @@
 {
   "compilerOptions": {
-    "module": "commonjs",
+    "target": "es2020",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
     "declaration": true,
+    "declarationMap": true,
     "removeComments": true,
-    "emitDecoratorMetadata": true,
-    "experimentalDecorators": true,
     "allowSyntheticDefaultImports": true,
-    "target": "es2015",
-    "sourceMap": true,
     "outDir": "./dist",
-    "baseUrl": "./",
     "incremental": true
   },
   "include": [
-    "src/**/*.ts",
-    "test/**/*.ts"
+    "src/**/*.ts"
   ],
   "exclude": [
     "node_modules"

package/tsconfig.json

@@ -1,16 +1,13 @@
 {
   "compilerOptions": {
-    "module": "commonjs",
+    "target": "es2020",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
     "declaration": true,
+    "declarationMap": true,
     "removeComments": true,
-    "emitDecoratorMetadata": true,
-    "experimentalDecorators": true,
     "allowSyntheticDefaultImports": true,
-    "target": "es2015",
-    "sourceMap": true,
-    "outDir": "./dist",
-    "baseUrl": "./",
-    "incremental": true
+    "outDir": "./dist"
   },
   "include": [
     "src/**/*.ts"