dyo-tools 0.3.2 → 0.4.0

package/test/core/DTComponent.double.ts

@@ -1,7 +1,8 @@
 import {DTComponent} from "../../src";
 import {DTErrorStub} from "./DTError.double";
 import {jest} from "@jest/globals";
-import {DTComponentOptions} from "../../src/types";
+import {DIXObject, DTComponentOptions, DTComponentToDIXObject} from "../../src/types";
+import * as domain from "domain";
 
 interface IOptionsTest extends DTComponentOptions {
     option1: boolean
@@ -18,6 +19,14 @@ export const ToObjectTest = { type: "DTComponent-test-toObject" };
 export const ToStringTest = "DTComponent-test-toString";
 export const DomainTest = "DTComponent-domain-test";
 export const SubKindTest = "DTComponent-subkind-test";
+export const ToDIXObjectTest = {
+  [IDTest]: {
+    key: KeyTest,
+    componentType: ComponentTypeTest,
+    domain: DomainTest,
+    subKind: SubKindTest,
+  }
+}
 
 /******************** STUB ABSTRACT IMPLEMENTATION
  * Implementation of abstract component class for tests
@@ -36,6 +45,9 @@ export class DTComponentImpl extends DTComponent<IOptionsTest> {
     toString(): string {
         return ToStringTest;
     }
+
+    updateFromDix(dix: Record<string, DIXObject>): void {
+    }
 }
 
 /******************** HELPER TEST CLASS
@@ -94,6 +106,9 @@ export class DTComponentTest extends DTComponentImpl {
     th_set_options(options: any): void {
         this._options = options;
     }
+
+    updateFromDix(dix: Record<string, DIXObject>): void {
+    }
 }
 
 /******************** STUB CLASS
@@ -107,7 +122,7 @@ export class DTComponentStub extends DTComponentTest {
         this.stubId = IDTest + (idSuffix && `-${idSuffix}`);
     }
 
-    getId() {
+    _getStubId(): string {
         return this.stubId;
     }
 }

package/test/core/DTComponent.spec.ts

@@ -3,15 +3,15 @@ import {
   ComponentTypeTest,
   DomainTest,
   DTComponentTest,
-  DTComponentImpl,
   IDTest,
   KeyTest,
   simulateHierarchy,
   SubKindTest,
+  ToDIXObjectTest,
 } from './DTComponent.double';
 import {DTErrorStub} from "./DTError.double";
 
-describe('class DYOToolsComponent', () => {
+describe('class DTComponent', () => {
   let componentTest: DTComponentTest;
 
   beforeEach(() => {
@@ -49,15 +49,17 @@ describe('class DYOToolsComponent', () => {
       const component = new DTComponentTest();
 
       expect(component.th_get_options()).toStrictEqual({
-        errors: false
+        errors: false,
+        syncId: undefined,
       });
     });
 
     test('creations with options', () => {
-      const component = new DTComponentTest(KeyTest, { errors: true, option1: false, option2: true });
+      const component = new DTComponentTest(KeyTest, { errors: true, option1: false, option2: true, syncId: "123" });
 
       expect(component.th_get_options()).toStrictEqual({
         errors: true,
+        syncId: "123",
         option1: false,
         option2: true
       });

package/test/core/DTComponentPhysical.double.ts

@@ -10,26 +10,19 @@ export const ComponentTypeTest = "DTComponentPhysical-componentType-test";
 export const ToObjectTest = { type: "DTComponentPhysical-test-toObject" };
 export const ToStringTest = "DTComponentPhysical-test-toString";
 export const OwnerTest = "owner-12345";
-
-/******************** STUB ABSTRACT IMPLEMENTATION
- * Implementation of abstract component class for tests
- * *****/
-export class DTComponentPhysicalImpl extends DTComponentPhysical<IMetaDataTest> {
-    protected _componentType: string = ComponentTypeTest;
-
-    copy(): DTComponentPhysical<IMetaDataTest> {
-        return this;
+export const ParentToDIXObjectTest = {
+    [IDTest]: {
+        key: KeyTest,
+        componentType: ComponentTypeTest,
+        meta: {}
     }
-
-    toObject(): any {
-        return ToObjectTest;
-    }
-
-    toString(): string {
-        return ToStringTest;
-    }
-
-    do(): void {
+}
+export const ToDIXObjectTest = {
+    [IDTest]: {
+        key: KeyTest,
+        componentType: ComponentTypeTest,
+        meta: {},
+        owner: OwnerTest,
     }
 }
 
@@ -37,40 +30,33 @@ export class DTComponentPhysicalImpl extends DTComponentPhysical<IMetaDataTest>
  * Helper test class, inherits the main component
  * Providing methods to property access and other facilities, in order to avoid using class methods
  * *****/
-export class DTComponentPhysicalTest extends DTComponentPhysicalImpl {
-    th_get_owner(): string {
-        return this._owner;
-    }
+export class DTComponentPhysicalTest extends DTComponentPhysical<IMetaDataTest> {
+    protected _componentType: string = ComponentTypeTest;
 
-    th_set_owner(owner: string): void {
+    constructor(
+      id: string = IDTest,
+      key: string = KeyTest,
+      owner?: string,
+    ) {
+        super(key);
+        this._id = id;
         this._owner = owner;
     }
-}
 
-/******************** STUB CLASS
- * Stub class, for using in other component
- * *****/
-export class DTComponentPhysicalStub extends DTComponentPhysicalTest {
-    private readonly stubId: string;
+    copy(): DTComponentPhysical<IMetaDataTest> {
+        return this;
+    }
 
-    constructor(idSuffix: string = "") {
-        super();
-        this.stubId = IDTest + (idSuffix && `-${idSuffix}`);
+    toObject(): any {
+        return ToObjectTest;
     }
 
-    getId() {
-        return this.stubId;
+    toString(): string {
+        return ToStringTest;
     }
 }
 
 /******************** HELPER METHODS
  * Additional helper methods to use with testing
  * *****/
-// Mocked implementations for overridden methods (for children tests)
-export function mockOverriddenMethods(mock: any) {
-    // Constructor
-    mock.prototype.constructor.mockImplementation(function (key?: string) {
-        this._id = IDTest;
-        this._key = key || this._id;
-    })
-}
+

package/test/core/DTComponentPhysical.spec.ts

@@ -1,18 +1,9 @@
 import {beforeEach, describe, expect, jest, test} from '@jest/globals';
-import {mockOverriddenMethods} from "./DTComponentWithMeta.double";
-import {DTComponentPhysicalTest, OwnerTest} from './DTComponentPhysical.double';
+import {DTComponentPhysicalTest, IDTest, KeyTest, OwnerTest} from './DTComponentPhysical.double';
 import {DTComponentPhysical, DTComponentWithMeta} from "../../src";
 
-/******************** MOCK DEPENDENCIES
- * All Dependencies used by the component are mocked with Jest
- * *****/
-jest.mock('../../src/core/DTComponent');
-jest.mock('../../src/core/DTComponentWithMeta');
-// Add specific mock for inherited methods to have a basic implementation
-mockOverriddenMethods(DTComponentWithMeta);
-
 /************************* TESTS SUITES *******************************/
-describe('class DYOToolsComponentPhysical', () => {
+describe('class DTComponentPhysical', () => {
   let componentPhysicalTest: DTComponentPhysicalTest;
 
   beforeEach(() => {
@@ -31,19 +22,23 @@ describe('class DYOToolsComponentPhysical', () => {
 
   describe('getManager()', () => {
     test('call get context with manager accessor', () => {
+      const getContextSpy = jest.spyOn(componentPhysicalTest, 'getContext');
+
       componentPhysicalTest.getManager();
 
-      expect((componentPhysicalTest.getContext as any).mock.calls.length).toBe(1);
-      expect((componentPhysicalTest.getContext as any).mock.calls[0][0]).toBe('manager');
+      expect(getContextSpy.mock.calls.length).toBe(1);
+      expect(getContextSpy.mock.calls[0][0]).toBe('manager');
     });
   });
 
   describe('getMaster()', () => {
     test('call get context with master accessor', () => {
+      const getContextSpy = jest.spyOn(componentPhysicalTest, 'getContext');
+
       componentPhysicalTest.getMaster();
 
-      expect((componentPhysicalTest.getContext as any).mock.calls.length).toBe(1);
-      expect((componentPhysicalTest.getContext as any).mock.calls[0][0]).toBe('master');
+      expect(getContextSpy.mock.calls.length).toBe(1);
+      expect(getContextSpy.mock.calls[0][0]).toBe('master');
     });
   });
 
@@ -53,7 +48,7 @@ describe('class DYOToolsComponentPhysical', () => {
     });
 
     test('return owner when set', () => {
-      componentPhysicalTest.th_set_owner(OwnerTest);
+      componentPhysicalTest = new DTComponentPhysicalTest(IDTest, KeyTest, OwnerTest);
 
       expect(componentPhysicalTest.getOwner()).toBe(OwnerTest);
     });
@@ -63,16 +58,24 @@ describe('class DYOToolsComponentPhysical', () => {
     test('add a new owner', () => {
       componentPhysicalTest.setOwner(OwnerTest);
 
-      expect(componentPhysicalTest.th_get_owner()).toBe(OwnerTest);
+      expect(componentPhysicalTest.getOwner()).toBe(OwnerTest);
     });
   });
 
   describe('removeOwner()', () => {
     test('remove the current Owner', () => {
-      componentPhysicalTest.th_set_owner(OwnerTest);
+      componentPhysicalTest = new DTComponentPhysicalTest(IDTest, KeyTest, OwnerTest);
 
       componentPhysicalTest.removeOwner();
-      expect(componentPhysicalTest.th_get_owner()).toBeUndefined();
+      expect(componentPhysicalTest.getOwner()).toBeUndefined();
     });
   });
+
+  // describe('toDIXObject()', () => {
+  //   test('return parent and owner', () => {
+  //     const dixObject = componentPhysicalTest.toDIXObject();
+  //
+  //     expect(dixObject).toStrictEqual(ToDIXObjectTest);
+  //   });
+  // });
 });

package/test/core/DTComponentWithMeta.double.ts

@@ -67,49 +67,56 @@ export const BunchMetaData: IMetaDataTest = {
   kd: [117, 3],
 };
 
-/******************** STUB ABSTRACT IMPLEMENTATION
- * Implementation of abstract component class for tests
- * *****/
-export class DTComponentWithMetaImpl extends DTComponentWithMeta<IMetaDataTest> {
-    protected _componentType: string = ComponentTypeTest;
-
-    copy(): DTComponentWithMeta<IMetaDataTest> {
-      return this;
-    }
-
-    toObject(): any {
-      return ToObjectTest;
-    }
-
-    toString(): string {
-      return ToStringTest;
-    }
+// DIX
+export const ParentToDIXObjectTest = {
+  [IDTest]: {
+    key: KeyTest,
+    componentType: ComponentTypeTest
+  }
+}
+export const ToDIXObjectTest = {
+  [IDTest]: {
+    key: KeyTest,
+    componentType: ComponentTypeTest,
+    meta: JSON.stringify(HaileiMetaData),
+  }
 }
 
 /******************** 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 DTComponentWithMetaTest extends DTComponentWithMetaImpl {
-  th_get_meta(): Partial<IMetaDataTest> {
+export class DTComponentWithMetaTest extends DTComponentWithMeta<IMetaDataTest> {
+  protected _componentType: string = ComponentTypeTest;
+
+  constructor(
+    id: string = IDTest,
+    key: string = KeyTest,
+    meta: Partial<IMetaDataTest> = {},
+  ) {
+    super(IDTest);
+    this._id = id;
+    this._meta = meta;
+  }
+
+  _getMeta(): Partial<IMetaDataTest> {
     return this._meta;
   }
 
-  th_set_meta(meta: Partial<IMetaDataTest>): void {
-    this._meta = meta;
+  copy(): DTComponentWithMeta<IMetaDataTest> {
+    return this;
+  }
+
+  toObject(): any {
+    return ToObjectTest;
+  }
+
+  toString(): string {
+    return ToStringTest;
   }
 }
 
 /******************** HELPER METHODS
  * Additional helper methods to use with testing
  * *****/
-// Mocked implementations for overridden methods (for children tests)
-export function mockOverriddenMethods(mock: any) {
-  // Constructor
-  mock.prototype.constructor.mockImplementation(function (key?: string) {
-    this._id = IDTest;
-    this._key = key || this._id;
-    this._errors = [];
-    return this;
-  })
-}
+

package/test/core/DTComponentWithMeta.spec.ts

@@ -2,21 +2,16 @@ import {afterEach, beforeEach, describe, expect, jest, test,} from '@jest/global
 import {
   DTComponentWithMetaTest,
   HaileiMetaData,
+  IDTest,
   IMetaDataTest,
+  KeyTest,
   MeldrineMetaData,
   YssaliaMetaData
 } from './DTComponentWithMeta.double';
-import {mockOverriddenMethods} from "./DTComponent.double";
 import {DTComponent, DTComponentWithMeta} from "../../src";
 
-/******************** MOCK DEPENDENCIES
- * All Dependencies used by the component are mocked with Jest
- * *****/
-jest.mock('../../src/core/DTComponent');
-mockOverriddenMethods(DTComponent);
-
 /************************* TESTS SUITES *******************************/
-describe('class DYOToolsComponentWithMeta', () => {
+describe('class DTComponentWithMeta', () => {
   let componentWithMetaTest: DTComponentWithMetaTest;
 
   beforeEach(() => {
@@ -39,7 +34,7 @@ describe('class DYOToolsComponentWithMeta', () => {
     });
 
     test('return one meta by key', () => {
-      componentWithMetaTest.th_set_meta(HaileiMetaData);
+      componentWithMetaTest = new DTComponentWithMetaTest(IDTest, KeyTest, { ...HaileiMetaData });
 
       expect(componentWithMetaTest.getMeta('name')).toBe(HaileiMetaData.name);
     });
@@ -47,10 +42,10 @@ describe('class DYOToolsComponentWithMeta', () => {
 
   describe('setMeta()', () => {
     test('set a new value for a meta', () => {
-      componentWithMetaTest.th_set_meta(HaileiMetaData);
+      componentWithMetaTest = new DTComponentWithMetaTest(IDTest, KeyTest, { ...HaileiMetaData });
       componentWithMetaTest.setMeta('name', MeldrineMetaData.name);
 
-      const newMeta = componentWithMetaTest.th_get_meta();
+      const newMeta = componentWithMetaTest._getMeta();
       expect(newMeta.name === MeldrineMetaData.name).toBeTruthy();
       expect(newMeta.rank === HaileiMetaData.rank).toBeTruthy();
       expect(newMeta.queen === HaileiMetaData.queen).toBeTruthy();
@@ -68,13 +63,13 @@ describe('class DYOToolsComponentWithMeta', () => {
     });
 
     test('return all meta', () => {
-      componentWithMetaTest.th_set_meta(HaileiMetaData);
+      componentWithMetaTest = new DTComponentWithMetaTest(IDTest, KeyTest, { ...HaileiMetaData });
 
       expect(componentWithMetaTest.getManyMeta()).toStrictEqual(HaileiMetaData);
     });
 
     test('return meta by keys', () => {
-      componentWithMetaTest.th_set_meta(HaileiMetaData);
+      componentWithMetaTest = new DTComponentWithMetaTest(IDTest, KeyTest, { ...HaileiMetaData });
       const keys: Array<keyof IMetaDataTest> = ['name', 'kd', 'queen'];
 
       expect(componentWithMetaTest.getManyMeta(keys)).toStrictEqual({
@@ -85,7 +80,7 @@ describe('class DYOToolsComponentWithMeta', () => {
     });
 
     test('return meta by keys - unexisting keys', () => {
-      componentWithMetaTest.th_set_meta(YssaliaMetaData);
+      componentWithMetaTest = new DTComponentWithMetaTest(IDTest, KeyTest, { ...YssaliaMetaData });
       const keys: Array<keyof IMetaDataTest> = ['name', 'rank', 'tribes'];
 
       expect(componentWithMetaTest.getManyMeta(keys)).toStrictEqual({
@@ -96,7 +91,7 @@ describe('class DYOToolsComponentWithMeta', () => {
 
   describe('setManyMeta()', () => {
     test('set new values', () => {
-      componentWithMetaTest.th_set_meta(HaileiMetaData);
+      componentWithMetaTest = new DTComponentWithMetaTest(IDTest, KeyTest, { ...HaileiMetaData });
       const setValues: Partial<IMetaDataTest> = {
         name: MeldrineMetaData.name,
         queen: MeldrineMetaData.queen,
@@ -105,7 +100,7 @@ describe('class DYOToolsComponentWithMeta', () => {
 
       componentWithMetaTest.setManyMeta(setValues);
 
-      const newMeta = componentWithMetaTest.th_get_meta();
+      const newMeta = componentWithMetaTest._getMeta();
       expect(newMeta.name === MeldrineMetaData.name).toBeTruthy();
       expect(newMeta.queen === MeldrineMetaData.queen).toBeTruthy();
       expect(newMeta.kd[0] === HaileiMetaData.kd[0]).toBeTruthy();
@@ -114,11 +109,21 @@ describe('class DYOToolsComponentWithMeta', () => {
     });
 
     test('set empty new values (keep former meta)', () => {
-      componentWithMetaTest.th_set_meta(HaileiMetaData);
+      componentWithMetaTest = new DTComponentWithMetaTest(IDTest, KeyTest, { ...HaileiMetaData });
 
       componentWithMetaTest.setManyMeta({});
 
-      expect(componentWithMetaTest.th_get_meta()).toStrictEqual(HaileiMetaData);
+      expect(componentWithMetaTest._getMeta()).toStrictEqual(HaileiMetaData);
     });
   });
+
+  // describe('toDIXObject()', () => {
+  //   test('return parent and meta', () => {
+  //     componentWithMetaTest = new DTComponentWithMetaTest(IDTest, KeyTest, { ...HaileiMetaData });
+  //
+  //     const dixObject = componentWithMetaTest.toDIXObject();
+  //
+  //     expect(dixObject).toStrictEqual(ToDIXObjectTest);
+  //   });
+  // });
 });

package/test/core/DTElement.double.ts

@@ -1,5 +1,7 @@
 import {DTBunch, DTElement} from '../../src';
 import {IMetaDataTest} from './DTComponentWithMeta.double';
+import {DTElementToObject} from "../../src/types";
+import {DTBunchStub} from "./DTBunch.double";
 
 /** ****************** STUB PROPERTIES CONSTANTS
  * Fixed properties to use with double classes, avoid auto generated and easy checking on test
@@ -13,91 +15,68 @@ export const DomainTest = 'DTElement-domain-test';
 export const HaileiIdTest = 'DTElement-id-Hailei';
 export const HaileiKeyTest = 'DTElement-key-Hailei';
 export const HaileiToObjectTest = { id: 'DTElement-id-Hailei', key: 'DTElement-key-Hailei', type: 'element' };
+
 export const MeldrineIdTest = 'DTElement-id-Meldrine';
 export const MeldrineKeyTest = 'DTElement-key-Meldrine';
 export const MeldrineToObjectTest = { id: 'DTElement-id-Meldrine', key: 'DTElement-key-Meldrine', type: 'element' };
+
 export const MaydenaIdTest = 'DTElement-id-Maydena';
 export const MaydenaKeyTest = 'DTElement-key-Maydena';
 export const MaydenaToObjectTest = { id: 'DTElement-id-Maydena', key: 'DTElement-key-Maydena', type: 'element' };
+
 export const IldressIdTest = 'DTElement-id-Ildress';
 export const IldressKeyTest = 'DTElement-key-Ildress';
 export const IldressToObjectTest = { id: 'DTElement-id-Ildress', key: 'DTElement-key-Ildress', type: 'element' };
+
 export const YssaliaIdTest = 'DTElement-id-Yssalia';
 export const YssaliaKeyTest = 'DTElement-key-Yssalia';
 export const YssaliaToObjectTest = { id: 'DTElement-id-Yssalia', key: 'DTElement-key-Yssalia', type: 'element' };
 
+
 /** ****************** 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 DTElementTest extends DTElement<IMetaDataTest> {
-  th_get_id(): string {
-    return this._id;
-  }
 
-  th_set_id(id: string): void {
+  constructor(
+    id: string = IDTest,
+    key: string = KeyTest,
+    container: DTBunchStub | undefined = undefined,
+    domain?: string,
+  ) {
+    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;
-  }
-
-  th_get_domain(): string {
-    return this._domain;
-  }
-
-  th_set_domain(domain: string): void {
+    this._container = container as DTBunch;
     this._domain = domain;
   }
-
-  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_container(): DTBunch<any> | undefined {
-    return this._container;
-  }
-
-  th_set_container(container: DTBunch<any>): void {
-    this._container = container;
-  }
 }
 /** ****************** STUB CLASS
  * Stub class, for using in other component
  * **** */
 export class DTElementStub extends DTElement<IMetaDataTest> {
   public parentIndex: number;
-
-  constructor(index = 0) {
+  public mockedToObject: DTElementToObject<IMetaDataTest>;
+
+  constructor(
+    index = 0,
+    id: string = IDTest,
+    key: string = KeyTest,
+    meta: Partial<IMetaDataTest> = {},
+    owner: string | undefined = undefined,
+    toObject: DTElementToObject<IMetaDataTest> = HaileiToObjectTest,
+  ) {
     super();
-    this._id = IDTest;
-    this._key = KeyTest;
+    this._id = id;
+    this._key = key;
+    this._meta = meta;
+    this._owner = owner;
     this.parentIndex = index;
+    this.mockedToObject = toObject;
   }
 
-  getId(): string {
-    return IDTest;
-  }
-
-  getKey(): string {
-    return KeyTest;
+  toObject(): DTElementToObject<IMetaDataTest> {
+    return this.mockedToObject;
   }
 }
 export class DTElementStubExtended extends DTElementStub {