dyo-tools 0.1.0 → 0.3.0

package/test/core/DTModule.spec.ts

@@ -0,0 +1,138 @@
+import {DTComponent, DTModule} from "../../src";
+import {mockOverriddenMethods} from "./DTComponent.double";
+import {afterEach, beforeEach, describe, expect, jest, test} from "@jest/globals";
+import {DTModuleTest, IDTest, KeyTest} from "./DTModule.double";
+import MockedFunction = jest.MockedFunction;
+
+/** ****************** MOCK DEPENDENCIES
+ * Dependencies used by the component are mocked with Jest
+ * **** */
+jest.mock('../../src/core/DTComponent');
+jest.mock('../../src/core/DTError');
+// Add specific mock for inherited methods to have a basic implementation
+mockOverriddenMethods(DTComponent);
+
+/** *********************** TESTS SUITES ****************************** */
+describe('class DYOToolsModule', () => {
+  let moduleTest: DTModuleTest;
+
+  beforeEach(() => {
+    moduleTest = new DTModuleTest();
+    moduleTest.th_set_id(IDTest);
+    moduleTest.th_set_key(KeyTest);
+  });
+
+  afterEach(() => {
+    jest.resetAllMocks();
+  });
+
+  describe('inheritance', () => {
+    test('check good inheritance for class', () => {
+      expect(DTModule.prototype instanceof DTComponent).toBeTruthy();
+    });
+  });
+
+  describe('_componentType', () => {
+    test('componentType must be "action"', () => {
+      expect(moduleTest.th_get_componentType()).toBe('module');
+    });
+  });
+
+  describe('constructor()', () => {
+    beforeEach(() => {
+      jest.resetAllMocks();
+    });
+
+    test('simple creation with key', () => {
+      const newModule = new DTModuleTest(KeyTest);
+      const parentConstructorMock = (DTComponent.prototype.constructor as MockedFunction<(key: string, options: any) => void>).mock;
+
+      expect(parentConstructorMock.calls.length).toBe(1);
+      expect(parentConstructorMock.calls[0][0]).toBe(KeyTest);
+
+      expect(newModule.th_get_enabled()).toStrictEqual(true);
+    });
+  });
+
+  describe('getMaster()', () => {
+    test('call get context with master accessor', () => {
+      moduleTest.getMaster();
+
+      expect((moduleTest.getContext as any).mock.calls.length).toBe(1);
+      expect((moduleTest.getContext as any).mock.calls[0][0]).toBe('master');
+    });
+  });
+
+  describe('isEnabled()', () => {
+    test('return true if the module is enabled', () => {
+      const enabledModule = moduleTest.isEnabled();
+
+      expect(enabledModule).toBe(true);
+    });
+
+    test('return false if the module is disabled', () => {
+      moduleTest.th_set_enabled(false);
+
+      const enabledModule = moduleTest.isEnabled();
+
+      expect(enabledModule).toBe(false);
+    });
+  });
+
+  describe('enable()', () => {
+    test('change enable to true', () => {
+      moduleTest.th_set_enabled(false);
+
+      moduleTest.enable();
+
+      expect(moduleTest.th_get_enabled()).toBe(true);
+    });
+  });
+
+  describe('disable()', () => {
+    test('change enable to false', () => {
+      moduleTest.th_set_enabled(true);
+
+      moduleTest.disable();
+
+      expect(moduleTest.th_get_enabled()).toBe(false);
+    });
+  });
+
+  describe('toString()', () => {
+    test('string output standard', () => {
+      const toStringAction = moduleTest.toString();
+
+      expect(toStringAction).toBe(`Component ${KeyTest} - Type: Module`);
+    });
+
+    test('string output standard when disabled', () => {
+      moduleTest.th_set_enabled(false);
+
+      const toStringAction = moduleTest.toString();
+
+      expect(toStringAction).toBe(`Component ${KeyTest} - Type: Module - Disabled`);
+    });
+  });
+
+  describe('toObject()', () => {
+    test('toObject output standard', () => {
+      const toObjectAction: any = moduleTest.toObject();
+
+      expect(Object.keys(toObjectAction)).toStrictEqual(['id', 'key', 'type', 'enabled']);
+      expect(toObjectAction.id).toBe(IDTest);
+      expect(toObjectAction.key).toBe(KeyTest);
+      expect(toObjectAction.type).toBe('module');
+      expect(toObjectAction.enabled).toBe(true);
+    });
+
+    test('toObject output standard when disabled', () => {
+      moduleTest.th_set_enabled(false);
+
+      const toObjectAction: any = moduleTest.toObject();
+
+      expect(Object.keys(toObjectAction)).toStrictEqual(['id', 'key', 'type', 'enabled']);
+      expect(toObjectAction.enabled).toBe(false);
+    });
+  });
+});

package/test/core/copy.spec.ts

@@ -0,0 +1,243 @@
+import {
+  describe, expect, jest, test,
+} from '@jest/globals';
+import { DTBunch, DTElement, DTPlayer } from '../../src';
+import { DTComponentStub } from './DTComponent.double';
+import {OwnerTest} from './DTComponentPhysical.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(OwnerTest);
+
+      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,
+        virtualContainer: 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, { virtualContainer: 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 - not copy container', () => {
+      const element = new DTElement(KeyTest);
+      jest.spyOn(element, 'setContainer').mockImplementation(function (container) {
+        this._container = container;
+      });
+
+      element.setContext(new DTComponentStub());
+
+      const elementCopy = element.copy();
+      jest.spyOn(elementCopy, 'getContainer').mockImplementation(function () {
+        return this._container;
+      });
+
+      expect(elementCopy.getContainer()).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);
+}