@molgenis/vip-report-template 6.1.1 → 7.0.0

package/tests/utils/sample.test.ts

@@ -0,0 +1,259 @@
+import { describe, expect, test } from "vitest";
+import {
+  getPedigreeSamples,
+  getSampleAffectedStatusLabel,
+  getSampleLabel,
+  getSampleSexLabel,
+  isSampleFather,
+  isSampleMother,
+} from "../../src/utils/sample.ts";
+import { Item, Sample } from "@molgenis/vip-report-api";
+import { SampleContainer } from "../../src/utils/api.ts";
+
+describe("sample utilities", () => {
+  test("getSampleLabel", () => {
+    const individualId = "sample_label";
+    const sample: Item<Sample> = {
+      data: {
+        person: {
+          individualId: individualId,
+        },
+      },
+    } as Item<Sample>;
+    expect(getSampleLabel(sample)).toStrictEqual(individualId);
+  });
+
+  describe("getSampleSexLabel", () => {
+    test("FEMALE", () => {
+      const sample: Item<Sample> = {
+        data: {
+          person: {
+            sex: "FEMALE",
+          },
+        },
+      } as Item<Sample>;
+      expect(getSampleSexLabel(sample)).toStrictEqual("female");
+    });
+
+    test("MALE", () => {
+      const sample: Item<Sample> = {
+        data: {
+          person: {
+            sex: "MALE",
+          },
+        },
+      } as Item<Sample>;
+      expect(getSampleSexLabel(sample)).toStrictEqual("male");
+    });
+
+    test("OTHER_SEX", () => {
+      const sample: Item<Sample> = {
+        data: {
+          person: {
+            sex: "OTHER_SEX",
+          },
+        },
+      } as Item<Sample>;
+      expect(getSampleSexLabel(sample)).toStrictEqual("?");
+    });
+
+    test("UNKNOWN_SEX", () => {
+      const sample: Item<Sample> = {
+        data: {
+          person: {
+            sex: "UNKNOWN_SEX",
+          },
+        },
+      } as Item<Sample>;
+      expect(getSampleSexLabel(sample)).toStrictEqual("?");
+    });
+  });
+
+  describe("getSampleAffectedStatusLabel", () => {
+    test("AFFECTED", () => {
+      const sample: Item<Sample> = {
+        data: {
+          person: {
+            affectedStatus: "AFFECTED",
+          },
+        },
+      } as Item<Sample>;
+      expect(getSampleAffectedStatusLabel(sample)).toStrictEqual("affected");
+    });
+
+    test("UNAFFECTED", () => {
+      const sample: Item<Sample> = {
+        data: {
+          person: {
+            affectedStatus: "UNAFFECTED",
+          },
+        },
+      } as Item<Sample>;
+      expect(getSampleAffectedStatusLabel(sample)).toStrictEqual("unaffected");
+    });
+
+    test("MISSING", () => {
+      const sample: Item<Sample> = {
+        data: {
+          person: {
+            affectedStatus: "MISSING",
+          },
+        },
+      } as Item<Sample>;
+      expect(getSampleAffectedStatusLabel(sample)).toStrictEqual("?");
+    });
+  });
+
+  describe("isSampleMother", () => {
+    test("true", () => {
+      const sample: Sample = {
+        person: {
+          maternalId: "mother0",
+          familyId: "fam0",
+        },
+      } as Sample;
+      const sampleMaternal: Sample = {
+        person: {
+          individualId: "mother0",
+          familyId: "fam0",
+        },
+      } as Sample;
+      expect(isSampleMother(sample, sampleMaternal)).toStrictEqual(true);
+    });
+
+    test("false, mother unknown", () => {
+      const sample: Sample = {
+        person: {
+          familyId: "fam0",
+        },
+      } as Sample;
+      const sampleMaternal: Sample = {
+        person: {
+          individualId: "mother0",
+          familyId: "fam0",
+        },
+      } as Sample;
+      expect(isSampleMother(sample, sampleMaternal)).toStrictEqual(false);
+    });
+
+    test("false, different family", () => {
+      const sample: Sample = {
+        person: {
+          maternalId: "mother0",
+          familyId: "fam0",
+        },
+      } as Sample;
+      const sampleMaternal: Sample = {
+        person: {
+          individualId: "mother0",
+          familyId: "fam1",
+        },
+      } as Sample;
+      expect(isSampleMother(sample, sampleMaternal)).toStrictEqual(false);
+    });
+
+    test("false, different individual id", () => {
+      const sample: Sample = {
+        person: {
+          maternalId: "mother0",
+          familyId: "fam0",
+        },
+      } as Sample;
+      const sampleMaternal: Sample = {
+        person: {
+          individualId: "individual0",
+          familyId: "fam1",
+        },
+      } as Sample;
+      expect(isSampleMother(sample, sampleMaternal)).toStrictEqual(false);
+    });
+  });
+
+  describe("isSampleFather", () => {
+    test("true", () => {
+      const sample: Sample = {
+        person: {
+          paternalId: "father0",
+          familyId: "fam0",
+        },
+      } as Sample;
+      const sampleMaternal: Sample = {
+        person: {
+          individualId: "father0",
+          familyId: "fam0",
+        },
+      } as Sample;
+      expect(isSampleFather(sample, sampleMaternal)).toStrictEqual(true);
+    });
+
+    test("false, mother unknown", () => {
+      const sample: Sample = {
+        person: {
+          familyId: "fam0",
+        },
+      } as Sample;
+      const sampleMaternal: Sample = {
+        person: {
+          individualId: "father0",
+          familyId: "fam0",
+        },
+      } as Sample;
+      expect(isSampleFather(sample, sampleMaternal)).toStrictEqual(false);
+    });
+
+    test("false, different family", () => {
+      const sample: Sample = {
+        person: {
+          paternalId: "father0",
+          familyId: "fam0",
+        },
+      } as Sample;
+      const sampleMaternal: Sample = {
+        person: {
+          individualId: "father0",
+          familyId: "fam1",
+        },
+      } as Sample;
+      expect(isSampleFather(sample, sampleMaternal)).toStrictEqual(false);
+    });
+
+    test("false, different individual id", () => {
+      const sample: Sample = {
+        person: {
+          paternalId: "father0",
+          familyId: "fam0",
+        },
+      } as Sample;
+      const sampleMaternal: Sample = {
+        person: {
+          individualId: "individual0",
+          familyId: "fam1",
+        },
+      } as Sample;
+      expect(isSampleFather(sample, sampleMaternal)).toStrictEqual(false);
+    });
+  });
+  describe("getPedigreeSamples", () => {
+    test("get", () => {
+      const sample = {
+        item: { id: 0 },
+        maternalSample: { id: 1 },
+        paternalSample: { id: 2 },
+        otherPedigreeSamples: [{ id: 3 }, { id: 4 }],
+      } as SampleContainer;
+
+      expect(getPedigreeSamples(sample)).toStrictEqual([{ id: 0 }, { id: 1 }, { id: 2 }, { id: 3 }, { id: 4 }]);
+    });
+
+    test("get, no father/mother/other", () => {
+      const sample = {
+        item: { id: 0 },
+        maternalSample: null,
+        paternalSample: null,
+        otherPedigreeSamples: [] as Item<Sample>[],
+      } as SampleContainer;
+
+      expect(getPedigreeSamples(sample)).toStrictEqual([{ id: 0 }]);
+    });
+  });
+});

package/tests/utils/utils.test.ts

@@ -0,0 +1,120 @@
+import { describe, expect, test } from "vitest";
+import { Item } from "@molgenis/vip-report-api";
+import { VcfRecord } from "@molgenis/vip-report-vcf";
+import {
+  abbreviateHeader,
+  getRecordLabel,
+  href,
+  isPositiveInteger,
+  parseId,
+  validateIntervalInput,
+} from "../../src/utils/utils.ts";
+
+describe("utils", () => {
+  describe("getRecordLabel", () => {
+    const recordBase = {
+      data: {
+        c: "chr1",
+        p: 123,
+        r: "A",
+        a: [],
+      },
+    } as Partial<Item<Partial<VcfRecord>>> as Item<VcfRecord>;
+
+    test("single allelic", () => {
+      const record = { ...recordBase, data: { ...recordBase.data, a: ["C"] } };
+      expect(getRecordLabel(record)).toStrictEqual("chr1:123 A>C");
+    });
+
+    test("multi allelic", () => {
+      const record = { ...recordBase, data: { ...recordBase.data, a: ["C", "T"] } };
+      expect(getRecordLabel(record)).toStrictEqual("chr1:123 A>C / A>T");
+    });
+
+    test("long ref or alt", () => {
+      const record = { ...recordBase, data: { ...recordBase.data, r: "GTCAGTCA", a: ["ACTGACTG"] } };
+      expect(getRecordLabel(record)).toStrictEqual("chr1:123 GT…A>AC…G");
+    });
+
+    test("missing alt", () => {
+      const record = { ...recordBase, data: { ...recordBase.data, a: [null] } };
+      expect(getRecordLabel(record)).toStrictEqual("chr1:123 A>.");
+    });
+  });
+
+  test("href", () => {
+    expect(href(["x", "/", "y"])).toStrictEqual("/x/%2F/y");
+  });
+
+  describe("isPositiveInteger", () => {
+    test("2", () => {
+      expect(isPositiveInteger(2)).toStrictEqual(true);
+    });
+
+    test("-2", () => {
+      expect(isPositiveInteger(-2)).toStrictEqual(false);
+    });
+
+    test("1.23", () => {
+      expect(isPositiveInteger(1.23)).toStrictEqual(false);
+    });
+
+    test("NaN", () => {
+      expect(isPositiveInteger(NaN)).toStrictEqual(false);
+    });
+  });
+
+  describe("parseId", () => {
+    test("0", () => {
+      expect(parseId("0")).toStrictEqual(0);
+    });
+
+    test("123", () => {
+      expect(parseId("123")).toStrictEqual(123);
+    });
+
+    test("undefined", () => {
+      expect(() => parseId(undefined)).toThrow();
+    });
+  });
+
+  describe("abbreviateHeader", () => {
+    test("abbreviate yes", () => {
+      expect(abbreviateHeader("foo bar foo bar foo bar")).toStrictEqual("foo bar foo\u2026");
+    });
+
+    test("abbreviate no", () => {
+      expect(abbreviateHeader("foo bar")).toStrictEqual("foo bar");
+    });
+  });
+
+  describe("validateIntervalInput", () => {
+    test("interval [1,]", () => {
+      expect(validateIntervalInput("x", "1", undefined)).toStrictEqual(undefined);
+    });
+
+    test("interval [,1]", () => {
+      expect(validateIntervalInput("x", "", "1")).toStrictEqual(undefined);
+    });
+
+    test("interval [1,1]", () => {
+      expect(validateIntervalInput("x", "1", "1")).toStrictEqual(undefined);
+    });
+
+    test("interval [2,1]", () => {
+      expect(validateIntervalInput("x", "2", "1")).toStrictEqual(
+        "Input 'to' (1) for filter 'x' should have a higher value than the 'from' input (2).",
+      );
+    });
+
+    test("interval [1.23,]", () => {
+      expect(validateIntervalInput("x", "1.23", "")).toStrictEqual(undefined);
+    });
+
+    test("interval [,abc]", () => {
+      expect(validateIntervalInput("x", "", "abc")).toStrictEqual(
+        "Input 'to' (abc) for filter 'x' should be a number.",
+      );
+    });
+  });
+});

package/tests/utils/variantType.test.ts

@@ -0,0 +1,48 @@
+import { describe, expect, test } from "vitest";
+import { getVariantTypes, mapSvTypeToVariantTypeId, parseVariantType } from "../../src/utils/variantType.ts";
+
+describe("variantType", () => {
+  test("getVariantTypes", () => {
+    expect(getVariantTypes(new Set(["all", "snv"]))).toStrictEqual([
+      {
+        id: "all",
+        label: "All",
+        description: "All variants",
+      },
+      { id: "snv", label: "SNV", description: "Single nucleotide variants and Indels < 50 bases" },
+    ]);
+  });
+
+  describe("parseVariantType", () => {
+    test("parse valid", () => {
+      expect(parseVariantType("snv")).toStrictEqual({
+        id: "snv",
+        label: "SNV",
+        description: "Single nucleotide variants and Indels < 50 bases",
+      });
+    });
+
+    test("parse invalid", () => {
+      expect(() => parseVariantType("invalid")).toThrow();
+    });
+
+    test("parse undefined", () => {
+      expect(() => parseVariantType(undefined)).toThrow();
+    });
+  });
+
+  describe("mapSvTypeToVariantTypeId", () => {
+    test("SVTYPE=null", () => {
+      expect(mapSvTypeToVariantTypeId(null)).toStrictEqual("snv");
+    });
+    test("SVTYPE=undefined", () => {
+      expect(mapSvTypeToVariantTypeId(undefined)).toStrictEqual("snv");
+    });
+    test("SVTYPE=STR", () => {
+      expect(mapSvTypeToVariantTypeId("STR")).toStrictEqual("str");
+    });
+    test("SVTYPE something else", () => {
+      expect(mapSvTypeToVariantTypeId("foo")).toStrictEqual("sv");
+    });
+  });
+});