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

package/src/FormSteps/StepFunctions.test.ts

@@ -0,0 +1,882 @@
+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']);
+    });
+});