@futdevpro/nts-dynamo 1.15.41 → 1.15.43

package/src/_models/control-models/endpoint-params.control-model.spec.ts

@@ -1,578 +1,578 @@
-
-import { Request, Response } from 'express';
-import { DyFM_HttpCallType, DyFM_Log, DyFM_Error, DyFM_EnvironmentFlag } from '@futdevpro/fsm-dynamo';
-import { DyNTS_Endpoint_Params } from './endpoint-params.control-model';
-import { DyNTS_RouteSecurity } from '../../_enums/route-security.enum';
-import { DyNTS_global_settings } from '../../_collections/global-settings.const';
-import { DyNTS_GlobalService } from '../../_services/core/global.service';
-
-// Skipped: DyFM_Error stack trace causes Jasmine 'split' errors
-describe('| DyNTS_Endpoint_Params', () => {
-  // Ensure env_settings and log_settings exist before tests
-  beforeAll(() => {
-    if (!DyNTS_global_settings.env_settings) {
-      (DyNTS_global_settings as any).env_settings = {
-        environment: DyFM_EnvironmentFlag.local,
-        discord: {},
-        mongoUri: undefined,
-        openAi: {},
-      };
-    } else if (!DyNTS_global_settings.env_settings.environment) {
-      DyNTS_global_settings.env_settings.environment = DyFM_EnvironmentFlag.local;
-    }
-    // Initialize log_settings for error handling tests
-    if (!DyNTS_global_settings.log_settings) {
-      (DyNTS_global_settings as any).log_settings = {
-        highDetailedLogs: false,
-        api_errors: true,
-        requestStackLocation: false,
-      };
-    }
-    // Initialize compactErrorResponse
-    if (DyNTS_global_settings.compactErrorResponse === undefined) {
-      (DyNTS_global_settings as any).compactErrorResponse = false;
-    }
-  });
-
-  describe('| constructor', () => {
-    it('| should create an instance with required parameters', () => {
-      const tasks = [
-        async (req: Request, res: Response, issuer: string): Promise<void> => {
-          res.send({ success: true });
-        },
-      ];
-
-      const params = new DyNTS_Endpoint_Params({
-        name: 'testEndpoint',
-        type: DyFM_HttpCallType.get,
-        endpoint: '/test',
-        tasks: tasks,
-      });
-
-      expect(params.name).toBe('testEndpoint');
-      expect(params.type).toBe(DyFM_HttpCallType.get);
-      expect(params.endpoint).toBe('/test');
-      expect((params as any).tasks).toBe(tasks);
-    });
-
-    it('| should set default security to open', () => {
-      const tasks = [
-        async (req: Request, res: Response, issuer: string): Promise<void> => {
-          res.send({ success: true });
-        },
-      ];
-
-      const params = new DyNTS_Endpoint_Params({
-        name: 'testEndpoint',
-        type: DyFM_HttpCallType.get,
-        endpoint: '/test',
-        tasks: tasks,
-      });
-
-      expect(params.security).toBe(DyNTS_RouteSecurity.open);
-    });
-
-    it('| should use provided security', () => {
-      const tasks = [
-        async (req: Request, res: Response, issuer: string): Promise<void> => {
-          res.send({ success: true });
-        },
-      ];
-
-      const params = new DyNTS_Endpoint_Params({
-        name: 'testEndpoint',
-        type: DyFM_HttpCallType.get,
-        endpoint: '/test',
-        security: DyNTS_RouteSecurity.secure,
-        tasks: tasks,
-      });
-
-      expect(params.security).toBe(DyNTS_RouteSecurity.secure);
-    });
-
-    it('| should extract path parameters from endpoint', () => {
-      const tasks = [
-        async (req: Request, res: Response, issuer: string): Promise<void> => {
-          res.send({ success: true });
-        },
-      ];
-
-      const params = new DyNTS_Endpoint_Params({
-        name: 'testEndpoint',
-        type: DyFM_HttpCallType.get,
-        endpoint: '/test/:userId/:itemId',
-        tasks: tasks,
-      });
-
-      expect(params['pathParams']).toEqual(['userId', 'itemId']);
-    });
-
-    it('| should handle endpoint without path parameters', () => {
-      const tasks = [
-        async (req: Request, res: Response, issuer: string): Promise<void> => {
-          res.send({ success: true });
-        },
-      ];
-
-      const params = new DyNTS_Endpoint_Params({
-        name: 'testEndpoint',
-        type: DyFM_HttpCallType.get,
-        endpoint: '/test',
-        tasks: tasks,
-      });
-
-      expect(params['pathParams']).toEqual([]);
-    });
-
-    it('| should set default logRequest to false', () => {
-      const tasks = [
-        async (req: Request, res: Response, issuer: string): Promise<void> => {
-          res.send({ success: true });
-        },
-      ];
-
-      const params = new DyNTS_Endpoint_Params({
-        name: 'testEndpoint',
-        type: DyFM_HttpCallType.get,
-        endpoint: '/test',
-        tasks: tasks,
-      });
-
-      expect(params['logRequest']).toBe(DyNTS_global_settings.log_settings.request);
-    });
-
-    it('| should use provided logRequest value', () => {
-      const tasks = [
-        async (req: Request, res: Response, issuer: string): Promise<void> => {
-          res.send({ success: true });
-        },
-      ];
-
-      const params = new DyNTS_Endpoint_Params({
-        name: 'testEndpoint',
-        type: DyFM_HttpCallType.get,
-        endpoint: '/test',
-        tasks: tasks,
-        logRequest: true,
-      });
-
-      expect(params['logRequest']).toBe(true);
-    });
-
-    it('| should set default autoResolveCirculation to false', () => {
-      const tasks = [
-        async (req: Request, res: Response, issuer: string): Promise<void> => {
-          res.send({ success: true });
-        },
-      ];
-
-      const params = new DyNTS_Endpoint_Params({
-        name: 'testEndpoint',
-        type: DyFM_HttpCallType.get,
-        endpoint: '/test',
-        tasks: tasks,
-      });
-
-      expect(params['autoResolveCirculation']).toBe(DyNTS_global_settings.autoResolveEndpointCirculationErrors);
-    });
-
-    it('| should set stackLocation', () => {
-      const tasks = [
-        async (req: Request, res: Response, issuer: string): Promise<void> => {
-          res.send({ success: true });
-        },
-      ];
-
-      const params = new DyNTS_Endpoint_Params({
-        name: 'testEndpoint',
-        type: DyFM_HttpCallType.get,
-        endpoint: '/test',
-        tasks: tasks,
-      });
-
-      expect(params.stackLocation).toBeDefined();
-      expect(typeof params.stackLocation).toBe('string');
-    });
-
-    it('| should handle preProcesses', () => {
-      const preProcess = async (req: Request, res: Response): Promise<void> => {
-        // Pre-process logic
-      };
-
-      const tasks = [
-        async (req: Request, res: Response, issuer: string): Promise<void> => {
-          res.send({ success: true });
-        },
-      ];
-
-      const params = new DyNTS_Endpoint_Params({
-        name: 'testEndpoint',
-        type: DyFM_HttpCallType.get,
-        endpoint: '/test',
-        preProcesses: [preProcess],
-        tasks: tasks,
-      });
-
-      expect(params['preProcesses']).toEqual([preProcess]);
-    });
-
-    it('| should throw error when endpoint is not provided', () => {
-      const tasks = [
-        async (req: Request, res: Response, issuer: string): Promise<void> => {
-          res.send({ success: true });
-        },
-      ];
-
-      expect(() => {
-        new DyNTS_Endpoint_Params({
-          name: 'testEndpoint',
-          type: DyFM_HttpCallType.get,
-          endpoint: '',
-          tasks: tasks,
-        });
-      }).toThrow();
-    });
-
-    it('| should set default log settings from global settings', () => {
-      const tasks = [
-        async (req: Request, res: Response, issuer: string): Promise<void> => {
-          res.send({ success: true });
-        },
-      ];
-
-      const params = new DyNTS_Endpoint_Params({
-        name: 'testEndpoint',
-        type: DyFM_HttpCallType.get,
-        endpoint: '/test',
-        tasks: tasks,
-      });
-
-      expect(params['logRequestsParams']).toBe(DyNTS_global_settings.log_settings.requestsParams);
-      expect(params['logRequestsContent']).toBe(DyNTS_global_settings.log_settings.requestsContent);
-      expect(params['logResponseContent']).toBe(DyNTS_global_settings.log_settings.responseContent);
-    });
-
-    it('| should use provided log settings', () => {
-      const tasks = [
-        async (req: Request, res: Response, issuer: string): Promise<void> => {
-          res.send({ success: true });
-        },
-      ];
-
-      const params = new DyNTS_Endpoint_Params({
-        name: 'testEndpoint',
-        type: DyFM_HttpCallType.get,
-        endpoint: '/test',
-        tasks: tasks,
-        logRequestsParams: true,
-        logRequestsContent: true,
-        logResponseContent: true,
-      });
-
-      expect(params['logRequestsParams']).toBe(true);
-      expect(params['logRequestsContent']).toBe(true);
-      expect(params['logResponseContent']).toBe(true);
-    });
-
-    it('| should use endpoint as name when name is not provided', () => {
-      const tasks = [
-        async (req: Request, res: Response, issuer: string): Promise<void> => {
-          res.send({ success: true });
-        },
-      ];
-
-      const params = new DyNTS_Endpoint_Params({
-        name: '/test-endpoint',
-        type: DyFM_HttpCallType.get,
-        endpoint: '/test-endpoint',
-        tasks: tasks,
-      });
-
-      expect(params.name).toBe('/test-endpoint');
-    });
-  });
-
-  describe('| getFullExecution', () => {
-    let mockRequest: Partial<Request>;
-    let mockResponse: Partial<Response>;
-    let sendSpy: jasmine.Spy;
-    let statusSpy: jasmine.Spy;
-
-    beforeEach(() => {
-      mockRequest = {
-        params: {},
-        body: {},
-        originalUrl: '/test',
-      };
-      sendSpy = jasmine.createSpy('send');
-      statusSpy = jasmine.createSpy('status').and.returnValue({ send: sendSpy });
-      mockResponse = {
-        send: sendSpy,
-        status: statusSpy,
-      };
-
-      spyOn(DyNTS_GlobalService, 'getAuthService').and.returnValue({
-        getIssuerFromRequest: () => 'test-issuer',
-      } as any);
-    });
-
-    it('| should execute tasks successfully', async () => {
-      const taskSpy = jasmine.createSpy('task').and.callFake(async (req: Request, res: Response, issuer: string) => {
-        res.send({ success: true });
-      });
-      const params = new DyNTS_Endpoint_Params({
-        name: 'testEndpoint',
-        type: DyFM_HttpCallType.get,
-        endpoint: '/test',
-        tasks: [taskSpy],
-        logRequest: false,
-      });
-
-      const execution = params.getFullExecution();
-      await execution(mockRequest as Request, mockResponse as Response);
-
-      expect(taskSpy).toHaveBeenCalledWith(mockRequest, mockResponse, 'test-issuer');
-      expect(sendSpy).toHaveBeenCalled();
-    });
-
-    it('| should execute preProcesses before tasks', async () => {
-      const preProcessSpy = jasmine.createSpy('preProcess').and.returnValue(Promise.resolve());
-      const taskSpy = jasmine.createSpy('task').and.returnValue(Promise.resolve());
-      const params = new DyNTS_Endpoint_Params({
-        name: 'testEndpoint',
-        type: DyFM_HttpCallType.get,
-        endpoint: '/test',
-        preProcesses: [preProcessSpy],
-        tasks: [taskSpy],
-        logRequest: false,
-      });
-
-      const execution = params.getFullExecution();
-      await execution(mockRequest as Request, mockResponse as Response);
-
-      expect(preProcessSpy).toHaveBeenCalledBefore(taskSpy as any);
-      expect(preProcessSpy).toHaveBeenCalledWith(mockRequest, mockResponse);
-    });
-
-    it('| should handle errors and call error handler', async () => {
-      const error = new Error('Test error');
-      const taskSpy = jasmine.createSpy('task').and.returnValue(Promise.reject(error));
-      const params = new DyNTS_Endpoint_Params({
-        name: 'testEndpoint',
-        type: DyFM_HttpCallType.get,
-        endpoint: '/test',
-        tasks: [taskSpy],
-        logRequest: false,
-      });
-
-      const globalErrorHandlerSpy = jasmine.createSpy('globalErrorHandler').and.returnValue(Promise.resolve());
-      (DyNTS_GlobalService as any).globalErrorHandler = globalErrorHandlerSpy;
-
-      const execution = params.getFullExecution();
-      await execution(mockRequest as Request, mockResponse as Response);
-      // Wait for async error handling to complete (error handler is not awaited in source)
-      await new Promise(resolve => setTimeout(resolve, 50));
-
-      expect(globalErrorHandlerSpy).toHaveBeenCalled();
-      expect(statusSpy).toHaveBeenCalled();
-      expect(statusSpy.calls.mostRecent().args[0]).toBe(501);
-      expect(sendSpy).toHaveBeenCalled();
-    });
-
-    it('| should log request when logRequest is true', async () => {
-      const logInfoSpy = spyOn(DyFM_Log, 'info');
-      const taskSpy = jasmine.createSpy('task').and.returnValue(Promise.resolve());
-      const params = new DyNTS_Endpoint_Params({
-        name: 'testEndpoint',
-        type: DyFM_HttpCallType.get,
-        endpoint: '/test',
-        tasks: [taskSpy],
-        logRequest: true,
-        logRequestsParams: false,
-        logRequestsContent: false,
-      });
-
-      const execution = params.getFullExecution();
-      await execution(mockRequest as Request, mockResponse as Response);
-
-      expect(logInfoSpy).toHaveBeenCalled();
-    });
-
-    it('| should log path params when logRequestsParams is true', async () => {
-      const logInfoSpy = spyOn(DyFM_Log, 'info');
-      mockRequest.params = { userId: '123', itemId: '456' };
-      const taskSpy = jasmine.createSpy('task').and.returnValue(Promise.resolve());
-      const params = new DyNTS_Endpoint_Params({
-        name: 'testEndpoint',
-        type: DyFM_HttpCallType.get,
-        endpoint: '/test/:userId/:itemId',
-        tasks: [taskSpy],
-        logRequest: true,
-        logRequestsParams: true,
-        logRequestsContent: false,
-      });
-
-      const execution = params.getFullExecution();
-      await execution(mockRequest as Request, mockResponse as Response);
-
-      expect(logInfoSpy).toHaveBeenCalled();
-    });
-
-    it('| should log request body when logRequestsContent is true', async () => {
-      const logInfoSpy = spyOn(DyFM_Log, 'info');
-      mockRequest.body = { key: 'value' };
-      const taskSpy = jasmine.createSpy('task').and.returnValue(Promise.resolve());
-      const params = new DyNTS_Endpoint_Params({
-        name: 'testEndpoint',
-        type: DyFM_HttpCallType.get,
-        endpoint: '/test',
-        tasks: [taskSpy],
-        logRequest: true,
-        logRequestsParams: false,
-        logRequestsContent: true,
-      });
-
-      const execution = params.getFullExecution();
-      await execution(mockRequest as Request, mockResponse as Response);
-
-      expect(logInfoSpy).toHaveBeenCalled();
-    });
-
-    it('| should handle issuer retrieval error', async () => {
-      (DyNTS_GlobalService.getAuthService as jasmine.Spy).and.returnValue({
-        getIssuerFromRequest: () => { throw new Error('Auth error'); },
-      } as any);
-      const logWarnSpy = spyOn(DyFM_Log, 'warn');
-      const taskSpy = jasmine.createSpy('task').and.callFake(async (req: Request, res: Response, issuer: string) => {
-        res.send({ success: true });
-      });
-      const params = new DyNTS_Endpoint_Params({
-        name: 'testEndpoint',
-        type: DyFM_HttpCallType.get,
-        endpoint: '/test',
-        tasks: [taskSpy],
-        logRequest: false,
-      });
-
-      const execution = params.getFullExecution();
-      await execution(mockRequest as Request, mockResponse as Response);
-
-      expect(logWarnSpy).toHaveBeenCalled();
-      expect(taskSpy).toHaveBeenCalledWith(mockRequest, mockResponse, 'unknown-issuer');
-    });
-
-    it('| should handle DyFM_Error with status code', async () => {
-      const error = new DyFM_Error({
-        error: new Error('Test error'),
-      });
-      (error as any).___status = 404;
-      const taskSpy = jasmine.createSpy('task').and.returnValue(Promise.reject(error));
-      const params = new DyNTS_Endpoint_Params({
-        name: 'testEndpoint',
-        type: DyFM_HttpCallType.get,
-        endpoint: '/test',
-        tasks: [taskSpy],
-        logRequest: false,
-      });
-
-      const globalErrorHandlerSpy = jasmine.createSpy('globalErrorHandler').and.returnValue(Promise.resolve());
-      (DyNTS_GlobalService as any).globalErrorHandler = globalErrorHandlerSpy;
-
-      const execution = params.getFullExecution();
-      await execution(mockRequest as Request, mockResponse as Response);
-      // Wait for async error handling to complete
-      await new Promise(resolve => setTimeout(resolve, 50));
-
-      expect(statusSpy).toHaveBeenCalled();
-      expect(statusSpy.calls.mostRecent().args[0]).toBe(404);
-      expect(sendSpy).toHaveBeenCalled();
-    });
-
-    it('| should use default status 501 when error has no status', async () => {
-      const error = new Error('Test error');
-      const taskSpy = jasmine.createSpy('task').and.returnValue(Promise.reject(error));
-      const params = new DyNTS_Endpoint_Params({
-        name: 'testEndpoint',
-        type: DyFM_HttpCallType.get,
-        endpoint: '/test',
-        tasks: [taskSpy],
-        logRequest: false,
-      });
-
-      const globalErrorHandlerSpy = jasmine.createSpy('globalErrorHandler').and.returnValue(Promise.resolve());
-      (DyNTS_GlobalService as any).globalErrorHandler = globalErrorHandlerSpy;
-
-      const execution = params.getFullExecution();
-      await execution(mockRequest as Request, mockResponse as Response);
-      // Wait for async error handling to complete
-      await new Promise(resolve => setTimeout(resolve, 50));
-
-      expect(statusSpy).toHaveBeenCalledWith(501);
-      expect(sendSpy).toHaveBeenCalled();
-    });
-
-    it('| should handle production environment error response', async () => {
-      const originalEnv = DyNTS_global_settings.env_settings.environment;
-      DyNTS_global_settings.env_settings.environment = DyFM_EnvironmentFlag.prod;
-      
-      const error = new DyFM_Error({
-        error: new Error('Test error'),
-      });
-      (error as any).___status = 500;
-      error.confidentialContent = { secret: 'value' };
-      error.additionalContent = { debug: 'info' };
-      const taskSpy = jasmine.createSpy('task').and.returnValue(Promise.reject(error));
-      const params = new DyNTS_Endpoint_Params({
-        name: 'testEndpoint',
-        type: DyFM_HttpCallType.get,
-        endpoint: '/test',
-        tasks: [taskSpy],
-        logRequest: false,
-      });
-
-      const globalErrorHandlerSpy = jasmine.createSpy('globalErrorHandler').and.returnValue(Promise.resolve());
-      (DyNTS_GlobalService as any).globalErrorHandler = globalErrorHandlerSpy;
-
-      const execution = params.getFullExecution();
-      await execution(mockRequest as Request, mockResponse as Response);
-      // Wait for async error handling to complete
-      await new Promise(resolve => setTimeout(resolve, 50));
-
-      expect(statusSpy).toHaveBeenCalled();
-      const statusCall = statusSpy.calls.mostRecent();
-      expect(statusCall.args[0]).toBe(500);
-      expect(sendSpy).toHaveBeenCalled();
-      const sentError = sendSpy.calls.mostRecent().args[0] as DyFM_Error;
-      expect(sentError.confidentialContent).toBeUndefined();
-
-      DyNTS_global_settings.env_settings.environment = originalEnv;
-    });
-
-    it('| should handle autoResolveCirculation for non-serializable errors', async () => {
-      const circularError: any = { message: 'Circular error' };
-      circularError.self = circularError;
-      const taskSpy = jasmine.createSpy('task').and.returnValue(Promise.reject(circularError));
-      const params = new DyNTS_Endpoint_Params({
-        name: 'testEndpoint',
-        type: DyFM_HttpCallType.get,
-        endpoint: '/test',
-        tasks: [taskSpy],
-        logRequest: false,
-        autoResolveCirculation: true,
-      });
-
-      const globalErrorHandlerSpy = jasmine.createSpy('globalErrorHandler').and.returnValue(Promise.resolve());
-      (DyNTS_GlobalService as any).globalErrorHandler = globalErrorHandlerSpy;
-
-      const execution = params.getFullExecution();
-      await execution(mockRequest as Request, mockResponse as Response);
-      // Wait for async error handling to complete
-      await new Promise(resolve => setTimeout(resolve, 50));
-
-      expect(statusSpy).toHaveBeenCalled();
-      expect(statusSpy.calls.mostRecent().args[0]).toBe(501);
-      expect(sendSpy).toHaveBeenCalled();
-    });
-  });
-});
-
+
+import { Request, Response } from 'express';
+import { DyFM_HttpCallType, DyFM_Log, DyFM_Error, DyFM_EnvironmentFlag } from '@futdevpro/fsm-dynamo';
+import { DyNTS_Endpoint_Params } from './endpoint-params.control-model';
+import { DyNTS_RouteSecurity } from '../../_enums/route-security.enum';
+import { DyNTS_global_settings } from '../../_collections/global-settings.const';
+import { DyNTS_GlobalService } from '../../_services/core/global.service';
+
+// Skipped: DyFM_Error stack trace causes Jasmine 'split' errors
+describe('| DyNTS_Endpoint_Params', () => {
+  // Ensure env_settings and log_settings exist before tests
+  beforeAll(() => {
+    if (!DyNTS_global_settings.env_settings) {
+      (DyNTS_global_settings as any).env_settings = {
+        environment: DyFM_EnvironmentFlag.local,
+        discord: {},
+        mongoUri: undefined,
+        openAi: {},
+      };
+    } else if (!DyNTS_global_settings.env_settings.environment) {
+      DyNTS_global_settings.env_settings.environment = DyFM_EnvironmentFlag.local;
+    }
+    // Initialize log_settings for error handling tests
+    if (!DyNTS_global_settings.log_settings) {
+      (DyNTS_global_settings as any).log_settings = {
+        highDetailedLogs: false,
+        api_errors: true,
+        requestStackLocation: false,
+      };
+    }
+    // Initialize compactErrorResponse
+    if (DyNTS_global_settings.compactErrorResponse === undefined) {
+      (DyNTS_global_settings as any).compactErrorResponse = false;
+    }
+  });
+
+  describe('| constructor', () => {
+    it('| should create an instance with required parameters', () => {
+      const tasks = [
+        async (req: Request, res: Response, issuer: string): Promise<void> => {
+          res.send({ success: true });
+        },
+      ];
+
+      const params = new DyNTS_Endpoint_Params({
+        name: 'testEndpoint',
+        type: DyFM_HttpCallType.get,
+        endpoint: '/test',
+        tasks: tasks,
+      });
+
+      expect(params.name).toBe('testEndpoint');
+      expect(params.type).toBe(DyFM_HttpCallType.get);
+      expect(params.endpoint).toBe('/test');
+      expect((params as any).tasks).toBe(tasks);
+    });
+
+    it('| should set default security to open', () => {
+      const tasks = [
+        async (req: Request, res: Response, issuer: string): Promise<void> => {
+          res.send({ success: true });
+        },
+      ];
+
+      const params = new DyNTS_Endpoint_Params({
+        name: 'testEndpoint',
+        type: DyFM_HttpCallType.get,
+        endpoint: '/test',
+        tasks: tasks,
+      });
+
+      expect(params.security).toBe(DyNTS_RouteSecurity.open);
+    });
+
+    it('| should use provided security', () => {
+      const tasks = [
+        async (req: Request, res: Response, issuer: string): Promise<void> => {
+          res.send({ success: true });
+        },
+      ];
+
+      const params = new DyNTS_Endpoint_Params({
+        name: 'testEndpoint',
+        type: DyFM_HttpCallType.get,
+        endpoint: '/test',
+        security: DyNTS_RouteSecurity.secure,
+        tasks: tasks,
+      });
+
+      expect(params.security).toBe(DyNTS_RouteSecurity.secure);
+    });
+
+    it('| should extract path parameters from endpoint', () => {
+      const tasks = [
+        async (req: Request, res: Response, issuer: string): Promise<void> => {
+          res.send({ success: true });
+        },
+      ];
+
+      const params = new DyNTS_Endpoint_Params({
+        name: 'testEndpoint',
+        type: DyFM_HttpCallType.get,
+        endpoint: '/test/:userId/:itemId',
+        tasks: tasks,
+      });
+
+      expect(params['pathParams']).toEqual(['userId', 'itemId']);
+    });
+
+    it('| should handle endpoint without path parameters', () => {
+      const tasks = [
+        async (req: Request, res: Response, issuer: string): Promise<void> => {
+          res.send({ success: true });
+        },
+      ];
+
+      const params = new DyNTS_Endpoint_Params({
+        name: 'testEndpoint',
+        type: DyFM_HttpCallType.get,
+        endpoint: '/test',
+        tasks: tasks,
+      });
+
+      expect(params['pathParams']).toEqual([]);
+    });
+
+    it('| should set default logRequest to false', () => {
+      const tasks = [
+        async (req: Request, res: Response, issuer: string): Promise<void> => {
+          res.send({ success: true });
+        },
+      ];
+
+      const params = new DyNTS_Endpoint_Params({
+        name: 'testEndpoint',
+        type: DyFM_HttpCallType.get,
+        endpoint: '/test',
+        tasks: tasks,
+      });
+
+      expect(params['logRequest']).toBe(DyNTS_global_settings.log_settings.request);
+    });
+
+    it('| should use provided logRequest value', () => {
+      const tasks = [
+        async (req: Request, res: Response, issuer: string): Promise<void> => {
+          res.send({ success: true });
+        },
+      ];
+
+      const params = new DyNTS_Endpoint_Params({
+        name: 'testEndpoint',
+        type: DyFM_HttpCallType.get,
+        endpoint: '/test',
+        tasks: tasks,
+        logRequest: true,
+      });
+
+      expect(params['logRequest']).toBe(true);
+    });
+
+    it('| should set default autoResolveCirculation to false', () => {
+      const tasks = [
+        async (req: Request, res: Response, issuer: string): Promise<void> => {
+          res.send({ success: true });
+        },
+      ];
+
+      const params = new DyNTS_Endpoint_Params({
+        name: 'testEndpoint',
+        type: DyFM_HttpCallType.get,
+        endpoint: '/test',
+        tasks: tasks,
+      });
+
+      expect(params['autoResolveCirculation']).toBe(DyNTS_global_settings.autoResolveEndpointCirculationErrors);
+    });
+
+    it('| should set stackLocation', () => {
+      const tasks = [
+        async (req: Request, res: Response, issuer: string): Promise<void> => {
+          res.send({ success: true });
+        },
+      ];
+
+      const params = new DyNTS_Endpoint_Params({
+        name: 'testEndpoint',
+        type: DyFM_HttpCallType.get,
+        endpoint: '/test',
+        tasks: tasks,
+      });
+
+      expect(params.stackLocation).toBeDefined();
+      expect(typeof params.stackLocation).toBe('string');
+    });
+
+    it('| should handle preProcesses', () => {
+      const preProcess = async (req: Request, res: Response): Promise<void> => {
+        // Pre-process logic
+      };
+
+      const tasks = [
+        async (req: Request, res: Response, issuer: string): Promise<void> => {
+          res.send({ success: true });
+        },
+      ];
+
+      const params = new DyNTS_Endpoint_Params({
+        name: 'testEndpoint',
+        type: DyFM_HttpCallType.get,
+        endpoint: '/test',
+        preProcesses: [preProcess],
+        tasks: tasks,
+      });
+
+      expect(params['preProcesses']).toEqual([preProcess]);
+    });
+
+    it('| should throw error when endpoint is not provided', () => {
+      const tasks = [
+        async (req: Request, res: Response, issuer: string): Promise<void> => {
+          res.send({ success: true });
+        },
+      ];
+
+      expect(() => {
+        new DyNTS_Endpoint_Params({
+          name: 'testEndpoint',
+          type: DyFM_HttpCallType.get,
+          endpoint: '',
+          tasks: tasks,
+        });
+      }).toThrow();
+    });
+
+    it('| should set default log settings from global settings', () => {
+      const tasks = [
+        async (req: Request, res: Response, issuer: string): Promise<void> => {
+          res.send({ success: true });
+        },
+      ];
+
+      const params = new DyNTS_Endpoint_Params({
+        name: 'testEndpoint',
+        type: DyFM_HttpCallType.get,
+        endpoint: '/test',
+        tasks: tasks,
+      });
+
+      expect(params['logRequestsParams']).toBe(DyNTS_global_settings.log_settings.requestsParams);
+      expect(params['logRequestsContent']).toBe(DyNTS_global_settings.log_settings.requestsContent);
+      expect(params['logResponseContent']).toBe(DyNTS_global_settings.log_settings.responseContent);
+    });
+
+    it('| should use provided log settings', () => {
+      const tasks = [
+        async (req: Request, res: Response, issuer: string): Promise<void> => {
+          res.send({ success: true });
+        },
+      ];
+
+      const params = new DyNTS_Endpoint_Params({
+        name: 'testEndpoint',
+        type: DyFM_HttpCallType.get,
+        endpoint: '/test',
+        tasks: tasks,
+        logRequestsParams: true,
+        logRequestsContent: true,
+        logResponseContent: true,
+      });
+
+      expect(params['logRequestsParams']).toBe(true);
+      expect(params['logRequestsContent']).toBe(true);
+      expect(params['logResponseContent']).toBe(true);
+    });
+
+    it('| should use endpoint as name when name is not provided', () => {
+      const tasks = [
+        async (req: Request, res: Response, issuer: string): Promise<void> => {
+          res.send({ success: true });
+        },
+      ];
+
+      const params = new DyNTS_Endpoint_Params({
+        name: '/test-endpoint',
+        type: DyFM_HttpCallType.get,
+        endpoint: '/test-endpoint',
+        tasks: tasks,
+      });
+
+      expect(params.name).toBe('/test-endpoint');
+    });
+  });
+
+  describe('| getFullExecution', () => {
+    let mockRequest: Partial<Request>;
+    let mockResponse: Partial<Response>;
+    let sendSpy: jasmine.Spy;
+    let statusSpy: jasmine.Spy;
+
+    beforeEach(() => {
+      mockRequest = {
+        params: {},
+        body: {},
+        originalUrl: '/test',
+      };
+      sendSpy = jasmine.createSpy('send');
+      statusSpy = jasmine.createSpy('status').and.returnValue({ send: sendSpy });
+      mockResponse = {
+        send: sendSpy,
+        status: statusSpy,
+      };
+
+      spyOn(DyNTS_GlobalService, 'getAuthService').and.returnValue({
+        getIssuerFromRequest: () => 'test-issuer',
+      } as any);
+    });
+
+    it('| should execute tasks successfully', async () => {
+      const taskSpy = jasmine.createSpy('task').and.callFake(async (req: Request, res: Response, issuer: string) => {
+        res.send({ success: true });
+      });
+      const params = new DyNTS_Endpoint_Params({
+        name: 'testEndpoint',
+        type: DyFM_HttpCallType.get,
+        endpoint: '/test',
+        tasks: [taskSpy],
+        logRequest: false,
+      });
+
+      const execution = params.getFullExecution();
+      await execution(mockRequest as Request, mockResponse as Response);
+
+      expect(taskSpy).toHaveBeenCalledWith(mockRequest, mockResponse, 'test-issuer');
+      expect(sendSpy).toHaveBeenCalled();
+    });
+
+    it('| should execute preProcesses before tasks', async () => {
+      const preProcessSpy = jasmine.createSpy('preProcess').and.returnValue(Promise.resolve());
+      const taskSpy = jasmine.createSpy('task').and.returnValue(Promise.resolve());
+      const params = new DyNTS_Endpoint_Params({
+        name: 'testEndpoint',
+        type: DyFM_HttpCallType.get,
+        endpoint: '/test',
+        preProcesses: [preProcessSpy],
+        tasks: [taskSpy],
+        logRequest: false,
+      });
+
+      const execution = params.getFullExecution();
+      await execution(mockRequest as Request, mockResponse as Response);
+
+      expect(preProcessSpy).toHaveBeenCalledBefore(taskSpy as any);
+      expect(preProcessSpy).toHaveBeenCalledWith(mockRequest, mockResponse);
+    });
+
+    it('| should handle errors and call error handler', async () => {
+      const error = new Error('Test error');
+      const taskSpy = jasmine.createSpy('task').and.returnValue(Promise.reject(error));
+      const params = new DyNTS_Endpoint_Params({
+        name: 'testEndpoint',
+        type: DyFM_HttpCallType.get,
+        endpoint: '/test',
+        tasks: [taskSpy],
+        logRequest: false,
+      });
+
+      const globalErrorHandlerSpy = jasmine.createSpy('globalErrorHandler').and.returnValue(Promise.resolve());
+      (DyNTS_GlobalService as any).globalErrorHandler = globalErrorHandlerSpy;
+
+      const execution = params.getFullExecution();
+      await execution(mockRequest as Request, mockResponse as Response);
+      // Wait for async error handling to complete (error handler is not awaited in source)
+      await new Promise(resolve => setTimeout(resolve, 50));
+
+      expect(globalErrorHandlerSpy).toHaveBeenCalled();
+      expect(statusSpy).toHaveBeenCalled();
+      expect(statusSpy.calls.mostRecent().args[0]).toBe(500);
+      expect(sendSpy).toHaveBeenCalled();
+    });
+
+    it('| should log request when logRequest is true', async () => {
+      const logInfoSpy = spyOn(DyFM_Log, 'info');
+      const taskSpy = jasmine.createSpy('task').and.returnValue(Promise.resolve());
+      const params = new DyNTS_Endpoint_Params({
+        name: 'testEndpoint',
+        type: DyFM_HttpCallType.get,
+        endpoint: '/test',
+        tasks: [taskSpy],
+        logRequest: true,
+        logRequestsParams: false,
+        logRequestsContent: false,
+      });
+
+      const execution = params.getFullExecution();
+      await execution(mockRequest as Request, mockResponse as Response);
+
+      expect(logInfoSpy).toHaveBeenCalled();
+    });
+
+    it('| should log path params when logRequestsParams is true', async () => {
+      const logInfoSpy = spyOn(DyFM_Log, 'info');
+      mockRequest.params = { userId: '123', itemId: '456' };
+      const taskSpy = jasmine.createSpy('task').and.returnValue(Promise.resolve());
+      const params = new DyNTS_Endpoint_Params({
+        name: 'testEndpoint',
+        type: DyFM_HttpCallType.get,
+        endpoint: '/test/:userId/:itemId',
+        tasks: [taskSpy],
+        logRequest: true,
+        logRequestsParams: true,
+        logRequestsContent: false,
+      });
+
+      const execution = params.getFullExecution();
+      await execution(mockRequest as Request, mockResponse as Response);
+
+      expect(logInfoSpy).toHaveBeenCalled();
+    });
+
+    it('| should log request body when logRequestsContent is true', async () => {
+      const logInfoSpy = spyOn(DyFM_Log, 'info');
+      mockRequest.body = { key: 'value' };
+      const taskSpy = jasmine.createSpy('task').and.returnValue(Promise.resolve());
+      const params = new DyNTS_Endpoint_Params({
+        name: 'testEndpoint',
+        type: DyFM_HttpCallType.get,
+        endpoint: '/test',
+        tasks: [taskSpy],
+        logRequest: true,
+        logRequestsParams: false,
+        logRequestsContent: true,
+      });
+
+      const execution = params.getFullExecution();
+      await execution(mockRequest as Request, mockResponse as Response);
+
+      expect(logInfoSpy).toHaveBeenCalled();
+    });
+
+    it('| should handle issuer retrieval error', async () => {
+      (DyNTS_GlobalService.getAuthService as jasmine.Spy).and.returnValue({
+        getIssuerFromRequest: () => { throw new Error('Auth error'); },
+      } as any);
+      const logWarnSpy = spyOn(DyFM_Log, 'warn');
+      const taskSpy = jasmine.createSpy('task').and.callFake(async (req: Request, res: Response, issuer: string) => {
+        res.send({ success: true });
+      });
+      const params = new DyNTS_Endpoint_Params({
+        name: 'testEndpoint',
+        type: DyFM_HttpCallType.get,
+        endpoint: '/test',
+        tasks: [taskSpy],
+        logRequest: false,
+      });
+
+      const execution = params.getFullExecution();
+      await execution(mockRequest as Request, mockResponse as Response);
+
+      expect(logWarnSpy).toHaveBeenCalled();
+      expect(taskSpy).toHaveBeenCalledWith(mockRequest, mockResponse, 'unknown-issuer');
+    });
+
+    it('| should handle DyFM_Error with status code', async () => {
+      const error = new DyFM_Error({
+        error: new Error('Test error'),
+      });
+      (error as any).___status = 404;
+      const taskSpy = jasmine.createSpy('task').and.returnValue(Promise.reject(error));
+      const params = new DyNTS_Endpoint_Params({
+        name: 'testEndpoint',
+        type: DyFM_HttpCallType.get,
+        endpoint: '/test',
+        tasks: [taskSpy],
+        logRequest: false,
+      });
+
+      const globalErrorHandlerSpy = jasmine.createSpy('globalErrorHandler').and.returnValue(Promise.resolve());
+      (DyNTS_GlobalService as any).globalErrorHandler = globalErrorHandlerSpy;
+
+      const execution = params.getFullExecution();
+      await execution(mockRequest as Request, mockResponse as Response);
+      // Wait for async error handling to complete
+      await new Promise(resolve => setTimeout(resolve, 50));
+
+      expect(statusSpy).toHaveBeenCalled();
+      expect(statusSpy.calls.mostRecent().args[0]).toBe(404);
+      expect(sendSpy).toHaveBeenCalled();
+    });
+
+    it('| should use default status 500 when error has no status', async () => {
+      const error = new Error('Test error');
+      const taskSpy = jasmine.createSpy('task').and.returnValue(Promise.reject(error));
+      const params = new DyNTS_Endpoint_Params({
+        name: 'testEndpoint',
+        type: DyFM_HttpCallType.get,
+        endpoint: '/test',
+        tasks: [taskSpy],
+        logRequest: false,
+      });
+
+      const globalErrorHandlerSpy = jasmine.createSpy('globalErrorHandler').and.returnValue(Promise.resolve());
+      (DyNTS_GlobalService as any).globalErrorHandler = globalErrorHandlerSpy;
+
+      const execution = params.getFullExecution();
+      await execution(mockRequest as Request, mockResponse as Response);
+      // Wait for async error handling to complete
+      await new Promise(resolve => setTimeout(resolve, 50));
+
+      expect(statusSpy).toHaveBeenCalledWith(500);
+      expect(sendSpy).toHaveBeenCalled();
+    });
+
+    it('| should handle production environment error response', async () => {
+      const originalEnv = DyNTS_global_settings.env_settings.environment;
+      DyNTS_global_settings.env_settings.environment = DyFM_EnvironmentFlag.prod;
+      
+      const error = new DyFM_Error({
+        error: new Error('Test error'),
+      });
+      (error as any).___status = 500;
+      error.confidentialContent = { secret: 'value' };
+      error.additionalContent = { debug: 'info' };
+      const taskSpy = jasmine.createSpy('task').and.returnValue(Promise.reject(error));
+      const params = new DyNTS_Endpoint_Params({
+        name: 'testEndpoint',
+        type: DyFM_HttpCallType.get,
+        endpoint: '/test',
+        tasks: [taskSpy],
+        logRequest: false,
+      });
+
+      const globalErrorHandlerSpy = jasmine.createSpy('globalErrorHandler').and.returnValue(Promise.resolve());
+      (DyNTS_GlobalService as any).globalErrorHandler = globalErrorHandlerSpy;
+
+      const execution = params.getFullExecution();
+      await execution(mockRequest as Request, mockResponse as Response);
+      // Wait for async error handling to complete
+      await new Promise(resolve => setTimeout(resolve, 50));
+
+      expect(statusSpy).toHaveBeenCalled();
+      const statusCall = statusSpy.calls.mostRecent();
+      expect(statusCall.args[0]).toBe(500);
+      expect(sendSpy).toHaveBeenCalled();
+      const sentError = sendSpy.calls.mostRecent().args[0] as DyFM_Error;
+      expect(sentError.confidentialContent).toBeUndefined();
+
+      DyNTS_global_settings.env_settings.environment = originalEnv;
+    });
+
+    it('| should handle autoResolveCirculation for non-serializable errors', async () => {
+      const circularError: any = { message: 'Circular error' };
+      circularError.self = circularError;
+      const taskSpy = jasmine.createSpy('task').and.returnValue(Promise.reject(circularError));
+      const params = new DyNTS_Endpoint_Params({
+        name: 'testEndpoint',
+        type: DyFM_HttpCallType.get,
+        endpoint: '/test',
+        tasks: [taskSpy],
+        logRequest: false,
+        autoResolveCirculation: true,
+      });
+
+      const globalErrorHandlerSpy = jasmine.createSpy('globalErrorHandler').and.returnValue(Promise.resolve());
+      (DyNTS_GlobalService as any).globalErrorHandler = globalErrorHandlerSpy;
+
+      const execution = params.getFullExecution();
+      await execution(mockRequest as Request, mockResponse as Response);
+      // Wait for async error handling to complete
+      await new Promise(resolve => setTimeout(resolve, 50));
+
+      expect(statusSpy).toHaveBeenCalled();
+      expect(statusSpy.calls.mostRecent().args[0]).toBe(500);
+      expect(sendSpy).toHaveBeenCalled();
+    });
+  });
+});
+