@legalplace/wizardx-core 0.0.1-alpha.0

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

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