@futdevpro/nts-dynamo 1.15.82 → 1.15.84

package/src/_modules/server/server-status/server-status.controller.spec.ts

@@ -1,248 +1,255 @@
-
-import { DyNTS_ServerStatus_Controller } from './server-status.controller';
-import { DyFM_ServerStatus, DyFM_Error, DyFM_Errors, DyFM_HttpCallType, DyFM_RelativeDate } from '@futdevpro/fsm-dynamo';
-import { DyNTS_Errors_ControlService } from '../errors/errors.control-service';
-import { DyNTS_ServerStatus_ControlService } from './server-status.control-service';
-import { DyNTS_ServerStatusSnapshot_ControlService } from './server-status-snapshot.control-service';
-import { DyNTS_Endpoint_Params } from '../../../_models/control-models/endpoint-params.control-model';
-
-class TestServerStatus extends DyFM_ServerStatus {
-  testProperty?: string;
-}
-
-class TestError extends DyFM_Error {
-  testProperty?: string;
-}
-
-class TestErrors extends DyFM_Errors<TestError> {
-  testProperty?: string;
-}
-
-class TestErrorsControlService extends DyNTS_Errors_ControlService<TestError, TestErrors> {
-  async recordError(data: TestErrors, issuer: string, alwaysRecord?: boolean): Promise<void> {}
-  async handleInternalError(error: any, issuer: string, alwaysRecord?: boolean): Promise<void> {}
-  checkErrorIsStringifyableOrResolvable(error: TestError, issuer: string): TestError | 'UNRESOLVABLE' { return error; }
-  getPriorityMultiplierByLevel(level: any, issuer: string): number { return 0; }
-  async getErrorsFromDate(date: Date, issuer: string): Promise<any> { return { results: [] }; }
-  async deleteError(errorId: string, issuer: string, alwaysDelete?: boolean): Promise<void> {}
-  async deleteAllErrors(issuer: string, alwaysDelete?: boolean): Promise<void> {}
-  async recordFixAttempt(errorId: string, version: string, hypothesis: string, issuer: string): Promise<any> {
-    return { at: new Date(), by: issuer, version, hypothesis };
-  }
-  async getErrorsByCategoryPaged(category: string, range: any, pageSize: number, pageIndex: number, issuer: string): Promise<any> {
-    return { items: [], total: 0, pageIndex, pageSize };
-  }
-
-  async resolveError(errorId: string, issuer: string, notes?: string): Promise<void> {
-    return;
-  }
-
-  async getErrorsByStatusPaged(status: string, range: any, pageSize: number, pageIndex: number, issuer: string): Promise<any> {
-    return { items: [], total: 0, pageIndex, pageSize };
-  }
-  async getErrorsInRange(range: DyFM_RelativeDate, issuer: string): Promise<any> { return { results: [] }; }
-  async getErrorsPaged(range: DyFM_RelativeDate, pageSize: number, pageIndex: number, issuer: string): Promise<any> { return { results: [] }; }
-  async getLastErrors(range: DyFM_RelativeDate, pageSize: number, pageIndex: number, issuer: string): Promise<any> { return { results: [] }; }
-  async searchErrors(searchQuery: any, issuer: string): Promise<any> { return { results: [] }; }
-}
-
-class TestServerStatusSnapshotControlService extends DyNTS_ServerStatusSnapshot_ControlService<TestServerStatus> {
-  async saveSnapshot(snapshot: TestServerStatus, issuer: string): Promise<TestServerStatus> {
-    return snapshot;
-  }
-}
-
-class TestServerStatusControlService extends DyNTS_ServerStatus_ControlService<
-  TestServerStatus,
-  TestError,
-  TestErrors,
-  TestErrorsControlService,
-  TestServerStatus,
-  TestServerStatusSnapshotControlService
-> {
-  protected getErrorControlService?(set?: { data?: TestErrors, issuer?: string }): TestErrorsControlService {
-    return new TestErrorsControlService();
-  }
-  protected getServerStatusSnapshotControlService?(set?: { data?: TestServerStatus, issuer?: string }): TestServerStatusSnapshotControlService {
-    return new TestServerStatusSnapshotControlService();
-  }
-  protected requiredServerConnections: any[] = [];
-}
-
-class TestServerStatusController extends DyNTS_ServerStatus_Controller<
-  TestServerStatus,
-  TestError,
-  TestErrors,
-  TestErrorsControlService,
-  TestServerStatus,
-  TestServerStatusSnapshotControlService,
-  TestServerStatusControlService
-> {
-  protected readonly server_CS: TestServerStatusControlService = (TestServerStatusControlService as any).getInstance ? (TestServerStatusControlService as any).getInstance() : new (TestServerStatusControlService as any)();
-  protected override readonly additionalEndpoints: DyNTS_Endpoint_Params[] = [];
-}
-
-describe('| DyNTS_ServerStatus_Controller', () => {
-  let controller: TestServerStatusController;
-
-  beforeEach(() => {
-    controller = new (TestServerStatusController as any)();
-  });
-
-  describe('| setupEndpoints', () => {
-    it('| should setup all server status endpoints', () => {
-      controller.setupEndpoints();
-
-      expect(controller.endpoints).toBeDefined();
-      expect(controller.endpoints.length).toBeGreaterThanOrEqual(4);
-    });
-
-    it('| should setup getServerStatus endpoint', () => {
-      controller.setupEndpoints();
-
-      const getServerStatusEndpoint = controller.endpoints.find(ep => ep.name === 'getServerStatus');
-      expect(getServerStatusEndpoint).toBeDefined();
-      expect(getServerStatusEndpoint?.type).toBe(DyFM_HttpCallType.get);
-      expect(getServerStatusEndpoint?.endpoint).toBe('/status');
-      expect((getServerStatusEndpoint as any)?.tasks).toBeDefined();
-      expect((getServerStatusEndpoint as any)?.tasks?.length).toBe(1);
-    });
-
-    it('| should setup getServerHealth endpoint', () => {
-      controller.setupEndpoints();
-
-      const getServerHealthEndpoint = controller.endpoints.find(ep => ep.name === 'getServerHealth');
-      expect(getServerHealthEndpoint).toBeDefined();
-      expect(getServerHealthEndpoint?.type).toBe(DyFM_HttpCallType.get);
-      expect(getServerHealthEndpoint?.endpoint).toBe('/health');
-      expect((getServerHealthEndpoint as any)?.tasks).toBeDefined();
-      expect((getServerHealthEndpoint as any)?.tasks?.length).toBe(1);
-    });
-
-    it('| should setup getServerStatusForClient endpoint', () => {
-      controller.setupEndpoints();
-
-      const getServerStatusForClientEndpoint = controller.endpoints.find(ep => ep.name === 'getServerStatusForClient');
-      expect(getServerStatusForClientEndpoint).toBeDefined();
-      expect(getServerStatusForClientEndpoint?.type).toBe(DyFM_HttpCallType.get);
-      expect(getServerStatusForClientEndpoint?.endpoint).toBe('/status/:version');
-      expect((getServerStatusForClientEndpoint as any)?.tasks).toBeDefined();
-      expect((getServerStatusForClientEndpoint as any)?.tasks?.length).toBe(1);
-    });
-
-    it('| should setup getErrorStatistics endpoint', () => {
-      controller.setupEndpoints();
-
-      const getErrorStatisticsEndpoint = controller.endpoints.find(ep => ep.name === 'getErrorStatistics');
-      expect(getErrorStatisticsEndpoint).toBeDefined();
-      expect(getErrorStatisticsEndpoint?.type).toBe(DyFM_HttpCallType.get);
-      expect(getErrorStatisticsEndpoint?.endpoint).toBe('/statistics/error/:range');
-      expect((getErrorStatisticsEndpoint as any)?.tasks).toBeDefined();
-      expect((getErrorStatisticsEndpoint as any)?.tasks?.length).toBe(1);
-    });
-
-    it('| should include additionalEndpoints', () => {
-      const additionalEndpoint = new DyNTS_Endpoint_Params({
-        name: 'customEndpoint',
-        type: DyFM_HttpCallType.get,
-        endpoint: '/status/custom',
-        tasks: [],
-      });
-      (controller as any).additionalEndpoints.push(additionalEndpoint);
-
-      controller.setupEndpoints();
-
-      const customEndpoint = controller.endpoints.find(ep => ep.name === 'customEndpoint');
-      expect(customEndpoint).toBeDefined();
-    });
-
-    it('| should throw error when additionalEndpoints is not defined', () => {
-      const controllerWithoutEndpoints = new (class extends TestServerStatusController {
-        protected override readonly additionalEndpoints: DyNTS_Endpoint_Params[] = undefined as any;
-      } as any)();
-
-      expect(() => {
-        controllerWithoutEndpoints.setupEndpoints();
-      }).toThrow();
-    });
-  });
-
-  describe('| opt-in admin auth retrofit', (): void => {
-    afterEach((): void => {
-      DyNTS_ServerStatus_Controller._resetAuthConfigForTesting();
-    });
-
-    const preCount = (controller: any, name: string): number => {
-      const ep: any = controller.endpoints.find((e: any) => e.name === name);
-      return (ep?.preProcesses ?? []).length;
-    };
-
-    it('| default: NO preProcesses on any endpoint (backwards compatible)', (): void => {
-      controller.setupEndpoints();
-      for (const ep of controller.endpoints) {
-        const pre: any = (ep as any).preProcesses;
-        expect(pre === undefined || pre.length === 0).toBe(true);
-      }
-    });
-
-    it('| configure({ authPreProcess }) → csak getErrorStatistics gated, a status-vegpontok NEM', (): void => {
-      const fakeAuth = async (): Promise<void> => { /* noop */ };
-      DyNTS_ServerStatus_Controller.configure({ authPreProcess: fakeAuth });
-      const c: any = new (TestServerStatusController as any)();
-      c.setupEndpoints();
-
-      // admin-adat → gated
-      expect(preCount(c, 'getErrorStatistics')).toBe(1);
-      // status-vegpontok (a kliens-indikator hivja, /health-tel adat-ekvivalens) → SOHA nem gated
-      expect(preCount(c, 'getServerStatus')).toBe(0);
-      expect(preCount(c, 'getServerHealth')).toBe(0);
-      expect(preCount(c, 'getServerReadiness')).toBe(0);
-      expect(preCount(c, 'getServerStatusForClient')).toBe(0);
-    });
-
-    it('| a status-vegpontokat (getServerStatus is) explicit protectedEndpoints-lista SEM gate-eli', (): void => {
-      const fakeAuth = async (): Promise<void> => { /* noop */ };
-      DyNTS_ServerStatus_Controller.configure({
-        authPreProcess: fakeAuth,
-        protectedEndpoints: [ 'getServerHealth', 'getServerReadiness', 'getServerStatusForClient', 'getServerStatus', 'getErrorStatistics' ],
-      });
-      const c: any = new (TestServerStatusController as any)();
-      c.setupEndpoints();
-
-      expect(preCount(c, 'getServerStatus')).toBe(0);
-      expect(preCount(c, 'getServerHealth')).toBe(0);
-      expect(preCount(c, 'getServerReadiness')).toBe(0);
-      expect(preCount(c, 'getServerStatusForClient')).toBe(0);
-      // a valodi admin-adat viszont gated
-      expect(preCount(c, 'getErrorStatistics')).toBe(1);
-    });
-
-    it('| protectedEndpoints subset → csak a megadott (nem-proba) neveken aktiv', (): void => {
-      const fakeAuth = async (): Promise<void> => { /* noop */ };
-      DyNTS_ServerStatus_Controller.configure({
-        authPreProcess: fakeAuth,
-        protectedEndpoints: [ 'getErrorStatistics' ],
-      });
-      const c: any = new (TestServerStatusController as any)();
-      c.setupEndpoints();
-
-      expect(preCount(c, 'getErrorStatistics')).toBe(1);
-      expect(preCount(c, 'getServerStatus')).toBe(0);
-    });
-
-    it('| getAuthConfig() returns the active config', (): void => {
-      const fakeAuth = async (): Promise<void> => { /* noop */ };
-      DyNTS_ServerStatus_Controller.configure({ authPreProcess: fakeAuth, protectedEndpoints: [ 'getErrorStatistics' ] });
-      const cfg = DyNTS_ServerStatus_Controller.getAuthConfig();
-      expect(cfg.authPreProcess).toBe(fakeAuth);
-      expect(cfg.protectedEndpoints).toEqual([ 'getErrorStatistics' ]);
-    });
-
-    it('| _resetAuthConfigForTesting() clears the config', (): void => {
-      DyNTS_ServerStatus_Controller.configure({ authPreProcess: async (): Promise<void> => { /* noop */ } });
-      DyNTS_ServerStatus_Controller._resetAuthConfigForTesting();
-      expect(DyNTS_ServerStatus_Controller.getAuthConfig().authPreProcess).toBeUndefined();
-    });
-  });
-});
-
+
+import { DyNTS_ServerStatus_Controller } from './server-status.controller';
+import { DyFM_ServerStatus, DyFM_Error, DyFM_Errors, DyFM_HttpCallType, DyFM_RelativeDate } from '@futdevpro/fsm-dynamo';
+import { DyNTS_Errors_ControlService } from '../errors/errors.control-service';
+import { DyNTS_ServerStatus_ControlService } from './server-status.control-service';
+import { DyNTS_ServerStatusSnapshot_ControlService } from './server-status-snapshot.control-service';
+import { DyNTS_Endpoint_Params } from '../../../_models/control-models/endpoint-params.control-model';
+
+class TestServerStatus extends DyFM_ServerStatus {
+  testProperty?: string;
+}
+
+class TestError extends DyFM_Error {
+  testProperty?: string;
+}
+
+class TestErrors extends DyFM_Errors<TestError> {
+  testProperty?: string;
+}
+
+class TestErrorsControlService extends DyNTS_Errors_ControlService<TestError, TestErrors> {
+  async recordError(data: TestErrors, issuer: string, alwaysRecord?: boolean): Promise<void> {}
+  async handleInternalError(error: any, issuer: string, alwaysRecord?: boolean): Promise<void> {}
+  checkErrorIsStringifyableOrResolvable(error: TestError, issuer: string): TestError | 'UNRESOLVABLE' { return error; }
+  getPriorityMultiplierByLevel(level: any, issuer: string): number { return 0; }
+  async getErrorsFromDate(date: Date, issuer: string): Promise<any> { return { results: [] }; }
+  async deleteError(errorId: string, issuer: string, alwaysDelete?: boolean): Promise<void> {}
+  async deleteAllErrors(issuer: string, alwaysDelete?: boolean): Promise<void> {}
+  async recordFixAttempt(errorId: string, version: string, hypothesis: string, issuer: string): Promise<any> {
+    return { at: new Date(), by: issuer, version, hypothesis };
+  }
+  async getErrorsByCategoryPaged(category: string, range: any, pageSize: number, pageIndex: number, issuer: string): Promise<any> {
+    return { items: [], total: 0, pageIndex, pageSize };
+  }
+
+  async resolveError(errorId: string, issuer: string, notes?: string): Promise<void> {
+    return;
+  }
+
+  async getErrorsByStatusPaged(status: string, range: any, pageSize: number, pageIndex: number, issuer: string): Promise<any> {
+    return { items: [], total: 0, pageIndex, pageSize };
+  }
+  async getErrorsInRange(range: DyFM_RelativeDate, issuer: string): Promise<any> { return { results: [] }; }
+  async getErrorsPaged(range: DyFM_RelativeDate, pageSize: number, pageIndex: number, issuer: string): Promise<any> { return { results: [] }; }
+  async getLastErrors(range: DyFM_RelativeDate, pageSize: number, pageIndex: number, issuer: string): Promise<any> { return { results: [] }; }
+  async searchErrors(searchQuery: any, issuer: string): Promise<any> { return { results: [] }; }
+}
+
+class TestServerStatusSnapshotControlService extends DyNTS_ServerStatusSnapshot_ControlService<TestServerStatus> {
+  async saveSnapshot(snapshot: TestServerStatus, issuer: string): Promise<TestServerStatus> {
+    return snapshot;
+  }
+}
+
+class TestServerStatusControlService extends DyNTS_ServerStatus_ControlService<
+  TestServerStatus,
+  TestError,
+  TestErrors,
+  TestErrorsControlService,
+  TestServerStatus,
+  TestServerStatusSnapshotControlService
+> {
+  protected getErrorControlService?(set?: { data?: TestErrors, issuer?: string }): TestErrorsControlService {
+    return new TestErrorsControlService();
+  }
+  protected getServerStatusSnapshotControlService?(set?: { data?: TestServerStatus, issuer?: string }): TestServerStatusSnapshotControlService {
+    return new TestServerStatusSnapshotControlService();
+  }
+  protected requiredServerConnections: any[] = [];
+}
+
+class TestServerStatusController extends DyNTS_ServerStatus_Controller<
+  TestServerStatus,
+  TestError,
+  TestErrors,
+  TestErrorsControlService,
+  TestServerStatus,
+  TestServerStatusSnapshotControlService,
+  TestServerStatusControlService
+> {
+  protected readonly server_CS: TestServerStatusControlService = (TestServerStatusControlService as any).getInstance ? (TestServerStatusControlService as any).getInstance() : new (TestServerStatusControlService as any)();
+  protected override readonly additionalEndpoints: DyNTS_Endpoint_Params[] = [];
+}
+
+describe('| DyNTS_ServerStatus_Controller', () => {
+  let controller: TestServerStatusController;
+
+  beforeEach(() => {
+    controller = new (TestServerStatusController as any)();
+  });
+
+  describe('| setupEndpoints', () => {
+    it('| should setup all server status endpoints', () => {
+      controller.setupEndpoints();
+
+      expect(controller.endpoints).toBeDefined();
+      expect(controller.endpoints.length).toBeGreaterThanOrEqual(4);
+    });
+
+    it('| should setup getServerStatus endpoint', () => {
+      controller.setupEndpoints();
+
+      const getServerStatusEndpoint = controller.endpoints.find(ep => ep.name === 'getServerStatus');
+      expect(getServerStatusEndpoint).toBeDefined();
+      expect(getServerStatusEndpoint?.type).toBe(DyFM_HttpCallType.get);
+      expect(getServerStatusEndpoint?.endpoint).toBe('/status');
+      expect((getServerStatusEndpoint as any)?.tasks).toBeDefined();
+      expect((getServerStatusEndpoint as any)?.tasks?.length).toBe(1);
+    });
+
+    it('| should setup getServerHealth endpoint', () => {
+      controller.setupEndpoints();
+
+      const getServerHealthEndpoint = controller.endpoints.find(ep => ep.name === 'getServerHealth');
+      expect(getServerHealthEndpoint).toBeDefined();
+      expect(getServerHealthEndpoint?.type).toBe(DyFM_HttpCallType.get);
+      expect(getServerHealthEndpoint?.endpoint).toBe('/health');
+      expect((getServerHealthEndpoint as any)?.tasks).toBeDefined();
+      expect((getServerHealthEndpoint as any)?.tasks?.length).toBe(1);
+    });
+
+    it('| should setup getServerStatusForClient endpoint', () => {
+      controller.setupEndpoints();
+
+      const getServerStatusForClientEndpoint = controller.endpoints.find(ep => ep.name === 'getServerStatusForClient');
+      expect(getServerStatusForClientEndpoint).toBeDefined();
+      expect(getServerStatusForClientEndpoint?.type).toBe(DyFM_HttpCallType.get);
+      expect(getServerStatusForClientEndpoint?.endpoint).toBe('/status/:version');
+      expect((getServerStatusForClientEndpoint as any)?.tasks).toBeDefined();
+      expect((getServerStatusForClientEndpoint as any)?.tasks?.length).toBe(1);
+    });
+
+    it('| should setup getErrorStatistics endpoint', () => {
+      controller.setupEndpoints();
+
+      const getErrorStatisticsEndpoint = controller.endpoints.find(ep => ep.name === 'getErrorStatistics');
+      expect(getErrorStatisticsEndpoint).toBeDefined();
+      expect(getErrorStatisticsEndpoint?.type).toBe(DyFM_HttpCallType.get);
+      expect(getErrorStatisticsEndpoint?.endpoint).toBe('/statistics/error/:range');
+      expect((getErrorStatisticsEndpoint as any)?.tasks).toBeDefined();
+      expect((getErrorStatisticsEndpoint as any)?.tasks?.length).toBe(1);
+    });
+
+    it('| should include additionalEndpoints', () => {
+      const additionalEndpoint = new DyNTS_Endpoint_Params({
+        name: 'customEndpoint',
+        type: DyFM_HttpCallType.get,
+        endpoint: '/status/custom',
+        tasks: [],
+      });
+      (controller as any).additionalEndpoints.push(additionalEndpoint);
+
+      controller.setupEndpoints();
+
+      const customEndpoint = controller.endpoints.find(ep => ep.name === 'customEndpoint');
+      expect(customEndpoint).toBeDefined();
+    });
+
+    it('| should throw error when additionalEndpoints is not defined', () => {
+      const controllerWithoutEndpoints = new (class extends TestServerStatusController {
+        protected override readonly additionalEndpoints: DyNTS_Endpoint_Params[] = undefined as any;
+      } as any)();
+
+      expect(() => {
+        controllerWithoutEndpoints.setupEndpoints();
+      }).toThrow();
+    });
+  });
+
+  describe('| opt-in admin auth retrofit', (): void => {
+    afterEach((): void => {
+      DyNTS_ServerStatus_Controller._resetAuthConfigForTesting();
+    });
+
+    // FR-263 — a guard request-idoben fut (lazy wrapper). "Gated-e egy endpoint" = a wrapper
+    // meghivasa lefuttatja-e a configured authPreProcess-t. A counter-t a teszt-spy lepteti.
+    let guardCalls: number = 0;
+    const spyAuth = async (): Promise<void> => { guardCalls++; };
+    const runGuard = async (c: any, name: string): Promise<void> => {
+      const ep: any = c.endpoints.find((e: any) => e.name === name);
+      await ep?.preProcesses?.[0]?.({} as any, { headersSent: false } as any);
+    };
+    beforeEach((): void => { guardCalls = 0; });
+
+    it('| default (no config): a wrapper jelen van, de egy keres NEM hiv guardot (nyitva marad)', async (): Promise<void> => {
+      controller.setupEndpoints();
+      for (const ep of controller.endpoints) {
+        await (ep as any).preProcesses?.[0]?.({} as any, { headersSent: false } as any); // no-op, nem dob
+      }
+      expect(guardCalls).toBe(0);
+    });
+
+    it('| configure({ authPreProcess }) → CSAK getErrorStatistics-en fut a guard, a status-vegpontokon NEM', async (): Promise<void> => {
+      DyNTS_ServerStatus_Controller.configure({ authPreProcess: spyAuth });
+      const c: any = new (TestServerStatusController as any)();
+      c.setupEndpoints();
+      await runGuard(c, 'getErrorStatistics');
+      expect(guardCalls).withContext('admin-adat → gated').toBe(1);
+      guardCalls = 0;
+      for (const name of ['getServerStatus', 'getServerHealth', 'getServerReadiness', 'getServerStatusForClient']) {
+        await runGuard(c, name);
+      }
+      expect(guardCalls).withContext('status-probak SOHA nem gated').toBe(0);
+    });
+
+    it('| a status-vegpontokat explicit protectedEndpoints-lista SEM gate-eli (PUBLIC_PROBE kizart)', async (): Promise<void> => {
+      DyNTS_ServerStatus_Controller.configure({
+        authPreProcess: spyAuth,
+        protectedEndpoints: [ 'getServerHealth', 'getServerReadiness', 'getServerStatusForClient', 'getServerStatus', 'getErrorStatistics' ],
+      });
+      const c: any = new (TestServerStatusController as any)();
+      c.setupEndpoints();
+      for (const name of ['getServerStatus', 'getServerHealth', 'getServerReadiness', 'getServerStatusForClient']) {
+        await runGuard(c, name);
+      }
+      expect(guardCalls).withContext('status-probak kizartak meg explicit listan is').toBe(0);
+      await runGuard(c, 'getErrorStatistics');
+      expect(guardCalls).withContext('getErrorStatistics gated').toBe(1);
+    });
+
+    it('| protectedEndpoints subset → getErrorStatistics gated, getServerStatus NEM', async (): Promise<void> => {
+      DyNTS_ServerStatus_Controller.configure({ authPreProcess: spyAuth, protectedEndpoints: [ 'getErrorStatistics' ] });
+      const c: any = new (TestServerStatusController as any)();
+      c.setupEndpoints();
+      await runGuard(c, 'getErrorStatistics');
+      expect(guardCalls).toBe(1);
+      guardCalls = 0;
+      await runGuard(c, 'getServerStatus');
+      expect(guardCalls).toBe(0);
+    });
+
+    it('| FR-263 ORDER-INDEPENDENCE: setupEndpoints() ELOTT epitett endpoint is enforce-olja a guardot', async (): Promise<void> => {
+      const c: any = new (TestServerStatusController as any)();
+      c.setupEndpoints(); // config NELKUL (korai framework-konstrukcio szimulacioja)
+      DyNTS_ServerStatus_Controller.configure({ authPreProcess: spyAuth }); // configure UTANA
+      await runGuard(c, 'getErrorStatistics');
+      expect(guardCalls).withContext('guard runs despite configure() AFTER setupEndpoints').toBe(1);
+    });
+
+    it('| getAuthConfig() returns the active config', (): void => {
+      const fakeAuth = async (): Promise<void> => { /* noop */ };
+      DyNTS_ServerStatus_Controller.configure({ authPreProcess: fakeAuth, protectedEndpoints: [ 'getErrorStatistics' ] });
+      const cfg = DyNTS_ServerStatus_Controller.getAuthConfig();
+      expect(cfg.authPreProcess).toBe(fakeAuth);
+      expect(cfg.protectedEndpoints).toEqual([ 'getErrorStatistics' ]);
+    });
+
+    it('| _resetAuthConfigForTesting() clears the config', (): void => {
+      DyNTS_ServerStatus_Controller.configure({ authPreProcess: async (): Promise<void> => { /* noop */ } });
+      DyNTS_ServerStatus_Controller._resetAuthConfigForTesting();
+      expect(DyNTS_ServerStatus_Controller.getAuthConfig().authPreProcess).toBeUndefined();
+    });
+  });
+});
+