@arquimedes.co/eureka-forms 2.0.34-test → 2.0.35-test

package/src/FormSteps/StepFunctions.test.ts

@@ -1,882 +0,0 @@
-import { AYFCityStep } from '../@Types/AYFFormStep';
-import { CBRFormStep } from '../@Types/CBRFormStep';
-import * as Steps from '../@Types/FormStep';
-import { FormStep } from '../@Types/FormStep';
-import AYFFormStepTypes from '../constants/AYFFormStepTypes';
-import CBRFormStepTypes from '../constants/CBRFormStepTypes';
-import StepTypes, {
-    ApiSelectorOptionTypes,
-    ClassifierOptionTypes,
-    EntityValueOptionTypes,
-    OptionTypes,
-} from '../constants/FormStepTypes';
-import {
-    calcDefaultValue,
-    calcFillerSize,
-    calcStepWidth,
-    calcSubSteps,
-    iterateNestedSteps,
-} from './StepFunctions';
-
-describe('StepFunctions', function () {
-    describe('calcFillerSize', function () {
-        test('No maxSize', async () => {
-            const size = calcFillerSize(
-                { type: StepTypes.SELECTOR } as Steps.FormSelector,
-                {},
-                {},
-                {
-                    blockNum: 4,
-                    blockSize: 210,
-                    spacingSize: 20,
-                }
-            );
-            expect(size).toBe(0);
-        });
-
-        test('Selector with no value', async () => {
-            const steps = {
-                idStep: {
-                    id: 'idStep',
-                    type: StepTypes.SELECTOR,
-                    size: 3,
-                    maxSize: 3,
-                } as Steps.FormSelector,
-            };
-
-            const size = calcFillerSize(
-                steps['idStep'],
-                steps,
-                {},
-                {
-                    blockNum: 4,
-                    blockSize: 210,
-                    spacingSize: 20,
-                }
-            );
-            expect(size).toBe(0);
-        });
-
-        test('Selector without nested steps', async () => {
-            const steps = {
-                idStep: {
-                    id: 'idStep',
-                    type: StepTypes.SELECTOR,
-                    size: 3,
-                    maxSize: 3,
-                    options: [
-                        {
-                            label: 'Option',
-                            value: 'option',
-                        },
-                    ],
-                } as Steps.FormSelector,
-            };
-
-            const size = calcFillerSize(
-                steps['idStep'],
-                steps,
-                {
-                    idStep: {
-                        label: 'Option',
-                        value: 'option',
-                    },
-                },
-                {
-                    blockNum: 4,
-                    blockSize: 210,
-                    spacingSize: 20,
-                }
-            );
-            expect(size).toBe(0);
-        });
-
-        test('Selector with nested steps and value', async () => {
-            const steps = {
-                idStep: {
-                    id: 'idStep',
-                    type: StepTypes.SELECTOR,
-                    size: 1,
-                    maxSize: 2,
-                    options: [
-                        {
-                            label: 'Option',
-                            value: 'option',
-                            type: OptionTypes.NESTED,
-                            steps: ['idStep2'],
-                        },
-                    ] as Steps.FormSelector['options'],
-                } as Steps.FormSelector,
-                idStep2: {
-                    id: 'idStep2',
-                    type: StepTypes.TEXTINPUT,
-                    size: 1,
-                } as Steps.TextInput,
-            };
-
-            const size = calcFillerSize(
-                steps['idStep'],
-                steps,
-                {
-                    idStep: {
-                        label: 'Option',
-                        value: 'option',
-                    },
-                },
-                {
-                    blockNum: 4,
-                    blockSize: 210,
-                    spacingSize: 20,
-                }
-            );
-            expect(size).toBe(0);
-        });
-
-        test('Selector with nested steps and no value', async () => {
-            const steps = {
-                idStep: {
-                    id: 'idStep',
-                    type: StepTypes.SELECTOR,
-                    size: 1,
-                    maxSize: 2,
-                    options: [
-                        {
-                            label: 'Option',
-                            value: 'option',
-                            type: OptionTypes.NESTED,
-                            steps: ['idStep2'],
-                        },
-                    ] as Steps.FormSelector['options'],
-                } as Steps.FormSelector,
-                idStep2: {
-                    id: 'idStep2',
-                    type: StepTypes.TEXTINPUT,
-                    size: 1,
-                } as Steps.TextInput,
-            };
-
-            const size = calcFillerSize(
-                steps['idStep'],
-                steps,
-                {},
-                {
-                    blockNum: 4,
-                    blockSize: 210,
-                    spacingSize: 20,
-                }
-            );
-            expect(size).toBe(230);
-        });
-
-        test('ClassifierSelector with nested steps and value', async () => {
-            const steps = {
-                idStep: {
-                    id: 'idStep',
-                    type: StepTypes.CLASSIFIER_SELECTOR,
-                    size: 1,
-                    maxSize: 2,
-                    options: {
-                        idClassifier: {
-                            label: 'Option',
-                            idClassifier: 'idClassifier',
-                            type: ClassifierOptionTypes.NESTED,
-                            steps: ['idStep2'],
-                        },
-                    } as Steps.ClassifierSelector['options'],
-                } as Steps.ClassifierSelector,
-                idStep2: {
-                    id: 'idStep2',
-                    type: StepTypes.TEXTINPUT,
-                    size: 1,
-                } as Steps.TextInput,
-            };
-
-            const size = calcFillerSize(
-                steps['idStep'],
-                steps,
-                {
-                    idStep: 'idClassifier',
-                },
-                {
-                    blockNum: 4,
-                    blockSize: 210,
-                    spacingSize: 20,
-                }
-            );
-            expect(size).toBe(0);
-        });
-
-        test('ClassifierSelector with nested steps and no value', async () => {
-            const steps = {
-                idStep: {
-                    id: 'idStep',
-                    type: StepTypes.CLASSIFIER_SELECTOR,
-                    size: 1,
-                    maxSize: 2,
-                    options: {
-                        idClassifier: {
-                            label: 'Option',
-                            idClassifier: 'idClassifier',
-                            type: ClassifierOptionTypes.NESTED,
-                            steps: ['idStep2'],
-                        },
-                    } as Steps.ClassifierSelector['options'],
-                } as Steps.ClassifierSelector,
-                idStep2: {
-                    id: 'idStep2',
-                    type: StepTypes.TEXTINPUT,
-                    size: 1,
-                } as Steps.TextInput,
-            };
-
-            const size = calcFillerSize(
-                steps['idStep'],
-                steps,
-                {},
-                {
-                    blockNum: 4,
-                    blockSize: 210,
-                    spacingSize: 20,
-                }
-            );
-            expect(size).toBe(230);
-        });
-
-        test('EntityValuePicker with nested steps and value', async () => {
-            const steps = {
-                idStep: {
-                    id: 'idStep',
-                    type: StepTypes.ENTITYVALUEPICKER,
-                    size: 1,
-                    maxSize: 2,
-                    options: {
-                        idEntityValue: {
-                            label: 'Option',
-                            idEntityValue: 'idEntityValue',
-                            type: EntityValueOptionTypes.NESTED,
-                            steps: ['idStep2'],
-                        },
-                    } as Steps.EntityValuePicker['options'],
-                } as Steps.EntityValuePicker,
-                idStep2: {
-                    id: 'idStep2',
-                    type: StepTypes.TEXTINPUT,
-                    size: 1,
-                } as Steps.TextInput,
-            };
-
-            const size = calcFillerSize(
-                steps['idStep'],
-                steps,
-                {
-                    idStep: 'idEntityValue',
-                },
-                {
-                    blockNum: 4,
-                    blockSize: 210,
-                    spacingSize: 20,
-                }
-            );
-            expect(size).toBe(0);
-        });
-
-        test('EntityValuePicker with nested steps and no value', async () => {
-            const steps = {
-                idStep: {
-                    id: 'idStep',
-                    type: StepTypes.ENTITYVALUEPICKER,
-                    size: 1,
-                    maxSize: 2,
-                    options: {
-                        idEntityValue: {
-                            label: 'Option',
-                            idEntityValue: 'idEntityValue',
-                            type: EntityValueOptionTypes.NESTED,
-                            steps: ['idStep2'],
-                        },
-                    } as Steps.EntityValuePicker['options'],
-                } as Steps.EntityValuePicker,
-                idStep2: {
-                    id: 'idStep2',
-                    type: StepTypes.TEXTINPUT,
-                    size: 1,
-                } as Steps.TextInput,
-            };
-
-            const size = calcFillerSize(
-                steps['idStep'],
-                steps,
-                {},
-                {
-                    blockNum: 4,
-                    blockSize: 210,
-                    spacingSize: 20,
-                }
-            );
-            expect(size).toBe(230);
-        });
-
-        test('ApiSelector with nested steps and value', async () => {
-            const steps = {
-                idStep: {
-                    id: 'idStep',
-                    type: StepTypes.API_SELECTOR,
-                    size: 1,
-                    maxSize: 2,
-                    options: {
-                        idOption: {
-                            label: 'Option',
-                            idOption: 'idOption',
-                            type: ApiSelectorOptionTypes.NESTED,
-                            steps: ['idStep2'],
-                        },
-                    } as Steps.ApiSelector['options'],
-                } as Steps.ApiSelector,
-                idStep2: {
-                    id: 'idStep2',
-                    type: StepTypes.TEXTINPUT,
-                    size: 1,
-                } as Steps.TextInput,
-            };
-
-            const size = calcFillerSize(
-                steps['idStep'],
-                steps,
-                {
-                    idStep: 'idOption',
-                },
-                {
-                    blockNum: 4,
-                    blockSize: 210,
-                    spacingSize: 20,
-                }
-            );
-            expect(size).toBe(0);
-        });
-
-        test('ApiSelector with nested steps and no value', async () => {
-            const steps = {
-                idStep: {
-                    id: 'idStep',
-                    type: StepTypes.API_SELECTOR,
-                    size: 1,
-                    maxSize: 2,
-                    options: {
-                        idOption: {
-                            label: 'Option',
-                            idOption: 'idOption',
-                            type: ApiSelectorOptionTypes.NESTED,
-                            steps: ['idStep2'],
-                        },
-                    } as Steps.ApiSelector['options'],
-                } as Steps.ApiSelector,
-                idStep2: {
-                    id: 'idStep2',
-                    type: StepTypes.TEXTINPUT,
-                    size: 1,
-                } as Steps.TextInput,
-            };
-
-            const size = calcFillerSize(
-                steps['idStep'],
-                steps,
-                {},
-                {
-                    blockNum: 4,
-                    blockSize: 210,
-                    spacingSize: 20,
-                }
-            );
-            expect(size).toBe(230);
-        });
-
-        test('Unchecked Checkbox with checked nested steps', async () => {
-            const steps = {
-                idStep: {
-                    id: 'idStep',
-                    type: StepTypes.CHECKBOX,
-                    size: 1,
-                    maxSize: 2,
-                    steps: ['idStep2'],
-                } as Steps.CheckBox,
-                idStep2: {
-                    id: 'idStep2',
-                    type: StepTypes.TEXTINPUT,
-                    size: 1,
-                } as Steps.TextInput,
-            };
-
-            const size = calcFillerSize(
-                steps['idStep'],
-                steps,
-                {},
-                {
-                    blockNum: 4,
-                    blockSize: 210,
-                    spacingSize: 20,
-                }
-            );
-            expect(size).toBe(230);
-        });
-
-        test('Checked Checkbox with unchecked nested steps', async () => {
-            const steps = {
-                idStep: {
-                    id: 'idStep',
-                    type: StepTypes.CHECKBOX,
-                    size: 1,
-                    maxSize: 2,
-                    uncheckedSteps: ['idStep2'],
-                } as Steps.CheckBox,
-                idStep2: {
-                    id: 'idStep2',
-                    type: StepTypes.TEXTINPUT,
-                    size: 1,
-                } as Steps.TextInput,
-            };
-
-            const size = calcFillerSize(
-                steps['idStep'],
-                steps,
-                {
-                    idStep: true,
-                },
-                {
-                    blockNum: 4,
-                    blockSize: 210,
-                    spacingSize: 20,
-                }
-            );
-            expect(size).toBe(230);
-        });
-
-        test('Unchecked Checkbox with unchecked nested steps', async () => {
-            const steps = {
-                idStep: {
-                    id: 'idStep',
-                    type: StepTypes.CHECKBOX,
-                    size: 1,
-                    maxSize: 2,
-                    uncheckedSteps: ['idStep2'],
-                } as Steps.CheckBox,
-                idStep2: {
-                    id: 'idStep2',
-                    type: StepTypes.TEXTINPUT,
-                    size: 1,
-                } as Steps.TextInput,
-            };
-
-            const size = calcFillerSize(
-                steps['idStep'],
-                steps,
-                {},
-                {
-                    blockNum: 4,
-                    blockSize: 210,
-                    spacingSize: 20,
-                }
-            );
-            expect(size).toBe(0);
-        });
-
-        test('Checked Checkbox with checked nested steps', async () => {
-            const steps = {
-                idStep: {
-                    id: 'idStep',
-                    type: StepTypes.CHECKBOX,
-                    size: 1,
-                    maxSize: 2,
-                    steps: ['idStep2'],
-                } as Steps.CheckBox,
-                idStep2: {
-                    id: 'idStep2',
-                    type: StepTypes.TEXTINPUT,
-                    size: 1,
-                } as Steps.TextInput,
-            };
-
-            const size = calcFillerSize(
-                steps['idStep'],
-                steps,
-                {
-                    idStep: true,
-                },
-                {
-                    blockNum: 4,
-                    blockSize: 210,
-                    spacingSize: 20,
-                }
-            );
-            expect(size).toBe(0);
-        });
-    });
-
-    describe('calcStepWidth', function () {
-        test('Size as 1', async () => {
-            const size = calcStepWidth(1, {
-                blockNum: 4,
-                blockSize: 210,
-                spacingSize: 20,
-            });
-            expect(size).toBe(210);
-        });
-
-        test('More than Size 1', async () => {
-            const size = calcStepWidth(2, {
-                blockNum: 4,
-                blockSize: 210,
-                spacingSize: 20,
-            });
-            expect(size).toBe(440);
-        });
-    });
-
-    describe('calcDefaultValue', function () {
-        test('CheckBox', async () => {
-            const defaultValue = calcDefaultValue({
-                type: StepTypes.CHECKBOX,
-            } as Steps.FormStep);
-            expect(defaultValue).toBe(false);
-        });
-
-        test('Checkbox with defaultValue', async () => {
-            const step = {
-                type: StepTypes.CHECKBOX,
-                defaultValue: true,
-            } as FormStep;
-
-            const defaultValue = calcDefaultValue(step);
-            expect(defaultValue).toBe(true);
-        });
-
-        test('Title step type', async () => {
-            const step = {
-                type: StepTypes.TITLE,
-                title: 'Title',
-                description: 'Description',
-            } as FormStep;
-
-            const defaultValue = calcDefaultValue(step);
-            expect(defaultValue).toEqual(undefined);
-        });
-
-        test('Selector, TextInput, ClassifierSelector step types', async () => {
-            const step1 = {
-                type: StepTypes.SELECTOR,
-            } as FormStep;
-
-            const step2 = {
-                type: StepTypes.TEXTINPUT,
-            } as FormStep;
-
-            const step3 = {
-                type: StepTypes.CLASSIFIER_SELECTOR,
-            } as FormStep;
-
-            const defaultValue1 = calcDefaultValue(step1);
-            const defaultValue2 = calcDefaultValue(step2);
-            const defaultValue3 = calcDefaultValue(step3);
-
-            expect(defaultValue1).toBe('');
-            expect(defaultValue2).toBe('');
-            expect(defaultValue3).toBe('');
-        });
-
-        test('Textarea step type with text editor', async () => {
-            const step = {
-                type: StepTypes.TEXTAREA,
-                hasTextEditor: true,
-            } as FormStep;
-
-            const defaultValue = calcDefaultValue(step);
-            expect(defaultValue.blocks[0].text).toBe('');
-        });
-
-        test('Textarea step type without text editor', async () => {
-            const step = {
-                type: StepTypes.TEXTAREA,
-                hasTextEditor: false,
-            } as FormStep;
-
-            const defaultValue = calcDefaultValue(step);
-            expect(defaultValue).toBe('');
-        });
-
-        test('Rating, DatePicker, ApiSelector, EntityValuePicker step types', async () => {
-            const step1 = {
-                type: StepTypes.RATING,
-            } as FormStep;
-
-            const step2 = {
-                type: StepTypes.DATEPICKER,
-            } as FormStep;
-
-            const step3 = {
-                type: StepTypes.API_SELECTOR,
-            } as FormStep;
-
-            const step4 = {
-                type: StepTypes.ENTITYVALUEPICKER,
-            } as FormStep;
-
-            const defaultValue1 = calcDefaultValue(step1);
-            const defaultValue2 = calcDefaultValue(step2);
-            const defaultValue3 = calcDefaultValue(step3);
-            const defaultValue4 = calcDefaultValue(step4);
-
-            expect(defaultValue1).toBe(null);
-            expect(defaultValue2).toBe(null);
-            expect(defaultValue3).toBe(null);
-            expect(defaultValue4).toBe(null);
-        });
-
-        test('Mapper, FileUpload, CBRFormStep types', async () => {
-            const step1 = {
-                type: StepTypes.MAPPER,
-            } as FormStep;
-
-            const step2 = {
-                type: StepTypes.FILEUPLOAD,
-            } as FormStep;
-
-            const step3 = {
-                type: CBRFormStepTypes.CBR_INCIDENCIAS,
-            } as CBRFormStep;
-
-            const defaultValue1 = calcDefaultValue(step1);
-            const defaultValue2 = calcDefaultValue(step2);
-            const defaultValue3 = calcDefaultValue(step3);
-
-            expect(defaultValue1).toEqual([]);
-            expect(defaultValue2).toEqual([]);
-            expect(defaultValue3).toEqual([]);
-        });
-
-        test('Collapsible step type', async () => {
-            const step = {
-                type: StepTypes.COLLAPSIBLE,
-            } as FormStep;
-
-            const defaultValue = calcDefaultValue(step);
-            expect(defaultValue).toBe(false);
-        });
-
-        test('Separator step type', async () => {
-            const step = {
-                type: StepTypes.SEPARATOR,
-            } as FormStep;
-
-            const defaultValue = calcDefaultValue(step);
-            expect(defaultValue).toBeUndefined();
-        });
-    });
-
-    describe('iterateNestedSteps', function () {
-        test('should iterate over nested steps', async () => {
-            const steps: Record<string, FormStep> = {
-                idStep1: {
-                    id: 'idStep1',
-                    type: StepTypes.MAPPER,
-                    rootSteps: ['idStep2'],
-                    steps: {
-                        idStep2: {
-                            id: 'idStep2',
-                            type: StepTypes.SELECTOR,
-                            size: 1,
-                            options: [
-                                {
-                                    label: 'Option',
-                                    value: 'option',
-                                    type: OptionTypes.NESTED,
-                                    steps: ['idStep3'],
-                                },
-                            ] as Steps.FormSelector['options'],
-                        } as FormStep,
-                        idStep3: {
-                            id: 'idStep3',
-                            type: StepTypes.TEXTINPUT,
-                            size: 1,
-                        } as Steps.TextInput,
-                    } as Steps.Mapper['steps'],
-                } as Steps.Mapper,
-                idStep4: {
-                    id: 'idStep4',
-                    type: StepTypes.TEXTINPUT,
-                    size: 1,
-                } as FormStep,
-            };
-
-            const iterationMock = jest.fn();
-            iterateNestedSteps('idStep1', steps, iterationMock);
-
-            expect(iterationMock).toHaveBeenCalledTimes(3);
-            expect(iterationMock).toHaveBeenCalledWith(steps['idStep1']);
-            expect(iterationMock).toHaveBeenCalledWith(
-                (steps['idStep1'] as Steps.Mapper).steps['idStep2']
-            );
-            expect(iterationMock).toHaveBeenCalledWith(
-                (steps['idStep1'] as Steps.Mapper).steps['idStep3']
-            );
-        });
-    });
-});
-
-describe('calcSubSteps', () => {
-    test('should return an empty array for unknown step type', () => {
-        const steps = {
-            unknownStep: {
-                id: 'unknownStep',
-                type: 'UNKNOWN_TYPE' as any,
-            } as FormStep,
-        };
-
-        const result = calcSubSteps('unknownStep', steps);
-
-        expect(result).toEqual([]);
-    });
-
-    test('should return nested steps for Selector type', () => {
-        const steps = {
-            selectorStep: {
-                id: 'selectorStep',
-                type: StepTypes.SELECTOR,
-                options: [
-                    {
-                        label: 'Option 1',
-                        value: 'option1',
-                        type: OptionTypes.NESTED,
-                        steps: ['nestedStep1', 'nestedStep2'],
-                    },
-                    {
-                        label: 'Option 2',
-                        value: 'option2',
-                        type: OptionTypes.DEFAULT,
-                    },
-                ],
-            } as Steps.FormSelector,
-        };
-
-        const result = calcSubSteps('selectorStep', steps);
-
-        expect(result).toEqual(['nestedStep1', 'nestedStep2']);
-    });
-
-    test('should return nested steps for ClassifierSelector type', () => {
-        const steps = {
-            classifierSelectorStep: {
-                id: 'classifierSelectorStep',
-                type: StepTypes.CLASSIFIER_SELECTOR,
-                options: {
-                    classifierOption1: {
-                        idClassifier: 'classifierOption1',
-                        type: ClassifierOptionTypes.NESTED,
-                        steps: ['nestedStep1', 'nestedStep2'],
-                    },
-                    classifierOption2: {
-                        idClassifier: 'classifierOption2',
-                        type: ClassifierOptionTypes.HIDE,
-                    },
-                } as Steps.ClassifierSelector['options'],
-            } as Steps.ClassifierSelector,
-        };
-
-        const result = calcSubSteps('classifierSelectorStep', steps);
-
-        expect(result).toEqual(['nestedStep1', 'nestedStep2']);
-    });
-
-    test('Rating with nested steps', () => {
-        const steps = {
-            idStep: {
-                id: 'idStep',
-                type: StepTypes.RATING,
-                nestedSteps: [
-                    ['idStep2'],
-                    ['idStep3'],
-                ] as Steps.Rating['nestedSteps'],
-            } as Steps.Rating,
-        };
-
-        const subSteps = calcSubSteps('idStep', steps);
-
-        expect(subSteps).toEqual(['idStep2', 'idStep3']);
-    });
-
-    test('Collapsible with steps', () => {
-        const steps = {
-            idStep: {
-                id: 'idStep',
-                type: StepTypes.COLLAPSIBLE,
-                steps: ['idStep2'],
-            } as Steps.Collapsible,
-        };
-
-        const subSteps = calcSubSteps('idStep', steps);
-
-        expect(subSteps).toEqual(['idStep2']);
-    });
-
-    test('Checkbox with steps', () => {
-        const steps = {
-            idStep: {
-                id: 'idStep',
-                type: StepTypes.CHECKBOX,
-                size: 1,
-                maxSize: 2,
-                steps: ['idStep2'],
-            } as Steps.CheckBox,
-        };
-
-        const subSteps = calcSubSteps('idStep', steps);
-
-        expect(subSteps).toEqual(['idStep2']);
-    });
-
-    test('EntityValuePicker with nested steps', () => {
-        const steps = {
-            idStep: {
-                id: 'idStep',
-                type: StepTypes.ENTITYVALUEPICKER,
-                options: {
-                    idEntityValue: {
-                        idEntityValue: 'idEntityValue',
-                        type: EntityValueOptionTypes.NESTED,
-                        steps: ['idStep2'],
-                    },
-                } as Steps.EntityValuePicker['options'],
-            } as Steps.EntityValuePicker,
-        };
-
-        const subSteps = calcSubSteps('idStep', steps);
-
-        expect(subSteps).toEqual(['idStep2']);
-    });
-
-    test('CBRFormStep with subStep', () => {
-        const steps = {
-            idStep: {
-                id: 'idStep',
-                type: CBRFormStepTypes.CBR_LOCATIVAS,
-                subStep: 'idStep2',
-            } as CBRFormStep,
-        };
-
-        const subSteps = calcSubSteps('idStep', steps);
-
-        expect(subSteps).toEqual(['idStep2']);
-    });
-
-    test('AYFFormStep with idNitStep', () => {
-        const steps = {
-            idStep: {
-                id: 'idStep',
-                type: AYFFormStepTypes.AYF_ICA_CITY,
-                idNitStep: 'idStep2',
-            } as AYFCityStep,
-        };
-
-        const subSteps = calcSubSteps('idStep', steps);
-
-        expect(subSteps).toEqual(['idStep2']);
-    });
-});