@legalplace/wizardx-core 2.6.4 → 2.7.1

package/src/redux/selectors/references.test.ts

@@ -1,660 +0,0 @@
-import { createAppStore, getStore } from '../store';
-import { StateType } from '../../types/State.type';
-import { initReferencesAction } from '../actions/references';
-import {
-  isOptionMultiple,
-  selectOptionReference,
-  selectOptionRelations,
-  selectOptionParents,
-  selectRadioSiblings,
-  selectVariableReference,
-  selectVariableRelations,
-  selectVariableParents,
-  selectAllSectionsReferences,
-  selectSectionReference,
-  selectSectionDefaults,
-  selectOptionConditionsObject,
-  selectVariableConditionsObject,
-  selectSectionConditionsObject,
-  selectPrefillerConditionsObject,
-} from './references';
-
-// Initiating state
-createAppStore('memory');
-const store = getStore();
-
-const initialState: StateType.References = {
-  options: {},
-  variables: {},
-  relations: {
-    options: {},
-    variables: {},
-    sections: {},
-  },
-  conditions: {
-    options: {},
-    variables: {},
-    prefillers: {},
-    validators: {
-      options: {},
-      variables: {},
-    },
-    sections: {},
-    documents: {},
-  },
-  sections: {},
-  documents: {},
-  defaults: {},
-  outputs: {},
-  evaluations: {},
-  boxes: {},
-};
-
-describe('Inputs selectors test suit', () => {
-  it('isOptionMultiple returns undefined when references are not set', () => {
-    expect(() => isOptionMultiple(4)).toThrowError();
-  });
-
-  it('selectOptionReference returns undefined when references are not set', () => {
-    expect(() => selectOptionReference(4)).toThrowError();
-  });
-
-  it('selectOptionRelations returns undefined when references are not set', () => {
-    expect(() => selectOptionRelations(4)).toThrowError();
-  });
-
-  it('selectOptionParents returns undefined when references are not set', () => {
-    expect(() => selectOptionParents(4)).toThrowError();
-  });
-
-  it('selectRadioSiblings returns undefined when references are not set', () => {
-    expect(() => selectRadioSiblings(4)).toThrowError();
-  });
-
-  it('selectVariableReference returns undefined when references are not set', () => {
-    expect(() => selectVariableReference(4)).toThrowError();
-  });
-
-  it('selectVariableRelations returns undefined when references are not set', () => {
-    expect(() => selectVariableRelations(4)).toThrowError();
-  });
-
-  it('selectVariableParents returns undefined when references are not set', () => {
-    expect(() => selectVariableParents(4)).toThrowError();
-  });
-
-  it('selectAllSectionsReferences returns undefined when references are not set', () => {
-    expect(() => selectAllSectionsReferences('main')).toThrowError();
-  });
-
-  it('selectSectionReference returns undefined when references are not set', () => {
-    expect(() => selectSectionReference(4)).toThrowError();
-  });
-
-  it('selectSectionDefaults returns undefined when references are not set', () => {
-    expect(() => selectSectionDefaults(4)).toThrowError();
-  });
-
-  it('selectOptionConditionsObject returns undefined when references are not set', () => {
-    expect(() => selectOptionConditionsObject(4)).toThrowError();
-  });
-
-  it('selectVariableConditionsObject returns undefined when references are not set', () => {
-    expect(() => selectVariableConditionsObject(4)).toThrowError();
-  });
-
-  it('selectSectionConditionsObject returns undefined when references are not set', () => {
-    expect(() => selectSectionConditionsObject(4, 'main')).toThrowError();
-  });
-
-  it('selectPrefillerConditionsObject returns undefined when references are not set', () => {
-    expect(() => selectPrefillerConditionsObject(4)).toThrowError();
-  });
-
-  it('Checks if an option is multiple', () => {
-    // Initiating option
-    store.dispatch(
-      initReferencesAction({
-        ...initialState,
-        options: {
-          '3': {
-            meta: {
-              id: 3,
-              label: '',
-              type: 'static',
-              multiple: { enabled: true },
-              step: '*',
-            },
-            options: [],
-            variables: [],
-          },
-        },
-      })
-    );
-
-    const selector = isOptionMultiple(3);
-
-    expect(selector).toBeTruthy();
-  });
-
-  it('Returns option refrence', () => {
-    // Initiating option
-    store.dispatch(
-      initReferencesAction({
-        ...initialState,
-        options: {
-          '34': {
-            meta: {
-              id: 34,
-              label: '',
-              type: 'static',
-              multiple: { enabled: true },
-              step: '*',
-            },
-            options: [],
-            variables: [],
-          },
-        },
-      })
-    );
-
-    const selector = selectOptionReference(34);
-
-    expect(selector).toEqual({
-      meta: {
-        id: 34,
-        label: '',
-        step: '*',
-        type: 'static',
-        multiple: {
-          enabled: true,
-        },
-      },
-      options: [],
-      variables: [],
-    });
-  });
-
-  it('Returns option relations', () => {
-    // Initiating option
-    store.dispatch(
-      initReferencesAction({
-        ...initialState,
-        relations: {
-          ...initialState.relations,
-          options: {
-            '5': {
-              options: [1],
-              variables: [4],
-              prefillers: [5],
-              sections: { main: [6] },
-              children: {
-                options: [1],
-                variables: [32],
-              },
-              parents: [43],
-              validators: {
-                options: [34],
-                variables: [53],
-              },
-              dependants: [434],
-              documents: [],
-            },
-          },
-        },
-      })
-    );
-
-    const selector = selectOptionRelations(5);
-
-    expect(selector).toEqual({
-      options: [1],
-      variables: [4],
-      prefillers: [5],
-      sections: {
-        main: [6],
-      },
-      children: {
-        options: [1],
-        variables: [32],
-      },
-      parents: [43],
-      validators: {
-        options: [34],
-        variables: [53],
-      },
-      dependants: [434],
-      documents: [],
-    });
-  });
-
-  it('Returns option parents', () => {
-    // Initiating option
-    store.dispatch(
-      initReferencesAction({
-        ...initialState,
-        relations: {
-          ...initialState.relations,
-          options: {
-            '5': {
-              options: [1],
-              variables: [4],
-              prefillers: [5],
-              sections: { main: [6] },
-              children: {
-                options: [1],
-                variables: [32],
-              },
-              parents: [43, 32, 432],
-              validators: {
-                options: [34],
-                variables: [53],
-              },
-              dependants: [434],
-              documents: [],
-            },
-          },
-        },
-      })
-    );
-
-    const selector = selectOptionParents(5);
-
-    expect(selector).toEqual([43, 32, 432]);
-  });
-
-  it('Returns option radio siblings', () => {
-    // Initiating option
-    store.dispatch(
-      initReferencesAction({
-        ...initialState,
-        relations: {
-          ...initialState.relations,
-          options: {
-            '5': {
-              options: [1],
-              variables: [4],
-              prefillers: [5],
-              sections: { main: [6] },
-              children: {
-                options: [1],
-                variables: [32],
-              },
-              parents: [43, 32, 432],
-              validators: {
-                options: [34],
-                variables: [53],
-              },
-              dependants: [434],
-              radioSiblings: [32, 4, 53],
-              documents: [],
-            },
-          },
-        },
-      })
-    );
-
-    const selector = selectRadioSiblings(5);
-
-    expect(selector).toEqual([32, 4, 53]);
-  });
-
-  /**
-   * VARIABLES
-   */
-  it('Returns variable reference', () => {
-    // Initiating option
-    store.dispatch(
-      initReferencesAction({
-        ...initialState,
-        variables: {
-          '3': {
-            id: 3,
-            type: 'text',
-            label: 'Variable',
-            step: '*',
-          },
-        },
-      })
-    );
-
-    const selector = selectVariableReference(3);
-
-    expect(selector).toEqual({
-      id: 3,
-      type: 'text',
-      label: 'Variable',
-      step: '*',
-    });
-  });
-
-  it('Returns variable relations', () => {
-    // Initiating option
-    store.dispatch(
-      initReferencesAction({
-        ...initialState,
-        relations: {
-          ...initialState.relations,
-          variables: {
-            '5': {
-              options: [1],
-              variables: [4],
-              prefillers: [5],
-              prefillingsContents: [],
-              sections: { main: [6] },
-              parents: [43],
-              validators: {
-                options: [34],
-                variables: [53],
-              },
-              documents: [],
-            },
-          },
-        },
-      })
-    );
-
-    const selector = selectVariableRelations(5);
-
-    expect(selector).toEqual({
-      options: [1],
-      variables: [4],
-      prefillers: [5],
-      prefillingsContents: [],
-      sections: { main: [6] },
-      parents: [43],
-      validators: {
-        options: [34],
-        variables: [53],
-      },
-      documents: [],
-    });
-  });
-
-  it('Returns variable parents', () => {
-    // Initiating option
-    store.dispatch(
-      initReferencesAction({
-        ...initialState,
-        relations: {
-          ...initialState.relations,
-          variables: {
-            '5': {
-              options: [1],
-              variables: [4],
-              prefillers: [5],
-              prefillingsContents: [],
-              sections: { main: [6] },
-              parents: [4, 3],
-              validators: {
-                options: [34],
-                variables: [53],
-              },
-              documents: [],
-            },
-          },
-        },
-      })
-    );
-
-    const selector = selectVariableParents(5);
-
-    expect(selector).toEqual([4, 3]);
-  });
-
-  /**
-   * SECTIONS
-   */
-  it('Returns all sections references', () => {
-    // Initiating option
-    store.dispatch(
-      initReferencesAction({
-        ...initialState,
-        sections: {
-          main: {
-            1: {
-              id: 1,
-              label: 'Some label 1',
-              options: [],
-            },
-            2: {
-              id: 2,
-              label: 'Some label 2',
-              options: [],
-            },
-          },
-        },
-      })
-    );
-
-    const selector = selectAllSectionsReferences();
-
-    expect(selector).toEqual({
-      '1': {
-        id: 1,
-        label: 'Some label 1',
-        options: [],
-      },
-      '2': {
-        id: 2,
-        label: 'Some label 2',
-        options: [],
-      },
-    });
-  });
-
-  it('Returns sections references', () => {
-    // Initiating option
-    store.dispatch(
-      initReferencesAction({
-        ...initialState,
-        sections: {
-          main: {
-            '1': {
-              id: 1,
-              label: 'Some label 1',
-              options: [],
-            },
-            '2': {
-              id: 2,
-              label: 'Some label 2',
-              options: [],
-            },
-          },
-        },
-      })
-    );
-
-    const selector = selectSectionReference(2);
-
-    expect(selector).toEqual({
-      id: 2,
-      label: 'Some label 2',
-      options: [],
-    });
-  });
-
-  it('Returns sections defaults', () => {
-    // Initiating option
-    store.dispatch(
-      initReferencesAction({
-        ...initialState,
-        defaults: {
-          ...initialState.defaults,
-          '3': {
-            '4': {
-              isDefault: true,
-              children: {
-                '5': {
-                  isDefault: true,
-                  children: {},
-                },
-              },
-            },
-          },
-        },
-      })
-    );
-
-    const selector = selectSectionDefaults(3);
-
-    expect(selector).toEqual({
-      '4': {
-        isDefault: true,
-        children: {
-          '5': {
-            isDefault: true,
-            children: {},
-          },
-        },
-      },
-    });
-  });
-
-  // Returns conditions object
-  it('Returns option conditions object', () => {
-    store.dispatch(
-      initReferencesAction({
-        ...initialState,
-        conditions: {
-          options: {
-            '4': {
-              dataMap: { o: [1], v: [], c: { o: [], v: [], s: [] } },
-              conditions: {
-                selected: [{ var: 'o.1' }],
-              },
-            },
-          },
-          variables: {},
-          sections: {},
-          prefillers: {},
-          validators: {
-            options: {},
-            variables: {},
-          },
-          documents: {},
-        },
-      })
-    );
-
-    const selector = selectOptionConditionsObject(4);
-
-    expect(selector).toEqual({
-      dataMap: { o: [1], v: [], c: { o: [], v: [], s: [] } },
-      conditions: {
-        selected: [{ var: 'o.1' }],
-      },
-    });
-  });
-
-  it('Returns variable conditions object', () => {
-    store.dispatch(
-      initReferencesAction({
-        ...initialState,
-        conditions: {
-          options: {},
-          variables: {
-            '2': {
-              dataMap: { o: [], v: [1], c: { o: [], v: [], s: [] } },
-              conditions: {
-                selected: [{ var: 'v.1' }],
-              },
-            },
-          },
-          sections: {},
-          prefillers: {},
-          validators: {
-            options: {},
-            variables: {},
-          },
-          documents: {},
-        },
-      })
-    );
-
-    const selector = selectVariableConditionsObject(2);
-
-    expect(selector).toEqual({
-      dataMap: { o: [], v: [1], c: { o: [], v: [], s: [] } },
-      conditions: {
-        selected: [{ var: 'v.1' }],
-      },
-    });
-  });
-
-  it('Returns section conditions object', () => {
-    store.dispatch(
-      initReferencesAction({
-        ...initialState,
-        conditions: {
-          options: {},
-          variables: {},
-          sections: {
-            main: {
-              '10': {
-                dataMap: { o: [1], v: [], c: { o: [], v: [], s: [] } },
-                conditions: {
-                  selected: [{ var: 'o.1' }],
-                },
-              },
-            },
-          },
-          documents: {},
-          prefillers: {},
-          validators: {
-            options: {},
-            variables: {},
-          },
-        },
-      })
-    );
-
-    const selector = selectSectionConditionsObject(10);
-
-    expect(selector).toEqual({
-      dataMap: { o: [1], v: [], c: { o: [], v: [], s: [] } },
-      conditions: {
-        selected: [{ var: 'o.1' }],
-      },
-    });
-  });
-
-  it('Returns prefiller conditions object', () => {
-    store.dispatch(
-      initReferencesAction({
-        ...initialState,
-        conditions: {
-          options: {},
-          variables: {},
-          sections: {},
-          prefillers: {
-            '9': [
-              {
-                dataMap: { o: [1], v: [], c: { o: [], v: [], s: [] } },
-                conditions: {
-                  selected: [{ var: 'o.4' }],
-                },
-              },
-            ],
-          },
-          validators: {
-            options: {},
-            variables: {},
-          },
-          documents: {},
-        },
-      })
-    );
-
-    const selector = selectPrefillerConditionsObject(9);
-
-    expect(selector).toEqual([
-      {
-        dataMap: { o: [1], v: [], c: { o: [], v: [], s: [] } },
-        conditions: {
-          selected: [{ var: 'o.4' }],
-        },
-      },
-    ]);
-  });
-});