@arquimedes.co/eureka-forms 3.0.35 → 3.0.36-test

package/dist/FormSteps/StepFunctions.test.js

@@ -0,0 +1,702 @@
+import AYFFormStepTypes from '../constants/AYFFormStepTypes';
+import CBRFormStepTypes from '../constants/CBRFormStepTypes';
+import FormStepTypes, { ApiSelectorOptionTypes, ClassifierOptionTypes, EntityValueOptionTypes, OptionTypes, } from '../constants/FormStepTypes';
+import { describe, expect, test, vi } from 'vitest';
+import { calcDefaultValue, calcFillerSize, calcStepWidth, calcSubSteps, iterateNestedSteps } from './StepFunctions';
+import { stringToDraft } from '../Utils/DraftFunctions';
+describe('StepFunctions', function () {
+    describe('calcFillerSize', function () {
+        test('No maxSize', async () => {
+            const size = calcFillerSize({ type: FormStepTypes.SELECTOR }, {}, {}, {
+                blockNum: 4,
+                blockSize: 210,
+                spacingSize: 20,
+            });
+            expect(size).toBe(0);
+        });
+        test('Selector with no value', async () => {
+            const steps = {
+                idStep: {
+                    id: 'idStep',
+                    type: FormStepTypes.SELECTOR,
+                    size: 3,
+                    maxSize: 3,
+                },
+            };
+            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: FormStepTypes.SELECTOR,
+                    size: 3,
+                    maxSize: 3,
+                    options: [
+                        {
+                            label: 'Option',
+                            value: 'option',
+                        },
+                    ],
+                },
+            };
+            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: FormStepTypes.SELECTOR,
+                    size: 1,
+                    maxSize: 2,
+                    options: [
+                        {
+                            label: 'Option',
+                            value: 'option',
+                            type: OptionTypes.NESTED,
+                            steps: ['idStep2'],
+                        },
+                    ],
+                },
+                idStep2: {
+                    id: 'idStep2',
+                    type: FormStepTypes.TEXTINPUT,
+                    size: 1,
+                },
+            };
+            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: FormStepTypes.SELECTOR,
+                    size: 1,
+                    maxSize: 2,
+                    options: [
+                        {
+                            label: 'Option',
+                            value: 'option',
+                            type: OptionTypes.NESTED,
+                            steps: ['idStep2'],
+                        },
+                    ],
+                },
+                idStep2: {
+                    id: 'idStep2',
+                    type: FormStepTypes.TEXTINPUT,
+                    size: 1,
+                },
+            };
+            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: FormStepTypes.CLASSIFIER_SELECTOR,
+                    size: 1,
+                    maxSize: 2,
+                    options: {
+                        idClassifier: {
+                            label: 'Option',
+                            idClassifier: 'idClassifier',
+                            type: ClassifierOptionTypes.NESTED,
+                            steps: ['idStep2'],
+                        },
+                    },
+                },
+                idStep2: {
+                    id: 'idStep2',
+                    type: FormStepTypes.TEXTINPUT,
+                    size: 1,
+                },
+            };
+            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: FormStepTypes.CLASSIFIER_SELECTOR,
+                    size: 1,
+                    maxSize: 2,
+                    options: {
+                        idClassifier: {
+                            label: 'Option',
+                            idClassifier: 'idClassifier',
+                            type: ClassifierOptionTypes.NESTED,
+                            steps: ['idStep2'],
+                        },
+                    },
+                },
+                idStep2: {
+                    id: 'idStep2',
+                    type: FormStepTypes.TEXTINPUT,
+                    size: 1,
+                },
+            };
+            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: FormStepTypes.ENTITYVALUEPICKER,
+                    size: 1,
+                    maxSize: 2,
+                    options: {
+                        idEntityValue: {
+                            label: 'Option',
+                            idEntityValue: 'idEntityValue',
+                            type: EntityValueOptionTypes.NESTED,
+                            steps: ['idStep2'],
+                        },
+                    },
+                },
+                idStep2: {
+                    id: 'idStep2',
+                    type: FormStepTypes.TEXTINPUT,
+                    size: 1,
+                },
+            };
+            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: FormStepTypes.ENTITYVALUEPICKER,
+                    size: 1,
+                    maxSize: 2,
+                    options: {
+                        idEntityValue: {
+                            label: 'Option',
+                            idEntityValue: 'idEntityValue',
+                            type: EntityValueOptionTypes.NESTED,
+                            steps: ['idStep2'],
+                        },
+                    },
+                },
+                idStep2: {
+                    id: 'idStep2',
+                    type: FormStepTypes.TEXTINPUT,
+                    size: 1,
+                },
+            };
+            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: FormStepTypes.API_SELECTOR,
+                    size: 1,
+                    maxSize: 2,
+                    options: {
+                        idOption: {
+                            label: 'Option',
+                            idOption: 'idOption',
+                            type: ApiSelectorOptionTypes.NESTED,
+                            steps: ['idStep2'],
+                        },
+                    },
+                },
+                idStep2: {
+                    id: 'idStep2',
+                    type: FormStepTypes.TEXTINPUT,
+                    size: 1,
+                },
+            };
+            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: FormStepTypes.API_SELECTOR,
+                    size: 1,
+                    maxSize: 2,
+                    options: {
+                        idOption: {
+                            label: 'Option',
+                            idOption: 'idOption',
+                            type: ApiSelectorOptionTypes.NESTED,
+                            steps: ['idStep2'],
+                        },
+                    },
+                },
+                idStep2: {
+                    id: 'idStep2',
+                    type: FormStepTypes.TEXTINPUT,
+                    size: 1,
+                },
+            };
+            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: FormStepTypes.CHECKBOX,
+                    size: 1,
+                    maxSize: 2,
+                    steps: ['idStep2'],
+                },
+                idStep2: {
+                    id: 'idStep2',
+                    type: FormStepTypes.TEXTINPUT,
+                    size: 1,
+                },
+            };
+            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: FormStepTypes.CHECKBOX,
+                    size: 1,
+                    maxSize: 2,
+                    uncheckedSteps: ['idStep2'],
+                },
+                idStep2: {
+                    id: 'idStep2',
+                    type: FormStepTypes.TEXTINPUT,
+                    size: 1,
+                },
+            };
+            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: FormStepTypes.CHECKBOX,
+                    size: 1,
+                    maxSize: 2,
+                    uncheckedSteps: ['idStep2'],
+                },
+                idStep2: {
+                    id: 'idStep2',
+                    type: FormStepTypes.TEXTINPUT,
+                    size: 1,
+                },
+            };
+            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: FormStepTypes.CHECKBOX,
+                    size: 1,
+                    maxSize: 2,
+                    steps: ['idStep2'],
+                },
+                idStep2: {
+                    id: 'idStep2',
+                    type: FormStepTypes.TEXTINPUT,
+                    size: 1,
+                },
+            };
+            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: FormStepTypes.CHECKBOX,
+            });
+            expect(defaultValue).toBe(false);
+        });
+        test('Checkbox with defaultValue', async () => {
+            const step = {
+                type: FormStepTypes.CHECKBOX,
+                defaultValue: true,
+            };
+            const defaultValue = calcDefaultValue(step);
+            expect(defaultValue).toBe(true);
+        });
+        test('Title step type', async () => {
+            const step = {
+                type: FormStepTypes.TITLE,
+                title: stringToDraft('Title'),
+            };
+            const defaultValue = calcDefaultValue(step);
+            expect(defaultValue).toEqual(undefined);
+        });
+        test('Selector, TextInput, ClassifierSelector step types', async () => {
+            const step1 = {
+                type: FormStepTypes.SELECTOR,
+            };
+            const step2 = {
+                type: FormStepTypes.TEXTINPUT,
+            };
+            const step3 = {
+                type: FormStepTypes.CLASSIFIER_SELECTOR,
+            };
+            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: FormStepTypes.TEXTAREA,
+                hasTextEditor: true,
+            };
+            const defaultValue = calcDefaultValue(step);
+            expect(defaultValue.blocks[0].text).toBe('');
+        });
+        test('Textarea step type without text editor', async () => {
+            const step = {
+                type: FormStepTypes.TEXTAREA,
+                hasTextEditor: false,
+            };
+            const defaultValue = calcDefaultValue(step);
+            expect(defaultValue).toBe('');
+        });
+        test('Rating, DatePicker, ApiSelector, EntityValuePicker step types', async () => {
+            const step1 = {
+                type: FormStepTypes.RATING,
+            };
+            const step2 = {
+                type: FormStepTypes.DATEPICKER,
+            };
+            const step3 = {
+                type: FormStepTypes.API_SELECTOR,
+            };
+            const step4 = {
+                type: FormStepTypes.ENTITYVALUEPICKER,
+            };
+            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('DatePickerRange step type', async () => {
+            const step = {
+                type: FormStepTypes.DATEPICKER_RANGE,
+            };
+            const defaultValue = calcDefaultValue(step);
+            expect(defaultValue).toBe(null);
+        });
+        test('Mapper, FileUpload, CBRFormStep types', async () => {
+            const step1 = {
+                type: FormStepTypes.MAPPER,
+            };
+            const step2 = {
+                type: FormStepTypes.FILEUPLOAD,
+            };
+            const step3 = {
+                type: CBRFormStepTypes.CBR_INCIDENCIAS,
+            };
+            const defaultValue1 = calcDefaultValue(step1);
+            const defaultValue2 = calcDefaultValue(step2);
+            const defaultValue3 = calcDefaultValue(step3);
+            expect(defaultValue1).toEqual({ elements: [], page: 0 });
+            expect(defaultValue2).toEqual([]);
+            expect(defaultValue3).toEqual([]);
+        });
+        test('Collapsible step type', async () => {
+            const step = {
+                type: FormStepTypes.COLLAPSIBLE,
+            };
+            const defaultValue = calcDefaultValue(step);
+            expect(defaultValue).toBe(false);
+        });
+        test('Separator step type', async () => {
+            const step = {
+                type: FormStepTypes.SEPARATOR,
+            };
+            const defaultValue = calcDefaultValue(step);
+            expect(defaultValue).toBeUndefined();
+        });
+    });
+    describe('iterateNestedSteps', function () {
+        test('should iterate over nested steps', async () => {
+            const steps = {
+                idStep1: {
+                    id: 'idStep1',
+                    type: FormStepTypes.MAPPER,
+                    rootSteps: ['idStep2'],
+                    steps: {
+                        idStep2: {
+                            id: 'idStep2',
+                            type: FormStepTypes.SELECTOR,
+                            size: 1,
+                            options: [
+                                {
+                                    label: 'Option',
+                                    value: 'option',
+                                    type: OptionTypes.NESTED,
+                                    steps: ['idStep3'],
+                                },
+                            ],
+                        },
+                        idStep3: {
+                            id: 'idStep3',
+                            type: FormStepTypes.TEXTINPUT,
+                            size: 1,
+                        },
+                    },
+                },
+                idStep4: {
+                    id: 'idStep4',
+                    type: FormStepTypes.TEXTINPUT,
+                    size: 1,
+                },
+            };
+            const iterationMock = vi.fn();
+            iterateNestedSteps('idStep1', steps, iterationMock);
+            expect(iterationMock).toHaveBeenCalledTimes(3);
+            expect(iterationMock).toHaveBeenCalledWith(steps.idStep1);
+            expect(iterationMock).toHaveBeenCalledWith(steps.idStep1.steps.idStep2);
+            expect(iterationMock).toHaveBeenCalledWith(steps.idStep1.steps.idStep3);
+        });
+    });
+});
+describe('calcSubSteps', () => {
+    test('should return an empty array for unknown step type', () => {
+        const steps = {
+            unknownStep: {
+                id: 'unknownStep',
+                type: 'UNKNOWN_TYPE',
+            },
+        };
+        const result = calcSubSteps('unknownStep', steps);
+        expect(result).toEqual([]);
+    });
+    test('should return nested steps for Selector type', () => {
+        const steps = {
+            selectorStep: {
+                id: 'selectorStep',
+                type: FormStepTypes.SELECTOR,
+                options: [
+                    {
+                        label: 'Option 1',
+                        value: 'option1',
+                        type: OptionTypes.NESTED,
+                        steps: ['nestedStep1', 'nestedStep2'],
+                    },
+                    {
+                        label: 'Option 2',
+                        value: 'option2',
+                        type: OptionTypes.DEFAULT,
+                    },
+                ],
+            },
+        };
+        const result = calcSubSteps('selectorStep', steps);
+        expect(result).toEqual(['nestedStep1', 'nestedStep2']);
+    });
+    test('should return nested steps for ClassifierSelector type', () => {
+        const steps = {
+            classifierSelectorStep: {
+                id: 'classifierSelectorStep',
+                type: FormStepTypes.CLASSIFIER_SELECTOR,
+                options: {
+                    classifierOption1: {
+                        idClassifier: 'classifierOption1',
+                        type: ClassifierOptionTypes.NESTED,
+                        steps: ['nestedStep1', 'nestedStep2'],
+                    },
+                    classifierOption2: {
+                        idClassifier: 'classifierOption2',
+                        type: ClassifierOptionTypes.HIDE,
+                    },
+                },
+            },
+        };
+        const result = calcSubSteps('classifierSelectorStep', steps);
+        expect(result).toEqual(['nestedStep1', 'nestedStep2']);
+    });
+    test('Rating with nested steps', () => {
+        const steps = {
+            idStep: {
+                id: 'idStep',
+                type: FormStepTypes.RATING,
+                nestedSteps: [['idStep2'], ['idStep3']],
+            },
+        };
+        const subSteps = calcSubSteps('idStep', steps);
+        expect(subSteps).toEqual(['idStep2', 'idStep3']);
+    });
+    test('Collapsible with steps', () => {
+        const steps = {
+            idStep: {
+                id: 'idStep',
+                type: FormStepTypes.COLLAPSIBLE,
+                steps: ['idStep2'],
+            },
+        };
+        const subSteps = calcSubSteps('idStep', steps);
+        expect(subSteps).toEqual(['idStep2']);
+    });
+    test('Checkbox with steps', () => {
+        const steps = {
+            idStep: {
+                id: 'idStep',
+                type: FormStepTypes.CHECKBOX,
+                size: 1,
+                maxSize: 2,
+                steps: ['idStep2'],
+            },
+        };
+        const subSteps = calcSubSteps('idStep', steps);
+        expect(subSteps).toEqual(['idStep2']);
+    });
+    test('EntityValuePicker with nested steps', () => {
+        const steps = {
+            idStep: {
+                id: 'idStep',
+                type: FormStepTypes.ENTITYVALUEPICKER,
+                options: {
+                    idEntityValue: {
+                        type: EntityValueOptionTypes.NESTED,
+                        steps: ['idStep2'],
+                    },
+                },
+            },
+        };
+        const subSteps = calcSubSteps('idStep', steps);
+        expect(subSteps).toEqual(['idStep2']);
+    });
+    test('CBRFormStep with subStep', () => {
+        const steps = {
+            idStep: {
+                id: 'idStep',
+                type: CBRFormStepTypes.CBR_LOCATIVAS,
+                subStep: 'idStep2',
+            },
+        };
+        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',
+            },
+        };
+        const subSteps = calcSubSteps('idStep', steps);
+        expect(subSteps).toEqual(['idStep2']);
+    });
+});