@futdevpro/fsm-dynamo 1.15.18 → 1.15.20

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

@@ -1,912 +1,912 @@
-
-
-import { DyFM_error_defaults } from '../../_collections/constants/error-defaults.const';
-import { DyFM_Log } from '../../_collections/utils/log.util';
-import { DyFM_Error, DyFM_Error_Settings } from './error.control-model';
-
-function testFormatter(any: any): any {
-  if (any instanceof Error) {
-    return any;
-  } else {
-    return `\n${JSON.stringify(any, null, 2)}\n`;
-  }
-}
-
-describe('| DyFM_Error;', (): void => {
-  let error_base: Error;
-  let error_0: DyFM_Error;
-  let error_stack_1: DyFM_Error;
-  let error_stack_withoutSubErrors_1: DyFM_Error;
-  let error_stack_2: DyFM_Error;
-  let error_stack_withoutSubErrors_2: DyFM_Error;
-  let error_selfDefined: DyFM_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:89: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 = 'DyFM_Error TEST was TEST! (0)';
-  const userMessage_2: string = 'DyFM_Error TEST was TEST! (2)';
-
-  const userMessageResult_0: string = userMessage_0 + `\n  ErrorCode: ${errorCode_0}`;
-  const userMessageResult_2: string = userMessage_2 + `\n  ErrorCode: ${errorCode_2}`;
-
-  const issuer: string = 'DyFM_Error TEST User';
-  const issuerSystem: string = 'DyFM_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 DyFM_Error({
-      userMessage: userMessage_0,
-      addECToUserMsg: true,
-      errorCode: errorCode_0,
-      issuerSystem: issuerSystem,
-      issuer: issuer,
-      issuerService: issuerService_0,
-      error: error_base,
-    });
-
-    error_stack_1 = new DyFM_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 DyFM_Error;
-    error_stack_withoutSubErrors_1.errors.forEach((error: DyFM_Error): any => {
-      const subError = { ...error } as DyFM_Error;
-
-      delete subError.errors;
-
-      return subError;
-    });
-
-    error_stack_2 = new DyFM_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 DyFM_Error;
-
-    error_stack_withoutSubErrors_2.errors = error_stack_withoutSubErrors_2.errors.map(
-      (error: DyFM_Error): any => ({ ...error })
-    );
-
-    error_stack_withoutSubErrors_2.errors.forEach((subError: DyFM_Error): any => {
-      delete subError.errors;
-    });
-
-    error_selfDefined = new DyFM_Error();
-  });
-
-  if (log) afterAll(async (): Promise<void> => {
-    DyFM_Log.testLog('error_stack_2:\n', error_stack_2);
-    DyFM_Log.testLog('error_stack_2.getFlat:\n', error_stack_2.getErrorsFlat());
-    DyFM_Log.testLog('error_stack_2.getSimplified:\n', error_stack_2.getErrorSimplified());
-    DyFM_Log.testLog('error_stack_withoutSubErrors_2:\n', error_stack_withoutSubErrors_2);
-    DyFM_Log.testLog('error_selfDefined:\n', error_selfDefined);
-    DyFM_Log.testLog('error_selfDefined.getFlat:\n', error_selfDefined.getErrorsFlat());
-    DyFM_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 DyFM_Error;', (): void => {
-    it('| error as DyFM_Error object', (): void => {
-      expect(error_0).toBeInstanceOf(DyFM_Error);
-    });
-
-    it('| error stack as DyFM_Error object', (): void => {
-      expect(error_stack_1).toBeInstanceOf(DyFM_Error);
-    });
-
-    it('| greater error stack as DyFM_Error object', (): void => {
-      expect(error_stack_2).toBeInstanceOf(DyFM_Error);
-    });
-
-    it('| self defined error as DyFM_Error object', (): void => {
-      expect(error_selfDefined).toBeInstanceOf(DyFM_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(DyFM_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([ DyFM_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(DyFM_error_defaults.message)
-      ).withContext(
-        `"${error_selfDefined._message}"` +
-        '\n  not contains' +
-        `\n"${DyFM_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(DyFM_error_defaults.message)
-      ).withContext(
-        `"${error_selfDefined._messages?.[0]}"` +
-        '\n  not contains' +
-        `\n"${DyFM_error_defaults.message}"` + 
-        '"\n  '
-      ).toBe(true);
-    });
-  });
-
-  describe('| getSemanticMessage;', (): void => {
-    it('| on non-DyFM_Error returns getErrorMessage only (no parentheses)', (): void => {
-      const result: string = DyFM_Error.getSemanticMessage(error_base);
-      expect(result).toBe(message_base);
-      expect(result).not.toContain('(');
-    });
-
-    it('| on DyFM_Error with single _messages returns our message only', (): void => {
-      const result: string = DyFM_Error.getSemanticMessage(error_0);
-      expect(result).toBe(message_base);
-    });
-
-    it('| on DyFM_Error chain returns string containing outer message and root in parentheses when different', (): void => {
-      const rootMsg: string = 'root-message';
-      const outerMsg: string = 'outer-message';
-      const errorInner: DyFM_Error = new DyFM_Error({
-        message: rootMsg,
-        error: new Error(),
-      });
-      const errorOuter: DyFM_Error = new DyFM_Error({
-        message: outerMsg,
-        errorCode: 'CUSTOM-SEM-001',
-        error: errorInner,
-      });
-      expect(errorOuter._messages?.length).toBeGreaterThan(1);
-      expect(errorOuter._messages?.[0]).toBe(rootMsg);
-      expect(errorOuter._message).toBe(outerMsg);
-      const result: string = DyFM_Error.getSemanticMessage(errorOuter);
-      expect(result).toBe(`${outerMsg} (${rootMsg})`);
-    });
-
-    it('| on error_stack_2 returns main message (first equals our message so no parentheses)', (): void => {
-      const result: string = DyFM_Error.getSemanticMessage(error_stack_2);
-      expect(result).toBe(message_base);
-    });
-  });
-
-  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, DyFM_error_defaults.userMessage ]
-      );
-    });
-
-    it('| on error_stack_2', (): void => {
-      expect(error_stack_2.__userMessages).toEqual(
-        [ userMessageResult_0, DyFM_error_defaults.userMessage, userMessageResult_2 ]
-      );
-    });
-
-    it('| on self defined error', (): void => {
-      expect(error_selfDefined.__userMessages).toEqual([ DyFM_error_defaults.userMessage ]);
-    });
-  });
-
-  describe('| should have proper error;', (): void => {
-    it('| on error_0', (): void => {
-      expect(testFormatter(error_0.error)).toBe(
-        testFormatter(error_base)
-      );
-    });
-
-    it('| on error_stack_1', (): void => {
-      expect(testFormatter(error_stack_1.error)).toBe(
-        testFormatter(error_base)
-      );
-    });
-
-    it('| on error_stack_2', (): void => {
-      expect(testFormatter(error_stack_2.error)).toBe(
-        testFormatter(error_base)
-      );
-    });
-
-    it('| on self defined error', (): void => {
-      expect(testFormatter(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 => {
-      const error_0_withoutSubErrors = { ...error_0 } as DyFM_Error;
-
-      delete error_0_withoutSubErrors.errors;
-      delete error_0_withoutSubErrors.additionalContent;
-      
-      expect(testFormatter(error_stack_1.errors)).toEqual(
-        testFormatter([ error_base, error_0_withoutSubErrors ])
-      );
-    });
-
-    it('| on error_stack_2', (): void => {
-      const error_0_withoutSubErrors = { ...error_0 } as DyFM_Error;
-      const error_stack_1_withoutSubErrors = { ...error_stack_1 } as DyFM_Error;
-
-      delete error_0_withoutSubErrors.errors;
-      delete error_0_withoutSubErrors.additionalContent;
-      delete error_stack_1_withoutSubErrors.errors;
-      delete error_stack_1_withoutSubErrors.additionalContent;
-
-      expect(testFormatter(error_stack_2.errors)).toEqual(
-        testFormatter([ error_base, error_0_withoutSubErrors, error_stack_1_withoutSubErrors ])
-      );
-    });
-
-    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(DyFM_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(DyFM_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(DyFM_error_defaults.issuerService);
-    });
-  });
-
-  describe('| should have get proper simplified;', (): void => {
-    let simplified: DyFM_Error_Settings;
-
-    describe('| on error_0;', (): void => {
-      beforeEach((): void => {
-        simplified = error_0.getErrorSimplified();
-      });
-      
-      it('| should be defined', (): void => {
-        expect(simplified).toBeDefined();
-      });
-
-      it('| should have errorCode', (): void => {
-        expect(simplified.errorCode).toBeDefined();
-      });
-
-      it('| should have message', (): void => {
-        expect(simplified.message).toBeDefined();
-      });
-
-      it('| should have userMessage', (): void => {
-        expect(simplified.userMessage).toBeDefined();
-      });
-
-      it('| should have stack', (): void => {
-        expect(simplified.stack).toBeDefined();
-      });
-
-      it('| should not have error', (): void => {
-        expect(simplified.error).toBeUndefined();
-      });
-
-      it('| should not have errors', (): void => {
-        expect(simplified.errors).toBeUndefined();
-      });
-
-      it('| should not have simplified.error.error', (): void => {
-        expect((simplified.error as DyFM_Error)?.error).toBeUndefined();
-      });
-
-      it('| should not have simplified.error.errors', (): void => {
-        expect((simplified.error as DyFM_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 errorCode', (): void => {
-        expect(simplified.errorCode).toBeDefined();
-      });
-
-      it('| should have message', (): void => {
-        expect(simplified.message).toBeDefined();
-      });
-
-      it('| should have userMessage', (): void => {
-        expect(simplified.userMessage).toBeDefined();
-      });
-
-      it('| should have stack', (): void => {
-        expect(simplified.stack).toBeDefined();
-      });
-
-      it('| should not have error', (): void => {
-        expect(simplified.error).toBeUndefined();
-      });
-
-      it('| should not have errors', (): void => {
-        expect(simplified.errors).toBeUndefined();
-      });
-
-      it('| should not have simplified.error.error', (): void => {
-        expect((simplified.error as DyFM_Error)?.error).toBeUndefined();
-      });
-
-      it('| should not have simplified.error.errors', (): void => {
-        expect((simplified.error as DyFM_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 errorCode', (): void => {
-        expect(simplified.errorCode).toBeDefined();
-      });
-
-      it('| should have message', (): void => {
-        expect(simplified.message).toBeDefined();
-      });
-
-      it('| should have userMessage', (): void => {
-        expect(simplified.userMessage).toBeDefined();
-      });
-
-      it('| should have stack', (): void => {
-        expect(simplified.stack).toBeDefined();
-      });
-
-      it('| should not have error', (): void => {
-        expect(simplified.error).toBeUndefined();
-      });
-
-      it('| should not have errors', (): void => {
-        expect(simplified.errors).toBeUndefined();
-      });
-
-      it('| should not have simplified.error.error', (): void => {
-        expect((simplified.error as DyFM_Error)?.error).toBeUndefined();
-      });
-
-      it('| should not have simplified.error.errors', (): void => {
-        expect((simplified.error as DyFM_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 errorCode', (): void => {
-        expect(simplified.errorCode).toBeDefined();
-      });
-
-      it('| should have message', (): void => {
-        expect(simplified.message).toBeDefined();
-      });
-
-      it('| should not have userMessage', (): void => {
-        expect(simplified.userMessage).toBeUndefined();
-      });
-
-      it('| should have stack', (): void => {
-        expect(simplified.stack).toBeDefined();
-      });
-
-      it('| should not have error', (): void => {
-        expect(simplified.error).toBeUndefined();
-      });
-
-      it('| should not have errors', (): void => {
-        expect(simplified.errors).toBeUndefined();
-      });
-
-      it('| should not have simplified.error.error', (): void => {
-        expect((simplified.error as DyFM_Error)?.error).toBeUndefined();
-      });
-
-      it('| should not have simplified.error.errors', (): void => {
-        expect((simplified.error as DyFM_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: DyFM_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 DyFM_Error)?.error).toBeUndefined();
-            });
-
-            it(`should not have error[${index}].error.errors`, (): void => {
-              expect((error.error as DyFM_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: DyFM_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 DyFM_Error)?.error).toBeUndefined();
-            });
-
-            it('| should not have error[${index}].error.errors', (): void => {
-              expect((error.error as DyFM_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: DyFM_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 DyFM_Error)?.error).toBeUndefined();
-            });
-
-            it(`should not have error[${index}].error.errors`, (): void => {
-              expect((error.error as DyFM_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: DyFM_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 DyFM_Error)?.error).toBeUndefined();
-            });
-
-            it(`should not have error[${index}].error.errors`, (): void => {
-              expect((error.error as DyFM_Error)?.errors).toBeUndefined();
-            });
-          });
-        });
-      });
-    });
-
-    describe('| stack', (): void => {
-      it('| error lvl3 should have the stack from the first', (): void => {
-        const error_lvl1 = new Error('error_lvl1');
-        
-        const error_lvl2 = new DyFM_Error({
-          error: error_lvl1,
-        });
-
-        const error_lvl3 = new DyFM_Error({
-          error: error_lvl2,
-        });
-
-        expect(error_lvl3.stack).toBe(error_lvl1.stack);
-      });
-    });
-  });
-
-  describe('| logSimple;', (): void => {
-    it('| should not fail', (): void => {
-      const error = new DyFM_Error({
-        error: new Error('error'),
-      });
-
-      expect(error.logSimple('test')).toBeUndefined();
-    });
-  });
-});
-
+
+
+import { DyFM_error_defaults } from '../../_collections/constants/error-defaults.const';
+import { DyFM_Log } from '../../_collections/utils/log.util';
+import { DyFM_Error, DyFM_Error_Settings } from './error.control-model';
+
+function testFormatter(any: any): any {
+  if (any instanceof Error) {
+    return any;
+  } else {
+    return `\n${JSON.stringify(any, null, 2)}\n`;
+  }
+}
+
+describe('| DyFM_Error;', (): void => {
+  let error_base: Error;
+  let error_0: DyFM_Error;
+  let error_stack_1: DyFM_Error;
+  let error_stack_withoutSubErrors_1: DyFM_Error;
+  let error_stack_2: DyFM_Error;
+  let error_stack_withoutSubErrors_2: DyFM_Error;
+  let error_selfDefined: DyFM_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:89: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 = 'DyFM_Error TEST was TEST! (0)';
+  const userMessage_2: string = 'DyFM_Error TEST was TEST! (2)';
+
+  const userMessageResult_0: string = userMessage_0 + `\n  ErrorCode: ${errorCode_0}`;
+  const userMessageResult_2: string = userMessage_2 + `\n  ErrorCode: ${errorCode_2}`;
+
+  const issuer: string = 'DyFM_Error TEST User';
+  const issuerSystem: string = 'DyFM_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 DyFM_Error({
+      userMessage: userMessage_0,
+      addECToUserMsg: true,
+      errorCode: errorCode_0,
+      issuerSystem: issuerSystem,
+      issuer: issuer,
+      issuerService: issuerService_0,
+      error: error_base,
+    });
+
+    error_stack_1 = new DyFM_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 DyFM_Error;
+    error_stack_withoutSubErrors_1.errors.forEach((error: DyFM_Error): any => {
+      const subError = { ...error } as DyFM_Error;
+
+      delete subError.errors;
+
+      return subError;
+    });
+
+    error_stack_2 = new DyFM_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 DyFM_Error;
+
+    error_stack_withoutSubErrors_2.errors = error_stack_withoutSubErrors_2.errors.map(
+      (error: DyFM_Error): any => ({ ...error })
+    );
+
+    error_stack_withoutSubErrors_2.errors.forEach((subError: DyFM_Error): any => {
+      delete subError.errors;
+    });
+
+    error_selfDefined = new DyFM_Error();
+  });
+
+  if (log) afterAll(async (): Promise<void> => {
+    DyFM_Log.testLog('error_stack_2:\n', error_stack_2);
+    DyFM_Log.testLog('error_stack_2.getFlat:\n', error_stack_2.getErrorsFlat());
+    DyFM_Log.testLog('error_stack_2.getSimplified:\n', error_stack_2.getErrorSimplified());
+    DyFM_Log.testLog('error_stack_withoutSubErrors_2:\n', error_stack_withoutSubErrors_2);
+    DyFM_Log.testLog('error_selfDefined:\n', error_selfDefined);
+    DyFM_Log.testLog('error_selfDefined.getFlat:\n', error_selfDefined.getErrorsFlat());
+    DyFM_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 DyFM_Error;', (): void => {
+    it('| error as DyFM_Error object', (): void => {
+      expect(error_0).toBeInstanceOf(DyFM_Error);
+    });
+
+    it('| error stack as DyFM_Error object', (): void => {
+      expect(error_stack_1).toBeInstanceOf(DyFM_Error);
+    });
+
+    it('| greater error stack as DyFM_Error object', (): void => {
+      expect(error_stack_2).toBeInstanceOf(DyFM_Error);
+    });
+
+    it('| self defined error as DyFM_Error object', (): void => {
+      expect(error_selfDefined).toBeInstanceOf(DyFM_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(DyFM_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([ DyFM_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(DyFM_error_defaults.message)
+      ).withContext(
+        `"${error_selfDefined._message}"` +
+        '\n  not contains' +
+        `\n"${DyFM_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(DyFM_error_defaults.message)
+      ).withContext(
+        `"${error_selfDefined._messages?.[0]}"` +
+        '\n  not contains' +
+        `\n"${DyFM_error_defaults.message}"` + 
+        '"\n  '
+      ).toBe(true);
+    });
+  });
+
+  describe('| getSemanticMessage;', (): void => {
+    it('| on non-DyFM_Error returns getErrorMessage only (no parentheses)', (): void => {
+      const result: string = DyFM_Error.getSemanticMessage(error_base);
+      expect(result).toBe(message_base);
+      expect(result).not.toContain('(');
+    });
+
+    it('| on DyFM_Error with single _messages returns our message only', (): void => {
+      const result: string = DyFM_Error.getSemanticMessage(error_0);
+      expect(result).toBe(message_base);
+    });
+
+    it('| on DyFM_Error chain returns string containing outer message and root in parentheses when different', (): void => {
+      const rootMsg: string = 'root-message';
+      const outerMsg: string = 'outer-message';
+      const errorInner: DyFM_Error = new DyFM_Error({
+        message: rootMsg,
+        error: new Error(),
+      });
+      const errorOuter: DyFM_Error = new DyFM_Error({
+        message: outerMsg,
+        errorCode: 'CUSTOM-SEM-001',
+        error: errorInner,
+      });
+      expect(errorOuter._messages?.length).toBeGreaterThan(1);
+      expect(errorOuter._messages?.[0]).toBe(rootMsg);
+      expect(errorOuter._message).toBe(outerMsg);
+      const result: string = DyFM_Error.getSemanticMessage(errorOuter);
+      expect(result).toBe(`${outerMsg} (${rootMsg})`);
+    });
+
+    it('| on error_stack_2 returns main message (first equals our message so no parentheses)', (): void => {
+      const result: string = DyFM_Error.getSemanticMessage(error_stack_2);
+      expect(result).toBe(message_base);
+    });
+  });
+
+  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, DyFM_error_defaults.userMessage ]
+      );
+    });
+
+    it('| on error_stack_2', (): void => {
+      expect(error_stack_2.__userMessages).toEqual(
+        [ userMessageResult_0, DyFM_error_defaults.userMessage, userMessageResult_2 ]
+      );
+    });
+
+    it('| on self defined error', (): void => {
+      expect(error_selfDefined.__userMessages).toEqual([ DyFM_error_defaults.userMessage ]);
+    });
+  });
+
+  describe('| should have proper error;', (): void => {
+    it('| on error_0', (): void => {
+      expect(testFormatter(error_0.error)).toBe(
+        testFormatter(error_base)
+      );
+    });
+
+    it('| on error_stack_1', (): void => {
+      expect(testFormatter(error_stack_1.error)).toBe(
+        testFormatter(error_base)
+      );
+    });
+
+    it('| on error_stack_2', (): void => {
+      expect(testFormatter(error_stack_2.error)).toBe(
+        testFormatter(error_base)
+      );
+    });
+
+    it('| on self defined error', (): void => {
+      expect(testFormatter(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 => {
+      const error_0_withoutSubErrors = { ...error_0 } as DyFM_Error;
+
+      delete error_0_withoutSubErrors.errors;
+      delete error_0_withoutSubErrors.additionalContent;
+      
+      expect(testFormatter(error_stack_1.errors)).toEqual(
+        testFormatter([ error_base, error_0_withoutSubErrors ])
+      );
+    });
+
+    it('| on error_stack_2', (): void => {
+      const error_0_withoutSubErrors = { ...error_0 } as DyFM_Error;
+      const error_stack_1_withoutSubErrors = { ...error_stack_1 } as DyFM_Error;
+
+      delete error_0_withoutSubErrors.errors;
+      delete error_0_withoutSubErrors.additionalContent;
+      delete error_stack_1_withoutSubErrors.errors;
+      delete error_stack_1_withoutSubErrors.additionalContent;
+
+      expect(testFormatter(error_stack_2.errors)).toEqual(
+        testFormatter([ error_base, error_0_withoutSubErrors, error_stack_1_withoutSubErrors ])
+      );
+    });
+
+    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(DyFM_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(DyFM_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(DyFM_error_defaults.issuerService);
+    });
+  });
+
+  describe('| should have get proper simplified;', (): void => {
+    let simplified: DyFM_Error_Settings;
+
+    describe('| on error_0;', (): void => {
+      beforeEach((): void => {
+        simplified = error_0.getErrorSimplified();
+      });
+      
+      it('| should be defined', (): void => {
+        expect(simplified).toBeDefined();
+      });
+
+      it('| should have errorCode', (): void => {
+        expect(simplified.errorCode).toBeDefined();
+      });
+
+      it('| should have message', (): void => {
+        expect(simplified.message).toBeDefined();
+      });
+
+      it('| should have userMessage', (): void => {
+        expect(simplified.userMessage).toBeDefined();
+      });
+
+      it('| should have stack', (): void => {
+        expect(simplified.stack).toBeDefined();
+      });
+
+      it('| should not have error', (): void => {
+        expect(simplified.error).toBeUndefined();
+      });
+
+      it('| should not have errors', (): void => {
+        expect(simplified.errors).toBeUndefined();
+      });
+
+      it('| should not have simplified.error.error', (): void => {
+        expect((simplified.error as DyFM_Error)?.error).toBeUndefined();
+      });
+
+      it('| should not have simplified.error.errors', (): void => {
+        expect((simplified.error as DyFM_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 errorCode', (): void => {
+        expect(simplified.errorCode).toBeDefined();
+      });
+
+      it('| should have message', (): void => {
+        expect(simplified.message).toBeDefined();
+      });
+
+      it('| should have userMessage', (): void => {
+        expect(simplified.userMessage).toBeDefined();
+      });
+
+      it('| should have stack', (): void => {
+        expect(simplified.stack).toBeDefined();
+      });
+
+      it('| should not have error', (): void => {
+        expect(simplified.error).toBeUndefined();
+      });
+
+      it('| should not have errors', (): void => {
+        expect(simplified.errors).toBeUndefined();
+      });
+
+      it('| should not have simplified.error.error', (): void => {
+        expect((simplified.error as DyFM_Error)?.error).toBeUndefined();
+      });
+
+      it('| should not have simplified.error.errors', (): void => {
+        expect((simplified.error as DyFM_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 errorCode', (): void => {
+        expect(simplified.errorCode).toBeDefined();
+      });
+
+      it('| should have message', (): void => {
+        expect(simplified.message).toBeDefined();
+      });
+
+      it('| should have userMessage', (): void => {
+        expect(simplified.userMessage).toBeDefined();
+      });
+
+      it('| should have stack', (): void => {
+        expect(simplified.stack).toBeDefined();
+      });
+
+      it('| should not have error', (): void => {
+        expect(simplified.error).toBeUndefined();
+      });
+
+      it('| should not have errors', (): void => {
+        expect(simplified.errors).toBeUndefined();
+      });
+
+      it('| should not have simplified.error.error', (): void => {
+        expect((simplified.error as DyFM_Error)?.error).toBeUndefined();
+      });
+
+      it('| should not have simplified.error.errors', (): void => {
+        expect((simplified.error as DyFM_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 errorCode', (): void => {
+        expect(simplified.errorCode).toBeDefined();
+      });
+
+      it('| should have message', (): void => {
+        expect(simplified.message).toBeDefined();
+      });
+
+      it('| should not have userMessage', (): void => {
+        expect(simplified.userMessage).toBeUndefined();
+      });
+
+      it('| should have stack', (): void => {
+        expect(simplified.stack).toBeDefined();
+      });
+
+      it('| should not have error', (): void => {
+        expect(simplified.error).toBeUndefined();
+      });
+
+      it('| should not have errors', (): void => {
+        expect(simplified.errors).toBeUndefined();
+      });
+
+      it('| should not have simplified.error.error', (): void => {
+        expect((simplified.error as DyFM_Error)?.error).toBeUndefined();
+      });
+
+      it('| should not have simplified.error.errors', (): void => {
+        expect((simplified.error as DyFM_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: DyFM_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 DyFM_Error)?.error).toBeUndefined();
+            });
+
+            it(`should not have error[${index}].error.errors`, (): void => {
+              expect((error.error as DyFM_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: DyFM_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 DyFM_Error)?.error).toBeUndefined();
+            });
+
+            it('| should not have error[${index}].error.errors', (): void => {
+              expect((error.error as DyFM_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: DyFM_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 DyFM_Error)?.error).toBeUndefined();
+            });
+
+            it(`should not have error[${index}].error.errors`, (): void => {
+              expect((error.error as DyFM_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: DyFM_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 DyFM_Error)?.error).toBeUndefined();
+            });
+
+            it(`should not have error[${index}].error.errors`, (): void => {
+              expect((error.error as DyFM_Error)?.errors).toBeUndefined();
+            });
+          });
+        });
+      });
+    });
+
+    describe('| stack', (): void => {
+      it('| error lvl3 should have the stack from the first', (): void => {
+        const error_lvl1 = new Error('error_lvl1');
+        
+        const error_lvl2 = new DyFM_Error({
+          error: error_lvl1,
+        });
+
+        const error_lvl3 = new DyFM_Error({
+          error: error_lvl2,
+        });
+
+        expect(error_lvl3.stack).toBe(error_lvl1.stack);
+      });
+    });
+  });
+
+  describe('| logSimple;', (): void => {
+    it('| should not fail', (): void => {
+      const error = new DyFM_Error({
+        error: new Error('error'),
+      });
+
+      expect(error.logSimple('test')).toBeUndefined();
+    });
+  });
+});
+