dyo-tools 0.3.2 → 0.4.1

package/test/core/DTModule.spec.ts

@@ -1,138 +0,0 @@
-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

@@ -1,243 +0,0 @@
-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

@@ -1,152 +0,0 @@
-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);
-}