@futdevpro/fsm-dynamo 1.9.10 → 1.9.14

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

@@ -1,716 +1,753 @@
-
-
-import { DynamoFM_error_defaults } from '../../_collections/constants/error-defaults.const';
-import { DynamoFM_Log } from '../../_collections/utils/log.util';
-import { DynamoFM_Error } from './error.control-model';
-
-describe('DynamoFM_Error;', (): void => {
-  let error_base: Error;
-  let error_0: DynamoFM_Error;
-  let error_stack_1: DynamoFM_Error;
-  let error_stack_withoutSubErrors_1: DynamoFM_Error;
-  let error_stack_2: DynamoFM_Error;
-  let error_stack_withoutSubErrors_2: DynamoFM_Error;
-  let error_selfDefined: DynamoFM_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 = DynamoFM_error_defaults.message + 
-    '; error.control-model.spec.js:83:29)';
-  
-  const errorCode_0: string = 'ASD-ASD-001';
-  const errorCode_1: string = 'ASD-ASD-002';
-  const errorCode_2: string = 'ASD-ASD-003';
-
-  const userMessage_0: string = 'DynamoFM_Error TEST was TEST! (0)';
-  const userMessage_2: string = 'DynamoFM_Error TEST was TEST! (2)';
-
-  const userMessageResult_0: string = userMessage_0 + `\nErrorCode: ${errorCode_0}`;
-  const userMessageResult_2: string = userMessage_2 + `\nErrorCode: ${errorCode_2}`;
-
-  const issuer: string = 'DynamoFM_Error TEST User';
-  const issuerSystem: string = 'DynamoFM_FSM TEST';
-  const issuerService_0: string = 'Service-0';
-  const issuerService_1: string = 'Service-1';
-
-  const additionalContent_1 = {
-    test: 'test',
-    test2: 'test2',
-  };
-  const additionalContent_2 = {
-    test2: 'testZ',
-    test3: 'test3',
-  };
-  
-  const log: boolean = false;
-  /* const log: boolean = true; */
-
-  beforeEach(async (): Promise<void> => {
-    error_base = new Error(message_base);
-
-    error_0 = new DynamoFM_Error({
-      userMessage: userMessage_0,
-      addECToUserMsg: true,
-      errorCode: errorCode_0,
-      issuerSystem: issuerSystem,
-      issuer: issuer,
-      issuerService: issuerService_0,
-      error: error_base,
-    });
-
-    error_stack_1 = new DynamoFM_Error({
-      message: message_1,
-      errorCode: errorCode_1,
-      issuerService: issuerService_1,
-      handled: true,
-      additionalContent: additionalContent_1,
-      error: error_0,
-    });
-
-    error_stack_withoutSubErrors_1 = {
-      ...error_stack_1,
-    } as DynamoFM_Error;
-    error_stack_withoutSubErrors_1.errors.forEach((error: DynamoFM_Error): any => {
-      const subError = { ...error };
-
-      delete (subError as DynamoFM_Error).errors;
-
-      return subError;
-    });
-
-    error_stack_2 = new DynamoFM_Error({
-      message: message_2,
-      userMessage: userMessage_2,
-      addECToUserMsg: true,
-      errorCode: errorCode_2,
-      additionalContent: additionalContent_2,
-      error: error_stack_1,
-    });
-
-    error_stack_withoutSubErrors_2 = {
-      ...error_stack_2,
-    } as DynamoFM_Error;
-    error_stack_withoutSubErrors_2.errors.map((error: DynamoFM_Error): any => {
-      const subError = { ...error };
-
-      delete (subError as DynamoFM_Error).errors;
-
-      return subError;
-    });
-
-    error_selfDefined = new DynamoFM_Error();
-  });
-
-  if (log) afterAll(async (): Promise<void> => {
-    DynamoFM_Log.testLog('error_stack_2:\n', error_stack_2);
-    DynamoFM_Log.testLog('error_stack_2.getFlat:\n', error_stack_2.getErrorsFlat());
-    DynamoFM_Log.testLog('error_stack_2.getSimplified:\n', error_stack_2.getErrorSimplified());
-    DynamoFM_Log.testLog('error_stack_withoutSubErrors_2:\n', error_stack_withoutSubErrors_2);
-    DynamoFM_Log.testLog('error_selfDefined:\n', error_selfDefined);
-    DynamoFM_Log.testLog('error_selfDefined.getFlat:\n', error_selfDefined.getErrorsFlat());
-    DynamoFM_Log.testLog(
-      'error_selfDefined.getSimplified:\n', error_selfDefined.getErrorSimplified()
-    );
-  });
-  
-  describe('should be defined;', (): void => {
-    it('error object', (): void => {
-      expect(error_0).toBeDefined();
-    });
-
-    it('error stack object', (): void => {
-      expect(error_stack_1).toBeDefined();
-    });
-
-    it('greater error stack object', (): void => {
-      expect(error_stack_2).toBeDefined();
-    });
-
-    it('self defined error object', (): void => {
-      expect(error_selfDefined).toBeDefined();
-    });
-  });
-
-  describe('should be instance of DynamoFM_Error;', (): void => {
-    it('error as DynamoFM_Error object', (): void => {
-      expect(error_0).toBeInstanceOf(DynamoFM_Error);
-    });
-
-    it('error stack as DynamoFM_Error object', (): void => {
-      expect(error_stack_1).toBeInstanceOf(DynamoFM_Error);
-    });
-
-    it('greater error stack as DynamoFM_Error object', (): void => {
-      expect(error_stack_2).toBeInstanceOf(DynamoFM_Error);
-    });
-
-    it('self defined error as DynamoFM_Error object', (): void => {
-      expect(error_selfDefined).toBeInstanceOf(DynamoFM_Error);
-    });
-  });
-
-  describe('should have the proper _errorCode;', (): void => {
-    it('on error_0', (): void => {
-      expect(error_0._errorCode).toBe(errorCode_0);
-    });
-
-    it('on error_stack_1', (): void => {
-      expect(error_stack_1._errorCode).toBe(errorCode_0);
-    });
-
-    it('on error_stack_2', (): void => {
-      expect(error_stack_2._errorCode).toBe(errorCode_0);
-    });
-
-    it('on self defined error', (): void => {
-      expect(error_selfDefined._errorCode).toBe(DynamoFM_error_defaults.errorCode);
-    });
-  });
-
-  describe('should have the proper _errorCodes;', (): void => {
-    it('on error_0', (): void => {
-      expect(error_0._errorCodes).toEqual([ errorCode_0 ]);
-    });
-    
-    it('on error_stack_1', (): void => {
-      expect(error_stack_1._errorCodes).toEqual([ errorCode_0, errorCode_1 ]);
-    });
-
-    it('on error_stack_2', (): void => {
-      expect(error_stack_2._errorCodes).toEqual([ errorCode_0, errorCode_1, errorCode_2 ]);
-    });
-
-    it('on self defined error', (): void => {
-      expect(error_selfDefined._errorCodes).toEqual([ DynamoFM_error_defaults.errorCode ]);
-    });
-  });
-
-  describe('should have the proper _message;', (): void => {
-    it('on error_0', (): void => {
-      expect(error_0._message).toBe(message_base);
-    });
-
-    it('on error_stack_1', (): void => {
-      expect(error_stack_1._message).toBe(message_base);
-    });
-
-    it('on error_stack_2', (): void => {
-      expect(error_stack_2._message).toBe(message_base);
-    });
-
-    it('on self defined error', (): void => {
-      expect(error_selfDefined._message).toBe(message_selfDefined);
-    });
-  });
-
-  describe('should have the proper _messages;', (): void => {
-    it('on error_0', (): void => {
-      expect(error_0._messages).toEqual([ message_base ]);
-    });
-
-    it('on error_stack_1', (): void => {
-      expect(error_stack_1._messages).toEqual([ message_base, message_1 ]);
-    });
-
-    it('on error_stack_2', (): void => {
-      expect(error_stack_2._messages).toEqual([ message_base, message_1, message_2 ]);
-    });
-
-    it('on self defined error', (): void => {
-      expect(error_selfDefined._messages).toEqual([ message_selfDefined ]);
-    });
-  });
-
-  describe('should have the proper __userMessage;', (): void => {
-    it('on error_0', (): void => {
-      expect(error_0.__userMessage).toBe(userMessageResult_0);
-    });
-
-    it('on error_stack_1', (): void => {
-      expect(error_stack_1.__userMessage).toBe(userMessageResult_0);
-    });
-
-    it('on error_stack_2', (): void => {
-      expect(error_stack_2.__userMessage).toBe(userMessageResult_0);
-    });
-
-    it('on self defined error', (): void => {
-      expect(error_selfDefined.__userMessage).toBeUndefined();
-    });
-  });
-
-  describe('should have the proper __userMessages;', (): void => {
-    it('on error_0', (): void => {
-      expect(error_0.__userMessages).toEqual([ userMessageResult_0 ]);
-    });
-
-    it('on error_stack_1', (): void => {
-      expect(error_stack_1.__userMessages).toEqual(
-        [ userMessageResult_0, DynamoFM_error_defaults.userMessage ]
-      );
-    });
-
-    it('on error_stack_2', (): void => {
-      expect(error_stack_2.__userMessages).toEqual(
-        [ userMessageResult_0, DynamoFM_error_defaults.userMessage, userMessageResult_2 ]
-      );
-    });
-
-    it('on self defined error', (): void => {
-      expect(error_selfDefined.__userMessages).toEqual([ DynamoFM_error_defaults.userMessage ]);
-    });
-  });
-
-  describe('should have proper error;', (): void => {
-    it('on error_0', (): void => {
-      expect(error_0.error).toBe(error_base);
-    });
-
-    it('on error_stack_1', (): void => {
-      expect(error_stack_1.error).toBe(error_base);
-    });
-
-    it('on error_stack_2', (): void => {
-      expect(error_stack_2.error).toBe(error_base);
-    });
-
-    it('on self defined error', (): void => {
-      expect(error_selfDefined.error).toBeDefined();
-    });
-  });
-
-  describe('should have the proper errors;', (): void => {
-    it('on error_0', (): void => {
-      expect(error_0.errors).toEqual([ error_base ]);
-    });
-
-    it('on error_stack_1', (): void => {
-      expect(error_stack_1.errors).toEqual([ error_base, error_0 ]);
-    });
-
-    it('on error_stack_2', (): void => {
-      expect(error_stack_2.errors).toEqual([ error_base, error_0, error_stack_1 ]);
-    });
-
-    it('on self defined error', (): void => {
-      expect(error_selfDefined?.errors?.length).toBe(1);
-    });
-  });
-
-  describe('should have proper handled;', (): void => {
-    it('on error_0', (): void => {
-      expect(error_0.___handled).toBe(false);
-    });
-
-    it('on error_stack_1', (): void => {
-      expect(error_stack_1.___handled).toBe(true);
-    });
-
-    it('on error_stack_2', (): void => {
-      expect(error_stack_2.___handled).toBe(true);
-    });
-
-    it('on self defined error', (): void => {
-      expect(error_selfDefined.___handled).toBe(false);
-    });
-  });
-
-  describe('should have status: undefined;', (): void => {
-    it('on error_0', (): void => {
-      expect(error_0.___status).toBe(undefined);
-    });
-
-    it('on error_stack_1', (): void => {
-      expect(error_stack_1.___status).toBe(undefined);
-    });
-
-    it('on error_stack_2', (): void => {
-      expect(error_stack_2.___status).toBe(undefined);
-    });
-
-    it('on self defined error', (): void => {
-      expect(error_selfDefined.___status).toBe(undefined);
-    });
-  });
-
-  describe('should have the proper issuer;', (): void => {
-    it('on error_0', (): void => {
-      expect(error_0.___issuer).toBe(issuer);
-    });
-
-    it('on error_stack_1', (): void => {
-      expect(error_stack_1.___issuer).toBe(issuer);
-    });
-
-    it('on error_stack_2', (): void => {
-      expect(error_stack_2.___issuer).toBe(issuer);
-    });
-
-    it('on self defined error', (): void => {
-      expect(error_selfDefined.___issuer).toBe(DynamoFM_error_defaults.issuer);
-    });
-  });
-  
-  describe('should have get proper additionalContent;', (): void => {
-    it('on error_0', (): void => {
-      expect(error_0.additionalContent).toEqual({});
-    });
-
-    it('on error_stack_1', (): void => {
-      expect(error_stack_1.additionalContent).toEqual(additionalContent_1);
-    });
-
-    it('on error_stack_2', (): void => {
-      expect(error_stack_2.additionalContent).toEqual({ 
-        ...additionalContent_1,
-        ...additionalContent_2, 
-      });
-    });
-
-    it('on self defined error', (): void => {
-      expect(error_selfDefined.additionalContent).toEqual({});
-    });
-  });
-
-  describe('should have the proper issuerSystem;', (): void => {
-    it('on error_0', (): void => {
-      expect(error_0.___issuerSystem).toBe(issuerSystem);
-    });
-
-    it('on error_stack_1', (): void => {
-      expect(error_stack_1.___issuerSystem).toBe(issuerSystem);
-    });
-
-    it('on error_stack_2', (): void => {
-      expect(error_stack_2.___issuerSystem).toBe(issuerSystem);
-    });
-
-    it('on self defined error', (): void => {
-      expect(error_selfDefined.___issuerSystem).toBe(DynamoFM_error_defaults.issuerSystem);
-    });
-  });
-
-  describe('should have the proper issuerService;', (): void => {
-    it('on error_0', (): void => {
-      expect(error_0.___issuerService).toBe(issuerService_0);
-    });
-
-    it('on error_stack_1', (): void => {
-      expect(error_stack_1.___issuerService).toBe(issuerService_1);
-    });
-
-    it('on error_stack_2', (): void => {
-      expect(error_stack_2.___issuerService).toBe(issuerService_1);
-    });
-
-    it('on self defined error', (): void => {
-      expect(error_selfDefined.___issuerService).toBe(DynamoFM_error_defaults.issuerService);
-    });
-  });
-
-  describe('should have get proper simplified;', (): void => {
-    let simplified;
-
-    describe('on error_0;', (): void => {
-      beforeEach((): void => {
-        simplified = error_0.getErrorSimplified();
-      });
-      
-      it('should be defined', (): void => {
-        expect(simplified).toBeDefined();
-      });
-
-      it('should have error', (): void => {
-        expect(simplified.error).toBeDefined();
-      });
-
-      it('should not have errors', (): void => {
-        expect(simplified.errors).toBeUndefined();
-      });
-
-      it('should not have simplified.error.error', (): void => {
-        expect((simplified.error as DynamoFM_Error)?.error).toBeUndefined();
-      });
-
-      it('should not have simplified.error.errors', (): void => {
-        expect((simplified.error as DynamoFM_Error)?.errors).toBeUndefined();
-      });
-    });
-
-    describe('on error_stack_1;', (): void => {
-      beforeEach((): void => {
-        simplified = error_stack_1.getErrorSimplified();
-      });
-      
-      it('should be defined', (): void => {
-        expect(simplified).toBeDefined();
-      });
-
-      it('should have error', (): void => {
-        expect(simplified.error).toBeDefined();
-      });
-
-      it('should not have errors', (): void => {
-        expect(simplified.errors).toBeUndefined();
-      });
-
-      it('should not have simplified.error.error', (): void => {
-        expect((simplified.error as DynamoFM_Error)?.error).toBeUndefined();
-      });
-
-      it('should not have simplified.error.errors', (): void => {
-        expect((simplified.error as DynamoFM_Error)?.errors).toBeUndefined();
-      });
-    });
-
-    describe('on error_stack_2;', (): void => {
-      beforeEach((): void => {
-        simplified = error_stack_2.getErrorSimplified();
-      });
-      
-      it('should be defined', (): void => {
-        expect(simplified).toBeDefined();
-      });
-
-      it('should have error', (): void => {
-        expect(simplified.error).toBeDefined();
-      });
-
-      it('should not have errors', (): void => {
-        expect(simplified.errors).toBeUndefined();
-      });
-
-      it('should not have simplified.error.error', (): void => {
-        expect((simplified.error as DynamoFM_Error)?.error).toBeUndefined();
-      });
-
-      it('should not have simplified.error.errors', (): void => {
-        expect((simplified.error as DynamoFM_Error)?.errors).toBeUndefined();
-      });
-    });
-
-    describe('on self defined error;', (): void => {
-      beforeEach((): void => {
-        simplified = error_selfDefined.getErrorSimplified();
-      });
-      
-      it('should be defined', (): void => {
-        expect(simplified).toBeDefined();
-      });
-
-      it('should have error', (): void => {
-        expect(simplified.error).toBeDefined();
-      });
-
-      it('should not have errors', (): void => {
-        expect(simplified.errors).toBeUndefined();
-      });
-
-      it('should not have simplified.error.error', (): void => {
-        expect((simplified.error as DynamoFM_Error)?.error).toBeUndefined();
-      });
-
-      it('should not have simplified.error.errors', (): void => {
-        expect((simplified.error as DynamoFM_Error)?.errors).toBeUndefined();
-      });
-    });
-  });
-
-  describe('should have get proper flat;', (): void => {
-    let flat;
-
-    describe('on error_0;', (): void => {
-      beforeEach((): void => {
-        flat = error_0.getErrorsFlat();
-      });
-      
-      it('should be defined', (): void => {
-        expect(flat).toBeDefined();
-      });
-
-      it('should have error', (): void => {
-        expect(flat.error).toBeDefined();
-      });
-
-      describe('errors...;', (): void => {
-        it('should have errors', (): void => {
-          expect(flat?.errors).toBeDefined();
-        });
-        
-        it('should have 1 errors', (): void => {
-          expect(flat?.errors?.length).toBe(1);
-        });
-
-        flat?.errors?.forEach((error: DynamoFM_Error, index: number): void => {
-          describe(`on error[${index}];`, (): void => {
-            it('should be', (): void => {
-              expect(error).toBeDefined();
-            });
-
-            it(`should have error[${index}].error`, (): void => {
-              expect(error.error).toBeDefined();
-            });
-
-            it(`should not have error[${index}].errors`, (): void => {
-              expect(error.errors).toBeUndefined();
-            });
-
-            it(`should not have error[${index}].error.error`, (): void => {
-              expect((error.error as DynamoFM_Error)?.error).toBeUndefined();
-            });
-
-            it(`should not have error[${index}].error.errors`, (): void => {
-              expect((error.error as DynamoFM_Error)?.errors).toBeUndefined();
-            });
-          });
-        });
-      });
-    });
-
-    describe('on error_stack_1;', (): void => {
-      beforeEach((): void => {
-        flat = error_stack_1.getErrorsFlat();
-      });
-      
-      it('should be defined', (): void => {
-        expect(flat).toBeDefined();
-      });
-
-      it('should have error', (): void => {
-        expect(flat.error).toBeDefined();
-      });
-
-      describe('errors...;', (): void => {
-        it('should have errors', (): void => {
-          expect(flat?.errors).toBeDefined();
-        });
-        
-        it('should have 2 errors', (): void => {
-          expect(flat?.errors?.length).toBe(2);
-        });
-
-        flat?.errors?.forEach((error: DynamoFM_Error, index: number): void => {
-          describe(`on error[${index}];`, (): void => {
-            it('should be', (): void => {
-              expect(error).toBeDefined();
-            });
-
-            it(`should have error[${index}].error`, (): void => {
-              expect(error.error).toBeDefined();
-            });
-
-            it(`should not have error[${index}].errors`, (): void => {
-              expect(error.errors).toBeUndefined();
-            });
-
-            it('should not have error[${index}].error.error', (): void => {
-              expect((error.error as DynamoFM_Error)?.error).toBeUndefined();
-            });
-
-            it('should not have error[${index}].error.errors', (): void => {
-              expect((error.error as DynamoFM_Error)?.errors).toBeUndefined();
-            });
-          });
-        });
-      });
-    });
-
-    describe('on error_stack_2;', (): void => {
-      beforeEach((): void => {
-        flat = error_stack_2.getErrorsFlat();
-      });
-      
-      it('should be defined', (): void => {
-        expect(flat).toBeDefined();
-      });
-
-      it('should have error', (): void => {
-        expect(flat.error).toBeDefined();
-      });
-
-      describe('errors...;', (): void => {
-        it('should have errors', (): void => {
-          expect(flat?.errors).toBeDefined();
-        });
-        
-        it('should have 3 errors', (): void => {
-          expect(flat?.errors?.length).toBe(3);
-        });
-
-        flat?.errors?.forEach((error: DynamoFM_Error, index: number): void => {
-          describe(`on error[${index}];`, (): void => {
-            it('should be', (): void => {
-              expect(error).toBeDefined();
-            });
-
-            it(`should have error[${index}].error`, (): void => {
-              expect(error.error).toBeDefined();
-            });
-
-            it(`should not have error[${index}].errors`, (): void => {
-              expect(error.errors).toBeUndefined();
-            });
-
-            it(`should not have error[${index}].error.error`, (): void => {
-              expect((error.error as DynamoFM_Error)?.error).toBeUndefined();
-            });
-
-            it(`should not have error[${index}].error.errors`, (): void => {
-              expect((error.error as DynamoFM_Error)?.errors).toBeUndefined();
-            });
-          });
-        });
-      });
-    }); 
-
-    describe('on self defined error;', (): void => {
-      beforeEach((): void => {
-        flat = error_selfDefined.getErrorsFlat();
-      });
-      
-      it('should be defined', (): void => {
-        expect(flat).toBeDefined();
-      });
-
-      it('should have error', (): void => {
-        expect(flat.error).toBeDefined();
-      });
-
-      describe('errors...;', (): void => {
-        it('should have errors', (): void => {
-          expect(flat?.errors).toBeDefined();
-        });
-        
-        it('should have 1 errors', (): void => {
-          expect(flat?.errors?.length).toBe(1);
-        });
-
-        flat?.errors?.forEach((error: DynamoFM_Error, index: number): void => {
-          describe(`on error[${index}];`, (): void => {
-            it('should be', (): void => {
-              expect(error).toBeDefined();
-            });
-
-            it(`should have error[${index}].error`, (): void => {
-              expect(error.error).toBeDefined();
-            });
-
-            it(`should not have error[${index}].errors`, (): void => {
-              expect(error.errors).toBeUndefined();
-            });
-
-            it(`should not have error[${index}].error.error`, (): void => {
-              expect((error.error as DynamoFM_Error)?.error).toBeUndefined();
-            });
-
-            it(`should not have error[${index}].error.errors`, (): void => {
-              expect((error.error as DynamoFM_Error)?.errors).toBeUndefined();
-            });
-          });
-        });
-      });
-    });
-  });
-});
-
+
+
+import { DynamoFM_error_defaults } from '../../_collections/constants/error-defaults.const';
+import { DynamoFM_Log } from '../../_collections/utils/log.util';
+import { DynamoFM_Error } from './error.control-model';
+
+describe('DynamoFM_Error;', (): void => {
+  let error_base: Error;
+  let error_0: DynamoFM_Error;
+  let error_stack_1: DynamoFM_Error;
+  let error_stack_withoutSubErrors_1: DynamoFM_Error;
+  let error_stack_2: DynamoFM_Error;
+  let error_stack_withoutSubErrors_2: DynamoFM_Error;
+  let error_selfDefined: DynamoFM_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 = 'error.control-model.spec.js:82:29';
+  
+  const errorCode_0: string = 'ASD-ASD-001';
+  const errorCode_1: string = 'ASD-ASD-002';
+  const errorCode_2: string = 'ASD-ASD-003';
+
+  const userMessage_0: string = 'DynamoFM_Error TEST was TEST! (0)';
+  const userMessage_2: string = 'DynamoFM_Error TEST was TEST! (2)';
+
+  const userMessageResult_0: string = userMessage_0 + `\nErrorCode: ${errorCode_0}`;
+  const userMessageResult_2: string = userMessage_2 + `\nErrorCode: ${errorCode_2}`;
+
+  const issuer: string = 'DynamoFM_Error TEST User';
+  const issuerSystem: string = 'DynamoFM_FSM TEST';
+  const issuerService_0: string = 'Service-0';
+  const issuerService_1: string = 'Service-1';
+
+  const additionalContent_1 = {
+    test: 'test',
+    test2: 'test2',
+  };
+  const additionalContent_2 = {
+    test2: 'testZ',
+    test3: 'test3',
+  };
+  
+  const log: boolean = false;
+  /* const log: boolean = true; */
+
+  beforeEach(async (): Promise<void> => {
+    error_base = new Error(message_base);
+
+    error_0 = new DynamoFM_Error({
+      userMessage: userMessage_0,
+      addECToUserMsg: true,
+      errorCode: errorCode_0,
+      issuerSystem: issuerSystem,
+      issuer: issuer,
+      issuerService: issuerService_0,
+      error: error_base,
+    });
+
+    error_stack_1 = new DynamoFM_Error({
+      message: message_1,
+      errorCode: errorCode_1,
+      issuerService: issuerService_1,
+      handled: true,
+      additionalContent: additionalContent_1,
+      error: error_0,
+    });
+
+    error_stack_withoutSubErrors_1 = {
+      ...error_stack_1,
+    } as DynamoFM_Error;
+    error_stack_withoutSubErrors_1.errors.forEach((error: DynamoFM_Error): any => {
+      const subError = { ...error };
+
+      delete (subError as DynamoFM_Error).errors;
+
+      return subError;
+    });
+
+    error_stack_2 = new DynamoFM_Error({
+      message: message_2,
+      userMessage: userMessage_2,
+      addECToUserMsg: true,
+      errorCode: errorCode_2,
+      additionalContent: additionalContent_2,
+      error: error_stack_1,
+    });
+
+    error_stack_withoutSubErrors_2 = {
+      ...error_stack_2,
+    } as DynamoFM_Error;
+    error_stack_withoutSubErrors_2.errors.map((error: DynamoFM_Error): any => {
+      const subError = { ...error };
+
+      delete (subError as DynamoFM_Error).errors;
+
+      return subError;
+    });
+
+    error_selfDefined = new DynamoFM_Error();
+  });
+
+  if (log) afterAll(async (): Promise<void> => {
+    DynamoFM_Log.testLog('error_stack_2:\n', error_stack_2);
+    DynamoFM_Log.testLog('error_stack_2.getFlat:\n', error_stack_2.getErrorsFlat());
+    DynamoFM_Log.testLog('error_stack_2.getSimplified:\n', error_stack_2.getErrorSimplified());
+    DynamoFM_Log.testLog('error_stack_withoutSubErrors_2:\n', error_stack_withoutSubErrors_2);
+    DynamoFM_Log.testLog('error_selfDefined:\n', error_selfDefined);
+    DynamoFM_Log.testLog('error_selfDefined.getFlat:\n', error_selfDefined.getErrorsFlat());
+    DynamoFM_Log.testLog(
+      'error_selfDefined.getSimplified:\n', error_selfDefined.getErrorSimplified()
+    );
+  });
+  
+  describe('should be defined;', (): void => {
+    it('error object', (): void => {
+      expect(error_0).toBeDefined();
+    });
+
+    it('error stack object', (): void => {
+      expect(error_stack_1).toBeDefined();
+    });
+
+    it('greater error stack object', (): void => {
+      expect(error_stack_2).toBeDefined();
+    });
+
+    it('self defined error object', (): void => {
+      expect(error_selfDefined).toBeDefined();
+    });
+  });
+
+  describe('should be instance of DynamoFM_Error;', (): void => {
+    it('error as DynamoFM_Error object', (): void => {
+      expect(error_0).toBeInstanceOf(DynamoFM_Error);
+    });
+
+    it('error stack as DynamoFM_Error object', (): void => {
+      expect(error_stack_1).toBeInstanceOf(DynamoFM_Error);
+    });
+
+    it('greater error stack as DynamoFM_Error object', (): void => {
+      expect(error_stack_2).toBeInstanceOf(DynamoFM_Error);
+    });
+
+    it('self defined error as DynamoFM_Error object', (): void => {
+      expect(error_selfDefined).toBeInstanceOf(DynamoFM_Error);
+    });
+  });
+
+  describe('should have the proper _errorCode;', (): void => {
+    it('on error_0', (): void => {
+      expect(error_0._errorCode).toBe(errorCode_0);
+    });
+
+    it('on error_stack_1', (): void => {
+      expect(error_stack_1._errorCode).toBe(errorCode_0);
+    });
+
+    it('on error_stack_2', (): void => {
+      expect(error_stack_2._errorCode).toBe(errorCode_0);
+    });
+
+    it('on self defined error', (): void => {
+      expect(error_selfDefined._errorCode).toBe(DynamoFM_error_defaults.errorCode);
+    });
+  });
+
+  describe('should have the proper _errorCodes;', (): void => {
+    it('on error_0', (): void => {
+      expect(error_0._errorCodes).toEqual([ errorCode_0 ]);
+    });
+    
+    it('on error_stack_1', (): void => {
+      expect(error_stack_1._errorCodes).toEqual([ errorCode_0, errorCode_1 ]);
+    });
+
+    it('on error_stack_2', (): void => {
+      expect(error_stack_2._errorCodes).toEqual([ errorCode_0, errorCode_1, errorCode_2 ]);
+    });
+
+    it('on self defined error', (): void => {
+      expect(error_selfDefined._errorCodes).toEqual([ DynamoFM_error_defaults.errorCode ]);
+    });
+  });
+
+  describe('should have the proper _message;', (): void => {
+    it('on error_0', (): void => {
+      expect(error_0._message).toBe(message_base);
+    });
+
+    it('on error_stack_1', (): void => {
+      expect(error_stack_1._message).toBe(message_base);
+    });
+
+    it('on error_stack_2', (): void => {
+      expect(error_stack_2._message).toBe(message_base);
+    });
+
+    it('on self defined error (stack)', (): void => {
+      expect(
+        error_selfDefined._message.includes(message_selfDefined)
+      ).withContext(
+        `"${error_selfDefined._message}"` +
+        '\n  not contains' +
+        `\n"${message_selfDefined}"` + 
+        '"\n  '
+      ).toBe(true);
+    });
+    
+    it('on self defined error (flag)', (): void => {
+      expect(
+        error_selfDefined._message.includes(DynamoFM_error_defaults.message)
+      ).withContext(
+        `"${error_selfDefined._message}"` +
+        '\n  not contains' +
+        `\n"${DynamoFM_error_defaults.message}"` + 
+        '"\n  '
+      ).toBe(true);
+    });
+  });
+
+  describe('should have the proper _messages;', (): void => {
+    it('on error_0', (): void => {
+      expect(error_0._messages).toEqual([ message_base ]);
+    });
+
+    it('on error_stack_1', (): void => {
+      expect(error_stack_1._messages).toEqual([ message_base, message_1 ]);
+    });
+
+    it('on error_stack_2', (): void => {
+      expect(error_stack_2._messages).toEqual([ message_base, message_1, message_2 ]);
+    });
+
+    it('on self defined error (stack)', (): void => {
+      expect(
+        error_selfDefined._messages.length === 1 && 
+        error_selfDefined._messages?.[0]?.includes(message_selfDefined)
+      ).withContext(
+        `"${error_selfDefined._messages?.[0]}"` +
+        '\n  not contains' +
+        `\n"${message_selfDefined}"` + 
+        '"\n  '
+      ).toBe(true);
+    });
+
+    it('on self defined error (flag)', (): void => {
+      expect(
+        error_selfDefined._messages.length === 1 && 
+        error_selfDefined._messages?.[0]?.includes(DynamoFM_error_defaults.message)
+      ).withContext(
+        `"${error_selfDefined._messages?.[0]}"` +
+        '\n  not contains' +
+        `\n"${DynamoFM_error_defaults.message}"` + 
+        '"\n  '
+      ).toBe(true);
+    });
+  });
+
+  describe('should have the proper __userMessage;', (): void => {
+    it('on error_0', (): void => {
+      expect(error_0.__userMessage).toBe(userMessageResult_0);
+    });
+
+    it('on error_stack_1', (): void => {
+      expect(error_stack_1.__userMessage).toBe(userMessageResult_0);
+    });
+
+    it('on error_stack_2', (): void => {
+      expect(error_stack_2.__userMessage).toBe(userMessageResult_0);
+    });
+
+    it('on self defined error', (): void => {
+      expect(error_selfDefined.__userMessage).toBeUndefined();
+    });
+  });
+
+  describe('should have the proper __userMessages;', (): void => {
+    it('on error_0', (): void => {
+      expect(error_0.__userMessages).toEqual([ userMessageResult_0 ]);
+    });
+
+    it('on error_stack_1', (): void => {
+      expect(error_stack_1.__userMessages).toEqual(
+        [ userMessageResult_0, DynamoFM_error_defaults.userMessage ]
+      );
+    });
+
+    it('on error_stack_2', (): void => {
+      expect(error_stack_2.__userMessages).toEqual(
+        [ userMessageResult_0, DynamoFM_error_defaults.userMessage, userMessageResult_2 ]
+      );
+    });
+
+    it('on self defined error', (): void => {
+      expect(error_selfDefined.__userMessages).toEqual([ DynamoFM_error_defaults.userMessage ]);
+    });
+  });
+
+  describe('should have proper error;', (): void => {
+    it('on error_0', (): void => {
+      expect(error_0.error).toBe(error_base);
+    });
+
+    it('on error_stack_1', (): void => {
+      expect(error_stack_1.error).toBe(error_base);
+    });
+
+    it('on error_stack_2', (): void => {
+      expect(error_stack_2.error).toBe(error_base);
+    });
+
+    it('on self defined error', (): void => {
+      expect(error_selfDefined.error).toBeDefined();
+    });
+  });
+
+  describe('should have the proper errors;', (): void => {
+    it('on error_0', (): void => {
+      expect(error_0.errors).toEqual([ error_base ]);
+    });
+
+    it('on error_stack_1', (): void => {
+      expect(error_stack_1.errors).toEqual([ error_base, error_0 ]);
+    });
+
+    it('on error_stack_2', (): void => {
+      expect(error_stack_2.errors).toEqual([ error_base, error_0, error_stack_1 ]);
+    });
+
+    it('on self defined error', (): void => {
+      expect(error_selfDefined?.errors?.length).toBe(1);
+    });
+  });
+
+  describe('should have proper handled;', (): void => {
+    it('on error_0', (): void => {
+      expect(error_0.___handled).toBe(false);
+    });
+
+    it('on error_stack_1', (): void => {
+      expect(error_stack_1.___handled).toBe(true);
+    });
+
+    it('on error_stack_2', (): void => {
+      expect(error_stack_2.___handled).toBe(true);
+    });
+
+    it('on self defined error', (): void => {
+      expect(error_selfDefined.___handled).toBe(false);
+    });
+  });
+
+  describe('should have status: undefined;', (): void => {
+    it('on error_0', (): void => {
+      expect(error_0.___status).toBe(undefined);
+    });
+
+    it('on error_stack_1', (): void => {
+      expect(error_stack_1.___status).toBe(undefined);
+    });
+
+    it('on error_stack_2', (): void => {
+      expect(error_stack_2.___status).toBe(undefined);
+    });
+
+    it('on self defined error', (): void => {
+      expect(error_selfDefined.___status).toBe(undefined);
+    });
+  });
+
+  describe('should have the proper issuer;', (): void => {
+    it('on error_0', (): void => {
+      expect(error_0.___issuer).toBe(issuer);
+    });
+
+    it('on error_stack_1', (): void => {
+      expect(error_stack_1.___issuer).toBe(issuer);
+    });
+
+    it('on error_stack_2', (): void => {
+      expect(error_stack_2.___issuer).toBe(issuer);
+    });
+
+    it('on self defined error', (): void => {
+      expect(error_selfDefined.___issuer).toBe(DynamoFM_error_defaults.issuer);
+    });
+  });
+  
+  describe('should have get proper additionalContent;', (): void => {
+    it('on error_0', (): void => {
+      expect(error_0.additionalContent).toEqual({});
+    });
+
+    it('on error_stack_1', (): void => {
+      expect(error_stack_1.additionalContent).toEqual(additionalContent_1);
+    });
+
+    it('on error_stack_2', (): void => {
+      expect(error_stack_2.additionalContent).toEqual({ 
+        ...additionalContent_1,
+        ...additionalContent_2, 
+      });
+    });
+
+    it('on self defined error', (): void => {
+      expect(error_selfDefined.additionalContent).toEqual({});
+    });
+  });
+
+  describe('should have the proper issuerSystem;', (): void => {
+    it('on error_0', (): void => {
+      expect(error_0.___issuerSystem).toBe(issuerSystem);
+    });
+
+    it('on error_stack_1', (): void => {
+      expect(error_stack_1.___issuerSystem).toBe(issuerSystem);
+    });
+
+    it('on error_stack_2', (): void => {
+      expect(error_stack_2.___issuerSystem).toBe(issuerSystem);
+    });
+
+    it('on self defined error', (): void => {
+      expect(error_selfDefined.___issuerSystem).toBe(DynamoFM_error_defaults.issuerSystem);
+    });
+  });
+
+  describe('should have the proper issuerService;', (): void => {
+    it('on error_0', (): void => {
+      expect(error_0.___issuerService).toBe(issuerService_0);
+    });
+
+    it('on error_stack_1', (): void => {
+      expect(error_stack_1.___issuerService).toBe(issuerService_1);
+    });
+
+    it('on error_stack_2', (): void => {
+      expect(error_stack_2.___issuerService).toBe(issuerService_1);
+    });
+
+    it('on self defined error', (): void => {
+      expect(error_selfDefined.___issuerService).toBe(DynamoFM_error_defaults.issuerService);
+    });
+  });
+
+  describe('should have get proper simplified;', (): void => {
+    let simplified;
+
+    describe('on error_0;', (): void => {
+      beforeEach((): void => {
+        simplified = error_0.getErrorSimplified();
+      });
+      
+      it('should be defined', (): void => {
+        expect(simplified).toBeDefined();
+      });
+
+      it('should have error', (): void => {
+        expect(simplified.error).toBeDefined();
+      });
+
+      it('should not have errors', (): void => {
+        expect(simplified.errors).toBeUndefined();
+      });
+
+      it('should not have simplified.error.error', (): void => {
+        expect((simplified.error as DynamoFM_Error)?.error).toBeUndefined();
+      });
+
+      it('should not have simplified.error.errors', (): void => {
+        expect((simplified.error as DynamoFM_Error)?.errors).toBeUndefined();
+      });
+    });
+
+    describe('on error_stack_1;', (): void => {
+      beforeEach((): void => {
+        simplified = error_stack_1.getErrorSimplified();
+      });
+      
+      it('should be defined', (): void => {
+        expect(simplified).toBeDefined();
+      });
+
+      it('should have error', (): void => {
+        expect(simplified.error).toBeDefined();
+      });
+
+      it('should not have errors', (): void => {
+        expect(simplified.errors).toBeUndefined();
+      });
+
+      it('should not have simplified.error.error', (): void => {
+        expect((simplified.error as DynamoFM_Error)?.error).toBeUndefined();
+      });
+
+      it('should not have simplified.error.errors', (): void => {
+        expect((simplified.error as DynamoFM_Error)?.errors).toBeUndefined();
+      });
+    });
+
+    describe('on error_stack_2;', (): void => {
+      beforeEach((): void => {
+        simplified = error_stack_2.getErrorSimplified();
+      });
+      
+      it('should be defined', (): void => {
+        expect(simplified).toBeDefined();
+      });
+
+      it('should have error', (): void => {
+        expect(simplified.error).toBeDefined();
+      });
+
+      it('should not have errors', (): void => {
+        expect(simplified.errors).toBeUndefined();
+      });
+
+      it('should not have simplified.error.error', (): void => {
+        expect((simplified.error as DynamoFM_Error)?.error).toBeUndefined();
+      });
+
+      it('should not have simplified.error.errors', (): void => {
+        expect((simplified.error as DynamoFM_Error)?.errors).toBeUndefined();
+      });
+    });
+
+    describe('on self defined error;', (): void => {
+      beforeEach((): void => {
+        simplified = error_selfDefined.getErrorSimplified();
+      });
+      
+      it('should be defined', (): void => {
+        expect(simplified).toBeDefined();
+      });
+
+      it('should have error', (): void => {
+        expect(simplified.error).toBeDefined();
+      });
+
+      it('should not have errors', (): void => {
+        expect(simplified.errors).toBeUndefined();
+      });
+
+      it('should not have simplified.error.error', (): void => {
+        expect((simplified.error as DynamoFM_Error)?.error).toBeUndefined();
+      });
+
+      it('should not have simplified.error.errors', (): void => {
+        expect((simplified.error as DynamoFM_Error)?.errors).toBeUndefined();
+      });
+    });
+  });
+
+  describe('should have get proper flat;', (): void => {
+    let flat;
+
+    describe('on error_0;', (): void => {
+      beforeEach((): void => {
+        flat = error_0.getErrorsFlat();
+      });
+      
+      it('should be defined', (): void => {
+        expect(flat).toBeDefined();
+      });
+
+      it('should have error', (): void => {
+        expect(flat.error).toBeDefined();
+      });
+
+      describe('errors...;', (): void => {
+        it('should have errors', (): void => {
+          expect(flat?.errors).toBeDefined();
+        });
+        
+        it('should have 1 errors', (): void => {
+          expect(flat?.errors?.length).toBe(1);
+        });
+
+        flat?.errors?.forEach((error: DynamoFM_Error, index: number): void => {
+          describe(`on error[${index}];`, (): void => {
+            it('should be', (): void => {
+              expect(error).toBeDefined();
+            });
+
+            it(`should have error[${index}].error`, (): void => {
+              expect(error.error).toBeDefined();
+            });
+
+            it(`should not have error[${index}].errors`, (): void => {
+              expect(error.errors).toBeUndefined();
+            });
+
+            it(`should not have error[${index}].error.error`, (): void => {
+              expect((error.error as DynamoFM_Error)?.error).toBeUndefined();
+            });
+
+            it(`should not have error[${index}].error.errors`, (): void => {
+              expect((error.error as DynamoFM_Error)?.errors).toBeUndefined();
+            });
+          });
+        });
+      });
+    });
+
+    describe('on error_stack_1;', (): void => {
+      beforeEach((): void => {
+        flat = error_stack_1.getErrorsFlat();
+      });
+      
+      it('should be defined', (): void => {
+        expect(flat).toBeDefined();
+      });
+
+      it('should have error', (): void => {
+        expect(flat.error).toBeDefined();
+      });
+
+      describe('errors...;', (): void => {
+        it('should have errors', (): void => {
+          expect(flat?.errors).toBeDefined();
+        });
+        
+        it('should have 2 errors', (): void => {
+          expect(flat?.errors?.length).toBe(2);
+        });
+
+        flat?.errors?.forEach((error: DynamoFM_Error, index: number): void => {
+          describe(`on error[${index}];`, (): void => {
+            it('should be', (): void => {
+              expect(error).toBeDefined();
+            });
+
+            it(`should have error[${index}].error`, (): void => {
+              expect(error.error).toBeDefined();
+            });
+
+            it(`should not have error[${index}].errors`, (): void => {
+              expect(error.errors).toBeUndefined();
+            });
+
+            it('should not have error[${index}].error.error', (): void => {
+              expect((error.error as DynamoFM_Error)?.error).toBeUndefined();
+            });
+
+            it('should not have error[${index}].error.errors', (): void => {
+              expect((error.error as DynamoFM_Error)?.errors).toBeUndefined();
+            });
+          });
+        });
+      });
+    });
+
+    describe('on error_stack_2;', (): void => {
+      beforeEach((): void => {
+        flat = error_stack_2.getErrorsFlat();
+      });
+      
+      it('should be defined', (): void => {
+        expect(flat).toBeDefined();
+      });
+
+      it('should have error', (): void => {
+        expect(flat.error).toBeDefined();
+      });
+
+      describe('errors...;', (): void => {
+        it('should have errors', (): void => {
+          expect(flat?.errors).toBeDefined();
+        });
+        
+        it('should have 3 errors', (): void => {
+          expect(flat?.errors?.length).toBe(3);
+        });
+
+        flat?.errors?.forEach((error: DynamoFM_Error, index: number): void => {
+          describe(`on error[${index}];`, (): void => {
+            it('should be', (): void => {
+              expect(error).toBeDefined();
+            });
+
+            it(`should have error[${index}].error`, (): void => {
+              expect(error.error).toBeDefined();
+            });
+
+            it(`should not have error[${index}].errors`, (): void => {
+              expect(error.errors).toBeUndefined();
+            });
+
+            it(`should not have error[${index}].error.error`, (): void => {
+              expect((error.error as DynamoFM_Error)?.error).toBeUndefined();
+            });
+
+            it(`should not have error[${index}].error.errors`, (): void => {
+              expect((error.error as DynamoFM_Error)?.errors).toBeUndefined();
+            });
+          });
+        });
+      });
+    }); 
+
+    describe('on self defined error;', (): void => {
+      beforeEach((): void => {
+        flat = error_selfDefined.getErrorsFlat();
+      });
+      
+      it('should be defined', (): void => {
+        expect(flat).toBeDefined();
+      });
+
+      it('should have error', (): void => {
+        expect(flat.error).toBeDefined();
+      });
+
+      describe('errors...;', (): void => {
+        it('should have errors', (): void => {
+          expect(flat?.errors).toBeDefined();
+        });
+        
+        it('should have 1 errors', (): void => {
+          expect(flat?.errors?.length).toBe(1);
+        });
+
+        flat?.errors?.forEach((error: DynamoFM_Error, index: number): void => {
+          describe(`on error[${index}];`, (): void => {
+            it('should be', (): void => {
+              expect(error).toBeDefined();
+            });
+
+            it(`should have error[${index}].error`, (): void => {
+              expect(error.error).toBeDefined();
+            });
+
+            it(`should not have error[${index}].errors`, (): void => {
+              expect(error.errors).toBeUndefined();
+            });
+
+            it(`should not have error[${index}].error.error`, (): void => {
+              expect((error.error as DynamoFM_Error)?.error).toBeUndefined();
+            });
+
+            it(`should not have error[${index}].error.errors`, (): void => {
+              expect((error.error as DynamoFM_Error)?.errors).toBeUndefined();
+            });
+          });
+        });
+      });
+    });
+  });
+});
+