@molgenis/vip-report-template 6.1.1 → 7.0.0

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

@@ -0,0 +1,504 @@
+import { afterEach, describe, expect, test, vi } from "vitest";
+import { initConfigFilterComposed } from "../../../src/utils/config/configFiltersComposed.ts";
+import { MetadataContainer, SampleContainer } from "../../../src/utils/api.ts";
+import { ConfigJsonFilterComposed, ConfigVip } from "../../../src/types/config";
+import {
+  ConfigFilterAllelicImbalance,
+  ConfigFilterDeNovo,
+  ConfigFilterHpo,
+  ConfigFilterInheritanceMatch,
+  ConfigFilterLocus,
+  ConfigFilterVipC,
+  ConfigFilterVipCS,
+} from "../../../src/types/configFilterComposed";
+import {
+  FieldMetadataWrapper,
+  getInfoNestedField,
+  getSampleField,
+  getSampleFields,
+  parseContigIds,
+} from "../../../src/utils/vcf.ts";
+import { PhenotypicFeature } from "@molgenis/vip-report-api";
+
+describe("config filters composed", () => {
+  vi.mock(import("../../../src/utils/vcf.ts"));
+
+  afterEach(() => {
+    vi.resetAllMocks();
+  });
+
+  describe("initConfigFiltersComposed", () => {
+    const vcfMetadata = {};
+    const metadata = { records: vcfMetadata } as MetadataContainer;
+    const configVip = {} as ConfigVip;
+
+    describe("hpo", () => {
+      const configBase: ConfigJsonFilterComposed = {
+        type: "composed",
+        name: "hpo",
+      };
+      const sample = {
+        phenotypes: [
+          { type: { id: "HP:0000951", label: "HP:0000951 label" } },
+          {
+            type: {
+              id: "HP:0000952",
+              label: "HP:0000952 label",
+            },
+          },
+        ],
+      } as SampleContainer;
+
+      test("hpo", () => {
+        const fieldHpo = { id: "CSQ/HPO" };
+        vi.mocked(getInfoNestedField).mockReturnValue(fieldHpo as FieldMetadataWrapper);
+
+        const filter = initConfigFilterComposed(configBase, configVip, metadata, sample) as ConfigFilterHpo;
+        expect(filter.type).toStrictEqual("composed");
+        expect(filter.id).toStrictEqual("hpo");
+        expect(filter.field).toStrictEqual({
+          ...fieldHpo,
+          categories: {
+            "HP:0000951": {
+              label: "HP:0000951 label",
+            },
+            "HP:0000952": {
+              label: "HP:0000952 label",
+            },
+          },
+        });
+        expect(getInfoNestedField).toHaveBeenCalledWith(vcfMetadata, "CSQ", "HPO");
+      });
+
+      test("hpo with field label and description", () => {
+        const fieldHpo = {
+          id: "CSQ/HPO",
+          label: "field_label",
+          description: "field_description",
+        };
+        vi.mocked(getInfoNestedField).mockReturnValue(fieldHpo as FieldMetadataWrapper);
+
+        const filter = initConfigFilterComposed(configBase, configVip, metadata, sample) as ConfigFilterHpo;
+        expect(filter.label()).toStrictEqual("field_label");
+        expect(filter.description()).toStrictEqual("field_description");
+      });
+
+      test("hpo with custom label and description", () => {
+        const config: ConfigJsonFilterComposed = {
+          ...configBase,
+          label: "my_label",
+          description: "my_description",
+        };
+
+        const fieldHpo = { id: "CSQ/HPO" };
+        vi.mocked(getInfoNestedField).mockReturnValue(fieldHpo as FieldMetadataWrapper);
+
+        const filter = initConfigFilterComposed(config, configVip, metadata, sample) as ConfigFilterHpo;
+        expect(filter.label()).toStrictEqual("my_label");
+        expect(filter.description()).toStrictEqual("my_description");
+      });
+
+      test("hpo is null when sample has no phenotypes", () => {
+        const sample = {
+          phenotypes: [] as PhenotypicFeature[],
+        } as SampleContainer;
+
+        expect(initConfigFilterComposed(configBase, configVip, metadata, sample)).toStrictEqual(null);
+      });
+
+      test("hpo is null when sample is null", () => {
+        expect(initConfigFilterComposed(configBase, configVip, metadata, null)).toStrictEqual(null);
+      });
+
+      test("hpo is null when metadata absent", () => {
+        vi.mocked(getInfoNestedField).mockReturnValue(undefined);
+        expect(initConfigFilterComposed(configBase, configVip, metadata, sample)).toStrictEqual(null);
+        expect(getInfoNestedField).toHaveBeenCalledWith(vcfMetadata, "CSQ", "HPO");
+      });
+    });
+
+    describe("locus", () => {
+      const configBase: ConfigJsonFilterComposed = {
+        type: "composed",
+        name: "locus",
+      };
+
+      test("locus", () => {
+        vi.mocked(parseContigIds).mockReturnValue(["chr1", "chr2"]);
+
+        const filter = initConfigFilterComposed(configBase, configVip, metadata, null) as ConfigFilterLocus;
+        expect(filter.type).toStrictEqual("composed");
+        expect(filter.id).toStrictEqual("locus");
+        expect(filter.label()).toStrictEqual("Locus");
+        expect(filter.description()).toStrictEqual(null);
+        expect(filter.chromosomes).toStrictEqual(["chr1", "chr2"]);
+
+        expect(parseContigIds).toHaveBeenCalledWith(vcfMetadata);
+      });
+
+      test("locus with custom label and description", () => {
+        const config: ConfigJsonFilterComposed = {
+          ...configBase,
+          label: "my_label",
+          description: "my_description",
+        };
+
+        const filter = initConfigFilterComposed(config, configVip, metadata, null) as ConfigFilterLocus;
+        expect(filter.label()).toStrictEqual("my_label");
+        expect(filter.description()).toStrictEqual("my_description");
+      });
+    });
+
+    describe("allelicImbalance", () => {
+      const configBase: ConfigJsonFilterComposed = {
+        type: "composed",
+        name: "allelicImbalance",
+      };
+      const sample = {} as SampleContainer;
+
+      test("allelicImbalance", () => {
+        const fieldViab = { id: "FORMAT/VIAB" };
+        const fieldGt = { id: "FORMAT/GT" };
+        vi.mocked(getSampleFields).mockReturnValue([fieldViab, fieldGt] as FieldMetadataWrapper[]);
+
+        const filter = initConfigFilterComposed(
+          configBase,
+          configVip,
+          metadata,
+          sample,
+        ) as ConfigFilterAllelicImbalance;
+        expect(filter.type).toStrictEqual("composed");
+        expect(filter.id).toStrictEqual("allelicImbalance");
+        expect(filter.label()).toStrictEqual("VIAB");
+        expect(filter.description()).toStrictEqual(null);
+        expect(filter.sample).toStrictEqual(sample);
+        expect(filter.viabField).toStrictEqual(fieldViab);
+        expect(filter.genotypeField).toStrictEqual(fieldGt);
+
+        expect(getSampleFields).toHaveBeenCalledWith(vcfMetadata, "VIAB", "GT");
+      });
+
+      test("allelicImbalance with field label and description", () => {
+        const fieldViab = { id: "FORMAT/VIAB", label: "field_label", description: "field_description" };
+        const fieldGt = { id: "FORMAT/GT" };
+        vi.mocked(getSampleFields).mockReturnValue([fieldViab, fieldGt] as FieldMetadataWrapper[]);
+
+        const filter = initConfigFilterComposed(
+          configBase,
+          configVip,
+          metadata,
+          sample,
+        ) as ConfigFilterAllelicImbalance;
+        expect(filter.label()).toStrictEqual("field_label");
+        expect(filter.description()).toStrictEqual("field_description");
+      });
+
+      test("allelicImbalance with custom label and description", () => {
+        const config: ConfigJsonFilterComposed = {
+          ...configBase,
+          label: "my_label",
+          description: "my_description",
+        };
+
+        const fieldViab = { id: "FORMAT/VIAB" };
+        const fieldGt = { id: "FORMAT/GT" };
+        vi.mocked(getSampleFields).mockReturnValue([fieldViab, fieldGt] as FieldMetadataWrapper[]);
+
+        const filter = initConfigFilterComposed(config, configVip, metadata, sample) as ConfigFilterAllelicImbalance;
+        expect(filter.label()).toStrictEqual("my_label");
+        expect(filter.description()).toStrictEqual("my_description");
+      });
+
+      test("allelicImbalance null for absent sample", () => {
+        expect(initConfigFilterComposed(configBase, configVip, metadata, null)).toStrictEqual(null);
+      });
+
+      test("allelicImbalance null for absent metadata", () => {
+        const fieldGt = { id: "FORMAT/GT" };
+        vi.mocked(getSampleFields).mockReturnValue([undefined, fieldGt] as FieldMetadataWrapper[]);
+        expect(initConfigFilterComposed(configBase, configVip, metadata, sample)).toStrictEqual(null);
+        expect(getSampleFields).toHaveBeenCalledWith(vcfMetadata, "VIAB", "GT");
+      });
+    });
+
+    describe("inheritanceMatch", () => {
+      const configBase: ConfigJsonFilterComposed = {
+        type: "composed",
+        name: "inheritanceMatch",
+      };
+      const sample = {} as SampleContainer;
+
+      test("inheritanceMatch", () => {
+        const fieldVim = { id: "FORMAT/VIM" };
+        vi.mocked(getSampleField).mockReturnValue(fieldVim as FieldMetadataWrapper);
+
+        const filter = initConfigFilterComposed(
+          configBase,
+          configVip,
+          metadata,
+          sample,
+        ) as ConfigFilterInheritanceMatch;
+        expect(filter.type).toStrictEqual("composed");
+        expect(filter.id).toStrictEqual("inheritanceMatch");
+        expect(filter.label()).toStrictEqual("VIM");
+        expect(filter.description()).toStrictEqual(null);
+        expect(filter.sample).toStrictEqual(sample);
+        expect(filter.vimField).toStrictEqual({ ...fieldVim, required: true });
+
+        expect(getSampleField).toHaveBeenCalledWith(vcfMetadata, "VIM");
+      });
+
+      test("inheritanceMatch with field label and description", () => {
+        const fieldVim = { id: "FORMAT/VIM", label: "field_label", description: "field_description" };
+        vi.mocked(getSampleField).mockReturnValue(fieldVim as FieldMetadataWrapper);
+
+        const filter = initConfigFilterComposed(
+          configBase,
+          configVip,
+          metadata,
+          sample,
+        ) as ConfigFilterInheritanceMatch;
+        expect(filter.label()).toStrictEqual("field_label");
+        expect(filter.description()).toStrictEqual("field_description");
+      });
+
+      test("inheritanceMatch with custom label and description", () => {
+        const config: ConfigJsonFilterComposed = {
+          ...configBase,
+          label: "my_label",
+          description: "my_description",
+        };
+
+        const fieldVim = { id: "FORMAT/VIM" };
+        vi.mocked(getSampleField).mockReturnValue(fieldVim as FieldMetadataWrapper);
+
+        const filter = initConfigFilterComposed(config, configVip, metadata, sample) as ConfigFilterInheritanceMatch;
+        expect(filter.label()).toStrictEqual("my_label");
+        expect(filter.description()).toStrictEqual("my_description");
+      });
+
+      test("inheritanceMatch null for absent sample", () => {
+        expect(initConfigFilterComposed(configBase, configVip, metadata, null)).toStrictEqual(null);
+      });
+
+      test("inheritanceMatch null for absent metadata", () => {
+        vi.mocked(getSampleField).mockReturnValue(undefined);
+        expect(initConfigFilterComposed(configBase, configVip, metadata, sample)).toStrictEqual(null);
+        expect(getSampleField).toHaveBeenCalledWith(vcfMetadata, "VIM");
+      });
+    });
+
+    describe("deNovo", () => {
+      const configBase: ConfigJsonFilterComposed = {
+        type: "composed",
+        name: "deNovo",
+      };
+      const sample = {} as SampleContainer;
+
+      test("deNovo", () => {
+        const fieldVid = { id: "FORMAT/VID" };
+        vi.mocked(getSampleField).mockReturnValue(fieldVid as FieldMetadataWrapper);
+
+        const filter = initConfigFilterComposed(configBase, configVip, metadata, sample) as ConfigFilterDeNovo;
+        expect(filter.type).toStrictEqual("composed");
+        expect(filter.id).toStrictEqual("deNovo");
+        expect(filter.label()).toStrictEqual("VID");
+        expect(filter.description()).toStrictEqual(null);
+        expect(filter.sample).toStrictEqual(sample);
+        expect(filter.vidField).toStrictEqual({ ...fieldVid, required: true });
+
+        expect(getSampleField).toHaveBeenCalledWith(vcfMetadata, "VID");
+      });
+
+      test("deNovo with field label and description", () => {
+        const fieldVid = { id: "FORMAT/VID", label: "field_label", description: "field_description" };
+        vi.mocked(getSampleField).mockReturnValue(fieldVid as FieldMetadataWrapper);
+
+        const filter = initConfigFilterComposed(configBase, configVip, metadata, sample) as ConfigFilterDeNovo;
+        expect(filter.label()).toStrictEqual("field_label");
+        expect(filter.description()).toStrictEqual("field_description");
+      });
+
+      test("deNovo with custom label and description", () => {
+        const config: ConfigJsonFilterComposed = {
+          ...configBase,
+          label: "my_label",
+          description: "my_description",
+        };
+
+        const fieldVid = { id: "FORMAT/VID" };
+        vi.mocked(getSampleField).mockReturnValue(fieldVid as FieldMetadataWrapper);
+
+        const filter = initConfigFilterComposed(config, configVip, metadata, sample) as ConfigFilterDeNovo;
+        expect(filter.label()).toStrictEqual("my_label");
+        expect(filter.description()).toStrictEqual("my_description");
+      });
+
+      test("deNovo null for absent sample", () => {
+        expect(initConfigFilterComposed(configBase, configVip, metadata, null)).toStrictEqual(null);
+      });
+
+      test("deNovo null for absent metadata", () => {
+        vi.mocked(getSampleField).mockReturnValue(undefined);
+        expect(initConfigFilterComposed(configBase, configVip, metadata, sample)).toStrictEqual(null);
+        expect(getSampleField).toHaveBeenCalledWith(vcfMetadata, "VID");
+      });
+    });
+
+    describe("vipC", () => {
+      const configBase: ConfigJsonFilterComposed = {
+        type: "composed",
+        name: "vipC",
+      };
+      const configVip = { params: { vcf: { filter: { classes: "a,c", consequences: true } } } } as ConfigVip;
+      const fieldVipCBase: FieldMetadataWrapper = {
+        id: "CSQ/VIPC",
+        type: "CATEGORICAL",
+        number: { type: "NUMBER", count: 1 },
+        categories: { a: { label: "a_label" }, b: { label: "b_label" }, c: { label: "c_label" } },
+        index: 0,
+      };
+
+      test("vipC", () => {
+        vi.mocked(getInfoNestedField).mockReturnValue(fieldVipCBase);
+
+        const filter = initConfigFilterComposed(configBase, configVip, metadata, null) as ConfigFilterVipC;
+        expect(filter.type).toStrictEqual("composed");
+        expect(filter.id).toStrictEqual("vipC");
+        expect(filter.field).toStrictEqual({
+          ...fieldVipCBase,
+          categories: { a: { label: "a_label" }, c: { label: "c_label" } },
+        });
+        expect(getInfoNestedField).toHaveBeenCalledWith(vcfMetadata, "CSQ", "VIPC");
+      });
+
+      test("vipC with field label and description", () => {
+        const fieldVipC: FieldMetadataWrapper = {
+          ...fieldVipCBase,
+          label: "field_label",
+          description: "field_description",
+        };
+        vi.mocked(getInfoNestedField).mockReturnValue(fieldVipC);
+
+        const filter = initConfigFilterComposed(configBase, configVip, metadata, null) as ConfigFilterVipC;
+        expect(filter.label()).toStrictEqual("field_label");
+        expect(filter.description()).toStrictEqual("field_description");
+      });
+
+      test("vipC with custom label and description", () => {
+        const config: ConfigJsonFilterComposed = {
+          ...configBase,
+          label: "my_label",
+          description: "my_description",
+        };
+
+        vi.mocked(getInfoNestedField).mockReturnValue(fieldVipCBase);
+
+        const filter = initConfigFilterComposed(config, configVip, metadata, null) as ConfigFilterVipC;
+        expect(filter.label()).toStrictEqual("my_label");
+        expect(filter.description()).toStrictEqual("my_description");
+      });
+
+      test("vipC is null when metadata absent", () => {
+        vi.mocked(getInfoNestedField).mockReturnValue(undefined);
+        expect(initConfigFilterComposed(configBase, configVip, metadata, null)).toStrictEqual(null);
+        expect(getInfoNestedField).toHaveBeenCalledWith(vcfMetadata, "CSQ", "VIPC");
+      });
+
+      test("vipC is null config consequences=false", () => {
+        vi.mocked(getInfoNestedField).mockReturnValue(fieldVipCBase);
+        const configVip = { params: { vcf: { filter: { classes: "a,c", consequences: false } } } } as ConfigVip;
+        const filter = initConfigFilterComposed(configBase, configVip, metadata, null) as ConfigFilterVipC;
+        expect(filter).toStrictEqual(null);
+      });
+
+      test("vipC is null when less than two categories", () => {
+        vi.mocked(getInfoNestedField).mockReturnValue(fieldVipCBase);
+        const configVip = { params: { vcf: { filter: { classes: "one", consequences: false } } } } as ConfigVip;
+        const filter = initConfigFilterComposed(configBase, configVip, metadata, null) as ConfigFilterVipC;
+        expect(filter).toStrictEqual(null);
+      });
+    });
+
+    describe("vipCS", () => {
+      const configBase: ConfigJsonFilterComposed = {
+        type: "composed",
+        name: "vipCS",
+      };
+      const configVip = { params: { vcf: { filter_samples: { classes: "a,c" } } } } as ConfigVip;
+      const fieldVipCSBase: FieldMetadataWrapper = {
+        id: "FORMAT/VIPC_S",
+        type: "CATEGORICAL",
+        number: { type: "NUMBER", count: 1 },
+        categories: { a: { label: "a_label" }, b: { label: "b_label" }, c: { label: "c_label" } },
+        required: true,
+        index: 0,
+      };
+      const sample = { item: { data: { proband: true } } } as SampleContainer;
+
+      test("vipCS", () => {
+        vi.mocked(getSampleField).mockReturnValue(fieldVipCSBase);
+
+        const filter = initConfigFilterComposed(configBase, configVip, metadata, sample) as ConfigFilterVipCS;
+        expect(filter.type).toStrictEqual("composed");
+        expect(filter.id).toStrictEqual("vipCS");
+        expect(filter.field).toStrictEqual({
+          ...fieldVipCSBase,
+          categories: { a: { label: "a_label" }, c: { label: "c_label" } },
+          required: true,
+        });
+        expect(filter.sample).toStrictEqual(sample);
+        expect(getSampleField).toHaveBeenCalledWith(vcfMetadata, "VIPC_S");
+      });
+
+      test("vipCS with field label and description", () => {
+        const fieldVipCS: FieldMetadataWrapper = {
+          ...fieldVipCSBase,
+          label: "field_label",
+          description: "field_description",
+        };
+        vi.mocked(getSampleField).mockReturnValue(fieldVipCS);
+
+        const filter = initConfigFilterComposed(configBase, configVip, metadata, sample) as ConfigFilterVipCS;
+        expect(filter.label()).toStrictEqual("field_label");
+        expect(filter.description()).toStrictEqual("field_description");
+      });
+
+      test("vipCS with custom label and description", () => {
+        const config: ConfigJsonFilterComposed = {
+          ...configBase,
+          label: "my_label",
+          description: "my_description",
+        };
+
+        vi.mocked(getSampleField).mockReturnValue(fieldVipCSBase);
+
+        const filter = initConfigFilterComposed(config, configVip, metadata, sample) as ConfigFilterVipCS;
+        expect(filter.label()).toStrictEqual("my_label");
+        expect(filter.description()).toStrictEqual("my_description");
+      });
+
+      test("vipCS is null when sample is null", () => {
+        expect(initConfigFilterComposed(configBase, configVip, metadata, null)).toStrictEqual(null);
+      });
+
+      test("vipCS is null when sample is not a proband", () => {
+        const sample = { item: { data: { proband: true } } } as SampleContainer;
+        expect(initConfigFilterComposed(configBase, configVip, metadata, sample)).toStrictEqual(null);
+      });
+
+      test("vipCS is null when metadata absent", () => {
+        vi.mocked(getSampleField).mockReturnValue(undefined);
+        expect(initConfigFilterComposed(configBase, configVip, metadata, sample)).toStrictEqual(null);
+        expect(getSampleField).toHaveBeenCalledWith(vcfMetadata, "VIPC_S");
+      });
+
+      test("vipCS is null when less than two categories", () => {
+        vi.mocked(getInfoNestedField).mockReturnValue(fieldVipCSBase);
+        const configVip = { params: { vcf: { filter: { classes: "one", consequences: false } } } } as ConfigVip;
+        const filter = initConfigFilterComposed(configBase, configVip, metadata, null) as ConfigFilterVipCS;
+        expect(filter).toStrictEqual(null);
+      });
+    });
+  });
+});

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

@@ -0,0 +1,140 @@
+import { afterEach, describe, expect, test, vi } from "vitest";
+import { SampleContainer, VcfMetadataContainer } from "../../../src/utils/api.ts";
+import { initConfigFiltersGenotype, initConfigFiltersInfo } from "../../../src/utils/config/configFiltersField.ts";
+import { FieldMetadataWrapper, getInfoFieldsRegex, getSampleFieldsRegex } from "../../../src/utils/vcf.ts";
+import { ConfigJsonFieldGenotype, ConfigJsonFieldInfo } from "../../../src/types/config";
+
+describe("config filters field", () => {
+  vi.mock(import("../../../src/utils/vcf.ts"));
+
+  afterEach(() => {
+    vi.resetAllMocks();
+  });
+
+  describe("initConfigFiltersInfo", () => {
+    const metadata = {} as VcfMetadataContainer;
+
+    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]);
+
+      const filters = initConfigFiltersInfo(config, metadata);
+      expect(filters.length).toStrictEqual(1);
+      const filter = filters[0]!;
+      expect(filter.type).toStrictEqual("info");
+      expect(filter.field).toStrictEqual(field);
+      expect(filter.label()).toStrictEqual("my_field_label");
+      expect(filter.description()).toStrictEqual("my_field_description");
+
+      expect(getInfoFieldsRegex).toHaveBeenCalledWith(metadata, /^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 filters = initConfigFiltersInfo(config, metadata);
+      expect(filters.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 filters = initConfigFiltersInfo(config, metadata);
+      expect(filters.length).toStrictEqual(0);
+      expect(getInfoFieldsRegex).toHaveBeenCalledWith(metadata, /^field_not_in_my_vcf$/);
+    });
+  });
+
+  describe("initConfigFiltersGenotype", () => {
+    const metadata = {} as VcfMetadataContainer;
+    const sample = { item: { id: 2 } } as SampleContainer;
+
+    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]);
+
+      const filters = initConfigFiltersGenotype(config, metadata, sample);
+      expect(filters.length).toStrictEqual(1);
+      const filter = filters[0]!;
+      expect(filter.type).toStrictEqual("genotype");
+      expect(filter.field).toStrictEqual(field);
+      expect(filter.label()).toStrictEqual("my_field_label");
+      expect(filter.description()).toStrictEqual("my_field_description");
+
+      expect(getSampleFieldsRegex).toHaveBeenCalledWith(metadata, /^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 filters = initConfigFiltersGenotype(config, metadata, sample);
+      expect(filters.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 filters = initConfigFiltersGenotype(config, metadata, sample);
+      expect(filters.length).toStrictEqual(0);
+      expect(getSampleFieldsRegex).toHaveBeenCalledWith(metadata, /^field_not_in_my_vcf$/);
+    });
+  });
+});