dyo-tools 0.1.0-rc1

package/test/core/DTComponent.double.ts

@@ -0,0 +1,69 @@
+import {DTComponent} from "../../src";
+
+// Global test variables
+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";
+
+// Test Child for DTComponent class (mocked abstract methods)
+export class DTComponentTest extends DTComponent {
+    protected _componentType: string = ComponentTypeTest;
+
+    copy(): DTComponent {
+        return this;
+    }
+
+    toObject(): any {
+        return ToObjectTest;
+    }
+
+    toString(): string {
+        return ToStringTest;
+    }
+}
+
+// Mock constructor for DTComponentTest class (getter tests)
+interface IDTComponentTestMockProps {
+    componentType?: string
+    domain?: string
+    subKind?: string
+    context?: DTComponent
+}
+
+export class DTComponentTestMock extends DTComponentTest {
+    constructor(props?: IDTComponentTestMockProps) {
+        super();
+        this._id = IDTest;
+        this._key = KeyTest;
+        if (props) {
+            this._componentType = props.componentType || ComponentTypeTest;
+            this._domain = props.domain || DomainTest;
+            this._subKind = props.subKind || SubKindTest;
+            this._context = props.context || undefined;
+        } else {
+            this._componentType = this._componentType || undefined;
+            this._domain = undefined;
+            this._subKind = undefined;
+            this._context = undefined;
+        }
+
+    }
+}
+
+// Stub for Component (used for other tests)
+export class DTComponentStub extends DTComponentTest {
+    private readonly stubId: string;
+
+    constructor(idSuffix: string = "") {
+        super();
+        this.stubId = IDTest + (idSuffix && `-${idSuffix}`);
+    }
+
+    getId() {
+        return this.stubId;
+    }
+}

package/test/core/DTComponent.spec.ts

@@ -0,0 +1,182 @@
+import {
+  jest, describe, expect, test, beforeEach, afterEach,
+} from '@jest/globals';
+import {
+  ComponentTypeTest,
+  DomainTest,
+  DTComponentTest,
+  DTComponentTestMock,
+  IDTest,
+  KeyTest,
+  SubKindTest,
+} from './DTComponent.double';
+
+describe('class DYOToolsComponent', () => {
+  let componentMock: DTComponentTestMock;
+
+  beforeEach(() => {
+    componentMock = new DTComponentTestMock();
+  });
+
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  describe('constructor()', () => {
+    test('creation without key', () => {
+      const component = new DTComponentTest();
+      jest.spyOn(component, 'getId').mockImplementation(function () {
+        return this._id;
+      });
+      jest.spyOn(component, 'getKey').mockImplementation(function () {
+        return this._key;
+      });
+
+      expect(component.getKey()).toBe(component.getId());
+    });
+
+    test('creation with key', () => {
+      const component = new DTComponentTest(KeyTest);
+      jest.spyOn(component, 'getId').mockImplementation(function () {
+        return this._id;
+      });
+      jest.spyOn(component, 'getKey').mockImplementation(function () {
+        return this._key;
+      });
+
+      expect(component.getKey()).toBe(KeyTest);
+      expect(component.getId() !== component.getKey()).toBeTruthy();
+    });
+
+    test('creations have unique ids', () => {
+      const component = new DTComponentTest(KeyTest);
+      const component2 = new DTComponentTest(KeyTest);
+      jest.spyOn(component, 'getId').mockImplementation(function () {
+        return this._id;
+      });
+      jest.spyOn(component2, 'getId').mockImplementation(function () {
+        return this._key;
+      });
+
+      expect(component.getId() !== component2.getId()).toBeTruthy();
+    });
+  });
+
+  describe('getId()', () => {
+    test('return id', () => {
+      expect(componentMock.getId()).toBe(IDTest);
+    });
+  });
+
+  describe('getKey()', () => {
+    test('return key', () => {
+      expect(componentMock.getKey()).toBe(KeyTest);
+    });
+  });
+
+  describe('getComponentType()', () => {
+    test('return componentType', () => {
+      const componentMockSet = new DTComponentTestMock({ componentType: `${ComponentTypeTest}-set` });
+
+      expect(componentMock.getComponentType()).toBe(ComponentTypeTest);
+      expect(componentMockSet.getComponentType()).toBe(`${ComponentTypeTest}-set`);
+    });
+  });
+
+  describe('getDomain()', () => {
+    test('return domain', () => {
+      const componentMockSet = new DTComponentTestMock({ domain: DomainTest });
+
+      expect(componentMock.getDomain()).toBeUndefined();
+      expect(componentMockSet.getDomain()).toBe(DomainTest);
+    });
+  });
+
+  describe('getSubKind()', () => {
+    test('return subkind', () => {
+      const componentMockSet = new DTComponentTestMock({ subKind: SubKindTest });
+
+      expect(componentMock.getSubKind()).toBeUndefined();
+      expect(componentMockSet.getSubKind()).toBe(SubKindTest);
+    });
+  });
+
+  describe('getContext()', () => {
+    test('return context', () => {
+      const component = new DTComponentTest();
+      const componentMockSet = new DTComponentTestMock({ context: component });
+
+      expect(componentMock.getContext()).toBeUndefined();
+      expect(componentMockSet.getContext()).toStrictEqual(component);
+    });
+
+    test('return context with Hierarchy - simple case', () => {
+      const componentRank1 = new DTComponentTestMock({ componentType: 'rank1' });
+      const componentRank2 = new DTComponentTestMock({ componentType: 'rank2', context: componentRank1 });
+      const componentRank3 = new DTComponentTestMock({ componentType: 'rank3', context: componentRank2 });
+      jest.spyOn(componentRank1, 'getComponentType').mockImplementation(function () {
+        return this._componentType;
+      });
+      jest.spyOn(componentRank2, 'getComponentType').mockImplementation(function () {
+        return this._componentType;
+      });
+      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 = new DTComponentTestMock({ componentType: 'rank1' });
+      const componentRank1 = new DTComponentTestMock({ componentType: 'rank1', context: componentRank0 });
+      const componentRank2 = new DTComponentTestMock({ componentType: 'rank2', context: componentRank1 });
+      const componentRank3 = new DTComponentTestMock({ componentType: 'rank3', context: componentRank2 });
+      jest.spyOn(componentRank0, 'getComponentType').mockImplementation(function () {
+        return this._componentType;
+      });
+      jest.spyOn(componentRank1, 'getComponentType').mockImplementation(function () {
+        return this._componentType;
+      });
+      jest.spyOn(componentRank2, 'getComponentType').mockImplementation(function () {
+        return this._componentType;
+      });
+      jest.spyOn(componentRank3, 'getComponentType').mockImplementation(function () {
+        return this._componentType;
+      });
+
+      expect(componentRank3.getContext('rank1')).toStrictEqual(componentRank1);
+    });
+  });
+
+  describe('setContext()', () => {
+    test('change context', () => {
+      const componentRank1 = new DTComponentTestMock({ componentType: 'rank1' });
+      jest.spyOn(componentMock, 'getContext').mockImplementation(function () {
+        return this._context;
+      });
+      componentMock.setContext(componentRank1);
+
+      expect(componentMock.getContext()).toBe(componentRank1);
+    });
+  });
+
+  describe('removeOwner()', () => {
+    test('remove the current Context', () => {
+      const componentRankSup = new DTComponentTestMock();
+      jest.spyOn(componentMock, 'setContext').mockImplementation(function (context) {
+        this._context = context;
+      });
+      jest.spyOn(componentMock, 'getContext').mockImplementation(function () {
+        return this._context;
+      });
+      componentMock.setContext(componentRankSup);
+
+      componentMock.removeContext();
+      expect(componentMock.getContext()).toBeUndefined();
+    });
+  });
+});

package/test/core/DTComponentWithMeta.double.ts

@@ -0,0 +1,88 @@
+import { DTComponentWithMeta } from '../../src';
+import {DTAcceptedMetaData} from "../../src/types";
+
+// Global test variables
+export const ComponentTypeTest = 'DTComponentWithMeta-componentType-test';
+
+// Test meta data interface
+export interface IMetaDataTest extends DTAcceptedMetaData {
+    name: string,
+    queen: boolean,
+    kd: number[],
+    rank?: number,
+    tribes?: string[]
+}
+
+// Elementary pentacle default values
+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],
+};
+
+// Test Child for DTComponentWithMeta class (mocked abstract methods)
+export class DTComponentWithMetaTest extends DTComponentWithMeta<IMetaDataTest> {
+    protected _componentType: string = ComponentTypeTest;
+
+    copy(): DTComponentWithMeta<IMetaDataTest> {
+      return this;
+    }
+
+    toObject(): any {
+      return {};
+    }
+
+    toString(): string {
+      return '';
+    }
+}
+
+// Mock constructor for DTComponentTest class (getter tests)
+export class DTComponentWithMetaTestMock extends DTComponentWithMetaTest {
+  constructor(defaultMeta?: IMetaDataTest) {
+    super();
+    if (defaultMeta) {
+      this._meta = { ...defaultMeta };
+    }
+  }
+}

package/test/core/DTComponentWithMeta.spec.ts

@@ -0,0 +1,112 @@
+import {
+  jest, describe, expect, test, beforeEach, afterEach,
+} from '@jest/globals';
+import {
+  DTComponentWithMetaTestMock, HaileiMetaData, MeldrineMetaData, IMetaDataTest, YssaliaMetaData,
+} from './DTComponentWithMeta.double';
+
+describe('class DYOToolsComponent', () => {
+  let componentMock: DTComponentWithMetaTestMock;
+
+  beforeEach(() => {
+    componentMock = new DTComponentWithMetaTestMock(HaileiMetaData);
+  });
+
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  describe('getMeta()', () => {
+    test('return one meta by key', () => {
+      expect(componentMock.getMeta('name')).toBe(HaileiMetaData.name);
+    });
+
+    test('return undefined if meta is empty', () => {
+      componentMock = new DTComponentWithMetaTestMock();
+
+      expect(componentMock.getMeta('name')).toBeUndefined();
+    });
+  });
+
+  describe('setMeta()', () => {
+    test('set a new value for a meta', () => {
+      jest.spyOn(componentMock, 'getManyMeta').mockImplementation(function () {
+        return this._meta;
+      });
+
+      componentMock.setMeta('name', MeldrineMetaData.name);
+      const newMeta = componentMock.getManyMeta();
+
+      expect(newMeta.name === HaileiMetaData.name).toBeFalsy();
+      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 all meta', () => {
+      expect(componentMock.getManyMeta()).toStrictEqual(HaileiMetaData);
+    });
+
+    test('return meta by keys', () => {
+      const keys: Array<keyof IMetaDataTest> = ['name', 'kd', 'queen'];
+
+      expect(componentMock.getManyMeta(keys)).toStrictEqual({
+        name: HaileiMetaData.name,
+        kd: HaileiMetaData.kd,
+        queen: HaileiMetaData.queen,
+      });
+    });
+
+    test('return meta by keys - unexisting keys', () => {
+      componentMock = new DTComponentWithMetaTestMock(YssaliaMetaData);
+      const keys: Array<keyof IMetaDataTest> = ['name', 'rank', 'tribes'];
+
+      expect(componentMock.getManyMeta(keys)).toStrictEqual({
+        name: YssaliaMetaData.name,
+      });
+    });
+
+    test('return empty object if meta is empty', () => {
+      componentMock = new DTComponentWithMetaTestMock();
+      const keys: Array<keyof IMetaDataTest> = ['name', 'rank', 'tribes'];
+
+      expect(componentMock.getManyMeta(keys)).toStrictEqual({});
+    });
+  });
+
+  describe('setManyMeta()', () => {
+    test('set new values', () => {
+      jest.spyOn(componentMock, 'getManyMeta').mockImplementation(function () {
+        return this._meta;
+      });
+      const setValues: Partial<IMetaDataTest> = {
+        name: MeldrineMetaData.name,
+        queen: MeldrineMetaData.queen,
+        rank: MeldrineMetaData.rank,
+      };
+
+      componentMock.setManyMeta(setValues);
+      const newMeta = componentMock.getManyMeta();
+
+      expect(newMeta.name === HaileiMetaData.name).toBeFalsy();
+      expect(newMeta.queen === HaileiMetaData.queen).toBeFalsy();
+      expect(newMeta.kd[0] === HaileiMetaData.kd[0]).toBeTruthy();
+      expect(newMeta.rank === HaileiMetaData.rank).toBeFalsy();
+      expect(newMeta.tribes[0] === HaileiMetaData.tribes[0]).toBeTruthy();
+    });
+
+    test('set no new values', () => {
+      jest.spyOn(componentMock, 'getManyMeta').mockImplementation(function () {
+        return this._meta;
+      });
+
+      componentMock.setManyMeta({});
+      const newMeta = componentMock.getManyMeta();
+
+      expect(newMeta).toStrictEqual(HaileiMetaData);
+    });
+  });
+});

package/test/core/DTElement.double.ts

@@ -0,0 +1,27 @@
+import { DTElement } from '../../src';
+import { IMetaDataTest, MeldrineMetaData } from './DTComponentWithMeta.double';
+
+// Global Variables
+export const IDTest = 'DTElement-id-1234567';
+export const KeyTest = 'DTElement-key-1234567';
+
+// Mock Constructor and parent methods for DTElement
+export class DTElementMock extends DTElement<IMetaDataTest> {
+  constructor() {
+    super();
+    this._id = IDTest;
+    this._key = KeyTest;
+  }
+
+  getComponentType(): string {
+    return this._componentType;
+  }
+
+  setManyMeta(metaValues: Partial<IMetaDataTest>) {
+    this._meta = MeldrineMetaData;
+  }
+
+  getManyMeta(metaKeys: Array<keyof IMetaDataTest> = []): Partial<IMetaDataTest> {
+    return this._meta;
+  }
+}

package/test/core/DTElement.spec.ts

@@ -0,0 +1,181 @@
+import { describe, test, beforeEach } from '@jest/globals';
+import {
+  DTPlayerStub, IDTest as IDPlayerTest, toStringTest as toStringPlayerTest, KeyTest as KeyPlayerTest,
+} from './DTPlayer.double';
+import { DTElementMock, IDTest, KeyTest } from './DTElement.double';
+import { MeldrineMetaData } from './DTComponentWithMeta.double';
+
+describe('class DYOToolsElement', () => {
+  let elementMock: DTElementMock;
+
+  beforeEach(() => {
+    elementMock = new DTElementMock();
+  });
+
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  describe('_componentType', () => {
+    test('componentType must be "element"', () => {
+      expect(elementMock.getComponentType()).toBe('element');
+    });
+  });
+
+  describe('getOwner()', () => {
+    test('return empty owner by default', () => {
+      expect(elementMock.getOwner()).toBeUndefined();
+    });
+
+    test('return owner when set', () => {
+      const owner = new DTPlayerStub();
+      jest.spyOn(elementMock, 'setOwner').mockImplementation(function (owner) {
+        this._owner = owner;
+      });
+      elementMock.setOwner(owner);
+
+      expect(elementMock.getOwner().getId()).toBe(IDPlayerTest);
+    });
+  });
+
+  describe('setOwner()', () => {
+    test('add a new owner', () => {
+      const owner = new DTPlayerStub();
+      jest.spyOn(elementMock, 'getOwner').mockImplementation(function () {
+        return this._owner;
+      });
+      elementMock.setOwner(owner);
+
+      expect(elementMock.getOwner().getId()).toBe(IDPlayerTest);
+    });
+  });
+
+  describe('removeOwner()', () => {
+    test('remove the current Owner', () => {
+      const owner = new DTPlayerStub();
+      jest.spyOn(elementMock, 'setOwner').mockImplementation(function (owner) {
+        this._owner = owner;
+      });
+      jest.spyOn(elementMock, 'getOwner').mockImplementation(function () {
+        return this._owner;
+      });
+      elementMock.setOwner(owner);
+
+      elementMock.removeOwner();
+      expect(elementMock.getOwner()).toBeUndefined();
+    });
+  });
+
+  describe('copy()', () => {
+    test('copy an element - simple case with id and key', () => {
+      // This test doesn't mock the DOC (Depended-on Component) correctly
+      // Need to change implementation to implement correct testing
+      const elementMockCopy = elementMock.copy();
+      jest.spyOn(elementMock, 'getId').mockImplementation(function () {
+        return this._id;
+      });
+      jest.spyOn(elementMockCopy, 'getId').mockImplementation(function () {
+        return this._id;
+      });
+      jest.spyOn(elementMock, 'getKey').mockImplementation(function () {
+        return this._key;
+      });
+      jest.spyOn(elementMockCopy, 'getKey').mockImplementation(function () {
+        return this._key;
+      });
+
+      expect(elementMock.getId() === elementMockCopy.getId()).toBeFalsy();
+      expect(elementMock.getKey() === elementMockCopy.getKey()).toBeTruthy();
+    });
+
+    test('copy an element - not copy owner and context', () => {
+      // This test doesn't mock the DOC (Depended-on Component) correctly
+      // Need to change implementation to implement correct testing
+      jest.spyOn(elementMock, 'setContext').mockImplementation(function (context) {
+        this._context = context;
+      });
+      jest.spyOn(elementMock, 'setOwner').mockImplementation(function (owner) {
+        this._owner = owner;
+      });
+
+      elementMock.setContext(new DTElementMock());
+      elementMock.setOwner(new DTPlayerStub());
+
+      const elementMockCopy = elementMock.copy();
+      jest.spyOn(elementMockCopy, 'getContext').mockImplementation(function () {
+        return this._context;
+      });
+      jest.spyOn(elementMockCopy, 'getOwner').mockImplementation(function () {
+        return this._owner;
+      });
+
+      expect(elementMockCopy.getContext()).toBeUndefined();
+      expect(elementMockCopy.getOwner()).toBeUndefined();
+    });
+
+    test('copy an element - copy meta-data', () => {
+      // This test doesn't mock the DOC (Depended-on Component) correctly
+      // Need to change implementation to implement correct testing
+      elementMock.setManyMeta({});
+
+      const elementMockCopy = elementMock.copy();
+      jest.spyOn(elementMockCopy, 'getManyMeta').mockImplementation(function () {
+        return this._meta;
+      });
+
+      expect(elementMockCopy.getManyMeta()).toStrictEqual(MeldrineMetaData);
+    });
+  });
+
+  describe('toObject()', () => {
+    test('toObject output standard', () => {
+      const toObjectElement = elementMock.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', () => {
+      jest.spyOn(elementMock, 'setOwner').mockImplementation(function (owner) {
+        this._owner = owner;
+      });
+      elementMock.setOwner(new DTPlayerStub());
+
+      const toObjectElement = elementMock.toObject();
+      expect(Object.keys(toObjectElement)).toStrictEqual(['id', 'key', 'type', 'owner']);
+      expect(toObjectElement.owner.toString()).toBe(toStringPlayerTest);
+    });
+
+    test('toObject output standard with owner and meta', () => {
+      jest.spyOn(elementMock, 'setOwner').mockImplementation(function (owner) {
+        this._owner = owner;
+      });
+      elementMock.setOwner(new DTPlayerStub());
+      elementMock.setManyMeta({});
+
+      const toObjectElement = elementMock.toObject();
+      expect(Object.keys(toObjectElement)).toStrictEqual(['id', 'key', 'type', 'owner', 'meta']);
+      expect(toObjectElement.meta).toStrictEqual(MeldrineMetaData);
+    });
+  });
+
+  describe('toString()', () => {
+    test('string output standard', () => {
+      const toStringElement = elementMock.toString();
+
+      expect(toStringElement).toBe(`Component ${KeyTest} - Type: Element`);
+    });
+
+    test('string output standard with owner', () => {
+      jest.spyOn(elementMock, 'setOwner').mockImplementation(function (owner) {
+        this._owner = owner;
+      });
+      elementMock.setOwner(new DTPlayerStub());
+
+      const toStringElement = elementMock.toString();
+      expect(toStringElement).toBe(`Component ${KeyTest} - Type: Element - Owner: ${KeyPlayerTest}`);
+    });
+  });
+});

package/test/core/DTError.double.ts

@@ -0,0 +1,43 @@
+import { DTError } from '../../src';
+import { DTComponentStub } from './DTComponent.double';
+
+// Global Variables
+export const CodeTest = 'DTError-code-123456';
+export const MessageTest = 'DTError-message-test';
+export const TimestampTest = 1500000000000;
+
+// Stub for Error (used for other tests)
+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;
+  }
+}
+
+// Mock Constructor for DTError
+export class DTErrorMock extends DTError {
+  constructor(setComponents = false) {
+    super('', '');
+    this.code = CodeTest;
+    this.message = MessageTest;
+    this.timestamp = new Date(TimestampTest);
+    if (setComponents) {
+      this.initiator = new DTComponentStub('initiator');
+      this.convicted = new DTComponentStub('convicted');
+    }
+  }
+}