dyo-tools 0.4.0 → 0.4.1

package/test/core/DTComponent.double.ts

@@ -1,179 +0,0 @@
-import {DTComponent} from "../../src";
-import {DTErrorStub} from "./DTError.double";
-import {jest} from "@jest/globals";
-import {DIXObject, DTComponentOptions, DTComponentToDIXObject} from "../../src/types";
-import * as domain from "domain";
-
-interface IOptionsTest extends DTComponentOptions {
-    option1: boolean
-    option2: boolean
-}
-
-/******************** STUB PROPERTIES CONSTANTS
- * Fixed properties to use with double classes, avoid auto generated and easy checking on test
- * *****/
-export const IDTest = "DTComponent-id-1234567";
-export const KeyTest = "DTComponent-key-1234567";
-export const ComponentTypeTest = "DTComponent-componentType-test";
-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
- * *****/
-export class DTComponentImpl extends DTComponent<IOptionsTest> {
-    protected _componentType: string = ComponentTypeTest;
-
-    copy(): DTComponent {
-        return this;
-    }
-
-    toObject(): any {
-        return ToObjectTest;
-    }
-
-    toString(): string {
-        return ToStringTest;
-    }
-
-    updateFromDix(dix: Record<string, DIXObject>): void {
-    }
-}
-
-/******************** 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 DTComponentTest extends DTComponentImpl {
-    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_set_componentType(componentType: string): void {
-        this._componentType = componentType;
-    }
-
-    th_set_domain(domain: string): void {
-        this._domain = domain;
-    }
-
-    th_set_subKind(subKind: string): void {
-        this._subKind = subKind;
-    }
-
-    th_get_context(): DTComponent | undefined {
-        return this._context;
-    }
-
-    th_set_context(context: DTComponentTest): void {
-        this._context = context;
-    }
-
-    th_get_errors(): Array<DTErrorStub> {
-       return this._errors;
-    }
-
-    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 = options;
-    }
-
-    updateFromDix(dix: Record<string, DIXObject>): void {
-    }
-}
-
-/******************** STUB CLASS
- * Stub class, for using in other component
- * *****/
-export class DTComponentStub extends DTComponentTest {
-    private readonly stubId: string;
-
-    constructor(idSuffix: string = "") {
-        super();
-        this.stubId = IDTest + (idSuffix && `-${idSuffix}`);
-    }
-
-    _getStubId(): string {
-        return this.stubId;
-    }
-}
-
-/******************** 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;
-    })
-}
-
-// Hierarchy Simulation
-type simulateHierarchyOptions = {
-    mockGetContext: boolean
-}
-export function simulateHierarchy(
-  ranks: number = 3,
-  options: simulateHierarchyOptions = { mockGetContext: false }): DTComponentTest[] {
-    const hierarchyComponents = [];
-    let lastRankComponent: DTComponentTest;
-
-    for (let i = 1; i <= ranks; i++) {
-        const componentRank = new DTComponentTest();
-        componentRank.th_set_componentType(`rank${i}`);
-        if (lastRankComponent) {
-            componentRank.th_set_context(lastRankComponent);
-        }
-
-        if (options.mockGetContext) {
-            if (lastRankComponent) {
-                const lastComponentRankScoped = lastRankComponent;
-                jest.spyOn(componentRank, 'getContext').mockImplementation(function () {
-                    return lastComponentRankScoped;
-                });
-            } else {
-                jest.spyOn(componentRank, 'getContext').mockImplementation(function () {
-                    return undefined;
-                });
-            }
-        }
-
-        hierarchyComponents.push(componentRank);
-        lastRankComponent = componentRank;
-    }
-
-    return hierarchyComponents;
-}

package/test/core/DTComponent.spec.ts

@@ -1,297 +0,0 @@
-import {afterEach, beforeEach, describe, expect, jest, test,} from '@jest/globals';
-import {
-  ComponentTypeTest,
-  DomainTest,
-  DTComponentTest,
-  IDTest,
-  KeyTest,
-  simulateHierarchy,
-  SubKindTest,
-  ToDIXObjectTest,
-} from './DTComponent.double';
-import {DTErrorStub} from "./DTError.double";
-
-describe('class DTComponent', () => {
-  let componentTest: DTComponentTest;
-
-  beforeEach(() => {
-    componentTest = new DTComponentTest();
-  });
-
-  afterEach(() => {
-    jest.clearAllMocks();
-  });
-
-  describe('constructor()', () => {
-    test('creation without key', () => {
-      const component = new DTComponentTest();
-      const component2 = new DTComponentTest(null);
-
-      expect(component.th_get_key()).toBe(component.th_get_id());
-      expect(component2.th_get_key()).toBe(component2.th_get_id());
-    });
-
-    test('creation with key', () => {
-      const component = new DTComponentTest(KeyTest);
-
-      expect(component.th_get_key()).toBe(KeyTest);
-      expect(component.th_get_id() !== component.th_get_key()).toBeTruthy();
-    });
-
-    test('creations have unique ids', () => {
-      const component = new DTComponentTest(KeyTest);
-      const component2 = new DTComponentTest(KeyTest);
-
-      expect(component.th_get_id() !== component2.th_get_id()).toBeTruthy();
-    });
-
-    test('creations without options - default', () => {
-      const component = new DTComponentTest();
-
-      expect(component.th_get_options()).toStrictEqual({
-        errors: false,
-        syncId: undefined,
-      });
-    });
-
-    test('creations with options', () => {
-      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
-      });
-    });
-  });
-
-  describe('getId()', () => {
-    test('return id', () => {
-      componentTest.th_set_id(IDTest);
-      expect(componentTest.getId()).toBe(IDTest);
-    });
-  });
-
-  describe('getKey()', () => {
-    test('return key', () => {
-      componentTest.th_set_key(KeyTest);
-      expect(componentTest.getKey()).toBe(KeyTest);
-    });
-  });
-
-  describe('getComponentType()', () => {
-    test('return componentType', () => {
-      const componentTestSet = new DTComponentTest();
-      componentTestSet.th_set_componentType(`${ComponentTypeTest}-set`);
-
-      expect(componentTest.getComponentType()).toBe(ComponentTypeTest);
-      expect(componentTestSet.getComponentType()).toBe(`${ComponentTypeTest}-set`);
-    });
-  });
-
-  describe('getDomain()', () => {
-    test('return domain', () => {
-      const componentTestSet = new DTComponentTest();
-      componentTestSet.th_set_domain(DomainTest);
-
-      expect(componentTest.getDomain()).toBeUndefined();
-      expect(componentTestSet.getDomain()).toBe(DomainTest);
-    });
-  });
-
-  describe('getSubKind()', () => {
-    test('return subkind', () => {
-      const componentTestSet = new DTComponentTest();
-      componentTestSet.th_set_subKind(SubKindTest);
-
-      expect(componentTest.getSubKind()).toBeUndefined();
-      expect(componentTestSet.getSubKind()).toBe(SubKindTest);
-    });
-  });
-
-  describe('getContext()', () => {
-    beforeEach(() => {
-      componentTest = new DTComponentTest();
-    });
-
-    test('return context', () => {
-      const component = new DTComponentTest();
-      const componentTestSet = new DTComponentTest();
-      componentTestSet.th_set_context(component);
-      jest.spyOn(component, 'getComponentType').mockImplementation(function () {
-        return this._componentType;
-      });
-      jest.spyOn(componentTestSet, 'getComponentType').mockImplementation(function () {
-        return this._componentType;
-      });
-
-      expect(componentTest.getContext()).toBeUndefined();
-      expect(componentTestSet.getContext()).toStrictEqual(component);
-    });
-
-    test('return context with Hierarchy - simple case', () => {
-      const [componentRank1, componentRank2, componentRank3] = simulateHierarchy();
-      jest.spyOn(componentRank3, 'getComponentType').mockImplementation(function () {
-        return this._componentType;
-      });
-
-      expect(componentRank3.getContext()).toStrictEqual(componentRank2);
-      expect(componentRank3.getContext('rank2')).toStrictEqual(componentRank2);
-      expect(componentRank3.getContext('rank1')).toStrictEqual(componentRank1);
-      expect(componentRank3.getContext('rank0')).toBeUndefined();
-    });
-
-    test('return context with Hierarchy - same type case so return first one', () => {
-      const [componentRank0, componentRank2, componentRank3] = simulateHierarchy();
-      const componentRank1 = new DTComponentTest();
-      componentRank1.th_set_componentType('rank1');
-      componentRank1.th_set_context(componentRank0);
-      componentRank2.th_set_context(componentRank1);
-      jest.spyOn(componentRank1, 'getComponentType').mockImplementation(function () {
-        return this._componentType;
-      });
-
-      expect(componentRank3.getContext('rank1')).toStrictEqual(componentRank1);
-    });
-  });
-
-  describe('setContext()', () => {
-    test('change context', () => {
-      const componentRank1 = new DTComponentTest();
-      componentRank1.th_set_componentType('rank1');
-
-      componentTest.setContext(componentRank1);
-      expect(componentTest.th_get_context()).toBe(componentRank1);
-    });
-  });
-
-  describe('removeContext()', () => {
-    test('remove the current Context', () => {
-      const componentRankSup = new DTComponentTest();
-      componentTest.th_set_context(componentRankSup);
-
-      componentTest.removeContext();
-      expect(componentTest.th_get_context()).toBeUndefined();
-    });
-  });
-
-  describe('getErrors()', () => {
-    test('return empty errors by default', () => {
-      expect(componentTest.getErrors()).toStrictEqual([]);
-    });
-
-    test('return array of errors if defined', () => {
-      const errors = [new DTErrorStub(), new DTErrorStub()];
-      componentTest.th_set_errors(errors);
-
-      expect(componentTest.getErrors()).toStrictEqual(errors);
-    });
-
-    test('return errors from higher level component', () => {
-      const [componentRank1, componentRank2, componentRank3] = simulateHierarchy(3, { mockGetContext: true });
-      componentRank1.th_set_errors([new DTErrorStub(), new DTErrorStub(), new DTErrorStub()]);
-      componentRank2.th_set_errors([new DTErrorStub(), new DTErrorStub()]);
-      componentRank3.th_set_errors([new DTErrorStub()]);
-
-      expect(componentRank1.getErrors().length).toEqual(3);
-      expect(componentRank2.getErrors().length).toEqual(3);
-      expect(componentRank3.getErrors().length).toEqual(3);
-    })
-  });
-
-  describe('getLastError()', () => {
-    test('return undefined if no errors', () => {
-      expect(componentTest.getLastError()).toBeUndefined();
-    });
-
-    test('return the last error', () => {
-      const lastError = new DTErrorStub();
-      const errors = [new DTErrorStub(), new DTErrorStub(), lastError];
-      componentTest.th_set_errors(errors);
-
-      expect(componentTest.getLastError().getTimestamp().toString()).toStrictEqual(lastError.getTimestamp().toString());
-    });
-
-    test('return the last error from higher level component', () => {
-      const [componentRank1, componentRank2, componentRank3] = simulateHierarchy(3, { mockGetContext: true });
-      const lastError = new DTErrorStub();
-      componentRank1.th_set_errors([new DTErrorStub(), new DTErrorStub(), lastError]);
-      componentRank2.th_set_errors([new DTErrorStub(), new DTErrorStub()]);
-      componentRank3.th_set_errors([new DTErrorStub()]);
-
-      expect(componentRank1.getLastError().getTimestamp().toString()).toStrictEqual(lastError.getTimestamp().toString());
-      expect(componentRank2.getLastError().getTimestamp().toString()).toStrictEqual(lastError.getTimestamp().toString());
-      expect(componentRank3.getLastError().getTimestamp().toString()).toStrictEqual(lastError.getTimestamp().toString());
-    });
-  });
-
-  describe('triggerError()', () => {
-    test('default throw an exception error - option errors false', () => {
-      const error = new DTErrorStub();
-
-      expect(() => componentTest.triggerError(error)).toThrow(error);
-    });
-
-    test('stack new error - option errors true', () => {
-      componentTest.th_set_options({ errors: true });
-      const error = new DTErrorStub();
-
-      componentTest.triggerError(error);
-      expect(componentTest.th_get_errors().length).toBe(1);
-    });
-
-    test('throw new error in higher level component - option errors false', () => {
-      const [componentRank1, componentRank2, componentRank3] = simulateHierarchy(3, { mockGetContext: true });
-      componentRank1.th_set_options({ errors: false });
-      componentRank2.th_set_options({ errors: true });
-      componentRank3.th_set_options({ errors: true });
-      const error = new DTErrorStub();
-
-      expect(() => componentRank3.triggerError(error)).toThrow(error);
-      expect(componentRank2.th_get_errors().length).toBe(0);
-      expect(componentRank1.th_get_errors().length).toBe(0);
-    });
-
-    test('stack new error in higher level component - option errors true', () => {
-      const [componentRank1, componentRank2, componentRank3] = simulateHierarchy(3, { mockGetContext: true });
-      componentRank1.th_set_options({ errors: true });
-      componentRank2.th_set_options({ errors: false });
-      const error = new DTErrorStub();
-
-      componentRank3.triggerError(error);
-      expect(componentRank1.th_get_errors().length).toBe(1);
-      expect(componentRank2.th_get_errors().length).toBe(0);
-      expect(componentRank3.th_get_errors().length).toBe(0);
-    });
-  });
-
-  describe('clearErrors()', () => {
-    test('reset errors array', () => {
-      componentTest.th_set_errors([new DTErrorStub(), new DTErrorStub()]);
-
-      componentTest.clearErrors();
-      expect(componentTest.th_get_errors().length).toBe(0);
-    });
-
-    test('reset errors in higher level components', () => {
-      const [componentRank1, componentRank2, componentRank3] = simulateHierarchy(3, { mockGetContext: true });
-      componentRank1.th_set_errors([new DTErrorStub(), new DTErrorStub(), new DTErrorStub()]);
-      componentRank2.th_set_errors([new DTErrorStub(), new DTErrorStub()]);
-      componentRank3.th_set_errors([new DTErrorStub()]);
-
-      componentRank3.clearErrors();
-      expect(componentRank1.th_get_errors().length).toBe(0);
-      expect(componentRank2.th_get_errors().length).toBe(0);
-      expect(componentRank3.th_get_errors().length).toBe(0);
-    });
-  });
-
-  describe('getOptions()', () => {
-    test('return options', () => {
-      componentTest.th_set_options({ errors: true, option1: false, option2: true });
-
-      expect(componentTest.getOptions()).toStrictEqual({ errors: true, option1: false, option2: true });
-    });
-  });
-});

package/test/core/DTComponentPhysical.double.ts

@@ -1,62 +0,0 @@
-import {DTComponentPhysical} from "../../src";
-import {IMetaDataTest} from "./DTComponentWithMeta.double";
-
-/******************** STUB PROPERTIES CONSTANTS
- * Fixed properties to use with double classes, avoid auto generated and easy checking on test
- * *****/
-export const IDTest = "DTComponentPhysical-id-1234567";
-export const KeyTest = "DTComponentPhysical-key-1234567";
-export const ComponentTypeTest = "DTComponentPhysical-componentType-test";
-export const ToObjectTest = { type: "DTComponentPhysical-test-toObject" };
-export const ToStringTest = "DTComponentPhysical-test-toString";
-export const OwnerTest = "owner-12345";
-export const ParentToDIXObjectTest = {
-    [IDTest]: {
-        key: KeyTest,
-        componentType: ComponentTypeTest,
-        meta: {}
-    }
-}
-export const ToDIXObjectTest = {
-    [IDTest]: {
-        key: KeyTest,
-        componentType: ComponentTypeTest,
-        meta: {},
-        owner: OwnerTest,
-    }
-}
-
-/******************** 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 DTComponentPhysicalTest extends DTComponentPhysical<IMetaDataTest> {
-    protected _componentType: string = ComponentTypeTest;
-
-    constructor(
-      id: string = IDTest,
-      key: string = KeyTest,
-      owner?: string,
-    ) {
-        super(key);
-        this._id = id;
-        this._owner = owner;
-    }
-
-    copy(): DTComponentPhysical<IMetaDataTest> {
-        return this;
-    }
-
-    toObject(): any {
-        return ToObjectTest;
-    }
-
-    toString(): string {
-        return ToStringTest;
-    }
-}
-
-/******************** HELPER METHODS
- * Additional helper methods to use with testing
- * *****/
-

package/test/core/DTComponentPhysical.spec.ts

@@ -1,81 +0,0 @@
-import {beforeEach, describe, expect, jest, test} from '@jest/globals';
-import {DTComponentPhysicalTest, IDTest, KeyTest, OwnerTest} from './DTComponentPhysical.double';
-import {DTComponentPhysical, DTComponentWithMeta} from "../../src";
-
-/************************* TESTS SUITES *******************************/
-describe('class DTComponentPhysical', () => {
-  let componentPhysicalTest: DTComponentPhysicalTest;
-
-  beforeEach(() => {
-    componentPhysicalTest = new DTComponentPhysicalTest();
-  });
-
-  afterEach(() => {
-    jest.resetAllMocks();
-  });
-
-  describe('inheritance', () => {
-    test('check good inheritance for class', () => {
-      expect(DTComponentPhysical.prototype instanceof DTComponentWithMeta).toBeTruthy();
-    });
-  });
-
-  describe('getManager()', () => {
-    test('call get context with manager accessor', () => {
-      const getContextSpy = jest.spyOn(componentPhysicalTest, 'getContext');
-
-      componentPhysicalTest.getManager();
-
-      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(getContextSpy.mock.calls.length).toBe(1);
-      expect(getContextSpy.mock.calls[0][0]).toBe('master');
-    });
-  });
-
-  describe('getOwner()', () => {
-    test('return empty owner by default', () => {
-      expect(componentPhysicalTest.getOwner()).toBeUndefined();
-    });
-
-    test('return owner when set', () => {
-      componentPhysicalTest = new DTComponentPhysicalTest(IDTest, KeyTest, OwnerTest);
-
-      expect(componentPhysicalTest.getOwner()).toBe(OwnerTest);
-    });
-  });
-
-  describe('setOwner()', () => {
-    test('add a new owner', () => {
-      componentPhysicalTest.setOwner(OwnerTest);
-
-      expect(componentPhysicalTest.getOwner()).toBe(OwnerTest);
-    });
-  });
-
-  describe('removeOwner()', () => {
-    test('remove the current Owner', () => {
-      componentPhysicalTest = new DTComponentPhysicalTest(IDTest, KeyTest, OwnerTest);
-
-      componentPhysicalTest.removeOwner();
-      expect(componentPhysicalTest.getOwner()).toBeUndefined();
-    });
-  });
-
-  // describe('toDIXObject()', () => {
-  //   test('return parent and owner', () => {
-  //     const dixObject = componentPhysicalTest.toDIXObject();
-  //
-  //     expect(dixObject).toStrictEqual(ToDIXObjectTest);
-  //   });
-  // });
-});