@futdevpro/fsm-dynamo 1.9.51 → 1.10.2

package/src/_modules/pipe/_collections/utils/pip-multi-pipe-pipe.util.spec.ts

@@ -0,0 +1,60 @@
+
+import {
+  DyFM_AngularMultiPipeAvailable
+} from '../../_enums/pip.enum';
+import { DyFM_MultiPipe_Setting } from '../../_models/pip-multi-pipe-settings.type';
+import { DyFM_multiPipe_pipeTransform, DyFM_multiPipeAngularPipes } from './pip-multi-pipe-pipe.util';
+
+describe('DyFM_multiPipe_pipeTransform', () => {
+  it('should return the original value if no pipes are provided', () => {
+    const value = 'test';
+    const pipes: DyFM_MultiPipe_Setting[] = [];
+    expect(DyFM_multiPipe_pipeTransform(value, pipes)).toBe(value);
+  });
+
+  /* it('should return the original value if pipe has more than one key', () => {
+    const value = 'test';
+    const pipes: DyFM_MultiPipe_Setting[] = [{ pipe1: [], pipe2: [] }];
+    expect(DyFM_multiPipe_pipeTransform(value, pipes)).toBe(value);
+  });
+
+  it('should return the original value if pipe is not available', () => {
+    const value = 'test';
+    const pipes: DyFM_MultiPipe_Setting[] = [{ unknownPipe: [] }];
+    expect(DyFM_multiPipe_pipeTransform(value, pipes)).toBe(value);
+  });
+
+  it('should transform value using a known pipe without arguments', () => {
+    const value = 'test';
+    const pipes: DyFM_MultiPipe_Setting[] = [{ [DyFM_Pipe.currency]: [] }];
+    DyFM_pipeTransforms[DyFM_Pipe.currency] = (val: unknown) => 'transformed';
+    expect(DyFM_multiPipe_pipeTransform(value, pipes)).toBe('transformed');
+  });
+
+  it('should transform value using a known pipe with arguments', () => {
+    const value = 'test';
+    const pipes: DyFM_MultiPipe_Setting[] = [{ [DyFM_Pipe.currency]: ['arg1'] }];
+    DyFM_pipeTransforms[DyFM_Pipe.currency] = (val: unknown, arg: string) => `transformed with ${arg}`;
+    expect(DyFM_multiPipe_pipeTransform(value, pipes)).toBe('transformed with arg1');
+  }); */
+
+  xit('should return the original value if Angular pipe is not defined', () => {
+    const value = 'test';
+    const pipes: DyFM_MultiPipe_Setting[] = [{ [DyFM_AngularMultiPipeAvailable.currency]: [] }];
+    expect(DyFM_multiPipe_pipeTransform(value, pipes)).toBe(value);
+  });
+
+  it('should transform value using a defined Angular pipe', () => {
+    const value = 'test';
+    const pipes: DyFM_MultiPipe_Setting[] = [{ [DyFM_AngularMultiPipeAvailable.currency]: ['arg1'] }];
+    DyFM_multiPipeAngularPipes[DyFM_AngularMultiPipeAvailable.currency] = (val: string, arg: string) => `angular transformed with ${arg}`;
+    expect(DyFM_multiPipe_pipeTransform(value, pipes)).toBe('angular transformed with arg1');
+  });
+
+  /* it('should handle errors gracefully and return the original value', () => {
+    const value = 'test';
+    const pipes: DyFM_MultiPipe_Setting[] = [{ [DyFM_Pipe.currency]: [] }];
+    DyFM_pipeTransforms[DyFM_Pipe.currency] = () => { throw new Error('Test error'); };
+    expect(DyFM_multiPipe_pipeTransform(value, pipes)).toBe(value);
+  }); */
+});

package/src/_modules/pipe/_collections/utils/pip-obj-key-pipe.util.spec.ts

@@ -0,0 +1,28 @@
+
+import { DyFM_objKey_pipeTransform } from './pip-obj-key-pipe.util';
+
+describe('DyFM_objKey_pipeTransform', () => {
+  it('should return an array of keys when an object is provided', () => {
+    const input = { a: 1, b: 2, c: 3 };
+    const expectedOutput = ['a', 'b', 'c'];
+    expect(DyFM_objKey_pipeTransform(input)).toEqual(expectedOutput);
+  });
+
+  it('should return an empty array when null is provided', () => {
+    const input = null;
+    const expectedOutput: string[] = [];
+    expect(DyFM_objKey_pipeTransform(input)).toEqual(expectedOutput);
+  });
+
+  it('should return an empty array when undefined is provided', () => {
+    const input = undefined;
+    const expectedOutput: string[] = [];
+    expect(DyFM_objKey_pipeTransform(input)).toEqual(expectedOutput);
+  });
+
+  it('should return an empty array when an empty object is provided', () => {
+    const input = {};
+    const expectedOutput: string[] = [];
+    expect(DyFM_objKey_pipeTransform(input)).toEqual(expectedOutput);
+  });
+});

package/src/_modules/pipe/_collections/utils/pip-range-pipe.util.spec.ts

@@ -0,0 +1,59 @@
+
+import { DyFM_RangeValue } from '../../../../_models/control-models/range-value.control-model';
+import { DyFM_RangePipe_Setting } from '../../_enums/pip-range-pipe-setting.enum';
+import { DyFM_MultiPipe_Setting } from '../../_models/pip-multi-pipe-settings.type';
+import { DyFM_range_pipeTransform } from './pip-range-pipe.util';
+
+describe('DyFM_range_pipeTransform', () => {
+  const mockMultiPipeTransform = (value: number, multiPipes: DyFM_MultiPipe_Setting[]) => {
+    return value.toString();
+  };
+
+  beforeAll(() => {
+    spyOn(console, 'warn');
+  });
+
+  it('should return the average of from and to when setting is avg or average', () => {
+    const value: DyFM_RangeValue = { from: 10, to: 20, isRange: true };
+    expect(DyFM_range_pipeTransform(value, DyFM_RangePipe_Setting.avg)).toBe(15);
+    expect(DyFM_range_pipeTransform(value, DyFM_RangePipe_Setting.average)).toBe(15);
+  });
+
+  it('should return from when setting is min or from', () => {
+    const value: DyFM_RangeValue = { from: 10, to: 20, isRange: true };
+    expect(DyFM_range_pipeTransform(value, DyFM_RangePipe_Setting.min)).toBe(10);
+    expect(DyFM_range_pipeTransform(value, DyFM_RangePipe_Setting.from)).toBe(10);
+  });
+
+  it('should return to when setting is max or to', () => {
+    const value: DyFM_RangeValue = { from: 10, to: 20, isRange: true };
+    expect(DyFM_range_pipeTransform(value, DyFM_RangePipe_Setting.max)).toBe(20);
+    expect(DyFM_range_pipeTransform(value, DyFM_RangePipe_Setting.to)).toBe(20);
+  });
+
+  it('should return formatted string when setting is both or fromTo', () => {
+    const value: DyFM_RangeValue = { from: 10, to: 20, isRange: true };
+    expect(DyFM_range_pipeTransform(value, DyFM_RangePipe_Setting.both)).toBe('10 - 20');
+    expect(DyFM_range_pipeTransform(value, DyFM_RangePipe_Setting.fromTo)).toBe('10 - 20');
+  });
+
+  /* it('should return transformed value using multiPipes when setting is both or fromTo and multiPipes are provided', () => {
+    const value: DyFM_RangeValue = { from: 10, to: 20, isRange: true };
+    const multiPipes: DyFM_MultiPipe_Setting[] = [{} as DyFM_MultiPipe_Setting];
+    spyOn(DyFM_multiPipe_pipeTransform, 'call').and.callFake(mockMultiPipeTransform);
+
+    expect(DyFM_range_pipeTransform(value, DyFM_RangePipe_Setting.both, multiPipes)).toBe('10 - 20');
+    expect(DyFM_range_pipeTransform(value, DyFM_RangePipe_Setting.fromTo, multiPipes)).toBe('10 - 20');
+  }); */
+
+  it('should return the original value if requirements are not met', () => {
+    const value: DyFM_RangeValue = { from: 10, to: 20, isRange: false };
+    expect(DyFM_range_pipeTransform(value, DyFM_RangePipe_Setting.avg)).toBe(value);
+    expect(console.warn).toHaveBeenCalled();
+  });
+
+  it('should return the original value for an unknown setting', () => {
+    const value: DyFM_RangeValue = { from: 10, to: 20, isRange: true };
+    expect(DyFM_range_pipeTransform(value, 'unknown')).toBe(value);
+  });
+});

package/src/_modules/pipe/_collections/utils/pip-region-pipe.util.spec.ts

@@ -0,0 +1,31 @@
+
+import { DyFM_region_pipeTransform } from './pip-region-pipe.util';
+import { DyFM_countryISOs } from '../../../location/_collections/loc-country-isos.const';
+import { DyFM_CountryISO } from '../../../location/_models/loc-country-iso.interface';
+
+describe('DyFM_region_pipeTransform', () => {
+  it('should return the region when a valid country ISO is provided', () => {
+    const validCountryISO = DyFM_countryISOs[0].iso2;
+    const expectedRegion = DyFM_countryISOs[0].region;
+
+    const result = DyFM_region_pipeTransform(validCountryISO);
+
+    expect(result).toBe(expectedRegion);
+  });
+
+  it('should return the input country ISO when an invalid country ISO is provided', () => {
+    const invalidCountryISO = 'XX';
+
+    const result = DyFM_region_pipeTransform(invalidCountryISO);
+
+    expect(result).toBe(invalidCountryISO);
+  });
+
+  it('should return the input country ISO when the country ISO is not found', () => {
+    const notFoundCountryISO = 'ZZ';
+
+    const result = DyFM_region_pipeTransform(notFoundCountryISO);
+
+    expect(result).toBe(notFoundCountryISO);
+  });
+});

package/src/_modules/pipe/_collections/utils/pip-replace-pipe.util.spec.ts

@@ -0,0 +1,44 @@
+
+import { DyFM_replace_pipeTransform } from './pip-replace-pipe.util';
+
+describe('DyFM_replace_pipeTransform', () => {
+  it('should replace all occurrences of "from" with "to" in the given string', () => {
+    const result = DyFM_replace_pipeTransform('hello world', 'world', 'there');
+    expect(result).toBe('hello there');
+  });
+
+  it('should return the original string if "from" is not found', () => {
+    const result = DyFM_replace_pipeTransform('hello world', 'planet', 'there');
+    expect(result).toBe('hello world');
+  });
+
+  it('should handle empty "from" and "to" strings', () => {
+    const result = DyFM_replace_pipeTransform('hello world', '', '');
+    expect(result).toBe('hello world');
+  });
+
+  it('should handle empty "value" string', () => {
+    const result = DyFM_replace_pipeTransform('', 'world', 'there');
+    expect(result).toBe('');
+  });
+
+  it('should handle null "value" gracefully', () => {
+    const result = DyFM_replace_pipeTransform(null, 'world', 'there');
+    expect(result).toBeNull();
+  });
+
+  it('should handle undefined "value" gracefully', () => {
+    const result = DyFM_replace_pipeTransform(undefined, 'world', 'there');
+    expect(result).toBeUndefined();
+  });
+
+  it('should replace all occurrences when "from" is a substring of "value"', () => {
+    const result = DyFM_replace_pipeTransform('ababab', 'ab', 'cd');
+    expect(result).toBe('cdcdcd');
+  });
+
+  it('should return the original string if "from" and "to" are the same', () => {
+    const result = DyFM_replace_pipeTransform('hello world', 'world', 'world');
+    expect(result).toBe('hello world');
+  });
+});

package/src/_modules/pipe/_collections/utils/pip-slider-pipe.util.spec.ts

@@ -0,0 +1,21 @@
+
+import { DyFM_slider_pipeTransform } from './pip-slider-pipe.util';
+import { DyFM_RangeValue } from '../../../../_models/control-models/range-value.control-model';
+
+describe('DyFM_slider_pipeTransform', () => {
+  it('should return the string representation of a DyFM_RangeValue instance', () => {
+    const rangeValue = new DyFM_RangeValue<number>(1, 10);
+    spyOn(rangeValue, 'toString').and.returnValue('1-10');
+    expect(DyFM_slider_pipeTransform(rangeValue)).toBe('1-10');
+  });
+
+  it('should return the string representation of a number', () => {
+    const numberValue = 42;
+    expect(DyFM_slider_pipeTransform(numberValue)).toBe('42');
+  });
+
+  it('should return the string as is if the input is a string', () => {
+    const stringValue = 'test';
+    expect(DyFM_slider_pipeTransform(stringValue)).toBe('test');
+  });
+});

package/src/_modules/pipe/_collections/utils/pip-smart-replace-pipe.util.spec.ts

@@ -0,0 +1,61 @@
+
+import { DyFM_smartReplace_pipeTransform } from './pip-smart-replace-pipe.util';
+
+describe('DyFM_smartReplace_pipeTransform', () => {
+  it('should return the original value if replacer is not defined', () => {
+    const result = DyFM_smartReplace_pipeTransform('Hello, {name}!', null);
+    expect(result).toBe('Hello, {name}!');
+  });
+
+  it('should replace keys with values from replacer', () => {
+    const replacer = { name: { value: 'World', pipes: [] } };
+    spyOn(console, 'warn');
+    const result = DyFM_smartReplace_pipeTransform('Hello, {name}!', replacer);
+    expect(result).toBe('Hello, World!');
+    expect(console.warn).not.toHaveBeenCalled();
+  });
+
+  it('should warn if replacer key has no pipes', () => {
+    const replacer = { name: { value: 'World' } };
+    spyOn(console, 'warn');
+    const result = DyFM_smartReplace_pipeTransform('Hello, {name}!', replacer);
+    expect(result).toBeUndefined();
+    expect(console.warn).toHaveBeenCalledWith(
+      'DYNAMO WARNING: ' +
+      '\nSmartReplacePipe: replaceTo[name].multiPipe is not defined...',
+      '\n\n',
+      jasmine.any(Error)
+    );
+  });
+
+  it('should warn if replacer key pipes is not an array', () => {
+    const replacer = { name: { value: 'World', pipes: 'not-an-array' } };
+    spyOn(console, 'warn');
+    const result = DyFM_smartReplace_pipeTransform('Hello, {name}!', replacer);
+    expect(result).toBeUndefined();
+    expect(console.warn).toHaveBeenCalledWith(
+      'DYNAMO WARNING: ' +
+      '\nSmartReplacePipe: replaceTo[name].multiPipe is not an array...',
+      '\n\n',
+      jasmine.any(Error)
+    );
+  });
+
+  /* it('should apply multiPipes if provided', () => {
+    const replacer = { name: 'World' };
+    const multiPipes: DyFM_MultiPipe_Setting[] = [];
+    spyOn(DyFM_multiPipe_pipeTransform).and.callThrough();
+    const result = DyFM_smartReplace_pipeTransform('Hello, {name}!', replacer, multiPipes);
+    expect(result).toBe('Hello, World!');
+    expect(DyFM_multiPipe_pipeTransform).toHaveBeenCalledWith('World', multiPipes);
+  }); */
+
+  it('should handle multiple replacements', () => {
+    const replacer = {
+      firstName: { value: 'John', pipes: [] },
+      lastName: { value: 'Doe', pipes: [] }
+    };
+    const result = DyFM_smartReplace_pipeTransform('Hello, {firstName} {lastName}!', replacer);
+    expect(result).toBe('Hello, John Doe!');
+  });
+});

package/src/_modules/socket/_models/sck-client-params.control-model.spec.ts

@@ -0,0 +1,67 @@
+
+import { second } from '../../../_collections/constants/times.const';
+import { DyFM_SocketClient_Params } from './sck-client-params.control-model';
+
+describe('DyFM_SocketClient_Params', () => {
+  xit('should assign provided values to the instance', () => {
+    const params: DyFM_SocketClient_Params = {
+      name: 'testName',
+      service: 'testService',
+      address: '127.0.0.1',
+      port: 8080,
+      reconnectDelay: second * 5,
+      reconnect: false,
+      socketOptions: { autoConnect: false }
+    };
+
+    const instance = new DyFM_SocketClient_Params(params);
+
+    expect(instance.name).toBe(params.name);
+    expect(instance.service).toBe(params.service);
+    expect(instance.address).toBe(params.address);
+    expect(instance.port).toBe(params.port);
+    expect(instance.reconnectDelay).toBe(params.reconnectDelay);
+    expect(instance.reconnect).toBe(params.reconnect);
+    expect(instance.socketOptions).toEqual(params.socketOptions);
+  });
+
+  it('should set default values for reconnectDelay and reconnect', () => {
+    const params: DyFM_SocketClient_Params = {};
+
+    const instance = new DyFM_SocketClient_Params(params);
+
+    expect(instance.reconnectDelay).toBe(second * 10);
+    expect(instance.reconnect).toBe(true);
+  });
+
+  it('should set reconnect to false if socketOptions.autoConnect is true', () => {
+    const params: DyFM_SocketClient_Params = {
+      socketOptions: { autoConnect: true }
+    };
+
+    const instance = new DyFM_SocketClient_Params(params);
+
+    expect(instance.reconnect).toBe(false);
+  });
+
+  it('should set reconnect to false if socketOptions.reconnection is true', () => {
+    const params: DyFM_SocketClient_Params = {
+      socketOptions: { reconnection: true }
+    };
+
+    const instance = new DyFM_SocketClient_Params(params);
+
+    expect(instance.reconnect).toBe(false);
+  });
+
+  it('should set reconnect to true if reconnectDelay is provided and socketOptions do not override', () => {
+    const params: DyFM_SocketClient_Params = {
+      reconnectDelay: second * 5,
+      socketOptions: { autoConnect: false, reconnection: false }
+    };
+
+    const instance = new DyFM_SocketClient_Params(params);
+
+    expect(instance.reconnect).toBe(true);
+  });
+});

package/src/_modules/socket/_models/sck-socket-event.control-model.spec.ts

@@ -0,0 +1,66 @@
+
+import { DyFM_global_settings } from '../../../_collections/constants/global-settings.const';
+import { DyFM_Log } from '../../../_collections/utils/log.util';
+import { DyFM_SocketEvent_Key } from '../_enums/sck-event-key.enum';
+import { DyFM_SocketEvent, DyFM_SocketEventPreprocessTask, DyFM_SocketEventTask } from './sck-socket-event.control-model';
+
+describe('DyFM_SocketEvent', () => {
+  let socketEvent: DyFM_SocketEvent<any>;
+
+  beforeEach(() => {
+    socketEvent = new DyFM_SocketEvent({
+      eventKey: DyFM_SocketEvent_Key.connect,
+      preProcesses: [],
+      tasks: [],
+    });
+  });
+
+  it('should initialize with default values', () => {
+    expect(socketEvent.name).toBe(DyFM_SocketEvent_Key.connect);
+    expect(socketEvent.serviceName).toBe('UnknownSocketService');
+    expect(socketEvent.preProcesses).toEqual([]);
+    expect(socketEvent.tasks).toEqual([]);
+    expect(socketEvent.logEvent).toBe(DyFM_global_settings.log_settings.socket_mainEvents);
+    expect(socketEvent.logEventContent).toBe(DyFM_global_settings.log_settings.socket_eventContent);
+  });
+
+  it('should execute preProcesses and tasks', async () => {
+    const mockPreProcess: DyFM_SocketEventPreprocessTask<any, any> = jasmine.createSpy('preProcess').and.callFake(async (content) => content);
+    const mockTask: DyFM_SocketEventTask<any> = jasmine.createSpy('task').and.callFake(async () => {});
+
+    socketEvent.preProcesses = [mockPreProcess];
+    socketEvent.tasks = [mockTask];
+
+    await socketEvent.executeEventTasks('testContent', 'testIssuer');
+
+    expect(mockPreProcess).toHaveBeenCalledWith('testContent');
+    expect(mockTask).toHaveBeenCalledWith('testContent', 'testIssuer');
+  });
+
+  it('should log event if logEvent is true', async () => {
+    spyOn(DyFM_Log, 'log');
+    socketEvent.logEvent = true;
+
+    await socketEvent.executeEventTasks('testContent', 'testIssuer');
+
+    expect(DyFM_Log.log).toHaveBeenCalled();
+  });
+
+  it('should handle errors in executeEventTasks gracefully', async () => {
+    const mockTask: DyFM_SocketEventTask<any> = jasmine.createSpy('task').and.callFake(async () => {
+      throw new Error('Task Error');
+    });
+
+    socketEvent.tasks = [mockTask];
+    spyOn(DyFM_Log, 'error');
+
+    await socketEvent.executeEventTasks('testContent', 'testIssuer');
+
+    expect(DyFM_Log.error).toHaveBeenCalledWith(
+      `Socket Event tasks failed to execute on UnknownSocketService.... (${DyFM_SocketEvent_Key.connect})`,
+      jasmine.any(Error),
+      'content:',
+      'testContent'
+    );
+  });
+});

package/src/_modules/socket/_models/sck-socket-event.control-model.ts

@@ -13,7 +13,7 @@ export type DyFM_SocketEventTask<T> = (content?: T, issuer?: string) => Promise<
  * socket handling and clarification is under development
  */
 export class DyFM_SocketEvent<T>{
-  socketName?: string;
+  name?: string;
   eventKey: DyFM_SocketEvent_Key | string;
   serviceName?: string;
   
@@ -61,7 +61,7 @@ export class DyFM_SocketEvent<T>{
     }
   ) {
     try {
-      this.socketName = set.name ?? set.eventKey;
+      this.name = set.name ?? set.eventKey;
       this.eventKey = set.eventKey;
       this.serviceName = set.serviceName ?? 'UnknownSocketService';
 

package/src/_modules/socket/_services/sck-client.service-base.spec.ts

@@ -0,0 +1,99 @@
+
+import { DyFM_Log } from '../../../_collections/utils/log.util';
+import { DyFM_SocketEvent_Key } from '../_enums/sck-event-key.enum';
+import { DyFM_SocketClient_Params } from '../_models/sck-client-params.control-model';
+import { DyFM_SocketEvent } from '../_models/sck-socket-event.control-model';
+import { DyFM_SocketClient_ServiceBase } from './sck-client.service-base';
+
+class TestSocketClientService extends DyFM_SocketClient_ServiceBase {
+  getParams(): DyFM_SocketClient_Params {
+    return {
+      name: 'testService',
+      address: 'http://localhost',
+      port: 3000,
+      reconnect: true,
+      reconnectDelay: 1000,
+      socketOptions: {},
+    };
+  }
+
+  getIncomingEvents(): DyFM_SocketEvent<any>[] {
+    return [];
+  }
+
+  async getSubscriptionContent(): Promise<any> {
+    return {};
+  }
+}
+
+xdescribe('DyFM_SocketClient_ServiceBase', () => {
+  let service: TestSocketClientService;
+
+  /* beforeEach(() => {
+    TestBed.configureTestingModule({});
+    service = new TestSocketClientService();
+  }); */
+
+  it('should initialize with default values', () => {
+    expect(service.connected).toBeFalse();
+    expect(service.subscribed).toBeFalse();
+    expect(service.subscriptionInProgress).toBeFalse();
+  });
+
+  it('should connect and disconnect socket', async () => {
+    spyOn(DyFM_Log, 'success');
+    spyOn(DyFM_Log, 'warn');
+
+    await service['setupDefaultEvents']();
+    await service['setupSocketEvents']();
+
+    service['socket'].emit(DyFM_SocketEvent_Key.connect);
+    expect(service.connected).toBeTrue();
+    expect(DyFM_Log.success).toHaveBeenCalledWith('<   >  socket-client(testService) connected!');
+
+    service['socket'].emit(DyFM_SocketEvent_Key.disconnect);
+    expect(service.connected).toBeFalse();
+    expect(DyFM_Log.warn).toHaveBeenCalledWith('<x  >  socket-client(testService) disconnected!');
+  });
+
+  it('should handle subscription and unsubscription', async () => {
+    spyOn(DyFM_Log, 'success');
+    spyOn(DyFM_Log, 'warn');
+
+    await service.subscribe();
+    expect(service.subscriptionInProgress).toBeFalse();
+    expect(DyFM_Log.success).toHaveBeenCalledWith('<=-->  socket-client(testService) subscription successful!');
+
+    await service.unsubscribe();
+    expect(DyFM_Log.success).toHaveBeenCalledWith('<x-->  socket-client(testService) unsubscribe successful!');
+  });
+
+  it('should handle errors during subscription', async () => {
+    spyOn(DyFM_Log, 'error');
+    spyOn(service, 'getSubscriptionContent').and.throwError('Subscription error');
+
+    try {
+      await service.subscribe();
+    } catch (error) {
+      expect(DyFM_Log.error).toHaveBeenCalledWith('socket-client(testService) Service Subscribe failed!', jasmine.any(Error));
+    }
+  });
+
+  it('should emit events correctly', async () => {
+    spyOn(DyFM_Log, 'log');
+    spyOn(service['socket'], 'emit');
+
+    await service['emitEvent'](DyFM_SocketEvent_Key.subscribe, { data: 'test' });
+    expect(DyFM_Log.log).toHaveBeenCalledWith('<=--   outgoing socket-client(testService) event: subscribe');
+    expect(service['socket'].emit).toHaveBeenCalledWith(DyFM_SocketEvent_Key.subscribe, { data: 'test' });
+  });
+
+  /* it('should reconnect if needed', async () => {
+    spyOn(service, 'connectSocket');
+    spyOn(DyFM_delay, 'delay').and.returnValue(Promise.resolve());
+
+    service['connected'] = false;
+    await service['tryReconnectIfNeeded']();
+    expect(service.connectSocket).toHaveBeenCalled();
+  }); */
+});

package/src/_modules/socket/_services/sck-client.service-base.ts

@@ -1,18 +1,18 @@
 
 import * as SocketIOClient from 'socket.io-client';
 
-import { 
-  DyFM_global_settings 
+import {
+  DyFM_global_settings
 } from '../../../_collections/constants/global-settings.const';
-import { DyFM_Error } from '../../../_models/control-models/error.control-model';
-import { DyFM_Log } from '../../../_collections/utils/log.util';
 import { DyFM_Array } from '../../../_collections/utils/array.util';
+import { DyFM_Log } from '../../../_collections/utils/log.util';
 import { DyFM_delay } from '../../../_collections/utils/utilities.util';
+import { DyFM_Error } from '../../../_models/control-models/error.control-model';
 
+import { BehaviorSubject } from 'rxjs';
 import { DyFM_SocketEvent_Key } from '../_enums/sck-event-key.enum';
 import { DyFM_SocketClient_Params } from '../_models/sck-client-params.control-model';
 import { DyFM_SocketEvent } from '../_models/sck-socket-event.control-model';
-import { BehaviorSubject } from 'rxjs';
 
 export abstract class DyFM_SocketClient_ServiceBase<T_SubscriptionContent = any> {
 
@@ -28,14 +28,14 @@ export abstract class DyFM_SocketClient_ServiceBase<T_SubscriptionContent = any>
   get connected(): boolean { return this._connected_BS.value; }
   readonly connected$ = this._connected_BS.asObservable();
 
-  private _subscribed_BS: BehaviorSubject<boolean> = new BehaviorSubject<boolean>(false);
+  private readonly _subscribed_BS: BehaviorSubject<boolean> = new BehaviorSubject<boolean>(false);
   get subscribed(): boolean { return this._subscribed_BS.value; }
   readonly subscribed$ = this._subscribed_BS.asObservable();
 
   protected debugLog: boolean = DyFM_global_settings.log_settings.setup;
   protected logFn: boolean = DyFM_global_settings.log_settings.functions;
 
-  private defaultEvents: DyFM_SocketEvent<any>[] = [
+  private readonly defaultEvents: DyFM_SocketEvent<any>[] = [
     new DyFM_SocketEvent<any>({
       eventKey: DyFM_SocketEvent_Key.connect,
       tasks: [

package/src/_modules/usage/_models/usg-action.control-model.spec.ts

@@ -0,0 +1,27 @@
+
+import { DyFM_UsageAction } from './usg-action.control-model';
+
+describe('DyFM_UsageAction', () => {
+
+  it('should create an instance with default values', () => {
+    const action = new DyFM_UsageAction();
+    expect(action.action).toBeUndefined();
+    expect(action.time).toBeUndefined();
+  });
+
+  it('should create an instance with provided values', () => {
+    const date = new Date();
+    const action = new DyFM_UsageAction({ action: 'testAction', time: date });
+    expect(action.action).toBe('testAction');
+    expect(action.time).toBe(date);
+  });
+
+  it('should assign properties from another DyFM_UsageAction instance', () => {
+    const date = new Date();
+    const sourceAction = new DyFM_UsageAction({ action: 'sourceAction', time: date });
+    const newAction = new DyFM_UsageAction(sourceAction);
+    expect(newAction.action).toBe('sourceAction');
+    expect(newAction.time).toBe(date);
+  });
+
+});

package/src/_modules/usage/_models/usg-daily-usage-data.control-model.spec.ts

@@ -0,0 +1,36 @@
+
+import { DyFM_DailyUsageData } from './usg-daily-usage-data.control-model';
+import { DyFM_UsageSession } from './usg-session.data-model';
+
+describe('DyFM_DailyUsageData', () => {
+  it('should create an instance with default values', () => {
+    const instance = new DyFM_DailyUsageData();
+    expect(instance.date).toBeUndefined();
+    expect(instance.totalVisitTime).toBe(0);
+    expect(instance.averageVisitTime).toBe(0);
+    expect(instance.visitorsHun).toBe(0);
+    expect(instance.visitorsElse).toBe(0);
+    expect(instance.visitations).toEqual([]);
+  });
+
+  it('should create an instance with provided values', () => {
+    const usageSession: DyFM_UsageSession = { /* mock session data */ };
+    const data: DyFM_DailyUsageData = {
+      date: '2023-10-01',
+      totalVisitTime: 120,
+      averageVisitTime: 30,
+      visitorsHun: 10,
+      visitorsElse: 5,
+      visitations: [usageSession]
+    };
+
+    const instance = new DyFM_DailyUsageData(data);
+
+    expect(instance.date).toBe('2023-10-01');
+    expect(instance.totalVisitTime).toBe(120);
+    expect(instance.averageVisitTime).toBe(30);
+    expect(instance.visitorsHun).toBe(10);
+    expect(instance.visitorsElse).toBe(5);
+    expect(instance.visitations).toEqual([usageSession]);
+  });
+});