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

package/src/Form/FormFunctions.test.ts

@@ -0,0 +1,583 @@
+import { ContentState, EditorState } from 'draft-js';
+import StepTypes, { EntityValueDataTypes } from '../constants/FormStepTypes';
+import { calcDependencies, calcValue } from './FormFunctions';
+import { FormStep, Mapper } from '../@Types/FormStep';
+import { stringToDraft } from '../Utils/DraftFunctions';
+
+describe('FormFunctions', function () {
+    describe('calcValue', function () {
+        test('Empty', async () => {
+            const value = calcValue('idStep', {}, {}, {}, [], undefined);
+            expect(value).toBeUndefined();
+        });
+
+        test('Custom Step', async () => {
+            const value = calcValue(
+                'idStep',
+                {
+                    idStep: {
+                        id: 'idStep',
+                        type: 'CUSTOM',
+                    } as any,
+                },
+                {},
+                {
+                    CUSTOM: {
+                        calcValue: () => 'custom',
+                    } as any,
+                },
+                [],
+                undefined
+            );
+            expect(value).toBe('custom');
+            const value2 = calcValue(
+                'idStep',
+                {
+                    idStep: {
+                        id: 'idStep',
+                        type: 'CUSTOM',
+                    } as any,
+                },
+                {},
+                {
+                    CUSTOM: {} as any,
+                },
+                [],
+                undefined
+            );
+            expect(value2).toBeUndefined();
+        });
+
+        test('Base Step', async () => {
+            const value = calcValue(
+                'idStep',
+                {
+                    idStep: {
+                        id: 'idStep',
+                        type: StepTypes.TEXTINPUT,
+                        label: '',
+                        description: '',
+                        idSection: 'idSection',
+                        required: false,
+                        size: 1,
+                    },
+                },
+                {},
+                {},
+                [],
+                'Value'
+            );
+            expect(value).toBe('Value');
+        });
+
+        test('Textarea without editor', async () => {
+            const value = calcValue(
+                'idStep',
+                {
+                    idStep: {
+                        id: 'idStep',
+                        type: StepTypes.TEXTAREA,
+                        label: '',
+                        description: '',
+                        idSection: 'idSection',
+                        required: false,
+                        hasTextEditor: false,
+                    },
+                },
+                {},
+                {},
+                [],
+                'Value'
+            );
+            expect(value.value).toBe('Value');
+            expect(value.draft.blocks[0].text).toBe('Value');
+        });
+
+        test('Textarea with editor', async () => {
+            const value = calcValue(
+                'idStep',
+                {
+                    idStep: {
+                        id: 'idStep',
+                        type: StepTypes.TEXTAREA,
+                        label: '',
+                        description: '',
+                        idSection: 'idSection',
+                        required: false,
+                        hasTextEditor: true,
+                    },
+                },
+                {},
+                {},
+                [],
+                EditorState.createWithContent(
+                    ContentState.createFromText('Value')
+                )
+            );
+            expect(value.value).toBe('Value');
+            expect(value.draft.blocks[0].text).toBe('Value');
+        });
+
+        test('FileUpload', async () => {
+            const value = calcValue(
+                'idStep',
+                {
+                    idStep: {
+                        id: 'idStep',
+                        type: StepTypes.FILEUPLOAD,
+                        label: '',
+                        description: '',
+                        idSection: 'idSection',
+                        required: false,
+                    },
+                },
+                {},
+                {},
+                [],
+                [
+                    {
+                        S3Key: 'S3Key',
+                        fileName: 'fileName',
+                        extra: 'extra',
+                    },
+                ]
+            );
+            expect(value[0].S3Key).toBe('S3Key');
+            expect(value[0].extra).toBeUndefined();
+        });
+
+        test('ClassifierSelector', async () => {
+            const value = calcValue(
+                'idStep',
+                {
+                    idStep: {
+                        id: 'idStep',
+                        type: StepTypes.CLASSIFIER_SELECTOR,
+                    } as any,
+                },
+                {},
+                {},
+                [],
+                {
+                    value: 'value',
+                    label: 'Label',
+                }
+            );
+            expect(value).toBe('value');
+        });
+
+        test('Selector', async () => {
+            const value = calcValue(
+                'idStep',
+                {
+                    idStep: {
+                        id: 'idStep',
+                        type: StepTypes.SELECTOR,
+                    } as any,
+                },
+                {},
+                {},
+                [],
+                {
+                    value: 'value',
+                    label: 'Label',
+                }
+            );
+            expect(value).toBe('value');
+        });
+
+        test('Title', async () => {
+            const deleteIds: string[] = [];
+            const value = calcValue(
+                'idStep',
+                {
+                    idStep: {
+                        id: 'idStep',
+                        type: StepTypes.TITLE,
+                    } as any,
+                },
+                {},
+                {},
+                deleteIds,
+                null
+            );
+            expect(value).toBeUndefined();
+        });
+
+        test('Collapsible', async () => {
+            const deleteIds: string[] = [];
+            const value = calcValue(
+                'idStep',
+                {
+                    idStep: {
+                        id: 'idStep',
+                        type: StepTypes.COLLAPSIBLE,
+                    } as any,
+                },
+                {},
+                {},
+                deleteIds,
+                null
+            );
+            expect(deleteIds[0]).toBe('idStep');
+            expect(value).toBeUndefined();
+        });
+
+        test('Mapper with deleted', async () => {
+            const value = calcValue(
+                'idStep',
+                {
+                    idStep: {
+                        id: 'idStep',
+                        type: StepTypes.MAPPER,
+                    } as Mapper,
+                },
+                {},
+                {},
+                [],
+                [{ deleted: true }]
+            );
+            expect(value.length).toBe(0);
+        });
+
+        test('Mapper', async () => {
+            const deleteIds: string[] = [];
+            const value = calcValue(
+                'idStep',
+                {
+                    idStep: {
+                        id: 'idStep',
+                        type: StepTypes.MAPPER,
+                        steps: {
+                            idSubStep: {
+                                id: 'idSubStep',
+                                type: StepTypes.TEXTINPUT,
+                            } as FormStep,
+                        } as Record<string, FormStep>,
+                    } as Mapper,
+                },
+                {
+                    mappedIdSubStep: 'subValue',
+                },
+                {},
+                deleteIds,
+                [
+                    {
+                        id: 'idElement',
+                        ids: {
+                            idSubStep: 'mappedIdSubStep',
+                        },
+                        originalValues: {
+                            original: 'Original',
+                        },
+                        value: 'value',
+                    },
+                ]
+            );
+            expect(value[0].id).toBe('idElement');
+            expect(value[0].original).toBe('Original');
+            expect(value[0].value).toBe('value');
+            expect(value[0].idSubStep).toBe('subValue');
+        });
+    });
+
+    describe('calcDependencies', function () {
+        test('Empty', async () => {
+            const dependencyStore = calcDependencies({}, {}, {});
+            expect(Object.keys(dependencyStore).length).toBe(0);
+        });
+
+        test('Basic Dependency', async () => {
+            const allSteps = {
+                idStep: {
+                    id: 'idStep',
+                    type: StepTypes.TEXTINPUT,
+                } as FormStep,
+                idStep2: {
+                    id: 'idStep2',
+                    type: StepTypes.TEXTINPUT,
+                    dependencies: ['idStep'],
+                } as FormStep,
+            };
+            const dependencyStore = calcDependencies(allSteps, {}, allSteps);
+            expect(Object.keys(dependencyStore).length).toBe(1);
+            expect(dependencyStore.idStep.value).toBeNull();
+            expect(dependencyStore.idStep.dependents.length).toBe(1);
+            expect(dependencyStore.idStep.type).toBe(StepTypes.TEXTINPUT);
+        });
+
+        test('Basic Dependency with originalValue', async () => {
+            const allSteps = {
+                idStep: {
+                    id: 'idStep',
+                    type: StepTypes.TEXTINPUT,
+                    idSection: 'FIRST',
+                } as FormStep,
+                idStep2: {
+                    id: 'idStep2',
+                    type: StepTypes.TEXTINPUT,
+                    dependencies: ['idStep'],
+                } as FormStep,
+            };
+            const dependencyStore = calcDependencies(
+                allSteps,
+                {},
+                allSteps,
+                {},
+                {
+                    sections: {
+                        FIRST: {
+                            idStep: 'Original',
+                        },
+                    },
+                    global: {},
+                }
+            );
+            expect(Object.keys(dependencyStore).length).toBe(1);
+            expect(dependencyStore.idStep.value).toBe('Original');
+            expect(dependencyStore.idStep.dependents.length).toBe(1);
+            expect(dependencyStore.idStep.type).toBe(StepTypes.TEXTINPUT);
+        });
+
+        test('Basic TextArea Dependency with originalValue with editor', async () => {
+            const allSteps = {
+                idStep: {
+                    id: 'idStep',
+                    type: StepTypes.TEXTAREA,
+                    idSection: 'FIRST',
+                    hasTextEditor: true,
+                } as FormStep,
+                idStep2: {
+                    id: 'idStep2',
+                    type: StepTypes.TEXTINPUT,
+                    dependencies: ['idStep'],
+                } as FormStep,
+            };
+            const dependencyStore = calcDependencies(
+                allSteps,
+                {},
+                allSteps,
+                {},
+                {
+                    sections: {
+                        FIRST: {
+                            idStep: stringToDraft('Original'),
+                        },
+                    },
+                    global: {},
+                }
+            );
+            expect(Object.keys(dependencyStore).length).toBe(1);
+            expect(dependencyStore.idStep.value).toBe('Original');
+            expect(dependencyStore.idStep.dependents.length).toBe(1);
+            expect(dependencyStore.idStep.type).toBe(StepTypes.TEXTAREA);
+        });
+
+        test('Basic TextArea Dependency with originalValue without editor', async () => {
+            const allSteps = {
+                idStep: {
+                    id: 'idStep',
+                    type: StepTypes.TEXTAREA,
+                    idSection: 'FIRST',
+                    hasTextEditor: false,
+                } as FormStep,
+                idStep2: {
+                    id: 'idStep2',
+                    type: StepTypes.TEXTINPUT,
+                    dependencies: ['idStep'],
+                } as FormStep,
+            };
+            const dependencyStore = calcDependencies(
+                allSteps,
+                {},
+                allSteps,
+                {},
+                {
+                    sections: {
+                        FIRST: {
+                            idStep: 'Original',
+                        },
+                    },
+                    global: {},
+                }
+            );
+            expect(Object.keys(dependencyStore).length).toBe(1);
+            expect(dependencyStore.idStep.value).toBe('Original');
+            expect(dependencyStore.idStep.dependents.length).toBe(1);
+            expect(dependencyStore.idStep.type).toBe(StepTypes.TEXTAREA);
+        });
+
+        test('Basic Dependency with missing originalValue', async () => {
+            const allSteps = {
+                idStep: {
+                    id: 'idStep',
+                    type: StepTypes.TEXTINPUT,
+                    dependencies: ['idOriginal'],
+                } as FormStep,
+            };
+            const dependencyStore = calcDependencies(
+                allSteps,
+                {},
+                allSteps,
+                {},
+                {
+                    sections: {},
+                    global: { idOriginal: 'Original' },
+                }
+            );
+            expect(Object.keys(dependencyStore).length).toBe(1);
+            expect(dependencyStore.idOriginal.value).toBe('Original');
+            expect(dependencyStore.idOriginal.dependents.length).toBe(1);
+            expect(dependencyStore.idOriginal.type).toBe('ORIGINAL');
+        });
+
+        test('Missing Dependency', async () => {
+            const dependencyStore = calcDependencies(
+                {
+                    idStep: {
+                        id: 'idStep',
+                        type: StepTypes.TEXTINPUT,
+                        dependencies: ['idMissingStep'],
+                    } as FormStep,
+                },
+                {},
+                {}
+            );
+            expect(Object.keys(dependencyStore).length).toBe(1);
+            expect(dependencyStore.idMissingStep.value).toBeNull();
+            expect(dependencyStore.idMissingStep.dependents.length).toBe(1);
+            expect(dependencyStore.idMissingStep.type).toBe('MISSING');
+        });
+
+        test('Basic Dependency without dependents', async () => {
+            const allSteps = {
+                idStep: {
+                    id: 'idStep',
+                    type: StepTypes.TEXTINPUT,
+                } as FormStep,
+                idStep2: {
+                    id: 'idStep2',
+                    type: StepTypes.TEXTINPUT,
+                    dependencies: ['idStep'],
+                } as FormStep,
+            };
+            const dependencyStore = calcDependencies(
+                allSteps,
+                {},
+                allSteps,
+                {},
+                { global: {}, sections: {} },
+                false
+            );
+            expect(Object.keys(dependencyStore).length).toBe(1);
+            expect(dependencyStore.idStep.value).toBeNull();
+        });
+
+        test('Double Basic Dependency', async () => {
+            const dependencyStore = calcDependencies(
+                {
+                    idStep: {
+                        id: 'idStep',
+                        type: StepTypes.TEXTINPUT,
+                    } as FormStep,
+                    idStep2: {
+                        id: 'idStep2',
+                        type: StepTypes.TEXTINPUT,
+                        dependencies: ['idStep'],
+                    } as FormStep,
+                    idStep3: {
+                        id: 'idStep3',
+                        type: StepTypes.TEXTINPUT,
+                        dependencies: ['idStep'],
+                    } as FormStep,
+                },
+                {},
+                {}
+            );
+            expect(Object.keys(dependencyStore).length).toBe(1);
+            expect(dependencyStore.idStep.value).toBeNull();
+            expect(dependencyStore.idStep.dependents.length).toBe(2);
+        });
+
+        test('EntityValue Dependencies', async () => {
+            const allSteps = {
+                idStep: {
+                    id: 'idStep',
+                    type: StepTypes.TEXTINPUT,
+                } as FormStep,
+                idStep2: {
+                    id: 'idStep2',
+                    type: StepTypes.ENTITYVALUEPICKER,
+                    path: [
+                        {
+                            type: EntityValueDataTypes.STEP,
+                            idStep: 'idStep',
+                        },
+                        {
+                            type: EntityValueDataTypes.VALUE,
+                        },
+                    ],
+                    filters: [
+                        {
+                            type: EntityValueDataTypes.STEP,
+                            idStep: 'idMissingStep',
+                        },
+                    ],
+                    dependencies: ['idMissingStep'],
+                } as FormStep,
+            };
+            const dependencyStore = calcDependencies(allSteps, {}, allSteps);
+            expect(Object.keys(dependencyStore).length).toBe(2);
+            expect(dependencyStore.idStep.value).toBeNull();
+            expect(dependencyStore.idStep.dependents.length).toBe(1);
+        });
+
+        test('Mapper Dependencies', async () => {
+            const allSteps = {
+                idStep: {
+                    id: 'idStep',
+                    type: StepTypes.TEXTINPUT,
+                    idSection: 'FIRST',
+                } as FormStep,
+                idStep2: {
+                    id: 'idStep2',
+                    type: StepTypes.MAPPER,
+                    idSection: 'FIRST',
+                    steps: {
+                        idSubStep: {
+                            id: 'idSubStep',
+                            type: StepTypes.TEXTINPUT,
+                            idSection: 'FIRST',
+                            dependencies: ['idStep'],
+                        } as FormStep,
+                    } as Mapper['steps'],
+                } as FormStep,
+            };
+            const dependencyStore = calcDependencies(
+                allSteps,
+                {},
+                allSteps,
+                {},
+                {
+                    sections: {
+                        FIRST: {
+                            idStep2: [
+                                {
+                                    id: 'idElement',
+                                    ids: {
+                                        idSubStep: 'mappedIdSubStep',
+                                    },
+                                },
+                            ],
+                            mappedIdSubStep: 'Original',
+                        },
+                    },
+                    global: {},
+                }
+            );
+            expect(Object.keys(dependencyStore).length).toBe(1);
+            expect(dependencyStore.idStep.value).toBeNull();
+            expect(dependencyStore.idStep.dependents.length).toBe(1);
+        });
+    });
+});