@oneuptime/common 13.0.0 → 13.0.1

package/Tests/Server/Utils/Dashboard/PublicDashboardResourceListPolicy.test.ts

@@ -422,6 +422,62 @@ const MAPPING_CASES: Array<MappingCase> = [
     expectedSort: { name: SortOrder.Ascending },
     expectedLimit: 25,
   },
+  {
+    name: "vmware host",
+    componentType: DashboardComponentType.VMwareHostList,
+    resourceType: "vmware-resource",
+    argumentsObject: {
+      vmwareVCenterIds: ["vcenter"],
+      /*
+       * The vcenter receiver reports no per-host state, so the host widget
+       * offers no status filter; a stray one must not reach the query.
+       */
+      statusFilter: "online",
+      powerStateFilter: "on",
+    },
+    expectedQuery: {
+      kind: "Host",
+      vmwareVCenterId: new Includes(["vcenter"]),
+    },
+    expectedSort: { name: SortOrder.Ascending },
+    expectedLimit: 25,
+  },
+  {
+    name: "vmware virtual machine",
+    componentType: DashboardComponentType.VMwareVirtualMachineList,
+    resourceType: "vmware-resource",
+    argumentsObject: {
+      vmwareVCenterIds: ["vcenter"],
+      powerStateFilter: "on",
+      templateFilter: "exclude",
+    },
+    expectedQuery: {
+      kind: "VirtualMachine",
+      vmwareVCenterId: new Includes(["vcenter"]),
+      isPoweredOn: true,
+      isTemplate: false,
+    },
+    expectedSort: { name: SortOrder.Ascending },
+    expectedLimit: 25,
+  },
+  {
+    name: "vmware virtual machine templates only, powered off",
+    componentType: DashboardComponentType.VMwareVirtualMachineList,
+    resourceType: "vmware-resource",
+    argumentsObject: {
+      vmwareVCenterIds: ["vcenter"],
+      powerStateFilter: "off",
+      templateFilter: "only",
+    },
+    expectedQuery: {
+      kind: "VirtualMachine",
+      vmwareVCenterId: new Includes(["vcenter"]),
+      isPoweredOn: false,
+      isTemplate: true,
+    },
+    expectedSort: { name: SortOrder.Ascending },
+    expectedLimit: 25,
+  },
   {
     name: "ceph OSD",
     componentType: DashboardComponentType.CephOsdList,
@@ -567,7 +623,23 @@ describe("PublicDashboardResourceListPolicy", () => {
       const swarmService: JSONObject = build({
         componentType: DashboardComponentType.DockerSwarmServiceList,
       }).select;
+      const vmwareHost: JSONObject = build({
+        componentType: DashboardComponentType.VMwareHostList,
+      }).select;
+      const vmwareVirtualMachine: JSONObject = build({
+        componentType: DashboardComponentType.VMwareVirtualMachineList,
+      }).select;
 
+      expect(vmwareHost["cpuCapacityMhz"]).toBe(true);
+      expect(vmwareHost["maxMemoryBytes"]).toBe(true);
+      expect(vmwareHost["isPoweredOn"]).toBeUndefined();
+      expect(vmwareHost["isTemplate"]).toBeUndefined();
+      expect(vmwareHost["hostName"]).toBeUndefined();
+      expect(vmwareVirtualMachine["isPoweredOn"]).toBe(true);
+      expect(vmwareVirtualMachine["isTemplate"]).toBe(true);
+      expect(vmwareVirtualMachine["hostName"]).toBe(true);
+      expect(vmwareVirtualMachine["cpuCapacityMhz"]).toBeUndefined();
+      expect(vmwareVirtualMachine["maxMemoryBytes"]).toBeUndefined();
       expect(proxmoxNode["latestCpuPercent"]).toBe(true);
       expect(proxmoxNode["vmid"]).toBeUndefined();
       expect(proxmoxGuest["vmid"]).toBe(true);
@@ -598,6 +670,279 @@ describe("PublicDashboardResourceListPolicy", () => {
     });
   });
 
+  describe("VMware widgets", () => {
+    const vmwareWidgets: Array<DashboardComponentType> = [
+      DashboardComponentType.VMwareHostList,
+      DashboardComponentType.VMwareVirtualMachineList,
+    ];
+
+    it("resolves both widgets to the vmware-resource registry key", () => {
+      for (const componentType of vmwareWidgets) {
+        expect(build({ componentType }).resourceType).toBe("vmware-resource");
+      }
+    });
+
+    it("owns the kind and never copies a caller-supplied one", () => {
+      const host: PublicDashboardResourceListPolicyResult = build({
+        componentType: DashboardComponentType.VMwareHostList,
+        argumentsObject: { kind: "VirtualMachine" },
+        requestedQuery: { kind: "Datastore", projectId: "other" },
+      });
+      const virtualMachine: PublicDashboardResourceListPolicyResult = build({
+        componentType: DashboardComponentType.VMwareVirtualMachineList,
+        argumentsObject: { kind: "Host" },
+        requestedQuery: { kind: "Datastore", projectId: "other" },
+      });
+
+      expect(host.query).toEqual({ kind: "Host" });
+      expect(virtualMachine.query).toEqual({ kind: "VirtualMachine" });
+    });
+
+    it("whitelists the virtual machine power-state and template filters", () => {
+      const expectations: Array<{
+        argumentsObject: JSONObject;
+        expectedQuery: JSONObject;
+      }> = [
+        {
+          argumentsObject: { powerStateFilter: "on" },
+          expectedQuery: { kind: "VirtualMachine", isPoweredOn: true },
+        },
+        {
+          argumentsObject: { powerStateFilter: "off" },
+          expectedQuery: { kind: "VirtualMachine", isPoweredOn: false },
+        },
+        {
+          argumentsObject: { templateFilter: "exclude" },
+          expectedQuery: { kind: "VirtualMachine", isTemplate: false },
+        },
+        {
+          argumentsObject: { templateFilter: "only" },
+          expectedQuery: { kind: "VirtualMachine", isTemplate: true },
+        },
+        // "" means All for both filters.
+        {
+          argumentsObject: { powerStateFilter: "", templateFilter: "" },
+          expectedQuery: { kind: "VirtualMachine" },
+        },
+        // Proxmox-style filters mean nothing to a VMware widget.
+        {
+          argumentsObject: { statusFilter: "running", guestTypeFilter: "qemu" },
+          expectedQuery: { kind: "VirtualMachine" },
+        },
+      ];
+
+      for (const expectation of expectations) {
+        expect(
+          build({
+            componentType: DashboardComponentType.VMwareVirtualMachineList,
+            argumentsObject: expectation.argumentsObject,
+          }).query,
+        ).toEqual(expectation.expectedQuery);
+      }
+
+      /*
+       * Anything outside the whitelist fails closed rather than reaching
+       * the query: the receiver never reports "suspended" separately from
+       * "off", and a non-string can never be a stored filter.
+       */
+      for (const invalidArguments of [
+        { powerStateFilter: "suspended" },
+        { powerStateFilter: "running" },
+        { powerStateFilter: true },
+        { templateFilter: "include" },
+        { templateFilter: ["only"] },
+        { templateFilter: 1 },
+      ] as Array<JSONObject>) {
+        expect(() => {
+          return build({
+            componentType: DashboardComponentType.VMwareVirtualMachineList,
+            argumentsObject: invalidArguments,
+          });
+        }).toThrow(BadDataException);
+      }
+    });
+
+    it("scopes hosts and virtual machines to the stored vCenter ids only", () => {
+      for (const componentType of vmwareWidgets) {
+        const result: PublicDashboardResourceListPolicyResult = build({
+          componentType,
+          argumentsObject: { vmwareVCenterIds: ["a", "b"] },
+          requestedQuery: { vmwareVCenterId: "forged" },
+        });
+        expect(result.query["vmwareVCenterId"]).toEqual(
+          new Includes(["a", "b"]),
+        );
+
+        const unscoped: PublicDashboardResourceListPolicyResult = build({
+          componentType,
+          argumentsObject: { vmwareVCenterIds: [] },
+        });
+        expect(unscoped.query["vmwareVCenterId"]).toBeUndefined();
+      }
+    });
+
+    it("interpolates host variables by vSphere attribute, bare or resource-prefixed", () => {
+      const hostVariable: JSONObject = {
+        id: "host",
+        name: "Host",
+        type: DashboardVariableType.TelemetryAttribute,
+        attributeKey: "resource.vcenter.host.name",
+      };
+      const clusterVariable: JSONObject = {
+        id: "cluster",
+        name: "Cluster",
+        type: DashboardVariableType.TelemetryAttribute,
+        attributeKey: "vcenter.cluster.name",
+        isMultiSelect: true,
+      };
+      const datacenterVariable: JSONObject = {
+        id: "datacenter",
+        name: "Datacenter",
+        type: DashboardVariableType.TelemetryAttribute,
+        attributeKey: "vcenter.datacenter.name",
+        defaultValue: "dc-1",
+      };
+
+      const result: PublicDashboardResourceListPolicyResult = build({
+        componentType: DashboardComponentType.VMwareHostList,
+        storedVariables: [hostVariable, clusterVariable, datacenterVariable],
+        requestedVariables: [
+          { id: "host", selectedValue: "esxi-01.example.com" },
+          {
+            id: "cluster",
+            selectedValue: null,
+            selectedValues: ["prod", "dr"],
+          },
+          { id: "datacenter", selectedValue: null },
+        ],
+      });
+
+      expect(result.query).toEqual({
+        kind: "Host",
+        name: "esxi-01.example.com",
+        clusterName: new Includes(["prod", "dr"]),
+        datacenterName: "dc-1",
+      });
+    });
+
+    it("interpolates virtual machine variables onto the VM's own columns", () => {
+      const result: PublicDashboardResourceListPolicyResult = build({
+        componentType: DashboardComponentType.VMwareVirtualMachineList,
+        argumentsObject: { powerStateFilter: "on" },
+        storedVariables: [
+          {
+            id: "vm",
+            name: "VM",
+            type: DashboardVariableType.TelemetryAttribute,
+            attributeKey: "vcenter.vm.name",
+          },
+          {
+            id: "host",
+            name: "Host",
+            type: DashboardVariableType.TelemetryAttribute,
+            attributeKey: "resource.vcenter.host.name",
+          },
+          {
+            id: "cluster",
+            name: "Cluster",
+            type: DashboardVariableType.TelemetryAttribute,
+            attributeKey: "resource.vcenter.cluster.name",
+          },
+        ],
+        requestedVariables: [
+          { id: "vm", selectedValue: "web-01" },
+          { id: "host", selectedValue: "esxi-01.example.com" },
+          { id: "cluster", selectedValue: "prod" },
+        ],
+      });
+
+      /*
+       * For a VM the host attribute is its PARENT host (hostName), not the
+       * row's own name — the maps differ between the two widgets on purpose.
+       */
+      expect(result.query).toEqual({
+        kind: "VirtualMachine",
+        isPoweredOn: true,
+        name: "web-01",
+        hostName: "esxi-01.example.com",
+        clusterName: "prod",
+      });
+    });
+
+    it("ignores variables keyed on attributes the widget does not map", () => {
+      const result: PublicDashboardResourceListPolicyResult = build({
+        componentType: DashboardComponentType.VMwareHostList,
+        storedVariables: [
+          {
+            id: "vm",
+            name: "VM",
+            type: DashboardVariableType.TelemetryAttribute,
+            attributeKey: "vcenter.vm.name",
+          },
+          {
+            id: "datastore",
+            name: "Datastore",
+            type: DashboardVariableType.TelemetryAttribute,
+            attributeKey: "vcenter.datastore.name",
+          },
+        ],
+        requestedVariables: [
+          { id: "vm", selectedValue: "web-01" },
+          { id: "datastore", selectedValue: "vsanDatastore" },
+        ],
+      });
+
+      expect(result.query).toEqual({ kind: "Host" });
+    });
+
+    it("projects only public-safe inventory columns", () => {
+      const publicColumns: Array<string> = [
+        "_id",
+        "name",
+        "externalId",
+        "kind",
+        "datacenterName",
+        "clusterName",
+        "hostName",
+        "resourcePoolName",
+        "isPoweredOn",
+        "isTemplate",
+        "latestCpuPercent",
+        "latestMemoryPercent",
+        "latestDiskPercent",
+        "cpuCapacityMhz",
+        "maxMemoryBytes",
+        "metricsUpdatedAt",
+        "vmwareVCenterId",
+        "vmwareVCenter",
+      ];
+      const privateColumns: Array<string> = [
+        "projectId",
+        "project",
+        "createdByUserId",
+        "createdByUser",
+        "deletedByUserId",
+        "deletedByUser",
+        "resourcePoolPath",
+        "virtualAppName",
+        "vmInstanceUuid",
+        "lastSeenAt",
+      ];
+
+      for (const componentType of vmwareWidgets) {
+        const select: JSONObject = build({ componentType }).select;
+
+        for (const column of Object.keys(select)) {
+          expect(publicColumns).toContain(column);
+        }
+        for (const column of privateColumns) {
+          expect(select[column]).toBeUndefined();
+        }
+        expect(select["vmwareVCenter"]).toEqual({ name: true });
+      }
+    });
+  });
+
   describe("SLO widgets", () => {
     const sloArguments: JSONObject = {
       serviceLevelObjectiveId: SLO_ID.toString(),