@molgenis/vip-report-template 6.2.0 → 7.0.0

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

@@ -0,0 +1,81 @@
+import { describe, expect, test } from "vitest";
+import { initConfigFilterFixed } from "../../../src/utils/config/configFiltersFixed.ts";
+
+describe("config filters fixed", () => {
+  describe("initConfigFilterFixed", () => {
+    test("chrom", () => {
+      const filter = initConfigFilterFixed({ type: "fixed", name: "chrom" });
+
+      expect(filter.type).toStrictEqual("fixed");
+      expect(filter.id).toStrictEqual("chrom");
+      expect(filter.label()).toStrictEqual("Chromosome");
+      expect(filter.description()).toStrictEqual(null);
+    });
+
+    test("pos", () => {
+      const filter = initConfigFilterFixed({ type: "fixed", name: "pos" });
+
+      expect(filter.type).toStrictEqual("fixed");
+      expect(filter.id).toStrictEqual("pos");
+      expect(filter.label()).toStrictEqual("Position");
+      expect(filter.description()).toStrictEqual(null);
+    });
+
+    test("id", () => {
+      const filter = initConfigFilterFixed({ type: "fixed", name: "id" });
+
+      expect(filter.type).toStrictEqual("fixed");
+      expect(filter.id).toStrictEqual("id");
+      expect(filter.label()).toStrictEqual("Identifiers");
+      expect(filter.description()).toStrictEqual(null);
+    });
+
+    test("ref", () => {
+      const filter = initConfigFilterFixed({ type: "fixed", name: "ref" });
+
+      expect(filter.type).toStrictEqual("fixed");
+      expect(filter.id).toStrictEqual("ref");
+      expect(filter.label()).toStrictEqual("Reference");
+      expect(filter.description()).toStrictEqual(null);
+    });
+
+    test("alt", () => {
+      const filter = initConfigFilterFixed({ type: "fixed", name: "alt" });
+
+      expect(filter.type).toStrictEqual("fixed");
+      expect(filter.id).toStrictEqual("alt");
+      expect(filter.label()).toStrictEqual("Alt");
+      expect(filter.description()).toStrictEqual(null);
+    });
+
+    test("qual", () => {
+      const filter = initConfigFilterFixed({ type: "fixed", name: "qual" });
+
+      expect(filter.type).toStrictEqual("fixed");
+      expect(filter.id).toStrictEqual("qual");
+      expect(filter.label()).toStrictEqual("Quality");
+      expect(filter.description()).toStrictEqual(null);
+    });
+
+    test("filter", () => {
+      const filter = initConfigFilterFixed({ type: "fixed", name: "filter" });
+
+      expect(filter.type).toStrictEqual("fixed");
+      expect(filter.id).toStrictEqual("filter");
+      expect(filter.label()).toStrictEqual("Filter");
+      expect(filter.description()).toStrictEqual(null);
+    });
+
+    test("filter with custom label and description", () => {
+      const filter = initConfigFilterFixed({
+        type: "fixed",
+        name: "chrom",
+        label: "custom_label",
+        description: "custom_description",
+      });
+
+      expect(filter.label()).toStrictEqual("custom_label");
+      expect(filter.description()).toStrictEqual("custom_description");
+    });
+  });
+});

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

@@ -0,0 +1,55 @@
+import { MetadataContainer, VcfMetadataContainer } from "../../../src/utils/api.ts";
+import { afterEach, describe, expect, test, vi } from "vitest";
+import { ConfigJsonSort } from "../../../src/types/config";
+import { initConfigSorts } from "../../../src/utils/config/configSorts.ts";
+import { FieldMetadataWrapper, getInfoField } from "../../../src/utils/vcf.ts";
+
+describe("initConfigSorts", () => {
+  vi.mock(import("../../../src/utils/vcf.ts"));
+
+  afterEach(() => {
+    vi.resetAllMocks();
+  });
+
+  const vcfMetadata = {};
+  const metadata: Partial<MetadataContainer> = { records: vcfMetadata as VcfMetadataContainer };
+
+  test("regular sorts config", () => {
+    const fieldMetadata = { id: "f" } as FieldMetadataWrapper;
+    const config: ConfigJsonSort[] = [
+      {
+        selected: true,
+        orders: [{ direction: "desc", field: { type: "info", name: "f" } }],
+      },
+    ];
+    vi.mocked(getInfoField).mockReturnValue(fieldMetadata);
+
+    expect(initConfigSorts(config, metadata as MetadataContainer)).toStrictEqual([
+      {
+        orders: [
+          {
+            direction: "desc",
+            field: {
+              id: "f",
+            },
+          },
+        ],
+        selected: true,
+      },
+    ]);
+    expect(getInfoField).toHaveBeenCalledWith(vcfMetadata, "f");
+  });
+
+  test("undefined sort field", () => {
+    const config: ConfigJsonSort[] = [
+      {
+        selected: true,
+        orders: [{ direction: "desc", field: { type: "info", name: "f_unknown" } }],
+      },
+    ];
+    vi.mocked(getInfoField).mockReturnValue(undefined);
+
+    expect(initConfigSorts(config, metadata as MetadataContainer)).toStrictEqual([]);
+    expect(getInfoField).toHaveBeenCalledWith(vcfMetadata, "f_unknown");
+  });
+});

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

@@ -0,0 +1,56 @@
+import { describe, expect, test } from "vitest";
+import { validateConfig } from "../../../src/utils/config/configValidator.ts";
+
+describe("config parser", () => {
+  const configBase = {
+    sample_variants: { cells: {} },
+    variants: { cells: {} },
+    sample_variant: { cells: {} },
+    variant: { cells: {} },
+    sample_variant_consequence: { sample_cells: {} },
+    variant_consequence: {},
+  };
+
+  describe("parseConfig", () => {
+    test("valid", () => {
+      const config = {
+        ...configBase,
+        vip: {
+          filter_field: { type: "genotype", name: "f" },
+          params: { vcf: { filter: { classes: "c0,c1", consequences: true }, filter_samples: { classes: "cs0,cs1" } } },
+        },
+      };
+      expect(validateConfig(config)).toStrictEqual(config);
+    });
+
+    test("valid with additional vip.params properties", () => {
+      const config = {
+        ...configBase,
+        vip: {
+          filter_field: { type: "genotype", name: "f" },
+          params: {
+            vcf: {
+              filter: { classes: "c0,c1", consequences: true, new_prop: true },
+              filter_samples: { classes: "cs0,cs1", new_prop: true },
+            },
+            new_prop: true,
+          },
+        },
+      };
+      expect(validateConfig(config)).toStrictEqual(config);
+    });
+
+    test("invalid", () => {
+      const config = {};
+
+      // suppress logging
+      const old = console.error;
+      console.error = () => {};
+      try {
+        expect(() => validateConfig(config)).toThrow(/^config invalid$/);
+      } finally {
+        console.error = old;
+      }
+    });
+  });
+});

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

@@ -0,0 +1,53 @@
+import { afterEach, describe, expect, test, vi } from "vitest";
+import { initConfigVip } from "../../../src/utils/config/configVip.ts";
+import { ConfigJsonVip, ConfigJsonVipParams } from "../../../src/types/config";
+import { MetadataContainer, VcfMetadataContainer } from "../../../src/utils/api.ts";
+import { FieldMetadataWrapper, getSampleField } from "../../../src/utils/vcf.ts";
+
+describe("config vip", () => {
+  vi.mock(import("../../../src/utils/vcf.ts"));
+
+  afterEach(() => {
+    vi.resetAllMocks();
+  });
+
+  describe("initConfigVip", () => {
+    const vcfMetadata = {};
+    const metadata: Partial<MetadataContainer> = { records: vcfMetadata as VcfMetadataContainer };
+    const params = { vcf: {} } as ConfigJsonVipParams;
+    const config: ConfigJsonVip = {
+      filter_field: { type: "genotype", name: "f" },
+      params,
+    };
+
+    test("init", () => {
+      const fieldMetadata = { id: "f", type: "CATEGORICAL" } as FieldMetadataWrapper;
+      vi.mocked(getSampleField).mockReturnValue(fieldMetadata);
+
+      expect(initConfigVip(config, metadata as MetadataContainer)).toStrictEqual({
+        filter_field: fieldMetadata,
+        params,
+      });
+      expect(getSampleField).toHaveBeenCalledWith(vcfMetadata, "f");
+    });
+
+    test("init metadata invalid", () => {
+      const fieldMetadata = { id: "f", type: "INTEGER" } as FieldMetadataWrapper;
+      vi.mocked(getSampleField).mockReturnValue(fieldMetadata);
+
+      expect(() => initConfigVip(config, metadata as MetadataContainer)).toThrowError(
+        /^config invalid: property 'vip.filter_field.name' value 'f' is of type INTEGER instead of CATEGORICAL$/,
+      );
+      expect(getSampleField).toHaveBeenCalledWith(vcfMetadata, "f");
+    });
+
+    test("init metadata unavailable", () => {
+      vi.mocked(getSampleField).mockReturnValue(undefined);
+
+      expect(() => initConfigVip(config, metadata as MetadataContainer)).toThrowError(
+        /^config invalid: property 'vip.filter_field.name' value 'f' does not exist in vcf metadata$/,
+      );
+      expect(getSampleField).toHaveBeenCalledWith(vcfMetadata, "f");
+    });
+  });
+});

package/tests/utils/decisionTree.test.ts

@@ -0,0 +1,71 @@
+import { afterEach, describe, expect, test, vi } from "vitest";
+import { getDecisionTreePath, getSampleTreePath } from "../../src/utils/decisionTree.ts";
+import { Item } from "@molgenis/vip-report-api";
+import { VcfRecord } from "@molgenis/vip-report-vcf";
+import { SampleContainer, VcfMetadataContainer } from "../../src/utils/api.ts";
+import {
+  FieldMetadataWrapper,
+  getInfoNestedField,
+  getInfoValue,
+  getSampleField,
+  getSampleValue,
+} from "../../src/utils/vcf.ts";
+
+describe("decision tree", () => {
+  vi.mock(import("../../src/utils/vcf.ts"));
+
+  afterEach(() => {
+    vi.resetAllMocks();
+  });
+
+  const vcfMetadata = {} as VcfMetadataContainer;
+  const record: Item<VcfRecord> = {
+    data: {
+      c: "chr1",
+      p: 123,
+    },
+  } as Partial<Item<Partial<VcfRecord>>> as Item<VcfRecord>;
+
+  describe("getDecisionTreePath", () => {
+    test("get", () => {
+      const fieldMetadata = {
+        id: "VIPP",
+        parent: { id: "CSQ" },
+      } as FieldMetadataWrapper;
+
+      vi.mocked(getInfoNestedField).mockReturnValue(fieldMetadata);
+      vi.mocked(getInfoValue).mockReturnValue("a&b&c");
+      expect(getDecisionTreePath(vcfMetadata, record, 2)).toStrictEqual("a&b&c");
+      expect(getInfoNestedField).toHaveBeenCalledWith(vcfMetadata, "CSQ", "VIPP");
+      expect(getInfoValue).toHaveBeenCalledWith(record, 2, fieldMetadata);
+    });
+
+    test("get, no metadata", () => {
+      vi.mocked(getInfoNestedField).mockReturnValue(undefined);
+      expect(getDecisionTreePath(vcfMetadata, record, 2)).toStrictEqual([]);
+      expect(getInfoNestedField).toHaveBeenCalledWith(vcfMetadata, "CSQ", "VIPP");
+    });
+  });
+
+  describe("getSampleTreePath", () => {
+    const sample = { item: { id: 0 } } as SampleContainer;
+
+    test("get", () => {
+      const fieldMetadata = {
+        id: "VIPP_S",
+      } as FieldMetadataWrapper;
+
+      vi.mocked(getSampleField).mockReturnValue(fieldMetadata);
+      vi.mocked(getSampleValue).mockReturnValue(["a&b&c", "d&e&f"]);
+      expect(getSampleTreePath(vcfMetadata, sample, record, 1)).toStrictEqual(["d", "e", "f"]);
+      expect(getSampleField).toHaveBeenCalledWith(vcfMetadata, "VIPP_S");
+      expect(getSampleValue).toHaveBeenCalledWith(sample, record, -1, fieldMetadata);
+    });
+
+    test("get, no metadata", () => {
+      vi.mocked(getSampleField).mockReturnValue(undefined);
+      expect(getSampleTreePath(vcfMetadata, sample, record, 1)).toStrictEqual([]);
+      expect(getSampleField).toHaveBeenCalledWith(vcfMetadata, "VIPP_S");
+    });
+  });
+});

package/tests/utils/download.test.ts

@@ -0,0 +1,20 @@
+import { describe, expect, test } from "vitest";
+import { HtsFileMetadata } from "@molgenis/vip-report-api";
+import { createVcfDownloadFilename } from "../../src/utils/download.ts";
+
+describe("download", () => {
+  test("createVcfDownloadFilename with path", () => {
+    const metadata = { uri: "/x/y/my.vcf" } as HtsFileMetadata;
+    expect(createVcfDownloadFilename(metadata)).toMatch(/^my_report_.*.vcf$/);
+  });
+
+  test("createVcfDownloadFilename without path", () => {
+    const metadata = { uri: "my.vcf" } as HtsFileMetadata;
+    expect(createVcfDownloadFilename(metadata)).toMatch(/^my_report_.*.vcf$/);
+  });
+
+  test("createVcfDownloadFilename unknown ", () => {
+    const metadata = { uri: "" } as HtsFileMetadata;
+    expect(createVcfDownloadFilename(metadata)).toMatch(/^unknown_report_.*.vcf$/);
+  });
+});

package/tests/utils/query/query.test.ts

@@ -0,0 +1,84 @@
+import { afterEach, describe, expect, test, vi } from "vitest";
+import { FieldMetadata } from "@molgenis/vip-report-vcf";
+
+import { createInfoSortPath } from "../../../src/utils/query/selector.ts";
+import { createQuery } from "../../../src/utils/query/query.ts";
+import { createQueryVariantType } from "../../../src/utils/query/queryVariantType.ts";
+import { createQuerySample } from "../../../src/utils/query/querySample.ts";
+import { createQueryFilters } from "../../../src/utils/query/queryFilter.ts";
+import { Query } from "@molgenis/vip-report-api";
+import { Config, ConfigFilters, ConfigVariants, ConfigVip, ConfigVipParams } from "../../../src/types/config";
+import { SampleContainer } from "../../../src/utils/api.ts";
+import { VariantType } from "../../../src/utils/variantType.ts";
+import { ConfigFilterFixed } from "../../../src/types/configFilter";
+
+describe("query", () => {
+  vi.mock(import("../../../src/utils/query/queryFilter.ts"));
+  vi.mock(import("../../../src/utils/query/queryVariantType.ts"));
+  vi.mock(import("../../../src/utils/query/querySample.ts"));
+
+  afterEach(() => {
+    vi.resetAllMocks();
+  });
+
+  describe("createQuery", () => {
+    const configFilters: ConfigFilters = [{ type: "fixed", id: "chrom" } as ConfigFilterFixed];
+    const configVip = { params: {} as ConfigVipParams } as ConfigVip;
+    const config: Config = { vip: configVip, variants: { filters: configFilters } as ConfigVariants } as Config;
+    const variantType = { id: "snv" } as VariantType;
+    const sample = { item: { id: 2 } } as SampleContainer;
+    const filterValues = { chrom: ["chr1"] };
+
+    test("variant type, sample and filters", () => {
+      const queryVariantType: Query = { selector: "a", operator: "==", args: "b" };
+      const querySample: Query = { selector: "c", operator: "==", args: "d" };
+      const queryFilters: Query = { selector: "e", operator: "==", args: "f" };
+      vi.mocked(createQueryVariantType).mockReturnValue(queryVariantType);
+      vi.mocked(createQuerySample).mockReturnValue(querySample);
+      vi.mocked(createQueryFilters).mockReturnValue(queryFilters);
+
+      expect(createQuery(config, variantType, sample, filterValues)).toStrictEqual({
+        args: [
+          { selector: "a", operator: "==", args: "b" },
+          { selector: "c", operator: "==", args: "d" },
+          { selector: "e", operator: "==", args: "f" },
+        ],
+        operator: "and",
+      });
+      expect(createQueryVariantType).toHaveBeenCalledWith(variantType);
+      expect(createQuerySample).toHaveBeenCalledWith(configVip, sample);
+      expect(createQueryFilters).toHaveBeenCalledWith(configFilters, filterValues);
+    });
+
+    test("sample", () => {
+      const querySample: Query = { selector: "c", operator: "==", args: "d" };
+      vi.mocked(createQueryVariantType).mockReturnValue(null);
+      vi.mocked(createQuerySample).mockReturnValue(querySample);
+      vi.mocked(createQueryFilters).mockReturnValue(null);
+
+      expect(createQuery(config, variantType, sample, filterValues)).toStrictEqual(querySample);
+      expect(createQueryVariantType).toHaveBeenCalledWith(variantType);
+      expect(createQuerySample).toHaveBeenCalledWith(configVip, sample);
+      expect(createQueryFilters).toHaveBeenCalledWith(configFilters, filterValues);
+    });
+
+    test("variant type=null, sample=null and filters=null", () => {
+      const variantType = { id: "all" } as VariantType;
+      vi.mocked(createQueryVariantType).mockReturnValue(null);
+      vi.mocked(createQueryFilters).mockReturnValue(null);
+
+      expect(createQuery(config, variantType, null, filterValues)).toStrictEqual(null);
+      expect(createQueryVariantType).toHaveBeenCalledWith(variantType);
+      expect(createQueryFilters).toHaveBeenCalledWith(configFilters, filterValues);
+    });
+  });
+
+  test("infoSortPath", () => {
+    const fieldMetaCsq: FieldMetadata = {
+      id: "CSQ",
+      number: { type: "NUMBER" },
+      type: "STRING",
+    };
+    expect(createInfoSortPath(fieldMetaCsq)).toStrictEqual(["n", "CSQ"]);
+  });
+});

package/tests/utils/query/queryFilter.test.ts

@@ -0,0 +1,243 @@
+import { afterEach, describe, expect, test, vi } from "vitest";
+import {
+  createQueryFilterClosedInterval,
+  createQueryFilterClosedIntervalOutside,
+  createQueryFilters,
+  createQueryFilterString,
+} from "../../../src/utils/query/queryFilter.ts";
+import { Query, Selector } from "@molgenis/vip-report-api";
+import { createQueryFilterComposed } from "../../../src/utils/query/queryFilterComposed.ts";
+import { ConfigFilterComposed } from "../../../src/types/configFilterComposed";
+import {
+  ConfigFilterField,
+  ConfigFilterFixed,
+  ConfigFilterFormat,
+  FilterValueString,
+} from "../../../src/types/configFilter";
+import { createQueryFilterFixed } from "../../../src/utils/query/queryFilterFixed.ts";
+import { createQueryFilterField } from "../../../src/utils/query/queryFilterField.ts";
+
+describe("query filters", () => {
+  vi.mock(import("../../../src/utils/query/queryFilterComposed.ts"));
+  vi.mock(import("../../../src/utils/query/queryFilterField.ts"));
+  vi.mock(import("../../../src/utils/query/queryFilterFixed.ts"));
+
+  afterEach(() => {
+    vi.resetAllMocks();
+  });
+
+  describe("createQueryFilters", () => {
+    const query: Query = { selector: "x", operator: "==", args: "y" };
+
+    test("composed", () => {
+      const config0 = { type: "composed", id: "c0" } as ConfigFilterComposed;
+      const config1 = { type: "composed", id: "c1" } as ConfigFilterComposed;
+      const value0 = ["my_value"];
+      const filterValues = { c0: value0 };
+      vi.mocked(createQueryFilterComposed).mockReturnValue(query);
+      expect(createQueryFilters([config0, config1], filterValues)).toStrictEqual(query);
+      expect(createQueryFilterComposed).toHaveBeenCalledWith(config0, value0);
+    });
+
+    test("fixed", () => {
+      const config = { type: "fixed", id: "chrom" } as ConfigFilterFixed;
+      const value = ["chr1"];
+      const filterValues = { chrom: value };
+      vi.mocked(createQueryFilterFixed).mockReturnValue(query);
+      expect(createQueryFilters([config], filterValues)).toStrictEqual(query);
+      expect(createQueryFilterFixed).toHaveBeenCalledWith(config, value);
+    });
+
+    test("genotype", () => {
+      const config = { type: "genotype", id: "f" } as ConfigFilterFormat;
+      const value = ["x"];
+      const filterValues = { f: value };
+      vi.mocked(createQueryFilterField).mockReturnValue(query);
+      expect(createQueryFilters([config], filterValues)).toStrictEqual(query);
+      expect(createQueryFilterField).toHaveBeenCalledWith(config, value);
+    });
+
+    test("info", () => {
+      const config = { type: "info", id: "f" } as ConfigFilterField;
+      const value = ["x"];
+      const filterValues = { f: value };
+      vi.mocked(createQueryFilterField).mockReturnValue(query);
+      expect(createQueryFilters([config], filterValues)).toStrictEqual(query);
+      expect(createQueryFilterField).toHaveBeenCalledWith(config, value);
+    });
+
+    test("mixed", () => {
+      const query0: Query = query;
+      const query1: Query = { selector: "y", operator: "==", args: "z" };
+
+      const config0 = { type: "composed", id: "c0" } as ConfigFilterComposed;
+      const config1 = { type: "fixed", id: "chrom" } as ConfigFilterComposed;
+      const value0 = ["my_value"];
+      const value1 = ["chr1"];
+      const filterValues = { c0: value0, chrom: value1 };
+      vi.mocked(createQueryFilterComposed).mockReturnValue(query0);
+      vi.mocked(createQueryFilterFixed).mockReturnValue(query1);
+      expect(createQueryFilters([config0, config1], filterValues)).toStrictEqual({
+        args: [query0, query1],
+        operator: "and",
+      });
+      expect(createQueryFilterComposed).toHaveBeenCalledWith(config0, value0);
+      expect(createQueryFilterFixed).toHaveBeenCalledWith(config1, value1);
+    });
+
+    test("return null", () => {
+      const config0 = { type: "composed", id: "c0" } as ConfigFilterComposed;
+      const filterValues = {};
+      expect(createQueryFilters([config0], filterValues)).toStrictEqual(null);
+    });
+  });
+
+  describe("createQueryFilterClosedInterval", () => {
+    const selector: Selector = ["x"];
+
+    test("left", () => {
+      expect(createQueryFilterClosedInterval(selector, { left: 1, right: undefined })).toStrictEqual({
+        selector: ["x"],
+        operator: ">=",
+        args: 1,
+      });
+    });
+
+    test("right", () => {
+      expect(createQueryFilterClosedInterval(selector, { left: undefined, right: 2 })).toStrictEqual({
+        selector: ["x"],
+        operator: "<=",
+        args: 2,
+      });
+    });
+
+    test("left and right", () => {
+      expect(createQueryFilterClosedInterval(selector, { left: 1, right: 2 })).toStrictEqual({
+        args: [
+          { selector: ["x"], operator: ">=", args: 1 },
+          { selector: ["x"], operator: "<=", args: 2 },
+        ],
+        operator: "and",
+      });
+    });
+
+    test("left=undefined and right=undefined", () => {
+      expect(() =>
+        createQueryFilterClosedInterval(selector, {
+          left: undefined,
+          right: undefined,
+        }),
+      ).toThrow();
+    });
+  });
+
+  describe("createQueryFilterClosedIntervalOutside", () => {
+    const selector: Selector = ["x"];
+
+    test("left", () => {
+      expect(createQueryFilterClosedIntervalOutside(selector, { left: 1, right: undefined })).toStrictEqual({
+        selector: ["x"],
+        operator: "<",
+        args: 1,
+      });
+    });
+
+    test("right", () => {
+      expect(createQueryFilterClosedIntervalOutside(selector, { left: undefined, right: 2 })).toStrictEqual({
+        selector: ["x"],
+        operator: ">",
+        args: 2,
+      });
+    });
+
+    test("left and right", () => {
+      expect(createQueryFilterClosedIntervalOutside(selector, { left: 1, right: 2 })).toStrictEqual({
+        args: [
+          { selector: ["x"], operator: "<", args: 1 },
+          { selector: ["x"], operator: ">", args: 2 },
+        ],
+        operator: "or",
+      });
+    });
+
+    test("left=undefined and right=undefined", () => {
+      expect(() =>
+        createQueryFilterClosedIntervalOutside(selector, {
+          left: undefined,
+          right: undefined,
+        }),
+      ).toThrow();
+    });
+  });
+
+  describe("createQueryFilterString", () => {
+    const selector: Selector = ["x"];
+
+    test("multi_value=false nested_value=false args=single", () => {
+      const value: FilterValueString = ["y"];
+      expect(createQueryFilterString(selector, value, false, false)).toStrictEqual({
+        selector: ["x"],
+        operator: "in",
+        args: ["y"],
+      });
+    });
+
+    test("multi_value=false nested_value=false args=multi", () => {
+      const value: FilterValueString = ["y", "z"];
+      expect(createQueryFilterString(selector, value, false, false)).toStrictEqual({
+        selector: ["x"],
+        operator: "in",
+        args: ["y", "z"],
+      });
+    });
+
+    test("multi_value=true nested_value=false args=single", () => {
+      const value: FilterValueString = ["y"];
+      expect(createQueryFilterString(selector, value, true, false)).toStrictEqual({
+        selector: ["x"],
+        operator: "has_any",
+        args: ["y"],
+      });
+    });
+
+    test("multi_value=false nested_value=true args=single", () => {
+      const value: FilterValueString = ["y"];
+      expect(createQueryFilterString(selector, value, false, true)).toStrictEqual({
+        selector: ["x"],
+        operator: "has_any",
+        args: ["y"],
+      });
+    });
+
+    test("multi_value=true nested_value=true args=single", () => {
+      const value: FilterValueString = ["y"];
+      expect(createQueryFilterString(selector, value, true, true)).toStrictEqual({
+        selector: ["x"],
+        operator: "any_has_any",
+        args: ["y"],
+      });
+    });
+
+    describe("categorical select null", () => {
+      test("categorical __null", () => {
+        const value: FilterValueString = ["__null"];
+
+        expect(createQueryFilterString(selector, value, false, false)).toStrictEqual({
+          selector: ["x"],
+          operator: "in",
+          args: [null],
+        });
+      });
+
+      test("categorical category and __null", () => {
+        const value: FilterValueString = ["c0", "__null"];
+
+        expect(createQueryFilterString(selector, value, false, false)).toStrictEqual({
+          selector: ["x"],
+          operator: "in",
+          args: ["c0", null],
+        });
+      });
+    });
+  });
+});