@oneuptime/common 11.5.8 → 11.5.9

package/Tests/Server/Utils/Monitor/NetworkDeviceHydrationUtil.test.ts

@@ -0,0 +1,502 @@
+import { afterEach, describe, expect, test } from "@jest/globals";
+import NetworkDeviceHydrationUtil, {
+  HydratableMonitor,
+} from "../../../../Server/Utils/Monitor/NetworkDeviceHydrationUtil";
+import NetworkDeviceService from "../../../../Server/Services/NetworkDeviceService";
+import NetworkDevice from "../../../../Models/DatabaseModels/NetworkDevice";
+import MonitorStep from "../../../../Types/Monitor/MonitorStep";
+import MonitorSteps from "../../../../Types/Monitor/MonitorSteps";
+import MonitorType from "../../../../Types/Monitor/MonitorType";
+import MonitorStepSnmpMonitor from "../../../../Types/Monitor/MonitorStepSnmpMonitor";
+import SnmpVersion from "../../../../Types/Monitor/SnmpMonitor/SnmpVersion";
+import SnmpV3Auth from "../../../../Types/Monitor/SnmpMonitor/SnmpV3Auth";
+import SnmpSecurityLevel from "../../../../Types/Monitor/SnmpMonitor/SnmpSecurityLevel";
+import SnmpAuthProtocol from "../../../../Types/Monitor/SnmpMonitor/SnmpAuthProtocol";
+import SnmpPrivProtocol from "../../../../Types/Monitor/SnmpMonitor/SnmpPrivProtocol";
+import ObjectID from "../../../../Types/ObjectID";
+
+/*
+ * Network Device monitors carry only a reference to a NetworkDevice; the probe
+ * is stateless and understands nothing but concrete SNMP config. This util is
+ * the single place that turns the stored device into the `snmpMonitor` block a
+ * probe can execute, so it is where an SNMP v3 device either gets its
+ * credentials or silently loses them.
+ *
+ * Customer report: "Test Metrics" (Test Monitor) errors for a monitor on a v3
+ * device while v2 works. The probe throws when a v3 step reaches it without a
+ * v3 username (SnmpMonitor.createSnmpSession fails loudly rather than
+ * downgrading to v2c/"public"), so these tests pin exactly when this util does
+ * and does not produce snmpV3Auth — and that it hydrates the MonitorTest shape
+ * used by Test Monitor, not just saved Monitors.
+ */
+
+const DEVICE_ID: string = "8f2c1f0e-0000-4000-8000-0000000000aa";
+
+/*
+ * Columns are assigned loosely so a test can pin a column to undefined, which
+ * Partial<NetworkDevice> forbids under exactOptionalPropertyTypes.
+ */
+type DeviceFields = Record<string, unknown>;
+
+function buildDevice(fields: DeviceFields): NetworkDevice {
+  const device: NetworkDevice = new NetworkDevice();
+  device._id = DEVICE_ID;
+  device.hostname = "10.0.0.1";
+  Object.assign(device, fields);
+
+  return device;
+}
+
+function buildV3Device(fields?: DeviceFields): NetworkDevice {
+  return buildDevice({
+    snmpVersion: "V3",
+    snmpV3SecurityLevel: SnmpSecurityLevel.AuthPriv,
+    snmpV3Username: "monitoring",
+    snmpV3AuthProtocol: SnmpAuthProtocol.SHA,
+    snmpV3AuthKey: "auth-passphrase",
+    snmpV3PrivProtocol: SnmpPrivProtocol.AES,
+    snmpV3PrivKey: "priv-passphrase",
+    ...fields,
+  });
+}
+
+/*
+ * Structural stand-in for both Monitor and MonitorTest — hydrateNetworkDeviceMonitors
+ * accepts either, which is what the Test Monitor path depends on.
+ */
+function buildMonitor(options?: {
+  monitorType?: MonitorType | undefined;
+  networkDeviceId?: string | undefined;
+  monitorInterfaces?: boolean | undefined;
+}): HydratableMonitor {
+  const step: MonitorStep = new MonitorStep();
+  step.data = {
+    ...step.data,
+    networkDeviceMonitor: {
+      networkDeviceId:
+        options && "networkDeviceId" in options
+          ? options.networkDeviceId
+          : DEVICE_ID,
+      monitorInterfaces: options?.monitorInterfaces ?? true,
+      oids: [{ oid: "1.3.6.1.2.1.1.1.0", name: "sysDescr" }],
+    },
+  } as MonitorStep["data"];
+
+  const monitorSteps: MonitorSteps = new MonitorSteps();
+  monitorSteps.data = {
+    monitorStepsInstanceArray: [step],
+    defaultMonitorStatusId: undefined,
+  };
+
+  return {
+    id: ObjectID.generate(),
+    monitorType: options?.monitorType ?? MonitorType.NetworkDevice,
+    monitorSteps: monitorSteps,
+  };
+}
+
+function mockDevices(devices: Array<NetworkDevice>): void {
+  jest.spyOn(NetworkDeviceService, "findBy").mockResolvedValue(devices);
+}
+
+function hydratedStep(
+  monitor: HydratableMonitor,
+): MonitorStepSnmpMonitor | undefined {
+  return monitor.monitorSteps?.data?.monitorStepsInstanceArray[0]?.data
+    ?.snmpMonitor;
+}
+
+describe("NetworkDeviceHydrationUtil.hydrateNetworkDeviceMonitors", () => {
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  describe("SNMP v3 credential assembly", () => {
+    test("a v3 device hands the probe a complete authPriv SnmpV3Auth", async () => {
+      mockDevices([buildV3Device()]);
+      const monitor: HydratableMonitor = buildMonitor();
+
+      await NetworkDeviceHydrationUtil.hydrateNetworkDeviceMonitors([monitor]);
+
+      const snmp: MonitorStepSnmpMonitor | undefined = hydratedStep(monitor);
+
+      expect(snmp?.snmpVersion).toBe(SnmpVersion.V3);
+      expect(snmp?.snmpV3Auth).toEqual({
+        securityLevel: SnmpSecurityLevel.AuthPriv,
+        username: "monitoring",
+        authProtocol: SnmpAuthProtocol.SHA,
+        authKey: "auth-passphrase",
+        privProtocol: SnmpPrivProtocol.AES,
+        privKey: "priv-passphrase",
+      } as SnmpV3Auth);
+    });
+
+    /*
+     * The probe refuses to open a v3 session without a username. If this util
+     * ever hands back a v3 step with no auth, Test Monitor surfaces that
+     * refusal as the error the customer reported — so a fully configured
+     * device must never produce one.
+     */
+    test("a fully configured v3 device never yields a v3 step without credentials", async () => {
+      mockDevices([buildV3Device()]);
+      const monitor: HydratableMonitor = buildMonitor();
+
+      await NetworkDeviceHydrationUtil.hydrateNetworkDeviceMonitors([monitor]);
+
+      const snmp: MonitorStepSnmpMonitor | undefined = hydratedStep(monitor);
+
+      expect(snmp?.snmpVersion).toBe(SnmpVersion.V3);
+      expect(snmp?.snmpV3Auth?.username).toBeTruthy();
+    });
+
+    test("an authNoPriv device carries auth but no privacy material", async () => {
+      mockDevices([
+        buildV3Device({
+          snmpV3SecurityLevel: SnmpSecurityLevel.AuthNoPriv,
+          snmpV3PrivProtocol: undefined,
+          snmpV3PrivKey: undefined,
+        }),
+      ]);
+      const monitor: HydratableMonitor = buildMonitor();
+
+      await NetworkDeviceHydrationUtil.hydrateNetworkDeviceMonitors([monitor]);
+
+      const auth: SnmpV3Auth | undefined = hydratedStep(monitor)?.snmpV3Auth;
+
+      expect(auth?.securityLevel).toBe(SnmpSecurityLevel.AuthNoPriv);
+      expect(auth?.authKey).toBe("auth-passphrase");
+      expect(auth?.privProtocol).toBeUndefined();
+      expect(auth?.privKey).toBeUndefined();
+    });
+
+    test("a noAuthNoPriv device carries only the username", async () => {
+      mockDevices([
+        buildV3Device({
+          snmpV3SecurityLevel: SnmpSecurityLevel.NoAuthNoPriv,
+          snmpV3AuthProtocol: undefined,
+          snmpV3AuthKey: undefined,
+          snmpV3PrivProtocol: undefined,
+          snmpV3PrivKey: undefined,
+        }),
+      ]);
+      const monitor: HydratableMonitor = buildMonitor();
+
+      await NetworkDeviceHydrationUtil.hydrateNetworkDeviceMonitors([monitor]);
+
+      const auth: SnmpV3Auth | undefined = hydratedStep(monitor)?.snmpV3Auth;
+
+      expect(auth?.securityLevel).toBe(SnmpSecurityLevel.NoAuthNoPriv);
+      expect(auth?.username).toBe("monitoring");
+      expect(auth?.authKey).toBeUndefined();
+    });
+
+    test("a v3 device with no username yields no auth at all", async () => {
+      mockDevices([
+        buildDevice({ snmpVersion: "V3", snmpV3Username: undefined }),
+      ]);
+      const monitor: HydratableMonitor = buildMonitor();
+
+      await NetworkDeviceHydrationUtil.hydrateNetworkDeviceMonitors([monitor]);
+
+      expect(hydratedStep(monitor)?.snmpV3Auth).toBeUndefined();
+    });
+
+    test("a v3 device with an unset security level defaults to noAuthNoPriv", async () => {
+      mockDevices([
+        buildDevice({ snmpVersion: "V3", snmpV3Username: "monitoring" }),
+      ]);
+      const monitor: HydratableMonitor = buildMonitor();
+
+      await NetworkDeviceHydrationUtil.hydrateNetworkDeviceMonitors([monitor]);
+
+      expect(hydratedStep(monitor)?.snmpV3Auth?.securityLevel).toBe(
+        SnmpSecurityLevel.NoAuthNoPriv,
+      );
+    });
+  });
+
+  describe("legacy snmpV3Auth JSON column", () => {
+    test("a device predating the flattened columns still authenticates", async () => {
+      mockDevices([
+        buildDevice({
+          snmpVersion: "V3",
+          snmpV3Auth: {
+            securityLevel: SnmpSecurityLevel.AuthPriv,
+            username: "legacy-user",
+            authProtocol: SnmpAuthProtocol.MD5,
+            authKey: "legacy-auth",
+            privProtocol: SnmpPrivProtocol.DES,
+            privKey: "legacy-priv",
+          },
+        }),
+      ]);
+      const monitor: HydratableMonitor = buildMonitor();
+
+      await NetworkDeviceHydrationUtil.hydrateNetworkDeviceMonitors([monitor]);
+
+      expect(hydratedStep(monitor)?.snmpV3Auth?.username).toBe("legacy-user");
+      expect(hydratedStep(monitor)?.snmpV3Auth?.authProtocol).toBe(
+        SnmpAuthProtocol.MD5,
+      );
+    });
+
+    test("the flattened columns win over a stale legacy blob", async () => {
+      mockDevices([
+        buildV3Device({
+          snmpV3Auth: {
+            securityLevel: SnmpSecurityLevel.NoAuthNoPriv,
+            username: "stale-legacy-user",
+          },
+        }),
+      ]);
+      const monitor: HydratableMonitor = buildMonitor();
+
+      await NetworkDeviceHydrationUtil.hydrateNetworkDeviceMonitors([monitor]);
+
+      expect(hydratedStep(monitor)?.snmpV3Auth?.username).toBe("monitoring");
+    });
+
+    test("a legacy blob with no username is ignored", async () => {
+      mockDevices([
+        buildDevice({
+          snmpVersion: "V3",
+          snmpV3Auth: { securityLevel: SnmpSecurityLevel.AuthPriv },
+        }),
+      ]);
+      const monitor: HydratableMonitor = buildMonitor();
+
+      await NetworkDeviceHydrationUtil.hydrateNetworkDeviceMonitors([monitor]);
+
+      expect(hydratedStep(monitor)?.snmpV3Auth).toBeUndefined();
+    });
+  });
+
+  describe("SNMP version parsing from the stored column", () => {
+    /*
+     * The column is free text and both spellings exist in the wild: the
+     * dropdown writes enum keys, other writers and older defaults use the enum
+     * values. The probe branches on SnmpVersion, so both must map through.
+     */
+    test.each([
+      ["V3", SnmpVersion.V3],
+      ["3", SnmpVersion.V3],
+      ["v3", SnmpVersion.V3],
+      ["V1", SnmpVersion.V1],
+      ["1", SnmpVersion.V1],
+      ["v1", SnmpVersion.V1],
+      ["V2c", SnmpVersion.V2c],
+      ["2c", SnmpVersion.V2c],
+      ["v2c", SnmpVersion.V2c],
+    ])(
+      "a device storing snmpVersion=%s polls as %s",
+      async (stored: string, expected: SnmpVersion) => {
+        mockDevices([buildV3Device({ snmpVersion: stored })]);
+        const monitor: HydratableMonitor = buildMonitor();
+
+        await NetworkDeviceHydrationUtil.hydrateNetworkDeviceMonitors([
+          monitor,
+        ]);
+
+        expect(hydratedStep(monitor)?.snmpVersion).toBe(expected);
+      },
+    );
+
+    test("an unset or unrecognised version falls back to v2c", async () => {
+      for (const stored of [undefined, "", "nonsense"]) {
+        mockDevices([buildDevice({ snmpVersion: stored })]);
+        const monitor: HydratableMonitor = buildMonitor();
+
+        await NetworkDeviceHydrationUtil.hydrateNetworkDeviceMonitors([
+          monitor,
+        ]);
+
+        expect(hydratedStep(monitor)?.snmpVersion).toBe(SnmpVersion.V2c);
+      }
+    });
+
+    /*
+     * A v3 device whose version is stored in enum-value form must still reach
+     * the probe as v3 WITH its credentials — parsing the version and building
+     * the auth are independent, and getting only one right is what downgrades
+     * a device to a cleartext v2c poll.
+     */
+    test('a v3 device stored as "3" keeps both its version and its credentials', async () => {
+      mockDevices([buildV3Device({ snmpVersion: "3" })]);
+      const monitor: HydratableMonitor = buildMonitor();
+
+      await NetworkDeviceHydrationUtil.hydrateNetworkDeviceMonitors([monitor]);
+
+      expect(hydratedStep(monitor)?.snmpVersion).toBe(SnmpVersion.V3);
+      expect(hydratedStep(monitor)?.snmpV3Auth?.username).toBe("monitoring");
+    });
+  });
+
+  describe("v1/v2c community polling", () => {
+    test("a v2c device carries its community string and no v3 auth", async () => {
+      mockDevices([
+        buildDevice({ snmpVersion: "V2c", snmpCommunityString: "s3cret" }),
+      ]);
+      const monitor: HydratableMonitor = buildMonitor();
+
+      await NetworkDeviceHydrationUtil.hydrateNetworkDeviceMonitors([monitor]);
+
+      const snmp: MonitorStepSnmpMonitor | undefined = hydratedStep(monitor);
+
+      expect(snmp?.snmpVersion).toBe(SnmpVersion.V2c);
+      expect(snmp?.communityString).toBe("s3cret");
+      expect(snmp?.snmpV3Auth).toBeUndefined();
+    });
+
+    test("a v2c device with no community string leaves it unset for the probe to default", async () => {
+      mockDevices([buildDevice({ snmpVersion: "V2c" })]);
+      const monitor: HydratableMonitor = buildMonitor();
+
+      await NetworkDeviceHydrationUtil.hydrateNetworkDeviceMonitors([monitor]);
+
+      expect(hydratedStep(monitor)?.communityString).toBeUndefined();
+    });
+  });
+
+  describe("connection details and step options", () => {
+    test("hostname, port, oids and interface flag come from the device and step", async () => {
+      mockDevices([buildV3Device({ hostname: "192.168.5.9", snmpPort: 1610 })]);
+      const monitor: HydratableMonitor = buildMonitor();
+
+      await NetworkDeviceHydrationUtil.hydrateNetworkDeviceMonitors([monitor]);
+
+      const snmp: MonitorStepSnmpMonitor | undefined = hydratedStep(monitor);
+
+      expect(snmp?.hostname).toBe("192.168.5.9");
+      expect(snmp?.port).toBe(1610);
+      expect(snmp?.oids).toEqual([
+        { oid: "1.3.6.1.2.1.1.1.0", name: "sysDescr" },
+      ]);
+      expect(snmp?.monitorInterfaces).toBe(true);
+    });
+
+    test("a device with no port falls back to 161", async () => {
+      mockDevices([buildV3Device({ snmpPort: undefined })]);
+      const monitor: HydratableMonitor = buildMonitor();
+
+      await NetworkDeviceHydrationUtil.hydrateNetworkDeviceMonitors([monitor]);
+
+      expect(hydratedStep(monitor)?.port).toBe(161);
+    });
+
+    test("monitorInterfaces=false is respected rather than defaulted on", async () => {
+      mockDevices([buildV3Device()]);
+      const monitor: HydratableMonitor = buildMonitor({
+        monitorInterfaces: false,
+      });
+
+      await NetworkDeviceHydrationUtil.hydrateNetworkDeviceMonitors([monitor]);
+
+      expect(hydratedStep(monitor)?.monitorInterfaces).toBe(false);
+    });
+  });
+
+  describe("guards", () => {
+    test("a non-NetworkDevice monitor is left untouched", async () => {
+      const findBy: jest.SpyInstance = jest
+        .spyOn(NetworkDeviceService, "findBy")
+        .mockResolvedValue([buildV3Device()]);
+
+      const monitor: HydratableMonitor = buildMonitor({
+        monitorType: MonitorType.Website,
+      });
+
+      await NetworkDeviceHydrationUtil.hydrateNetworkDeviceMonitors([monitor]);
+
+      expect(hydratedStep(monitor)).toBeUndefined();
+      expect(findBy).not.toHaveBeenCalled();
+    });
+
+    test("a step referencing a deleted device is not hydrated", async () => {
+      mockDevices([]);
+      const monitor: HydratableMonitor = buildMonitor();
+
+      await NetworkDeviceHydrationUtil.hydrateNetworkDeviceMonitors([monitor]);
+
+      expect(hydratedStep(monitor)).toBeUndefined();
+    });
+
+    test("a step with no device reference is skipped without a lookup", async () => {
+      const findBy: jest.SpyInstance = jest
+        .spyOn(NetworkDeviceService, "findBy")
+        .mockResolvedValue([]);
+
+      const monitor: HydratableMonitor = buildMonitor({
+        networkDeviceId: undefined,
+      });
+
+      await NetworkDeviceHydrationUtil.hydrateNetworkDeviceMonitors([monitor]);
+
+      expect(hydratedStep(monitor)).toBeUndefined();
+      expect(findBy).not.toHaveBeenCalled();
+    });
+
+    test("a device with no hostname is not hydrated", async () => {
+      mockDevices([buildV3Device({ hostname: undefined })]);
+      const monitor: HydratableMonitor = buildMonitor();
+
+      await NetworkDeviceHydrationUtil.hydrateNetworkDeviceMonitors([monitor]);
+
+      expect(hydratedStep(monitor)).toBeUndefined();
+    });
+
+    test("an empty monitor list performs no lookup", async () => {
+      const findBy: jest.SpyInstance = jest
+        .spyOn(NetworkDeviceService, "findBy")
+        .mockResolvedValue([]);
+
+      await NetworkDeviceHydrationUtil.hydrateNetworkDeviceMonitors([]);
+
+      expect(findBy).not.toHaveBeenCalled();
+    });
+  });
+
+  describe("the Test Monitor path", () => {
+    /*
+     * Test Monitor posts a MonitorTest — a different model from Monitor, but
+     * structurally hydratable. It must receive the same v3 credentials the
+     * scheduled monitor does, or the test errors while live polling works.
+     */
+    test("a MonitorTest-shaped object gets the same v3 credentials as a Monitor", async () => {
+      mockDevices([buildV3Device()]);
+
+      const monitorTest: HydratableMonitor = buildMonitor();
+      const monitor: HydratableMonitor = buildMonitor();
+
+      await NetworkDeviceHydrationUtil.hydrateNetworkDeviceMonitors([
+        monitorTest,
+      ]);
+      mockDevices([buildV3Device()]);
+      await NetworkDeviceHydrationUtil.hydrateNetworkDeviceMonitors([monitor]);
+
+      expect(hydratedStep(monitorTest)).toEqual(hydratedStep(monitor));
+      expect(hydratedStep(monitorTest)?.snmpV3Auth?.username).toBe(
+        "monitoring",
+      );
+    });
+
+    test("many monitors sharing one device are all hydrated from a single lookup", async () => {
+      const findBy: jest.SpyInstance = jest
+        .spyOn(NetworkDeviceService, "findBy")
+        .mockResolvedValue([buildV3Device()]);
+
+      const monitors: Array<HydratableMonitor> = [
+        buildMonitor(),
+        buildMonitor(),
+        buildMonitor(),
+      ];
+
+      await NetworkDeviceHydrationUtil.hydrateNetworkDeviceMonitors(monitors);
+
+      expect(findBy).toHaveBeenCalledTimes(1);
+
+      for (const monitor of monitors) {
+        expect(hydratedStep(monitor)?.snmpV3Auth?.username).toBe("monitoring");
+      }
+    });
+  });
+});

package/Tests/Types/AI/AIAgentTaskStatus.test.ts

@@ -69,12 +69,13 @@ describe("AIAgentTaskStatusHelper", () => {
   });
 
   describe("isTerminalStatus", () => {
-    test.each([AIAgentTaskStatus.Completed, AIAgentTaskStatus.Error])(
-      "returns true for terminal status %s",
-      (status: AIAgentTaskStatus) => {
-        expect(AIAgentTaskStatusHelper.isTerminalStatus(status)).toBe(true);
-      },
-    );
+    test.each([
+      AIAgentTaskStatus.Completed,
+      AIAgentTaskStatus.NoFixFound,
+      AIAgentTaskStatus.Error,
+    ])("returns true for terminal status %s", (status: AIAgentTaskStatus) => {
+      expect(AIAgentTaskStatusHelper.isTerminalStatus(status)).toBe(true);
+    });
 
     test.each([AIAgentTaskStatus.Scheduled, AIAgentTaskStatus.InProgress])(
       "returns false for non-terminal status %s",

package/Tests/Types/AI/AIRunStatus.test.ts

@@ -0,0 +1,42 @@
+import AIRunStatus, { AIRunStatusHelper } from "../../../Types/AI/AIRunStatus";
+
+describe("AIRunStatusHelper", () => {
+  describe("isTerminalStatus", () => {
+    test.each([
+      AIRunStatus.Completed,
+      AIRunStatus.NoFixFound,
+      AIRunStatus.Error,
+      AIRunStatus.Cancelled,
+      AIRunStatus.Stale,
+    ])("returns true for terminal status %s", (status: AIRunStatus) => {
+      expect(AIRunStatusHelper.isTerminalStatus(status)).toBe(true);
+    });
+
+    test.each([
+      AIRunStatus.Queued,
+      AIRunStatus.Running,
+      AIRunStatus.WaitingForApproval,
+    ])("returns false for non-terminal status %s", (status: AIRunStatus) => {
+      expect(AIRunStatusHelper.isTerminalStatus(status)).toBe(false);
+    });
+
+    /*
+     * A run that finished with no fix is DONE. Were it treated as non-terminal,
+     * the exception page would report a task still in flight forever: no retry
+     * offered, and the duplicate guard would refuse to start a new run.
+     */
+    test("NoFixFound is terminal — it is a result, not an in-flight run", () => {
+      expect(AIRunStatusHelper.isTerminalStatus(AIRunStatus.NoFixFound)).toBe(
+        true,
+      );
+    });
+
+    test("every status in the enum is classified", () => {
+      for (const status of Object.values(AIRunStatus)) {
+        expect(typeof AIRunStatusHelper.isTerminalStatus(status)).toBe(
+          "boolean",
+        );
+      }
+    });
+  });
+});

package/Tests/Types/Log/LogSeverity.test.ts

@@ -0,0 +1,78 @@
+import LogSeverity, {
+  LogSeverityNumber,
+  normalizeLogSeverity,
+} from "../../../Types/Log/LogSeverity";
+
+/*
+ * severityText on a log row is not what the client sent — ingest throws that
+ * away and re-derives it from severityNumber into one of these seven enum
+ * members. Filter comparisons are case-sensitive, so anything that writes or
+ * offers a severity-shaped string ("INFO", "warn") produces a value that
+ * matches nothing and reports no error. These tests pin the two things that
+ * prevent that: the enum is the only vocabulary, and the number always agrees
+ * with the text.
+ */
+describe("LogSeverity", () => {
+  describe("LogSeverityNumber agrees with the OTLP ranges ingest buckets on", () => {
+    test.each([
+      [LogSeverity.Unspecified, 0],
+      [LogSeverity.Trace, 1],
+      [LogSeverity.Debug, 5],
+      [LogSeverity.Information, 9],
+      [LogSeverity.Warning, 13],
+      [LogSeverity.Error, 17],
+      [LogSeverity.Fatal, 21],
+    ])("%s -> %i", (severity: LogSeverity, expected: number) => {
+      expect(LogSeverityNumber[severity]).toBe(expected);
+    });
+
+    test("every enum member has a number", () => {
+      for (const severity of Object.values(LogSeverity)) {
+        expect(LogSeverityNumber[severity]).toBeDefined();
+      }
+    });
+  });
+
+  describe("normalizeLogSeverity rescues the values the old dropdowns emitted", () => {
+    /*
+     * These six are exactly what the filter builder and the severity remapper
+     * used to write. INFO and WARNING are the dangerous ones: they differ from
+     * the stored value by more than case, so no amount of case-insensitive
+     * comparison would have saved them.
+     */
+    test.each([
+      ["TRACE", LogSeverity.Trace],
+      ["DEBUG", LogSeverity.Debug],
+      ["INFO", LogSeverity.Information],
+      ["WARNING", LogSeverity.Warning],
+      ["ERROR", LogSeverity.Error],
+      ["FATAL", LogSeverity.Fatal],
+    ])("legacy %s -> %s", (legacy: string, expected: LogSeverity) => {
+      expect(normalizeLogSeverity(legacy)).toBe(expected);
+    });
+
+    test.each([
+      ["info", LogSeverity.Information],
+      ["Information", LogSeverity.Information],
+      ["warn", LogSeverity.Warning],
+      ["  Error  ", LogSeverity.Error],
+      ["err", LogSeverity.Error],
+      ["Unspecified", LogSeverity.Unspecified],
+    ])("%s -> %s", (input: string, expected: LogSeverity) => {
+      expect(normalizeLogSeverity(input)).toBe(expected);
+    });
+
+    test("every enum member normalizes to itself", () => {
+      for (const severity of Object.values(LogSeverity)) {
+        expect(normalizeLogSeverity(severity)).toBe(severity);
+      }
+    });
+
+    test.each([[""], ["   "], ["nonsense"], ["INFORMATIONAL"], ["3"]])(
+      "%s -> null rather than a guess",
+      (input: string) => {
+        expect(normalizeLogSeverity(input)).toBeNull();
+      },
+    );
+  });
+});