@futdevpro/fsm-dynamo 1.16.39 → 1.20.2

package/build/_models/control-models/error.control-model.spec.js

@@ -1,749 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const error_defaults_const_1 = require("../../_collections/constants/error-defaults.const");
-const log_util_1 = require("../../_collections/utils/log.util");
-const error_control_model_1 = require("./error.control-model");
-function testFormatter(any) {
-    if (any instanceof Error) {
-        return any;
-    }
-    else {
-        return `\n${JSON.stringify(any, null, 2)}\n`;
-    }
-}
-describe('| DyFM_Error;', () => {
-    let error_base;
-    let error_0;
-    let error_stack_1;
-    let error_stack_withoutSubErrors_1;
-    let error_stack_2;
-    let error_stack_withoutSubErrors_2;
-    let error_selfDefined;
-    const message_base = '-TEST ERROR: something failed!-';
-    const message_1 = 'TEST ERROR MSG (1)';
-    const message_2 = 'TEST ERROR MSG (2)';
-    const message_selfDefined = 'error.control-model.spec.js:89:29';
-    const errorCode_0 = 'ASD-ASD-001';
-    const errorCode_1 = 'ASD-ASD-002';
-    const errorCode_2 = 'ASD-ASD-003';
-    const userMessage_0 = 'DyFM_Error TEST was TEST! (0)';
-    const userMessage_2 = 'DyFM_Error TEST was TEST! (2)';
-    const userMessageResult_0 = userMessage_0 + `\n  ErrorCode: ${errorCode_0}`;
-    const userMessageResult_2 = userMessage_2 + `\n  ErrorCode: ${errorCode_2}`;
-    const issuer = 'DyFM_Error TEST User';
-    const issuerSystem = 'DyFM_FSM TEST';
-    const issuerService_0 = 'Service-0';
-    const issuerService_1 = 'Service-1';
-    const additionalContent_1 = {
-        test: 'test',
-        test2: 'test2',
-    };
-    const additionalContent_2 = {
-        test2: 'testZ',
-        test3: 'test3',
-    };
-    const log = false;
-    /* const log: boolean = true; */
-    beforeEach(async () => {
-        error_base = new Error(message_base);
-        error_0 = new error_control_model_1.DyFM_Error({
-            userMessage: userMessage_0,
-            addECToUserMsg: true,
-            errorCode: errorCode_0,
-            issuerSystem: issuerSystem,
-            issuer: issuer,
-            issuerService: issuerService_0,
-            error: error_base,
-        });
-        error_stack_1 = new error_control_model_1.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,
-        };
-        error_stack_withoutSubErrors_1.errors.forEach((error) => {
-            const subError = { ...error };
-            delete subError.errors;
-            return subError;
-        });
-        error_stack_2 = new error_control_model_1.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,
-        };
-        error_stack_withoutSubErrors_2.errors = error_stack_withoutSubErrors_2.errors.map((error) => ({ ...error }));
-        error_stack_withoutSubErrors_2.errors.forEach((subError) => {
-            delete subError.errors;
-        });
-        error_selfDefined = new error_control_model_1.DyFM_Error();
-    });
-    if (log)
-        afterAll(async () => {
-            log_util_1.DyFM_Log.testLog('error_stack_2:\n', error_stack_2);
-            log_util_1.DyFM_Log.testLog('error_stack_2.getFlat:\n', error_stack_2.getErrorsFlat());
-            log_util_1.DyFM_Log.testLog('error_stack_2.getSimplified:\n', error_stack_2.getErrorSimplified());
-            log_util_1.DyFM_Log.testLog('error_stack_withoutSubErrors_2:\n', error_stack_withoutSubErrors_2);
-            log_util_1.DyFM_Log.testLog('error_selfDefined:\n', error_selfDefined);
-            log_util_1.DyFM_Log.testLog('error_selfDefined.getFlat:\n', error_selfDefined.getErrorsFlat());
-            log_util_1.DyFM_Log.testLog('error_selfDefined.getSimplified:\n', error_selfDefined.getErrorSimplified());
-        });
-    describe('| should be defined;', () => {
-        it('| error object', () => {
-            expect(error_0).toBeDefined();
-        });
-        it('| error stack object', () => {
-            expect(error_stack_1).toBeDefined();
-        });
-        it('| greater error stack object', () => {
-            expect(error_stack_2).toBeDefined();
-        });
-        it('| self defined error object', () => {
-            expect(error_selfDefined).toBeDefined();
-        });
-    });
-    describe('| should be instance of DyFM_Error;', () => {
-        it('| error as DyFM_Error object', () => {
-            expect(error_0).toBeInstanceOf(error_control_model_1.DyFM_Error);
-        });
-        it('| error stack as DyFM_Error object', () => {
-            expect(error_stack_1).toBeInstanceOf(error_control_model_1.DyFM_Error);
-        });
-        it('| greater error stack as DyFM_Error object', () => {
-            expect(error_stack_2).toBeInstanceOf(error_control_model_1.DyFM_Error);
-        });
-        it('| self defined error as DyFM_Error object', () => {
-            expect(error_selfDefined).toBeInstanceOf(error_control_model_1.DyFM_Error);
-        });
-    });
-    describe('| should have the proper _errorCode;', () => {
-        it('| on error_0', () => {
-            expect(error_0._errorCode).toBe(errorCode_0);
-        });
-        it('| on error_stack_1', () => {
-            expect(error_stack_1._errorCode).toBe(errorCode_0);
-        });
-        it('| on error_stack_2', () => {
-            expect(error_stack_2._errorCode).toBe(errorCode_0);
-        });
-        it('| on self defined error', () => {
-            expect(error_selfDefined._errorCode).toBe(error_defaults_const_1.DyFM_error_defaults.errorCode);
-        });
-    });
-    describe('| should have the proper _errorCodes;', () => {
-        it('| on error_0', () => {
-            expect(error_0._errorCodes).toEqual([errorCode_0]);
-        });
-        it('| on error_stack_1', () => {
-            expect(error_stack_1._errorCodes).toEqual([errorCode_0, errorCode_1]);
-        });
-        it('| on error_stack_2', () => {
-            expect(error_stack_2._errorCodes).toEqual([errorCode_0, errorCode_1, errorCode_2]);
-        });
-        it('| on self defined error', () => {
-            expect(error_selfDefined._errorCodes).toEqual([error_defaults_const_1.DyFM_error_defaults.errorCode]);
-        });
-    });
-    describe('| should have the proper _message;', () => {
-        it('| on error_0', () => {
-            expect(error_0._message).toBe(message_base);
-        });
-        it('| on error_stack_1', () => {
-            expect(error_stack_1._message).toBe(message_base);
-        });
-        it('| on error_stack_2', () => {
-            expect(error_stack_2._message).toBe(message_base);
-        });
-        it('| on self defined error (stack)', () => {
-            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)', () => {
-            expect(error_selfDefined._message.includes(error_defaults_const_1.DyFM_error_defaults.message)).withContext(`"${error_selfDefined._message}"` +
-                '\n  not contains' +
-                `\n"${error_defaults_const_1.DyFM_error_defaults.message}"` +
-                '"\n  ').toBe(true);
-        });
-    });
-    describe('| should have the proper _messages;', () => {
-        it('| on error_0', () => {
-            expect(error_0._messages).toEqual([message_base]);
-        });
-        it('| on error_stack_1', () => {
-            expect(error_stack_1._messages).toEqual([message_base, message_1]);
-        });
-        it('| on error_stack_2', () => {
-            expect(error_stack_2._messages).toEqual([message_base, message_1, message_2]);
-        });
-        it('| on self defined error (stack)', () => {
-            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)', () => {
-            expect(error_selfDefined._messages.length === 1 &&
-                error_selfDefined._messages?.[0]?.includes(error_defaults_const_1.DyFM_error_defaults.message)).withContext(`"${error_selfDefined._messages?.[0]}"` +
-                '\n  not contains' +
-                `\n"${error_defaults_const_1.DyFM_error_defaults.message}"` +
-                '"\n  ').toBe(true);
-        });
-    });
-    describe('| getSemanticMessage;', () => {
-        it('| on non-DyFM_Error returns getErrorMessage only (no parentheses)', () => {
-            const result = error_control_model_1.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', () => {
-            const result = error_control_model_1.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', () => {
-            const rootMsg = 'root-message';
-            const outerMsg = 'outer-message';
-            const errorInner = new error_control_model_1.DyFM_Error({
-                message: rootMsg,
-                error: new Error(),
-            });
-            const errorOuter = new error_control_model_1.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 = error_control_model_1.DyFM_Error.getSemanticMessage(errorOuter);
-            expect(result).toBe(`${outerMsg} (${rootMsg})`);
-        });
-        it('| on error_stack_2 returns main message (first equals our message so no parentheses)', () => {
-            const result = error_control_model_1.DyFM_Error.getSemanticMessage(error_stack_2);
-            expect(result).toBe(message_base);
-        });
-    });
-    describe('| should have the proper __userMessage;', () => {
-        it('| on error_0', () => {
-            expect(error_0.__userMessage).toBe(userMessageResult_0);
-        });
-        it('| on error_stack_1', () => {
-            expect(error_stack_1.__userMessage).toBe(userMessageResult_0);
-        });
-        it('| on error_stack_2', () => {
-            expect(error_stack_2.__userMessage).toBe(userMessageResult_0);
-        });
-        it('| on self defined error', () => {
-            expect(error_selfDefined.__userMessage).toBeUndefined();
-        });
-    });
-    describe('| should have the proper __userMessages;', () => {
-        it('| on error_0', () => {
-            expect(error_0.__userMessages).toEqual([userMessageResult_0]);
-        });
-        it('| on error_stack_1', () => {
-            expect(error_stack_1.__userMessages).toEqual([userMessageResult_0, error_defaults_const_1.DyFM_error_defaults.userMessage]);
-        });
-        it('| on error_stack_2', () => {
-            expect(error_stack_2.__userMessages).toEqual([userMessageResult_0, error_defaults_const_1.DyFM_error_defaults.userMessage, userMessageResult_2]);
-        });
-        it('| on self defined error', () => {
-            expect(error_selfDefined.__userMessages).toEqual([error_defaults_const_1.DyFM_error_defaults.userMessage]);
-        });
-    });
-    describe('| should have proper error;', () => {
-        it('| on error_0', () => {
-            expect(testFormatter(error_0.error)).toBe(testFormatter(error_base));
-        });
-        it('| on error_stack_1', () => {
-            expect(testFormatter(error_stack_1.error)).toBe(testFormatter(error_base));
-        });
-        it('| on error_stack_2', () => {
-            expect(testFormatter(error_stack_2.error)).toBe(testFormatter(error_base));
-        });
-        it('| on self defined error', () => {
-            expect(testFormatter(error_selfDefined.error)).toBeDefined();
-        });
-    });
-    describe('| should have the proper errors;', () => {
-        it('| on error_0', () => {
-            expect(error_0.errors).toEqual([error_base]);
-        });
-        it('| on error_stack_1', () => {
-            const error_0_withoutSubErrors = { ...error_0 };
-            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', () => {
-            const error_0_withoutSubErrors = { ...error_0 };
-            const error_stack_1_withoutSubErrors = { ...error_stack_1 };
-            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', () => {
-            expect(error_selfDefined?.errors?.length).toBe(1);
-        });
-    });
-    describe('| should have proper handled;', () => {
-        it('| on error_0', () => {
-            expect(error_0.___handled).toBe(false);
-        });
-        it('| on error_stack_1', () => {
-            expect(error_stack_1.___handled).toBe(true);
-        });
-        it('| on error_stack_2', () => {
-            expect(error_stack_2.___handled).toBe(true);
-        });
-        it('| on self defined error', () => {
-            expect(error_selfDefined.___handled).toBe(false);
-        });
-    });
-    describe('| should have status: undefined;', () => {
-        it('| on error_0', () => {
-            expect(error_0.___status).toBe(undefined);
-        });
-        it('| on error_stack_1', () => {
-            expect(error_stack_1.___status).toBe(undefined);
-        });
-        it('| on error_stack_2', () => {
-            expect(error_stack_2.___status).toBe(undefined);
-        });
-        it('| on self defined error', () => {
-            expect(error_selfDefined.___status).toBe(undefined);
-        });
-    });
-    describe('| should have the proper issuer;', () => {
-        it('| on error_0', () => {
-            expect(error_0.___issuer).toBe(issuer);
-        });
-        it('| on error_stack_1', () => {
-            expect(error_stack_1.___issuer).toBe(issuer);
-        });
-        it('| on error_stack_2', () => {
-            expect(error_stack_2.___issuer).toBe(issuer);
-        });
-        it('| on self defined error', () => {
-            expect(error_selfDefined.___issuer).toBe(error_defaults_const_1.DyFM_error_defaults.issuer);
-        });
-    });
-    describe('| should have get proper additionalContent;', () => {
-        it('| on error_0', () => {
-            expect(error_0.additionalContent).toEqual({});
-        });
-        it('| on error_stack_1', () => {
-            expect(error_stack_1.additionalContent).toEqual(additionalContent_1);
-        });
-        it('| on error_stack_2', () => {
-            expect(error_stack_2.additionalContent).toEqual({
-                ...additionalContent_1,
-                ...additionalContent_2,
-            });
-        });
-        it('| on self defined error', () => {
-            expect(error_selfDefined.additionalContent).toEqual({});
-        });
-    });
-    describe('| should have the proper issuerSystem;', () => {
-        it('| on error_0', () => {
-            expect(error_0.___issuerSystem).toBe(issuerSystem);
-        });
-        it('| on error_stack_1', () => {
-            expect(error_stack_1.___issuerSystem).toBe(issuerSystem);
-        });
-        it('| on error_stack_2', () => {
-            expect(error_stack_2.___issuerSystem).toBe(issuerSystem);
-        });
-        it('| on self defined error', () => {
-            expect(error_selfDefined.___issuerSystem).toBe(error_defaults_const_1.DyFM_error_defaults.issuerSystem);
-        });
-    });
-    describe('| should have the proper issuerService;', () => {
-        it('| on error_0', () => {
-            expect(error_0.___issuerService).toBe(issuerService_0);
-        });
-        it('| on error_stack_1', () => {
-            expect(error_stack_1.___issuerService).toBe(issuerService_1);
-        });
-        it('| on error_stack_2', () => {
-            expect(error_stack_2.___issuerService).toBe(issuerService_1);
-        });
-        it('| on self defined error', () => {
-            expect(error_selfDefined.___issuerService).toBe(error_defaults_const_1.DyFM_error_defaults.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 errorCode', () => {
-                expect(simplified.errorCode).toBeDefined();
-            });
-            it('| should have message', () => {
-                expect(simplified.message).toBeDefined();
-            });
-            it('| should have userMessage', () => {
-                expect(simplified.userMessage).toBeDefined();
-            });
-            it('| should have stack', () => {
-                expect(simplified.stack).toBeDefined();
-            });
-            it('| should not have error', () => {
-                expect(simplified.error).toBeUndefined();
-            });
-            it('| should not have errors', () => {
-                expect(simplified.errors).toBeUndefined();
-            });
-            it('| should not have simplified.error.error', () => {
-                expect(simplified.error?.error).toBeUndefined();
-            });
-            it('| should not have simplified.error.errors', () => {
-                expect(simplified.error?.errors).toBeUndefined();
-            });
-        });
-        describe('| on error_stack_1;', () => {
-            beforeEach(() => {
-                simplified = error_stack_1.getErrorSimplified();
-            });
-            it('| should be defined', () => {
-                expect(simplified).toBeDefined();
-            });
-            it('| should have errorCode', () => {
-                expect(simplified.errorCode).toBeDefined();
-            });
-            it('| should have message', () => {
-                expect(simplified.message).toBeDefined();
-            });
-            it('| should have userMessage', () => {
-                expect(simplified.userMessage).toBeDefined();
-            });
-            it('| should have stack', () => {
-                expect(simplified.stack).toBeDefined();
-            });
-            it('| should not have error', () => {
-                expect(simplified.error).toBeUndefined();
-            });
-            it('| should not have errors', () => {
-                expect(simplified.errors).toBeUndefined();
-            });
-            it('| should not have simplified.error.error', () => {
-                expect(simplified.error?.error).toBeUndefined();
-            });
-            it('| should not have simplified.error.errors', () => {
-                expect(simplified.error?.errors).toBeUndefined();
-            });
-        });
-        describe('| on error_stack_2;', () => {
-            beforeEach(() => {
-                simplified = error_stack_2.getErrorSimplified();
-            });
-            it('| should be defined', () => {
-                expect(simplified).toBeDefined();
-            });
-            it('| should have errorCode', () => {
-                expect(simplified.errorCode).toBeDefined();
-            });
-            it('| should have message', () => {
-                expect(simplified.message).toBeDefined();
-            });
-            it('| should have userMessage', () => {
-                expect(simplified.userMessage).toBeDefined();
-            });
-            it('| should have stack', () => {
-                expect(simplified.stack).toBeDefined();
-            });
-            it('| should not have error', () => {
-                expect(simplified.error).toBeUndefined();
-            });
-            it('| should not have errors', () => {
-                expect(simplified.errors).toBeUndefined();
-            });
-            it('| should not have simplified.error.error', () => {
-                expect(simplified.error?.error).toBeUndefined();
-            });
-            it('| should not have simplified.error.errors', () => {
-                expect(simplified.error?.errors).toBeUndefined();
-            });
-        });
-        describe('| on self defined error;', () => {
-            beforeEach(() => {
-                simplified = error_selfDefined.getErrorSimplified();
-            });
-            it('| should be defined', () => {
-                expect(simplified).toBeDefined();
-            });
-            it('| should have errorCode', () => {
-                expect(simplified.errorCode).toBeDefined();
-            });
-            it('| should have message', () => {
-                expect(simplified.message).toBeDefined();
-            });
-            it('| should not have userMessage', () => {
-                expect(simplified.userMessage).toBeUndefined();
-            });
-            it('| should have stack', () => {
-                expect(simplified.stack).toBeDefined();
-            });
-            it('| should not have error', () => {
-                expect(simplified.error).toBeUndefined();
-            });
-            it('| should not have errors', () => {
-                expect(simplified.errors).toBeUndefined();
-            });
-            it('| should not have simplified.error.error', () => {
-                expect(simplified.error?.error).toBeUndefined();
-            });
-            it('| should not have simplified.error.errors', () => {
-                expect(simplified.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, index) => {
-                    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?.error).toBeUndefined();
-                        });
-                        it(`should not have error[${index}].error.errors`, () => {
-                            expect(error.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, index) => {
-                    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?.error).toBeUndefined();
-                        });
-                        it('| should not have error[${index}].error.errors', () => {
-                            expect(error.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, index) => {
-                    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?.error).toBeUndefined();
-                        });
-                        it(`should not have error[${index}].error.errors`, () => {
-                            expect(error.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, index) => {
-                    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?.error).toBeUndefined();
-                        });
-                        it(`should not have error[${index}].error.errors`, () => {
-                            expect(error.error?.errors).toBeUndefined();
-                        });
-                    });
-                });
-            });
-        });
-        describe('| stack', () => {
-            it('| error lvl3 should have the stack from the first', () => {
-                const error_lvl1 = new Error('error_lvl1');
-                const error_lvl2 = new error_control_model_1.DyFM_Error({
-                    error: error_lvl1,
-                });
-                const error_lvl3 = new error_control_model_1.DyFM_Error({
-                    error: error_lvl2,
-                });
-                expect(error_lvl3.stack).toBe(error_lvl1.stack);
-            });
-        });
-    });
-    describe('| logSimple;', () => {
-        it('| should not fail', () => {
-            const error = new error_control_model_1.DyFM_Error({
-                error: new Error('error'),
-            });
-            expect(error.logSimple('test')).toBeUndefined();
-        });
-    });
-    /**
-     * BFR-FDPTOKENSERVICE-013 — az `ErrorCode:` userMessage-utótag kontrollja: a végfelhasználó
-     * ne kapjon belső hibakódot, és wrapper-láncban ne a KÜLSŐ kód jelenjen meg.
-     */
-    describe('| addECToUserMsg — ErrorCode-utótag kontroll (BFR-FDPTOKENSERVICE-013);', () => {
-        afterEach(() => {
-            delete error_defaults_const_1.DyFM_error_defaults.addECToUserMsg;
-        });
-        it('| addECToUserMsg:true → az utótag rákerül (visszafelé-kompatibilis default)', () => {
-            const error = new error_control_model_1.DyFM_Error({
-                errorCode: 'TEST-EC-1',
-                userMessage: 'Something went wrong.',
-                addECToUserMsg: true,
-                error: new Error('x'),
-            });
-            expect(error.__userMessage).toContain('ErrorCode: TEST-EC-1');
-        });
-        it('| flag nélkül NINCS utótag (az explicit false / kihagyás tiszteletben tartva)', () => {
-            const error = new error_control_model_1.DyFM_Error({
-                errorCode: 'TEST-EC-2',
-                userMessage: 'Something went wrong.',
-                error: new Error('x'),
-            });
-            expect(error.__userMessage).not.toContain('ErrorCode:');
-        });
-        it('| GLOBÁLIS kill-switch: DyFM_error_defaults.addECToUserMsg=false → per-error true mellett SINCS utótag', () => {
-            error_defaults_const_1.DyFM_error_defaults.addECToUserMsg = false;
-            const error = new error_control_model_1.DyFM_Error({
-                errorCode: 'TEST-EC-3',
-                userMessage: 'Something went wrong.',
-                addECToUserMsg: true,
-                error: new Error('x'),
-            });
-            expect(error.__userMessage).not.toContain('ErrorCode:');
-        });
-        it('| wrapper-lánc: már utótagos userMessage-re NEM fűzünk újra (a külső kód nem takarhatja a valódit)', () => {
-            const inner = new error_control_model_1.DyFM_Error({
-                errorCode: 'INNER-EC',
-                userMessage: 'Form error.',
-                addECToUserMsg: true,
-                error: new Error('inner'),
-            });
-            const outer = new error_control_model_1.DyFM_Error({
-                errorCode: 'OUTER-EC',
-                userMessage: inner.__userMessage,
-                addECToUserMsg: true,
-                error: inner,
-            });
-            expect(outer.__userMessage).toContain('ErrorCode: INNER-EC');
-            expect(outer.__userMessage).not.toContain('OUTER-EC');
-        });
-    });
-});
-//# sourceMappingURL=error.control-model.spec.js.map