@futdevpro/nts-dynamo 1.15.92 → 1.15.96

package/src/_modules/test-email-sink/_services/dynts-test-email-sink.service.spec.ts

@@ -0,0 +1,112 @@
+import { DyFM_EnvironmentFlag } from '@futdevpro/fsm-dynamo';
+
+import { DyNTS_global_settings } from '../../../_collections/global-settings.const';
+import { DyNTS_testEmailPattern } from '../_collections/test-email-pattern.const';
+import { DyNTS_TestEmailSink_Service } from './dynts-test-email-sink.service';
+
+describe('| DyNTS_TestEmailSink_Service (BFR-MASTERPROMPTER-015)', () => {
+  let originalEnvironment: DyFM_EnvironmentFlag;
+  let originalSinkSettings: typeof DyNTS_global_settings.testEmailSink;
+
+  beforeEach(() => {
+    originalEnvironment = DyNTS_global_settings.env_settings.environment;
+    originalSinkSettings = DyNTS_global_settings.testEmailSink;
+  });
+
+  afterEach(() => {
+    DyNTS_global_settings.env_settings.environment = originalEnvironment;
+    DyNTS_global_settings.testEmailSink = originalSinkSettings;
+  });
+
+  describe('| DyNTS_testEmailPattern', () => {
+    it('| matchel a kanonikus teszt-cimre (case-insensitive)', () => {
+      expect(DyNTS_testEmailPattern.test('e2e-abc123@e2e.test.futdevpro.local')).toBeTrue();
+      expect(DyNTS_testEmailPattern.test('X@E2E.TEST.FUTDEVPRO.LOCAL')).toBeTrue();
+    });
+
+    it('| NEM matchel valos cimekre (incl. hasonlo domain-vegzodesek)', () => {
+      expect(DyNTS_testEmailPattern.test('user@gmail.com')).toBeFalse();
+      expect(DyNTS_testEmailPattern.test('user@futdevpro.hu')).toBeFalse();
+      expect(DyNTS_testEmailPattern.test('user@e2e.test.futdevpro.localhost')).toBeFalse();
+      expect(DyNTS_testEmailPattern.test('user@notE2e.test.futdevpro.local.evil.com')).toBeFalse();
+    });
+  });
+
+  describe('| shouldSink — env-gate (fail-closed)', () => {
+    it('| test kornyezetben teszt-cimre → TRUE', () => {
+      DyNTS_global_settings.env_settings.environment = DyFM_EnvironmentFlag.test;
+      expect(DyNTS_TestEmailSink_Service.shouldSink('x@e2e.test.futdevpro.local')).toBeTrue();
+    });
+
+    it('| local kornyezetben teszt-cimre → TRUE', () => {
+      DyNTS_global_settings.env_settings.environment = DyFM_EnvironmentFlag.local;
+      expect(DyNTS_TestEmailSink_Service.shouldSink('x@e2e.test.futdevpro.local')).toBeTrue();
+    });
+
+    it('| PROD kornyezetben MEG enabled:true settinggel SEM aktiv (hard fail-closed)', () => {
+      DyNTS_global_settings.env_settings.environment = DyFM_EnvironmentFlag.prod;
+      DyNTS_global_settings.testEmailSink = { enabled: true };
+      expect(DyNTS_TestEmailSink_Service.shouldSink('x@e2e.test.futdevpro.local')).toBeFalse();
+    });
+
+    it('| test kornyezetben enabled:false settinggel kikapcsolhato', () => {
+      DyNTS_global_settings.env_settings.environment = DyFM_EnvironmentFlag.test;
+      DyNTS_global_settings.testEmailSink = { enabled: false };
+      expect(DyNTS_TestEmailSink_Service.shouldSink('x@e2e.test.futdevpro.local')).toBeFalse();
+    });
+  });
+
+  describe('| shouldSink — cimzett-minta', () => {
+    beforeEach(() => {
+      DyNTS_global_settings.env_settings.environment = DyFM_EnvironmentFlag.test;
+    });
+
+    it('| valos cimre → FALSE (test kornyezetben is)', () => {
+      expect(DyNTS_TestEmailSink_Service.shouldSink('user@gmail.com')).toBeFalse();
+    });
+
+    it('| ures/undefined cimre → FALSE', () => {
+      expect(DyNTS_TestEmailSink_Service.shouldSink(undefined)).toBeFalse();
+      expect(DyNTS_TestEmailSink_Service.shouldSink('')).toBeFalse();
+    });
+
+    it('| vesszos tobb-cimzettes string: MIND teszt-cim → TRUE', () => {
+      expect(DyNTS_TestEmailSink_Service.shouldSink(
+        'a@e2e.test.futdevpro.local, b@e2e.test.futdevpro.local',
+      )).toBeTrue();
+    });
+
+    it('| KEVERT cimzett-lista (teszt + valos) → FALSE (a valos cimzett nem veszithet emailt)', () => {
+      expect(DyNTS_TestEmailSink_Service.shouldSink(
+        'a@e2e.test.futdevpro.local, real@gmail.com',
+      )).toBeFalse();
+    });
+
+    it('| tomb-cimzettek: mind teszt → TRUE; kevert → FALSE', () => {
+      expect(DyNTS_TestEmailSink_Service.shouldSink([ 'a@e2e.test.futdevpro.local' ])).toBeTrue();
+      expect(DyNTS_TestEmailSink_Service.shouldSink([ 'a@e2e.test.futdevpro.local', 'real@x.com' ])).toBeFalse();
+    });
+
+    it('| custom pattern-override settinggel', () => {
+      DyNTS_global_settings.testEmailSink = { pattern: /@sink\.example$/ };
+      expect(DyNTS_TestEmailSink_Service.shouldSink('x@sink.example')).toBeTrue();
+      expect(DyNTS_TestEmailSink_Service.shouldSink('x@e2e.test.futdevpro.local')).toBeFalse();
+    });
+  });
+
+  describe('| extractLinks', () => {
+    it('| minden href-et kinyer sorrendben', () => {
+      const html: string =
+        '<a href="https://x.hu/email-verification/tok3n">Verify</a> <a href="https://x.hu/reset">Reset</a>';
+      expect(DyNTS_TestEmailSink_Service.extractLinks(html)).toEqual([
+        'https://x.hu/email-verification/tok3n',
+        'https://x.hu/reset',
+      ]);
+    });
+
+    it('| ures/undefined html → ures tomb', () => {
+      expect(DyNTS_TestEmailSink_Service.extractLinks(undefined)).toEqual([]);
+      expect(DyNTS_TestEmailSink_Service.extractLinks('<p>no links</p>')).toEqual([]);
+    });
+  });
+});

package/src/_modules/test-email-sink/_services/dynts-test-email-sink.service.ts

@@ -0,0 +1,141 @@
+import { DyFM_EnvironmentFlag, DyFM_Log } from '@futdevpro/fsm-dynamo';
+
+import { DyNTS_global_settings } from '../../../_collections/global-settings.const';
+import { DyNTS_DataService } from '../../../_services/base/data.service';
+import { DyNTS_testEmailPattern } from '../_collections/test-email-pattern.const';
+import { DyNTS_SentTestMail, DyNTS_sentTestMail_dataParams } from '../_models/data-models/dynts-sent-test-mail.data-model';
+
+/**
+ * BFR-MASTERPROMPTER-015 (MP-19) — test-email SINK statikus util-service.
+ *
+ * A `DyNTS_EmailService.sendEmail` a kuldes ELOTT megkerdezi (`shouldSink`): ha a kornyezet
+ * local/test ES a cimzett(ek) a teszt-cim-mintara matchelnek, a kuldes NEM SMTP-re megy, hanem a
+ * `dynts_sent_test_mails` kollekcioba (`storeSentMail`). Minden mas eset VALTOZATLAN (zero
+ * regresszio a valos emailekre; prod-on a sink SOHA nem aktiv — fail-closed env-gate).
+ *
+ * Konfiguracio (opcionalis): `DyNTS_global_settings.testEmailSink = { enabled?, pattern?, ttlHours? }`
+ * — default: enabled local/test-en, pattern = `DyNTS_testEmailPattern`, TTL 24h.
+ */
+export class DyNTS_TestEmailSink_Service {
+
+  /** A TTL-index ensure csak egyszer fusson processzenkent (idempotens a Mongo-oldalon is). */
+  private static ttlIndexEnsured: boolean = false;
+
+  /** A sink aktiv-e: explicit setting-override VAGY default env-gate (CSAK local/test — prod fail-closed). */
+  static isSinkActive(): boolean {
+    const settings = DyNTS_global_settings.testEmailSink;
+    const envIsTestLike: boolean = [ DyFM_EnvironmentFlag.local, DyFM_EnvironmentFlag.test ]
+      .includes(DyNTS_global_settings.env_settings.environment);
+
+    // A prod/dev kornyezet HARD-gate: settings.enabled=true SEM kapcsolhatja be (fail-closed).
+    if (!envIsTestLike) { return false; }
+
+    return settings?.enabled !== false; // default: local/test-en aktiv
+  }
+
+  /** Az ervenyes teszt-cim-minta (setting-override vagy a kanonikus default). */
+  static getPattern(): RegExp {
+    return DyNTS_global_settings.testEmailSink?.pattern ?? DyNTS_testEmailPattern;
+  }
+
+  /**
+   * SINK-elendo-e a kuldes: aktiv a sink ES MINDEN cimzett a teszt-mintara matchel.
+   * Kevert cimzett-lista (teszt + valos) → NEM sink-elunk (a kuldes a mai uton megy) — igy egy valos
+   * cimzett SOHA nem veszithet emailt a sink miatt.
+   */
+  static shouldSink(to: string | string[] | undefined): boolean {
+    if (!to || !this.isSinkActive()) { return false; }
+
+    const recipients: string[] = Array.isArray(to) ? to : String(to).split(',').map((r: string): string => r.trim());
+    if (!recipients.length) { return false; }
+
+    const pattern: RegExp = this.getPattern();
+    return recipients.every((recipient: string): boolean => pattern.test(recipient));
+  }
+
+  /** A sink-elt email eltarolasa + (elso hivaskor) a TTL-index best-effort felhuzasa. */
+  static async storeSentMail(set: {
+    to: string | string[];
+    subject?: string;
+    html?: string;
+    issuer: string;
+  }): Promise<void> {
+    const mail_DS = new DyNTS_DataService<DyNTS_SentTestMail>(
+      new DyNTS_SentTestMail(),
+      DyNTS_sentTestMail_dataParams,
+      set.issuer,
+    );
+
+    await mail_DS.dataDBService.createData(new DyNTS_SentTestMail({
+      to: Array.isArray(set.to) ? set.to.join(',') : set.to,
+      subject: set.subject,
+      html: set.html,
+      issuer: set.issuer,
+    }), set.issuer);
+
+    DyFM_Log.info(`[TEST-EMAIL-SINK] sunk mail to ${set.to} (subject: "${set.subject}") — DB-be, SMTP kihagyva`);
+
+    this.ensureTtlIndex(mail_DS);
+  }
+
+  /**
+   * Sink-elt emailek lekerdezese (a read-endpoint + a tesztek hasznaljak).
+   * BFR-008 query-options: sort desc + limit DB-szinten (nincs full-scan).
+   */
+  static async findSentMails(filter: {
+    to?: string;
+    sinceIso?: string;
+    limit?: number;
+  }, issuer: string): Promise<DyNTS_SentTestMail[]> {
+    const mail_DS = new DyNTS_DataService<DyNTS_SentTestMail>(
+      new DyNTS_SentTestMail(),
+      DyNTS_sentTestMail_dataParams,
+      issuer,
+    );
+
+    const dbFilter: Record<string, unknown> = {};
+    if (filter.to) { dbFilter.to = filter.to; }
+    if (filter.sinceIso) { dbFilter.__created = { $gte: new Date(filter.sinceIso) }; }
+
+    return mail_DS.findDataList(
+      dbFilter as never,
+      true,
+      { sort: { __created: -1 }, limit: Math.min(filter.limit ?? 20, 100) },
+    );
+  }
+
+  /**
+   * Link-kinyero a sink-elt HTML-bol (pl. verifikacios link / reset-token URL) — a fogyaszto tesztek
+   * kenyelmi utilja. Minden href-et visszaad, sorrendben.
+   */
+  static extractLinks(html: string | undefined): string[] {
+    if (!html) { return []; }
+    const links: string[] = [];
+    const hrefRegex: RegExp = /href="([^"]+)"/gi;
+    let match: RegExpExecArray | null = hrefRegex.exec(html);
+    while (match) {
+      links.push(match[1]);
+      match = hrefRegex.exec(html);
+    }
+    return links;
+  }
+
+  /** Best-effort TTL-index a __created-en (default 24h; settings.ttlHours override). Sosem dob. */
+  private static ensureTtlIndex(mail_DS: DyNTS_DataService<DyNTS_SentTestMail>): void {
+    if (this.ttlIndexEnsured) { return; }
+    this.ttlIndexEnsured = true;
+
+    const ttlHours: number = DyNTS_global_settings.testEmailSink?.ttlHours ?? 24;
+    try {
+      const model = mail_DS.dataDBService.dataModel as {
+        collection?: { createIndex?: (spec: object, opts: object) => Promise<unknown> };
+      };
+      void model.collection?.createIndex?.({ __created: 1 }, { expireAfterSeconds: ttlHours * 3600 })
+        ?.catch((error: Error): void => {
+          DyFM_Log.warn(`[TEST-EMAIL-SINK] TTL-index ensure failed (non-fatal): ${error.message}`);
+        });
+    } catch (error) {
+      DyFM_Log.warn(`[TEST-EMAIL-SINK] TTL-index ensure failed (non-fatal): ${(error as Error).message}`);
+    }
+  }
+}

package/src/_modules/test-email-sink/get-sent-mail-routing-module.util.ts

@@ -0,0 +1,29 @@
+import { DyNTS_RoutingModule_Settings } from '../../_models/interfaces/routing-module-settings.interface';
+import { DyNTS_RoutingModule } from '../../_services/route/routing-module.service';
+import { DyNTS_TestEmailSink_Controller, DyNTS_TestEmailSinkController_Config } from './test-email-sink.controller';
+
+/**
+ * BFR-MASTERPROMPTER-015 (MP-19) — a sent-mail read-endpoint routing-modulja
+ * (a `DyNTS_getLogsRoutingModule` mintajara).
+ *
+ * Hasznalat a fogyaszto routing-jaban (X-E2E-KEY vedelemmel — EROSEN ajanlott):
+ *   DyNTS_getSentMailRoutingModule({ authPreProcess: authService.validateE2EKey })
+ *
+ * Ez a `GET /e2e/sent-mail/get?to=…&since=…&limit=…` endpointot adja. A sink magatol aktiv
+ * local/test kornyezetben (lasd `DyNTS_TestEmailSink_Service.isSinkActive`); a read-endpoint
+ * beepitett HARD env-gate-tel prod-on mindig 403.
+ */
+export function DyNTS_getSentMailRoutingModule(
+  config?: DyNTS_TestEmailSinkController_Config
+): DyNTS_RoutingModule {
+  if (config) {
+    DyNTS_TestEmailSink_Controller.configure(config);
+  }
+
+  const set: DyNTS_RoutingModule_Settings = {
+    route: '/e2e/sent-mail',
+    controllers: [ DyNTS_TestEmailSink_Controller.getInstance() ],
+  };
+
+  return new DyNTS_RoutingModule(set);
+}

package/src/_modules/test-email-sink/index.ts

@@ -0,0 +1,11 @@
+/**
+ * BFR-MASTERPROMPTER-015 (MP-19) — test-email SINK modul.
+ *
+ * A local/test kornyezetben a kanonikus teszt-cim-mintara (`*@e2e.test.futdevpro.local`) meno emailek
+ * SMTP helyett DB-be kerulnek, es a `/e2e/sent-mail` read-endpointon olvashatok (verif-link kinyerheto).
+ */
+export * from './_collections/test-email-pattern.const';
+export * from './_models/data-models/dynts-sent-test-mail.data-model';
+export * from './_services/dynts-test-email-sink.service';
+export * from './test-email-sink.controller';
+export * from './get-sent-mail-routing-module.util';

package/src/_modules/test-email-sink/test-email-sink.controller.ts

@@ -0,0 +1,83 @@
+import { Request, Response } from 'express';
+
+import { DyFM_EnvironmentFlag, DyFM_HttpCallType } from '@futdevpro/fsm-dynamo';
+
+import { DyNTS_Controller } from '../../_services/route/controller.service';
+import { DyNTS_Endpoint_Params } from '../../_models/control-models/endpoint-params.control-model';
+import { DyNTS_global_settings } from '../../_collections/global-settings.const';
+import { DyNTS_TestEmailSink_Service } from './_services/dynts-test-email-sink.service';
+import { DyNTS_SentTestMail } from './_models/data-models/dynts-sent-test-mail.data-model';
+
+/**
+ * A sent-mail read-endpoint konfigja — az authPreProcess a fogyaszto sajat vedelme (pl. az
+ * auth-service `validateE2EKey`-e, X-E2E-KEY headerrel). ERŐSEN ajanlott megadni.
+ */
+export interface DyNTS_TestEmailSinkController_Config {
+  /** Opcionalis auth preprocess (pl. validateE2EKey). Ha nincs → csak az env-gate ved. */
+  authPreProcess?: (req: Request, res: Response) => Promise<void>;
+}
+
+/**
+ * BFR-MASTERPROMPTER-015 (MP-19) — sent-mail READ controller.
+ *
+ * GET /get?to=<cim>&since=<ISO>&limit=<n> → a sink-elt teszt-emailek (legfrissebb elol), a HTML-bol
+ * kinyert `links` tombbel (pl. verifikacios link). KETTOS vedelem: (1) a fogyaszto authPreProcess-e
+ * (X-E2E-KEY), (2) beepitett HARD env-gate — prod/dev kornyezetben MINDIG 403, konfigtol fuggetlenul.
+ */
+export class DyNTS_TestEmailSink_Controller extends DyNTS_Controller {
+
+  private static config: DyNTS_TestEmailSinkController_Config = {};
+
+  static configure(config: DyNTS_TestEmailSinkController_Config): void {
+    DyNTS_TestEmailSink_Controller.config = config;
+  }
+
+  static getInstance(): DyNTS_TestEmailSink_Controller {
+    return DyNTS_TestEmailSink_Controller.getSingletonInstance();
+  }
+
+  setupEndpoints(): void {
+    const preProcesses: ((req: Request, res: Response) => Promise<void>)[] = [];
+    if (DyNTS_TestEmailSink_Controller.config.authPreProcess) {
+      preProcesses.push(DyNTS_TestEmailSink_Controller.config.authPreProcess);
+    }
+
+    this.endpoints = [
+      new DyNTS_Endpoint_Params({
+        name: 'getSentTestMails',
+        type: DyFM_HttpCallType.get,
+        endpoint: '/get',
+        preProcesses: preProcesses,
+        logRequest: false,
+        tasks: [
+          async (req: Request, res: Response, issuer: string): Promise<void> => {
+            // HARD env-gate: a teszt-emailek TARTALMA (verif-linkek!) prod-on sosem olvashato.
+            if (![ DyFM_EnvironmentFlag.local, DyFM_EnvironmentFlag.test ]
+              .includes(DyNTS_global_settings.env_settings.environment)) {
+              res.status(403).send({ error: 'Sent-mail endpoint is not available in this environment.' });
+              return;
+            }
+
+            const mails: DyNTS_SentTestMail[] = await DyNTS_TestEmailSink_Service.findSentMails({
+              to: typeof req.query.to === 'string' ? req.query.to : undefined,
+              sinceIso: typeof req.query.since === 'string' ? req.query.since : undefined,
+              limit: req.query.limit ? parseInt(String(req.query.limit), 10) : undefined,
+            }, issuer);
+
+            res.send({
+              count: mails.length,
+              mails: mails.map((mail: DyNTS_SentTestMail): object => ({
+                to: mail.to,
+                subject: mail.subject,
+                html: mail.html,
+                links: DyNTS_TestEmailSink_Service.extractLinks(mail.html),
+                issuer: mail.issuer,
+                createdAt: mail.__created,
+              })),
+            });
+          },
+        ],
+      }),
+    ];
+  }
+}

package/src/_modules/usage/get-usage-routing-module.util.ts

@@ -1,23 +1,23 @@
-
-import { DyFM_usageModule_settings } from '@futdevpro/fsm-dynamo/usage';
-import { DyNTS_RouteSecurity } from '../../_enums/route-security.enum';
-import { 
-  DyNTS_RoutingModule_Settings 
-} from '../../_models/interfaces/routing-module-settings.interface';
-import { DyNTS_RoutingModule } from '../../_services/route/routing-module.service';
-import { DyNTS_Usage_Controller } from './usage.controller';
-
-export function DyNTS_getUsageRoutingModule(
-  securityOverride?: DyNTS_RouteSecurity
-): DyNTS_RoutingModule {
-  const set: DyNTS_RoutingModule_Settings = {
-    route: DyFM_usageModule_settings.mainRoute,
-    controllers: [ DyNTS_Usage_Controller.getInstance() ],
-  };
-
-  if (securityOverride) {
-    set.securityOverride = securityOverride;
-  }
-
-  return new DyNTS_RoutingModule(set);
+
+import { DyFM_usageModule_settings } from '@futdevpro/fsm-dynamo/usage';
+import { DyNTS_RouteSecurity } from '../../_enums/route-security.enum';
+import { 
+  DyNTS_RoutingModule_Settings 
+} from '../../_models/interfaces/routing-module-settings.interface';
+import { DyNTS_RoutingModule } from '../../_services/route/routing-module.service';
+import { DyNTS_Usage_Controller } from './usage.controller';
+
+export function DyNTS_getUsageRoutingModule(
+  securityOverride?: DyNTS_RouteSecurity
+): DyNTS_RoutingModule {
+  const set: DyNTS_RoutingModule_Settings = {
+    route: DyFM_usageModule_settings.mainRoute,
+    controllers: [ DyNTS_Usage_Controller.getInstance() ],
+  };
+
+  if (securityOverride) {
+    set.securityOverride = securityOverride;
+  }
+
+  return new DyNTS_RoutingModule(set);
 }

package/src/_modules/usage/index.ts

@@ -1,15 +1,15 @@
-
-
-//
-// Usage module
-//
-// This module is creates solutions to register and manage usage data
-//
-
-
-// USAGE MODULE
-export * from './usage.controller';
-export * from './usage.data-service';
-export * from './get-usage-routing-module.util';
-export * from '@futdevpro/fsm-dynamo/usage';
-
+
+
+//
+// Usage module
+//
+// This module is creates solutions to register and manage usage data
+//
+
+
+// USAGE MODULE
+export * from './usage.controller';
+export * from './usage.data-service';
+export * from './get-usage-routing-module.util';
+export * from '@futdevpro/fsm-dynamo/usage';
+

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

@@ -1,81 +1,81 @@
-
-import { DyNTS_Usage_Controller } from './usage.controller';
-import { DyNTS_GlobalService } from '../../_services/core/global.service';
-import { DyNTS_AuthService } from '../../_services/core/auth.service';
-import { DyFM_HttpCallType } from '@futdevpro/fsm-dynamo';
-
-describe('| DyNTS_Usage_Controller', () => {
-  let controller: DyNTS_Usage_Controller;
-  let mockAuthService: jasmine.SpyObj<DyNTS_AuthService>;
-
-  beforeEach(() => {
-    controller = DyNTS_Usage_Controller.getInstance();
-    mockAuthService = jasmine.createSpyObj<DyNTS_AuthService>('AuthService', [
-      'getUsernameFromRequest',
-    ]);
-
-    spyOn(DyNTS_GlobalService, 'getAuthService').and.returnValue(mockAuthService);
-  });
-
-  it('| should be a singleton instance', () => {
-    const instance1 = DyNTS_Usage_Controller.getInstance();
-    const instance2 = DyNTS_Usage_Controller.getInstance();
-
-    expect(instance1).toBe(instance2);
-    expect(instance1).toBeInstanceOf(DyNTS_Usage_Controller);
-  });
-
-  it('| should setup endpoints', () => {
-    controller.setupEndpoints();
-
-    expect(controller.endpoints).toBeDefined();
-    expect(controller.endpoints.length).toBeGreaterThan(0);
-  });
-
-  it('| should have newSession endpoint', () => {
-    controller.setupEndpoints();
-
-    const newSessionEndpoint = controller.endpoints.find(ep => ep.name === 'newSession');
-
-    expect(newSessionEndpoint).toBeDefined();
-    expect(newSessionEndpoint?.type).toBe(DyFM_HttpCallType.get);
-    expect((newSessionEndpoint as any)?.tasks).toBeDefined();
-    expect((newSessionEndpoint as any)?.tasks.length).toBeGreaterThan(0);
-  });
-
-  it('| should have updateUsage endpoint', () => {
-    controller.setupEndpoints();
-
-    const updateUsageEndpoint = controller.endpoints.find(ep => ep.name === 'updateUsage');
-
-    expect(updateUsageEndpoint).toBeDefined();
-    expect(updateUsageEndpoint?.type).toBe(DyFM_HttpCallType.post);
-    expect((updateUsageEndpoint as any)?.tasks).toBeDefined();
-    expect((updateUsageEndpoint as any)?.tasks.length).toBeGreaterThan(0);
-  });
-
-  it('| should have closeSession endpoint', () => {
-    controller.setupEndpoints();
-
-    const closeSessionEndpoint = controller.endpoints.find(ep => ep.name === 'closeSession');
-
-    expect(closeSessionEndpoint).toBeDefined();
-    expect(closeSessionEndpoint?.type).toBe(DyFM_HttpCallType.get);
-    expect((closeSessionEndpoint as any)?.tasks).toBeDefined();
-    expect((closeSessionEndpoint as any)?.tasks.length).toBeGreaterThan(0);
-  });
-
-  it('| should have getUsageData endpoint with authentication', () => {
-    controller.setupEndpoints();
-
-    const getUsageDataEndpoint = controller.endpoints.find(ep => ep.name === 'getUsageData');
-
-    expect(getUsageDataEndpoint).toBeDefined();
-    expect(getUsageDataEndpoint?.type).toBe(DyFM_HttpCallType.get);
-    expect((getUsageDataEndpoint as any)?.preProcesses).toBeDefined();
-    expect((getUsageDataEndpoint as any)?.preProcesses.length).toBeGreaterThan(0);
-    expect((getUsageDataEndpoint as any)?.tasks).toBeDefined();
-    expect((getUsageDataEndpoint as any)?.tasks.length).toBeGreaterThan(0);
-  });
-});
-
+
+import { DyNTS_Usage_Controller } from './usage.controller';
+import { DyNTS_GlobalService } from '../../_services/core/global.service';
+import { DyNTS_AuthService } from '../../_services/core/auth.service';
+import { DyFM_HttpCallType } from '@futdevpro/fsm-dynamo';
+
+describe('| DyNTS_Usage_Controller', () => {
+  let controller: DyNTS_Usage_Controller;
+  let mockAuthService: jasmine.SpyObj<DyNTS_AuthService>;
+
+  beforeEach(() => {
+    controller = DyNTS_Usage_Controller.getInstance();
+    mockAuthService = jasmine.createSpyObj<DyNTS_AuthService>('AuthService', [
+      'getUsernameFromRequest',
+    ]);
+
+    spyOn(DyNTS_GlobalService, 'getAuthService').and.returnValue(mockAuthService);
+  });
+
+  it('| should be a singleton instance', () => {
+    const instance1 = DyNTS_Usage_Controller.getInstance();
+    const instance2 = DyNTS_Usage_Controller.getInstance();
+
+    expect(instance1).toBe(instance2);
+    expect(instance1).toBeInstanceOf(DyNTS_Usage_Controller);
+  });
+
+  it('| should setup endpoints', () => {
+    controller.setupEndpoints();
+
+    expect(controller.endpoints).toBeDefined();
+    expect(controller.endpoints.length).toBeGreaterThan(0);
+  });
+
+  it('| should have newSession endpoint', () => {
+    controller.setupEndpoints();
+
+    const newSessionEndpoint = controller.endpoints.find(ep => ep.name === 'newSession');
+
+    expect(newSessionEndpoint).toBeDefined();
+    expect(newSessionEndpoint?.type).toBe(DyFM_HttpCallType.get);
+    expect((newSessionEndpoint as any)?.tasks).toBeDefined();
+    expect((newSessionEndpoint as any)?.tasks.length).toBeGreaterThan(0);
+  });
+
+  it('| should have updateUsage endpoint', () => {
+    controller.setupEndpoints();
+
+    const updateUsageEndpoint = controller.endpoints.find(ep => ep.name === 'updateUsage');
+
+    expect(updateUsageEndpoint).toBeDefined();
+    expect(updateUsageEndpoint?.type).toBe(DyFM_HttpCallType.post);
+    expect((updateUsageEndpoint as any)?.tasks).toBeDefined();
+    expect((updateUsageEndpoint as any)?.tasks.length).toBeGreaterThan(0);
+  });
+
+  it('| should have closeSession endpoint', () => {
+    controller.setupEndpoints();
+
+    const closeSessionEndpoint = controller.endpoints.find(ep => ep.name === 'closeSession');
+
+    expect(closeSessionEndpoint).toBeDefined();
+    expect(closeSessionEndpoint?.type).toBe(DyFM_HttpCallType.get);
+    expect((closeSessionEndpoint as any)?.tasks).toBeDefined();
+    expect((closeSessionEndpoint as any)?.tasks.length).toBeGreaterThan(0);
+  });
+
+  it('| should have getUsageData endpoint with authentication', () => {
+    controller.setupEndpoints();
+
+    const getUsageDataEndpoint = controller.endpoints.find(ep => ep.name === 'getUsageData');
+
+    expect(getUsageDataEndpoint).toBeDefined();
+    expect(getUsageDataEndpoint?.type).toBe(DyFM_HttpCallType.get);
+    expect((getUsageDataEndpoint as any)?.preProcesses).toBeDefined();
+    expect((getUsageDataEndpoint as any)?.preProcesses.length).toBeGreaterThan(0);
+    expect((getUsageDataEndpoint as any)?.tasks).toBeDefined();
+    expect((getUsageDataEndpoint as any)?.tasks.length).toBeGreaterThan(0);
+  });
+});
+