@oneuptime/common 13.0.5 → 13.0.7

package/Tests/App/Dashboard/DeviceLatencyTrend.test.tsx

@@ -0,0 +1,278 @@
+import "@testing-library/jest-dom";
+import {
+  afterEach,
+  beforeEach,
+  describe,
+  expect,
+  jest,
+  test,
+} from "@jest/globals";
+import { act, cleanup, render, screen } from "@testing-library/react";
+import * as React from "react";
+import { MemoryRouter } from "react-router-dom";
+import DeviceLatencyTrend from "../../../../App/FeatureSet/Dashboard/src/Components/NetworkDevice/DeviceLatencyTrend";
+import { NETWORK_DEVICE_PING_ROUND_TRIP_TIME_METRIC_NAME as SERVER_METRIC_NAME } from "../../../Server/Utils/Monitor/NetworkDeviceMetricUtil";
+import AggregatedResult from "../../../Types/BaseDatabase/AggregatedResult";
+import MetricQueryConfigData from "../../../Types/Metrics/MetricQueryConfigData";
+import MetricViewData from "../../../Types/Metrics/MetricViewData";
+import MonitorMetricType from "../../../Types/Monitor/MonitorMetricType";
+import { NETWORK_DEVICE_PING_ROUND_TRIP_TIME_METRIC_NAME } from "../../../Types/NetworkDevice/NetworkDevicePingMetricNames";
+import ObjectID from "../../../Types/ObjectID";
+import getJestMockFunction, { MockFunction } from "../../MockType";
+
+/*
+ * Issue #3745: the hour of round-trip time under a device's name.
+ *
+ * The trend is the context an on-demand ping is read against, and the only
+ * thing that makes it the RIGHT context is the query: the device's own
+ * series (attributes.networkDeviceId), by the name the server writes, for
+ * the past hour. That query is what this pins, along with what the operator
+ * sees for a series, for a single point, for nothing, and for a metrics
+ * store that failed. The metrics API and the sparkline are stubbed so the
+ * assertions are about this component's decisions, not recharts.
+ */
+
+const DEVICE_ID: string = "11111111-1111-4111-8111-111111111111";
+const PROJECT_ID: string = "10000000-0000-4000-8000-000000000001";
+
+const fetchResultsMock: MockFunction = getJestMockFunction();
+const currentProjectIdMock: MockFunction = getJestMockFunction();
+
+jest.mock("../../../UI/Utils/Project", () => {
+  return {
+    __esModule: true,
+    default: {
+      getCurrentProjectId: () => {
+        return currentProjectIdMock();
+      },
+    },
+  };
+});
+
+jest.mock(
+  "../../../../App/FeatureSet/Dashboard/src/Components/Metrics/Utils/Metrics",
+  () => {
+    return {
+      __esModule: true,
+      default: {
+        fetchResults: (...args: Array<unknown>) => {
+          return fetchResultsMock(...args);
+        },
+      },
+    };
+  },
+);
+
+jest.mock(
+  "../../../../App/FeatureSet/Dashboard/src/Components/Metrics/MetricSparkline",
+  () => {
+    return {
+      __esModule: true,
+      default: (props: {
+        points: Array<unknown>;
+        isLoading?: boolean | undefined;
+      }) => {
+        return `sparkline-stub:${
+          props.isLoading ? "loading" : props.points.length
+        }`;
+      },
+    };
+  },
+);
+
+interface FetchResultsRequest {
+  metricViewData: MetricViewData;
+  metricTypes?: Array<unknown> | undefined;
+}
+
+function aggregate(
+  rows: Array<{ time: string; value: number }>,
+): AggregatedResult {
+  return {
+    data: rows.map((row: { time: string; value: number }) => {
+      return { timestamp: new Date(row.time), value: row.value };
+    }),
+  };
+}
+
+async function renderTrend(): Promise<void> {
+  await act(async () => {
+    render(
+      <MemoryRouter>
+        <DeviceLatencyTrend networkDeviceId={new ObjectID(DEVICE_ID)} />
+      </MemoryRouter>,
+    );
+  });
+}
+
+beforeEach(() => {
+  fetchResultsMock.mockReset();
+  currentProjectIdMock.mockReset();
+  currentProjectIdMock.mockReturnValue(PROJECT_ID);
+  fetchResultsMock.mockResolvedValue([aggregate([]), aggregate([])]);
+});
+
+afterEach(() => {
+  cleanup();
+});
+
+describe("what the trend asks the metrics API for", () => {
+  test("the device's own RTT and packet-loss series, with no MetricType listing", async () => {
+    await renderTrend();
+
+    expect(fetchResultsMock).toHaveBeenCalledTimes(1);
+
+    const request: FetchResultsRequest = fetchResultsMock.mock
+      .calls[0]![0] as FetchResultsRequest;
+    const configs: Array<MetricQueryConfigData> =
+      request.metricViewData.queryConfigs;
+
+    expect(configs).toHaveLength(2);
+
+    expect(configs[0]!.metricQueryData.filterData.metricName).toBe(
+      NETWORK_DEVICE_PING_ROUND_TRIP_TIME_METRIC_NAME,
+    );
+    expect(configs[0]!.metricQueryData.filterData.attributes).toEqual({
+      networkDeviceId: DEVICE_ID,
+      projectId: PROJECT_ID,
+    });
+
+    expect(configs[1]!.metricQueryData.filterData.metricName).toBe(
+      MonitorMetricType.PacketLossPercent,
+    );
+    expect(configs[1]!.metricQueryData.filterData.attributes).toEqual({
+      networkDeviceId: DEVICE_ID,
+      projectId: PROJECT_ID,
+    });
+
+    /*
+     * Left out, fetchResults lists every MetricType of the project (up to
+     * ten thousand rows, uncached) on every drawer open, for a unit
+     * conversion these ms and % series do not need.
+     */
+    expect(request.metricTypes).toEqual([]);
+  });
+
+  test("no project means nothing to scope to, so nothing is fetched", async () => {
+    currentProjectIdMock.mockReturnValue(null);
+
+    await renderTrend();
+
+    expect(fetchResultsMock).not.toHaveBeenCalled();
+    expect(
+      screen.getByText("No ping data in the last hour."),
+    ).toBeInTheDocument();
+  });
+
+  /*
+   * The dashboard reads the series the server writes. A rename on either
+   * side that the other does not follow leaves the sparkline pointed at a
+   * series nobody writes, and no type checker notices; the value is what
+   * has to agree.
+   */
+  test("by the same name the server util writes under", () => {
+    expect(SERVER_METRIC_NAME).toBe(
+      NETWORK_DEVICE_PING_ROUND_TRIP_TIME_METRIC_NAME,
+    );
+    expect(NETWORK_DEVICE_PING_ROUND_TRIP_TIME_METRIC_NAME).toBe(
+      "oneuptime.monitor.ping.round.trip.time",
+    );
+  });
+});
+
+describe("what the trend shows", () => {
+  test("a series: the sparkline, now / avg / max, and the hour's worst loss", async () => {
+    fetchResultsMock.mockResolvedValue([
+      aggregate([
+        { time: "2026-09-15T10:00:00Z", value: 10 },
+        { time: "2026-09-15T10:01:00Z", value: 30 },
+        { time: "2026-09-15T10:02:00Z", value: 20 },
+      ]),
+      aggregate([
+        { time: "2026-09-15T10:00:00Z", value: 0 },
+        { time: "2026-09-15T10:01:00Z", value: 40 },
+      ]),
+    ]);
+
+    await renderTrend();
+
+    expect(
+      screen.getByTestId("network-device-latency-summary"),
+    ).toHaveTextContent("now 20.0 ms · avg 20.0 ms · max 30.0 ms");
+    expect(screen.getByTestId("network-device-loss-summary")).toHaveTextContent(
+      "Packet loss (1h max): 40%",
+    );
+    expect(
+      screen.getByTestId("network-device-latency-trend"),
+    ).toHaveTextContent("sparkline-stub:3");
+  });
+
+  /*
+   * MetricSparkline draws a dashed "no data" box for fewer than two points,
+   * which above a summary line with a number in it reads as a contradiction.
+   */
+  test("a single point is a summary, not a line", async () => {
+    fetchResultsMock.mockResolvedValue([
+      aggregate([{ time: "2026-09-15T10:00:00Z", value: 12.5 }]),
+      aggregate([{ time: "2026-09-15T10:00:00Z", value: 0 }]),
+    ]);
+
+    await renderTrend();
+
+    expect(
+      screen.getByTestId("network-device-latency-summary"),
+    ).toHaveTextContent("now 12.5 ms · avg 12.5 ms · max 12.5 ms");
+    expect(screen.getByTestId("network-device-loss-summary")).toHaveTextContent(
+      "Packet loss (1h max): 0%",
+    );
+    expect(screen.queryByText(/sparkline-stub/)).not.toBeInTheDocument();
+  });
+
+  test("shows the loading placeholder until the API answers", async () => {
+    fetchResultsMock.mockReturnValue(
+      new Promise<Array<AggregatedResult>>(() => {
+        // Never settles: the fetch is still in flight.
+      }),
+    );
+
+    await renderTrend();
+
+    expect(
+      screen.getByTestId("network-device-latency-trend"),
+    ).toHaveTextContent("sparkline-stub:loading");
+    expect(
+      screen.queryByTestId("network-device-latency-summary"),
+    ).not.toBeInTheDocument();
+    expect(
+      screen.queryByText("No ping data in the last hour."),
+    ).not.toBeInTheDocument();
+  });
+
+  /*
+   * Quiet on failure: the drawer mounts this for every managed device it
+   * opens, and a red error under the device's name because the metrics
+   * store was slow would make the whole drawer look broken.
+   */
+  test("a metrics store that failed reads as no data, not as an error", async () => {
+    fetchResultsMock.mockRejectedValue(new Error("ClickHouse is away."));
+
+    await renderTrend();
+
+    expect(
+      screen.getByText("No ping data in the last hour."),
+    ).toBeInTheDocument();
+    expect(screen.queryByText("ClickHouse is away.")).not.toBeInTheDocument();
+    expect(screen.queryByText(/sparkline-stub/)).not.toBeInTheDocument();
+  });
+
+  test("links to the device's Metrics page", async () => {
+    await renderTrend();
+
+    const link: HTMLElement = screen.getByText("Open metrics");
+
+    expect(link.closest("a")).toHaveAttribute(
+      "href",
+      expect.stringContaining(`${DEVICE_ID}/metrics`),
+    );
+  });
+});

package/Tests/App/Dashboard/DiscoveryReviewInventoryRefresh.test.tsx

@@ -253,6 +253,7 @@ describe("Discovery review refreshes registration from current inventory", () =>
         discoveredDevices: true,
         probeId: true,
         isSnmpEnabled: true,
+        useShortDeviceNames: true,
         snmpConfigs: true,
         snmpVersion: true,
         snmpCommunityString: true,
@@ -334,6 +335,284 @@ describe("Discovery review refreshes registration from current inventory", () =>
   });
 });
 
+/*
+ * OneUptime issue #3678, end to end through the page's real review and import
+ * handlers: a scan set to short device names shows the short name, creates the
+ * device under it, keeps the FQDN as the device's DNS name, and — on a name
+ * collision — retries as "short (address)" rather than falling back to the
+ * FQDN the scan was told not to use.
+ */
+describe("Discovery review names devices by the scan's short-name choice", () => {
+  const FQDN: string = "core-gw.corp.example.com";
+
+  // A ping-only host named only by its PTR record, like the reporter's.
+  function namedHost(
+    ipAddress: string,
+    dnsHostname: string = FQDN,
+  ): DiscoveredNetworkDevice {
+    return { ...host(ipAddress, false), dnsHostname };
+  }
+
+  function scanNaming(
+    hosts: Array<DiscoveredNetworkDevice>,
+    useShortDeviceNames: boolean | undefined,
+  ): NetworkDeviceDiscoveryScan {
+    const value: NetworkDeviceDiscoveryScan = scan(hosts);
+    if (useShortDeviceNames !== undefined) {
+      value.useShortDeviceNames = useShortDeviceNames;
+    }
+    return value;
+  }
+
+  test("a scan set to short names shows the short name, with the FQDN beside the address", async () => {
+    getItemSpy.mockResolvedValue(scanNaming([namedHost("10.0.0.1")], true));
+    await renderPage();
+    await openReview(scanNaming([namedHost("10.0.0.1")], true));
+
+    expect(screen.getByText("core-gw")).toBeInTheDocument();
+    expect(screen.getByText("core-gw")).toHaveAttribute("title", "core-gw");
+    expect(screen.getByText(FQDN, { exact: false })).toBeInTheDocument();
+    expect(checkbox("10.0.0.1")).toHaveAttribute(
+      "aria-label",
+      "Import core-gw (10.0.0.1)",
+    );
+  });
+
+  test("a scan set to short names imports the short name and keeps the FQDN as the DNS name", async () => {
+    getItemSpy.mockResolvedValue(scanNaming([namedHost("10.0.0.1")], true));
+    await renderPage();
+    await openReview(scanNaming([namedHost("10.0.0.1")], true));
+    await importSelected();
+
+    expect(createSpy).toHaveBeenCalledTimes(1);
+
+    const device: NetworkDevice = createSpy.mock.calls[0]![0].model;
+
+    expect(device.name).toBe("core-gw");
+    expect(device.dnsName).toBe(FQDN);
+    expect(device.hostname).toBe("10.0.0.1");
+  });
+
+  test("a scan that did not ask imports the full name, and still keeps the DNS name", async () => {
+    for (const flag of [false, undefined]) {
+      createSpy.mockClear();
+      cleanup();
+      capturedTable = null;
+      getItemSpy.mockResolvedValue(scanNaming([namedHost("10.0.0.1")], flag));
+      await renderPage();
+      await openReview(scanNaming([namedHost("10.0.0.1")], flag));
+
+      expect(checkbox("10.0.0.1")).toHaveAttribute(
+        "aria-label",
+        `Import ${FQDN} (10.0.0.1)`,
+      );
+
+      await importSelected();
+
+      const device: NetworkDevice = createSpy.mock.calls[0]![0].model;
+
+      expect(device.name).toBe(FQDN);
+      expect(device.dnsName).toBe(FQDN);
+    }
+  });
+
+  /*
+   * The choice is read off the FRESH scan, not the table row the dialog was
+   * opened from. The operator may have switched short names on in the Edit
+   * dialog (or another tab) since the list loaded; the review is what they
+   * are about to import, so it has to name hosts the way the scan says now.
+   */
+  test("the fresh read decides the naming, not the stale table row", async () => {
+    getItemSpy.mockResolvedValue(scanNaming([namedHost("10.0.0.1")], true));
+    await renderPage();
+    await openReview(scanNaming([namedHost("10.0.0.1")], false));
+    await importSelected();
+
+    expect(createSpy.mock.calls[0]![0].model.name).toBe("core-gw");
+  });
+
+  test("a short name that is already taken is retried as the short name plus the address", async () => {
+    /*
+     * Short names collide more than FQDNs do — "core-gw" in two domains is one
+     * name. The first create fails on the duplicate; the retry must build from
+     * the same naming choice.
+     */
+    createSpy
+      .mockRejectedValueOnce(
+        new Error("Network Device with the same name already exists"),
+      )
+      .mockResolvedValueOnce(undefined);
+    getItemSpy.mockResolvedValue(scanNaming([namedHost("10.0.0.1")], true));
+    await renderPage();
+    await openReview(scanNaming([namedHost("10.0.0.1")], true));
+    await importSelected();
+
+    expect(createSpy).toHaveBeenCalledTimes(2);
+
+    /*
+     * The page retries with the SAME device object, renamed — so both calls
+     * hold it and both now read the final name. What distinguishes the retry
+     * is that it happened, and what it was renamed to.
+     */
+    const device: NetworkDevice = createSpy.mock.calls[1]![0].model;
+
+    expect(device.name).toBe("core-gw (10.0.0.1)");
+    expect(device.dnsName).toBe(FQDN);
+  });
+
+  test("two hosts whose short names collide both import", async () => {
+    const taken: Set<string> = new Set<string>();
+
+    createSpy.mockImplementation(
+      async (args: { model: NetworkDevice }): Promise<undefined> => {
+        const name: string = String(args.model.name);
+
+        if (taken.has(name)) {
+          throw new Error("Network Device with the same name already exists");
+        }
+
+        taken.add(name);
+        return undefined;
+      },
+    );
+
+    const hosts: Array<DiscoveredNetworkDevice> = [
+      namedHost("10.0.0.1", "web.corp.example.com"),
+      namedHost("10.0.0.2", "web.lab.example.com"),
+    ];
+
+    getItemSpy.mockResolvedValue(scanNaming(hosts, true));
+    await renderPage();
+    await openReview(scanNaming(hosts, true));
+    await importSelected();
+
+    expect(Array.from(taken)).toEqual(["web", "web (10.0.0.2)"]);
+  });
+});
+
+/*
+ * OneUptime issue #3677, end to end through the page's real review and import
+ * handlers: a host with no SNMP and no PTR record, which the probe named by
+ * asking it over NetBIOS, is shown under that name with a plain "NetBIOS name"
+ * hint beside its address, and imports under that name.
+ *
+ * The name is self-reported by the host, so it is never stored as the
+ * device's DNS name — `dnsName` means "a record in DNS says so", and that is
+ * the one thing a NetBIOS answer is not.
+ */
+describe("Discovery review names a host by its NetBIOS answer when nothing else names it", () => {
+  function netbiosHost(
+    ipAddress: string,
+    netbiosName: string,
+  ): DiscoveredNetworkDevice {
+    return { ...host(ipAddress, false), netbiosName };
+  }
+
+  test("the row shows the NetBIOS name, and says beside the address where it came from", async () => {
+    getItemSpy.mockResolvedValue(
+      scan([netbiosHost("10.0.0.1", "accounts-pc01")]),
+    );
+    await renderPage();
+    await openReview(scan([netbiosHost("10.0.0.1", "accounts-pc01")]));
+
+    expect(screen.getByText("accounts-pc01")).toHaveAttribute(
+      "title",
+      "accounts-pc01",
+    );
+    expect(checkbox("10.0.0.1")).toHaveAttribute(
+      "aria-label",
+      "Import accounts-pc01 (10.0.0.1)",
+    );
+
+    const hint: HTMLElement = screen.getByText(/NetBIOS name/);
+
+    expect(hint.tagName).toBe("SPAN");
+    // Beside the address, on the address line — not a badge elsewhere.
+    expect(hint.parentElement).toHaveTextContent("10.0.0.1 · NetBIOS name");
+    expect(hint.getAttribute("title") || "").toContain(
+      "reported this name itself",
+    );
+  });
+
+  test("a host with only a NetBIOS name imports under it, with no DNS name", async () => {
+    getItemSpy.mockResolvedValue(
+      scan([netbiosHost("10.0.0.1", "accounts-pc01")]),
+    );
+    await renderPage();
+    await openReview(scan([netbiosHost("10.0.0.1", "accounts-pc01")]));
+    await importSelected();
+
+    expect(createSpy).toHaveBeenCalledTimes(1);
+
+    const device: NetworkDevice = createSpy.mock.calls[0]![0].model;
+
+    expect(device.name).toBe("accounts-pc01");
+    expect(device.hostname).toBe("10.0.0.1");
+    expect(device.dnsName).toBeUndefined();
+  });
+
+  test("the short-name option imports a NetBIOS name unchanged", async () => {
+    const value: NetworkDeviceDiscoveryScan = scan([
+      netbiosHost("10.0.0.1", "accounts-pc01"),
+    ]);
+    value.useShortDeviceNames = true;
+    getItemSpy.mockResolvedValue(value);
+    await renderPage();
+    await openReview(value);
+
+    expect(screen.getByText(/NetBIOS name/)).toBeInTheDocument();
+
+    await importSelected();
+
+    const device: NetworkDevice = createSpy.mock.calls[0]![0].model;
+
+    expect(device.name).toBe("accounts-pc01");
+    expect(device.dnsName).toBeUndefined();
+  });
+
+  test("a host DNS names carries no NetBIOS hint, and imports under its DNS name", async () => {
+    getItemSpy.mockResolvedValue(
+      scan([
+        {
+          ...netbiosHost("10.0.0.1", "accounts-pc01"),
+          dnsHostname: "core-gw.corp.example.com",
+        },
+      ]),
+    );
+    await renderPage();
+    await openReview(scan([]));
+
+    expect(screen.getByText("core-gw.corp.example.com")).toBeInTheDocument();
+    expect(screen.queryByText(/NetBIOS name/)).not.toBeInTheDocument();
+
+    await importSelected();
+
+    const device: NetworkDevice = createSpy.mock.calls[0]![0].model;
+
+    expect(device.name).toBe("core-gw.corp.example.com");
+    expect(device.dnsName).toBe("core-gw.corp.example.com");
+  });
+
+  test("a NetBIOS answer the rules reject leaves the host on its address, with no hint", async () => {
+    getItemSpy.mockResolvedValue(
+      scan([netbiosHost("10.0.0.1", "<img src=x onerror=alert(1)>")]),
+    );
+    await renderPage();
+    await openReview(scan([]));
+
+    expect(checkbox("10.0.0.1")).toHaveAttribute(
+      "aria-label",
+      "Import 10.0.0.1 (10.0.0.1)",
+    );
+    expect(screen.queryByText(/NetBIOS name/)).not.toBeInTheDocument();
+    expect(screen.queryByText(/onerror/)).not.toBeInTheDocument();
+
+    await importSelected();
+
+    expect(createSpy.mock.calls[0]![0].model.name).toBe("10.0.0.1");
+  });
+});
+
 describe("Discovery review waits for a successful current response", () => {
   test("does not expose stale selection or import while the inventory read is pending", async () => {
     const pending: Deferred<NetworkDeviceDiscoveryScan | null> = deferred();

package/Tests/App/Dashboard/DiscoveryScanEditForm.test.tsx

@@ -287,6 +287,21 @@ describe("Editing a discovery scan after it was created", () => {
    * this dialog was built to end, one field further along. Asserted as an
    * exact list rather than a set of `toContain` calls, so a tenth flat field
    * creeping back onto the wizard fails here too.
+   *
+   * `useShortDeviceNames` (OneUptime issue #3678) belongs here as much as the
+   * method does. The scans that most need it are the ones that already exist
+   * and already import "wb-0660-kds01.wbhq.com", and a choice that could only
+   * be made at creation would send the operator straight back to deleting and
+   * recreating them.
+   *
+   * `isNetbiosLookupEnabled` (OneUptime issue #3677) belongs here for the
+   * opposite reason as well. Every scan that predates it stores OFF, so this
+   * dialog is the only way an existing scan can opt in — and an operator whose
+   * IDS starts flagging NBSTAT queries on a scan created with it on needs a way
+   * to turn it off that is not deleting the scan. Being a declared field is
+   * also what makes the dialog LOAD the stored value: ModelForm selects exactly
+   * the declared fields, and the create wizard's default of on applies only to
+   * a value that is undefined, never to a stored false.
    */
   test("offers every setting the create wizard collects", async () => {
     await openEditDialog();
@@ -302,6 +317,8 @@ describe("Editing a discovery scan after it was created", () => {
       "cidr",
       "probe",
       "isSnmpEnabled",
+      "isNetbiosLookupEnabled",
+      "useShortDeviceNames",
       "snmpConfigs",
       "isRecurring",
       "rescanIntervalInMinutes",
@@ -667,6 +684,76 @@ describe("Editing a discovery scan after it was created", () => {
      * questions the step asks would read as one.
      */
     expect(editFieldNamed("isSnmpEnabled").sectionTitle).toBe("What to check");
+
+    /*
+     * The same holds for the naming toggle (issue #3678): it opens its own
+     * "Device names" group inside the Scan Target step, so it must keep that
+     * heading rather than being folded under "What to check" or promoted to a
+     * second "Scan Target".
+     */
+    expect(editFieldNamed("useShortDeviceNames").sectionTitle).toBe(
+      "Device names",
+    );
+    expect(headings).toContain("Device names");
+
+    /*
+     * The NetBIOS lookup (issue #3677) is the opposite case: it carries NO
+     * heading, so it reads as the second question under "What to check" — it
+     * is something the probe sends — rather than opening a group, or being
+     * swallowed by "Device names", which sends nothing.
+     */
+    expect(editFieldNamed("isNetbiosLookupEnabled").sectionTitle).toBe(
+      undefined,
+    );
+    expect(editFieldKeys().indexOf("isNetbiosLookupEnabled")).toBe(
+      editFieldKeys().indexOf("isSnmpEnabled") + 1,
+    );
+  });
+
+  /*
+   * The naming choice is not a sweep setting: flipping it keeps the last run's
+   * hosts, and the Review dialog simply names them differently the next time it
+   * opens. The warning about what re-runs the scan has to say so, or an
+   * operator who only wants short names reads "re-runs the scan" and hesitates
+   * to save a change that costs nothing.
+   */
+  test("says that switching short device names leaves the results alone", async () => {
+    await openEditDialog();
+
+    const { container } = render(
+      <MemoryRouter>{capturedModalProps?.footer}</MemoryRouter>,
+    );
+
+    expect(container.textContent || "").toContain(
+      "whether devices get short names, leaves the results alone",
+    );
+  });
+
+  /*
+   * The NetBIOS lookup (issue #3677) is not a sweep column either, so saving it
+   * keeps the results — but, unlike short names, it changes what the PROBE
+   * asks, so the stored hosts gain no NetBIOS names until the scan runs again.
+   * Both halves are said: without the first the operator hesitates to save a
+   * change that costs nothing, and without the second they turn it on, reopen
+   * Review Results to the same bare addresses, and conclude it does not work.
+   */
+  test("says that switching NetBIOS lookup keeps the results and applies from the next run", async () => {
+    await openEditDialog();
+
+    const { container } = render(
+      <MemoryRouter>{capturedModalProps?.footer}</MemoryRouter>,
+    );
+    const warning: string = container.textContent || "";
+
+    expect(warning).toContain(
+      "Turning NetBIOS name lookup on or off leaves them alone too",
+    );
+    expect(warning).toContain("applies from the next time the scan runs");
+    // ...and it is not listed among the changes that re-run the scan.
+    expect(warning).toContain(
+      "Changing the target, probe or credentials re-runs the scan",
+    );
+    expect(warning).not.toMatch(/NetBIOS[^.]*re-runs the scan/);
   });
 
   /*