@oneuptime/common 12.0.32 → 12.0.34

package/Tests/Utils/HTTPResponseBodyReader.test.ts

@@ -0,0 +1,323 @@
+import { describe, expect, test } from "@jest/globals";
+import BadDataException from "../../Types/Exception/BadDataException";
+import HTTPResponseBodyReader, {
+  HTTPResponseBodyBudget,
+} from "../../Utils/HTTPResponseBodyReader";
+import { Readable } from "stream";
+
+const read: (
+  body: AsyncIterable<unknown>,
+  budget: HTTPResponseBodyBudget,
+  options?: {
+    statusCode?: number;
+    limitRedirectResponseBody?: boolean;
+    headers?: unknown;
+    isHeadResponse?: boolean;
+    maximumResponseBytes?: number;
+  },
+) => Promise<Buffer> = async (
+  body: AsyncIterable<unknown>,
+  budget: HTTPResponseBodyBudget,
+  options: {
+    statusCode?: number;
+    limitRedirectResponseBody?: boolean;
+    headers?: unknown;
+    isHeadResponse?: boolean;
+    maximumResponseBytes?: number;
+  } = {},
+): Promise<Buffer> => {
+  return await HTTPResponseBodyReader.read(body, {
+    budget: budget,
+    statusCode: options.statusCode ?? 200,
+    limitRedirectResponseBody: options.limitRedirectResponseBody ?? true,
+    headers: options.headers,
+    isHeadResponse: options.isHeadResponse,
+    maximumResponseBytes: options.maximumResponseBytes,
+  });
+};
+
+describe("HTTPResponseBodyReader", () => {
+  test("charges sequential responses against one cumulative byte budget", async () => {
+    const budget: HTTPResponseBodyBudget = new HTTPResponseBodyBudget(6);
+
+    await expect(
+      read(Readable.from([Buffer.from("abc")]), budget),
+    ).resolves.toEqual(Buffer.from("abc"));
+    expect(budget.remainingBytes).toBe(3);
+
+    await expect(
+      read(Readable.from([Buffer.from("de")]), budget),
+    ).resolves.toEqual(Buffer.from("de"));
+    expect(budget.remainingBytes).toBe(1);
+
+    await expect(
+      read(Readable.from([Buffer.from("fg")]), budget),
+    ).rejects.toBeInstanceOf(BadDataException);
+  });
+
+  test.each([301, 302, 303, 307, 308])(
+    "applies the smaller redirect cap to status %s",
+    async (statusCode: number) => {
+      const budget: HTTPResponseBodyBudget = new HTTPResponseBodyBudget(100, 4);
+      const body: Readable = Readable.from([Buffer.from("12345")]);
+
+      await expect(
+        read(body, budget, {
+          statusCode: statusCode,
+          limitRedirectResponseBody: true,
+        }),
+      ).rejects.toThrow("exceeded the allowed size");
+      expect(body.destroyed).toBe(true);
+    },
+  );
+
+  test("allows a redirect body to use the full budget when redirects are not followed", async () => {
+    const budget: HTTPResponseBodyBudget = new HTTPResponseBodyBudget(10, 4);
+
+    await expect(
+      read(Readable.from([Buffer.from("12345")]), budget, {
+        statusCode: 302,
+        limitRedirectResponseBody: false,
+      }),
+    ).resolves.toEqual(Buffer.from("12345"));
+    expect(budget.remainingBytes).toBe(5);
+  });
+
+  test("accepts a redirect body exactly at its smaller cap and charges the shared budget", async () => {
+    const budget: HTTPResponseBodyBudget = new HTTPResponseBodyBudget(10, 4);
+
+    await expect(
+      read(Readable.from([Buffer.from("1234")]), budget, {
+        statusCode: 308,
+        limitRedirectResponseBody: true,
+      }),
+    ).resolves.toEqual(Buffer.from("1234"));
+    expect(budget.remainingBytes).toBe(6);
+  });
+
+  test("enforces a caller-specific per-response cap while charging the shared budget", async () => {
+    const budget: HTTPResponseBodyBudget = new HTTPResponseBodyBudget(100);
+    const body: Readable = Readable.from([Buffer.from("12345")]);
+
+    await expect(
+      read(body, budget, {
+        limitRedirectResponseBody: false,
+        maximumResponseBytes: 4,
+      }),
+    ).rejects.toThrow("exceeded the allowed size");
+    expect(body.destroyed).toBe(true);
+    expect(budget.remainingBytes).toBe(95);
+  });
+
+  test("counts UTF-8 bytes rather than JavaScript characters", async () => {
+    const budget: HTTPResponseBodyBudget = new HTTPResponseBodyBudget(2);
+
+    await expect(
+      read(Readable.from([Buffer.from("é")]), budget),
+    ).resolves.toEqual(Buffer.from("é"));
+    expect(budget.remainingBytes).toBe(0);
+  });
+
+  test("rejects an oversized Content-Length before reading the stream", async () => {
+    const budget: HTTPResponseBodyBudget = new HTTPResponseBodyBudget(4);
+    const body: Readable = Readable.from([Buffer.from("data")]);
+
+    await expect(
+      read(body, budget, {
+        headers: { "Content-Length": "5" },
+      }),
+    ).rejects.toThrow("exceeded the allowed size");
+    expect(body.destroyed).toBe(true);
+    expect(budget.remainingBytes).toBe(4);
+  });
+
+  test("ignores hypothetical Content-Length on HEAD while still counting actual bytes", async () => {
+    const emptyBudget: HTTPResponseBodyBudget = new HTTPResponseBodyBudget(4);
+
+    await expect(
+      read(Readable.from([]), emptyBudget, {
+        headers: { "Content-Length": "1000000" },
+        isHeadResponse: true,
+      }),
+    ).resolves.toEqual(Buffer.alloc(0));
+    expect(emptyBudget.remainingBytes).toBe(4);
+
+    const nonCompliantBudget: HTTPResponseBodyBudget =
+      new HTTPResponseBodyBudget(4);
+    await expect(
+      read(Readable.from([Buffer.from("12345")]), nonCompliantBudget, {
+        headers: { "Content-Length": "1000000" },
+        isHeadResponse: true,
+      }),
+    ).rejects.toBeInstanceOf(BadDataException);
+    expect(nonCompliantBudget.remainingBytes).toBe(0);
+  });
+
+  test.each([204, 304])(
+    "ignores hypothetical Content-Length on bodyless status %s while still counting actual bytes",
+    async (statusCode: number) => {
+      const emptyBudget: HTTPResponseBodyBudget = new HTTPResponseBodyBudget(4);
+
+      await expect(
+        read(Readable.from([]), emptyBudget, {
+          statusCode: statusCode,
+          headers: { "Content-Length": "1000000" },
+        }),
+      ).resolves.toEqual(Buffer.alloc(0));
+      expect(emptyBudget.remainingBytes).toBe(4);
+
+      const nonCompliantBudget: HTTPResponseBodyBudget =
+        new HTTPResponseBodyBudget(4);
+      await expect(
+        read(Readable.from([Buffer.from("12345")]), nonCompliantBudget, {
+          statusCode: statusCode,
+          headers: { "Content-Length": "1000000" },
+        }),
+      ).rejects.toBeInstanceOf(BadDataException);
+      expect(nonCompliantBudget.remainingBytes).toBe(0);
+    },
+  );
+
+  test("supports Axios-style headers with a get method", async () => {
+    const budget: HTTPResponseBodyBudget = new HTTPResponseBodyBudget(4);
+    const body: Readable = Readable.from([Buffer.from("data")]);
+
+    await expect(
+      read(body, budget, {
+        headers: {
+          get: (name: string): string | undefined => {
+            return name === "content-length" ? "5" : undefined;
+          },
+        },
+      }),
+    ).rejects.toBeInstanceOf(BadDataException);
+    expect(body.destroyed).toBe(true);
+  });
+
+  test("uses the first Content-Length value when a header collection returns an array", async () => {
+    const budget: HTTPResponseBodyBudget = new HTTPResponseBodyBudget(4);
+    const body: Readable = Readable.from([Buffer.from("data")]);
+
+    await expect(
+      read(body, budget, {
+        headers: { "content-length": ["5", "4"] },
+      }),
+    ).rejects.toThrow("exceeded the allowed size");
+    expect(body.destroyed).toBe(true);
+    expect(budget.remainingBytes).toBe(4);
+  });
+
+  test.each(["not-a-number", "-1", Number.POSITIVE_INFINITY])(
+    "ignores an invalid Content-Length value (%s) and enforces the stream itself",
+    async (contentLength: string | number) => {
+      const budget: HTTPResponseBodyBudget = new HTTPResponseBodyBudget(4);
+
+      await expect(
+        read(Readable.from([Buffer.from("data")]), budget, {
+          headers: { "content-length": contentLength },
+        }),
+      ).resolves.toEqual(Buffer.from("data"));
+      expect(budget.remainingBytes).toBe(0);
+    },
+  );
+
+  test("destroys a chunked stream as soon as it exceeds the remaining budget", async () => {
+    const budget: HTTPResponseBodyBudget = new HTTPResponseBodyBudget(4);
+    const body: Readable = Readable.from([
+      Buffer.from("12"),
+      Buffer.from("345"),
+      Buffer.from("unread"),
+    ]);
+
+    await expect(read(body, budget)).rejects.toBeInstanceOf(BadDataException);
+    expect(body.destroyed).toBe(true);
+    expect(budget.remainingBytes).toBe(0);
+  });
+
+  test("charges bytes received before the source stream fails", async () => {
+    const budget: HTTPResponseBodyBudget = new HTTPResponseBodyBudget(20);
+    let nextCallCount: number = 0;
+    const body: AsyncIterable<Buffer> = {
+      [Symbol.asyncIterator](): AsyncIterator<Buffer> {
+        return {
+          next: (): Promise<IteratorResult<Buffer>> => {
+            nextCallCount++;
+            if (nextCallCount === 1) {
+              return Promise.resolve({
+                done: false,
+                value: Buffer.from("partial"),
+              });
+            }
+
+            return Promise.reject(new Error("socket reset while reading"));
+          },
+        };
+      },
+    };
+
+    await expect(read(body, budget)).rejects.toThrow(
+      "socket reset while reading",
+    );
+    expect(budget.remainingBytes).toBe(13);
+  });
+
+  test("rejects a new response after the shared budget is exactly exhausted", async () => {
+    const budget: HTTPResponseBodyBudget = new HTTPResponseBodyBudget(4);
+    await read(Readable.from([Buffer.from("data")]), budget);
+    const rejectedBody: Readable = Readable.from([Buffer.alloc(0)]);
+
+    await expect(read(rejectedBody, budget)).rejects.toThrow("cumulative size");
+    expect(rejectedBody.destroyed).toBe(true);
+  });
+
+  test("rejects a non-stream body in budgeted mode", async () => {
+    await expect(
+      HTTPResponseBodyReader.read("not-a-stream", {
+        budget: new HTTPResponseBodyBudget(10),
+        statusCode: 200,
+        limitRedirectResponseBody: true,
+      }),
+    ).rejects.toThrow("could not be read");
+  });
+
+  test.each([Number.NaN, Number.POSITIVE_INFINITY, Number.NEGATIVE_INFINITY])(
+    "fails closed for a non-finite constructor limit (%s)",
+    async (invalidLimit: number) => {
+      const budget: HTTPResponseBodyBudget = new HTTPResponseBodyBudget(
+        invalidLimit,
+        invalidLimit,
+      );
+
+      expect(budget.remainingBytes).toBe(0);
+      expect(budget.maxRedirectResponseBytes).toBe(0);
+      await expect(
+        read(Readable.from([Buffer.alloc(0)]), budget),
+      ).rejects.toThrow("cumulative size");
+    },
+  );
+
+  test("clamps negative constructor limits and refuses any response", async () => {
+    const budget: HTTPResponseBodyBudget = new HTTPResponseBodyBudget(-10, -1);
+
+    expect(budget.remainingBytes).toBe(0);
+    expect(budget.maxRedirectResponseBytes).toBe(0);
+    await expect(
+      read(Readable.from([Buffer.alloc(0)]), budget),
+    ).rejects.toThrow("cumulative size");
+  });
+
+  test("rejects invalid direct budget consumption without changing the balance", () => {
+    const budget: HTTPResponseBodyBudget = new HTTPResponseBodyBudget(10);
+
+    expect(() => {
+      budget.consume(-1);
+    }).toThrow("cumulative size");
+    expect(() => {
+      budget.consume(11);
+    }).toThrow("cumulative size");
+    expect(() => {
+      budget.consume(Number.NaN);
+    }).toThrow("cumulative size");
+    expect(budget.remainingBytes).toBe(10);
+  });
+});

package/Tests/Utils/Monitor/MonitorMetricType.test.ts

@@ -1,9 +1,20 @@
 import AggregationType from "../../../Types/BaseDatabase/AggregationType";
-import { CheckOn } from "../../../Types/Monitor/CriteriaFilter";
+import {
+  CheckOn,
+  CriteriaFilter,
+  FilterType,
+} from "../../../Types/Monitor/CriteriaFilter";
+import {
+  DatabaseMetricCategory,
+  DatabaseMetricDefinition,
+  getAllDatabaseMetrics,
+  getDatabaseMetricsForEngine,
+} from "../../../Types/Monitor/DatabaseMetricCatalog";
 import MonitorMetricType from "../../../Types/Monitor/MonitorMetricType";
 import MonitorType, {
   MonitorTypeHelper,
 } from "../../../Types/Monitor/MonitorType";
+import SqlDatabaseType from "../../../Types/Monitor/SqlDatabaseType";
 import MonitorMetricTypeUtil, {
   MonitorMetricCategory,
 } from "../../../Utils/Monitor/MonitorMetricType";
@@ -478,3 +489,271 @@ describe("getMonitorMetricTypeByCheckOnOrNull", () => {
     }).toThrow();
   });
 });
+
+/*
+ * Database Health declares its ~40 series in DatabaseMetricCatalog rather
+ * than in the five metadata switches in this util; a short prelude in each
+ * switch resolves them. A prelude that is missing does not throw - it
+ * renders a chart with a blank legend, no unit, or the wrong aggregation.
+ * These sweep the whole catalog through the public lookups so a metric can
+ * never end up half-wired.
+ */
+describe("Database Health metric metadata", () => {
+  const catalog: Array<DatabaseMetricDefinition> = getAllDatabaseMetrics();
+
+  test("every catalog metric resolves its display metadata", () => {
+    for (const metric of catalog) {
+      expect(
+        MonitorMetricTypeUtil.getTitleByMonitorMetricType(metric.metricType),
+      ).toBe(metric.friendlyName);
+      expect(
+        MonitorMetricTypeUtil.getLegendByMonitorMetricType(metric.metricType),
+      ).toBe(metric.friendlyName);
+      expect(
+        MonitorMetricTypeUtil.getLegendUnitByMonitorMetricType(
+          metric.metricType,
+        ),
+      ).toBe(metric.unit);
+      expect(
+        MonitorMetricTypeUtil.getDescriptionByMonitorMetricType(
+          metric.metricType,
+        ).length,
+      ).toBeGreaterThan(0);
+    }
+  });
+
+  test("every catalog metric aggregates the way the catalog says", () => {
+    for (const metric of catalog) {
+      expect(
+        MonitorMetricTypeUtil.getAggregationTypeByMonitorMetricType(
+          metric.metricType,
+        ),
+      ).toBe(metric.defaultAggregation);
+    }
+  });
+
+  /*
+   * The preludes run before the switches, so a catalog row that ever matched
+   * a shared series would rewrite the metadata of every monitor type using
+   * it, not just Database Health.
+   */
+  test("the catalog does not shadow the shared probe series", () => {
+    expect(
+      MonitorMetricTypeUtil.getLegendUnitByMonitorMetricType(
+        MonitorMetricType.ResponseTime,
+      ),
+    ).toBe("ms");
+    expect(
+      MonitorMetricTypeUtil.getAggregationTypeByMonitorMetricType(
+        MonitorMetricType.IsOnline,
+      ),
+    ).toBe(AggregationType.Min);
+  });
+});
+
+describe("Database Health metric lists and cards", () => {
+  const catalog: Array<DatabaseMetricDefinition> = getAllDatabaseMetrics();
+
+  test("Database exposes availability plus every catalog series", () => {
+    const metrics: Array<MonitorMetricType> =
+      MonitorMetricTypeUtil.getMonitorMetricTypesByMonitorType(
+        MonitorType.Database,
+      );
+
+    expect(metrics[0]).toBe(MonitorMetricType.IsOnline);
+    expect(metrics[1]).toBe(MonitorMetricType.ResponseTime);
+
+    for (const metric of catalog) {
+      expect(metrics).toContain(metric.metricType);
+    }
+
+    expect(metrics.length).toBe(catalog.length + 2);
+  });
+
+  test("with no engine chosen the cards show the full capability set", () => {
+    const categories: Array<MonitorMetricCategory> =
+      MonitorMetricTypeUtil.getDatabaseMetricCategories();
+
+    const shown: Array<MonitorMetricType> = categories.flatMap(
+      (category: MonitorMetricCategory) => {
+        return category.metrics;
+      },
+    );
+
+    for (const metric of catalog) {
+      expect(shown).toContain(metric.metricType);
+    }
+  });
+
+  /*
+   * A card of permanently empty charts is worse than no card: it reads as a
+   * broken monitor rather than as an engine that does not report the data.
+   */
+  test("a MySQL monitor drops the cards its engine can never fill", () => {
+    const mysqlMetrics: Array<MonitorMetricType> = getDatabaseMetricsForEngine(
+      SqlDatabaseType.MySQL,
+    ).map((metric: DatabaseMetricDefinition) => {
+      return metric.metricType;
+    });
+
+    const categories: Array<MonitorMetricCategory> =
+      MonitorMetricTypeUtil.getDatabaseMetricCategories(SqlDatabaseType.MySQL);
+
+    const titles: Array<string> = categories.map(
+      (category: MonitorMetricCategory) => {
+        return category.title;
+      },
+    );
+
+    // Every PostgreSQL-only vacuum and wraparound metric lives on this card.
+    expect(titles).not.toContain(DatabaseMetricCategory.Maintenance);
+
+    for (const category of categories) {
+      expect(category.title.length).toBeGreaterThan(0);
+      expect(category.description.length).toBeGreaterThan(0);
+      expect(category.metrics.length).toBeGreaterThan(0);
+
+      for (const metric of category.metrics) {
+        if (
+          metric === MonitorMetricType.IsOnline ||
+          metric === MonitorMetricType.ResponseTime
+        ) {
+          continue;
+        }
+
+        expect(mysqlMetrics).toContain(metric);
+      }
+    }
+  });
+
+  test("PostgreSQL keeps the maintenance card", () => {
+    const categories: Array<MonitorMetricCategory> =
+      MonitorMetricTypeUtil.getDatabaseMetricCategories(
+        SqlDatabaseType.PostgreSQL,
+      );
+
+    const titles: Array<string> = categories.map(
+      (category: MonitorMetricCategory) => {
+        return category.title;
+      },
+    );
+
+    expect(titles).toContain(DatabaseMetricCategory.Maintenance);
+  });
+
+  /*
+   * Availability carries the shared probe series on top of its catalog
+   * metrics, so it is the one card that must render whatever the engine.
+   */
+  test("availability is the first card on every engine", () => {
+    for (const engine of [
+      SqlDatabaseType.PostgreSQL,
+      SqlDatabaseType.MySQL,
+      SqlDatabaseType.MicrosoftSqlServer,
+    ]) {
+      const categories: Array<MonitorMetricCategory> =
+        MonitorMetricTypeUtil.getDatabaseMetricCategories(engine);
+
+      expect(categories[0]?.title).toBe(DatabaseMetricCategory.Availability);
+      expect(categories[0]?.metrics).toContain(MonitorMetricType.IsOnline);
+      expect(categories[0]?.metrics).toContain(MonitorMetricType.ResponseTime);
+    }
+  });
+
+  test("the monitor type routes through the database cards", () => {
+    expect(
+      MonitorMetricTypeUtil.getMonitorMetricCategoriesByMonitorType(
+        MonitorType.Database,
+        SqlDatabaseType.MySQL,
+      ),
+    ).toEqual(
+      MonitorMetricTypeUtil.getDatabaseMetricCategories(SqlDatabaseType.MySQL),
+    );
+  });
+});
+
+/*
+ * Database Health filters name their series in databaseMonitorOptions rather
+ * than in the CheckOn, because one CheckOn covers all 40. Resolving from the
+ * CheckOn alone returns null, which turns "evaluate over time" back into an
+ * instantaneous comparison while the UI still offers the toggle - so
+ * EvaluateOverTime has to ask with the whole filter.
+ */
+describe("getMonitorMetricTypeByCriteriaFilterOrNull", () => {
+  const buildFilter: (filter: Partial<CriteriaFilter>) => CriteriaFilter = (
+    filter: Partial<CriteriaFilter>,
+  ): CriteriaFilter => {
+    return {
+      checkOn: CheckOn.DatabaseMetric,
+      filterType: FilterType.GreaterThan,
+      value: "90",
+      ...filter,
+    };
+  };
+
+  test("resolves the series a database metric filter names", () => {
+    for (const metric of getAllDatabaseMetrics()) {
+      expect(
+        MonitorMetricTypeUtil.getMonitorMetricTypeByCriteriaFilterOrNull(
+          buildFilter({
+            databaseMonitorOptions: { metricType: metric.metricType },
+          }),
+        ),
+      ).toBe(metric.metricType);
+    }
+  });
+
+  test("returns null when the filter names no series", () => {
+    expect(
+      MonitorMetricTypeUtil.getMonitorMetricTypeByCriteriaFilterOrNull(
+        buildFilter({}),
+      ),
+    ).toBeNull();
+    expect(
+      MonitorMetricTypeUtil.getMonitorMetricTypeByCriteriaFilterOrNull(
+        buildFilter({ databaseMonitorOptions: {} }),
+      ),
+    ).toBeNull();
+  });
+
+  test("the database online check reads the shared online series", () => {
+    expect(
+      MonitorMetricTypeUtil.getMonitorMetricTypeByCriteriaFilterOrNull(
+        buildFilter({
+          checkOn: CheckOn.DatabaseIsOnline,
+          filterType: FilterType.True,
+          value: undefined,
+        }),
+      ),
+    ).toBe(MonitorMetricType.IsOnline);
+  });
+
+  test("collection errors are text, not a series", () => {
+    expect(
+      MonitorMetricTypeUtil.getMonitorMetricTypeByCriteriaFilterOrNull(
+        buildFilter({
+          checkOn: CheckOn.DatabaseCollectionError,
+          filterType: FilterType.IsNotEmpty,
+          value: undefined,
+        }),
+      ),
+    ).toBeNull();
+  });
+
+  test("every other CheckOn still resolves the way it always did", () => {
+    for (const checkOn of [
+      CheckOn.CPUUsagePercent,
+      CheckOn.ResponseTime,
+      CheckOn.DnsIsOnline,
+      CheckOn.JavaScriptExpression,
+    ]) {
+      expect(
+        MonitorMetricTypeUtil.getMonitorMetricTypeByCriteriaFilterOrNull(
+          buildFilter({ checkOn: checkOn }),
+        ),
+      ).toBe(
+        MonitorMetricTypeUtil.getMonitorMetricTypeByCheckOnOrNull(checkOn),
+      );
+    }
+  });
+});

package/Tests/Utils/Monitor/MonitorSummarySnapshotUtil.test.ts

@@ -98,6 +98,7 @@ const EXPECTED_PAYLOAD_KIND: Record<MonitorType, PayloadKind> = {
   [MonitorType.DNSSEC]: PayloadKind.Probe,
   [MonitorType.Domain]: PayloadKind.Probe,
   [MonitorType.SQLQuery]: PayloadKind.Probe,
+  [MonitorType.Database]: PayloadKind.Probe,
   [MonitorType.ExternalStatusPage]: PayloadKind.Probe,
   /*
    * Not a "probeable" monitor - the device owns its polling schedule - but

package/Tests/Utils/Monitor/NetworkTopologyUtil.test.ts

@@ -188,6 +188,44 @@ describe("NetworkTopologyUtil.buildTopology", () => {
       expect(nodeById(result, "d3")!.status).toBe("unknown");
     });
 
+    /*
+     * Issue #3562: a monitor-backed device is never polled, so its poll
+     * columns are either NULL or whatever a probe last found before it
+     * stopped asking. With nothing stamped yet it is drawn "unknown" — the
+     * device list says the same about the row — rather than red off a
+     * lastSeenAt from before it was switched over from SNMP.
+     */
+    it("a monitor-backed device with nothing stamped is unknown, whatever its leftover poll columns say", () => {
+      const result: TopologyBuildResult = NetworkTopologyUtil.buildTopology(
+        [
+          makeDevice("d1", "switched-from-snmp", {
+            isReachable: undefined,
+            lastPolledAt: undefined,
+            lastSeenAt: outOfContact,
+            monitoringMethod: "Monitor",
+          }),
+          // The same leftovers on a device that IS polled: freshness decides.
+          makeDevice("d2", "still-walked", {
+            isReachable: undefined,
+            lastPolledAt: undefined,
+            lastSeenAt: outOfContact,
+          }),
+          // A mirrored outcome without a stamp is not a verdict either.
+          makeDevice("d3", "mirrored-but-unstamped", {
+            isReachable: true,
+            lastPolledAt: undefined,
+            lastSeenAt: undefined,
+            monitoringMethod: "Monitor",
+          }),
+        ],
+        now,
+      );
+
+      expect(nodeById(result, "d1")!.status).toBe("unknown");
+      expect(nodeById(result, "d2")!.status).toBe("down");
+      expect(nodeById(result, "d3")!.status).toBe("unknown");
+    });
+
     /*
      * Issue #3220: the map drew a whole fleet red because its probe could
      * not get round every device inside the old fixed 15-minute freshness