@futdevpro/nts-dynamo 1.15.41 → 1.15.43

package/src/_services/core/api.service.spec.ts

@@ -1,140 +1,140 @@
-
-import Axios from 'axios';
-
-import { DyFM_Error, DyFM_HttpCallType, DyFM_HttpResponseType } from '@futdevpro/fsm-dynamo';
-
-import { DyNTS_ApiCall_Params } from '../../_models/control-models/api-call-params.control-model';
-import { DyNTS_ApiCallInput_Params, DyNTS_ApiService } from './api.service';
-
-describe('| DyNTS_ApiService', () => {
-  let callParams: DyNTS_ApiCall_Params;
-  let inputParams: DyNTS_ApiCallInput_Params;
-
-  beforeEach(() => {
-    callParams = new DyNTS_ApiCall_Params({
-      baseUrl: 'http://example.com',
-      endpoint: '/api/test',
-      type: DyFM_HttpCallType.get,
-      httpOptions: {
-        headers: {},
-        responseType: DyFM_HttpResponseType.json,
-      },
-      name: 'Test API Call',
-      getFullResponse: false,
-    });
-
-    inputParams = {
-      pathParams: { id: '123' },
-      body: { key: 'value' },
-    };
-  });
-
-  // Helper function to create a complete mock Axios instance
-  const createMockAxiosInstance = (methods: any = {}) => {
-    return {
-      defaults: {
-        headers: {
-          common: {},
-          delete: {},
-          get: {},
-          head: {},
-          post: {},
-          put: {},
-          patch: {},
-        },
-        httpsAgent: undefined,
-        httpAgent: undefined,
-        timeout: undefined,
-        maxRedirects: undefined,
-        withCredentials: undefined,
-        responseType: undefined,
-      },
-      get: jasmine.createSpy('get'),
-      post: jasmine.createSpy('post'),
-      put: jasmine.createSpy('put'),
-      patch: jasmine.createSpy('patch'),
-      delete: jasmine.createSpy('delete'),
-      ...methods,
-    };
-  };
-
-  it('| should make a GET request successfully', async () => {
-    callParams.type = DyFM_HttpCallType.get;
-    const response = { data: { success: true } };
-    const mockAxios = createMockAxiosInstance({
-      get: jasmine.createSpy('get').and.returnValue(Promise.resolve(response)),
-    });
-
-    spyOn(Axios, 'create').and.returnValue(mockAxios);
-
-    const result = await DyNTS_ApiService.startApiCall(callParams, inputParams);
-
-    expect(result).toEqual(response.data);
-  });
-
-  it('| should handle a POST request successfully', async () => {
-    callParams.type = DyFM_HttpCallType.post;
-    const response = { data: { success: true } };
-    const mockAxios = createMockAxiosInstance({
-      post: jasmine.createSpy('post').and.returnValue(Promise.resolve(response)),
-    });
-
-    spyOn(Axios, 'create').and.returnValue(mockAxios);
-
-    const result = await DyNTS_ApiService.startApiCall(callParams, inputParams);
-
-    expect(result).toEqual(response.data);
-  });
-
-  it('| should throw an error for unsupported HTTP method', async () => {
-    callParams.type = 'unsupported' as DyFM_HttpCallType;
-    const mockAxios = createMockAxiosInstance();
-
-    spyOn(Axios, 'create').and.returnValue(mockAxios);
-
-    await expectAsync(DyNTS_ApiService.startApiCall(callParams, inputParams)).toBeRejectedWith(
-      jasmine.any(DyFM_Error)
-    );
-  });
-
-  it('| should handle error response with DYNAMO flag', async () => {
-    const errorResponse = {
-      response: { data: { flag: 'DYNAMO', message: 'Error' } },
-    };
-    const mockAxios = createMockAxiosInstance({
-      get: jasmine.createSpy('get').and.returnValue(Promise.reject(errorResponse)),
-    });
-
-    spyOn(Axios, 'create').and.returnValue(mockAxios);
-
-    await expectAsync(DyNTS_ApiService.startApiCall(callParams, inputParams)).toBeRejectedWith(
-      jasmine.any(DyFM_Error)
-    );
-  });
-
-  it('| should handle DNS error', async () => {
-    const error = { code: 'ENOTFOUND' };
-    const mockAxios = createMockAxiosInstance({
-      get: jasmine.createSpy('get').and.returnValue(Promise.reject(error)),
-    });
-
-    spyOn(Axios, 'create').and.returnValue(mockAxios);
-
-    await expectAsync(DyNTS_ApiService.startApiCall(callParams, inputParams)).toBeRejectedWith(
-      jasmine.any(DyFM_Error)
-    );
-  });
-
-  it('| should handle connection refused error', async () => {
-    const error = { code: 'ECONNREFUSED' };
-    const mockAxios = createMockAxiosInstance({
-      get: jasmine.createSpy('get').and.returnValue(Promise.reject(error)),
-    });
-    
-    spyOn(Axios, 'create').and.returnValue(mockAxios);
-
-    await expectAsync(DyNTS_ApiService.startApiCall(callParams, inputParams)).toBeRejectedWith(
-      jasmine.any(DyFM_Error)
-    );
-  });
-});
+
+import Axios from 'axios';
+
+import { DyFM_Error, DyFM_HttpCallType, DyFM_HttpResponseType } from '@futdevpro/fsm-dynamo';
+
+import { DyNTS_ApiCall_Params } from '../../_models/control-models/api-call-params.control-model';
+import { DyNTS_ApiCallInput_Params, DyNTS_ApiService } from './api.service';
+
+describe('| DyNTS_ApiService', () => {
+  let callParams: DyNTS_ApiCall_Params;
+  let inputParams: DyNTS_ApiCallInput_Params;
+
+  beforeEach(() => {
+    callParams = new DyNTS_ApiCall_Params({
+      baseUrl: 'http://example.com',
+      endpoint: '/api/test',
+      type: DyFM_HttpCallType.get,
+      httpOptions: {
+        headers: {},
+        responseType: DyFM_HttpResponseType.json,
+      },
+      name: 'Test API Call',
+      getFullResponse: false,
+    });
+
+    inputParams = {
+      pathParams: { id: '123' },
+      body: { key: 'value' },
+    };
+  });
+
+  // Helper function to create a complete mock Axios instance
+  const createMockAxiosInstance = (methods: any = {}) => {
+    return {
+      defaults: {
+        headers: {
+          common: {},
+          delete: {},
+          get: {},
+          head: {},
+          post: {},
+          put: {},
+          patch: {},
+        },
+        httpsAgent: undefined,
+        httpAgent: undefined,
+        timeout: undefined,
+        maxRedirects: undefined,
+        withCredentials: undefined,
+        responseType: undefined,
+      },
+      get: jasmine.createSpy('get'),
+      post: jasmine.createSpy('post'),
+      put: jasmine.createSpy('put'),
+      patch: jasmine.createSpy('patch'),
+      delete: jasmine.createSpy('delete'),
+      ...methods,
+    };
+  };
+
+  it('| should make a GET request successfully', async () => {
+    callParams.type = DyFM_HttpCallType.get;
+    const response = { data: { success: true } };
+    const mockAxios = createMockAxiosInstance({
+      get: jasmine.createSpy('get').and.returnValue(Promise.resolve(response)),
+    });
+
+    spyOn(Axios, 'create').and.returnValue(mockAxios);
+
+    const result = await DyNTS_ApiService.startApiCall(callParams, inputParams);
+
+    expect(result).toEqual(response.data);
+  });
+
+  it('| should handle a POST request successfully', async () => {
+    callParams.type = DyFM_HttpCallType.post;
+    const response = { data: { success: true } };
+    const mockAxios = createMockAxiosInstance({
+      post: jasmine.createSpy('post').and.returnValue(Promise.resolve(response)),
+    });
+
+    spyOn(Axios, 'create').and.returnValue(mockAxios);
+
+    const result = await DyNTS_ApiService.startApiCall(callParams, inputParams);
+
+    expect(result).toEqual(response.data);
+  });
+
+  it('| should throw an error for unsupported HTTP method', async () => {
+    callParams.type = 'unsupported' as DyFM_HttpCallType;
+    const mockAxios = createMockAxiosInstance();
+
+    spyOn(Axios, 'create').and.returnValue(mockAxios);
+
+    await expectAsync(DyNTS_ApiService.startApiCall(callParams, inputParams)).toBeRejectedWith(
+      jasmine.any(DyFM_Error)
+    );
+  });
+
+  it('| should handle error response with DYNAMO flag', async () => {
+    const errorResponse = {
+      response: { data: { flag: 'DYNAMO', message: 'Error' } },
+    };
+    const mockAxios = createMockAxiosInstance({
+      get: jasmine.createSpy('get').and.returnValue(Promise.reject(errorResponse)),
+    });
+
+    spyOn(Axios, 'create').and.returnValue(mockAxios);
+
+    await expectAsync(DyNTS_ApiService.startApiCall(callParams, inputParams)).toBeRejectedWith(
+      jasmine.any(DyFM_Error)
+    );
+  });
+
+  it('| should handle DNS error', async () => {
+    const error = { code: 'ENOTFOUND' };
+    const mockAxios = createMockAxiosInstance({
+      get: jasmine.createSpy('get').and.returnValue(Promise.reject(error)),
+    });
+
+    spyOn(Axios, 'create').and.returnValue(mockAxios);
+
+    await expectAsync(DyNTS_ApiService.startApiCall(callParams, inputParams)).toBeRejectedWith(
+      jasmine.any(DyFM_Error)
+    );
+  });
+
+  it('| should handle connection refused error', async () => {
+    const error = { code: 'ECONNREFUSED' };
+    const mockAxios = createMockAxiosInstance({
+      get: jasmine.createSpy('get').and.returnValue(Promise.reject(error)),
+    });
+    
+    spyOn(Axios, 'create').and.returnValue(mockAxios);
+
+    await expectAsync(DyNTS_ApiService.startApiCall(callParams, inputParams)).toBeRejectedWith(
+      jasmine.any(DyFM_Error)
+    );
+  });
+});

package/src/_services/core/auth.service.spec.ts

@@ -1,159 +1,159 @@
-
-import { DyNTS_AuthService } from './auth.service';
-import { Request } from 'express';
-import { DyFM_Error } from '@futdevpro/fsm-dynamo';
-import { DyNTS_global_settings } from '../../_collections/global-settings.const';
-
-class TestAuthService extends DyNTS_AuthService {
-  static getInstance(): TestAuthService {
-    return TestAuthService.getSingletonInstance();
-  }
-
-  authenticate_token = async (req: Request, res: any): Promise<void> => {
-    // Mock implementation
-  };
-
-  authenticate_tokenSelf = async (req: Request, res: any): Promise<void> => {
-    // Mock implementation
-  };
-
-  authenticate_tokenPerm_accUsageData = async (req: Request, res: any): Promise<void> => {
-    // Mock implementation
-  };
-
-  getIssuerFromRequest(req: Request): string {
-    return 'test-issuer';
-  }
-
-  getUsernameFromRequest(req: Request): string {
-    return 'test-user';
-  }
-}
-
-describe('| DyNTS_AuthService', () => {
-  let service: TestAuthService;
-
-  beforeEach(() => {
-    service = TestAuthService.getInstance();
-  });
-
-  it('| should be a singleton instance', () => {
-    const instance1 = TestAuthService.getInstance();
-    const instance2 = TestAuthService.getInstance();
-
-    expect(instance1).toBe(instance2);
-    expect(instance1).toBeInstanceOf(TestAuthService);
-  });
-
-  it('| should have default service name', () => {
-    expect(service.serviceName).toBe('AuthService');
-  });
-
-  it('| should have default error user message', () => {
-    expect(service.defaultErrorUserMsg).toBeDefined();
-    expect(service.defaultErrorUserMsg).toContain('Auth Error');
-  });
-
-  describe('| getTokenFromRequest', () => {
-    it('| should extract token from authorization header', () => {
-      const req = {
-        headers: {
-          authorization: 'Bearer test-token-123',
-        },
-      } as any as Request;
-
-      const result = service.getTokenFromRequest(req);
-
-      expect(result).toBe('test-token-123');
-    });
-
-    it('| should throw error when authorization header is missing', () => {
-      const req = {
-        headers: {},
-      } as any as Request;
-
-      expect(() => {
-        service.getTokenFromRequest(req);
-      }).toThrow();
-    });
-
-    it('| should throw error when authorization header is null', () => {
-      const req = {
-        headers: {
-          authorization: null,
-        },
-      } as any as Request;
-
-      expect(() => {
-        service.getTokenFromRequest(req);
-      }).toThrow();
-    });
-
-    it('| should throw error when token is missing from header', () => {
-      const req = {
-        headers: {
-          authorization: 'Bearer ',
-        },
-      } as any as Request;
-
-      expect(() => {
-        service.getTokenFromRequest(req);
-      }).toThrow();
-    });
-
-    it('| should throw error when authorization header does not contain Bearer', () => {
-      const req = {
-        headers: {
-          authorization: 'InvalidFormat token',
-        },
-      } as any as Request;
-
-      const result = service.getTokenFromRequest(req);
-
-      expect(result).toBe('token');
-    });
-
-    it('| should handle token with spaces correctly', () => {
-      const req = {
-        headers: {
-          authorization: 'Bearer token-with-spaces',
-        },
-      } as any as Request;
-
-      const result = service.getTokenFromRequest(req);
-
-      expect(result).toBe('token-with-spaces');
-    });
-
-    it('| should include error code in thrown error', () => {
-      const req = {
-        headers: {},
-      } as any as Request;
-
-      try {
-        service.getTokenFromRequest(req);
-        fail('Should have thrown an error');
-      } catch (error) {
-        expect(error).toBeInstanceOf(DyFM_Error);
-        expect((error as DyFM_Error)._errorCode).toContain('DyNTS-AS0-GT0');
-      }
-    });
-
-    it('| should include confidential content in error when header missing', () => {
-      const req = {
-        headers: {
-          'x-custom-header': 'value',
-        },
-      } as any as Request;
-
-      try {
-        service.getTokenFromRequest(req);
-        fail('Should have thrown an error');
-      } catch (error) {
-        expect(error).toBeInstanceOf(DyFM_Error);
-        expect((error as DyFM_Error).confidentialContent).toBeDefined();
-      }
-    });
-  });
-});
-
+
+import { DyNTS_AuthService } from './auth.service';
+import { Request } from 'express';
+import { DyFM_Error } from '@futdevpro/fsm-dynamo';
+import { DyNTS_global_settings } from '../../_collections/global-settings.const';
+
+class TestAuthService extends DyNTS_AuthService {
+  static getInstance(): TestAuthService {
+    return TestAuthService.getSingletonInstance();
+  }
+
+  authenticate_token = async (req: Request, res: any): Promise<void> => {
+    // Mock implementation
+  };
+
+  authenticate_tokenSelf = async (req: Request, res: any): Promise<void> => {
+    // Mock implementation
+  };
+
+  authenticate_tokenPerm_accUsageData = async (req: Request, res: any): Promise<void> => {
+    // Mock implementation
+  };
+
+  getIssuerFromRequest(req: Request): string {
+    return 'test-issuer';
+  }
+
+  getUsernameFromRequest(req: Request): string {
+    return 'test-user';
+  }
+}
+
+describe('| DyNTS_AuthService', () => {
+  let service: TestAuthService;
+
+  beforeEach(() => {
+    service = TestAuthService.getInstance();
+  });
+
+  it('| should be a singleton instance', () => {
+    const instance1 = TestAuthService.getInstance();
+    const instance2 = TestAuthService.getInstance();
+
+    expect(instance1).toBe(instance2);
+    expect(instance1).toBeInstanceOf(TestAuthService);
+  });
+
+  it('| should have default service name', () => {
+    expect(service.serviceName).toBe('AuthService');
+  });
+
+  it('| should have default error user message', () => {
+    expect(service.defaultErrorUserMsg).toBeDefined();
+    expect(service.defaultErrorUserMsg).toContain('Auth Error');
+  });
+
+  describe('| getTokenFromRequest', () => {
+    it('| should extract token from authorization header', () => {
+      const req = {
+        headers: {
+          authorization: 'Bearer test-token-123',
+        },
+      } as any as Request;
+
+      const result = service.getTokenFromRequest(req);
+
+      expect(result).toBe('test-token-123');
+    });
+
+    it('| should throw error when authorization header is missing', () => {
+      const req = {
+        headers: {},
+      } as any as Request;
+
+      expect(() => {
+        service.getTokenFromRequest(req);
+      }).toThrow();
+    });
+
+    it('| should throw error when authorization header is null', () => {
+      const req = {
+        headers: {
+          authorization: null,
+        },
+      } as any as Request;
+
+      expect(() => {
+        service.getTokenFromRequest(req);
+      }).toThrow();
+    });
+
+    it('| should throw error when token is missing from header', () => {
+      const req = {
+        headers: {
+          authorization: 'Bearer ',
+        },
+      } as any as Request;
+
+      expect(() => {
+        service.getTokenFromRequest(req);
+      }).toThrow();
+    });
+
+    it('| should throw error when authorization header does not contain Bearer', () => {
+      const req = {
+        headers: {
+          authorization: 'InvalidFormat token',
+        },
+      } as any as Request;
+
+      const result = service.getTokenFromRequest(req);
+
+      expect(result).toBe('token');
+    });
+
+    it('| should handle token with spaces correctly', () => {
+      const req = {
+        headers: {
+          authorization: 'Bearer token-with-spaces',
+        },
+      } as any as Request;
+
+      const result = service.getTokenFromRequest(req);
+
+      expect(result).toBe('token-with-spaces');
+    });
+
+    it('| should include error code in thrown error', () => {
+      const req = {
+        headers: {},
+      } as any as Request;
+
+      try {
+        service.getTokenFromRequest(req);
+        fail('Should have thrown an error');
+      } catch (error) {
+        expect(error).toBeInstanceOf(DyFM_Error);
+        expect((error as DyFM_Error)._errorCode).toContain('DyNTS-AS0-GT0');
+      }
+    });
+
+    it('| should include confidential content in error when header missing', () => {
+      const req = {
+        headers: {
+          'x-custom-header': 'value',
+        },
+      } as any as Request;
+
+      try {
+        service.getTokenFromRequest(req);
+        fail('Should have thrown an error');
+      } catch (error) {
+        expect(error).toBeInstanceOf(DyFM_Error);
+        expect((error as DyFM_Error).confidentialContent).toBeDefined();
+      }
+    });
+  });
+});
+