@futdevpro/nts-dynamo 1.15.104 → 1.15.105

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

@@ -1,268 +1,268 @@
-
-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> {
-    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 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();
-    });
-
-    // FR-263 — a guard mostantol REQUEST-IDOBEN fut (lazy wrapper); igy MINDEN endpoint-on pontosan
-    // 1 preProcess (a wrapper) van, a tenyleges guard-logikat a wrapper MEGHIVASAVAL teszteljuk.
-    const lazyWrapperOf = (c: any, name: string): ((req: any, res: any) => Promise<void>) | undefined => {
-      const ep: any = c.endpoints.find((e: any) => e.name === name);
-      return ep?.preProcesses?.[0];
-    };
-    const mockReqRes = (): { req: any; res: any } => ({ req: {} as any, res: { headersSent: false } as any });
-
-    it('| default (no config): a lazy wrapper jelen van, de egy keres NEM hiv guardot (nyitva marad)', async (): Promise<void> => {
-      controller.setupEndpoints();
-      for (const name of ['logError', 'getErrors', 'searchErrors']) {
-        const w = lazyWrapperOf(controller, name);
-        expect(w).withContext(`${name} wrapper`).toBeDefined();
-        const { req, res } = mockReqRes();
-        await w!(req, res); // nincs config → no-op, nem dob, nem blokkol
-      }
-    });
-
-    it('| configure({ authPreProcess }) → egy keres MINDEN built-in endpoint-on meghivja a guardot', async (): Promise<void> => {
-      let calls: number = 0;
-      DyNTS_Errors_Controller.configure({ authPreProcess: async (): Promise<void> => { calls++; } });
-      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 w = lazyWrapperOf(c, name);
-        expect(w).withContext(`endpoint ${name} missing`).toBeDefined();
-        const { req, res } = mockReqRes();
-        await w!(req, res);
-      }
-      expect(calls).toBe(builtIn.length);
-    });
-
-    it('| configure({ protectedEndpoints: subset }) → a guard CSAK a listazott endpoint-okon fut', async (): Promise<void> => {
-      let calls: number = 0;
-      DyNTS_Errors_Controller.configure({
-        authPreProcess: async (): Promise<void> => { calls++; },
-        protectedEndpoints: ['markAllErrorDone', 'logError'],
-      });
-      const c = new (TestErrorsController as any)();
-      c.setupEndpoints();
-      for (const name of ['markAllErrorDone', 'logError']) {
-        const { req, res } = mockReqRes();
-        await lazyWrapperOf(c, name)!(req, res);
-      }
-      expect(calls).withContext('protected → guard runs').toBe(2);
-      calls = 0;
-      const { req, res } = mockReqRes();
-      await lazyWrapperOf(c, 'getErrors')!(req, res);
-      expect(calls).withContext('non-protected getErrors → guard does NOT run').toBe(0);
-    });
-
-    it('| FR-263 ORDER-INDEPENDENCE: setupEndpoints() ELOTT epitett endpoint is enforce-olja a guardot (a fix lenyege)', async (): Promise<void> => {
-      // A framework korai singleton-konstrukcioja: az endpoints config NELKUL epul fel...
-      const c = new (TestErrorsController as any)();
-      c.setupEndpoints();
-      // ...es a configure() KESOBB fut (ez volt a fals-200 info-disclosure bug). A lazy wrapper
-      // request-idoben olvassa a configot → a guard MEGIS lefut. Ez az FR-263 regresszio-guard.
-      let calls: number = 0;
-      DyNTS_Errors_Controller.configure({ authPreProcess: async (): Promise<void> => { calls++; } });
-      const { req, res } = mockReqRes();
-      await lazyWrapperOf(c, 'getErrors')!(req, res);
-      expect(calls).withContext('guard must run despite configure() AFTER setupEndpoints').toBe(1);
-    });
-
-    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();
-    });
-  });
-});
-
+
+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> {
+    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 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();
+    });
+
+    // FR-263 — a guard mostantol REQUEST-IDOBEN fut (lazy wrapper); igy MINDEN endpoint-on pontosan
+    // 1 preProcess (a wrapper) van, a tenyleges guard-logikat a wrapper MEGHIVASAVAL teszteljuk.
+    const lazyWrapperOf = (c: any, name: string): ((req: any, res: any) => Promise<void>) | undefined => {
+      const ep: any = c.endpoints.find((e: any) => e.name === name);
+      return ep?.preProcesses?.[0];
+    };
+    const mockReqRes = (): { req: any; res: any } => ({ req: {} as any, res: { headersSent: false } as any });
+
+    it('| default (no config): a lazy wrapper jelen van, de egy keres NEM hiv guardot (nyitva marad)', async (): Promise<void> => {
+      controller.setupEndpoints();
+      for (const name of ['logError', 'getErrors', 'searchErrors']) {
+        const w = lazyWrapperOf(controller, name);
+        expect(w).withContext(`${name} wrapper`).toBeDefined();
+        const { req, res } = mockReqRes();
+        await w!(req, res); // nincs config → no-op, nem dob, nem blokkol
+      }
+    });
+
+    it('| configure({ authPreProcess }) → egy keres MINDEN built-in endpoint-on meghivja a guardot', async (): Promise<void> => {
+      let calls: number = 0;
+      DyNTS_Errors_Controller.configure({ authPreProcess: async (): Promise<void> => { calls++; } });
+      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 w = lazyWrapperOf(c, name);
+        expect(w).withContext(`endpoint ${name} missing`).toBeDefined();
+        const { req, res } = mockReqRes();
+        await w!(req, res);
+      }
+      expect(calls).toBe(builtIn.length);
+    });
+
+    it('| configure({ protectedEndpoints: subset }) → a guard CSAK a listazott endpoint-okon fut', async (): Promise<void> => {
+      let calls: number = 0;
+      DyNTS_Errors_Controller.configure({
+        authPreProcess: async (): Promise<void> => { calls++; },
+        protectedEndpoints: ['markAllErrorDone', 'logError'],
+      });
+      const c = new (TestErrorsController as any)();
+      c.setupEndpoints();
+      for (const name of ['markAllErrorDone', 'logError']) {
+        const { req, res } = mockReqRes();
+        await lazyWrapperOf(c, name)!(req, res);
+      }
+      expect(calls).withContext('protected → guard runs').toBe(2);
+      calls = 0;
+      const { req, res } = mockReqRes();
+      await lazyWrapperOf(c, 'getErrors')!(req, res);
+      expect(calls).withContext('non-protected getErrors → guard does NOT run').toBe(0);
+    });
+
+    it('| FR-263 ORDER-INDEPENDENCE: setupEndpoints() ELOTT epitett endpoint is enforce-olja a guardot (a fix lenyege)', async (): Promise<void> => {
+      // A framework korai singleton-konstrukcioja: az endpoints config NELKUL epul fel...
+      const c = new (TestErrorsController as any)();
+      c.setupEndpoints();
+      // ...es a configure() KESOBB fut (ez volt a fals-200 info-disclosure bug). A lazy wrapper
+      // request-idoben olvassa a configot → a guard MEGIS lefut. Ez az FR-263 regresszio-guard.
+      let calls: number = 0;
+      DyNTS_Errors_Controller.configure({ authPreProcess: async (): Promise<void> => { calls++; } });
+      const { req, res } = mockReqRes();
+      await lazyWrapperOf(c, 'getErrors')!(req, res);
+      expect(calls).withContext('guard must run despite configure() AFTER setupEndpoints').toBe(1);
+    });
+
+    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();
+    });
+  });
+});
+