@futdevpro/fsm-dynamo 1.7.2 → 1.7.5

package/src/_models/control-models/error.control-model.spec.ts

@@ -4,7 +4,7 @@ import { dynamo_error_default } from '../../_constants/error-defaults.const';
 import { Dynamo_Log } from '../../_utils/log.util';
 import { Dynamo_Error } from './error.control-model';
 
-describe('Dynamo_Error;', () => {
+describe('Dynamo_Error;', (): void => {
   let error_base: Error;
   let error_0: Dynamo_Error;
   let error_stack_1: Dynamo_Error;
@@ -16,7 +16,8 @@ describe('Dynamo_Error;', () => {
   const message_base: string = '-TEST ERROR: something failed!-';
   const message_1: string = 'TEST ERROR MSG (1)';
   const message_2: string = 'TEST ERROR MSG (2)';
-  const message_selfDefined: string = dynamo_error_default.message + '; error.control-model.spec.js:77:29)';
+  const message_selfDefined: string = dynamo_error_default.message + 
+    '; error.control-model.spec.js:78:29)';
   
   const errorCode_0: string = 'ASD-ASD-001';
   const errorCode_1: string = 'ASD-ASD-002';
@@ -28,12 +29,12 @@ describe('Dynamo_Error;', () => {
   const userMessageResult_0: string = userMessage_0 + `\nErrorCode: ${errorCode_0}`;
   const userMessageResult_2: string = userMessage_2 + `\nErrorCode: ${errorCode_2}`;
 
-  const issuer: string = 'Dynamo_Error TEST User'
+  const issuer: string = 'Dynamo_Error TEST User';
   const issuerSystem: string = 'Dynamo_FSM TEST';
   const issuerService_0: string = 'Service-0';
   const issuerService_1: string = 'Service-1';
 
-  const additionalContent_1: any = {
+  const additionalContent_1 = {
     test: 'test',
     test2: 'test2',
   };
@@ -41,7 +42,7 @@ describe('Dynamo_Error;', () => {
   const log: boolean = false;
   /* const log: boolean = true; */
 
-  beforeEach(async () => {
+  beforeEach(async (): Promise<void> => {
     error_base = new Error(message_base);
 
     error_0 = new Dynamo_Error({
@@ -66,9 +67,11 @@ describe('Dynamo_Error;', () => {
     error_stack_withoutSubErrors_1 = {
       ...error_stack_1,
     } as Dynamo_Error;
-    error_stack_withoutSubErrors_1.errors.forEach((error: Dynamo_Error) => {
+    error_stack_withoutSubErrors_1.errors.forEach((error: Dynamo_Error): any => {
       const subError = { ...error };
+
       delete (subError as Dynamo_Error).errors;
+
       return subError;
     });
 
@@ -83,465 +86,473 @@ describe('Dynamo_Error;', () => {
     error_stack_withoutSubErrors_2 = {
       ...error_stack_2,
     } as Dynamo_Error;
-    error_stack_withoutSubErrors_2.errors.map((error: Dynamo_Error) => {
+    error_stack_withoutSubErrors_2.errors.map((error: Dynamo_Error): any => {
       const subError = { ...error };
+
       delete (subError as Dynamo_Error).errors;
+
       return subError;
     });
 
     error_selfDefined = new Dynamo_Error();
   });
 
-  if (log) afterAll(async () => {
+  if (log) afterAll(async (): Promise<void> => {
     Dynamo_Log.testLog('error_stack_2:\n', error_stack_2);
     Dynamo_Log.testLog('error_stack_2.getFlat:\n', error_stack_2.getErrorsFlat());
     Dynamo_Log.testLog('error_stack_2.getSimplified:\n', error_stack_2.getErrorSimplified());
     Dynamo_Log.testLog('error_stack_withoutSubErrors_2:\n', error_stack_withoutSubErrors_2);
     Dynamo_Log.testLog('error_selfDefined:\n', error_selfDefined);
     Dynamo_Log.testLog('error_selfDefined.getFlat:\n', error_selfDefined.getErrorsFlat());
-    Dynamo_Log.testLog('error_selfDefined.getSimplified:\n', error_selfDefined.getErrorSimplified());
+    Dynamo_Log.testLog(
+      'error_selfDefined.getSimplified:\n', error_selfDefined.getErrorSimplified()
+    );
   });
   
-  describe('should be defined;', () => {
-    it('error object', () => {
+  describe('should be defined;', (): void => {
+    it('error object', (): void => {
       expect(error_0).toBeDefined();
     });
 
-    it('error stack object', () => {
+    it('error stack object', (): void => {
       expect(error_stack_1).toBeDefined();
     });
 
-    it('greater error stack object', () => {
+    it('greater error stack object', (): void => {
       expect(error_stack_2).toBeDefined();
     });
 
-    it('self defined error object', () => {
+    it('self defined error object', (): void => {
       expect(error_selfDefined).toBeDefined();
     });
   });
 
-  describe('should be instance of Dynamo_Error;', () => {
-    it('error as Dynamo_Error object', () => {
+  describe('should be instance of Dynamo_Error;', (): void => {
+    it('error as Dynamo_Error object', (): void => {
       expect(error_0).toBeInstanceOf(Dynamo_Error);
     });
 
-    it('error stack as Dynamo_Error object', () => {
+    it('error stack as Dynamo_Error object', (): void => {
       expect(error_stack_1).toBeInstanceOf(Dynamo_Error);
     });
 
-    it('greater error stack as Dynamo_Error object', () => {
+    it('greater error stack as Dynamo_Error object', (): void => {
       expect(error_stack_2).toBeInstanceOf(Dynamo_Error);
     });
 
-    it('self defined error as Dynamo_Error object', () => {
+    it('self defined error as Dynamo_Error object', (): void => {
       expect(error_selfDefined).toBeInstanceOf(Dynamo_Error);
     });
   });
 
-  describe('should have the proper _errorCode;', () => {
-    it('on error_0', () => {
+  describe('should have the proper _errorCode;', (): void => {
+    it('on error_0', (): void => {
       expect(error_0._errorCode).toBe(errorCode_0);
     });
 
-    it('on error_stack_1', () => {
+    it('on error_stack_1', (): void => {
       expect(error_stack_1._errorCode).toBe(errorCode_0);
     });
 
-    it('on error_stack_2', () => {
+    it('on error_stack_2', (): void => {
       expect(error_stack_2._errorCode).toBe(errorCode_0);
     });
 
-    it('on self defined error', () => {
+    it('on self defined error', (): void => {
       expect(error_selfDefined._errorCode).toBe(dynamo_error_default.errorCode);
     });
   });
 
-  describe('should have the proper _errorCodes;', () => {
-    it('on error_0', () => {
+  describe('should have the proper _errorCodes;', (): void => {
+    it('on error_0', (): void => {
       expect(error_0._errorCodes).toEqual([ errorCode_0 ]);
     });
     
-    it('on error_stack_1', () => {
+    it('on error_stack_1', (): void => {
       expect(error_stack_1._errorCodes).toEqual([ errorCode_0, errorCode_1 ]);
     });
 
-    it('on error_stack_2', () => {
+    it('on error_stack_2', (): void => {
       expect(error_stack_2._errorCodes).toEqual([ errorCode_0, errorCode_1, errorCode_2 ]);
     });
 
-    it('on self defined error', () => {
+    it('on self defined error', (): void => {
       expect(error_selfDefined._errorCodes).toEqual([ dynamo_error_default.errorCode ]);
     });
   });
 
-  describe('should have the proper _message;', () => {
-    it('on error_0', () => {
+  describe('should have the proper _message;', (): void => {
+    it('on error_0', (): void => {
       expect(error_0._message).toBe(message_base);
     });
 
-    it('on error_stack_1', () => {
+    it('on error_stack_1', (): void => {
       expect(error_stack_1._message).toBe(message_base);
     });
 
-    it('on error_stack_2', () => {
+    it('on error_stack_2', (): void => {
       expect(error_stack_2._message).toBe(message_base);
     });
 
-    it('on self defined error', () => {
+    it('on self defined error', (): void => {
       expect(error_selfDefined._message).toBe(message_selfDefined);
     });
   });
 
-  describe('should have the proper _messages;', () => {
-    it('on error_0', () => {
+  describe('should have the proper _messages;', (): void => {
+    it('on error_0', (): void => {
       expect(error_0._messages).toEqual([ message_base ]);
     });
 
-    it('on error_stack_1', () => {
+    it('on error_stack_1', (): void => {
       expect(error_stack_1._messages).toEqual([ message_base, message_1 ]);
     });
 
-    it('on error_stack_2', () => {
+    it('on error_stack_2', (): void => {
       expect(error_stack_2._messages).toEqual([ message_base, message_1, message_2 ]);
     });
 
-    it('on self defined error', () => {
+    it('on self defined error', (): void => {
       expect(error_selfDefined._messages).toEqual([ message_selfDefined ]);
     });
   });
 
-  describe('should have the proper __userMessage;', () => {
-    it('on error_0', () => {
+  describe('should have the proper __userMessage;', (): void => {
+    it('on error_0', (): void => {
       expect(error_0.__userMessage).toBe(userMessageResult_0);
     });
 
-    it('on error_stack_1', () => {
+    it('on error_stack_1', (): void => {
       expect(error_stack_1.__userMessage).toBe(userMessageResult_0);
     });
 
-    it('on error_stack_2', () => {
+    it('on error_stack_2', (): void => {
       expect(error_stack_2.__userMessage).toBe(userMessageResult_0);
     });
 
-    it('on self defined error', () => {
+    it('on self defined error', (): void => {
       expect(error_selfDefined.__userMessage).toBeUndefined();
     });
   });
 
-  describe('should have the proper __userMessages;', () => {
-    it('on error_0', () => {
+  describe('should have the proper __userMessages;', (): void => {
+    it('on error_0', (): void => {
       expect(error_0.__userMessages).toEqual([ userMessageResult_0 ]);
     });
 
-    it('on error_stack_1', () => {
-      expect(error_stack_1.__userMessages).toEqual([ userMessageResult_0, dynamo_error_default.userMessage ]);
+    it('on error_stack_1', (): void => {
+      expect(error_stack_1.__userMessages).toEqual(
+        [ userMessageResult_0, dynamo_error_default.userMessage ]
+      );
     });
 
-    it('on error_stack_2', () => {
-      expect(error_stack_2.__userMessages).toEqual([ userMessageResult_0, dynamo_error_default.userMessage, userMessageResult_2 ]);
+    it('on error_stack_2', (): void => {
+      expect(error_stack_2.__userMessages).toEqual(
+        [ userMessageResult_0, dynamo_error_default.userMessage, userMessageResult_2 ]
+      );
     });
 
-    it('on self defined error', () => {
+    it('on self defined error', (): void => {
       expect(error_selfDefined.__userMessages).toEqual([ dynamo_error_default.userMessage ]);
     });
   });
 
-  describe('should have proper error;', () => {
-    it('on error_0', () => {
+  describe('should have proper error;', (): void => {
+    it('on error_0', (): void => {
       expect(error_0.error).toBe(error_base);
     });
 
-    it('on error_stack_1', () => {
+    it('on error_stack_1', (): void => {
       expect(error_stack_1.error).toBe(error_base);
     });
 
-    it('on error_stack_2', () => {
+    it('on error_stack_2', (): void => {
       expect(error_stack_2.error).toBe(error_base);
     });
 
-    it('on self defined error', () => {
+    it('on self defined error', (): void => {
       expect(error_selfDefined.error).toBeDefined();
     });
   });
 
-  describe('should have the proper errors;', () => {
-    it('on error_0', () => {
+  describe('should have the proper errors;', (): void => {
+    it('on error_0', (): void => {
       expect(error_0.errors).toEqual([ error_base ]);
     });
 
-    it('on error_stack_1', () => {
+    it('on error_stack_1', (): void => {
       expect(error_stack_1.errors).toEqual([ error_base, error_0 ]);
     });
 
-    it('on error_stack_2', () => {
+    it('on error_stack_2', (): void => {
       expect(error_stack_2.errors).toEqual([ error_base, error_0, error_stack_1 ]);
     });
 
-    it('on self defined error', () => {
+    it('on self defined error', (): void => {
       expect(error_selfDefined?.errors?.length).toBe(1);
     });
   });
 
-  describe('should have proper handled;', () => {
-    it('on error_0', () => {
+  describe('should have proper handled;', (): void => {
+    it('on error_0', (): void => {
       expect(error_0.___handled).toBe(false);
     });
 
-    it('on error_stack_1', () => {
+    it('on error_stack_1', (): void => {
       expect(error_stack_1.___handled).toBe(true);
     });
 
-    it('on error_stack_2', () => {
+    it('on error_stack_2', (): void => {
       expect(error_stack_2.___handled).toBe(true);
     });
 
-    it('on self defined error', () => {
+    it('on self defined error', (): void => {
       expect(error_selfDefined.___handled).toBe(false);
     });
   });
 
-  describe('should have status: undefined;', () => {
-    it('on error_0', () => {
+  describe('should have status: undefined;', (): void => {
+    it('on error_0', (): void => {
       expect(error_0.___status).toBe(undefined);
     });
 
-    it('on error_stack_1', () => {
+    it('on error_stack_1', (): void => {
       expect(error_stack_1.___status).toBe(undefined);
     });
 
-    it('on error_stack_2', () => {
+    it('on error_stack_2', (): void => {
       expect(error_stack_2.___status).toBe(undefined);
     });
 
-    it('on self defined error', () => {
+    it('on self defined error', (): void => {
       expect(error_selfDefined.___status).toBe(undefined);
     });
   });
 
-  describe('should have the proper issuer;', () => {
-    it('on error_0', () => {
+  describe('should have the proper issuer;', (): void => {
+    it('on error_0', (): void => {
       expect(error_0.___issuer).toBe(issuer);
     });
 
-    it('on error_stack_1', () => {
+    it('on error_stack_1', (): void => {
       expect(error_stack_1.___issuer).toBe(issuer);
     });
 
-    it('on error_stack_2', () => {
+    it('on error_stack_2', (): void => {
       expect(error_stack_2.___issuer).toBe(issuer);
     });
 
-    it('on self defined error', () => {
+    it('on self defined error', (): void => {
       expect(error_selfDefined.___issuer).toBe(dynamo_error_default.issuer);
     });
   });
   
-  describe('should have get proper additionalContent;', () => {
-    it('on error_0', () => {
+  describe('should have get proper additionalContent;', (): void => {
+    it('on error_0', (): void => {
       expect(error_0.additionalContent).toBeUndefined();
     });
 
-    it('on error_stack_1', () => {
+    it('on error_stack_1', (): void => {
       expect(error_stack_1.additionalContent).toBe(additionalContent_1);
     });
 
-    it('on error_stack_2', () => {
-      expect(error_stack_2.additionalContent).toBeUndefined();
+    it('on error_stack_2', (): void => {
+      expect(error_stack_2.additionalContent).toBe(additionalContent_1);
     });
 
-    it('on self defined error', () => {
+    it('on self defined error', (): void => {
       expect(error_selfDefined.additionalContent).toBeUndefined();
     });
   });
 
-  describe('should have the proper issuerSystem;', () => {
-    it('on error_0', () => {
+  describe('should have the proper issuerSystem;', (): void => {
+    it('on error_0', (): void => {
       expect(error_0.___issuerSystem).toBe(issuerSystem);
     });
 
-    it('on error_stack_1', () => {
+    it('on error_stack_1', (): void => {
       expect(error_stack_1.___issuerSystem).toBe(issuerSystem);
     });
 
-    it('on error_stack_2', () => {
+    it('on error_stack_2', (): void => {
       expect(error_stack_2.___issuerSystem).toBe(issuerSystem);
     });
 
-    it('on self defined error', () => {
+    it('on self defined error', (): void => {
       expect(error_selfDefined.___issuerSystem).toBe(dynamo_error_default.issuerSystem);
     });
   });
 
-  describe('should have the proper issuerService;', () => {
-    it('on error_0', () => {
+  describe('should have the proper issuerService;', (): void => {
+    it('on error_0', (): void => {
       expect(error_0.___issuerService).toBe(issuerService_0);
     });
 
-    it('on error_stack_1', () => {
+    it('on error_stack_1', (): void => {
       expect(error_stack_1.___issuerService).toBe(issuerService_1);
     });
 
-    it('on error_stack_2', () => {
+    it('on error_stack_2', (): void => {
       expect(error_stack_2.___issuerService).toBe(issuerService_1);
     });
 
-    it('on self defined error', () => {
+    it('on self defined error', (): void => {
       expect(error_selfDefined.___issuerService).toBe(dynamo_error_default.issuerService);
     });
   });
 
-  describe('should have get proper simplified;', () => {
+  describe('should have get proper simplified;', (): void => {
     let simplified;
 
-    describe('on error_0;', () => {
-      beforeEach(() => {
+    describe('on error_0;', (): void => {
+      beforeEach((): void => {
         simplified = error_0.getErrorSimplified();
       });
       
-      it('should be defined', () => {
+      it('should be defined', (): void => {
         expect(simplified).toBeDefined();
       });
 
-      it('should have error', () => {
+      it('should have error', (): void => {
         expect(simplified.error).toBeDefined();
       });
 
-      it('should not have errors', () => {
+      it('should not have errors', (): void => {
         expect(simplified.errors).toBeUndefined();
       });
 
-      it('should not have simplified.error.error', () => {
+      it('should not have simplified.error.error', (): void => {
         expect((simplified.error as Dynamo_Error)?.error).toBeUndefined();
       });
 
-      it('should not have simplified.error.errors', () => {
+      it('should not have simplified.error.errors', (): void => {
         expect((simplified.error as Dynamo_Error)?.errors).toBeUndefined();
       });
     });
 
-    describe('on error_stack_1;', () => {
-      beforeEach(() => {
+    describe('on error_stack_1;', (): void => {
+      beforeEach((): void => {
         simplified = error_stack_1.getErrorSimplified();
       });
       
-      it('should be defined', () => {
+      it('should be defined', (): void => {
         expect(simplified).toBeDefined();
       });
 
-      it('should have error', () => {
+      it('should have error', (): void => {
         expect(simplified.error).toBeDefined();
       });
 
-      it('should not have errors', () => {
+      it('should not have errors', (): void => {
         expect(simplified.errors).toBeUndefined();
       });
 
-      it('should not have simplified.error.error', () => {
+      it('should not have simplified.error.error', (): void => {
         expect((simplified.error as Dynamo_Error)?.error).toBeUndefined();
       });
 
-      it('should not have simplified.error.errors', () => {
+      it('should not have simplified.error.errors', (): void => {
         expect((simplified.error as Dynamo_Error)?.errors).toBeUndefined();
       });
     });
 
-    describe('on error_stack_2;', () => {
-      beforeEach(() => {
+    describe('on error_stack_2;', (): void => {
+      beforeEach((): void => {
         simplified = error_stack_2.getErrorSimplified();
       });
       
-      it('should be defined', () => {
+      it('should be defined', (): void => {
         expect(simplified).toBeDefined();
       });
 
-      it('should have error', () => {
+      it('should have error', (): void => {
         expect(simplified.error).toBeDefined();
       });
 
-      it('should not have errors', () => {
+      it('should not have errors', (): void => {
         expect(simplified.errors).toBeUndefined();
       });
 
-      it('should not have simplified.error.error', () => {
+      it('should not have simplified.error.error', (): void => {
         expect((simplified.error as Dynamo_Error)?.error).toBeUndefined();
       });
 
-      it('should not have simplified.error.errors', () => {
+      it('should not have simplified.error.errors', (): void => {
         expect((simplified.error as Dynamo_Error)?.errors).toBeUndefined();
       });
     });
 
-    describe('on self defined error;', () => {
-      beforeEach(() => {
+    describe('on self defined error;', (): void => {
+      beforeEach((): void => {
         simplified = error_selfDefined.getErrorSimplified();
       });
       
-      it('should be defined', () => {
+      it('should be defined', (): void => {
         expect(simplified).toBeDefined();
       });
 
-      it('should have error', () => {
+      it('should have error', (): void => {
         expect(simplified.error).toBeDefined();
       });
 
-      it('should not have errors', () => {
+      it('should not have errors', (): void => {
         expect(simplified.errors).toBeUndefined();
       });
 
-      it('should not have simplified.error.error', () => {
+      it('should not have simplified.error.error', (): void => {
         expect((simplified.error as Dynamo_Error)?.error).toBeUndefined();
       });
 
-      it('should not have simplified.error.errors', () => {
+      it('should not have simplified.error.errors', (): void => {
         expect((simplified.error as Dynamo_Error)?.errors).toBeUndefined();
       });
     });
   });
 
-  describe('should have get proper flat;', () => {
+  describe('should have get proper flat;', (): void => {
     let flat;
 
-    describe('on error_0;', () => {
-      beforeEach(() => {
+    describe('on error_0;', (): void => {
+      beforeEach((): void => {
         flat = error_0.getErrorsFlat();
       });
       
-      it('should be defined', () => {
+      it('should be defined', (): void => {
         expect(flat).toBeDefined();
       });
 
-      it('should have error', () => {
+      it('should have error', (): void => {
         expect(flat.error).toBeDefined();
       });
 
-      describe('errors...;', () => {
-        it('should have errors', () => {
+      describe('errors...;', (): void => {
+        it('should have errors', (): void => {
           expect(flat?.errors).toBeDefined();
         });
         
-        it('should have 1 errors', () => {
+        it('should have 1 errors', (): void => {
           expect(flat?.errors?.length).toBe(1);
         });
 
-        flat?.errors?.forEach((error: Dynamo_Error, index: number) => {
-          describe(`on error[${index}];`, () => {
-            it('should be', () => {
+        flat?.errors?.forEach((error: Dynamo_Error, index: number): void => {
+          describe(`on error[${index}];`, (): void => {
+            it('should be', (): void => {
               expect(error).toBeDefined();
             });
 
-            it(`should have error[${index}].error`, () => {
+            it(`should have error[${index}].error`, (): void => {
               expect(error.error).toBeDefined();
             });
 
-            it(`should not have error[${index}].errors`, () => {
+            it(`should not have error[${index}].errors`, (): void => {
               expect(error.errors).toBeUndefined();
             });
 
-            it(`should not have error[${index}].error.error`, () => {
+            it(`should not have error[${index}].error.error`, (): void => {
               expect((error.error as Dynamo_Error)?.error).toBeUndefined();
             });
 
-            it(`should not have error[${index}].error.errors`, () => {
+            it(`should not have error[${index}].error.errors`, (): void => {
               expect((error.error as Dynamo_Error)?.errors).toBeUndefined();
             });
           });
@@ -549,47 +560,47 @@ describe('Dynamo_Error;', () => {
       });
     });
 
-    describe('on error_stack_1;', () => {
-      beforeEach(() => {
+    describe('on error_stack_1;', (): void => {
+      beforeEach((): void => {
         flat = error_stack_1.getErrorsFlat();
       });
       
-      it('should be defined', () => {
+      it('should be defined', (): void => {
         expect(flat).toBeDefined();
       });
 
-      it('should have error', () => {
+      it('should have error', (): void => {
         expect(flat.error).toBeDefined();
       });
 
-      describe('errors...;', () => {
-        it('should have errors', () => {
+      describe('errors...;', (): void => {
+        it('should have errors', (): void => {
           expect(flat?.errors).toBeDefined();
         });
         
-        it('should have 2 errors', () => {
+        it('should have 2 errors', (): void => {
           expect(flat?.errors?.length).toBe(2);
         });
 
-        flat?.errors?.forEach((error: Dynamo_Error, index: number) => {
-          describe(`on error[${index}];`, () => {
-            it('should be', () => {
+        flat?.errors?.forEach((error: Dynamo_Error, index: number): void => {
+          describe(`on error[${index}];`, (): void => {
+            it('should be', (): void => {
               expect(error).toBeDefined();
             });
 
-            it(`should have error[${index}].error`, () => {
+            it(`should have error[${index}].error`, (): void => {
               expect(error.error).toBeDefined();
             });
 
-            it(`should not have error[${index}].errors`, () => {
+            it(`should not have error[${index}].errors`, (): void => {
               expect(error.errors).toBeUndefined();
             });
 
-            it('should not have error[${index}].error.error', () => {
+            it('should not have error[${index}].error.error', (): void => {
               expect((error.error as Dynamo_Error)?.error).toBeUndefined();
             });
 
-            it('should not have error[${index}].error.errors', () => {
+            it('should not have error[${index}].error.errors', (): void => {
               expect((error.error as Dynamo_Error)?.errors).toBeUndefined();
             });
           });
@@ -597,47 +608,47 @@ describe('Dynamo_Error;', () => {
       });
     });
 
-    describe('on error_stack_2;', () => {
-      beforeEach(() => {
+    describe('on error_stack_2;', (): void => {
+      beforeEach((): void => {
         flat = error_stack_2.getErrorsFlat();
       });
       
-      it('should be defined', () => {
+      it('should be defined', (): void => {
         expect(flat).toBeDefined();
       });
 
-      it('should have error', () => {
+      it('should have error', (): void => {
         expect(flat.error).toBeDefined();
       });
 
-      describe('errors...;', () => {
-        it('should have errors', () => {
+      describe('errors...;', (): void => {
+        it('should have errors', (): void => {
           expect(flat?.errors).toBeDefined();
         });
         
-        it('should have 3 errors', () => {
+        it('should have 3 errors', (): void => {
           expect(flat?.errors?.length).toBe(3);
         });
 
-        flat?.errors?.forEach((error: Dynamo_Error, index: number) => {
-          describe(`on error[${index}];`, () => {
-            it('should be', () => {
+        flat?.errors?.forEach((error: Dynamo_Error, index: number): void => {
+          describe(`on error[${index}];`, (): void => {
+            it('should be', (): void => {
               expect(error).toBeDefined();
             });
 
-            it(`should have error[${index}].error`, () => {
+            it(`should have error[${index}].error`, (): void => {
               expect(error.error).toBeDefined();
             });
 
-            it(`should not have error[${index}].errors`, () => {
+            it(`should not have error[${index}].errors`, (): void => {
               expect(error.errors).toBeUndefined();
             });
 
-            it(`should not have error[${index}].error.error`, () => {
+            it(`should not have error[${index}].error.error`, (): void => {
               expect((error.error as Dynamo_Error)?.error).toBeUndefined();
             });
 
-            it(`should not have error[${index}].error.errors`, () => {
+            it(`should not have error[${index}].error.errors`, (): void => {
               expect((error.error as Dynamo_Error)?.errors).toBeUndefined();
             });
           });
@@ -645,47 +656,47 @@ describe('Dynamo_Error;', () => {
       });
     }); 
 
-    describe('on self defined error;', () => {
-      beforeEach(() => {
+    describe('on self defined error;', (): void => {
+      beforeEach((): void => {
         flat = error_selfDefined.getErrorsFlat();
       });
       
-      it('should be defined', () => {
+      it('should be defined', (): void => {
         expect(flat).toBeDefined();
       });
 
-      it('should have error', () => {
+      it('should have error', (): void => {
         expect(flat.error).toBeDefined();
       });
 
-      describe('errors...;', () => {
-        it('should have errors', () => {
+      describe('errors...;', (): void => {
+        it('should have errors', (): void => {
           expect(flat?.errors).toBeDefined();
         });
         
-        it('should have 1 errors', () => {
+        it('should have 1 errors', (): void => {
           expect(flat?.errors?.length).toBe(1);
         });
 
-        flat?.errors?.forEach((error: Dynamo_Error, index: number) => {
-          describe(`on error[${index}];`, () => {
-            it('should be', () => {
+        flat?.errors?.forEach((error: Dynamo_Error, index: number): void => {
+          describe(`on error[${index}];`, (): void => {
+            it('should be', (): void => {
               expect(error).toBeDefined();
             });
 
-            it(`should have error[${index}].error`, () => {
+            it(`should have error[${index}].error`, (): void => {
               expect(error.error).toBeDefined();
             });
 
-            it(`should not have error[${index}].errors`, () => {
+            it(`should not have error[${index}].errors`, (): void => {
               expect(error.errors).toBeUndefined();
             });
 
-            it(`should not have error[${index}].error.error`, () => {
+            it(`should not have error[${index}].error.error`, (): void => {
               expect((error.error as Dynamo_Error)?.error).toBeUndefined();
             });
 
-            it(`should not have error[${index}].error.errors`, () => {
+            it(`should not have error[${index}].error.errors`, (): void => {
               expect((error.error as Dynamo_Error)?.errors).toBeUndefined();
             });
           });