@futdevpro/nts-dynamo 1.15.40 → 1.15.41

package/src/_collections/star.controller.spec.ts

@@ -1,224 +1,224 @@
-
-import { DyNTS_Star_Controller, DyNTS_getStarRoute } from './star.controller';
-import { DyFM_HttpCallType, DyFM_Error } from '@futdevpro/fsm-dynamo';
-import { DyNTS_RoutingModule } from '../_services/route/routing-module.service';
-
-describe('| DyNTS_Star_Controller', () => {
-  let controller: DyNTS_Star_Controller;
-
-  beforeEach(() => {
-    controller = DyNTS_Star_Controller.getInstance();
-  });
-
-  it('| should be a singleton instance', () => {
-    const instance1 = DyNTS_Star_Controller.getInstance();
-    const instance2 = DyNTS_Star_Controller.getInstance();
-
-    expect(instance1).toBe(instance2);
-    expect(instance1).toBeInstanceOf(DyNTS_Star_Controller);
-  });
-
-  describe('| setupEndpoints', () => {
-    it('| should setup all default endpoints', () => {
-      controller.setupEndpoints();
-
-      expect(controller.endpoints).toBeDefined();
-      expect(controller.endpoints.length).toBe(5);
-    });
-
-    it('| should setup defaultGet endpoint', () => {
-      controller.setupEndpoints();
-
-      const defaultGetEndpoint = controller.endpoints.find(ep => ep.name === 'defaultGet');
-      expect(defaultGetEndpoint).toBeDefined();
-      expect(defaultGetEndpoint?.type).toBe(DyFM_HttpCallType.get);
-      expect(defaultGetEndpoint?.endpoint).toBe('/*');
-      expect((defaultGetEndpoint as any)?.tasks).toBeDefined();
-      expect((defaultGetEndpoint as any)?.tasks?.length).toBe(1);
-    });
-
-    it('| should setup defaultPost endpoint', () => {
-      controller.setupEndpoints();
-
-      const defaultPostEndpoint = controller.endpoints.find(ep => ep.name === 'defaultPost');
-      expect(defaultPostEndpoint).toBeDefined();
-      expect(defaultPostEndpoint?.type).toBe(DyFM_HttpCallType.post);
-      expect(defaultPostEndpoint?.endpoint).toBe('/*');
-      expect((defaultPostEndpoint as any)?.tasks).toBeDefined();
-      expect((defaultPostEndpoint as any)?.tasks?.length).toBe(1);
-    });
-
-    it('| should setup defaultPut endpoint', () => {
-      controller.setupEndpoints();
-
-      const defaultPutEndpoint = controller.endpoints.find(ep => ep.name === 'defaultPut');
-      expect(defaultPutEndpoint).toBeDefined();
-      expect(defaultPutEndpoint?.type).toBe(DyFM_HttpCallType.put);
-      expect(defaultPutEndpoint?.endpoint).toBe('/*');
-      expect((defaultPutEndpoint as any)?.tasks).toBeDefined();
-      expect((defaultPutEndpoint as any)?.tasks?.length).toBe(1);
-    });
-
-    it('| should setup defaultPatch endpoint', () => {
-      controller.setupEndpoints();
-
-      const defaultPatchEndpoint = controller.endpoints.find(ep => ep.name === 'defaultPatch');
-      expect(defaultPatchEndpoint).toBeDefined();
-      expect(defaultPatchEndpoint?.type).toBe(DyFM_HttpCallType.patch);
-      expect(defaultPatchEndpoint?.endpoint).toBe('/*');
-      expect((defaultPatchEndpoint as any)?.tasks).toBeDefined();
-      expect((defaultPatchEndpoint as any)?.tasks?.length).toBe(1);
-    });
-
-    it('| should setup defaultDelete endpoint', () => {
-      controller.setupEndpoints();
-
-      const defaultDeleteEndpoint = controller.endpoints.find(ep => ep.name === 'defaultDelete');
-      expect(defaultDeleteEndpoint).toBeDefined();
-      expect(defaultDeleteEndpoint?.type).toBe(DyFM_HttpCallType.delete);
-      expect(defaultDeleteEndpoint?.endpoint).toBe('/*');
-      expect((defaultDeleteEndpoint as any)?.tasks).toBeDefined();
-      expect((defaultDeleteEndpoint as any)?.tasks?.length).toBe(1);
-    });
-  });
-
-  describe('| DyNTS_getStarRoute', () => {
-    it('| should return routing module', () => {
-      const routingModule = DyNTS_getStarRoute();
-
-      expect(routingModule).toBeInstanceOf(DyNTS_RoutingModule);
-      // The route might be modified by RoutingModule, check if it contains /**
-      expect(routingModule.route).toContain('**');
-      expect((routingModule as any).controllers).toBeDefined();
-      expect((routingModule as any).controllers.length).toBe(1);
-      expect((routingModule as any).controllers[0]).toBeInstanceOf(DyNTS_Star_Controller);
-    });
-
-    it('| should return routing module with correct route', () => {
-      const routingModule = DyNTS_getStarRoute();
-      expect(routingModule.route).toBe('/api/**');
-    });
-  });
-
-  describe('| endpoint tasks', () => {
-    it('| should throw 404 error for defaultGet endpoint', async () => {
-      controller.setupEndpoints();
-      const defaultGetEndpoint = controller.endpoints.find(ep => ep.name === 'defaultGet');
-      expect(defaultGetEndpoint).toBeDefined();
-
-      const mockReq = {
-        originalUrl: '/test-route',
-      } as any;
-      const mockRes = {} as any;
-
-      try {
-        await (defaultGetEndpoint as any).tasks[0](mockReq, mockRes, 'test-issuer');
-        fail('Should have thrown an error');
-      } catch (error) {
-        expect(error).toBeInstanceOf(DyFM_Error);
-        expect((error as DyFM_Error).___status).toBe(404);
-        expect((error as DyFM_Error)._errorCode).toContain('DyNTS-RMS-G404');
-      }
-    });
-
-    it('| should throw 404 error for defaultPost endpoint', async () => {
-      controller.setupEndpoints();
-      const defaultPostEndpoint = controller.endpoints.find(ep => ep.name === 'defaultPost');
-      expect(defaultPostEndpoint).toBeDefined();
-
-      const mockReq = {
-        originalUrl: '/test-route',
-      } as any;
-      const mockRes = {} as any;
-
-      try {
-        await (defaultPostEndpoint as any).tasks[0](mockReq, mockRes, 'test-issuer');
-        fail('Should have thrown an error');
-      } catch (error) {
-        expect(error).toBeInstanceOf(DyFM_Error);
-        expect((error as DyFM_Error).___status).toBe(404);
-        expect((error as DyFM_Error)._errorCode).toContain('DyNTS-RMS-PO404');
-      }
-    });
-
-    it('| should throw 404 error for defaultPut endpoint', async () => {
-      controller.setupEndpoints();
-      const defaultPutEndpoint = controller.endpoints.find(ep => ep.name === 'defaultPut');
-      expect(defaultPutEndpoint).toBeDefined();
-
-      const mockReq = {
-        originalUrl: '/test-route',
-      } as any;
-      const mockRes = {} as any;
-
-      try {
-        await (defaultPutEndpoint as any).tasks[0](mockReq, mockRes, 'test-issuer');
-        fail('Should have thrown an error');
-      } catch (error) {
-        expect(error).toBeInstanceOf(DyFM_Error);
-        expect((error as DyFM_Error).___status).toBe(404);
-        expect((error as DyFM_Error)._errorCode).toContain('DyNTS-RMS-PU404');
-      }
-    });
-
-    it('| should throw 404 error for defaultPatch endpoint', async () => {
-      controller.setupEndpoints();
-      const defaultPatchEndpoint = controller.endpoints.find(ep => ep.name === 'defaultPatch');
-      expect(defaultPatchEndpoint).toBeDefined();
-
-      const mockReq = {
-        originalUrl: '/test-route',
-      } as any;
-      const mockRes = {} as any;
-
-      try {
-        await (defaultPatchEndpoint as any).tasks[0](mockReq, mockRes, 'test-issuer');
-        fail('Should have thrown an error');
-      } catch (error) {
-        expect(error).toBeInstanceOf(DyFM_Error);
-        expect((error as DyFM_Error).___status).toBe(404);
-        expect((error as DyFM_Error)._errorCode).toContain('DyNTS-RMS-PA404');
-      }
-    });
-
-    it('| should throw 404 error for defaultDelete endpoint', async () => {
-      controller.setupEndpoints();
-      const defaultDeleteEndpoint = controller.endpoints.find(ep => ep.name === 'defaultDelete');
-      expect(defaultDeleteEndpoint).toBeDefined();
-
-      const mockReq = {
-        originalUrl: '/test-route',
-      } as any;
-      const mockRes = {} as any;
-
-      try {
-        await (defaultDeleteEndpoint as any).tasks[0](mockReq, mockRes, 'test-issuer');
-        fail('Should have thrown an error');
-      } catch (error) {
-        expect(error).toBeInstanceOf(DyFM_Error);
-        expect((error as DyFM_Error).___status).toBe(404);
-        expect((error as DyFM_Error)._errorCode).toContain('DyNTS-RMS-D404');
-      }
-    });
-
-    it('| should include originalUrl in error message', async () => {
-      controller.setupEndpoints();
-      const defaultGetEndpoint = controller.endpoints.find(ep => ep.name === 'defaultGet');
-      expect(defaultGetEndpoint).toBeDefined();
-
-      const mockReq = {
-        originalUrl: '/custom-route',
-      } as any;
-      const mockRes = {} as any;
-
-      try {
-        await (defaultGetEndpoint as any).tasks[0](mockReq, mockRes, 'test-issuer');
-        fail('Should have thrown an error');
-      } catch (error) {
-        expect(error).toBeInstanceOf(DyFM_Error);
-        expect((error as DyFM_Error)._message).toContain('/custom-route');
-      }
-    });
-  });
-});
-
+
+import { DyNTS_Star_Controller, DyNTS_getStarRoute } from './star.controller';
+import { DyFM_HttpCallType, DyFM_Error } from '@futdevpro/fsm-dynamo';
+import { DyNTS_RoutingModule } from '../_services/route/routing-module.service';
+
+describe('| DyNTS_Star_Controller', () => {
+  let controller: DyNTS_Star_Controller;
+
+  beforeEach(() => {
+    controller = DyNTS_Star_Controller.getInstance();
+  });
+
+  it('| should be a singleton instance', () => {
+    const instance1 = DyNTS_Star_Controller.getInstance();
+    const instance2 = DyNTS_Star_Controller.getInstance();
+
+    expect(instance1).toBe(instance2);
+    expect(instance1).toBeInstanceOf(DyNTS_Star_Controller);
+  });
+
+  describe('| setupEndpoints', () => {
+    it('| should setup all default endpoints', () => {
+      controller.setupEndpoints();
+
+      expect(controller.endpoints).toBeDefined();
+      expect(controller.endpoints.length).toBe(5);
+    });
+
+    it('| should setup defaultGet endpoint', () => {
+      controller.setupEndpoints();
+
+      const defaultGetEndpoint = controller.endpoints.find(ep => ep.name === 'defaultGet');
+      expect(defaultGetEndpoint).toBeDefined();
+      expect(defaultGetEndpoint?.type).toBe(DyFM_HttpCallType.get);
+      expect(defaultGetEndpoint?.endpoint).toBe('/*');
+      expect((defaultGetEndpoint as any)?.tasks).toBeDefined();
+      expect((defaultGetEndpoint as any)?.tasks?.length).toBe(1);
+    });
+
+    it('| should setup defaultPost endpoint', () => {
+      controller.setupEndpoints();
+
+      const defaultPostEndpoint = controller.endpoints.find(ep => ep.name === 'defaultPost');
+      expect(defaultPostEndpoint).toBeDefined();
+      expect(defaultPostEndpoint?.type).toBe(DyFM_HttpCallType.post);
+      expect(defaultPostEndpoint?.endpoint).toBe('/*');
+      expect((defaultPostEndpoint as any)?.tasks).toBeDefined();
+      expect((defaultPostEndpoint as any)?.tasks?.length).toBe(1);
+    });
+
+    it('| should setup defaultPut endpoint', () => {
+      controller.setupEndpoints();
+
+      const defaultPutEndpoint = controller.endpoints.find(ep => ep.name === 'defaultPut');
+      expect(defaultPutEndpoint).toBeDefined();
+      expect(defaultPutEndpoint?.type).toBe(DyFM_HttpCallType.put);
+      expect(defaultPutEndpoint?.endpoint).toBe('/*');
+      expect((defaultPutEndpoint as any)?.tasks).toBeDefined();
+      expect((defaultPutEndpoint as any)?.tasks?.length).toBe(1);
+    });
+
+    it('| should setup defaultPatch endpoint', () => {
+      controller.setupEndpoints();
+
+      const defaultPatchEndpoint = controller.endpoints.find(ep => ep.name === 'defaultPatch');
+      expect(defaultPatchEndpoint).toBeDefined();
+      expect(defaultPatchEndpoint?.type).toBe(DyFM_HttpCallType.patch);
+      expect(defaultPatchEndpoint?.endpoint).toBe('/*');
+      expect((defaultPatchEndpoint as any)?.tasks).toBeDefined();
+      expect((defaultPatchEndpoint as any)?.tasks?.length).toBe(1);
+    });
+
+    it('| should setup defaultDelete endpoint', () => {
+      controller.setupEndpoints();
+
+      const defaultDeleteEndpoint = controller.endpoints.find(ep => ep.name === 'defaultDelete');
+      expect(defaultDeleteEndpoint).toBeDefined();
+      expect(defaultDeleteEndpoint?.type).toBe(DyFM_HttpCallType.delete);
+      expect(defaultDeleteEndpoint?.endpoint).toBe('/*');
+      expect((defaultDeleteEndpoint as any)?.tasks).toBeDefined();
+      expect((defaultDeleteEndpoint as any)?.tasks?.length).toBe(1);
+    });
+  });
+
+  describe('| DyNTS_getStarRoute', () => {
+    it('| should return routing module', () => {
+      const routingModule = DyNTS_getStarRoute();
+
+      expect(routingModule).toBeInstanceOf(DyNTS_RoutingModule);
+      // The route might be modified by RoutingModule, check if it contains /**
+      expect(routingModule.route).toContain('**');
+      expect((routingModule as any).controllers).toBeDefined();
+      expect((routingModule as any).controllers.length).toBe(1);
+      expect((routingModule as any).controllers[0]).toBeInstanceOf(DyNTS_Star_Controller);
+    });
+
+    it('| should return routing module with correct route', () => {
+      const routingModule = DyNTS_getStarRoute();
+      expect(routingModule.route).toBe('/api/**');
+    });
+  });
+
+  describe('| endpoint tasks', () => {
+    it('| should throw 404 error for defaultGet endpoint', async () => {
+      controller.setupEndpoints();
+      const defaultGetEndpoint = controller.endpoints.find(ep => ep.name === 'defaultGet');
+      expect(defaultGetEndpoint).toBeDefined();
+
+      const mockReq = {
+        originalUrl: '/test-route',
+      } as any;
+      const mockRes = {} as any;
+
+      try {
+        await (defaultGetEndpoint as any).tasks[0](mockReq, mockRes, 'test-issuer');
+        fail('Should have thrown an error');
+      } catch (error) {
+        expect(error).toBeInstanceOf(DyFM_Error);
+        expect((error as DyFM_Error).___status).toBe(404);
+        expect((error as DyFM_Error)._errorCode).toContain('DyNTS-RMS-G404');
+      }
+    });
+
+    it('| should throw 404 error for defaultPost endpoint', async () => {
+      controller.setupEndpoints();
+      const defaultPostEndpoint = controller.endpoints.find(ep => ep.name === 'defaultPost');
+      expect(defaultPostEndpoint).toBeDefined();
+
+      const mockReq = {
+        originalUrl: '/test-route',
+      } as any;
+      const mockRes = {} as any;
+
+      try {
+        await (defaultPostEndpoint as any).tasks[0](mockReq, mockRes, 'test-issuer');
+        fail('Should have thrown an error');
+      } catch (error) {
+        expect(error).toBeInstanceOf(DyFM_Error);
+        expect((error as DyFM_Error).___status).toBe(404);
+        expect((error as DyFM_Error)._errorCode).toContain('DyNTS-RMS-PO404');
+      }
+    });
+
+    it('| should throw 404 error for defaultPut endpoint', async () => {
+      controller.setupEndpoints();
+      const defaultPutEndpoint = controller.endpoints.find(ep => ep.name === 'defaultPut');
+      expect(defaultPutEndpoint).toBeDefined();
+
+      const mockReq = {
+        originalUrl: '/test-route',
+      } as any;
+      const mockRes = {} as any;
+
+      try {
+        await (defaultPutEndpoint as any).tasks[0](mockReq, mockRes, 'test-issuer');
+        fail('Should have thrown an error');
+      } catch (error) {
+        expect(error).toBeInstanceOf(DyFM_Error);
+        expect((error as DyFM_Error).___status).toBe(404);
+        expect((error as DyFM_Error)._errorCode).toContain('DyNTS-RMS-PU404');
+      }
+    });
+
+    it('| should throw 404 error for defaultPatch endpoint', async () => {
+      controller.setupEndpoints();
+      const defaultPatchEndpoint = controller.endpoints.find(ep => ep.name === 'defaultPatch');
+      expect(defaultPatchEndpoint).toBeDefined();
+
+      const mockReq = {
+        originalUrl: '/test-route',
+      } as any;
+      const mockRes = {} as any;
+
+      try {
+        await (defaultPatchEndpoint as any).tasks[0](mockReq, mockRes, 'test-issuer');
+        fail('Should have thrown an error');
+      } catch (error) {
+        expect(error).toBeInstanceOf(DyFM_Error);
+        expect((error as DyFM_Error).___status).toBe(404);
+        expect((error as DyFM_Error)._errorCode).toContain('DyNTS-RMS-PA404');
+      }
+    });
+
+    it('| should throw 404 error for defaultDelete endpoint', async () => {
+      controller.setupEndpoints();
+      const defaultDeleteEndpoint = controller.endpoints.find(ep => ep.name === 'defaultDelete');
+      expect(defaultDeleteEndpoint).toBeDefined();
+
+      const mockReq = {
+        originalUrl: '/test-route',
+      } as any;
+      const mockRes = {} as any;
+
+      try {
+        await (defaultDeleteEndpoint as any).tasks[0](mockReq, mockRes, 'test-issuer');
+        fail('Should have thrown an error');
+      } catch (error) {
+        expect(error).toBeInstanceOf(DyFM_Error);
+        expect((error as DyFM_Error).___status).toBe(404);
+        expect((error as DyFM_Error)._errorCode).toContain('DyNTS-RMS-D404');
+      }
+    });
+
+    it('| should include originalUrl in error message', async () => {
+      controller.setupEndpoints();
+      const defaultGetEndpoint = controller.endpoints.find(ep => ep.name === 'defaultGet');
+      expect(defaultGetEndpoint).toBeDefined();
+
+      const mockReq = {
+        originalUrl: '/custom-route',
+      } as any;
+      const mockRes = {} as any;
+
+      try {
+        await (defaultGetEndpoint as any).tasks[0](mockReq, mockRes, 'test-issuer');
+        fail('Should have thrown an error');
+      } catch (error) {
+        expect(error).toBeInstanceOf(DyFM_Error);
+        expect((error as DyFM_Error)._message).toContain('/custom-route');
+      }
+    });
+  });
+});
+