@oneuptime/common 12.0.25 → 12.0.27

package/Tests/Types/Monitor/TemplateGroupByKeys.test.ts

@@ -0,0 +1,296 @@
+import {
+  DockerAlertTemplate,
+  DockerAlertTemplateArgs,
+  getAllDockerAlertTemplates,
+} from "../../../Types/Monitor/DockerAlertTemplates";
+import {
+  HostAlertTemplate,
+  HostAlertTemplateArgs,
+  getAllHostAlertTemplates,
+} from "../../../Types/Monitor/HostAlertTemplates";
+import {
+  PodmanAlertTemplate,
+  PodmanAlertTemplateArgs,
+  getAllPodmanAlertTemplates,
+} from "../../../Types/Monitor/PodmanAlertTemplates";
+import MonitorStep from "../../../Types/Monitor/MonitorStep";
+import ObjectID from "../../../Types/ObjectID";
+
+/*
+ * Guard: a shipped template must never silently lose (or silently gain) its
+ * per-series group-by.
+ *
+ * `MonitorStep.getGroupByAttributeKeys` is the single source of truth for "is
+ * this monitor grouped?" — the telemetry worker uses it to build the
+ * per-series breakdown and the criteria evaluator uses it to decide whether a
+ * criteria fans out one alert/incident per series. An ungrouped template over
+ * a fleet raises ONE alert for the whole fleet: the first container/mount to
+ * breach opens an incident whose dedupe key carries no series, and every other
+ * container/mount that breaches afterwards is silenced for as long as that
+ * incident stays open. That is the exact bug this table exists to prevent from
+ * coming back.
+ *
+ * The decision recorded per template:
+ *
+ *   - Docker / Podman: EVERY template groups by `resource.container.name`.
+ *     Both agents stamp container identity as OTLP RESOURCE attributes, so
+ *     ClickHouse stores them `resource.`-prefixed — the same key the worker
+ *     uses for `containerFilters.containerName`
+ *     (App/FeatureSet/Workers/Jobs/TelemetryMonitor/MonitorTelemetryMonitor.ts)
+ *     and the same key the Docker/Podman dashboards query by
+ *     (`CONTAINER_NAME_ATTR` in App/FeatureSet/Dashboard/src/Pages/{Docker,
+ *     Podman}/View/Overview.tsx). NOTE this differs from Docker Swarm, whose
+ *     docker_stats receiver keeps container identity in DATAPOINT labels
+ *     (plain `container.name`).
+ *
+ *   - Host: a host monitor is already scoped to ONE host (the worker injects
+ *     `resource.host.name` from hostIdentifier), so host-scalar metrics — CPU
+ *     utilization, memory utilization, load average, process count — stay
+ *     UNGROUPED: there is exactly one series per host and grouping buys
+ *     nothing. Filesystem utilization is per-mountpoint, so it groups by the
+ *     unprefixed `mountpoint` datapoint label the hostmetrics receiver sets
+ *     (read the same way in App/FeatureSet/Dashboard/src/Pages/Host/View/
+ *     Overview.tsx). Host templates for per-device disk I/O or network
+ *     interfaces do not exist yet; when one is added it groups by `device`.
+ *
+ * Each table is exhaustive both ways — a new template with no row here fails
+ * loudly, which forces the group-by decision to be made deliberately.
+ */
+
+interface GroupByExpectation {
+  id: string;
+  // The exact group-by keys, or [] for a deliberately ungrouped template.
+  groupByAttributeKeys: Array<string>;
+}
+
+const CONTAINER_NAME_ATTRIBUTE: string = "resource.container.name";
+
+const EXPECTED_DOCKER_GROUP_BY: Array<GroupByExpectation> = [
+  { id: "docker-high-cpu", groupByAttributeKeys: [CONTAINER_NAME_ATTRIBUTE] },
+  {
+    id: "docker-high-memory",
+    groupByAttributeKeys: [CONTAINER_NAME_ATTRIBUTE],
+  },
+  {
+    id: "docker-restart-loop",
+    groupByAttributeKeys: [CONTAINER_NAME_ATTRIBUTE],
+  },
+  {
+    id: "docker-cpu-throttling",
+    groupByAttributeKeys: [CONTAINER_NAME_ATTRIBUTE],
+  },
+  { id: "docker-high-pids", groupByAttributeKeys: [CONTAINER_NAME_ATTRIBUTE] },
+  {
+    id: "docker-container-down",
+    groupByAttributeKeys: [CONTAINER_NAME_ATTRIBUTE],
+  },
+];
+
+const EXPECTED_PODMAN_GROUP_BY: Array<GroupByExpectation> = [
+  { id: "podman-high-cpu", groupByAttributeKeys: [CONTAINER_NAME_ATTRIBUTE] },
+  {
+    id: "podman-high-memory",
+    groupByAttributeKeys: [CONTAINER_NAME_ATTRIBUTE],
+  },
+  {
+    id: "podman-restart-loop",
+    groupByAttributeKeys: [CONTAINER_NAME_ATTRIBUTE],
+  },
+  {
+    id: "podman-cpu-throttling",
+    groupByAttributeKeys: [CONTAINER_NAME_ATTRIBUTE],
+  },
+  { id: "podman-high-pids", groupByAttributeKeys: [CONTAINER_NAME_ATTRIBUTE] },
+  {
+    id: "podman-container-down",
+    groupByAttributeKeys: [CONTAINER_NAME_ATTRIBUTE],
+  },
+];
+
+const EXPECTED_HOST_GROUP_BY: Array<GroupByExpectation> = [
+  // Host-scalar: one series per host, nothing to fan out over.
+  { id: "host-high-cpu", groupByAttributeKeys: [] },
+  { id: "host-high-memory", groupByAttributeKeys: [] },
+  { id: "host-high-load-average", groupByAttributeKeys: [] },
+  { id: "host-high-processes", groupByAttributeKeys: [] },
+  // Per-entity within the host: one series (and one incident) per mount.
+  { id: "host-high-filesystem", groupByAttributeKeys: ["mountpoint"] },
+];
+
+function buildDockerArgs(): DockerAlertTemplateArgs {
+  return {
+    hostIdentifier: "host-01",
+    onlineMonitorStatusId: ObjectID.generate(),
+    offlineMonitorStatusId: ObjectID.generate(),
+    defaultIncidentSeverityId: ObjectID.generate(),
+    defaultAlertSeverityId: ObjectID.generate(),
+    monitorName: "Test Monitor",
+  };
+}
+
+function buildPodmanArgs(): PodmanAlertTemplateArgs {
+  return buildDockerArgs();
+}
+
+function buildHostArgs(): HostAlertTemplateArgs {
+  return buildDockerArgs();
+}
+
+function idsOf(expectations: Array<GroupByExpectation>): Array<string> {
+  return expectations
+    .map((expectation: GroupByExpectation) => {
+      return expectation.id;
+    })
+    .sort();
+}
+
+function expectationFor(
+  expectations: Array<GroupByExpectation>,
+  id: string,
+): GroupByExpectation {
+  const expectation: GroupByExpectation | undefined = expectations.find(
+    (candidate: GroupByExpectation) => {
+      return candidate.id === id;
+    },
+  );
+
+  if (!expectation) {
+    throw new Error(
+      `No group-by expectation for template "${id}". Add a row to this table and decide, deliberately, whether the template is per-series.`,
+    );
+  }
+
+  return expectation;
+}
+
+const DOCKER_TEMPLATES: Array<DockerAlertTemplate> =
+  getAllDockerAlertTemplates();
+const PODMAN_TEMPLATES: Array<PodmanAlertTemplate> =
+  getAllPodmanAlertTemplates();
+const HOST_TEMPLATES: Array<HostAlertTemplate> = getAllHostAlertTemplates();
+
+describe("Alert template group-by keys", () => {
+  describe("DockerAlertTemplates", () => {
+    test("every template has a group-by expectation (exhaustive both ways)", () => {
+      expect(
+        DOCKER_TEMPLATES.map((template: DockerAlertTemplate) => {
+          return template.id;
+        }).sort(),
+      ).toEqual(idsOf(EXPECTED_DOCKER_GROUP_BY));
+    });
+
+    test.each(
+      DOCKER_TEMPLATES.map((template: DockerAlertTemplate) => {
+        return [template.id, template];
+      }),
+    )(
+      "%s groups by the expected attribute keys",
+      (id: unknown, template: unknown) => {
+        const step: MonitorStep = (
+          template as DockerAlertTemplate
+        ).getMonitorStep(buildDockerArgs());
+
+        expect(MonitorStep.getGroupByAttributeKeys(step)).toEqual(
+          expectationFor(EXPECTED_DOCKER_GROUP_BY, id as string)
+            .groupByAttributeKeys,
+        );
+      },
+    );
+  });
+
+  describe("PodmanAlertTemplates", () => {
+    test("every template has a group-by expectation (exhaustive both ways)", () => {
+      expect(
+        PODMAN_TEMPLATES.map((template: PodmanAlertTemplate) => {
+          return template.id;
+        }).sort(),
+      ).toEqual(idsOf(EXPECTED_PODMAN_GROUP_BY));
+    });
+
+    test.each(
+      PODMAN_TEMPLATES.map((template: PodmanAlertTemplate) => {
+        return [template.id, template];
+      }),
+    )(
+      "%s groups by the expected attribute keys",
+      (id: unknown, template: unknown) => {
+        const step: MonitorStep = (
+          template as PodmanAlertTemplate
+        ).getMonitorStep(buildPodmanArgs());
+
+        expect(MonitorStep.getGroupByAttributeKeys(step)).toEqual(
+          expectationFor(EXPECTED_PODMAN_GROUP_BY, id as string)
+            .groupByAttributeKeys,
+        );
+      },
+    );
+  });
+
+  describe("HostAlertTemplates", () => {
+    test("every template has a group-by expectation (exhaustive both ways)", () => {
+      expect(
+        HOST_TEMPLATES.map((template: HostAlertTemplate) => {
+          return template.id;
+        }).sort(),
+      ).toEqual(idsOf(EXPECTED_HOST_GROUP_BY));
+    });
+
+    test.each(
+      HOST_TEMPLATES.map((template: HostAlertTemplate) => {
+        return [template.id, template];
+      }),
+    )(
+      "%s groups by the expected attribute keys",
+      (id: unknown, template: unknown) => {
+        const step: MonitorStep = (
+          template as HostAlertTemplate
+        ).getMonitorStep(buildHostArgs());
+
+        expect(MonitorStep.getGroupByAttributeKeys(step)).toEqual(
+          expectationFor(EXPECTED_HOST_GROUP_BY, id as string)
+            .groupByAttributeKeys,
+        );
+      },
+    );
+  });
+
+  /*
+   * The fleet templates are the whole point of the fix: a container monitor
+   * covers every container on the host and a filesystem monitor covers every
+   * mount, so both MUST be grouped. Asserted separately from the tables so a
+   * bulk edit that blanks every expectation still fails.
+   */
+  test("every Docker and Podman template is grouped, and by a resource-prefixed key", () => {
+    const containerTemplates: Array<DockerAlertTemplate | PodmanAlertTemplate> =
+      [...DOCKER_TEMPLATES, ...PODMAN_TEMPLATES];
+
+    expect(containerTemplates.length).toBeGreaterThan(0);
+
+    for (const template of containerTemplates) {
+      const step: MonitorStep = template.getMonitorStep(buildDockerArgs());
+      const keys: Array<string> = MonitorStep.getGroupByAttributeKeys(step);
+
+      expect(keys).toEqual([CONTAINER_NAME_ATTRIBUTE]);
+      /*
+       * Docker/Podman container identity is a RESOURCE attribute. Dropping the
+       * prefix (the Docker Swarm spelling) would group every datapoint into a
+       * single "" series and quietly restore the fleet-wide single alert.
+       */
+      expect(keys[0]!.startsWith("resource.")).toBe(true);
+    }
+  });
+
+  test("the host filesystem template is grouped per mountpoint", () => {
+    const filesystemTemplate: HostAlertTemplate | undefined =
+      HOST_TEMPLATES.find((template: HostAlertTemplate) => {
+        return template.id === "host-high-filesystem";
+      });
+
+    expect(filesystemTemplate).toBeDefined();
+
+    const step: MonitorStep =
+      filesystemTemplate!.getMonitorStep(buildHostArgs());
+
+    expect(MonitorStep.getGroupByAttributeKeys(step)).toEqual(["mountpoint"]);
+  });
+});

package/Tests/Types/NetworkAutomation/RuleRunResult.test.ts

@@ -1,4 +1,5 @@
 import {
+  AutoImportRuleRunResult,
   LabelRuleRunResult,
   RuleRunResultUtil,
   SiteAssignmentRuleRunResult,
@@ -182,3 +183,104 @@ describe("RuleRunResultUtil.parseLabelRuleRunResult", () => {
     expect(parsed.devicesLabeled).toBe(0);
   });
 });
+
+describe("RuleRunResultUtil.parseAutoImportRuleRunResult", () => {
+  it("reads the device and active-monitor outcome independently", () => {
+    const parsed: AutoImportRuleRunResult =
+      RuleRunResultUtil.parseAutoImportRuleRunResult({
+        hostsEvaluated: 20,
+        hostsMatched: 10,
+        hostsExcluded: 2,
+        hostsSkippedAlreadyRegistered: 3,
+        devicesCreated: 4,
+        devicesFailed: 1,
+        monitorsWouldCreate: 0,
+        monitorsCreated: 3,
+        monitorsSkippedAlreadyExisting: 2,
+        monitorsSkippedUnsupportedHost: 1,
+        monitorsFailed: 1,
+        isTruncated: true,
+        hasMoreScans: true,
+        isDryRun: false,
+        matchedIpAddressSample: ["10.0.0.1", "10.0.0.2"],
+      } as JSONObject);
+
+    expect(parsed).toEqual({
+      hostsEvaluated: 20,
+      hostsMatched: 10,
+      hostsExcluded: 2,
+      hostsSkippedAlreadyRegistered: 3,
+      devicesCreated: 4,
+      devicesFailed: 1,
+      monitorsWouldCreate: 0,
+      monitorsCreated: 3,
+      monitorsSkippedAlreadyExisting: 2,
+      monitorsSkippedUnsupportedHost: 1,
+      monitorsFailed: 1,
+      isTruncated: true,
+      hasMoreScans: true,
+      isDryRun: false,
+      matchedIpAddressSample: ["10.0.0.1", "10.0.0.2"],
+    });
+  });
+
+  it("reads every missing monitor counter as zero for older servers", () => {
+    const parsed: AutoImportRuleRunResult =
+      RuleRunResultUtil.parseAutoImportRuleRunResult({
+        hostsEvaluated: 1,
+      });
+
+    expect(parsed.monitorsWouldCreate).toBe(0);
+    expect(parsed.monitorsCreated).toBe(0);
+    expect(parsed.monitorsSkippedAlreadyExisting).toBe(0);
+    expect(parsed.monitorsSkippedUnsupportedHost).toBe(0);
+    expect(parsed.monitorsFailed).toBe(0);
+  });
+
+  it("refuses malformed and non-finite monitor counters", () => {
+    const parsed: AutoImportRuleRunResult =
+      RuleRunResultUtil.parseAutoImportRuleRunResult({
+        monitorsWouldCreate: "4",
+        monitorsCreated: Number.NaN,
+        monitorsSkippedAlreadyExisting: null,
+        monitorsSkippedUnsupportedHost: {},
+        monitorsFailed: Number.POSITIVE_INFINITY,
+      } as unknown as JSONObject);
+
+    expect(parsed.monitorsWouldCreate).toBe(0);
+    expect(parsed.monitorsCreated).toBe(0);
+    expect(parsed.monitorsSkippedAlreadyExisting).toBe(0);
+    expect(parsed.monitorsSkippedUnsupportedHost).toBe(0);
+    expect(parsed.monitorsFailed).toBe(0);
+  });
+
+  it("keeps only a bounded sample of string IP addresses", () => {
+    const sample: Array<unknown> = Array.from(
+      { length: 60 },
+      (_value: unknown, index: number): unknown => {
+        return index === 1 ? 42 : `10.0.0.${index}`;
+      },
+    );
+
+    const parsed: AutoImportRuleRunResult =
+      RuleRunResultUtil.parseAutoImportRuleRunResult({
+        matchedIpAddressSample: sample,
+      } as unknown as JSONObject);
+
+    expect(parsed.matchedIpAddressSample).toHaveLength(50);
+    expect(parsed.matchedIpAddressSample).not.toContain(42);
+  });
+
+  it("treats only literal true as dry-run and truncation flags", () => {
+    const parsed: AutoImportRuleRunResult =
+      RuleRunResultUtil.parseAutoImportRuleRunResult({
+        isDryRun: "true",
+        isTruncated: 1,
+        hasMoreScans: true,
+      } as unknown as JSONObject);
+
+    expect(parsed.isDryRun).toBe(false);
+    expect(parsed.isTruncated).toBe(false);
+    expect(parsed.hasMoreScans).toBe(true);
+  });
+});

package/Tests/Types/NetworkAutomation/RuleRunResultDescribe.test.ts

@@ -0,0 +1,145 @@
+import {
+  AutoImportRuleRunResult,
+  RuleRunResultUtil,
+} from "../../../Types/NetworkAutomation/RuleRunResult";
+import { describe, expect, it } from "@jest/globals";
+
+/*
+ * Text contract for RuleRunResultUtil.describeAutoImportRun. The wording is what
+ * the "Run Now" / "Dry Run" report shows an operator, so each sentence is
+ * asserted at the boundary that produces it: an import of zero must say WHY, a
+ * dry run must never claim it wrote anything, and singular/plural grammar must
+ * track the count.
+ */
+
+function result(
+  overrides: Partial<AutoImportRuleRunResult>,
+): AutoImportRuleRunResult {
+  return {
+    hostsEvaluated: 0,
+    hostsMatched: 0,
+    hostsExcluded: 0,
+    hostsSkippedAlreadyRegistered: 0,
+    devicesCreated: 0,
+    devicesFailed: 0,
+    monitorsWouldCreate: 0,
+    monitorsCreated: 0,
+    monitorsSkippedAlreadyExisting: 0,
+    monitorsSkippedUnsupportedHost: 0,
+    monitorsFailed: 0,
+    isTruncated: false,
+    hasMoreScans: false,
+    isDryRun: false,
+    matchedIpAddressSample: [],
+    ...overrides,
+  };
+}
+
+function describe_(overrides: Partial<AutoImportRuleRunResult>): string {
+  return RuleRunResultUtil.describeAutoImportRun(result(overrides));
+}
+
+describe("RuleRunResultUtil.describeAutoImportRun", () => {
+  it("reports a real import with the device count", () => {
+    expect(describe_({ devicesCreated: 3, hostsMatched: 3 })).toContain(
+      "Imported 3 hosts as network devices.",
+    );
+  });
+
+  it("uses singular grammar for a single imported device", () => {
+    const summary: string = describe_({ devicesCreated: 1, hostsMatched: 1 });
+    expect(summary).toContain("Imported 1 host as network devices.");
+    expect(summary).not.toContain("1 hosts");
+  });
+
+  it("explains a zero import instead of just saying zero", () => {
+    const summary: string = describe_({
+      devicesCreated: 0,
+      hostsMatched: 0,
+      hostsEvaluated: 12,
+    });
+    expect(summary).toContain("No devices were imported.");
+    expect(summary).toContain("matched 0 hosts out of the 12 hosts");
+  });
+
+  it("a dry run that would import reports the projection and writes nothing", () => {
+    const summary: string = describe_({
+      isDryRun: true,
+      hostsMatched: 5,
+      hostsSkippedAlreadyRegistered: 2,
+    });
+    // wouldImport = matched - alreadyRegistered = 3
+    expect(summary).toContain("This rule would import 3 hosts");
+    expect(summary).toContain("Nothing was written — this was a dry run.");
+  });
+
+  it("a dry run that would import nothing says so without claiming a write", () => {
+    const summary: string = describe_({
+      isDryRun: true,
+      hostsMatched: 0,
+      hostsEvaluated: 7,
+    });
+    expect(summary).toContain("This rule would import nothing.");
+    expect(summary).not.toContain("Imported");
+  });
+
+  it("never lets already-registered exceed matched into a negative projection", () => {
+    const summary: string = describe_({
+      isDryRun: true,
+      hostsMatched: 1,
+      hostsSkippedAlreadyRegistered: 4,
+    });
+    expect(summary).toContain("This rule would import nothing.");
+    expect(summary).not.toContain("-3");
+  });
+
+  it("reports monitor provisioning on a real run", () => {
+    const summary: string = describe_({
+      devicesCreated: 2,
+      hostsMatched: 2,
+      monitorsCreated: 2,
+    });
+    expect(summary).toContain(
+      "Created 2 active Network Device monitors from the selected Monitor Template.",
+    );
+  });
+
+  it("predicts monitor provisioning on a dry run without claiming a write", () => {
+    const summary: string = describe_({
+      isDryRun: true,
+      hostsMatched: 2,
+      monitorsWouldCreate: 2,
+    });
+    expect(summary).toContain(
+      "It would also create 2 active Network Device monitors",
+    );
+  });
+
+  it("reports exclusions, already-registered hosts, and failures", () => {
+    const summary: string = describe_({
+      devicesCreated: 1,
+      hostsMatched: 4,
+      hostsExcluded: 1,
+      hostsSkippedAlreadyRegistered: 1,
+      devicesFailed: 1,
+    });
+    expect(summary).toContain("An exclusion rule vetoed 1 host.");
+    expect(summary).toContain("1 host already had network devices");
+    expect(summary).toContain("1 host could not be imported.");
+  });
+
+  it("gives resumable advice for a truncated real run and non-resumable for dry", () => {
+    expect(describe_({ isTruncated: true, devicesCreated: 5 })).toContain(
+      "run again to continue",
+    );
+    const dry: string = describe_({ isTruncated: true, isDryRun: true });
+    expect(dry).toContain("device-import and active-monitor creation");
+    expect(dry).not.toContain("run again to continue");
+  });
+
+  it("warns when older scans went unread", () => {
+    expect(describe_({ hasMoreScans: true, devicesCreated: 1 })).toContain(
+      "Only the newest 100 completed scans were read",
+    );
+  });
+});

package/Tests/Types/NetworkSite/SiteHealthRollupPolicy.test.ts

@@ -0,0 +1,58 @@
+import SiteHealthRollupPolicy, {
+  DefaultSiteHealthRollupPolicy,
+  DefaultSiteOfflineThresholdPercent,
+  SiteHealthRollupPolicyValues,
+  getSiteHealthRollupPolicyLabel,
+  parseSiteHealthRollupPolicy,
+} from "../../../Types/NetworkSite/SiteHealthRollupPolicy";
+
+/*
+ * The policy column is a free-form string in Postgres, so what it means
+ * when it holds something unexpected is a product decision, not an
+ * accident. It means "worst-of" — the pre-policy behaviour — because a
+ * rollup that threw on a bad settings string would leave a site with no
+ * verdict at all.
+ */
+describe("parseSiteHealthRollupPolicy", () => {
+  it("round-trips every declared policy", () => {
+    for (const policy of SiteHealthRollupPolicyValues) {
+      expect(parseSiteHealthRollupPolicy(policy)).toBe(policy);
+    }
+  });
+
+  it("falls back to the default for anything it does not recognise", () => {
+    expect(parseSiteHealthRollupPolicy(null)).toBe(
+      DefaultSiteHealthRollupPolicy,
+    );
+    expect(parseSiteHealthRollupPolicy(undefined)).toBe(
+      DefaultSiteHealthRollupPolicy,
+    );
+    expect(parseSiteHealthRollupPolicy("")).toBe(DefaultSiteHealthRollupPolicy);
+    expect(parseSiteHealthRollupPolicy("worststatus")).toBe(
+      DefaultSiteHealthRollupPolicy,
+    );
+    expect(parseSiteHealthRollupPolicy("Averaged")).toBe(
+      DefaultSiteHealthRollupPolicy,
+    );
+  });
+
+  it("defaults to worst-of, so upgrading changes no existing site", () => {
+    expect(DefaultSiteHealthRollupPolicy).toBe(
+      SiteHealthRollupPolicy.WorstStatus,
+    );
+  });
+
+  it("has a distinct label for every policy", () => {
+    const labels: Set<string> = new Set(
+      SiteHealthRollupPolicyValues.map((policy: SiteHealthRollupPolicy) => {
+        return getSiteHealthRollupPolicyLabel(policy);
+      }),
+    );
+    expect(labels.size).toBe(SiteHealthRollupPolicyValues.length);
+  });
+
+  it("keeps the default threshold inside 0..100", () => {
+    expect(DefaultSiteOfflineThresholdPercent).toBeGreaterThan(0);
+    expect(DefaultSiteOfflineThresholdPercent).toBeLessThanOrEqual(100);
+  });
+});

package/Tests/Types/SerializableObjectDictionaryImportCycle.test.ts

@@ -28,6 +28,8 @@ import LessThan from "../../Types/BaseDatabase/LessThan";
 import LessThanOrEqual from "../../Types/BaseDatabase/LessThanOrEqual";
 import LessThanOrNull from "../../Types/BaseDatabase/LessThanOrNull";
 import NotContains from "../../Types/BaseDatabase/NotContains";
+import Wildcard from "../../Types/BaseDatabase/Wildcard";
+import NotWildcard from "../../Types/BaseDatabase/NotWildcard";
 import NotEqual from "../../Types/BaseDatabase/NotEqual";
 import NotNull from "../../Types/BaseDatabase/NotNull";
 import Search from "../../Types/BaseDatabase/Search";
@@ -149,6 +151,19 @@ describe("query operators survive a serialize/deserialize round trip", () => {
     expect(roundTrip(new EndsWith("a"))).toBeInstanceOf(EndsWith);
   });
 
+  test("the wildcard operators keep their class and their glob list", () => {
+    /*
+     * A wildcard that arrives as a plain `{_type, value}` object is worse
+     * than a crash: on a Map(String,String) column the compiler reads the
+     * WRAPPER as the filter and emits `attributes['_type'] = 'Wildcard'`.
+     */
+    const wildcard: unknown = roundTrip(new Wildcard(["a*", "b"]));
+
+    expect(wildcard).toBeInstanceOf(Wildcard);
+    expect((wildcard as Wildcard<string>).values).toEqual(["a*", "b"]);
+    expect(roundTrip(new NotWildcard("a*"))).toBeInstanceOf(NotWildcard);
+  });
+
   test("the null checks keep their class", () => {
     expect(roundTrip(new IsNull())).toBeInstanceOf(IsNull);
     expect(roundTrip(new NotNull())).toBeInstanceOf(NotNull);