@futdevpro/fsm-dynamo 1.5.61 → 1.5.64

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

@@ -8,13 +8,15 @@ describe('Dynamo_Error;', () => {
   let error_base: Error;
   let error_0: Dynamo_Error;
   let error_stack_1: Dynamo_Error;
+  let error_stack_withoutSubErrors_1: Dynamo_Error;
   let error_stack_2: Dynamo_Error;
+  let error_stack_withoutSubErrors_2: Dynamo_Error;
   let error_selfDefined: Dynamo_Error;
 
   const message_base: string = '-TEST ERROR: something failed!-';
   const message_1: string = 'TEST ERROR MSG (1)';
   const message_2: string = 'TEST ERROR MSG (2)';
-  const message_selfDefined: string = dynamo_error_default.message + '; error.control-model.spec.js:55:29';
+  const message_selfDefined: string = dynamo_error_default.message + '; error.control-model.spec.js:74:29';
   
   const errorCode_0: string = 'ASD-ASD-001';
   const errorCode_1: string = 'ASD-ASD-002';
@@ -30,6 +32,11 @@ describe('Dynamo_Error;', () => {
   const issuerSystem: string = 'Dynamo_FSM TEST';
   const issuerService_0: string = 'Service-0';
   const issuerService_1: string = 'Service-1';
+
+  const additionalContent_1: any = {
+    test: 'test',
+    test2: 'test2',
+  };
   
   const log: boolean = false;
   /* const log: boolean = true; */
@@ -52,9 +59,19 @@ describe('Dynamo_Error;', () => {
       errorCode: errorCode_1,
       issuerService: issuerService_1,
       handled: true,
+      additionalContent: additionalContent_1,
       error: error_0,
     });
 
+    error_stack_withoutSubErrors_1 = {
+      ...error_stack_1,
+    } as Dynamo_Error;
+    error_stack_withoutSubErrors_1.errors.forEach((error: Dynamo_Error) => {
+      const subError = { ...error };
+      delete (subError as Dynamo_Error).errors;
+      return subError;
+    });
+
     error_stack_2 = new Dynamo_Error({
       message: message_2,
       userMessage: userMessage_2,
@@ -63,13 +80,26 @@ describe('Dynamo_Error;', () => {
       error: error_stack_1,
     });
 
+    error_stack_withoutSubErrors_2 = {
+      ...error_stack_2,
+    } as Dynamo_Error;
+    error_stack_withoutSubErrors_2.errors.map((error: Dynamo_Error) => {
+      const subError = { ...error };
+      delete (subError as Dynamo_Error).errors;
+      return subError;
+    });
+
     error_selfDefined = new Dynamo_Error();
   });
 
   if (log) afterAll(async () => {
-    Dynamo_Log.testLog(
-      'afterAll, error_stack_2:', error_stack_2, '\n\nselfDefined:', error_selfDefined
-    );
+    Dynamo_Log.testLog('error_stack_2:\n', error_stack_2);
+    Dynamo_Log.testLog('error_stack_2.getFlat:\n', error_stack_2.getErrorsFlat());
+    Dynamo_Log.testLog('error_stack_2.getSimplified:\n', error_stack_2.getErrorSimplified());
+    Dynamo_Log.testLog('error_stack_withoutSubErrors_2:\n', error_stack_withoutSubErrors_2);
+    Dynamo_Log.testLog('error_selfDefined:\n', error_selfDefined);
+    Dynamo_Log.testLog('error_selfDefined.getFlat:\n', error_selfDefined.getErrorsFlat());
+    Dynamo_Log.testLog('error_selfDefined.getSimplified:\n', error_selfDefined.getErrorSimplified());
   });
   
   describe('should be defined;', () => {
@@ -126,165 +156,165 @@ describe('Dynamo_Error;', () => {
     });
   });
 
-  describe('should have the proper _message;', () => {
+  describe('should have the proper _errorCodes;', () => {
     it('on error_0', () => {
-      expect(error_0._message).toBe(message_base);
+      expect(error_0._errorCodes).toEqual([ errorCode_0 ]);
     });
-
+    
     it('on error_stack_1', () => {
-      expect(error_stack_1._message).toBe(message_base);
+      expect(error_stack_1._errorCodes).toEqual([ errorCode_0, errorCode_1 ]);
     });
 
     it('on error_stack_2', () => {
-      expect(error_stack_2._message).toBe(message_base);
+      expect(error_stack_2._errorCodes).toEqual([ errorCode_0, errorCode_1, errorCode_2 ]);
     });
 
     it('on self defined error', () => {
-      expect(error_selfDefined._message).toBe(message_selfDefined);
+      expect(error_selfDefined._errorCodes).toEqual([ dynamo_error_default.errorCode ]);
     });
   });
 
-  describe('should have the proper __userMessage;', () => {
+  describe('should have the proper _message;', () => {
     it('on error_0', () => {
-      expect(error_0.__userMessage).toBe(userMessageResult_0);
+      expect(error_0._message).toBe(message_base);
     });
 
     it('on error_stack_1', () => {
-      expect(error_stack_1.__userMessage).toBe(userMessageResult_0);
+      expect(error_stack_1._message).toBe(message_base);
     });
 
     it('on error_stack_2', () => {
-      expect(error_stack_2.__userMessage).toBe(userMessageResult_0);
+      expect(error_stack_2._message).toBe(message_base);
     });
 
     it('on self defined error', () => {
-      expect(error_selfDefined.__userMessage).toBeUndefined();
+      expect(error_selfDefined._message).toBe(message_selfDefined);
     });
   });
 
-  describe('should have proper error;', () => {
+  describe('should have the proper _messages;', () => {
     it('on error_0', () => {
-      expect(error_0.error).toBe(error_base);
+      expect(error_0._messages).toEqual([ message_base ]);
     });
 
     it('on error_stack_1', () => {
-      expect(error_stack_1.error).toBe(error_base);
+      expect(error_stack_1._messages).toEqual([ message_base, message_1 ]);
     });
 
     it('on error_stack_2', () => {
-      expect(error_stack_2.error).toBe(error_base);
+      expect(error_stack_2._messages).toEqual([ message_base, message_1, message_2 ]);
     });
 
     it('on self defined error', () => {
-      expect(error_selfDefined.error).toBeUndefined();
+      expect(error_selfDefined._messages).toEqual([ message_selfDefined ]);
     });
   });
 
-  describe('should have proper handled;', () => {
+  describe('should have the proper __userMessage;', () => {
     it('on error_0', () => {
-      expect(error_0.___handled).toBe(false);
+      expect(error_0.__userMessage).toBe(userMessageResult_0);
     });
 
     it('on error_stack_1', () => {
-      expect(error_stack_1.___handled).toBe(true);
+      expect(error_stack_1.__userMessage).toBe(userMessageResult_0);
     });
 
     it('on error_stack_2', () => {
-      expect(error_stack_2.___handled).toBe(true);
+      expect(error_stack_2.__userMessage).toBe(userMessageResult_0);
     });
 
     it('on self defined error', () => {
-      expect(error_selfDefined.___handled).toBe(false);
+      expect(error_selfDefined.__userMessage).toBeUndefined();
     });
   });
 
-  describe('should have status: undefined;', () => {
+  describe('should have the proper __userMessages;', () => {
     it('on error_0', () => {
-      expect(error_0.___status).toBe(undefined);
+      expect(error_0.__userMessages).toEqual([ userMessageResult_0 ]);
     });
 
     it('on error_stack_1', () => {
-      expect(error_stack_1.___status).toBe(undefined);
+      expect(error_stack_1.__userMessages).toEqual([ userMessageResult_0, dynamo_error_default.userMessage ]);
     });
 
     it('on error_stack_2', () => {
-      expect(error_stack_2.___status).toBe(undefined);
+      expect(error_stack_2.__userMessages).toEqual([ userMessageResult_0, dynamo_error_default.userMessage, userMessageResult_2 ]);
     });
 
     it('on self defined error', () => {
-      expect(error_selfDefined.___status).toBe(undefined);
+      expect(error_selfDefined.__userMessages).toEqual([ dynamo_error_default.userMessage ]);
     });
   });
 
-  describe('should have the proper _errorCodes;', () => {
+  describe('should have proper error;', () => {
     it('on error_0', () => {
-      expect(error_0._errorCodes).toEqual([ errorCode_0 ]);
+      expect(error_0.error).toBe(error_base);
     });
-    
+
     it('on error_stack_1', () => {
-      expect(error_stack_1._errorCodes).toEqual([ errorCode_0, errorCode_1 ]);
+      expect(error_stack_1.error).toBe(error_base);
     });
 
     it('on error_stack_2', () => {
-      expect(error_stack_2._errorCodes).toEqual([ errorCode_0, errorCode_1, errorCode_2 ]);
+      expect(error_stack_2.error).toBe(error_base);
     });
 
     it('on self defined error', () => {
-      expect(error_selfDefined._errorCodes).toEqual([ dynamo_error_default.errorCode ]);
+      expect(error_selfDefined.error).toBeDefined();
     });
   });
 
-  describe('should have the proper _messages;', () => {
+  describe('should have the proper errors;', () => {
     it('on error_0', () => {
-      expect(error_0._messages).toEqual([ message_base ]);
+      expect(error_0.errors).toEqual([ error_base ]);
     });
 
     it('on error_stack_1', () => {
-      expect(error_stack_1._messages).toEqual([ message_base, message_1 ]);
+      expect(error_stack_1.errors).toEqual([ error_base, error_0 ]);
     });
 
     it('on error_stack_2', () => {
-      expect(error_stack_2._messages).toEqual([ message_base, message_1, message_2 ]);
+      expect(error_stack_2.errors).toEqual([ error_base, error_0, error_stack_1 ]);
     });
 
     it('on self defined error', () => {
-      expect(error_selfDefined._messages).toEqual([ message_selfDefined ]);
+      expect(error_selfDefined?.errors?.length).toBe(1);
     });
   });
 
-  describe('should have the proper __userMessages;', () => {
+  describe('should have proper handled;', () => {
     it('on error_0', () => {
-      expect(error_0.__userMessages).toEqual([ userMessageResult_0 ]);
+      expect(error_0.___handled).toBe(false);
     });
 
     it('on error_stack_1', () => {
-      expect(error_stack_1.__userMessages).toEqual([ userMessageResult_0, dynamo_error_default.userMessage ]);
+      expect(error_stack_1.___handled).toBe(true);
     });
 
     it('on error_stack_2', () => {
-      expect(error_stack_2.__userMessages).toEqual([ userMessageResult_0, dynamo_error_default.userMessage, userMessageResult_2 ]);
+      expect(error_stack_2.___handled).toBe(true);
     });
 
     it('on self defined error', () => {
-      expect(error_selfDefined.__userMessages).toEqual([ dynamo_error_default.userMessage ]);
+      expect(error_selfDefined.___handled).toBe(false);
     });
   });
 
-  describe('should have the proper errors;', () => {
+  describe('should have status: undefined;', () => {
     it('on error_0', () => {
-      expect(error_0.errors).toEqual([ error_base ]);
+      expect(error_0.___status).toBe(undefined);
     });
 
     it('on error_stack_1', () => {
-      expect(error_stack_1.errors).toEqual([ error_base, error_0 ]);
+      expect(error_stack_1.___status).toBe(undefined);
     });
 
     it('on error_stack_2', () => {
-      expect(error_stack_2.errors).toEqual([ error_base, error_0, error_stack_1 ]);
+      expect(error_stack_2.___status).toBe(undefined);
     });
 
     it('on self defined error', () => {
-      expect(error_selfDefined.errors).toEqual([]);
+      expect(error_selfDefined.___status).toBe(undefined);
     });
   });
 
@@ -305,6 +335,24 @@ describe('Dynamo_Error;', () => {
       expect(error_selfDefined.___issuer).toBe(dynamo_error_default.issuer);
     });
   });
+  
+  describe('should have get proper additionalContent;', () => {
+    it('on error_0', () => {
+      expect(error_0.additionalContent).toBeUndefined();
+    });
+
+    it('on error_stack_1', () => {
+      expect(error_stack_1.additionalContent).toBe(additionalContent_1);
+    });
+
+    it('on error_stack_2', () => {
+      expect(error_stack_2.additionalContent).toBeUndefined();
+    });
+
+    it('on self defined error', () => {
+      expect(error_selfDefined.additionalContent).toBeUndefined();
+    });
+  });
 
   describe('should have the proper issuerSystem;', () => {
     it('on error_0', () => {
@@ -341,5 +389,309 @@ describe('Dynamo_Error;', () => {
       expect(error_selfDefined.___issuerService).toBe(dynamo_error_default.issuerService);
     });
   });
+
+  describe('should have get proper simplified;', () => {
+    let simplified;
+
+    describe('on error_0;', () => {
+      beforeEach(() => {
+        simplified = error_0.getErrorSimplified();
+      });
+      
+      it('should be defined', () => {
+        expect(simplified).toBeDefined();
+      });
+
+      it('should have error', () => {
+        expect(simplified.error).toBeDefined();
+      });
+
+      it('should not have errors', () => {
+        expect(simplified.errors).toBeUndefined();
+      });
+
+      it('should not have simplified.error.error', () => {
+        expect((simplified.error as Dynamo_Error)?.error).toBeUndefined();
+      });
+
+      it('should not have simplified.error.errors', () => {
+        expect((simplified.error as Dynamo_Error)?.errors).toBeUndefined();
+      });
+    });
+
+    describe('on error_stack_1;', () => {
+      beforeEach(() => {
+        simplified = error_stack_1.getErrorSimplified();
+      });
+      
+      it('should be defined', () => {
+        expect(simplified).toBeDefined();
+      });
+
+      it('should have error', () => {
+        expect(simplified.error).toBeDefined();
+      });
+
+      it('should not have errors', () => {
+        expect(simplified.errors).toBeUndefined();
+      });
+
+      it('should not have simplified.error.error', () => {
+        expect((simplified.error as Dynamo_Error)?.error).toBeUndefined();
+      });
+
+      it('should not have simplified.error.errors', () => {
+        expect((simplified.error as Dynamo_Error)?.errors).toBeUndefined();
+      });
+    });
+
+    describe('on error_stack_2;', () => {
+      beforeEach(() => {
+        simplified = error_stack_2.getErrorSimplified();
+      });
+      
+      it('should be defined', () => {
+        expect(simplified).toBeDefined();
+      });
+
+      it('should have error', () => {
+        expect(simplified.error).toBeDefined();
+      });
+
+      it('should not have errors', () => {
+        expect(simplified.errors).toBeUndefined();
+      });
+
+      it('should not have simplified.error.error', () => {
+        expect((simplified.error as Dynamo_Error)?.error).toBeUndefined();
+      });
+
+      it('should not have simplified.error.errors', () => {
+        expect((simplified.error as Dynamo_Error)?.errors).toBeUndefined();
+      });
+    });
+
+    describe('on self defined error;', () => {
+      beforeEach(() => {
+        simplified = error_selfDefined.getErrorSimplified();
+      });
+      
+      it('should be defined', () => {
+        expect(simplified).toBeDefined();
+      });
+
+      it('should have error', () => {
+        expect(simplified.error).toBeDefined();
+      });
+
+      it('should not have errors', () => {
+        expect(simplified.errors).toBeUndefined();
+      });
+
+      it('should not have simplified.error.error', () => {
+        expect((simplified.error as Dynamo_Error)?.error).toBeUndefined();
+      });
+
+      it('should not have simplified.error.errors', () => {
+        expect((simplified.error as Dynamo_Error)?.errors).toBeUndefined();
+      });
+    });
+  });
+
+  describe('should have get proper flat;', () => {
+    let flat;
+
+    describe('on error_0;', () => {
+      beforeEach(() => {
+        flat = error_0.getErrorsFlat();
+      });
+      
+      it('should be defined', () => {
+        expect(flat).toBeDefined();
+      });
+
+      it('should have error', () => {
+        expect(flat.error).toBeDefined();
+      });
+
+      describe('errors...;', () => {
+        it('should have errors', () => {
+          expect(flat?.errors).toBeDefined();
+        });
+        
+        it('should have 1 errors', () => {
+          expect(flat?.errors?.length).toBe(1);
+        });
+
+        flat?.errors?.forEach((error: Dynamo_Error, index: number) => {
+          describe(`on error[${index}];`, () => {
+            it('should be', () => {
+              expect(error).toBeDefined();
+            });
+
+            it(`should have error[${index}].error`, () => {
+              expect(error.error).toBeDefined();
+            });
+
+            it(`should not have error[${index}].errors`, () => {
+              expect(error.errors).toBeUndefined();
+            });
+
+            it(`should not have error[${index}].error.error`, () => {
+              expect((error.error as Dynamo_Error)?.error).toBeUndefined();
+            });
+
+            it(`should not have error[${index}].error.errors`, () => {
+              expect((error.error as Dynamo_Error)?.errors).toBeUndefined();
+            });
+          });
+        });
+      });
+    });
+
+    describe('on error_stack_1;', () => {
+      beforeEach(() => {
+        flat = error_stack_1.getErrorsFlat();
+      });
+      
+      it('should be defined', () => {
+        expect(flat).toBeDefined();
+      });
+
+      it('should have error', () => {
+        expect(flat.error).toBeDefined();
+      });
+
+      describe('errors...;', () => {
+        it('should have errors', () => {
+          expect(flat?.errors).toBeDefined();
+        });
+        
+        it('should have 2 errors', () => {
+          expect(flat?.errors?.length).toBe(2);
+        });
+
+        flat?.errors?.forEach((error: Dynamo_Error, index: number) => {
+          describe(`on error[${index}];`, () => {
+            it('should be', () => {
+              expect(error).toBeDefined();
+            });
+
+            it(`should have error[${index}].error`, () => {
+              expect(error.error).toBeDefined();
+            });
+
+            it(`should not have error[${index}].errors`, () => {
+              expect(error.errors).toBeUndefined();
+            });
+
+            it('should not have error[${index}].error.error', () => {
+              expect((error.error as Dynamo_Error)?.error).toBeUndefined();
+            });
+
+            it('should not have error[${index}].error.errors', () => {
+              expect((error.error as Dynamo_Error)?.errors).toBeUndefined();
+            });
+          });
+        });
+      });
+    });
+
+    describe('on error_stack_2;', () => {
+      beforeEach(() => {
+        flat = error_stack_2.getErrorsFlat();
+      });
+      
+      it('should be defined', () => {
+        expect(flat).toBeDefined();
+      });
+
+      it('should have error', () => {
+        expect(flat.error).toBeDefined();
+      });
+
+      describe('errors...;', () => {
+        it('should have errors', () => {
+          expect(flat?.errors).toBeDefined();
+        });
+        
+        it('should have 3 errors', () => {
+          expect(flat?.errors?.length).toBe(3);
+        });
+
+        flat?.errors?.forEach((error: Dynamo_Error, index: number) => {
+          describe(`on error[${index}];`, () => {
+            it('should be', () => {
+              expect(error).toBeDefined();
+            });
+
+            it(`should have error[${index}].error`, () => {
+              expect(error.error).toBeDefined();
+            });
+
+            it(`should not have error[${index}].errors`, () => {
+              expect(error.errors).toBeUndefined();
+            });
+
+            it(`should not have error[${index}].error.error`, () => {
+              expect((error.error as Dynamo_Error)?.error).toBeUndefined();
+            });
+
+            it(`should not have error[${index}].error.errors`, () => {
+              expect((error.error as Dynamo_Error)?.errors).toBeUndefined();
+            });
+          });
+        });
+      });
+    }); 
+
+    describe('on self defined error;', () => {
+      beforeEach(() => {
+        flat = error_selfDefined.getErrorsFlat();
+      });
+      
+      it('should be defined', () => {
+        expect(flat).toBeDefined();
+      });
+
+      it('should have error', () => {
+        expect(flat.error).toBeDefined();
+      });
+
+      describe('errors...;', () => {
+        it('should have errors', () => {
+          expect(flat?.errors).toBeDefined();
+        });
+        
+        it('should have 1 errors', () => {
+          expect(flat?.errors?.length).toBe(1);
+        });
+
+        flat?.errors?.forEach((error: Dynamo_Error, index: number) => {
+          describe(`on error[${index}];`, () => {
+            it('should be', () => {
+              expect(error).toBeDefined();
+            });
+
+            it(`should have error[${index}].error`, () => {
+              expect(error.error).toBeDefined();
+            });
+
+            it(`should not have error[${index}].errors`, () => {
+              expect(error.errors).toBeUndefined();
+            });
+
+            it(`should not have error[${index}].error.error`, () => {
+              expect((error.error as Dynamo_Error)?.error).toBeUndefined();
+            });
+
+            it(`should not have error[${index}].error.errors`, () => {
+              expect((error.error as Dynamo_Error)?.errors).toBeUndefined();
+            });
+          });
+        });
+      });
+    });
+  });
 });