dyo-tools 0.2.0 → 0.3.0

package/src/types/index.ts

@@ -1,162 +1,2 @@
-import { DTBunch, DTComponent } from '../index';
-import DYOToolsElement from '../core/DTElement';
-
-/** Constants Enum * */
-export enum FilterOperatorType {
-  EQ = '$eq',
-  IN = '$in',
-  NIN = '$nin',
-  NE = '$ne',
-  LTE = '$lte',
-  GTE = '$gte',
-  CONTAINS = '$contains',
-  NCONTAINS = '$ncontains',
-}
-
-/** Common Types * */
-export type StandardPrimitiveType = string | number | boolean | null | undefined;
-export type StandardPrimitiveTypeWithArray = string | number | boolean | Array<string | number | boolean> | null | undefined;
-
-/** DYO Finder interfaces * */
-export type DYOFinderConfiguration = Record<string, DYOFinderConfigurationProp>;
-export type DYOFinderComponentType = DTComponent & {
-  getAll: () => DTComponent[],
-};
-
-export interface DYOFinderConfigurationPropDefault {
-  operators: FilterOperatorType[],
-  getValue: (item: DTComponent, ctx?: DTComponent) => StandardPrimitiveType,
-  objectSearch: false,
-}
-
-export interface DYOFinderConfigurationPropObjectSearch {
-  operators: FilterOperatorType[],
-  getValue: (item: DTComponent, ctx?: DTComponent) => Record<string, StandardPrimitiveTypeWithArray>,
-  objectSearch: true,
-}
-export type DYOFinderConfigurationProp = DYOFinderConfigurationPropDefault | DYOFinderConfigurationPropObjectSearch;
-
-export interface DYOFinderFilterOperatorBase {
-  [FilterOperatorType.EQ]: StandardPrimitiveType
-  [FilterOperatorType.IN]: Array<StandardPrimitiveType>
-  [FilterOperatorType.NIN]: Array<StandardPrimitiveType>
-  [FilterOperatorType.NE]: StandardPrimitiveType
-}
-export interface DYOFinderFilterOperatorAdvanced {
-  [FilterOperatorType.LTE]: number
-  [FilterOperatorType.GTE]: number
-  [FilterOperatorType.CONTAINS]: StandardPrimitiveType
-  [FilterOperatorType.NCONTAINS]: StandardPrimitiveType
-}
-
-export type DYOFinderFilterOperator = DYOFinderFilterOperatorBase & DYOFinderFilterOperatorAdvanced;
-export type DYOFinderFilterOperatorArgument = Partial<DYOFinderFilterOperator | Record<string, Partial<DYOFinderFilterOperator>>>;
-export type DYOFinderFilters = Record<string, DYOFinderFilterOperatorArgument>;
-
-/** DTComponent interfaces * */
-/**
- * DTComponent default options configuration.
- */
-export interface DTComponentOptions {
-  /**
-   * Default *false*. If *true*, no exception is thrown when an error occurred, a new DTError instance is
-   * added to the _errors property array instead. If *false*, throw the exception with a DTError instance.
-   */
-  errors: boolean
-}
-
-export interface DTComponentToObject {
-  id: string
-  key: string
-  type: string
-}
-
-/** DTComponentWithMeta interfaces * */
-export type DTAcceptedMetaData = Record<
-string,
-StandardPrimitiveTypeWithArray
->;
-
-/** DTElement interfaces * */
-export interface DTElementToObject<IComponentMeta> extends DTComponentToObject {
-  owner?: string
-  meta?: Partial<IComponentMeta>
-}
-
-/** DTBunch interfaces * */
-/**
- * DTBunch option configuration.
- */
-export interface DTBunchOptions extends DTComponentOptions {
-  /**
-   * Default *false*. If *true*, an error occurred when adding a new DTElement with the same key of an
-   * existing element into the bunch.
-   */
-  uniqueKey: boolean
-  /**
-   * Default *false*. If *true*, when a new DTElement is added, the owner of this element becomes
-   * automatically the current bunch owner.
-   */
-  replaceIndex: boolean
-  /**
-   * Default *false*. If *true*, the context is not changed when a new DTElement is added.
-   * If *false*, when a new DTElement is added, the context of this element becomes automatically the current bunch instance
-   * and the element is removed from the old context Component (if defined).
-   */
-  inheritOwner: boolean
-  /**
-   * Default *false*. If *true*, when a new DTElement is added at existing index (using **addAtIndex**
-   * or **addManyAtIndex** method), this component replaces the old one. If *false*, this component is added at the specified
-   * index and other existing component are reindexed with the following index.
-   */
-  virtualContext: boolean
-}
-
-export interface DTBunchToObject<IComponentMeta> extends DTComponentToObject {
-  items: Array<DTElementToObject<DTAcceptedMetaData>>
-  owner?: string
-  meta?: Partial<IComponentMeta>
-}
-
-export interface DTBunchFilters {
-  id: Partial<DYOFinderFilterOperatorBase>
-  key: Partial<DYOFinderFilterOperatorBase>
-  context: Partial<DYOFinderFilterOperatorBase>
-  owner: Partial<DYOFinderFilterOperatorBase>
-  meta: Record<string, Partial<DYOFinderFilterOperatorAdvanced>>
-}
-
-/** DTPlayer interfaces * */
-export interface DTPlayerToObject<IComponentMeta> extends DTComponentToObject {
-  meta?: Partial<IComponentMeta>
-}
-
-/** DTManager interfaces * */
-export type DTManagerItemsType<IBunchItem extends DYOToolsElement<DTAcceptedMetaData>> = Record<string, DTManagerItemType<IBunchItem>>;
-export type DTManagerItemType<IBunchItem extends DYOToolsElement<DTAcceptedMetaData>> = {
-  scope: string,
-  item: DTBunch<IBunchItem>,
-};
-
-export interface DTManagerFilters extends DYOFinderFilters {
-  id: Partial<DYOFinderFilterOperatorBase>
-  key: Partial<DYOFinderFilterOperatorBase>
-  owner: Partial<DYOFinderFilterOperatorBase>
-  scope: Partial<DYOFinderFilterOperatorBase>
-  meta: Record<string, Partial<DYOFinderFilterOperatorAdvanced>>
-}
-
-/**
- * DTManager option configuration.
- */
-export interface DTManagerOptions extends DTComponentOptions {
-  /**
-   * Default *false*. If *true*, when a bunch instance is removed from the Manager _items, the process performs also
-   * a removal from the Manager Library of all DTElement instances of the bunch.
-   */
-  libraryDeletion: boolean,
-}
-
-export interface DTManagerToObject extends DTComponentToObject {
-  items: Array<DTBunchToObject<DTAcceptedMetaData> & { scope: string }>
-}
+export * from './core';
+export * from './player';

package/src/types/player.ts

@@ -0,0 +1,6 @@
+import { DTPlayer } from '../index';
+
+export interface DTPlayerManagerSimpleConfiguration {
+  players?: number | DTPlayer[];
+  errors?: boolean;
+}

package/test/core/DTAction.double.ts

@@ -0,0 +1,78 @@
+import {DTAction} from "../../src";
+import {DTComponentToObject} from "../../src/types";
+
+/** ****************** STUB PROPERTIES CONSTANTS
+ * Fixed properties to use with double classes, avoid auto generated and easy checking on test
+ * **** */
+export const IDTest = 'DTAction-id-1234567';
+export const KeyTest = 'DTAction-key-1234567';
+
+// Specific Manager constants
+export const action1IDTest = `${IDTest}_1`;
+export const action1KeyTest = `${KeyTest}_1`;
+
+export const action1ToObject: DTComponentToObject = {
+  id: action1IDTest,
+  key: action1KeyTest,
+  type: 'action'
+}
+
+/******************** STUB ABSTRACT IMPLEMENTATION
+ * Implementation of abstract component class for tests
+ * *****/
+export class DTActionImpl extends DTAction<string> {
+  async execute(payload: string): Promise<void> {
+    throw `${this._key} : ${payload}`;
+  }
+}
+
+/** ****************** 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 DTActionTest extends DTActionImpl {
+  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;
+  }
+}
+
+
+/** ****************** STUB CLASS
+ * Stub class, for using in other component
+ * **** */
+export class DTActionStub extends DTActionTest {
+  constructor() {
+    super();
+    this._id = IDTest;
+    this._key = KeyTest;
+    this._errors = [];
+  }
+
+  getId(): string {
+    return IDTest;
+  }
+
+  getKey(): string {
+    return KeyTest;
+  }
+}
+
+/** ****************** HELPER METHODS
+ * Additional helper methods to use with testing
+ * **** */

package/test/core/DTAction.spec.ts

@@ -0,0 +1,76 @@
+import {DTComponent, DTAction} from "../../src";
+import {mockOverriddenMethods} from "./DTComponent.double";
+import {afterEach, beforeEach, describe, expect, jest, test} from "@jest/globals";
+import {DTActionTest, IDTest, KeyTest} from "./DTAction.double";
+
+/** ****************** 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 DYOToolsAction', () => {
+  let actionTest: DTActionTest;
+
+  beforeEach(() => {
+    actionTest = new DTActionTest();
+    actionTest.th_set_id(IDTest);
+    actionTest.th_set_key(KeyTest);
+  });
+
+  afterEach(() => {
+    jest.resetAllMocks();
+  });
+
+  describe('inheritance', () => {
+    test('check good inheritance for class', () => {
+      expect(DTAction.prototype instanceof DTComponent).toBeTruthy();
+    });
+  });
+
+  describe('_componentType', () => {
+    test('componentType must be "action"', () => {
+      expect(actionTest.th_get_componentType()).toBe('action');
+    });
+  });
+
+  describe('getMaster', () => {
+    test('call get context with master accessor', () => {
+      actionTest.getMaster();
+
+      expect((actionTest.getContext as any).mock.calls.length).toBe(1);
+      expect((actionTest.getContext as any).mock.calls[0][0]).toBe('master');
+    });
+  });
+
+  describe('execute', () => {
+    test('throw payload in test implementation', async () => {
+      const payload = `execute action`;
+      const expectedPayload = `${KeyTest} : execute action`;
+
+      await expect(actionTest.execute(payload)).rejects.toBe(expectedPayload);
+    });
+  });
+
+  describe('toString', () => {
+    test('string output standard', () => {
+      const toStringAction = actionTest.toString();
+
+      expect(toStringAction).toBe(`Component ${KeyTest} - Type: Action`);
+    });
+  });
+
+  describe('toObject', () => {
+    test('toObject output standard', () => {
+      const toObjectAction: any = actionTest.toObject();
+
+      expect(Object.keys(toObjectAction)).toStrictEqual(['id', 'key', 'type']);
+      expect(toObjectAction.id).toBe(IDTest);
+      expect(toObjectAction.key).toBe(KeyTest);
+      expect(toObjectAction.type).toBe('action');
+    });
+  });
+});

package/test/core/DTBunch.double.ts

@@ -1,5 +1,5 @@
-import { DTBunch, DTComponent } from '../../src';
-import { bunchDefaultOptions as DTBunchDefaultOptions } from '../../src/constants';
+import {DTBunch, DTComponent} from '../../src';
+import {bunchDefaultOptions as DTBunchDefaultOptions} from '../../src/constants';
 import {
   HaileiMetaData,
   IldressMetaData,
@@ -9,8 +9,7 @@ import {
   YssaliaMetaData,
 } from './DTComponentWithMeta.double';
 import DYOToolsElement from '../../src/core/DTElement';
-import { DTBunchOptions, DTElementToObject } from '../../src/types';
-import Mocked = jest.Mocked;
+import {DTBunchOptions, DTElementToObject} from '../../src/types';
 import {
   HaileiIdTest,
   HaileiKeyTest,
@@ -23,11 +22,14 @@ import {
   MaydenaToObjectTest,
   MeldrineIdTest,
   MeldrineKeyTest,
-  MeldrineToObjectTest, YssaliaIdTest, YssaliaKeyTest, YssaliaToObjectTest,
+  MeldrineToObjectTest,
+  YssaliaIdTest,
+  YssaliaKeyTest,
+  YssaliaToObjectTest,
 } from './DTElement.double';
-import { DTErrorStub } from './DTError.double';
-import { DTPlayerStub } from './DTPlayer.double';
+import {DTErrorStub} from './DTError.double';
 import DYOFinder from '../../src/libs/DYOFinder';
+import Mocked = jest.Mocked;
 
 /** ****************** STUB PROPERTIES CONSTANTS
  * Fixed properties to use with double classes, avoid auto generated and easy checking on test
@@ -108,11 +110,11 @@ export class DTBunchTest extends DTBunch<Mocked<DYOToolsElement<IMetaDataTest>>,
     };
   }
 
-  th_get_owner(): DTPlayerStub {
+  th_get_owner(): string {
     return this._owner;
   }
 
-  th_set_owner(owner: DTPlayerStub): void {
+  th_set_owner(owner: string): void {
     this._owner = owner;
   }
 
@@ -165,7 +167,7 @@ export class DTBunchStubLibrary extends DTBunchStub {
     this._items = items;
     this._options = {
       ...DTBunchDefaultOptions,
-      virtualContext: true,
+      virtualContainer: true,
     };
   }
 
@@ -243,6 +245,12 @@ export const generateMockedElements = (numberElements: number): Array<Mocked<DYO
     mockedElement.getOwner.mockImplementation(function () {
       return this._owner;
     });
+    mockedElement.setContainer.mockImplementation(function (container) {
+      this._container = container;
+    });
+    mockedElement.getContainer.mockImplementation(function () {
+      return this._container;
+    });
     mockedElement.copy.mockReturnValue(mockedElement);
     mockedElement.toObject.mockReturnValue(mockedData[selectedMock].toObject);