@molgenis/vip-report-template 6.1.1 → 7.0.0

package/tests/utils/config/configCellsField.test.ts

@@ -0,0 +1,164 @@
+import { afterEach, describe, expect, test, vi } from "vitest";
+import { SampleContainer, VcfMetadataContainer } from "../../../src/utils/api.ts";
+import { Item } from "@molgenis/vip-report-api";
+import { VcfRecord } from "@molgenis/vip-report-vcf";
+import { initConfigCellGenotype, initConfigCellInfo } from "../../../src/utils/config/configCellsField.ts";
+import {
+  FieldMetadataWrapper,
+  getInfoFieldsRegex,
+  getInfoValue,
+  getInfoValueCount,
+  getSampleFieldsRegex,
+  getSampleValue,
+  getSampleValueCount,
+} from "../../../src/utils/vcf.ts";
+import { ConfigJsonFieldGenotype, ConfigJsonFieldInfo } from "../../../src/types/config";
+
+describe("config cells field", () => {
+  vi.mock(import("../../../src/utils/vcf.ts"));
+
+  afterEach(() => {
+    vi.resetAllMocks();
+  });
+
+  describe("initConfigCellInfo", () => {
+    const metadata = {} as VcfMetadataContainer;
+    const record = { id: 0, data: { c: "chr1", p: 123, r: "A", a: ["C", "T"] } } as Item<VcfRecord>;
+
+    test("config matches one field", () => {
+      const config: ConfigJsonFieldInfo = {
+        type: "info",
+        name: "field",
+        label: "my_field_label",
+        description: "my_field_description",
+      };
+      const field = {
+        id: "INFO/field",
+        label: "field_label",
+        description: "field_description",
+      } as FieldMetadataWrapper;
+      vi.mocked(getInfoFieldsRegex).mockReturnValue([field]);
+      vi.mocked(getInfoValueCount).mockReturnValue(1);
+      vi.mocked(getInfoValue).mockReturnValue(0);
+
+      const cells = initConfigCellInfo(config, metadata);
+      expect(cells.length).toStrictEqual(1);
+      const cell = cells[0]!;
+      expect(cell.type).toStrictEqual("info");
+      expect(cell.field).toStrictEqual(field);
+      expect(cell.label()).toStrictEqual("my_field_label");
+      expect(cell.description()).toStrictEqual("my_field_description");
+      expect(cell.valueCount(record)).toStrictEqual(1);
+      expect(cell.value(record, 1)).toStrictEqual(0);
+
+      expect(getInfoFieldsRegex).toHaveBeenCalledWith(metadata, /^field$/);
+      expect(getInfoValueCount).toHaveBeenCalledWith(record, field);
+      expect(getInfoValue).toHaveBeenCalledWith(record, 1, field);
+    });
+
+    test("config matches multiple fields", () => {
+      const config: ConfigJsonFieldInfo = {
+        type: "info",
+        name: "VIP/.*",
+      };
+      const fieldVip = {
+        id: "INFO/VIP",
+        nested: {},
+      } as FieldMetadataWrapper;
+      const fieldVipField0 = {
+        id: "INFO/VIP/field0",
+      } as FieldMetadataWrapper;
+      const fieldVipField1 = {
+        id: "INFO/VIP/field1",
+      } as FieldMetadataWrapper;
+      vi.mocked(getInfoFieldsRegex).mockReturnValue([fieldVip, fieldVipField0, fieldVipField1]);
+
+      const cells = initConfigCellInfo(config, metadata);
+      expect(cells.length).toStrictEqual(2); // drop nested fields
+      expect(getInfoFieldsRegex).toHaveBeenCalledWith(metadata, /^VIP\/.*$/);
+    });
+
+    test("config matches zero fields", () => {
+      const config: ConfigJsonFieldInfo = {
+        type: "info",
+        name: "field_not_in_my_vcf",
+      };
+      vi.mocked(getInfoFieldsRegex).mockReturnValue([]);
+
+      const cells = initConfigCellInfo(config, metadata);
+      expect(cells.length).toStrictEqual(0);
+      expect(getInfoFieldsRegex).toHaveBeenCalledWith(metadata, /^field_not_in_my_vcf$/);
+    });
+  });
+
+  describe("initConfigCellGenotype", () => {
+    const metadata = {} as VcfMetadataContainer;
+    const sample = { item: { id: 2 } } as SampleContainer;
+    const record = { id: 0, data: { c: "chr1", p: 123, r: "A", a: ["C", "T"] } } as Item<VcfRecord>;
+
+    test("config matches one field", () => {
+      const config: ConfigJsonFieldGenotype = {
+        type: "genotype",
+        name: "field",
+        label: "my_field_label",
+        description: "my_field_description",
+      };
+      const field = {
+        id: "FORMAT/field",
+        label: "field_label",
+        description: "field_description",
+      } as FieldMetadataWrapper;
+      vi.mocked(getSampleFieldsRegex).mockReturnValue([field]);
+      vi.mocked(getSampleValueCount).mockReturnValue(1);
+      vi.mocked(getSampleValue).mockReturnValue(0);
+
+      const cells = initConfigCellGenotype(config, metadata, sample);
+      expect(cells.length).toStrictEqual(1);
+      const cell = cells[0]!;
+      expect(cell.type).toStrictEqual("genotype");
+      expect(cell.field).toStrictEqual(field);
+      expect(cell.label()).toStrictEqual("my_field_label");
+      expect(cell.description()).toStrictEqual("my_field_description");
+      expect(cell.valueCount(record)).toStrictEqual(1);
+      expect(cell.value(record, 1)).toStrictEqual(0);
+
+      expect(getSampleFieldsRegex).toHaveBeenCalledWith(metadata, /^field$/);
+      expect(getSampleValueCount).toHaveBeenCalledWith(sample, record, field);
+      expect(getSampleValue).toHaveBeenCalledWith(sample, record, 1, field);
+    });
+
+    test("config matches multiple fields", () => {
+      const config: ConfigJsonFieldGenotype = {
+        type: "genotype",
+        name: "VIP/.*",
+      };
+      const fieldVip = {
+        id: "FORMAT/VIP",
+        nested: {},
+      } as FieldMetadataWrapper;
+      const fieldVipField0 = {
+        id: "FORMAT/VIP/field0",
+      } as FieldMetadataWrapper;
+      const fieldVipField1 = {
+        id: "FORMAT/VIP/field1",
+      } as FieldMetadataWrapper;
+      vi.mocked(getSampleFieldsRegex).mockReturnValue([fieldVip, fieldVipField0, fieldVipField1]);
+
+      const cells = initConfigCellGenotype(config, metadata, sample);
+      expect(cells.length).toStrictEqual(2); // drop nested fields
+      expect(getSampleFieldsRegex).toHaveBeenCalledWith(metadata, /^VIP\/.*$/);
+    });
+
+    test("config matches zero fields", () => {
+      const config: ConfigJsonFieldGenotype = {
+        type: "genotype",
+        name: "field_not_in_my_vcf",
+      };
+      vi.mocked(getSampleFieldsRegex).mockReturnValue([]);
+
+      const cells = initConfigCellGenotype(config, metadata, sample);
+      expect(cells.length).toStrictEqual(0);
+      expect(getSampleFieldsRegex).toHaveBeenCalledWith(metadata, /^field_not_in_my_vcf$/);
+    });
+  });
+});

package/tests/utils/config/configCellsFixed.test.ts

@@ -0,0 +1,99 @@
+import { describe, expect, test } from "vitest";
+import { initConfigCellFixed } from "../../../src/utils/config/configCellsFixed.ts";
+import { Item } from "@molgenis/vip-report-api";
+import { VcfRecord } from "@molgenis/vip-report-vcf";
+
+describe("config cells fixed", () => {
+  describe("initConfigCellFixed", () => {
+    test("chrom", () => {
+      const cell = initConfigCellFixed({ type: "fixed", name: "chrom" });
+      const record: Partial<Item<Partial<VcfRecord>>> = { data: { c: "chr1" } };
+
+      expect(cell.type).toStrictEqual("chrom");
+      expect(cell.label()).toStrictEqual("Chromosome");
+      expect(cell.description()).toStrictEqual(null);
+      expect(cell.value(record as Item<VcfRecord>, 0)).toStrictEqual("chr1");
+      expect(cell.valueCount(record as Item<VcfRecord>)).toStrictEqual(1);
+    });
+
+    test("pos", () => {
+      const cell = initConfigCellFixed({ type: "fixed", name: "pos" });
+      const record: Partial<Item<Partial<VcfRecord>>> = { data: { p: 1 } };
+
+      expect(cell.type).toStrictEqual("pos");
+      expect(cell.label()).toStrictEqual("Position");
+      expect(cell.description()).toStrictEqual(null);
+      expect(cell.value(record as Item<VcfRecord>, 0)).toStrictEqual(1);
+      expect(cell.valueCount(record as Item<VcfRecord>)).toStrictEqual(1);
+    });
+
+    test("id", () => {
+      const cell = initConfigCellFixed({ type: "fixed", name: "id" });
+      const record: Partial<Item<Partial<VcfRecord>>> = { data: { i: ["id0", "id1"] } };
+
+      expect(cell.type).toStrictEqual("id");
+      expect(cell.label()).toStrictEqual("Ids");
+      expect(cell.description()).toStrictEqual(null);
+      expect(cell.value(record as Item<VcfRecord>, 0)).toStrictEqual(["id0", "id1"]);
+      expect(cell.valueCount(record as Item<VcfRecord>)).toStrictEqual(1);
+    });
+
+    test("ref", () => {
+      const cell = initConfigCellFixed({ type: "fixed", name: "ref" });
+      const record: Partial<Item<Partial<VcfRecord>>> = { data: { r: "A" } };
+
+      expect(cell.type).toStrictEqual("ref");
+      expect(cell.label()).toStrictEqual("Reference");
+      expect(cell.description()).toStrictEqual("Reference base(s)");
+      expect(cell.value(record as Item<VcfRecord>, 0)).toStrictEqual("A");
+      expect(cell.valueCount(record as Item<VcfRecord>)).toStrictEqual(1);
+    });
+
+    test("alt", () => {
+      const cell = initConfigCellFixed({ type: "fixed", name: "alt" });
+      const record: Partial<Item<Partial<VcfRecord>>> = { data: { a: ["C", "T"] } };
+
+      expect(cell.type).toStrictEqual("alt");
+      expect(cell.label()).toStrictEqual("Alternate(s)");
+      expect(cell.description()).toStrictEqual("Alternate base(s): list of alternate non-reference alleles");
+      expect(cell.value(record as Item<VcfRecord>, 0)).toStrictEqual(["C", "T"]);
+      expect(cell.valueCount(record as Item<VcfRecord>)).toStrictEqual(1);
+    });
+
+    test("qual", () => {
+      const cell = initConfigCellFixed({ type: "fixed", name: "qual" });
+      const record: Partial<Item<Partial<VcfRecord>>> = { data: { q: 123 } };
+
+      expect(cell.type).toStrictEqual("qual");
+      expect(cell.label()).toStrictEqual("Qual");
+      expect(cell.description()).toStrictEqual("Quality: phred-scaled quality score for the 'Alt' assertions");
+      expect(cell.value(record as Item<VcfRecord>, 0)).toStrictEqual(123);
+      expect(cell.valueCount(record as Item<VcfRecord>)).toStrictEqual(1);
+    });
+
+    test("filter", () => {
+      const cell = initConfigCellFixed({ type: "fixed", name: "filter" });
+      const record: Partial<Item<Partial<VcfRecord>>> = { data: { f: ["PASS"] } };
+
+      expect(cell.type).toStrictEqual("filter");
+      expect(cell.label()).toStrictEqual("Filters");
+      expect(cell.description()).toStrictEqual(
+        "Filter status: PASS if this position has passed all filter, otherwise a list of codes for filters that fail",
+      );
+      expect(cell.value(record as Item<VcfRecord>, 0)).toStrictEqual(["PASS"]);
+      expect(cell.valueCount(record as Item<VcfRecord>)).toStrictEqual(1);
+    });
+
+    test("cell with custom label and description", () => {
+      const cell = initConfigCellFixed({
+        type: "fixed",
+        name: "chrom",
+        label: "custom_label",
+        description: "custom_description",
+      });
+
+      expect(cell.label()).toStrictEqual("custom_label");
+      expect(cell.description()).toStrictEqual("custom_description");
+    });
+  });
+});

package/tests/utils/config/configFilters.test.ts

@@ -0,0 +1,80 @@
+import { afterEach, describe, expect, test, vi } from "vitest";
+import { initConfigFilters } from "../../../src/utils/config/configFilters.ts";
+import { ConfigJsonFilter, ConfigVip } from "../../../src/types/config";
+import { MetadataContainer, SampleContainer, VcfMetadataContainer } from "../../../src/utils/api.ts";
+import { initConfigFilterFixed } from "../../../src/utils/config/configFiltersFixed.ts";
+import { ConfigFilterField, ConfigFilterFixed, ConfigFilterFormat } from "../../../src/types/configFilter";
+import { initConfigFilterComposed } from "../../../src/utils/config/configFiltersComposed.ts";
+import { initConfigFiltersGenotype, initConfigFiltersInfo } from "../../../src/utils/config/configFiltersField.ts";
+import { ConfigFilterComposed } from "../../../src/types/configFilterComposed";
+
+describe("config filters", () => {
+  vi.mock(import("../../../src/utils/config/configFiltersComposed.ts"));
+  vi.mock(import("../../../src/utils/config/configFiltersField.ts"));
+  vi.mock(import("../../../src/utils/config/configFiltersFixed.ts"));
+
+  afterEach(() => {
+    vi.resetAllMocks();
+  });
+
+  const metadata: Partial<MetadataContainer> = { records: {} as VcfMetadataContainer };
+  const sample: Partial<SampleContainer> | null = {};
+
+  describe("initConfigFilters", () => {
+    const configVip = {} as ConfigVip;
+
+    test("regular filters config", () => {
+      vi.mocked(initConfigFilterFixed).mockReturnValue({ type: "fixed", id: "chrom" } as ConfigFilterFixed);
+      vi.mocked(initConfigFiltersInfo).mockReturnValue([
+        {
+          type: "info",
+          id: "my_info",
+        } as Partial<ConfigFilterField> as ConfigFilterField,
+      ]);
+      vi.mocked(initConfigFiltersGenotype).mockReturnValue([
+        {
+          type: "genotype",
+          id: "my_genotype",
+        } as Partial<ConfigFilterFormat> as ConfigFilterFormat,
+      ]);
+      vi.mocked(initConfigFilterComposed).mockReturnValue({
+        type: "composed",
+        id: "locus",
+      } as Partial<ConfigFilterComposed> as ConfigFilterComposed);
+
+      const config: ConfigJsonFilter[] = [
+        { type: "fixed", name: "chrom" },
+        { type: "info", name: "my_info" },
+        { type: "genotype", name: "my_genotype" },
+        { type: "composed", name: "locus" },
+      ];
+
+      expect(
+        initConfigFilters(config, configVip, metadata as MetadataContainer, sample as SampleContainer | null),
+      ).toStrictEqual([
+        { type: "fixed", id: "fixed/chrom" },
+        { type: "info", id: "info/my_info" },
+        {
+          type: "genotype",
+          id: "genotype/my_genotype",
+        },
+        { type: "composed", id: "composed/locus" },
+      ]);
+    });
+
+    test("exclude filters that are not applicable", () => {
+      vi.mocked(initConfigFiltersInfo).mockReturnValue([]);
+      vi.mocked(initConfigFiltersGenotype).mockReturnValue([]);
+      vi.mocked(initConfigFilterComposed).mockReturnValue(null);
+
+      const config: ConfigJsonFilter[] = [
+        { type: "info", name: "unknown_info" },
+        { type: "genotype", name: "unknown_genotype" },
+      ];
+
+      expect(
+        initConfigFilters(config, configVip, metadata as MetadataContainer, sample as SampleContainer | null),
+      ).toStrictEqual([]);
+    });
+  });
+});