@futdevpro/nts-dynamo 1.9.50 → 1.10.2

package/src/_models/control-models/app-params.control-model.spec.ts

@@ -0,0 +1,69 @@
+
+import { DyNTS_App_Params } from './app-params.control-model';
+
+describe('DyNTS_App_Params', () => {
+  it('should initialize with provided values', () => {
+    const params: DyNTS_App_Params = {
+      name: 'TestApp',
+      title: 'Test Application',
+      version: '1.0.0',
+      dbName: 'testdb',
+      dbUri: 'mongodb://localhost:27017/testdb',
+      systemName: 'Test-App',
+      systemShortCodeName: 'TA'
+    };
+
+    const appParams = new DyNTS_App_Params(params);
+
+    expect(appParams.name).toBe('TestApp');
+    expect(appParams.title).toBe('Test Application');
+    expect(appParams.version).toBe('1.0.0');
+    expect(appParams.dbName).toBe('testdb');
+    expect(appParams.dbUri).toBe('mongodb://localhost:27017/testdb');
+    expect(appParams.systemName).toBe('Test-App');
+    expect(appParams.systemShortCodeName).toBe('TA');
+  });
+
+  it('should set default values when optional parameters are not provided', () => {
+    const params: DyNTS_App_Params = {
+      name: 'TestApp',
+      version: '1.0.0',
+      dbName: 'testdb'
+    };
+
+    const appParams = new DyNTS_App_Params(params);
+
+    expect(appParams.name).toBe('TestApp');
+    expect(appParams.title).toBe('');
+    expect(appParams.version).toBe('1.0.0');
+    expect(appParams.dbName).toBe('testdb');
+    expect(appParams.dbUri).toBe('mongodb://localhost:27017/testdb');
+    expect(appParams.systemName).toBe('TestApp');
+    expect(appParams.systemShortCodeName).toBe('TA');
+  });
+
+  it('should generate systemShortCodeName from systemName if not provided', () => {
+    const params: DyNTS_App_Params = {
+      name: 'Test Application',
+      version: '1.0.0',
+      dbName: 'testdb',
+      systemName: 'Test-App'
+    };
+
+    const appParams = new DyNTS_App_Params(params);
+
+    expect(appParams.systemShortCodeName).toBe('TA');
+  });
+
+  it('should generate systemName from name if not provided', () => {
+    const params: DyNTS_App_Params = {
+      name: 'Test Application',
+      version: '1.0.0',
+      dbName: 'testdb'
+    };
+
+    const appParams = new DyNTS_App_Params(params);
+
+    expect(appParams.systemName).toBe('Test-Application');
+  });
+});

package/src/_models/control-models/app-system-controls.control-model.spec.ts

@@ -0,0 +1,31 @@
+
+import { DyNTS_AppSystemControls } from './app-system-controls.control-model';
+import { DyNTS_SystemControl } from './system-control.control-model';
+
+describe('DyNTS_AppSystemControls', () => {
+  let appSystemControls: DyNTS_AppSystemControls;
+
+  beforeEach(() => {
+    appSystemControls = new DyNTS_AppSystemControls();
+  });
+
+  it('should create an instance of DyNTS_AppSystemControls', () => {
+    expect(appSystemControls).toBeTruthy();
+  });
+
+  it('should initialize "app" as an instance of DyNTS_SystemControl', () => {
+    expect(appSystemControls.app).toBeInstanceOf(DyNTS_SystemControl);
+  });
+
+  it('should initialize "mongoose" as an instance of DyNTS_SystemControl', () => {
+    expect(appSystemControls.mongoose).toBeInstanceOf(DyNTS_SystemControl);
+  });
+
+  it('should initialize "httpServer" as an instance of DyNTS_SystemControl', () => {
+    expect(appSystemControls.httpServer).toBeInstanceOf(DyNTS_SystemControl);
+  });
+
+  it('should initialize "httpsServer" as an instance of DyNTS_SystemControl', () => {
+    expect(appSystemControls.httpsServer).toBeInstanceOf(DyNTS_SystemControl);
+  });
+});

package/src/_models/control-models/endpoint-params.control-model.ts

@@ -2,10 +2,11 @@
 
 import { Request, Response } from 'express';
 
-import { DyFM_Array, DyFM_Error, DyFM_errorFlag, DyFM_Log, DyFM_Shared } from '@futdevpro/fsm-dynamo';
-import { DyNTS_RouteSecurity } from '../../_enums/route-security.enum';
-import { DyNTS_HttpCallType } from '../../_enums/http/http-call-type.enum';
+import { DyFM_Array, DyFM_Error, DyFM_Log, DyFM_Shared } from '@futdevpro/fsm-dynamo';
+
 import { DyNTS_global_settings } from '../../_collections/global-settings.const';
+import { DyNTS_HttpCallType } from '../../_enums/http/http-call-type.enum';
+import { DyNTS_RouteSecurity } from '../../_enums/route-security.enum';
 import { DyNTS_GlobalService } from '../../_services/core/global.service';
 
 /**
@@ -114,7 +115,7 @@ export class DyNTS_Endpoint_Params {
           status: 406, 
           errorCode: 'NTS-EP0-C00',
           addECToUserMsg: true,
-          message: 'trying to create DyNTS_EndpointParams without endpoint value',
+          message: 'trying to create DyNTS_Endpoint_Params without endpoint value',
           userMessage: 
             'We encountered an unhandled Server Error, ' +
             'please contact the responsible development team.',
@@ -361,7 +362,7 @@ export class DyNTS_Endpoint_Params {
   ): void {
     if (DyNTS_global_settings.log_settings.highDetailedLogs) {
       DyFM_Log.H_error(
-        `\n\nDYNAMO MULTILEVEL ERROR:DyNTS_EndpointParams: error: ` +
+        `\n\nDYNAMO MULTILEVEL ERROR:DyNTS_Endpoint_Params: error: ` +
           `(${this.name}, ${this.endpoint})` +
         `\n(DYNAMO MULTILEVEL ERROR means, that the ERROR HANDLING is ALSO FAILED, ` +
           `and the error message was not sent.)` + 
@@ -370,7 +371,7 @@ export class DyNTS_Endpoint_Params {
       );
     } else {
       DyFM_Log.H_error(
-        `\n\nDYNAMO MULTILEVEL ERROR:DyNTS_EndpointParams: error: ` +
+        `\n\nDYNAMO MULTILEVEL ERROR:DyNTS_Endpoint_Params: error: ` +
           `(${this.name}, ${this.endpoint})` +
         `\n(DYNAMO MULTILEVEL ERROR means, that the ERROR HANDLING is ALSO FAILED, ` +
           `and the error message was not sent.)`

package/src/_models/control-models/http-settings.control-model.spec.ts

@@ -0,0 +1,66 @@
+
+import { DyNTS_Http_Settings } from './http-settings.control-model';
+import * as BodyParser from 'body-parser';
+
+describe('DyNTS_Http_Settings', () => {
+  it('should create an instance with default settings', () => {
+    const settings = new DyNTS_Http_Settings();
+
+    expect(settings.httpPort).toBeUndefined();
+    expect(settings.httpsPort).toBeUndefined();
+    expect(settings.httpUrlencoded).toEqual({
+      limit: '50mb',
+      extended: true,
+    } as BodyParser.OptionsUrlencoded);
+    expect(settings.httpJson).toEqual({
+      limit: '50mb',
+    } as BodyParser.OptionsJson);
+    expect(settings.httpsUrlencoded).toEqual({
+      limit: '50mb',
+      extended: true,
+    } as BodyParser.OptionsUrlencoded);
+    expect(settings.httpsJson).toEqual({
+      limit: '50mb',
+    } as BodyParser.OptionsJson);
+  });
+
+  it('should create an instance with provided settings', () => {
+    const customSettings: DyNTS_Http_Settings = {
+      httpPort: 8080,
+      httpsPort: 8443,
+      httpUrlencoded: {
+        limit: '100mb',
+        extended: false,
+      },
+      httpJson: {
+        limit: '100mb',
+      },
+      httpsUrlencoded: {
+        limit: '100mb',
+        extended: false,
+      },
+      httpsJson: {
+        limit: '100mb',
+      },
+    };
+
+    const settings = new DyNTS_Http_Settings(customSettings);
+
+    expect(settings.httpPort).toBe(8080);
+    expect(settings.httpsPort).toBe(8443);
+    expect(settings.httpUrlencoded).toEqual({
+      limit: '100mb',
+      extended: false,
+    } as BodyParser.OptionsUrlencoded);
+    expect(settings.httpJson).toEqual({
+      limit: '100mb',
+    } as BodyParser.OptionsJson);
+    expect(settings.httpsUrlencoded).toEqual({
+      limit: '100mb',
+      extended: false,
+    } as BodyParser.OptionsUrlencoded);
+    expect(settings.httpsJson).toEqual({
+      limit: '100mb',
+    } as BodyParser.OptionsJson);
+  });
+});

package/src/_models/control-models/system-control.control-model.spec.ts

@@ -0,0 +1,27 @@
+
+import { DyNTS_SystemControl } from './system-control.control-model';
+
+describe('DyNTS_SystemControl', () => {
+  let systemControl: DyNTS_SystemControl;
+
+  beforeEach(() => {
+    systemControl = new DyNTS_SystemControl();
+  });
+
+  it('should return true when init is false', () => {
+    systemControl.init = false;
+    expect(systemControl.getIsReady()).toBeTrue();
+  });
+
+  it('should return true when init is true and started is true', () => {
+    systemControl.init = true;
+    systemControl.started = true;
+    expect(systemControl.getIsReady()).toBeTrue();
+  });
+
+  it('should return false when init is true and started is false', () => {
+    systemControl.init = true;
+    systemControl.started = false;
+    expect(systemControl.getIsReady()).toBeFalse();
+  });
+});

package/src/_modules/custom-data/custom-data.controller.ts

@@ -4,11 +4,11 @@ import { Request, Response } from 'express';
 import { DyFM_customDataModule_settings } from '@futdevpro/fsm-dynamo/custom-data';
 
 import { DyNTS_HttpCallType } from '../../_enums/http/http-call-type.enum';
-import { DyNTS_Controller } from '../../_services/route/controller.service';
-import { DyFM_CustomData_DataService } from './custom-data.data-service';
-import { 
-  DyNTS_Endpoint_Params 
+import {
+  DyNTS_Endpoint_Params
 } from '../../_models/control-models/endpoint-params.control-model';
+import { DyNTS_Controller } from '../../_services/route/controller.service';
+import { DyNTS_CustomData_DataService } from './custom-data.data-service';
 
 export class DyNTS_CustomData_Controller extends DyNTS_Controller {
 
@@ -25,7 +25,7 @@ export class DyNTS_CustomData_Controller extends DyNTS_Controller {
         endpoint: DyFM_customDataModule_settings.endPoints.getCustomData,
         tasks: [
           async (req: Request, res: Response): Promise<void> => {
-            const customDataService = new DyFM_CustomData_DataService({ 
+            const customDataService = new DyNTS_CustomData_DataService({ 
               _id: req.params.customId,
             });
 
@@ -47,7 +47,7 @@ export class DyNTS_CustomData_Controller extends DyNTS_Controller {
         endpoint: DyFM_customDataModule_settings.endPoints.modifyCustomData,
         tasks: [
           async (req: Request, res: Response, issuer: string): Promise<void> => {
-            const customDataService = new DyFM_CustomData_DataService(req.body, issuer);
+            const customDataService = new DyNTS_CustomData_DataService(req.body, issuer);
 
             await customDataService.saveData();
 

package/src/_modules/custom-data/custom-data.data-service.ts

@@ -1,12 +1,13 @@
 
 
 
-import { 
-  DyFM_customData_dataParams, DyFM_CustomData 
+import {
+  DyFM_CustomData,
+  DyFM_customData_dataParams
 } from '@futdevpro/fsm-dynamo/custom-data';
 import { DyNTS_DataService } from '../../_services/base/data.service';
 
-export class DyFM_CustomData_DataService extends DyNTS_DataService<DyFM_CustomData> {
+export class DyNTS_CustomData_DataService extends DyNTS_DataService<DyFM_CustomData> {
 
   constructor(
     customData?: DyFM_CustomData,

package/src/_modules/mock/app-params.mock.spec.ts

@@ -0,0 +1,21 @@
+
+import { DyNTS_App_Params } from '../../_models/control-models/app-params.control-model';
+import { DyNTS_appParams_mock } from './app-params.mock';
+
+describe('DyNTS_appParams_mock', () => {
+  it('should create an instance of DyNTS_App_Params', () => {
+    expect(DyNTS_appParams_mock).toBeInstanceOf(DyNTS_App_Params);
+  });
+
+  it('should have the correct name', () => {
+    expect(DyNTS_appParams_mock.name).toBe('test');
+  });
+
+  it('should have the correct version', () => {
+    expect(DyNTS_appParams_mock.version).toBe('0.0.1');
+  });
+
+  it('should have the correct dbName', () => {
+    expect(DyNTS_appParams_mock.dbName).toBe('test');
+  });
+});

package/src/_modules/mock/auth-service.mock.spec.ts

@@ -0,0 +1,47 @@
+
+import { Request, Response } from 'express';
+import { AuthService_Mock } from './auth-service.mock';
+
+describe('AuthService_Mock', () => {
+  let authServiceMock: AuthService_Mock;
+
+  beforeEach(() => {
+    authServiceMock = AuthService_Mock.getInstance();
+  });
+
+  it('should return a singleton instance', () => {
+    const instance1 = AuthService_Mock.getInstance();
+    const instance2 = AuthService_Mock.getInstance();
+    expect(instance1).toBe(instance2);
+  });
+
+  it('should return "accountId_mock" from getIssuerFromRequest', () => {
+    const req = {} as Request;
+    const issuer = authServiceMock.getIssuerFromRequest(req);
+    expect(issuer).toBe('accountId_mock');
+  });
+
+  it('should return "username_mock" from getUsernameFromRequest', () => {
+    const req = {} as Request;
+    const username = authServiceMock.getUsernameFromRequest(req);
+    expect(username).toBe('username_mock');
+  });
+
+  it('should have an authenticate_token method', async () => {
+    const req = {} as Request;
+    const res = {} as Response;
+    await expectAsync(authServiceMock.authenticate_token(req, res)).toBeResolved();
+  });
+
+  it('should have an authenticate_tokenSelf method', async () => {
+    const req = {} as Request;
+    const res = {} as Response;
+    await expectAsync(authServiceMock.authenticate_tokenSelf(req, res)).toBeResolved();
+  });
+
+  it('should have an authenticate_tokenPerm_accUsageData method', async () => {
+    const req = {} as Request;
+    const res = {} as Response;
+    await expectAsync(authServiceMock.authenticate_tokenPerm_accUsageData(req, res)).toBeResolved();
+  });
+});

package/src/_modules/mock/controller.mock.spec.ts

@@ -0,0 +1,26 @@
+
+import { DyNTS_Controller_Mock } from './controller.mock';
+import { DyNTS_endpoints_mock } from './endpoint.mock';
+
+describe('DyNTS_Controller_Mock', () => {
+  let controllerMock: DyNTS_Controller_Mock;
+
+  beforeEach(() => {
+    controllerMock = DyNTS_Controller_Mock.getInstance();
+  });
+
+  it('should create an instance of DyNTS_Controller_Mock', () => {
+    expect(controllerMock).toBeTruthy();
+    expect(controllerMock instanceof DyNTS_Controller_Mock).toBeTrue();
+  });
+
+  it('should setup endpoints correctly', () => {
+    controllerMock.setupEndpoints();
+    expect(controllerMock.endpoints).toEqual(DyNTS_endpoints_mock);
+  });
+
+  it('should return the same instance on multiple getInstance calls', () => {
+    const anotherInstance = DyNTS_Controller_Mock.getInstance();
+    expect(controllerMock).toBe(anotherInstance);
+  });
+});

package/src/_modules/mock/data-model.mock.spec.ts

@@ -0,0 +1,109 @@
+
+import {
+  Dependency_Mock, dependency_mock_DataParams, Dependent_Mock, dependent_mock_DataParams
+} from './data-model.mock';
+
+describe('Dependency_Mock', () => {
+  it('should create an instance with default values', () => {
+    const instance = new Dependency_Mock();
+
+    expect(instance).toBeTruthy();
+    expect(instance.string).toBeUndefined();
+    expect(instance.number).toBeUndefined();
+    expect(instance.date).toBeUndefined();
+    expect(instance.boolean).toBeUndefined();
+    expect(instance.array).toBeUndefined();
+    expect(instance.object).toBeUndefined();
+    expect(instance.objectArray).toBeUndefined();
+    expect(instance.objectArrayArray).toBeUndefined();
+  });
+
+  it('should create an instance with provided values', () => {
+    const mockData: Dependency_Mock = {
+      string: 'test',
+      number: 42,
+      date: new Date(),
+      boolean: true,
+      array: [ 'a', 'b' ],
+      object: { key: 'value' },
+      objectArray: [{ key: 'value' }],
+      objectArrayArray: [[{ key: 'value' }]],
+    };
+    const instance = new Dependency_Mock(mockData);
+
+    expect(instance).toEqual(jasmine.objectContaining(mockData));
+  });
+});
+
+xdescribe('DyFM_DataModel_Params for Dependency_Mock', () => {
+  it('should have correct dataName and properties', () => {
+    expect(dependency_mock_DataParams.dataName).toBe('dependencyMock');
+    expect(dependency_mock_DataParams.properties).toEqual({
+      string: { type: 'string' },
+      number: { type: 'number' },
+      date: { type: 'Date' },
+      boolean: { type: 'boolean' },
+      array: { type: 'string[]' },
+      object: { type: 'any' },
+      objectArray: { type: 'any[]' },
+      objectArrayArray: { type: 'any[][]' },
+    });
+  });
+});
+
+describe('Dependent_Mock', () => {
+  it('should create an instance with default values', () => {
+    const instance = new Dependent_Mock();
+
+    expect(instance).toBeTruthy();
+    expect(instance.dependencyId).toBeUndefined();
+    expect(instance.string).toBeUndefined();
+    expect(instance.number).toBeUndefined();
+    expect(instance.date).toBeUndefined();
+    expect(instance.boolean).toBeUndefined();
+    expect(instance.array).toBeUndefined();
+    expect(instance.object).toBeUndefined();
+    expect(instance.objectArray).toBeUndefined();
+    expect(instance.objectArrayArray).toBeUndefined();
+  });
+
+  it('should create an instance with provided values', () => {
+    const mockData: Dependent_Mock = {
+      dependencyId: 'dep123',
+      string: 'test',
+      number: 42,
+      date: new Date(),
+      boolean: true,
+      array: [ 'a', 'b' ],
+      object: { key: 'value' },
+      objectArray: [{ key: 'value' }],
+      objectArrayArray: [[{ key: 'value' }]],
+    };
+    const instance = new Dependent_Mock(mockData);
+
+    expect(instance).toEqual(jasmine.objectContaining(mockData));
+  });
+});
+
+xdescribe('DyFM_DataModel_Params for Dependent_Mock', () => {
+  it('should have correct dataName and properties', () => {
+    expect(dependent_mock_DataParams.dataName).toBe('dependentMock');
+    expect(dependent_mock_DataParams.properties).toEqual({
+      dependencyId: {
+        type: 'string',
+        unique: true,
+        required: true,
+        isDependencyHook: true,
+        dependencyDataName: dependency_mock_DataParams.dataName,
+      },
+      string: { type: 'string' },
+      number: { type: 'number' },
+      date: { type: 'Date' },
+      boolean: { type: 'boolean' },
+      array: { type: 'string[]' },
+      object: { type: 'any' },
+      objectArray: { type: 'any[]' },
+      objectArrayArray: { type: 'any[][]' },
+    });
+  });
+});

package/src/_modules/mock/email-service-collection.mock.spec.ts

@@ -0,0 +1,24 @@
+
+import { EmailServiceCollection_Mock } from './email-service-collection.mock';
+import { EmailService_Mock } from './email-service.mock';
+
+describe('EmailServiceCollection_Mock', () => {
+  let emailServiceCollectionMock: EmailServiceCollection_Mock;
+
+  beforeEach(() => {
+    emailServiceCollectionMock = EmailServiceCollection_Mock.getInstance();
+  });
+
+  it('should create an instance of EmailServiceCollection_Mock', () => {
+    expect(emailServiceCollectionMock).toBeTruthy();
+  });
+
+  it('should return a singleton instance', () => {
+    const anotherInstance = EmailServiceCollection_Mock.getInstance();
+    expect(emailServiceCollectionMock).toBe(anotherInstance);
+  });
+
+  it('should have a test property of type EmailService_Mock', () => {
+    expect(emailServiceCollectionMock.test).toBeInstanceOf(EmailService_Mock);
+  });
+});

package/src/_modules/mock/email-service.mock.spec.ts

@@ -0,0 +1,17 @@
+
+import {
+  DyNTS_EmailService
+} from '../../_services/core/email.service';
+import { EmailService_Mock } from './email-service.mock';
+
+describe('EmailService_Mock', () => {
+  let emailServiceMock: EmailService_Mock;
+
+  beforeEach(() => {
+    emailServiceMock = new EmailService_Mock();
+  });
+
+  it('should be an instance of DyNTS_EmailService', () => {
+    expect(emailServiceMock instanceof DyNTS_EmailService).toBeTrue();
+  });
+});

package/src/_modules/mock/socket-client.mock.spec.ts

@@ -0,0 +1,40 @@
+
+import { DyFM_SocketEvent, DyFM_SocketEvent_Key } from '@futdevpro/fsm-dynamo/socket';
+
+import {
+  DyNTS_SocketClientService_Params
+} from '../socket/_models/socket-client-service-params.control-model';
+import { SocketClient_Mock } from './socket-client.mock';
+
+describe('SocketClient_Mock', () => {
+  let socketClientMock: SocketClient_Mock;
+
+  beforeEach(() => {
+    socketClientMock = SocketClient_Mock.getInstance();
+  });
+
+  it('should create an instance of SocketClient_Mock', () => {
+    expect(socketClientMock).toBeTruthy();
+  });
+
+  it('should return the correct incoming events', () => {
+    const events = socketClientMock.getIncomingEvents();
+
+    expect(events.length).toBe(1);
+    expect(events[0]).toEqual(jasmine.any(DyFM_SocketEvent));
+    expect(events[0].name).toBe('connect');
+    expect(events[0].eventKey).toBe(DyFM_SocketEvent_Key.connect);
+    expect(events[0].tasks.length).toBe(1);
+    expect(events[0].tasks[0]).toEqual(jasmine.any(Function));
+  });
+
+  it('should return the correct parameters', () => {
+    const params = socketClientMock.getParams();
+
+    expect(params).toEqual(jasmine.any(DyNTS_SocketClientService_Params));
+    expect(params.service).toBe('-test-socket-target-');
+    expect(params.name).toBe('socket-client-mock');
+    expect(params.port).toBe(30303);
+    expect(params.socketOptions.reconnection).toBeTrue();
+  });
+});

package/src/_modules/mock/socket-client.mock.ts

@@ -1,8 +1,8 @@
 
 import { DyFM_SocketEvent, DyFM_SocketEvent_Key } from '@futdevpro/fsm-dynamo/socket';
 
-import { 
-  DyNTS_SocketClientService_Params 
+import {
+  DyNTS_SocketClientService_Params
 } from '../socket/_models/socket-client-service-params.control-model';
 import { DyNTS_SocketClient_ServiceBase } from '../socket/_services/socket-client.service';
 
@@ -24,8 +24,8 @@ export class SocketClient_Mock extends DyNTS_SocketClient_ServiceBase {
         tasks: [
           async (content: any, issuer: string) => {
             console.log('SocketClient_Mock: connect event received');
-          }
-        ]
+          },
+        ],
       }),
     ];
   }

package/src/_modules/mock/socket-server.mock.spec.ts

@@ -0,0 +1,44 @@
+
+import {
+  DyNTS_SocketServerService_Params
+} from '../socket/_models/socket-server-service-params.control-model';
+import { DyNTS_SocketServer_Mock } from './socket-server.mock';
+
+describe('DyNTS_SocketServer_Mock', () => {
+  let socketServerMock: DyNTS_SocketServer_Mock;
+
+  beforeEach(() => {
+    socketServerMock = DyNTS_SocketServer_Mock.getInstance();
+  });
+
+  it('should return an instance of DyNTS_SocketServer_Mock', () => {
+    expect(socketServerMock).toBeInstanceOf(DyNTS_SocketServer_Mock);
+  });
+
+  it('should return correct service parameters', () => {
+    const params = socketServerMock.getServiceParams();
+
+    expect(params).toBeInstanceOf(DyNTS_SocketServerService_Params);
+    expect(params.name).toBe('test');
+    expect(params.port).toBe(9393);
+  });
+
+  it('should return an empty array for incoming events', () => {
+    const events = socketServerMock.getIncomingEvents();
+
+    expect(events).toEqual([]);
+  });
+
+  /* it('should return correct presence from subscription event content', async () => {
+    const mockSocketSubscription = { issuerId: 'testIssuerId' };
+    const mockSocket = {} as Socket;
+
+    const presence = await socketServerMock.getPresenceFromSubscriptionEventContent(
+      mockSocketSubscription, mockSocket);
+
+    expect(presence).toBeInstanceOf(DyNTS_SocketPresence);
+    expect(presence.issuerLocalId).toBe('testIssuerId');
+    expect(presence.sockets).toEqual([ mockSocket ]);
+    expect(presence.issuer).toBe('ISSUER socketServer_Mock');
+  }); */
+});

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

@@ -0,0 +1,30 @@
+
+import { DyFM_Log } from '@futdevpro/fsm-dynamo';
+import { DyNTS_SocketClientService_Params } from './socket-client-service-params.control-model';
+
+describe('DyNTS_SocketClientService_Params', () => {
+  it('should create an instance with default address', () => {
+    const params = new DyNTS_SocketClientService_Params({});
+
+    expect(params).toBeTruthy();
+    expect(params.address).toBe('ws://localhost');
+  });
+
+  it('should log information on creation', () => {
+    spyOn(DyFM_Log, 'H_info');
+
+    const params = new DyNTS_SocketClientService_Params({});
+
+    expect(DyFM_Log.H_info).toHaveBeenCalledWith(
+      'DyNTS_SocketClientService_Params (test this with custom address!)',
+      'ws://localhost'
+    );
+  });
+
+  xit('should allow overriding the address', () => {
+    const customAddress = 'ws://custom-address';
+    const params = new DyNTS_SocketClientService_Params({ address: customAddress });
+
+    expect(params.address).toBe(customAddress);
+  });
+});