@futdevpro/nts-dynamo 1.15.2 → 1.15.5

package/src/_modules/server/errors/errors.control-service.spec.ts

@@ -0,0 +1,230 @@
+
+import { DyNTS_Errors_ControlService } from './errors.control-service';
+import { DyFM_Error, DyFM_Errors, DyFM_ErrorLevel, DyFM_RelativeDate, DyFM_Paged, DyFM_SearchQuery, DyFM_SearchResult } from '@futdevpro/fsm-dynamo';
+import { DyNTS_global_settings } from '../../../_collections/global-settings.const';
+
+class TestError extends DyFM_Error {
+  constructor(set?: Partial<TestError>) {
+    super(set);
+    Object.assign(this, set);
+  }
+}
+
+class TestErrors extends DyFM_Errors<TestError> {
+  constructor(set?: Partial<TestErrors>) {
+    super(set);
+    Object.assign(this, set);
+  }
+}
+
+class TestErrorsControlService extends DyNTS_Errors_ControlService<TestError, TestErrors> {
+  async recordError(data: TestErrors, issuer: string, alwaysRecord?: boolean): Promise<void> {
+    // Mock implementation
+  }
+
+  async handleInternalError(error: any, issuer: string, alwaysRecord?: boolean): Promise<void> {
+    // Mock implementation
+  }
+
+  checkErrorIsStringifyableOrResolvable(error: TestError, issuer: string): TestError | 'UNRESOLVABLE' {
+    return error;
+  }
+
+  getPriorityMultiplierByLevel(level: DyFM_ErrorLevel, issuer: string): number {
+    return 1;
+  }
+
+  async getErrorsFromDate(date: Date, issuer: string): Promise<DyFM_Paged<TestErrors>> {
+    return {
+      items: [],
+      total: 0,
+      pageIndex: 0,
+      pageSize: 0,
+    };
+  }
+
+  async deleteError(errorId: string, issuer: string, alwaysDelete?: boolean): Promise<void> {
+    // Mock implementation
+  }
+
+  async deleteAllErrors(issuer: string, alwaysDelete?: boolean): Promise<void> {
+    // Mock implementation
+  }
+
+  async getErrorsInRange(range: DyFM_RelativeDate, issuer: string): Promise<DyFM_Paged<TestErrors>> {
+    return {
+      items: [],
+      total: 0,
+      pageIndex: 0,
+      pageSize: 0,
+    };
+  }
+
+  async getErrorsPaged(range: DyFM_RelativeDate, pageSize: number, pageIndex: number, issuer: string): Promise<DyFM_Paged<TestErrors>> {
+    return {
+      items: [],
+      total: 0,
+      pageIndex,
+      pageSize,
+    };
+  }
+
+  async getLastErrors(range: DyFM_RelativeDate, pageSize: number, pageIndex: number, issuer: string): Promise<DyFM_Paged<TestErrors>> {
+    return {
+      items: [],
+      total: 0,
+      pageIndex,
+      pageSize,
+    };
+  }
+
+  async searchErrors(searchQuery: DyFM_SearchQuery<TestErrors>, issuer: string): Promise<DyFM_SearchResult<TestErrors>> {
+    return {
+      results: [],
+      totalItems: 0,
+    };
+  }
+
+  static getInstance(): TestErrorsControlService {
+    return (TestErrorsControlService as any).getSingletonInstance();
+  }
+}
+
+describe('| DyNTS_Errors_ControlService', () => {
+  let service: TestErrorsControlService;
+
+  beforeEach(() => {
+    service = new (TestErrorsControlService as any)();
+  });
+
+  describe('| constructor', () => {
+    it('| should initialize with default values', () => {
+      expect(service.debugLog).toBe(false);
+      expect(service.version).toBe(DyNTS_global_settings.systemVersion);
+      expect(service.duplicationCounter).toBeUndefined();
+    });
+  });
+
+  describe('| properties', () => {
+    it('| should have version property', () => {
+      expect(service.version).toBeDefined();
+      expect(typeof service.version).toBe('string');
+    });
+
+    it('| should have debugLog property', () => {
+      expect(service.debugLog).toBeDefined();
+      expect(typeof service.debugLog).toBe('boolean');
+    });
+  });
+
+  describe('| recordError', () => {
+    it('| should record error', async () => {
+      const errors = new TestErrors({
+        error: new TestError({ _message: 'Test error' }),
+      });
+
+      await service.recordError(errors, 'test-issuer');
+
+      expect(service.recordError).toBeDefined();
+    });
+  });
+
+  describe('| handleInternalError', () => {
+    it('| should handle internal error', async () => {
+      const error = new Error('Internal error');
+
+      await service.handleInternalError(error, 'test-issuer');
+
+      expect(service.handleInternalError).toBeDefined();
+    });
+  });
+
+  describe('| checkErrorIsStringifyableOrResolvable', () => {
+    it('| should check if error is stringifyable', () => {
+      const error = new TestError({ _message: 'Test error' });
+
+      const result = service.checkErrorIsStringifyableOrResolvable(error, 'test-issuer');
+
+      expect(result).toBe(error);
+    });
+  });
+
+  describe('| getPriorityMultiplierByLevel', () => {
+    it('| should return priority multiplier', () => {
+      const result = service.getPriorityMultiplierByLevel(DyFM_ErrorLevel.error, 'test-issuer');
+
+      expect(result).toBe(1);
+    });
+  });
+
+  describe('| getErrorsFromDate', () => {
+    it('| should get errors from date', async () => {
+      const date = new Date();
+      const result = await service.getErrorsFromDate(date, 'test-issuer');
+
+      expect(result).toBeDefined();
+      expect(result.items).toBeDefined();
+      expect(result.total).toBeDefined();
+    });
+  });
+
+  describe('| deleteError', () => {
+    it('| should delete error', async () => {
+      await service.deleteError('error-123', 'test-issuer');
+
+      expect(service.deleteError).toBeDefined();
+    });
+  });
+
+  describe('| deleteAllErrors', () => {
+    it('| should delete all errors', async () => {
+      await service.deleteAllErrors('test-issuer');
+
+      expect(service.deleteAllErrors).toBeDefined();
+    });
+  });
+
+  describe('| getErrorsInRange', () => {
+    it('| should get errors in range', async () => {
+      const result = await service.getErrorsInRange(DyFM_RelativeDate.lastWeek, 'test-issuer');
+
+      expect(result).toBeDefined();
+      expect(result.items).toBeDefined();
+    });
+  });
+
+  describe('| getErrorsPaged', () => {
+    it('| should get errors paged', async () => {
+      const result = await service.getErrorsPaged(DyFM_RelativeDate.lastWeek, 10, 0, 'test-issuer');
+
+      expect(result).toBeDefined();
+      expect(result.items).toBeDefined();
+      expect(result.pageIndex).toBe(0);
+      expect(result.pageSize).toBe(10);
+    });
+  });
+
+  describe('| getLastErrors', () => {
+    it('| should get last errors', async () => {
+      const result = await service.getLastErrors(DyFM_RelativeDate.lastWeek, 10, 0, 'test-issuer');
+
+      expect(result).toBeDefined();
+      expect(result.items).toBeDefined();
+    });
+  });
+
+  describe('| searchErrors', () => {
+    it('| should search errors', async () => {
+      const searchQuery: DyFM_SearchQuery<TestErrors> = {
+        filterBy: {},
+      };
+
+      const result = await service.searchErrors(searchQuery, 'test-issuer');
+
+      expect(result).toBeDefined();
+      expect(result.results).toBeDefined();
+      expect(result.totalItems).toBeDefined();
+    });
+  });
+});
+

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

@@ -0,0 +1,165 @@
+
+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 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();
+    });
+  });
+});
+