dyo-tools 0.1.0-rc1

package/test/core/DTError.spec.ts

@@ -0,0 +1,106 @@
+import {
+  afterEach, beforeEach, describe, expect, jest, test,
+} from '@jest/globals';
+import {
+  CodeTest, DTErrorMock, MessageTest, TimestampTest,
+} from './DTError.double';
+import { DTError } from '../../src';
+import { DTComponentStub, IDTest as ComponentIdTest } from './DTComponent.double';
+
+describe('class DYOToolsError', () => {
+  let errorMock: DTErrorMock;
+
+  beforeEach(() => {
+    errorMock = new DTErrorMock();
+  });
+
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  describe('constructor()', () => {
+    test('creation with standard field (code, message and timestamp)', () => {
+      const newError = new DTError(CodeTest, MessageTest);
+      const currentDate = new Date();
+      jest.spyOn(newError, 'getCode').mockImplementation(function () {
+        return this.code;
+      });
+      jest.spyOn(newError, 'getMessage').mockImplementation(function () {
+        return this.message;
+      });
+      jest.spyOn(newError, 'getTimestamp').mockImplementation(function () {
+        return this.timestamp;
+      });
+      jest.spyOn(newError, 'getInitiator').mockImplementation(function () {
+        return this.initiator;
+      });
+      jest.spyOn(newError, 'getConvicted').mockImplementation(function () {
+        return this.convicted;
+      });
+
+      expect(newError.getCode()).toBe(CodeTest);
+      expect(newError.getMessage()).toBe(MessageTest);
+      expect(newError.getTimestamp().toDateString()).toBe(currentDate.toDateString());
+      expect(newError.getTimestamp().toTimeString()).toBe(currentDate.toTimeString());
+      expect(newError.getInitiator()).toBeUndefined();
+      expect(newError.getConvicted()).toBeUndefined();
+    });
+
+    test('creation with initiator component', () => {
+      const initiatorMock = new DTComponentStub('initiator');
+      const newError = new DTError(CodeTest, MessageTest, initiatorMock);
+      jest.spyOn(newError, 'getInitiator').mockImplementation(function () {
+        return this.initiator;
+      });
+
+      expect(newError.getInitiator().getId()).toBe(`${ComponentIdTest}-initiator`);
+    });
+
+    test('creation with initiator and convicted component', () => {
+      const initiatorMock = new DTComponentStub('initiator');
+      const convictedMock = new DTComponentStub('convicted');
+      const newError = new DTError(CodeTest, MessageTest, initiatorMock, convictedMock);
+      jest.spyOn(newError, 'getConvicted').mockImplementation(function () {
+        return this.convicted;
+      });
+
+      expect(newError.getConvicted().getId()).toBe(`${ComponentIdTest}-convicted`);
+    });
+  });
+
+  describe('getCode()', () => {
+    test('return code property', () => {
+      expect(errorMock.getCode()).toBe(CodeTest);
+    });
+  });
+
+  describe('getMessage()', () => {
+    test('return message property', () => {
+      expect(errorMock.getMessage()).toBe(MessageTest);
+    });
+  });
+
+  describe('getTimestamp()', () => {
+    test('return timestamp property', () => {
+      expect(errorMock.getTimestamp().getTime()).toBe(TimestampTest);
+    });
+  });
+
+  describe('getInitiator()', () => {
+    test('return initiator component', () => {
+      const errorMockSet = new DTErrorMock(true);
+
+      expect(errorMock.getInitiator()).toBeUndefined();
+      expect(errorMockSet.getInitiator().getId()).toBe(`${ComponentIdTest}-initiator`);
+    });
+  });
+
+  describe('getConvicted()', () => {
+    test('return convicted component', () => {
+      const errorMockSet = new DTErrorMock(true);
+
+      expect(errorMock.getConvicted()).toBeUndefined();
+      expect(errorMockSet.getConvicted().getId()).toBe(`${ComponentIdTest}-convicted`);
+    });
+  });
+});

package/test/core/DTPlayer.double.ts

@@ -0,0 +1,49 @@
+import { DTPlayer } from '../../src';
+import { IMetaDataTest, PlayerMetaData } from './DTComponentWithMeta.double';
+
+// Global Variables
+export const IDTest = 'DTPlayer-id-1234567';
+export const KeyTest = 'DTPlayer-key-1234567';
+export const toStringTest = 'DTPlayer Stub toString';
+
+// Stub for Player (used for other tests)
+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;
+  }
+}
+
+// Mock Constructor and parent methods for DTPlayer
+export class DTPlayerMock extends DTPlayer<IMetaDataTest> {
+  constructor() {
+    super();
+    this._id = IDTest;
+    this._key = KeyTest;
+  }
+
+  getComponentType(): string {
+    return this._componentType;
+  }
+
+  setManyMeta(metaValues: Partial<IMetaDataTest>) {
+    this._meta = PlayerMetaData;
+  }
+
+  getManyMeta(metaKeys: Array<keyof IMetaDataTest> = []): Partial<IMetaDataTest> {
+    return this._meta;
+  }
+}

package/test/core/DTPlayer.spec.ts

@@ -0,0 +1,102 @@
+import { beforeEach, describe, test } from '@jest/globals';
+import { DTPlayerMock, IDTest, KeyTest } from './DTPlayer.double';
+import { DTComponentTestMock } from './DTComponent.double';
+import { PlayerMetaData } from './DTComponentWithMeta.double';
+
+describe('class DYOToolsPlayer', () => {
+  let playerMock: DTPlayerMock;
+
+  beforeEach(() => {
+    playerMock = new DTPlayerMock();
+  });
+
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  describe('_componentType', () => {
+    test('componentType must be "player"', () => {
+      expect(playerMock.getComponentType()).toBe('player');
+    });
+  });
+
+  describe('copy()', () => {
+    test('copy a player - 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 playerMockCopy = playerMock.copy();
+      jest.spyOn(playerMock, 'getId').mockImplementation(function () {
+        return this._id;
+      });
+      jest.spyOn(playerMockCopy, 'getId').mockImplementation(function () {
+        return this._id;
+      });
+      jest.spyOn(playerMock, 'getKey').mockImplementation(function () {
+        return this._key;
+      });
+      jest.spyOn(playerMockCopy, 'getKey').mockImplementation(function () {
+        return this._key;
+      });
+
+      expect(playerMock.getId() === playerMockCopy.getId()).toBeFalsy();
+      expect(playerMock.getKey() === playerMockCopy.getKey()).toBeTruthy();
+    });
+
+    test('copy a player - not copy context', () => {
+      // This test doesn't mock the DOC (Depended-on Component) correctly
+      // Need to change implementation to implement correct testing
+      jest.spyOn(playerMock, 'setContext').mockImplementation(function (context) {
+        this._context = context;
+      });
+
+      playerMock.setContext(new DTComponentTestMock());
+
+      const playerMockCopy = playerMock.copy();
+      jest.spyOn(playerMockCopy, 'getContext').mockImplementation(function () {
+        return this._context;
+      });
+
+      expect(playerMockCopy.getContext()).toBeUndefined();
+    });
+
+    test('copy a player - copy meta-data', () => {
+      // This test doesn't mock the DOC (Depended-on Component) correctly
+      // Need to change implementation to implement correct testing
+      playerMock.setManyMeta({});
+
+      const playerMockCopy = playerMock.copy();
+      jest.spyOn(playerMockCopy, 'getManyMeta').mockImplementation(function () {
+        return this._meta;
+      });
+
+      expect(playerMockCopy.getManyMeta()).toStrictEqual(PlayerMetaData);
+    });
+  });
+
+  describe('toObject()', () => {
+    test('toObject output standard', () => {
+      const toObjectPlayer = playerMock.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', () => {
+      playerMock.setManyMeta({});
+
+      const toObjectPlayer = playerMock.toObject();
+      expect(Object.keys(toObjectPlayer)).toStrictEqual(['id', 'key', 'type', 'meta']);
+      expect(toObjectPlayer.meta).toStrictEqual(PlayerMetaData);
+    });
+  });
+
+  describe('toString()', () => {
+    test('string output standard', () => {
+      const toStringElement = playerMock.toString();
+
+      expect(toStringElement).toBe(`Component ${KeyTest} - Type: Player`);
+    });
+  });
+});

package/test/utils/filters.spec.ts

@@ -0,0 +1,109 @@
+import { describe } from '@jest/globals';
+import { validFiltersForItem } from '../../src/utils/filters';
+import { FilterOperatorType } from '../../src/types';
+
+describe('validFiltersForItem', () => {
+  test('valid value for $eq equivalency', () => {
+    expect(validFiltersForItem('filter-id', 'filter-id', FilterOperatorType.EQ)).toBe(true);
+    expect(validFiltersForItem('12345', 'filter-id', FilterOperatorType.EQ)).toBe(false);
+    expect(validFiltersForItem(12345, '12345', FilterOperatorType.EQ)).toBe(false);
+    expect(validFiltersForItem(true, true, FilterOperatorType.EQ)).toBe(true);
+    expect(validFiltersForItem(false, true, FilterOperatorType.EQ)).toBe(false);
+    expect(validFiltersForItem(null, null, FilterOperatorType.EQ)).toBe(true);
+    expect(validFiltersForItem(0, null, FilterOperatorType.EQ)).toBe(false);
+    expect(validFiltersForItem(undefined, null, FilterOperatorType.EQ)).toBe(false);
+    expect(validFiltersForItem(12345, 12345, FilterOperatorType.EQ)).toBe(true);
+    expect(validFiltersForItem(45678, 12345, FilterOperatorType.EQ)).toBe(false);
+  });
+
+  test('valid value for $in operator', () => {
+    expect(validFiltersForItem('filter-id', ['filter-id'], FilterOperatorType.IN)).toBe(true);
+    expect(validFiltersForItem('filter-id', ['filter-id', '12345'], FilterOperatorType.IN)).toBe(true);
+    expect(validFiltersForItem('filter-id', ['12345', 'filter-key'], FilterOperatorType.IN)).toBe(false);
+    expect(validFiltersForItem(true, [true, 12345, 'filter-id'], FilterOperatorType.IN)).toBe(true);
+    expect(validFiltersForItem(false, [true, 12345, 'filter-id'], FilterOperatorType.IN)).toBe(false);
+    expect(validFiltersForItem(null, [null, 12345, 'filter-id'], FilterOperatorType.IN)).toBe(true);
+    expect(validFiltersForItem(undefined, [null, 12345, 'filter-id'], FilterOperatorType.IN)).toBe(false);
+    expect(validFiltersForItem(12345, ['filter-id', 12345, 45678, true], FilterOperatorType.IN)).toBe(true);
+    expect(validFiltersForItem(17, ['filter-id', 12345, 45678, true], FilterOperatorType.IN)).toBe(false);
+    expect(validFiltersForItem('filter-id', null, FilterOperatorType.IN)).toBe(false);
+  });
+
+  test('valid value for $nin operator', () => {
+    expect(validFiltersForItem('filter-id', ['filter-id'], FilterOperatorType.NIN)).toBe(false);
+    expect(validFiltersForItem('filter-id', ['filter-id', '12345'], FilterOperatorType.NIN)).toBe(false);
+    expect(validFiltersForItem('filter-id', ['12345', 'filter-key'], FilterOperatorType.NIN)).toBe(true);
+    expect(validFiltersForItem(true, [true, 12345, 'filter-id'], FilterOperatorType.NIN)).toBe(false);
+    expect(validFiltersForItem(false, [true, 12345, 'filter-id'], FilterOperatorType.NIN)).toBe(true);
+    expect(validFiltersForItem(null, [null, 12345, 'filter-id'], FilterOperatorType.NIN)).toBe(false);
+    expect(validFiltersForItem(undefined, [null, 12345, 'filter-id'], FilterOperatorType.NIN)).toBe(true);
+    expect(validFiltersForItem(12345, ['filter-id', 12345, 45678, true], FilterOperatorType.NIN)).toBe(false);
+    expect(validFiltersForItem(17, ['filter-id', 12345, 45678, true], FilterOperatorType.NIN)).toBe(true);
+    expect(validFiltersForItem('filter-id', null, FilterOperatorType.NIN)).toBe(false);
+  });
+
+  test('valid value for $ne operator', () => {
+    expect(validFiltersForItem('filter-id', 'filter-id', FilterOperatorType.NE)).toBe(false);
+    expect(validFiltersForItem('12345', 'filter-id', FilterOperatorType.NE)).toBe(true);
+    expect(validFiltersForItem(12345, '12345', FilterOperatorType.NE)).toBe(true);
+    expect(validFiltersForItem(true, true, FilterOperatorType.NE)).toBe(false);
+    expect(validFiltersForItem(false, true, FilterOperatorType.NE)).toBe(true);
+    expect(validFiltersForItem(null, null, FilterOperatorType.NE)).toBe(false);
+    expect(validFiltersForItem(0, null, FilterOperatorType.NE)).toBe(true);
+    expect(validFiltersForItem(undefined, null, FilterOperatorType.NE)).toBe(true);
+    expect(validFiltersForItem(12345, 12345, FilterOperatorType.NE)).toBe(false);
+    expect(validFiltersForItem(45678, 12345, FilterOperatorType.NE)).toBe(true);
+  });
+
+  test('valid value for $lte operator', () => {
+    expect(validFiltersForItem(1, 3, FilterOperatorType.LTE)).toBe(true);
+    expect(validFiltersForItem(5, 3, FilterOperatorType.LTE)).toBe(false);
+    expect(validFiltersForItem(3, 3, FilterOperatorType.LTE)).toBe(true);
+    expect(validFiltersForItem(0, 0, FilterOperatorType.LTE)).toBe(true);
+    expect(validFiltersForItem(-11, 0, FilterOperatorType.LTE)).toBe(true);
+    expect(validFiltersForItem(-7, -11, FilterOperatorType.LTE)).toBe(false);
+    expect(validFiltersForItem(null, -11, FilterOperatorType.LTE)).toBe(false);
+    expect(validFiltersForItem(undefined, -11, FilterOperatorType.LTE)).toBe(false);
+    expect(validFiltersForItem(0, null, FilterOperatorType.LTE)).toBe(false);
+    expect(validFiltersForItem(0, undefined, FilterOperatorType.LTE)).toBe(false);
+  });
+
+  test('valid value for $gte operator', () => {
+    expect(validFiltersForItem(1, 3, FilterOperatorType.GTE)).toBe(false);
+    expect(validFiltersForItem(5, 3, FilterOperatorType.GTE)).toBe(true);
+    expect(validFiltersForItem(3, 3, FilterOperatorType.GTE)).toBe(true);
+    expect(validFiltersForItem(0, 0, FilterOperatorType.GTE)).toBe(true);
+    expect(validFiltersForItem(-11, 0, FilterOperatorType.GTE)).toBe(false);
+    expect(validFiltersForItem(-7, -11, FilterOperatorType.GTE)).toBe(true);
+    expect(validFiltersForItem(null, -7, FilterOperatorType.GTE)).toBe(false);
+    expect(validFiltersForItem(undefined, -7, FilterOperatorType.GTE)).toBe(false);
+    expect(validFiltersForItem(0, null, FilterOperatorType.GTE)).toBe(false);
+    expect(validFiltersForItem(0, undefined, FilterOperatorType.GTE)).toBe(false);
+  });
+
+  test('valid value for $contains operator', () => {
+    expect(validFiltersForItem(['filter-id'], 'filter-id', FilterOperatorType.CONTAINS)).toBe(true);
+    expect(validFiltersForItem(['filter-id', '12345'], 'filter-id', FilterOperatorType.CONTAINS)).toBe(true);
+    expect(validFiltersForItem(['12345', 'filter-key'], 'filter-id', FilterOperatorType.CONTAINS)).toBe(false);
+    expect(validFiltersForItem([true, 12345, 'filter-id'], true, FilterOperatorType.CONTAINS)).toBe(true);
+    expect(validFiltersForItem([true, 12345, 'filter-id'], false, FilterOperatorType.CONTAINS)).toBe(false);
+    expect(validFiltersForItem([null, 12345, 'filter-id'], null, FilterOperatorType.CONTAINS)).toBe(true);
+    expect(validFiltersForItem([null, 12345, 'filter-id'], undefined, FilterOperatorType.CONTAINS)).toBe(false);
+    expect(validFiltersForItem(['filter-id', 12345, 45678, true], 12345, FilterOperatorType.CONTAINS)).toBe(true);
+    expect(validFiltersForItem(['filter-id', 12345, 45678, true], 17, FilterOperatorType.CONTAINS)).toBe(false);
+    expect(validFiltersForItem(null, 'filter-id', FilterOperatorType.CONTAINS)).toBe(false);
+  });
+
+  test('valid value for $ncontains operator', () => {
+    expect(validFiltersForItem(['filter-id'], 'filter-id', FilterOperatorType.NCONTAINS)).toBe(false);
+    expect(validFiltersForItem(['filter-id', '12345'], 'filter-id', FilterOperatorType.NCONTAINS)).toBe(false);
+    expect(validFiltersForItem(['12345', 'filter-key'], 'filter-id', FilterOperatorType.NCONTAINS)).toBe(true);
+    expect(validFiltersForItem([true, 12345, 'filter-id'], true, FilterOperatorType.NCONTAINS)).toBe(false);
+    expect(validFiltersForItem([true, 12345, 'filter-id'], false, FilterOperatorType.NCONTAINS)).toBe(true);
+    expect(validFiltersForItem([null, 12345, 'filter-id'], null, FilterOperatorType.NCONTAINS)).toBe(false);
+    expect(validFiltersForItem([null, 12345, 'filter-id'], undefined, FilterOperatorType.NCONTAINS)).toBe(true);
+    expect(validFiltersForItem(['filter-id', 12345, 45678, true], 12345, FilterOperatorType.NCONTAINS)).toBe(false);
+    expect(validFiltersForItem(['filter-id', 12345, 45678, true], 17, FilterOperatorType.NCONTAINS)).toBe(true);
+    expect(validFiltersForItem(null, 'filter-id', FilterOperatorType.NCONTAINS)).toBe(false);
+  });
+});

package/tsconfig.json

@@ -0,0 +1,21 @@
+{
+  "compilerOptions": {
+    "module": "commonjs",
+    "declaration": true,
+    "removeComments": true,
+    "emitDecoratorMetadata": true,
+    "experimentalDecorators": true,
+    "allowSyntheticDefaultImports": true,
+    "target": "es2015",
+    "sourceMap": true,
+    "outDir": "./dist",
+    "baseUrl": "./",
+    "incremental": true
+  },
+  "include": [
+    "src/**/*.ts"
+  ],
+  "exclude": [
+    "node_modules"
+  ]
+}