@oneuptime/common 13.0.0 → 13.0.1

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

@@ -24,22 +24,30 @@ import MonitorStepPodmanMonitor, {
 import MonitorStepProxmoxMonitor, {
   MonitorStepProxmoxMonitorUtil,
 } from "../../../Types/Monitor/MonitorStepProxmoxMonitor";
+import MonitorStepVMwareMonitor, {
+  MonitorStepVMwareMonitorUtil,
+} from "../../../Types/Monitor/MonitorStepVMwareMonitor";
 import { JSONObject } from "../../../Types/JSON";
 import RollingTime from "../../../Types/RollingTime/RollingTime";
 import { describe, expect, it } from "@jest/globals";
 
 /*
  * The infrastructure monitor-step types (Host, Docker, Podman, Kubernetes,
- * Ceph, IoT, Docker Swarm, Proxmox) each ship a small `*Util` class with
+ * Ceph, IoT, Docker Swarm, Proxmox, VMware) each ship a small `*Util` class with
  * getDefault / fromJSON / toJSON. getDefault seeds the monitor-step editor
  * when a user first picks that monitor type, so two things it does are
  * load-bearing and neither is obvious from the (near-identity) code:
  *
- *   1. THE DEFAULT ROLLING WINDOW. Every infra step defaults to
- *      RollingTime.Past1Minute. That value is what a freshly created
- *      metric monitor evaluates over until the user changes it; a silent
- *      change to it would change the meaning of every new monitor. Pinned
- *      per type so a copy-paste edit in one file is caught.
+ *   1. THE DEFAULT ROLLING WINDOW. Every infra step whose agent scrapes
+ *      every 30 s defaults to RollingTime.Past1Minute. VMware is the one
+ *      exception: its agent polls vCenter every 2 minutes
+ *      (VCENTER_COLLECTION_INTERVAL) and emits one sample per object per
+ *      collection, so it defaults to Past5Minutes — a 1-minute window
+ *      would be empty every other evaluation and flap. That value is what
+ *      a freshly created metric monitor evaluates over until the user
+ *      changes it; a silent change to it would change the meaning of every
+ *      new monitor. Pinned per type so a copy-paste edit in one file is
+ *      caught in either direction.
  *
  *   2. getDefault RETURNS A FRESH OBJECT GRAPH. The editor mutates the
  *      returned object (typing an identifier, adding a filter). If
@@ -60,6 +68,8 @@ interface InfraCase {
   util: InfraMonitorUtil<any>;
   // The empty-string identifier field each default carries.
   identifierField: string;
+  // The rolling window getDefault seeds — see note 1 in the header.
+  defaultRollingTime: RollingTime;
 }
 
 const CASES: Array<InfraCase> = [
@@ -67,50 +77,64 @@ const CASES: Array<InfraCase> = [
     name: "Host",
     util: MonitorStepHostMonitorUtil as InfraMonitorUtil<MonitorStepHostMonitor>,
     identifierField: "hostIdentifier",
+    defaultRollingTime: RollingTime.Past1Minute,
   },
   {
     name: "Docker",
     util: MonitorStepDockerMonitorUtil as InfraMonitorUtil<MonitorStepDockerMonitor>,
     identifierField: "hostIdentifier",
+    defaultRollingTime: RollingTime.Past1Minute,
   },
   {
     name: "Podman",
     util: MonitorStepPodmanMonitorUtil as InfraMonitorUtil<MonitorStepPodmanMonitor>,
     identifierField: "hostIdentifier",
+    defaultRollingTime: RollingTime.Past1Minute,
   },
   {
     name: "Kubernetes",
     util: MonitorStepKubernetesMonitorUtil as InfraMonitorUtil<MonitorStepKubernetesMonitor>,
     identifierField: "clusterIdentifier",
+    defaultRollingTime: RollingTime.Past1Minute,
   },
   {
     name: "Ceph",
     util: MonitorStepCephMonitorUtil as InfraMonitorUtil<MonitorStepCephMonitor>,
     identifierField: "clusterIdentifier",
+    defaultRollingTime: RollingTime.Past1Minute,
   },
   {
     name: "IoT",
     util: MonitorStepIoTMonitorUtil as InfraMonitorUtil<MonitorStepIoTMonitor>,
     identifierField: "fleetIdentifier",
+    defaultRollingTime: RollingTime.Past1Minute,
   },
   {
     name: "DockerSwarm",
     util: MonitorStepDockerSwarmMonitorUtil as InfraMonitorUtil<MonitorStepDockerSwarmMonitor>,
     identifierField: "clusterIdentifier",
+    defaultRollingTime: RollingTime.Past1Minute,
   },
   {
     name: "Proxmox",
     util: MonitorStepProxmoxMonitorUtil as InfraMonitorUtil<MonitorStepProxmoxMonitor>,
     identifierField: "clusterIdentifier",
+    defaultRollingTime: RollingTime.Past1Minute,
+  },
+  {
+    name: "VMware",
+    util: MonitorStepVMwareMonitorUtil as InfraMonitorUtil<MonitorStepVMwareMonitor>,
+    identifierField: "vcenterIdentifier",
+    defaultRollingTime: RollingTime.Past5Minutes,
   },
 ];
 
 describe("Infrastructure monitor-step getDefault contract", () => {
   for (const testCase of CASES) {
     describe(`MonitorStep${testCase.name}MonitorUtil`, () => {
-      it("defaults the rolling window to Past1Minute", () => {
+      it(`defaults the rolling window to ${testCase.defaultRollingTime}`, () => {
         const def: Record<string, unknown> = testCase.util.getDefault();
-        expect(def["rollingTime"]).toBe(RollingTime.Past1Minute);
+        expect(def["rollingTime"]).toBe(testCase.defaultRollingTime);
       });
 
       it("defaults the identifier to an empty string", () => {
@@ -147,6 +171,27 @@ describe("Infrastructure monitor-step getDefault contract", () => {
   }
 });
 
+describe("Infrastructure monitor-step default rolling window", () => {
+  it("only VMware departs from the 1-minute window, and only upward", () => {
+    /*
+     * Guards the table itself: a new product copy-pasted from VMware must
+     * not inherit the 5-minute window without the 2-minute-collection
+     * justification, and VMware must never slide back to 1 minute.
+     */
+    for (const testCase of CASES) {
+      if (testCase.name === "VMware") {
+        expect(testCase.defaultRollingTime).toBe(RollingTime.Past5Minutes);
+      } else {
+        expect(testCase.defaultRollingTime).toBe(RollingTime.Past1Minute);
+      }
+    }
+
+    expect(MonitorStepVMwareMonitorUtil.getDefault().rollingTime).toBe(
+      RollingTime.Past5Minutes,
+    );
+  });
+});
+
 describe("Infrastructure monitor-step JSON round-trip", () => {
   for (const testCase of CASES) {
     it(`MonitorStep${testCase.name}MonitorUtil round-trips getDefault through to/fromJSON`, () => {

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

@@ -30,6 +30,11 @@ import MonitorStepProxmoxMonitor, {
   MonitorStepProxmoxMonitorUtil,
   ProxmoxResourceScope,
 } from "../../../Types/Monitor/MonitorStepProxmoxMonitor";
+import MonitorStepVMwareMonitor, {
+  MonitorStepVMwareMonitorUtil,
+  VMwareResourceKind,
+  VMwareResourceScope,
+} from "../../../Types/Monitor/MonitorStepVMwareMonitor";
 import RollingTime from "../../../Types/RollingTime/RollingTime";
 
 /*
@@ -38,6 +43,10 @@ import RollingTime from "../../../Types/RollingTime/RollingTime";
  * view config, and fromJSON/toJSON are structural pass-throughs. This suite
  * locks in that contract for each of them so a future refactor cannot quietly
  * change a default or drop a field on the wire.
+ *
+ * VMware is the one deliberate exception to the 1-minute window: its agent
+ * collects every 2 minutes (VCENTER_COLLECTION_INTERVAL), so it defaults to
+ * Past5Minutes — see the VMware block below.
  */
 
 describe("Infrastructure MonitorStep utils", () => {
@@ -215,6 +224,94 @@ describe("Infrastructure MonitorStep utils", () => {
     });
   });
 
+  describe("MonitorStepVMwareMonitorUtil", () => {
+    test("getDefault has no resource filters", () => {
+      const def: MonitorStepVMwareMonitor =
+        MonitorStepVMwareMonitorUtil.getDefault();
+
+      expect(def.vcenterIdentifier).toBe("");
+      expect(def.resourceFilters).toEqual({});
+    });
+
+    test("getDefault evaluates over a 5-minute window, not the 1-minute one", () => {
+      /*
+       * The VMware Agent's default VCENTER_COLLECTION_INTERVAL is 2 minutes
+       * and the vcenter receiver emits one sample per object per
+       * collection, so a 1-minute window (the Proxmox / Kubernetes default,
+       * whose agents scrape every 30 s) would be empty on roughly every
+       * other evaluation and a hand-built monitor would flap between "no
+       * criteria met" and firing. The default must cover at least two
+       * collections.
+       */
+      const def: MonitorStepVMwareMonitor =
+        MonitorStepVMwareMonitorUtil.getDefault();
+
+      expect(def.rollingTime).toBe(RollingTime.Past5Minutes);
+      expect(def.rollingTime).not.toBe(RollingTime.Past1Minute);
+    });
+
+    test("round-trips a VM-scoped monitor", () => {
+      const monitor: MonitorStepVMwareMonitor = {
+        vcenterIdentifier: "vcsa-prod",
+        resourceFilters: {
+          datacenterName: "DC1",
+          clusterName: "Compute-A",
+          hostName: "esx01.example.com",
+          vmName: "web-01",
+        },
+        metricViewConfig: { queryConfigs: [], formulaConfigs: [] },
+        rollingTime: RollingTime.Past1Minute,
+      };
+      expect(
+        MonitorStepVMwareMonitorUtil.fromJSON(
+          MonitorStepVMwareMonitorUtil.toJSON(monitor),
+        ),
+      ).toEqual(monitor);
+    });
+
+    test("round-trips a resource-pool-scoped monitor by inventory path", () => {
+      const monitor: MonitorStepVMwareMonitor = {
+        vcenterIdentifier: "vcsa-prod",
+        resourceFilters: {
+          resourcePoolPath: "/DC1/host/Compute-A/Resources/prod",
+          datastoreName: "vsanDatastore",
+        },
+        metricViewConfig: { queryConfigs: [], formulaConfigs: [] },
+        rollingTime: RollingTime.Past5Minutes,
+      };
+      expect(
+        MonitorStepVMwareMonitorUtil.fromJSON(
+          MonitorStepVMwareMonitorUtil.toJSON(monitor),
+        ),
+      ).toEqual(monitor);
+    });
+
+    test("scope and kind enums carry the spec'd literal values", () => {
+      /*
+       * The scope values are what the picker and the worker key on; the
+       * kind values are the literal strings stored in VMwareResource.kind
+       * and read back by the ingest scan and the dashboard.
+       */
+      expect(Object.values(VMwareResourceScope)).toEqual([
+        "vcenter",
+        "datacenter",
+        "cluster",
+        "host",
+        "vm",
+        "datastore",
+        "resource_pool",
+      ]);
+      expect(Object.values(VMwareResourceKind)).toEqual([
+        "Datacenter",
+        "Cluster",
+        "Host",
+        "VirtualMachine",
+        "Datastore",
+        "ResourcePool",
+      ]);
+    });
+  });
+
   describe("MonitorStepDockerSwarmMonitorUtil", () => {
     test("getDefault has no resource filters", () => {
       const def: MonitorStepDockerSwarmMonitor =

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

@@ -29,6 +29,7 @@ const METRIC_SHAPED_KEYS: Array<keyof MonitorStepType> = [
   "dockerSwarmMonitor",
   "podmanMonitor",
   "proxmoxMonitor",
+  "vmwareMonitor",
   "cephMonitor",
   "iotMonitor",
 ];

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

@@ -0,0 +1,107 @@
+import { JSONObject } from "../../../Types/JSON";
+import MonitorStep from "../../../Types/Monitor/MonitorStep";
+import MonitorSteps from "../../../Types/Monitor/MonitorSteps";
+import MonitorType from "../../../Types/Monitor/MonitorType";
+
+describe("MonitorStep template sync field policy persistence", () => {
+  test("policy survives step and step-list serialization, cloning, and schema validation", (): void => {
+    const step: MonitorStep = new MonitorStep();
+    step.data!.doNotSyncFields = [
+      "monitorDestination",
+      "requestHeaders",
+      "tlsClientAuthentication",
+    ];
+    const json: JSONObject = step.toJSON();
+
+    expect((json["value"] as JSONObject)["doNotSyncFields"]).toEqual(
+      step.data!.doNotSyncFields,
+    );
+    expect(MonitorStep.fromJSON(json).data!.doNotSyncFields).toEqual(
+      step.data!.doNotSyncFields,
+    );
+    expect(MonitorStep.clone(step).data!.doNotSyncFields).toEqual(
+      step.data!.doNotSyncFields,
+    );
+    expect(MonitorStep.getSchema().safeParse(json).success).toBe(true);
+    const steps: MonitorSteps = new MonitorSteps();
+    steps.setMonitorStepsInstanceArray([step]);
+    expect(
+      MonitorSteps.clone(steps).data!.monitorStepsInstanceArray[0]!.data!
+        .doNotSyncFields,
+    ).toEqual(step.data!.doNotSyncFields);
+  });
+
+  test("legacy steps do not acquire a policy when serialized", (): void => {
+    const step: MonitorStep = new MonitorStep();
+    expect(step.data!.doNotSyncFields).toBeUndefined();
+    expect(step.toJSON()["value"]).not.toHaveProperty("doNotSyncFields");
+    expect(
+      MonitorStep.fromJSON(step.toJSON()).data!.doNotSyncFields,
+    ).toBeUndefined();
+  });
+
+  test.each([
+    null,
+    "requestHeaders",
+    {},
+    [1],
+    ["requestHeaders", false],
+    ["id"],
+    ["monitorCriteria"],
+    ["requestHeaders.Authorization"],
+    ["unknownField"],
+  ])("rejects invalid persisted and API policy %j", (value: unknown): void => {
+    const json: JSONObject = new MonitorStep().toJSON();
+    (json["value"] as JSONObject)["doNotSyncFields"] = value as never;
+    expect((): void => {
+      MonitorStep.fromJSON(json);
+    }).toThrow();
+    expect(MonitorStep.getSchema().safeParse(json).success).toBe(false);
+  });
+
+  test("validates policy against the step's monitor type", (): void => {
+    const step: MonitorStep = new MonitorStep();
+    step.data!.doNotSyncFields = ["requestHeaders"];
+    expect(MonitorStep.getValidationError(step, MonitorType.DNS)).toContain(
+      "Unsupported do not sync field: requestHeaders",
+    );
+  });
+
+  test("does not mutate or share the policy array during a step clone", (): void => {
+    const step: MonitorStep = new MonitorStep();
+    step.data!.doNotSyncFields = ["requestHeaders"];
+    const cloned: MonitorStep = MonitorStep.clone(step);
+    cloned.data!.doNotSyncFields!.push("requestBody");
+    expect(step.data!.doNotSyncFields).toEqual(["requestHeaders"]);
+  });
+
+  test.each([
+    ["doNotFollowRedirects", false],
+    ["allowSelfSignedCertificates", false],
+    ["requestBody", ""],
+    ["customCode", ""],
+    ["tlsClientCertificate", ""],
+    ["tlsClientKey", ""],
+    ["tlsClientKeyPassphrase", ""],
+    ["retryCount", 0],
+    ["retryCountOnError", 0],
+  ])(
+    "preserves explicit falsy %s through persistence",
+    (
+      key: string | number | boolean,
+      value: string | number | boolean,
+    ): void => {
+      const step: MonitorStep = new MonitorStep();
+      (step.data as unknown as Record<string, unknown>)[String(key)] = value;
+      expect((step.toJSON()["value"] as JSONObject)[String(key)]).toBe(value);
+      expect(
+        (
+          MonitorStep.fromJSON(step.toJSON()).data as unknown as Record<
+            string,
+            unknown
+          >
+        )[String(key)],
+      ).toBe(value);
+    },
+  );
+});

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

@@ -0,0 +1,172 @@
+import BadDataException from "../../../Types/Exception/BadDataException";
+import MonitorTemplateSyncFieldUtil, {
+  MonitorTemplateSyncField,
+} from "../../../Types/Monitor/MonitorTemplateSyncField";
+import MonitorType from "../../../Types/Monitor/MonitorType";
+
+describe("MonitorTemplateSyncFieldUtil", () => {
+  test.each(Object.values(MonitorType))(
+    "%s exposes distinct, validated field options",
+    (monitorType: MonitorType): void => {
+      const fields: Array<MonitorTemplateSyncField> =
+        MonitorTemplateSyncFieldUtil.getFields(monitorType);
+      const paths: Array<string> = fields.map(
+        (field: MonitorTemplateSyncField): string => {
+          return field.path;
+        },
+      );
+      expect(new Set(paths).size).toBe(paths.length);
+      expect(MonitorTemplateSyncFieldUtil.parse(paths, monitorType)).toEqual(
+        paths,
+      );
+      for (const field of fields) {
+        expect(field.label.length).toBeGreaterThan(0);
+        for (const path of MonitorTemplateSyncFieldUtil.getPaths(field.path)) {
+          expect(path).not.toMatch(
+            /(^|\.)(id|monitorCriteria|doNotSyncFields)(\.|$)/,
+          );
+          expect(path.split(".").length).toBeLessThanOrEqual(2);
+        }
+      }
+    },
+  );
+
+  test("omitted policy stays omitted and empty policy stays empty", (): void => {
+    expect(MonitorTemplateSyncFieldUtil.parse(undefined)).toBeUndefined();
+    expect(MonitorTemplateSyncFieldUtil.parse([])).toEqual([]);
+  });
+
+  test("deduplicates a policy without modifying the supplied array", (): void => {
+    const input: Array<string> = [
+      "requestHeaders",
+      "monitorDestination",
+      "requestHeaders",
+    ];
+    expect(MonitorTemplateSyncFieldUtil.parse(input, MonitorType.API)).toEqual([
+      "requestHeaders",
+      "monitorDestination",
+    ]);
+    expect(input).toEqual([
+      "requestHeaders",
+      "monitorDestination",
+      "requestHeaders",
+    ]);
+  });
+
+  test.each([
+    null,
+    "requestHeaders",
+    0,
+    false,
+    {},
+    ["requestHeaders", null],
+    [1],
+    [[]],
+  ])("rejects malformed policy %j", (value: unknown): void => {
+    expect((): void => {
+      MonitorTemplateSyncFieldUtil.parse(value);
+    }).toThrow(BadDataException);
+  });
+
+  test.each([
+    "id",
+    "monitorCriteria",
+    "monitorCriteria.monitorCriteriaInstanceArray",
+    "doNotSyncFields",
+    "requestHeaders.Authorization",
+    "unknownField",
+    "networkDeviceMonitor.networkDeviceId",
+  ])("rejects non-selectable field %s", (path: string): void => {
+    expect((): void => {
+      MonitorTemplateSyncFieldUtil.parse([path]);
+    }).toThrow("Unsupported do not sync field");
+    expect((): void => {
+      MonitorTemplateSyncFieldUtil.getPaths(path);
+    }).toThrow("Unsupported do not sync field");
+  });
+
+  test("rejects a field belonging to a different monitor type", (): void => {
+    expect((): void => {
+      MonitorTemplateSyncFieldUtil.parse(["requestHeaders"], MonitorType.DNS);
+    }).toThrow("Unsupported do not sync field");
+    expect((): void => {
+      MonitorTemplateSyncFieldUtil.parse(
+        ["dnsMonitor.queryName"],
+        MonitorType.API,
+      );
+    }).toThrow("Unsupported do not sync field");
+  });
+
+  test("TLS credentials are a single option", (): void => {
+    expect(
+      MonitorTemplateSyncFieldUtil.getPaths("tlsClientAuthentication"),
+    ).toEqual([
+      "tlsClientCertificate",
+      "tlsClientKey",
+      "tlsClientKeyPassphrase",
+    ]);
+    expect((): void => {
+      MonitorTemplateSyncFieldUtil.parse(["tlsClientKey"]);
+    }).toThrow();
+  });
+
+  test("Website options include only settings used by website checks", (): void => {
+    const websiteFields: Array<string> = MonitorTemplateSyncFieldUtil.getFields(
+      MonitorType.Website,
+    ).map((field: MonitorTemplateSyncField): string => {
+      return field.path;
+    });
+    expect(websiteFields).toEqual([
+      "monitorDestination",
+      "requestTimeoutInMs",
+      "retryCount",
+      "doNotFollowRedirects",
+      "allowSelfSignedCertificates",
+      "tlsClientAuthentication",
+    ]);
+    for (const apiField of ["requestHeaders", "requestType", "requestBody"]) {
+      expect((): void => {
+        MonitorTemplateSyncFieldUtil.parse([apiField], MonitorType.Website);
+      }).toThrow("Unsupported do not sync field");
+      expect(
+        MonitorTemplateSyncFieldUtil.parse([apiField], MonitorType.API),
+      ).toEqual([apiField]);
+    }
+  });
+
+  test.each(["sqlMonitor", "databaseMonitor"])(
+    "%s connection includes all authentication and endpoint fields",
+    (prefix: string): void => {
+      expect(
+        MonitorTemplateSyncFieldUtil.getPaths(`${prefix}.connection`),
+      ).toEqual(
+        [
+          "databaseType",
+          "host",
+          "port",
+          "databaseName",
+          "username",
+          "password",
+          "useWindowsIntegratedAuthentication",
+          "useSsl",
+          "rejectUnauthorizedSsl",
+        ].map((key: string): string => {
+          return `${prefix}.${key}`;
+        }),
+      );
+    },
+  );
+
+  test.each([
+    MonitorType.Manual,
+    MonitorType.IncomingRequest,
+    MonitorType.IncomingEmail,
+    MonitorType.Server,
+    MonitorType.NetworkDevice,
+  ])(
+    "%s has no misleading exclusions for criteria or automatically preserved bindings",
+    (monitorType: MonitorType): void => {
+      expect(MonitorTemplateSyncFieldUtil.getFields(monitorType)).toEqual([]);
+    },
+  );
+});

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

@@ -55,6 +55,7 @@ describe("MonitorTypeHelper", () => {
       MonitorType.Podman,
       MonitorType.DockerSwarm,
       MonitorType.Proxmox,
+      MonitorType.VMware,
       MonitorType.Ceph,
     ])("returns true for %s", (monitorType: MonitorType) => {
       expect(MonitorTypeHelper.isTelemetryMonitor(monitorType)).toBe(true);

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

@@ -268,6 +268,8 @@ describe("MonitorType keywords", () => {
       ["javascript", MonitorType.CustomJavaScriptCode],
       ["rootless", MonitorType.Podman],
       ["lxc", MonitorType.Proxmox],
+      ["esxi", MonitorType.VMware],
+      ["vcenter", MonitorType.VMware],
       ["osd", MonitorType.Ceph],
       ["sensor", MonitorType.IoTDevice],
       ["imap", MonitorType.IncomingEmail],

package/Tests/Types/Monitor/Recommendation/MonitorRecommendationAlertDebuggability.test.ts

@@ -297,6 +297,7 @@ describe("Recommendation templates produce debuggable alerts", () => {
       MonitorType.DockerSwarm,
       MonitorType.Host,
       MonitorType.Proxmox,
+      MonitorType.VMware,
       MonitorType.Ceph,
     ];
 

package/Tests/Types/Monitor/Recommendation/MonitorRecommendationCatalog.test.ts

@@ -18,6 +18,7 @@ import { getAllKubernetesAlertTemplates } from "../../../../Types/Monitor/Kubern
 import { getAllPodmanAlertTemplates } from "../../../../Types/Monitor/PodmanAlertTemplates";
 import { getAllProxmoxAlertTemplates } from "../../../../Types/Monitor/ProxmoxAlertTemplates";
 import { getAllRumAlertTemplates } from "../../../../Types/Monitor/RumAlertTemplates";
+import { getAllVMwareAlertTemplates } from "../../../../Types/Monitor/VMwareAlertTemplates";
 import {
   getAllServiceAlertTemplates,
   getLanguagesWithServiceAlertTemplates,
@@ -64,6 +65,7 @@ interface ModuleExpectation {
   contextFreeTemplateCount: number;
   identifierFieldName:
     | "clusterIdentifier"
+    | "vcenterIdentifier"
     | "hostIdentifier"
     | "fleetIdentifier"
     | "rumApplicationId"
@@ -113,6 +115,13 @@ const MODULE_EXPECTATIONS: Array<ModuleExpectation> = [
     contextFreeTemplateCount: getAllProxmoxAlertTemplates().length,
     identifierFieldName: "clusterIdentifier",
   },
+  {
+    resourceType: MonitorRecommendationResourceType.VMware,
+    monitorTypes: [MonitorType.VMware],
+    templateCount: getAllVMwareAlertTemplates().length,
+    contextFreeTemplateCount: getAllVMwareAlertTemplates().length,
+    identifierFieldName: "vcenterIdentifier",
+  },
   {
     resourceType: MonitorRecommendationResourceType.Ceph,
     monitorTypes: [MonitorType.Ceph],

package/Tests/Types/Monitor/Recommendation/MonitorRecommendationCoverage.test.ts

@@ -513,7 +513,7 @@ describe("MonitorRecommendationUtil.getCoveredRecommendationMonitorIds", () => {
      * both a covered and an uncovered answer are exercised for all eight
      * resource types.
      */
-    expect(RESOURCE_TYPE_DEFINITIONS.length).toBe(10);
+    expect(RESOURCE_TYPE_DEFINITIONS.length).toBe(11);
 
     for (const definition of RESOURCE_TYPE_DEFINITIONS) {
       const recommendations: Array<MonitorRecommendation> =

package/Tests/Types/Monitor/Recommendation/MonitorRecommendationNotificationMode.test.ts

@@ -194,7 +194,7 @@ describe("MonitorRecommendationNotificationMode", () => {
     it("has recommendations to test at all", () => {
       // Guards every for-loop in this file against a vacuous pass.
       expect(ALL_RECOMMENDATIONS.length).toBeGreaterThan(0);
-      expect(ONE_PER_RESOURCE_TYPE.length).toBe(10);
+      expect(ONE_PER_RESOURCE_TYPE.length).toBe(11);
     });
 
     it("ships every unhealthy criteria with createIncidents AND createAlerts true, and both arrays populated", () => {