@futdevpro/nts-dynamo 1.15.73 → 1.15.75

package/src/_modules/server/errors/errors.controller.spec.ts

@@ -1,30 +1,30 @@
-
-import { DyNTS_Errors_Controller } from './errors.controller';
-import { DyFM_Error, DyFM_Errors, DyFM_HttpCallType, DyFM_RelativeDate } from '@futdevpro/fsm-dynamo';
-import { DyNTS_Errors_ControlService } from './errors.control-service';
-import { DyNTS_Endpoint_Params } from '../../../_models/control-models/endpoint-params.control-model';
-
-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 };
+
+import { DyNTS_Errors_Controller } from './errors.controller';
+import { DyFM_Error, DyFM_Errors, DyFM_HttpCallType, DyFM_RelativeDate } from '@futdevpro/fsm-dynamo';
+import { DyNTS_Errors_ControlService } from './errors.control-service';
+import { DyNTS_Endpoint_Params } from '../../../_models/control-models/endpoint-params.control-model';
+
+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> {
@@ -33,217 +33,217 @@ class TestErrorsControlService extends DyNTS_Errors_ControlService<TestError, Te
 
   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 TestErrorsController extends DyNTS_Errors_Controller<TestError, TestErrors, TestErrorsControlService> {
-  protected getError_ControlService(set: { data?: TestError, issuer: string }): TestErrorsControlService {
-    return new TestErrorsControlService();
-  }
-  protected override readonly additionalEndpoints: DyNTS_Endpoint_Params[] = [];
-}
-
-describe('| DyNTS_Errors_Controller', () => {
-  let controller: TestErrorsController;
-
-  beforeEach(() => {
-    controller = new (TestErrorsController as any)();
-  });
-
-  describe('| setupEndpoints', () => {
-    it('| should setup all error endpoints', () => {
-      controller.setupEndpoints();
-
-      expect(controller.endpoints).toBeDefined();
-      expect(controller.endpoints.length).toBeGreaterThanOrEqual(6);
-    });
-
-    it('| should setup logError endpoint', () => {
-      controller.setupEndpoints();
-
-      const logErrorEndpoint = controller.endpoints.find(ep => ep.name === 'logError');
-      expect(logErrorEndpoint).toBeDefined();
-      expect(logErrorEndpoint?.type).toBe(DyFM_HttpCallType.post);
-      expect(logErrorEndpoint?.endpoint).toBe('/error/log');
-      expect((logErrorEndpoint as any)?.tasks).toBeDefined();
-      expect((logErrorEndpoint as any)?.tasks?.length).toBe(1);
-    });
-
-    it('| should setup newError endpoint', () => {
-      controller.setupEndpoints();
-
-      const newErrorEndpoint = controller.endpoints.find(ep => ep.name === 'newError');
-      expect(newErrorEndpoint).toBeDefined();
-      expect(newErrorEndpoint?.type).toBe(DyFM_HttpCallType.post);
-      expect(newErrorEndpoint?.endpoint).toBe('/error/new');
-      expect((newErrorEndpoint as any)?.tasks).toBeDefined();
-      expect((newErrorEndpoint as any)?.tasks?.length).toBe(1);
-    });
-
-    it('| should setup markErrorDone endpoint', () => {
-      controller.setupEndpoints();
-
-      const markErrorDoneEndpoint = controller.endpoints.find(ep => ep.name === 'markErrorDone');
-      expect(markErrorDoneEndpoint).toBeDefined();
-      expect(markErrorDoneEndpoint?.type).toBe(DyFM_HttpCallType.get);
-      expect(markErrorDoneEndpoint?.endpoint).toBe('/error/mark-done/:errorId');
-      expect((markErrorDoneEndpoint as any)?.tasks).toBeDefined();
-      expect((markErrorDoneEndpoint as any)?.tasks?.length).toBe(1);
-    });
-
-    it('| should setup markAllErrorDone endpoint', () => {
-      controller.setupEndpoints();
-
-      const markAllErrorDoneEndpoint = controller.endpoints.find(ep => ep.name === 'markAllErrorDone');
-      expect(markAllErrorDoneEndpoint).toBeDefined();
-      expect(markAllErrorDoneEndpoint?.type).toBe(DyFM_HttpCallType.get);
-      expect(markAllErrorDoneEndpoint?.endpoint).toBe('/error/mark-all-done');
-      expect((markAllErrorDoneEndpoint as any)?.tasks).toBeDefined();
-      expect((markAllErrorDoneEndpoint as any)?.tasks?.length).toBe(1);
-    });
-
-    it('| should setup getErrors endpoint', () => {
-      controller.setupEndpoints();
-
-      const getErrorsEndpoint = controller.endpoints.find(ep => ep.name === 'getErrors');
-      expect(getErrorsEndpoint).toBeDefined();
-      expect(getErrorsEndpoint?.type).toBe(DyFM_HttpCallType.get);
-      expect(getErrorsEndpoint?.endpoint).toBe('/error/get-range/:range');
-      expect((getErrorsEndpoint as any)?.tasks).toBeDefined();
-      expect((getErrorsEndpoint as any)?.tasks?.length).toBe(1);
-    });
-
-    it('| should setup getErrorsPaged endpoint', () => {
-      controller.setupEndpoints();
-
-      const getErrorsPagedEndpoint = controller.endpoints.find(ep => ep.name === 'getErrorsPaged');
-      expect(getErrorsPagedEndpoint).toBeDefined();
-      expect(getErrorsPagedEndpoint?.type).toBe(DyFM_HttpCallType.get);
-      expect(getErrorsPagedEndpoint?.endpoint).toBe('/error/get-paged/:range/:pageSize/:pageIndex');
-      expect((getErrorsPagedEndpoint as any)?.tasks).toBeDefined();
-      expect((getErrorsPagedEndpoint as any)?.tasks?.length).toBe(1);
-    });
-
-    it('| should setup getLastErrors endpoint', () => {
-      controller.setupEndpoints();
-
-      const getLastErrorsEndpoint = controller.endpoints.find(ep => ep.name === 'getLastErrors');
-      expect(getLastErrorsEndpoint).toBeDefined();
-      expect(getLastErrorsEndpoint?.type).toBe(DyFM_HttpCallType.get);
-      expect(getLastErrorsEndpoint?.endpoint).toBe('/error/get-last-paged/:range/:pageSize/:pageIndex');
-      expect((getLastErrorsEndpoint as any)?.tasks).toBeDefined();
-      expect((getLastErrorsEndpoint as any)?.tasks?.length).toBe(1);
-    });
-
-    it('| should setup searchErrors endpoint', () => {
-      controller.setupEndpoints();
-
-      const searchErrorsEndpoint = controller.endpoints.find(ep => ep.name === 'searchErrors');
-      expect(searchErrorsEndpoint).toBeDefined();
-      expect(searchErrorsEndpoint?.type).toBe(DyFM_HttpCallType.get);
-      expect(searchErrorsEndpoint?.endpoint).toBe('/error/search');
-      expect((searchErrorsEndpoint as any)?.tasks).toBeDefined();
-      expect((searchErrorsEndpoint as any)?.tasks?.length).toBe(1);
-    });
-
-    it('| should include additionalEndpoints', () => {
-      const additionalEndpoint = new DyNTS_Endpoint_Params({
-        name: 'customEndpoint',
-        type: DyFM_HttpCallType.get,
-        endpoint: '/error/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 TestErrorsController {
-        protected override readonly additionalEndpoints: DyNTS_Endpoint_Params[] = undefined as any;
-      } as any)();
-
-      expect(() => {
-        controllerWithoutEndpoints.setupEndpoints();
-      }).toThrow();
-    });
-  });
-
-  describe('| opt-in admin auth retrofit (BL-20260420-004)', (): void => {
-    afterEach((): void => {
-      DyNTS_Errors_Controller._resetAuthConfigForTesting();
-    });
-
-    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;
-        // Ures array vagy undefined elfogadhato — fontos hogy NE legyen auth
-        expect(pre === undefined || pre.length === 0).toBe(true);
-      }
-    });
-
-    it('| configure({ authPreProcess }) → mind a 8 endpoint kap preProcesses-t', (): void => {
-      const fakeAuth = async (): Promise<void> => { /* noop */ };
-      DyNTS_Errors_Controller.configure({ authPreProcess: fakeAuth });
-      // Uj controller instance kell — a setupEndpoints olvassa a static config-ot
-      const c = new (TestErrorsController as any)();
-      c.setupEndpoints();
-
-      const builtIn: string[] = [
-        'logError', 'newError',
-        'markErrorDone', 'markAllErrorDone',
-        'getErrors', 'getErrorsPaged', 'getLastErrors',
-        'searchErrors',
-      ];
-      for (const name of builtIn) {
-        const ep: any = c.endpoints.find((e: any) => e.name === name);
-        expect(ep).withContext(`endpoint ${name} missing`).toBeDefined();
-        const pre: any = (ep as any).preProcesses;
-        expect(pre.length).withContext(`endpoint ${name} preProcesses`).toBe(1);
-        expect(pre[0]).toBe(fakeAuth);
-      }
-    });
-
-    it('| configure({ authPreProcess, protectedEndpoints: subset }) → csak a megadott neveken aktiv', (): void => {
-      const fakeAuth = async (): Promise<void> => { /* noop */ };
-      DyNTS_Errors_Controller.configure({
-        authPreProcess: fakeAuth,
-        protectedEndpoints: ['markAllErrorDone', 'logError'],
-      });
-      const c = new (TestErrorsController as any)();
-      c.setupEndpoints();
-
-      const markAll: any = c.endpoints.find((e: any) => e.name === 'markAllErrorDone');
-      const log: any    = c.endpoints.find((e: any) => e.name === 'logError');
-      const getErrors: any = c.endpoints.find((e: any) => e.name === 'getErrors');
-
-      expect((markAll as any).preProcesses.length).toBe(1);
-      expect((log as any).preProcesses.length).toBe(1);
-      expect((getErrors as any).preProcesses?.length ?? 0).toBe(0);
-    });
-
-    it('| getAuthConfig() returns the active config', (): void => {
-      const fakeAuth = async (): Promise<void> => { /* noop */ };
-      DyNTS_Errors_Controller.configure({ authPreProcess: fakeAuth, protectedEndpoints: ['logError'] });
-      const cfg = DyNTS_Errors_Controller.getAuthConfig();
-      expect(cfg.authPreProcess).toBe(fakeAuth);
-      expect(cfg.protectedEndpoints).toEqual(['logError']);
-    });
-
-    it('| _resetAuthConfigForTesting() clears the config', (): void => {
-      DyNTS_Errors_Controller.configure({ authPreProcess: async (): Promise<void> => { /* noop */ } });
-      DyNTS_Errors_Controller._resetAuthConfigForTesting();
-      const cfg = DyNTS_Errors_Controller.getAuthConfig();
-      expect(cfg.authPreProcess).toBeUndefined();
-    });
-  });
-});
-
+  }
+  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 TestErrorsController extends DyNTS_Errors_Controller<TestError, TestErrors, TestErrorsControlService> {
+  protected getError_ControlService(set: { data?: TestError, issuer: string }): TestErrorsControlService {
+    return new TestErrorsControlService();
+  }
+  protected override readonly additionalEndpoints: DyNTS_Endpoint_Params[] = [];
+}
+
+describe('| DyNTS_Errors_Controller', () => {
+  let controller: TestErrorsController;
+
+  beforeEach(() => {
+    controller = new (TestErrorsController as any)();
+  });
+
+  describe('| setupEndpoints', () => {
+    it('| should setup all error endpoints', () => {
+      controller.setupEndpoints();
+
+      expect(controller.endpoints).toBeDefined();
+      expect(controller.endpoints.length).toBeGreaterThanOrEqual(6);
+    });
+
+    it('| should setup logError endpoint', () => {
+      controller.setupEndpoints();
+
+      const logErrorEndpoint = controller.endpoints.find(ep => ep.name === 'logError');
+      expect(logErrorEndpoint).toBeDefined();
+      expect(logErrorEndpoint?.type).toBe(DyFM_HttpCallType.post);
+      expect(logErrorEndpoint?.endpoint).toBe('/error/log');
+      expect((logErrorEndpoint as any)?.tasks).toBeDefined();
+      expect((logErrorEndpoint as any)?.tasks?.length).toBe(1);
+    });
+
+    it('| should setup newError endpoint', () => {
+      controller.setupEndpoints();
+
+      const newErrorEndpoint = controller.endpoints.find(ep => ep.name === 'newError');
+      expect(newErrorEndpoint).toBeDefined();
+      expect(newErrorEndpoint?.type).toBe(DyFM_HttpCallType.post);
+      expect(newErrorEndpoint?.endpoint).toBe('/error/new');
+      expect((newErrorEndpoint as any)?.tasks).toBeDefined();
+      expect((newErrorEndpoint as any)?.tasks?.length).toBe(1);
+    });
+
+    it('| should setup markErrorDone endpoint', () => {
+      controller.setupEndpoints();
+
+      const markErrorDoneEndpoint = controller.endpoints.find(ep => ep.name === 'markErrorDone');
+      expect(markErrorDoneEndpoint).toBeDefined();
+      expect(markErrorDoneEndpoint?.type).toBe(DyFM_HttpCallType.get);
+      expect(markErrorDoneEndpoint?.endpoint).toBe('/error/mark-done/:errorId');
+      expect((markErrorDoneEndpoint as any)?.tasks).toBeDefined();
+      expect((markErrorDoneEndpoint as any)?.tasks?.length).toBe(1);
+    });
+
+    it('| should setup markAllErrorDone endpoint', () => {
+      controller.setupEndpoints();
+
+      const markAllErrorDoneEndpoint = controller.endpoints.find(ep => ep.name === 'markAllErrorDone');
+      expect(markAllErrorDoneEndpoint).toBeDefined();
+      expect(markAllErrorDoneEndpoint?.type).toBe(DyFM_HttpCallType.get);
+      expect(markAllErrorDoneEndpoint?.endpoint).toBe('/error/mark-all-done');
+      expect((markAllErrorDoneEndpoint as any)?.tasks).toBeDefined();
+      expect((markAllErrorDoneEndpoint as any)?.tasks?.length).toBe(1);
+    });
+
+    it('| should setup getErrors endpoint', () => {
+      controller.setupEndpoints();
+
+      const getErrorsEndpoint = controller.endpoints.find(ep => ep.name === 'getErrors');
+      expect(getErrorsEndpoint).toBeDefined();
+      expect(getErrorsEndpoint?.type).toBe(DyFM_HttpCallType.get);
+      expect(getErrorsEndpoint?.endpoint).toBe('/error/get-range/:range');
+      expect((getErrorsEndpoint as any)?.tasks).toBeDefined();
+      expect((getErrorsEndpoint as any)?.tasks?.length).toBe(1);
+    });
+
+    it('| should setup getErrorsPaged endpoint', () => {
+      controller.setupEndpoints();
+
+      const getErrorsPagedEndpoint = controller.endpoints.find(ep => ep.name === 'getErrorsPaged');
+      expect(getErrorsPagedEndpoint).toBeDefined();
+      expect(getErrorsPagedEndpoint?.type).toBe(DyFM_HttpCallType.get);
+      expect(getErrorsPagedEndpoint?.endpoint).toBe('/error/get-paged/:range/:pageSize/:pageIndex');
+      expect((getErrorsPagedEndpoint as any)?.tasks).toBeDefined();
+      expect((getErrorsPagedEndpoint as any)?.tasks?.length).toBe(1);
+    });
+
+    it('| should setup getLastErrors endpoint', () => {
+      controller.setupEndpoints();
+
+      const getLastErrorsEndpoint = controller.endpoints.find(ep => ep.name === 'getLastErrors');
+      expect(getLastErrorsEndpoint).toBeDefined();
+      expect(getLastErrorsEndpoint?.type).toBe(DyFM_HttpCallType.get);
+      expect(getLastErrorsEndpoint?.endpoint).toBe('/error/get-last-paged/:range/:pageSize/:pageIndex');
+      expect((getLastErrorsEndpoint as any)?.tasks).toBeDefined();
+      expect((getLastErrorsEndpoint as any)?.tasks?.length).toBe(1);
+    });
+
+    it('| should setup searchErrors endpoint', () => {
+      controller.setupEndpoints();
+
+      const searchErrorsEndpoint = controller.endpoints.find(ep => ep.name === 'searchErrors');
+      expect(searchErrorsEndpoint).toBeDefined();
+      expect(searchErrorsEndpoint?.type).toBe(DyFM_HttpCallType.get);
+      expect(searchErrorsEndpoint?.endpoint).toBe('/error/search');
+      expect((searchErrorsEndpoint as any)?.tasks).toBeDefined();
+      expect((searchErrorsEndpoint as any)?.tasks?.length).toBe(1);
+    });
+
+    it('| should include additionalEndpoints', () => {
+      const additionalEndpoint = new DyNTS_Endpoint_Params({
+        name: 'customEndpoint',
+        type: DyFM_HttpCallType.get,
+        endpoint: '/error/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 TestErrorsController {
+        protected override readonly additionalEndpoints: DyNTS_Endpoint_Params[] = undefined as any;
+      } as any)();
+
+      expect(() => {
+        controllerWithoutEndpoints.setupEndpoints();
+      }).toThrow();
+    });
+  });
+
+  describe('| opt-in admin auth retrofit (BL-20260420-004)', (): void => {
+    afterEach((): void => {
+      DyNTS_Errors_Controller._resetAuthConfigForTesting();
+    });
+
+    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;
+        // Ures array vagy undefined elfogadhato — fontos hogy NE legyen auth
+        expect(pre === undefined || pre.length === 0).toBe(true);
+      }
+    });
+
+    it('| configure({ authPreProcess }) → mind a 8 endpoint kap preProcesses-t', (): void => {
+      const fakeAuth = async (): Promise<void> => { /* noop */ };
+      DyNTS_Errors_Controller.configure({ authPreProcess: fakeAuth });
+      // Uj controller instance kell — a setupEndpoints olvassa a static config-ot
+      const c = new (TestErrorsController as any)();
+      c.setupEndpoints();
+
+      const builtIn: string[] = [
+        'logError', 'newError',
+        'markErrorDone', 'markAllErrorDone',
+        'getErrors', 'getErrorsPaged', 'getLastErrors',
+        'searchErrors',
+      ];
+      for (const name of builtIn) {
+        const ep: any = c.endpoints.find((e: any) => e.name === name);
+        expect(ep).withContext(`endpoint ${name} missing`).toBeDefined();
+        const pre: any = (ep as any).preProcesses;
+        expect(pre.length).withContext(`endpoint ${name} preProcesses`).toBe(1);
+        expect(pre[0]).toBe(fakeAuth);
+      }
+    });
+
+    it('| configure({ authPreProcess, protectedEndpoints: subset }) → csak a megadott neveken aktiv', (): void => {
+      const fakeAuth = async (): Promise<void> => { /* noop */ };
+      DyNTS_Errors_Controller.configure({
+        authPreProcess: fakeAuth,
+        protectedEndpoints: ['markAllErrorDone', 'logError'],
+      });
+      const c = new (TestErrorsController as any)();
+      c.setupEndpoints();
+
+      const markAll: any = c.endpoints.find((e: any) => e.name === 'markAllErrorDone');
+      const log: any    = c.endpoints.find((e: any) => e.name === 'logError');
+      const getErrors: any = c.endpoints.find((e: any) => e.name === 'getErrors');
+
+      expect((markAll as any).preProcesses.length).toBe(1);
+      expect((log as any).preProcesses.length).toBe(1);
+      expect((getErrors as any).preProcesses?.length ?? 0).toBe(0);
+    });
+
+    it('| getAuthConfig() returns the active config', (): void => {
+      const fakeAuth = async (): Promise<void> => { /* noop */ };
+      DyNTS_Errors_Controller.configure({ authPreProcess: fakeAuth, protectedEndpoints: ['logError'] });
+      const cfg = DyNTS_Errors_Controller.getAuthConfig();
+      expect(cfg.authPreProcess).toBe(fakeAuth);
+      expect(cfg.protectedEndpoints).toEqual(['logError']);
+    });
+
+    it('| _resetAuthConfigForTesting() clears the config', (): void => {
+      DyNTS_Errors_Controller.configure({ authPreProcess: async (): Promise<void> => { /* noop */ } });
+      DyNTS_Errors_Controller._resetAuthConfigForTesting();
+      const cfg = DyNTS_Errors_Controller.getAuthConfig();
+      expect(cfg.authPreProcess).toBeUndefined();
+    });
+  });
+});
+