@oneuptime/common 12.0.4 → 12.0.5

package/Tests/Types/Dashboard/DashboardTemplates.test.ts

@@ -0,0 +1,111 @@
+import {
+  DashboardTemplate,
+  DashboardTemplateCategories,
+  DashboardTemplateCategory,
+  DashboardTemplateType,
+  DashboardTemplates,
+  getDashboardTemplatesByCategory,
+  getTemplateConfig,
+} from "../../../Types/Dashboard/DashboardTemplates";
+import DashboardViewConfig from "../../../Types/Dashboard/DashboardViewConfig";
+import { ObjectType } from "../../../Types/JSON";
+import { describe, expect, test } from "@jest/globals";
+
+describe("DashboardTemplates", () => {
+  test("exposes a non-empty template list", () => {
+    expect(Array.isArray(DashboardTemplates)).toBe(true);
+    expect(DashboardTemplates.length).toBeGreaterThan(0);
+  });
+
+  test("every template has all required non-empty fields", () => {
+    for (const template of DashboardTemplates) {
+      expect(template.name.length).toBeGreaterThan(0);
+      expect(template.description.length).toBeGreaterThan(0);
+      expect(template.icon.length).toBeGreaterThan(0);
+      expect(Object.values(DashboardTemplateType).includes(template.type)).toBe(
+        true,
+      );
+      expect(
+        Object.values(DashboardTemplateCategory).includes(template.category),
+      ).toBe(true);
+    }
+  });
+
+  test("template types are unique", () => {
+    const types: Array<DashboardTemplateType> = DashboardTemplates.map(
+      (t: DashboardTemplate) => {
+        return t.type;
+      },
+    );
+    expect(new Set(types).size).toBe(types.length);
+  });
+
+  test("every template category is one of the declared categories", () => {
+    for (const template of DashboardTemplates) {
+      expect(DashboardTemplateCategories).toContain(template.category);
+    }
+  });
+
+  test("declared categories are unique", () => {
+    expect(new Set(DashboardTemplateCategories).size).toBe(
+      DashboardTemplateCategories.length,
+    );
+  });
+
+  describe("getDashboardTemplatesByCategory", () => {
+    test("returns only templates of the requested category", () => {
+      for (const category of DashboardTemplateCategories) {
+        for (const template of getDashboardTemplatesByCategory(category)) {
+          expect(template.category).toBe(category);
+        }
+      }
+    });
+
+    test("every declared category has at least one template", () => {
+      for (const category of DashboardTemplateCategories) {
+        expect(
+          getDashboardTemplatesByCategory(category).length,
+        ).toBeGreaterThan(0);
+      }
+    });
+
+    test("categories partition the full template list", () => {
+      const totalByCategory: number = DashboardTemplateCategories.reduce(
+        (sum: number, category: DashboardTemplateCategory) => {
+          return sum + getDashboardTemplatesByCategory(category).length;
+        },
+        0,
+      );
+      expect(totalByCategory).toBe(DashboardTemplates.length);
+    });
+  });
+
+  describe("getTemplateConfig", () => {
+    test("returns null for the Blank template", () => {
+      expect(getTemplateConfig(DashboardTemplateType.Blank)).toBeNull();
+    });
+
+    test("returns a well-formed config for every non-Blank type", () => {
+      for (const type of Object.values(DashboardTemplateType)) {
+        if (type === DashboardTemplateType.Blank) {
+          continue;
+        }
+        const config: DashboardViewConfig | null = getTemplateConfig(type);
+        expect(config).not.toBeNull();
+        expect(config!._type).toBe(ObjectType.DashboardViewConfig);
+        expect(Array.isArray(config!.components)).toBe(true);
+        expect(config!.components.length).toBeGreaterThan(0);
+        expect(typeof config!.heightInDashboardUnits).toBe("number");
+        expect(config!.heightInDashboardUnits).toBeGreaterThan(0);
+      }
+    });
+
+    test("handles every enum value without throwing", () => {
+      for (const type of Object.values(DashboardTemplateType)) {
+        expect(() => {
+          return getTemplateConfig(type);
+        }).not.toThrow();
+      }
+    });
+  });
+});

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

@@ -0,0 +1,104 @@
+import {
+  CephMetricCategory,
+  CephMetricDefinition,
+  getAllCephMetricCategories,
+  getAllCephMetrics,
+  getCephMetricById,
+  getCephMetricByMetricName,
+  getCephMetricsByCategory,
+} from "../../../Types/Monitor/CephMetricCatalog";
+import AggregationType from "../../../Types/BaseDatabase/AggregationType";
+import { describe, expect, test } from "@jest/globals";
+
+describe("CephMetricCatalog", () => {
+  const allMetrics: Array<CephMetricDefinition> = getAllCephMetrics();
+  const allCategories: Array<CephMetricCategory> = getAllCephMetricCategories();
+  const validAggregations: Array<string> = Object.values(AggregationType);
+
+  test("returns a non-empty catalog", () => {
+    expect(Array.isArray(allMetrics)).toBe(true);
+    expect(allMetrics.length).toBeGreaterThan(0);
+  });
+
+  test("every metric definition has all required non-empty fields", () => {
+    for (const metric of allMetrics) {
+      expect(typeof metric.id).toBe("string");
+      expect(metric.id.length).toBeGreaterThan(0);
+      expect(metric.friendlyName.length).toBeGreaterThan(0);
+      expect(metric.description.length).toBeGreaterThan(0);
+      expect(metric.metricName.length).toBeGreaterThan(0);
+      expect(metric.category.length).toBeGreaterThan(0);
+    }
+  });
+
+  test("every metric uses a valid aggregation type", () => {
+    for (const metric of allMetrics) {
+      expect(validAggregations).toContain(metric.defaultAggregation);
+    }
+  });
+
+  test("metric ids are unique", () => {
+    const ids: Array<string> = allMetrics.map((m: CephMetricDefinition) => {
+      return m.id;
+    });
+    expect(new Set(ids).size).toBe(ids.length);
+  });
+
+  test("metric names are unique", () => {
+    const names: Array<string> = allMetrics.map((m: CephMetricDefinition) => {
+      return m.metricName;
+    });
+    expect(new Set(names).size).toBe(names.length);
+  });
+
+  test("every metric category is a declared category", () => {
+    for (const metric of allMetrics) {
+      expect(allCategories).toContain(metric.category);
+    }
+  });
+
+  test("declared categories are unique and non-empty", () => {
+    expect(allCategories.length).toBeGreaterThan(0);
+    expect(new Set(allCategories).size).toBe(allCategories.length);
+  });
+
+  test("every declared category has at least one metric", () => {
+    for (const category of allCategories) {
+      expect(getCephMetricsByCategory(category).length).toBeGreaterThan(0);
+    }
+  });
+
+  test("getCephMetricsByCategory returns only metrics of that category", () => {
+    for (const category of allCategories) {
+      for (const metric of getCephMetricsByCategory(category)) {
+        expect(metric.category).toBe(category);
+      }
+    }
+  });
+
+  test("getCephMetricById round-trips every metric", () => {
+    for (const metric of allMetrics) {
+      expect(getCephMetricById(metric.id)).toEqual(metric);
+    }
+  });
+
+  test("getCephMetricById returns undefined for an unknown id", () => {
+    expect(getCephMetricById("does-not-exist")).toBeUndefined();
+    expect(getCephMetricById("")).toBeUndefined();
+  });
+
+  test("getCephMetricByMetricName round-trips every metric", () => {
+    for (const metric of allMetrics) {
+      expect(getCephMetricByMetricName(metric.metricName)).toEqual(metric);
+    }
+  });
+
+  test("getCephMetricByMetricName returns undefined for an unknown name", () => {
+    expect(getCephMetricByMetricName("nope.nope.nope")).toBeUndefined();
+  });
+
+  test("known metrics are present", () => {
+    expect(getCephMetricByMetricName("ceph_health_status")).toBeDefined();
+    expect(getCephMetricByMetricName("ceph_health_detail")).toBeDefined();
+  });
+});

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

@@ -270,6 +270,8 @@ describe("CriteriaFilterUtil", () => {
     test.each([
       CheckOn.ResponseStatusCode,
       CheckOn.ResponseTime,
+      CheckOn.PortDnsLookupTime,
+      CheckOn.PortTcpConnectTime,
       CheckOn.CPUUsagePercent,
       CheckOn.MemoryUsagePercent,
       CheckOn.IsOnline,
@@ -290,6 +292,8 @@ describe("CriteriaFilterUtil", () => {
     test.each([
       CheckOn.ResponseStatusCode,
       CheckOn.ResponseTime,
+      CheckOn.PortDnsLookupTime,
+      CheckOn.PortTcpConnectTime,
       CheckOn.DiskUsagePercent,
       CheckOn.CPUUsagePercent,
       CheckOn.MemoryUsagePercent,

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

@@ -0,0 +1,109 @@
+import {
+  DockerMetricCategory,
+  DockerMetricDefinition,
+  getAllDockerMetricCategories,
+  getAllDockerMetrics,
+  getDockerMetricById,
+  getDockerMetricByMetricName,
+  getDockerMetricsByCategory,
+} from "../../../Types/Monitor/DockerMetricCatalog";
+import AggregationType from "../../../Types/BaseDatabase/AggregationType";
+import { describe, expect, test } from "@jest/globals";
+
+describe("DockerMetricCatalog", () => {
+  const allMetrics: Array<DockerMetricDefinition> = getAllDockerMetrics();
+  const allCategories: Array<DockerMetricCategory> =
+    getAllDockerMetricCategories();
+  const validAggregations: Array<string> = Object.values(AggregationType);
+
+  test("returns a non-empty catalog", () => {
+    expect(Array.isArray(allMetrics)).toBe(true);
+    expect(allMetrics.length).toBeGreaterThan(0);
+  });
+
+  test("every metric definition has all required non-empty fields", () => {
+    for (const metric of allMetrics) {
+      expect(typeof metric.id).toBe("string");
+      expect(metric.id.length).toBeGreaterThan(0);
+      expect(metric.friendlyName.length).toBeGreaterThan(0);
+      expect(metric.description.length).toBeGreaterThan(0);
+      expect(metric.metricName.length).toBeGreaterThan(0);
+      expect(metric.category.length).toBeGreaterThan(0);
+    }
+  });
+
+  test("every metric uses a valid aggregation type", () => {
+    for (const metric of allMetrics) {
+      expect(validAggregations).toContain(metric.defaultAggregation);
+    }
+  });
+
+  test("metric ids are unique", () => {
+    const ids: Array<string> = allMetrics.map((m: DockerMetricDefinition) => {
+      return m.id;
+    });
+    expect(new Set(ids).size).toBe(ids.length);
+  });
+
+  test("metric names are unique", () => {
+    const names: Array<string> = allMetrics.map((m: DockerMetricDefinition) => {
+      return m.metricName;
+    });
+    expect(new Set(names).size).toBe(names.length);
+  });
+
+  test("every metric category is a declared category", () => {
+    for (const metric of allMetrics) {
+      expect(allCategories).toContain(metric.category);
+    }
+  });
+
+  test("declared categories are unique and non-empty", () => {
+    expect(allCategories.length).toBeGreaterThan(0);
+    expect(new Set(allCategories).size).toBe(allCategories.length);
+  });
+
+  test("every declared category has at least one metric", () => {
+    for (const category of allCategories) {
+      expect(getDockerMetricsByCategory(category).length).toBeGreaterThan(0);
+    }
+  });
+
+  test("getDockerMetricsByCategory returns only metrics of that category", () => {
+    for (const category of allCategories) {
+      for (const metric of getDockerMetricsByCategory(category)) {
+        expect(metric.category).toBe(category);
+      }
+    }
+  });
+
+  test("getDockerMetricById round-trips every metric", () => {
+    for (const metric of allMetrics) {
+      expect(getDockerMetricById(metric.id)).toEqual(metric);
+    }
+  });
+
+  test("getDockerMetricById returns undefined for an unknown id", () => {
+    expect(getDockerMetricById("does-not-exist")).toBeUndefined();
+    expect(getDockerMetricById("")).toBeUndefined();
+  });
+
+  test("getDockerMetricByMetricName round-trips every metric", () => {
+    for (const metric of allMetrics) {
+      expect(getDockerMetricByMetricName(metric.metricName)).toEqual(metric);
+    }
+  });
+
+  test("getDockerMetricByMetricName returns undefined for an unknown name", () => {
+    expect(getDockerMetricByMetricName("nope.nope.nope")).toBeUndefined();
+  });
+
+  test("known metrics are present", () => {
+    expect(
+      getDockerMetricByMetricName("container.cpu.usage.total"),
+    ).toBeDefined();
+    expect(
+      getDockerMetricByMetricName("container.cpu.utilization"),
+    ).toBeDefined();
+  });
+});

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

@@ -0,0 +1,118 @@
+import {
+  DockerSwarmMetricCategory,
+  DockerSwarmMetricDefinition,
+  getAllDockerSwarmMetricCategories,
+  getAllDockerSwarmMetrics,
+  getDockerSwarmMetricById,
+  getDockerSwarmMetricByMetricName,
+  getDockerSwarmMetricsByCategory,
+} from "../../../Types/Monitor/DockerSwarmMetricCatalog";
+import AggregationType from "../../../Types/BaseDatabase/AggregationType";
+import { describe, expect, test } from "@jest/globals";
+
+describe("DockerSwarmMetricCatalog", () => {
+  const allMetrics: Array<DockerSwarmMetricDefinition> =
+    getAllDockerSwarmMetrics();
+  const allCategories: Array<DockerSwarmMetricCategory> =
+    getAllDockerSwarmMetricCategories();
+  const validAggregations: Array<string> = Object.values(AggregationType);
+
+  test("returns a non-empty catalog", () => {
+    expect(Array.isArray(allMetrics)).toBe(true);
+    expect(allMetrics.length).toBeGreaterThan(0);
+  });
+
+  test("every metric definition has all required non-empty fields", () => {
+    for (const metric of allMetrics) {
+      expect(typeof metric.id).toBe("string");
+      expect(metric.id.length).toBeGreaterThan(0);
+      expect(metric.friendlyName.length).toBeGreaterThan(0);
+      expect(metric.description.length).toBeGreaterThan(0);
+      expect(metric.metricName.length).toBeGreaterThan(0);
+      expect(metric.category.length).toBeGreaterThan(0);
+    }
+  });
+
+  test("every metric uses a valid aggregation type", () => {
+    for (const metric of allMetrics) {
+      expect(validAggregations).toContain(metric.defaultAggregation);
+    }
+  });
+
+  test("metric ids are unique", () => {
+    const ids: Array<string> = allMetrics.map(
+      (m: DockerSwarmMetricDefinition) => {
+        return m.id;
+      },
+    );
+    expect(new Set(ids).size).toBe(ids.length);
+  });
+
+  test("metric names are unique", () => {
+    const names: Array<string> = allMetrics.map(
+      (m: DockerSwarmMetricDefinition) => {
+        return m.metricName;
+      },
+    );
+    expect(new Set(names).size).toBe(names.length);
+  });
+
+  test("every metric category is a declared category", () => {
+    for (const metric of allMetrics) {
+      expect(allCategories).toContain(metric.category);
+    }
+  });
+
+  test("declared categories are unique and non-empty", () => {
+    expect(allCategories.length).toBeGreaterThan(0);
+    expect(new Set(allCategories).size).toBe(allCategories.length);
+  });
+
+  test("every declared category has at least one metric", () => {
+    for (const category of allCategories) {
+      expect(getDockerSwarmMetricsByCategory(category).length).toBeGreaterThan(
+        0,
+      );
+    }
+  });
+
+  test("getDockerSwarmMetricsByCategory returns only metrics of that category", () => {
+    for (const category of allCategories) {
+      for (const metric of getDockerSwarmMetricsByCategory(category)) {
+        expect(metric.category).toBe(category);
+      }
+    }
+  });
+
+  test("getDockerSwarmMetricById round-trips every metric", () => {
+    for (const metric of allMetrics) {
+      expect(getDockerSwarmMetricById(metric.id)).toEqual(metric);
+    }
+  });
+
+  test("getDockerSwarmMetricById returns undefined for an unknown id", () => {
+    expect(getDockerSwarmMetricById("does-not-exist")).toBeUndefined();
+    expect(getDockerSwarmMetricById("")).toBeUndefined();
+  });
+
+  test("getDockerSwarmMetricByMetricName round-trips every metric", () => {
+    for (const metric of allMetrics) {
+      expect(getDockerSwarmMetricByMetricName(metric.metricName)).toEqual(
+        metric,
+      );
+    }
+  });
+
+  test("getDockerSwarmMetricByMetricName returns undefined for an unknown name", () => {
+    expect(getDockerSwarmMetricByMetricName("nope.nope.nope")).toBeUndefined();
+  });
+
+  test("known metrics are present", () => {
+    expect(
+      getDockerSwarmMetricByMetricName("container.cpu.utilization"),
+    ).toBeDefined();
+    expect(
+      getDockerSwarmMetricByMetricName("container.memory.usage.total"),
+    ).toBeDefined();
+  });
+});

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

@@ -0,0 +1,104 @@
+import {
+  HostMetricCategory,
+  HostMetricDefinition,
+  getAllHostMetricCategories,
+  getAllHostMetrics,
+  getHostMetricById,
+  getHostMetricByMetricName,
+  getHostMetricsByCategory,
+} from "../../../Types/Monitor/HostMetricCatalog";
+import AggregationType from "../../../Types/BaseDatabase/AggregationType";
+import { describe, expect, test } from "@jest/globals";
+
+describe("HostMetricCatalog", () => {
+  const allMetrics: Array<HostMetricDefinition> = getAllHostMetrics();
+  const allCategories: Array<HostMetricCategory> = getAllHostMetricCategories();
+  const validAggregations: Array<string> = Object.values(AggregationType);
+
+  test("returns a non-empty catalog", () => {
+    expect(Array.isArray(allMetrics)).toBe(true);
+    expect(allMetrics.length).toBeGreaterThan(0);
+  });
+
+  test("every metric definition has all required non-empty fields", () => {
+    for (const metric of allMetrics) {
+      expect(typeof metric.id).toBe("string");
+      expect(metric.id.length).toBeGreaterThan(0);
+      expect(metric.friendlyName.length).toBeGreaterThan(0);
+      expect(metric.description.length).toBeGreaterThan(0);
+      expect(metric.metricName.length).toBeGreaterThan(0);
+      expect(metric.category.length).toBeGreaterThan(0);
+    }
+  });
+
+  test("every metric uses a valid aggregation type", () => {
+    for (const metric of allMetrics) {
+      expect(validAggregations).toContain(metric.defaultAggregation);
+    }
+  });
+
+  test("metric ids are unique", () => {
+    const ids: Array<string> = allMetrics.map((m: HostMetricDefinition) => {
+      return m.id;
+    });
+    expect(new Set(ids).size).toBe(ids.length);
+  });
+
+  test("metric names are unique", () => {
+    const names: Array<string> = allMetrics.map((m: HostMetricDefinition) => {
+      return m.metricName;
+    });
+    expect(new Set(names).size).toBe(names.length);
+  });
+
+  test("every metric category is a declared category", () => {
+    for (const metric of allMetrics) {
+      expect(allCategories).toContain(metric.category);
+    }
+  });
+
+  test("declared categories are unique and non-empty", () => {
+    expect(allCategories.length).toBeGreaterThan(0);
+    expect(new Set(allCategories).size).toBe(allCategories.length);
+  });
+
+  test("every declared category has at least one metric", () => {
+    for (const category of allCategories) {
+      expect(getHostMetricsByCategory(category).length).toBeGreaterThan(0);
+    }
+  });
+
+  test("getHostMetricsByCategory returns only metrics of that category", () => {
+    for (const category of allCategories) {
+      for (const metric of getHostMetricsByCategory(category)) {
+        expect(metric.category).toBe(category);
+      }
+    }
+  });
+
+  test("getHostMetricById round-trips every metric", () => {
+    for (const metric of allMetrics) {
+      expect(getHostMetricById(metric.id)).toEqual(metric);
+    }
+  });
+
+  test("getHostMetricById returns undefined for an unknown id", () => {
+    expect(getHostMetricById("does-not-exist")).toBeUndefined();
+    expect(getHostMetricById("")).toBeUndefined();
+  });
+
+  test("getHostMetricByMetricName round-trips every metric", () => {
+    for (const metric of allMetrics) {
+      expect(getHostMetricByMetricName(metric.metricName)).toEqual(metric);
+    }
+  });
+
+  test("getHostMetricByMetricName returns undefined for an unknown name", () => {
+    expect(getHostMetricByMetricName("nope.nope")).toBeUndefined();
+  });
+
+  test("known host metrics are present", () => {
+    expect(getHostMetricByMetricName("system.cpu.utilization")).toBeDefined();
+    expect(getHostMetricByMetricName("system.memory.usage")).toBeDefined();
+  });
+});

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

@@ -0,0 +1,104 @@
+import {
+  IoTMetricCategory,
+  IoTMetricDefinition,
+  getAllIoTMetricCategories,
+  getAllIoTMetrics,
+  getIoTMetricById,
+  getIoTMetricByMetricName,
+  getIoTMetricsByCategory,
+} from "../../../Types/Monitor/IotMetricCatalog";
+import AggregationType from "../../../Types/BaseDatabase/AggregationType";
+import { describe, expect, test } from "@jest/globals";
+
+describe("IotMetricCatalog", () => {
+  const allMetrics: Array<IoTMetricDefinition> = getAllIoTMetrics();
+  const allCategories: Array<IoTMetricCategory> = getAllIoTMetricCategories();
+  const validAggregations: Array<string> = Object.values(AggregationType);
+
+  test("returns a non-empty catalog", () => {
+    expect(Array.isArray(allMetrics)).toBe(true);
+    expect(allMetrics.length).toBeGreaterThan(0);
+  });
+
+  test("every metric definition has all required non-empty fields", () => {
+    for (const metric of allMetrics) {
+      expect(typeof metric.id).toBe("string");
+      expect(metric.id.length).toBeGreaterThan(0);
+      expect(metric.friendlyName.length).toBeGreaterThan(0);
+      expect(metric.description.length).toBeGreaterThan(0);
+      expect(metric.metricName.length).toBeGreaterThan(0);
+      expect(metric.category.length).toBeGreaterThan(0);
+    }
+  });
+
+  test("every metric uses a valid aggregation type", () => {
+    for (const metric of allMetrics) {
+      expect(validAggregations).toContain(metric.defaultAggregation);
+    }
+  });
+
+  test("metric ids are unique", () => {
+    const ids: Array<string> = allMetrics.map((m: IoTMetricDefinition) => {
+      return m.id;
+    });
+    expect(new Set(ids).size).toBe(ids.length);
+  });
+
+  test("metric names are unique", () => {
+    const names: Array<string> = allMetrics.map((m: IoTMetricDefinition) => {
+      return m.metricName;
+    });
+    expect(new Set(names).size).toBe(names.length);
+  });
+
+  test("every metric category is a declared category", () => {
+    for (const metric of allMetrics) {
+      expect(allCategories).toContain(metric.category);
+    }
+  });
+
+  test("declared categories are unique and non-empty", () => {
+    expect(allCategories.length).toBeGreaterThan(0);
+    expect(new Set(allCategories).size).toBe(allCategories.length);
+  });
+
+  test("every declared category has at least one metric", () => {
+    for (const category of allCategories) {
+      expect(getIoTMetricsByCategory(category).length).toBeGreaterThan(0);
+    }
+  });
+
+  test("getIoTMetricsByCategory returns only metrics of that category", () => {
+    for (const category of allCategories) {
+      for (const metric of getIoTMetricsByCategory(category)) {
+        expect(metric.category).toBe(category);
+      }
+    }
+  });
+
+  test("getIoTMetricById round-trips every metric", () => {
+    for (const metric of allMetrics) {
+      expect(getIoTMetricById(metric.id)).toEqual(metric);
+    }
+  });
+
+  test("getIoTMetricById returns undefined for an unknown id", () => {
+    expect(getIoTMetricById("does-not-exist")).toBeUndefined();
+    expect(getIoTMetricById("")).toBeUndefined();
+  });
+
+  test("getIoTMetricByMetricName round-trips every metric", () => {
+    for (const metric of allMetrics) {
+      expect(getIoTMetricByMetricName(metric.metricName)).toEqual(metric);
+    }
+  });
+
+  test("getIoTMetricByMetricName returns undefined for an unknown name", () => {
+    expect(getIoTMetricByMetricName("nope.nope.nope")).toBeUndefined();
+  });
+
+  test("known metrics are present", () => {
+    expect(getIoTMetricByMetricName("iot_device_up")).toBeDefined();
+    expect(getIoTMetricByMetricName("iot_battery_percent")).toBeDefined();
+  });
+});