@molgenis/vip-report-template 2.7.2 → 3.0.0-beta2

package/tests/unit/store/mutations.spec.ts

@@ -1,80 +0,0 @@
-import initialState from '@/store/state';
-import mutations from '@/store/mutations';
-import { State } from '@/types/State';
-import { mock } from 'ts-mockito';
-import { Api, Vcf } from '@molgenis/vip-report-api';
-import { Annotations } from '@/types/Annotations';
-
-test('set metadata', () => {
-  const testState: State = { ...initialState };
-  const metadata: Api.Metadata = mock<Api.Metadata>();
-  mutations.setMetadata(testState, metadata);
-  expect(testState.metadata).toBe(metadata);
-});
-
-test('set samples', () => {
-  const testState: State = { ...initialState };
-  const samples: Api.PagedItems<Api.Sample> = mock<Api.PagedItems<Api.Sample>>();
-  mutations.setSamples(testState, samples);
-  expect(testState.samples).toBe(samples);
-});
-
-test('set selected sample', () => {
-  const testState: State = { ...initialState };
-  const sample: Api.Sample = mock<Api.Sample>();
-  mutations.setSelectedSample(testState, sample);
-  expect(testState.selectedSample).toBe(sample);
-  expect(testState.selectedRecord).toBe(null);
-});
-
-test('set selected sample phenotypes', () => {
-  const testState: State = { ...initialState };
-  const phenotypes: Api.PagedItems<Api.Phenotype> = mock<Api.PagedItems<Api.Phenotype>>();
-  mutations.setSelectedSamplePhenotypes(testState, phenotypes);
-  expect(testState.selectedSamplePhenotypes).toBe(phenotypes);
-});
-
-test('set records', () => {
-  const testState: State = { ...initialState };
-  const records: Api.PagedItems<Vcf.Record> = mock<Api.PagedItems<Vcf.Record>>();
-  mutations.setRecords(testState, records);
-  expect(testState.records).toBe(records);
-});
-
-test('set selected record', () => {
-  const testState: State = { ...initialState };
-  const record: Vcf.Record = mock<Vcf.Record>();
-  mutations.setSelectedRecord(testState, record);
-  expect(testState.selectedRecord).toBe(record);
-});
-
-test('set annotations', () => {
-  const testState: State = { ...initialState };
-  const annotations: Annotations = mock<Annotations>();
-  mutations.setAnnotations(testState, annotations);
-  expect(testState.annotations).toBe(annotations);
-});
-
-test('set filter records by phenotype', () => {
-  const testState: State = { ...initialState };
-  mutations.setFilterRecordsByPhenotype(testState, false);
-  expect(testState.filterRecordsByPhenotype).toBe(false);
-});
-
-test('set filter records by inheritance', () => {
-  const testState: State = { ...initialState };
-  mutations.setFilterRecordsByInheritance(testState, false);
-  expect(testState.filterRecordsByInheritance).toBe(false);
-});
-
-test('set filter records by denovo', () => {
-  const testState: State = { ...initialState };
-  mutations.setFilterRecordsByDenovo(testState, false);
-  expect(testState.filterRecordsByDenovo).toBe(false);
-});
-
-test('set filter records by read depth', () => {
-  const testState: State = { ...initialState };
-  mutations.setFilterRecordsByDepth(testState, false);
-  expect(testState.filterRecordsByDepth).toBe(false);
-});

package/tests/unit/utils/treeBuilder.spec.ts

@@ -1,256 +0,0 @@
-import { createEdge, createSimpleEdge, getNodeLabel, retrieveEdges, retrieveNodes } from '@/utils/treeBuilder';
-import { DecisionTree, Exists, TreeEdgesObj, TreeNodes } from '@/types/DecisionTree';
-
-describe('treeBuilder', () => {
-  const decisionTree: DecisionTree = {
-    files: {
-      panel: {
-        path: 'path/to/tsv'
-      }
-    },
-    rootNode: 'ROOT',
-    nodes: {
-      boolNode: {
-        type: 'BOOL',
-        description: 'Bool type node',
-        query: {
-          field: 'field',
-          operator: '==',
-          value: 'val'
-        },
-        outcomeTrue: {
-          nextNode: 'exit_f'
-        },
-        outcomeFalse: {
-          nextNode: 'existsNode'
-        },
-        outcomeMissing: {
-          nextNode: 'existsNode'
-        }
-      },
-      existsNode: {
-        type: 'EXISTS',
-        description: 'check some field exists',
-        field: 'Some field',
-        outcomeTrue: {
-          nextNode: 'categorical_field'
-        },
-        outcomeFalse: {
-          nextNode: 'categorical_field'
-        }
-      },
-      categoricalField: {
-        type: 'CATEGORICAL',
-        description: 'check categorical field',
-        field: 'FIELD_TO_CHECK',
-        outcomeMap: {
-          P: {
-            nextNode: 'exit_t'
-          },
-          LP: {
-            nextNode: 'exit_t'
-          },
-          LB: {
-            nextNode: 'exit_f'
-          },
-          B: {
-            nextNode: 'exit_f'
-          }
-        },
-        outcomeMissing: {
-          nextNode: 'exit_t'
-        },
-        outcomeDefault: {
-          nextNode: 'exit_t'
-        }
-      },
-      exit_t: {
-        type: 'LEAF',
-        class: 'T'
-      },
-      exit_f: {
-        type: 'LEAF',
-        class: 'F'
-      }
-    }
-  };
-  it('should return correct node structure', () => {
-    const nodes: TreeNodes = retrieveNodes(decisionTree);
-    const expected: TreeNodes = [
-      {
-        id: 'boolNode',
-        label: 'boolNode\n(== val)',
-        type: 'BOOL'
-      },
-      {
-        id: 'existsNode',
-        label: 'existsNode\n(exists)',
-        type: 'EXISTS'
-      },
-      {
-        id: 'categoricalField',
-        label: 'categoricalField',
-        type: 'CATEGORICAL'
-      },
-      {
-        id: 'exit_t',
-        label: 'exit_t',
-        type: 'LEAF'
-      },
-      {
-        id: 'exit_f',
-        label: 'exit_f',
-        type: 'LEAF'
-      }
-    ];
-    expect(nodes).toStrictEqual(expected);
-  });
-  it('should return the node label for a query type', () => {
-    const query = {
-      field: 'field',
-      operator: '==',
-      value: 'value1'
-    };
-    const actual = getNodeLabel('label', 'BOOL', query);
-    const expected = 'label\n(== value1)';
-    expect(actual).toEqual(expected);
-  });
-  it('should return the node label for a exists type', () => {
-    const actual = getNodeLabel('label', 'EXISTS', undefined);
-    const expected = 'label\n(exists)';
-    expect(actual).toEqual(expected);
-  });
-  it('should return the node label for a leaf type', () => {
-    const actual = getNodeLabel('label', 'LEAF', undefined);
-    const expected = 'label';
-    expect(actual).toEqual(expected);
-  });
-  it('should create a simple edge', () => {
-    const type: Exists = 'EXISTS';
-    const node = {
-      description: 'description',
-      type: type,
-      field: 'field',
-      outcomeTrue: { nextNode: 'trueNode' },
-      outcomeFalse: { nextNode: 'falseNode' }
-    };
-    const edges = {};
-    const actual = createSimpleEdge('True', node, 'key1', edges);
-    const expected = { key1_trueNode: { from: 'key1', to: 'trueNode', label: 'True' } };
-    expect(actual).toStrictEqual(expected);
-  });
-  it('should add to a simple edge', () => {
-    const type: Exists = 'EXISTS';
-    const node = {
-      description: 'description',
-      type: type,
-      field: 'field',
-      outcomeTrue: { nextNode: 'trueNode' },
-      outcomeFalse: { nextNode: 'trueNode' }
-    };
-    const edges = { key1_trueNode: { from: 'key1', to: 'trueNode', label: 'True' } };
-    const actual = createSimpleEdge('False', node, 'key1', edges);
-    const expected = { key1_trueNode: { from: 'key1', to: 'trueNode', label: 'True\nFalse' } };
-    expect(actual).toStrictEqual(expected);
-  });
-  it('should generate edge', () => {
-    const nextNode = 'exit';
-    const label = 'label';
-    const key = 'current';
-    const edges: TreeEdgesObj = {};
-    const outcome = createEdge(nextNode, label, key, edges);
-    const expected = {
-      current_exit: {
-        from: key,
-        to: nextNode,
-        label: label
-      }
-    };
-    expect(outcome).toStrictEqual(expected);
-  });
-  it('should generate edges', () => {
-    const outcome = retrieveEdges(decisionTree);
-    const expected = [
-      {
-        from: 'boolNode',
-        to: 'exit_f',
-        label: 'True'
-      },
-      {
-        from: 'boolNode',
-        to: 'existsNode',
-        label: 'False\nMissing'
-      },
-      {
-        from: 'existsNode',
-        to: 'categorical_field',
-        label: 'True\nFalse'
-      },
-      {
-        from: 'categoricalField',
-        to: 'exit_t',
-        label: 'P\nLP\nMissing\nDefault'
-      },
-      {
-        from: 'categoricalField',
-        to: 'exit_f',
-        label: 'LB\nB'
-      }
-    ];
-    expect(outcome).toStrictEqual(expected);
-  });
-  it('should generate edges for CATEGORICAL node without default/missing', () => {
-    const decisionTree: DecisionTree = {
-      files: {
-        panel: {
-          path: 'path/to/tsv'
-        }
-      },
-      rootNode: 'ROOT',
-      nodes: {
-        categoricalField: {
-          type: 'CATEGORICAL',
-          description: 'check categorical field',
-          field: 'FIELD_TO_CHECK',
-          outcomeMap: {
-            P: {
-              nextNode: 'exit_t'
-            },
-            LP: {
-              nextNode: 'exit_t'
-            },
-            LB: {
-              nextNode: 'exit_f'
-            },
-            B: {
-              nextNode: 'exit_f'
-            }
-          }
-        },
-        exit_t: {
-          type: 'LEAF',
-          class: 'T'
-        },
-        exit_f: {
-          type: 'LEAF',
-          class: 'F'
-        }
-      }
-    };
-
-    const outcome = retrieveEdges(decisionTree);
-    const expected = [
-      {
-        from: 'categoricalField',
-        to: 'exit_t',
-        label: 'P\nLP'
-      },
-      {
-        from: 'categoricalField',
-        to: 'exit_f',
-        label: 'LB\nB'
-      }
-    ];
-    expect(outcome).toStrictEqual(expected);
-  });
-});

package/tests/unit/utils/treeDrawer.spec.ts

@@ -1,104 +0,0 @@
-import treeDrawer from '@/utils/treeDrawer';
-
-describe('retrieveTreeFromFile', () => {
-  it('getLineThickness', () => {
-    const actual = treeDrawer.getLineThickness(10);
-    expect(actual).toEqual(1);
-  });
-  it('getBarHeightFromFontSize', () => {
-    const actual = treeDrawer.getBarHeightFromFontSize(12);
-    expect(actual).toEqual(36);
-  });
-  it('getFontSizeFromBarHeight', () => {
-    const actual = treeDrawer.getFontSizeFromBarHeight(12);
-    expect(actual).toEqual(4);
-  });
-  it('getNode', () => {
-    treeDrawer.getTextWidth = jest.fn().mockReturnValue(42);
-    const actual = treeDrawer.getNode('node', 10, 'BOOL', 'Arial');
-    const expected = {
-      label: 'node',
-      type: 'BOOL',
-      width: 52,
-      height: 30
-    };
-    expect(actual).toEqual(expected);
-  });
-  it('getMiddleEdgeIndex', () => {
-    const actual = treeDrawer.getMiddleEdgeIndex([
-      {
-        x: 1,
-        y: 1
-      },
-      {
-        x: 2,
-        y: 2
-      },
-      {
-        x: 3,
-        y: 3
-      }
-    ]);
-    expect(actual).toEqual(1);
-  });
-  it('getEdgeLabelXPos', () => {
-    const actual = treeDrawer.getEdgeLabelXPos(84, 42);
-    expect(actual).toEqual(107);
-  });
-  it('getEdgeLabelYPos', () => {
-    const actual = treeDrawer.getEdgeLabelYPos(42, 1, 10, 10);
-    expect(actual).toEqual(72);
-  });
-  it('getNodeXPos', () => {
-    const actual = treeDrawer.getNodeXPos(84, 42);
-    expect(actual).toEqual(63);
-  });
-  it('getNodeLabelYPos', () => {
-    const actual = treeDrawer.getNodeLabelYPos(42, 1, 10, 2);
-    expect(actual).toEqual(67);
-  });
-  it('getXPos', () => {
-    const actual = treeDrawer.getXPos(42, 42);
-    expect(actual).toEqual(84);
-  });
-  it('getYPos', () => {
-    const actual = treeDrawer.getYPos(42, 20, 42);
-    expect(actual).toEqual(94);
-  });
-  it('getLongestLabelPart', () => {
-    const actual = treeDrawer.getLongestLabelPart('this is a long label\nhello!');
-    expect(actual).toEqual('this is a long label');
-  });
-  it('getCoordinates', () => {
-    const actual = treeDrawer.getCoordinates(42, 42, 42, 42, 42, 42, 20);
-    expect(actual).toEqual({ x1: 84, x2: 84, y1: 94, y2: 94 });
-  });
-  it('getXOffset when vertical svg > graph', () => {
-    const actual = treeDrawer.getXOffset(20, 10, false);
-    expect(actual).toEqual(5);
-  });
-  it('getXOffset when vertical svg < graph', () => {
-    const actual = treeDrawer.getXOffset(20, 30, false);
-    expect(actual).toEqual(100);
-  });
-  it('getXOffset when horizontal', () => {
-    const actual = treeDrawer.getXOffset(20, 10, true);
-    expect(actual).toEqual(25);
-  });
-  it('getYOffset when svg > graph', () => {
-    const actual = treeDrawer.getYOffset(20, 10);
-    expect(actual).toEqual(5);
-  });
-  it('getYOffset when svg < graph', () => {
-    const actual = treeDrawer.getYOffset(10, 20);
-    expect(actual).toEqual(100);
-  });
-  it('getGraphScale', () => {
-    const actual = treeDrawer.getGraphScale(100, 50);
-    expect(actual).toEqual(1);
-  });
-  it('calculateScaleToFit', () => {
-    const actual = treeDrawer.calculateScaleToFit(0.6, 0.4);
-    expect(actual).toEqual(0.4);
-  });
-});

package/vue.config.js

@@ -1,36 +0,0 @@
-// vue.config.js
-// eslint-disable-next-line @typescript-eslint/no-var-requires
-const HtmlWebpackInlineSourcePlugin = require('html-webpack-inline-source-plugin');
-
-module.exports = {
-  filenameHashing: false,
-  productionSourceMap: process.env.NODE_ENV !== 'production',
-
-  configureWebpack: {
-    plugins: [new HtmlWebpackInlineSourcePlugin()]
-  },
-
-  chainWebpack: (config) => {
-    if (process.env.NODE_ENV === 'production') {
-      config.plugins.delete('preload');
-      config.plugins.delete('prefetch');
-
-      config.optimization.splitChunks({ chunks: 'all' });
-
-      config.plugin('html').tap((args) => {
-        args[0].filename = './vip-report-template.html';
-        args[0].inlineSource = '.(js|css)$';
-        return args;
-      });
-    }
-  },
-
-  pluginOptions: {
-    i18n: {
-      locale: 'en',
-      fallbackLocale: 'en',
-      localeDir: 'locales',
-      enableInSFC: false
-    }
-  }
-};