dyo-tools 0.1.0 → 0.3.0

package/test/core/DTComponentWithMeta.double.ts

@@ -0,0 +1,115 @@
+import {DTComponentWithMeta} from '../../src';
+import {DTAcceptedMetaData} from "../../src/types";
+
+/******************** STUB PROPERTIES CONSTANTS
+ * Fixed properties to use with double classes, avoid auto generated and easy checking on test
+ * *****/
+// Test meta data interface
+export interface IMetaDataTest extends DTAcceptedMetaData {
+  name: string,
+  queen: boolean,
+  kd: number[],
+  rank?: number,
+  tribes?: string[]
+}
+
+// Global properties
+export const IDTest = "DTComponentWithMeta-id-1234567";
+export const KeyTest = "DTComponentWithMeta-key-1234567";
+export const ComponentTypeTest = 'DTComponentWithMeta-componentType-test';
+export const ToObjectTest = { type: "DTComponentWithMeta-test-toObject" };
+export const ToStringTest = "DTComponentWithMeta-test-toString";
+
+// Specific components tests meta-data
+export const HaileiMetaData: IMetaDataTest = {
+  name: 'Hailei Dorcan Kazan',
+  queen: true,
+  kd: [47, 1],
+  rank: 1,
+  tribes: ['Peuple de Salta', 'Fils de Salta', 'Peuple Kanti'],
+};
+export const MeldrineMetaData: IMetaDataTest = {
+  name: 'Meldrine Goldmane',
+  queen: false,
+  kd: [53, 0],
+  rank: 2,
+  tribes: ['Lodaniens'],
+};
+export const MaydenaMetaData: IMetaDataTest = {
+  name: "Maydena 'Intan Kazan",
+  queen: true,
+  kd: [29, 0],
+  tribes: ['Exil rouge', 'Désolation'],
+};
+export const IldressMetaData: IMetaDataTest = {
+  name: 'Electel Ildress',
+  queen: false,
+  kd: [19, 1],
+  rank: 3,
+};
+export const YssaliaMetaData: IMetaDataTest = {
+  name: 'Yssalia du Gillit',
+  queen: true,
+  kd: [23, 0],
+};
+
+// Player default value
+export const PlayerMetaData: IMetaDataTest = {
+  name: 'Llhôonn',
+  queen: true,
+  kd: [0, 0],
+}
+
+// Bunch default value
+export const BunchMetaData: IMetaDataTest = {
+  name: 'Elementary Pentacle',
+  queen: true,
+  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;
+    }
+}
+
+/******************** 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> {
+    return this._meta;
+  }
+
+  th_set_meta(meta: Partial<IMetaDataTest>): void {
+    this._meta = meta;
+  }
+}
+
+/******************** 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

@@ -0,0 +1,124 @@
+import {afterEach, beforeEach, describe, expect, jest, test,} from '@jest/globals';
+import {
+  DTComponentWithMetaTest,
+  HaileiMetaData,
+  IMetaDataTest,
+  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', () => {
+  let componentWithMetaTest: DTComponentWithMetaTest;
+
+  beforeEach(() => {
+    componentWithMetaTest = new DTComponentWithMetaTest();
+  });
+
+  afterEach(() => {
+    jest.resetAllMocks();
+  });
+
+  describe('inheritance', () => {
+    test('check good inheritance for class', () => {
+      expect(DTComponentWithMeta.prototype instanceof DTComponent).toBeTruthy();
+    });
+  });
+
+  describe('getMeta()', () => {
+    test('return undefined if meta is empty', () => {
+      expect(componentWithMetaTest.getMeta('name')).toBeUndefined();
+    });
+
+    test('return one meta by key', () => {
+      componentWithMetaTest.th_set_meta(HaileiMetaData);
+
+      expect(componentWithMetaTest.getMeta('name')).toBe(HaileiMetaData.name);
+    });
+  });
+
+  describe('setMeta()', () => {
+    test('set a new value for a meta', () => {
+      componentWithMetaTest.th_set_meta(HaileiMetaData);
+      componentWithMetaTest.setMeta('name', MeldrineMetaData.name);
+
+      const newMeta = componentWithMetaTest.th_get_meta();
+      expect(newMeta.name === MeldrineMetaData.name).toBeTruthy();
+      expect(newMeta.rank === HaileiMetaData.rank).toBeTruthy();
+      expect(newMeta.queen === HaileiMetaData.queen).toBeTruthy();
+      expect(newMeta.kd[0] === HaileiMetaData.kd[0]).toBeTruthy();
+      expect(newMeta.tribes[0] === HaileiMetaData.tribes[0]).toBeTruthy();
+    });
+  });
+
+  describe('getManyMeta()', () => {
+    test('return empty object meta by default', () => {
+      const keys: Array<keyof IMetaDataTest> = ['name', 'rank', 'tribes'];
+
+      expect(componentWithMetaTest.getManyMeta()).toStrictEqual({});
+      expect(componentWithMetaTest.getManyMeta(keys)).toStrictEqual({});
+    });
+
+    test('return all meta', () => {
+      componentWithMetaTest.th_set_meta(HaileiMetaData);
+
+      expect(componentWithMetaTest.getManyMeta()).toStrictEqual(HaileiMetaData);
+    });
+
+    test('return meta by keys', () => {
+      componentWithMetaTest.th_set_meta(HaileiMetaData);
+      const keys: Array<keyof IMetaDataTest> = ['name', 'kd', 'queen'];
+
+      expect(componentWithMetaTest.getManyMeta(keys)).toStrictEqual({
+        name: HaileiMetaData.name,
+        kd: HaileiMetaData.kd,
+        queen: HaileiMetaData.queen,
+      });
+    });
+
+    test('return meta by keys - unexisting keys', () => {
+      componentWithMetaTest.th_set_meta(YssaliaMetaData);
+      const keys: Array<keyof IMetaDataTest> = ['name', 'rank', 'tribes'];
+
+      expect(componentWithMetaTest.getManyMeta(keys)).toStrictEqual({
+        name: YssaliaMetaData.name,
+      });
+    });
+  });
+
+  describe('setManyMeta()', () => {
+    test('set new values', () => {
+      componentWithMetaTest.th_set_meta(HaileiMetaData);
+      const setValues: Partial<IMetaDataTest> = {
+        name: MeldrineMetaData.name,
+        queen: MeldrineMetaData.queen,
+        rank: MeldrineMetaData.rank,
+      };
+
+      componentWithMetaTest.setManyMeta(setValues);
+
+      const newMeta = componentWithMetaTest.th_get_meta();
+      expect(newMeta.name === MeldrineMetaData.name).toBeTruthy();
+      expect(newMeta.queen === MeldrineMetaData.queen).toBeTruthy();
+      expect(newMeta.kd[0] === HaileiMetaData.kd[0]).toBeTruthy();
+      expect(newMeta.rank === MeldrineMetaData.rank).toBeTruthy();
+      expect(newMeta.tribes[0] === HaileiMetaData.tribes[0]).toBeTruthy();
+    });
+
+    test('set empty new values (keep former meta)', () => {
+      componentWithMetaTest.th_set_meta(HaileiMetaData);
+
+      componentWithMetaTest.setManyMeta({});
+
+      expect(componentWithMetaTest.th_get_meta()).toStrictEqual(HaileiMetaData);
+    });
+  });
+});

package/test/core/DTElement.double.ts

@@ -0,0 +1,163 @@
+import {DTBunch, DTElement} 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
+ * **** */
+// Global constants
+export const IDTest = 'DTElement-id-1234567';
+export const KeyTest = 'DTElement-key-1234567';
+export const DomainTest = 'DTElement-domain-test';
+
+// Specific elements constants
+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 {
+    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._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) {
+    super();
+    this._id = IDTest;
+    this._key = KeyTest;
+    this.parentIndex = index;
+  }
+
+  getId(): string {
+    return IDTest;
+  }
+
+  getKey(): string {
+    return KeyTest;
+  }
+}
+export class DTElementStubExtended extends DTElementStub {
+  private propString: string;
+
+  private propArray: string[];
+
+  private propNumber: number;
+
+  private propBoolean: boolean;
+
+  private propObject: Record<string, unknown>;
+
+  private propMeta: Record<string, unknown>;
+
+  getPropString(): string {
+    return this.propString;
+  }
+
+  setPropString(propString: string): void {
+    this.propString = propString;
+  }
+
+  getPropArray(): string[] {
+    return this.propArray;
+  }
+
+  setPropArray(propArray: string[]): void {
+    this.propArray = propArray;
+  }
+
+  getPropNumber(): number {
+    return this.propNumber;
+  }
+
+  setPropNumber(propNumber: number): void {
+    this.propNumber = propNumber;
+  }
+
+  getPropBoolean(): boolean {
+    return this.propBoolean;
+  }
+
+  setPropBoolean(propBoolean: boolean): void {
+    this.propBoolean = propBoolean;
+  }
+
+  getPropObject(): Record<string, unknown> {
+    return this.propObject;
+  }
+
+  setPropObject(propObject: Record<string, unknown>): void {
+    this.propObject = propObject;
+  }
+
+  getPropMeta(): Record<string, unknown> {
+    return this.propMeta;
+  }
+
+  setPropMeta(propMeta: Record<string, unknown>): void {
+    this.propMeta = propMeta;
+  }
+}

package/test/core/DTElement.spec.ts

@@ -0,0 +1,146 @@
+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 {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', () => {
+  let elementTest: DTElementTest;
+
+  beforeEach(() => {
+    elementTest = new DTElementTest();
+  });
+
+  afterEach(() => {
+    jest.resetAllMocks();
+  });
+
+  describe('inheritance', () => {
+    test('check good inheritance for class', () => {
+      expect(DTElement.prototype instanceof DTComponentPhysical).toBeTruthy();
+    });
+  });
+
+  describe('_componentType', () => {
+    test('componentType must be "element"', () => {
+      expect(elementTest.th_get_componentType()).toBe('element');
+    });
+  });
+
+  describe('getContainer()', () => {
+    test('return undefined if no container - default case', () => {
+      expect(elementTest.getContainer()).toBeUndefined();
+    });
+
+    test('return container', () => {
+      const container = new DTBunchStub();
+      elementTest.th_set_container(container);
+
+      expect(elementTest.getContainer()).toBeDefined();
+      expect(elementTest.getContainer().getId()).toStrictEqual(bunchIdTest);
+    });
+  });
+
+  describe('setContainer()', () => {
+    test('set a new container for element', () => {
+      const container = new DTBunchStub();
+
+      elementTest.setContainer(container);
+
+      expect(elementTest.th_get_container()).toBeDefined();
+      expect(elementTest.th_get_container().getId()).toStrictEqual(bunchIdTest);
+    });
+  });
+
+  describe('removeContainer()', () => {
+    test('remove the current container', () => {
+      const bunchContainer = new DTBunchStub();
+      elementTest.th_set_container(bunchContainer);
+
+      elementTest.removeContainer();
+      expect(elementTest.th_get_container()).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();
+
+      expect(Object.keys(toObjectElement)).toStrictEqual(['id', 'key', 'type']);
+      expect(toObjectElement.id).toBe(IDTest);
+      expect(toObjectElement.key).toBe(KeyTest);
+      expect(toObjectElement.type).toBe('element');
+    });
+
+    test('toObject output standard with owner', () => {
+      elementTest.th_set_owner(OwnerTest);
+
+      const toObjectElement = elementTest.toObject();
+
+      expect(Object.keys(toObjectElement)).toStrictEqual(['id', 'key', 'type', 'owner']);
+      expect(toObjectElement.owner).toBe(OwnerTest);
+    });
+
+    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);
+
+      const toObjectElement = elementTest.toObject();
+
+      expect(Object.keys(toObjectElement)).toStrictEqual(['id', 'key', 'type', 'owner', 'meta']);
+      expect(toObjectElement.meta).toStrictEqual(MeldrineMetaData);
+    });
+  });
+
+  describe('toString()', () => {
+    beforeEach(() => {
+      elementTest.th_set_key(KeyTest);
+    })
+
+    test('string output standard', () => {
+      const toStringElement = elementTest.toString();
+
+      expect(toStringElement).toBe(`Component ${KeyTest} - Type: Element`);
+    });
+
+    test('string output standard with domain', () => {
+      elementTest.th_set_domain(DomainTest);
+
+      const toStringElement = elementTest.toString();
+
+      expect(toStringElement).toBe(`Component ${DomainTest} ${KeyTest} - Type: Element`);
+    });
+
+    test('string output standard with owner', () => {
+      elementTest.th_set_owner(OwnerTest);
+
+      const toStringElement = elementTest.toString();
+
+      expect(toStringElement).toBe(`Component ${KeyTest} - Type: Element - Owner: ${OwnerTest}`);
+    });
+  });
+});

package/test/core/DTError.double.ts

@@ -0,0 +1,92 @@
+import {DTError} from '../../src';
+import {expect} from "@jest/globals";
+import DYOToolsComponent from "../../src/core/DTComponent";
+import MockedFunction = jest.MockedFunction;
+
+/******************** STUB PROPERTIES CONSTANTS
+ * Fixed properties to use with double classes, avoid auto generated and easy checking on test
+ * *****/
+export const CodeTest = 'DTError-code-123456';
+export const MessageTest = 'DTError-message-test';
+export const TimestampTest = 1500000000000;
+
+/******************** 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 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;
+  }
+
+  th_get_convicted(): DYOToolsComponent {
+    return this.convicted;
+  }
+
+  th_set_convicted(convicted: DYOToolsComponent): void {
+    this.convicted = convicted;
+  }
+}
+
+/******************** STUB CLASS
+ * Stub class, for using in other component
+ * *****/
+export class DTErrorStub extends DTError {
+  constructor() {
+    super('', '');
+    this.code = CodeTest;
+    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);
+    }
+  }
+};
+