dyo-tools 0.1.0-rc2 → 0.2.0

package/test/core/DTPlayer.double.ts

@@ -0,0 +1,64 @@
+import {DTPlayer} 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 = 'DTPlayer-id-1234567';
+export const KeyTest = 'DTPlayer-key-1234567';
+export const toStringTest = 'DTPlayer Stub toString';
+
+/******************** 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 DTPlayerTest extends DTPlayer<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_set_meta(meta: IMetaDataTest): void {
+    this._meta = meta;
+  }
+}
+
+/******************** STUB CLASS
+ * Stub class, for using in other component
+ * *****/
+export class DTPlayerStub extends DTPlayer<{}> {
+  constructor() {
+    super();
+    this._id = IDTest;
+    this._key = KeyTest;
+  }
+
+  getKey(): string {
+    return KeyTest;
+  }
+
+  getId(): string {
+    return IDTest;
+  }
+
+  toString(): string {
+    return toStringTest;
+  }
+}
+
+

package/test/core/DTPlayer.spec.ts

@@ -0,0 +1,80 @@
+import {beforeEach, describe, expect, jest, test} from '@jest/globals';
+import {DTPlayerTest, IDTest, KeyTest} from './DTPlayer.double';
+import {mockOverriddenMethods, PlayerMetaData} from './DTComponentWithMeta.double';
+import {DTComponentWithMeta, DTPlayer} from "../../src";
+
+/******************** MOCK DEPENDENCIES
+ * All Dependencies used by the component are mocked with Jest
+ * *****/
+jest.mock('../../src/core/DTComponent');
+jest.mock('../../src/core/DTComponentWithMeta');
+mockOverriddenMethods(DTComponentWithMeta);
+
+/************************* TESTS SUITES *******************************/
+describe('class DYOToolsPlayer', () => {
+  let playerTest: DTPlayerTest;
+
+  beforeEach(() => {
+    playerTest = new DTPlayerTest();
+  });
+
+  afterEach(() => {
+    jest.resetAllMocks();
+  });
+
+  describe('inheritance', () => {
+    test('check good inheritance for class', () => {
+      expect(DTPlayer.prototype instanceof DTComponentWithMeta).toBeTruthy();
+    });
+  });
+
+  describe('_componentType', () => {
+    test('componentType must be "player"', () => {
+      expect(playerTest.th_get_componentType()).toBe('player');
+    });
+  });
+
+  describe('copy()', () => {
+    // @see copy.spec.ts for unit tests about copy method
+  });
+
+  describe('toObject()', () => {
+    beforeEach(() => {
+      playerTest.th_set_id(IDTest);
+      playerTest.th_set_key(KeyTest);
+    })
+
+    test('toObject output standard', () => {
+      const toObjectPlayer = playerTest.toObject();
+
+      expect(Object.keys(toObjectPlayer)).toStrictEqual(['id', 'key', 'type']);
+      expect(toObjectPlayer.id).toBe(IDTest);
+      expect(toObjectPlayer.key).toBe(KeyTest);
+      expect(toObjectPlayer.type).toBe('player');
+    });
+
+    test('toObject output standard with meta', () => {
+      jest.spyOn(playerTest, 'getManyMeta').mockImplementation(function () {
+        return this._meta;
+      });
+      playerTest.th_set_meta(PlayerMetaData);
+
+      const toObjectPlayer = playerTest.toObject();
+
+      expect(Object.keys(toObjectPlayer)).toStrictEqual(['id', 'key', 'type', 'meta']);
+      expect(toObjectPlayer.meta).toStrictEqual(PlayerMetaData);
+    });
+  });
+
+  describe('toString()', () => {
+    beforeEach(() => {
+      playerTest.th_set_key(KeyTest);
+    })
+
+    test('string output standard', () => {
+      const toStringElement = playerTest.toString();
+
+      expect(toStringElement).toBe(`Component ${KeyTest} - Type: Player`);
+    });
+  });
+});

package/test/core/copy.spec.ts

@@ -0,0 +1,227 @@
+import {
+  describe, expect, jest, test,
+} from '@jest/globals';
+import { DTBunch, DTElement, DTPlayer } from '../../src';
+import { DTComponentStub } from './DTComponent.double';
+import { DTPlayerStub } from './DTPlayer.double';
+import {
+  BunchMetaData, HaileiMetaData, IMetaDataTest, PlayerMetaData,
+} from './DTComponentWithMeta.double';
+import { defaultOptions, 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
+ */
+
+describe('Inherited method copy', () => {
+  describe('DTBunch copy()', () => {
+    afterEach(() => {
+      jest.resetAllMocks();
+    });
+
+    test('copy a bunch - simple case with id and key', () => {
+      const bunch = new DTBunch(KeyTest);
+      const bunchCopy = bunch.copy();
+
+      expect(bunch.getId() === bunchCopy.getId()).toBeFalsy();
+      expect(bunch.getKey() === bunchCopy.getKey()).toBeTruthy();
+    });
+
+    test('copy a bunch - not copy owner and context', () => {
+      const bunch = new DTBunch(KeyTest);
+      jest.spyOn(bunch, 'setContext').mockImplementation(function (context) {
+        this._context = context;
+      });
+      jest.spyOn(bunch, 'setOwner').mockImplementation(function (owner) {
+        this._owner = owner;
+      });
+
+      bunch.setContext(new DTComponentStub());
+      bunch.setOwner(new DTPlayerStub());
+
+      const bunchCopy = bunch.copy();
+      jest.spyOn(bunchCopy, 'getContext').mockImplementation(function () {
+        return this._context;
+      });
+      jest.spyOn(bunchCopy, 'getOwner').mockImplementation(function () {
+        return this._owner;
+      });
+
+      expect(bunchCopy.getContext()).toBeUndefined();
+      expect(bunchCopy.getOwner()).toBeUndefined();
+    });
+
+    test('copy a bunch - copy meta-data and globalOptions', () => {
+      const copiedOptions = {
+        inheritOwner: true,
+        replaceIndex: true,
+        virtualContext: true,
+      };
+      const bunch = new DTBunch('', [], copiedOptions);
+      jest.spyOn(bunch, 'getManyMeta').mockImplementation(() => BunchMetaData);
+
+      const bunchCopy = bunch.copy();
+
+      expect(bunchCopy.getManyMeta()).toStrictEqual(BunchMetaData);
+      expect(bunchCopy.getOptions()).toStrictEqual({
+        ...defaultOptions,
+        ...copiedOptions,
+      });
+    });
+
+    test('copy a bunch - empty errors', () => {
+      const bunch = new DTBunch(KeyTest, [], { errors: true });
+      bunch.triggerError(new DTErrorStub());
+      bunch.triggerError(new DTErrorStub());
+
+      const bunchCopy = bunch.copy();
+
+      expect(bunchCopy.getErrors().length).toBe(0);
+    });
+
+    test('copy a bunch with items - default case', () => {
+      const items: Array<DTElement<IMetaDataTest>> = [
+        new DTElement(),
+        new DTElement(),
+        new DTElement(),
+      ];
+      jest.spyOn(items[0], 'copy');
+      jest.spyOn(items[1], 'copy');
+      jest.spyOn(items[2], 'copy');
+      const bunch = new DTBunch<DTElement<IMetaDataTest>, IMetaDataTest>(KeyTest, items);
+
+      const bunchCopy = bunch.copy();
+
+      expect(bunchCopy.getAll().length).toBe(3);
+      expect((items[0].copy as any).mock.calls.length).toBe(1);
+      expect((items[1].copy as any).mock.calls.length).toBe(1);
+      expect((items[2].copy as any).mock.calls.length).toBe(1);
+    });
+
+    test('copy a bunch with items - virtual context case', () => {
+      const items: Array<DTElement<IMetaDataTest>> = [
+        new DTElement(),
+        new DTElement(),
+        new DTElement(),
+      ];
+      jest.spyOn(items[0], 'copy');
+      jest.spyOn(items[1], 'copy');
+      jest.spyOn(items[2], 'copy');
+      const bunch = new DTBunch<DTElement<IMetaDataTest>, IMetaDataTest>(KeyTest, items, { virtualContext: true });
+
+      const bunchCopy = bunch.copy();
+
+      expect(bunchCopy.getAll().length).toBe(3);
+      expect((items[0].copy as any).mock.calls.length).toBe(0);
+      expect((items[1].copy as any).mock.calls.length).toBe(0);
+      expect((items[2].copy as any).mock.calls.length).toBe(0);
+    });
+  });
+
+  describe('DTElement copy()', () => {
+    afterEach(() => {
+      jest.resetAllMocks();
+    });
+
+    test('copy an element - simple case with id and key', () => {
+      const element = new DTElement(KeyTest);
+      const elementCopy = element.copy();
+
+      expect(element.getId() === elementCopy.getId()).toBeFalsy();
+      expect(element.getKey() === elementCopy.getKey()).toBeTruthy();
+    });
+
+    test('copy an element - not copy context', () => {
+      const element = new DTElement(KeyTest);
+      jest.spyOn(element, 'setContext').mockImplementation(function (context) {
+        this._context = context;
+      });
+
+      element.setContext(new DTComponentStub());
+
+      const elementCopy = element.copy();
+      jest.spyOn(elementCopy, 'getContext').mockImplementation(function () {
+        return this._context;
+      });
+
+      expect(elementCopy.getContext()).toBeUndefined();
+    });
+
+    test('copy an element - copy meta-data and options', () => {
+      const element = new DTElement(KeyTest, { errors: true });
+      jest.spyOn(element, 'getManyMeta').mockImplementation(() => HaileiMetaData);
+
+      const elementCopy = element.copy();
+
+      expect(elementCopy.getManyMeta()).toStrictEqual(HaileiMetaData);
+      expect(elementCopy.getOptions()).toStrictEqual({ errors: true });
+    });
+
+    test('copy an element - empty errors', () => {
+      const element = new DTElement(KeyTest, { errors: true });
+      element.triggerError(new DTErrorStub());
+      element.triggerError(new DTErrorStub());
+
+      const elementCopy = element.copy();
+
+      expect(elementCopy.getErrors().length).toBe(0);
+    });
+  });
+
+  describe('DTPlayer copy()', () => {
+    afterEach(() => {
+      jest.resetAllMocks();
+    });
+
+    test('copy a player - simple case with id and key', () => {
+      const player = new DTPlayer(KeyTest);
+      const playerCopy = player.copy();
+
+      expect(player.getId() === playerCopy.getId()).toBeFalsy();
+      expect(player.getKey() === playerCopy.getKey()).toBeTruthy();
+    });
+
+    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 playerCopy = player.copy();
+
+      expect(playerCopy.getManyMeta()).toStrictEqual(PlayerMetaData);
+      expect(playerCopy.getOptions()).toStrictEqual({ errors: true });
+    });
+
+    test('copy a player - empty errors', () => {
+      const player = new DTPlayer(KeyTest, { errors: true });
+      player.triggerError(new DTErrorStub());
+      player.triggerError(new DTErrorStub());
+
+      const playerCopy = player.copy();
+
+      expect(playerCopy.getErrors().length).toBe(0);
+    });
+  });
+});

package/test/libs/DYOFinder.double.ts

@@ -0,0 +1,152 @@
+import { DYOFinderConfiguration, FilterOperatorType } from '../../src/types';
+import DYOFinder from '../../src/libs/DYOFinder';
+import { DTBunchStub } from '../core/DTBunch.double';
+import { DTElementStubExtended } from '../core/DTElement.double';
+
+/** ****************** STUB PROPERTIES CONSTANTS
+ * Fixed properties to use with double classes, avoid auto generated and easy checking on test
+ * **** */
+const baseOperators = [
+  FilterOperatorType.EQ,
+  FilterOperatorType.IN,
+  FilterOperatorType.NIN,
+  FilterOperatorType.NE,
+];
+
+export const DefaultConfiguration: DYOFinderConfiguration = {
+  propString: {
+    operators: baseOperators,
+    getValue: (item: any) => item.getPropString(),
+    objectSearch: false,
+  },
+  propArray: {
+    operators: [...baseOperators, FilterOperatorType.CONTAINS, FilterOperatorType.NCONTAINS],
+    getValue: (item: any) => item.getPropArray(),
+    objectSearch: false,
+  },
+  propNumber: {
+    operators: [...baseOperators, FilterOperatorType.LTE, FilterOperatorType.GTE],
+    getValue: (item: any) => item.getPropNumber(),
+    objectSearch: false,
+  },
+  propBoolean: {
+    operators: baseOperators,
+    getValue: (item: any) => item.getPropBoolean(),
+    objectSearch: false,
+  },
+  propObject: {
+    operators: baseOperators,
+    getValue: (item: any) => item.getPropObject(),
+    objectSearch: false,
+  },
+  propMeta: {
+    operators: baseOperators,
+    getValue: (item: any) => item.getPropMeta(),
+    objectSearch: true,
+  },
+};
+
+/** ****************** 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 default class DYOFinderTest extends DYOFinder {
+  th_get_component(): any {
+    return this._component;
+  }
+
+  th_get_configuration(): DYOFinderConfiguration {
+    return this._configuration;
+  }
+
+  th_set_configuration(configuration: DYOFinderConfiguration): void {
+    this._configuration = {
+      ...this._configuration,
+      ...configuration,
+    };
+  }
+}
+
+/** ****************** STUB CLASS
+ * Stub class, for using in other component
+ * **** */
+
+/** ****************** HELPER METHODS
+ * Additional helper methods to use with testing
+ * **** */
+export function generateComponent(): DTBunchStub {
+  const elementFindStubData = [
+    {
+      propString: 'item_prime',
+      propArray: ['tag1', 'tag2'],
+      propNumber: 17,
+      propBoolean: true,
+      propObject: {
+        data: 'value',
+      },
+      propMeta: {
+        meta1: 'value1',
+      },
+    },
+    {
+      propString: 'item_prime',
+      propArray: ['tag1', 'tag2', 'tag3'],
+      propNumber: 19,
+      propBoolean: false,
+      propObject: {
+        data: 'value',
+      },
+      propMeta: {
+        meta1: 'value1',
+        meta2: 'value2',
+      },
+    },
+    {
+      propString: 'item_second',
+      propArray: ['tag1', 'tag3'],
+      propNumber: 23,
+      propBoolean: true,
+      propObject: {
+        data: 'value',
+      },
+      propMeta: {
+        meta1: 'value2',
+        meta2: 'value2',
+      },
+    },
+    {
+      propString: 'item_third',
+      propNumber: 17,
+      propBoolean: false,
+      propObject: null,
+    },
+    {
+      propString: 'item_second',
+      propArray: [],
+      propNumber: 31,
+      propBoolean: true,
+      propObject: null,
+      propMeta: {
+        meta3: 'value3',
+      },
+    },
+  ];
+
+  const items = [];
+  let itemIndex = 0;
+  for (const data of elementFindStubData) {
+    const elementStub = new DTElementStubExtended();
+    elementStub.parentIndex = itemIndex;
+    elementStub.setPropString(data.propString);
+    elementStub.setPropArray(data.propArray);
+    elementStub.setPropNumber(data.propNumber);
+    elementStub.setPropBoolean(data.propBoolean);
+    elementStub.setPropObject(data.propObject);
+    elementStub.setPropMeta(data.propMeta);
+
+    items.push(elementStub);
+    itemIndex += 1;
+  }
+
+  return new DTBunchStub(items);
+}