@openshift-migration-advisor/shared-components 0.22.0-aaabd4569e38 → 0.23.0-54185b7f1be8

package/src/report/__tests__/infrastructureSummary.test.ts

@@ -0,0 +1,224 @@
+import { describe, expect, it } from "vitest";
+import {
+  booleanToFeatureStatus,
+  buildClusterDetailRows,
+  buildClusterDetails,
+  buildInfrastructureSummary,
+  countVCenters,
+  formatVSphereVersion,
+  hostCapabilityStatus,
+  type InventoryCluster,
+  type InventoryHost,
+  type InventoryInfra,
+  visibleNetworks,
+  vsanStatus,
+} from "../infrastructureSummary.js";
+
+const createInfra = (
+  overrides: Partial<InventoryInfra> = {},
+): InventoryInfra => ({
+  totalHosts: 0,
+  networks: [],
+  datastores: [],
+  ...overrides,
+});
+
+describe("formatVSphereVersion", () => {
+  it("formats API versions as vSphere labels and drops trailing build zeros", () => {
+    expect(formatVSphereVersion("7.0.3.0")).toBe("vSphere 7.0.3");
+    expect(formatVSphereVersion("8.0.3.0")).toBe("vSphere 8.0.3");
+  });
+
+  it("keeps an existing vSphere prefix and missing values", () => {
+    expect(formatVSphereVersion("vSphere 7.0.3")).toBe("vSphere 7.0.3");
+    expect(formatVSphereVersion(undefined)).toBe("—");
+    expect(formatVSphereVersion("")).toBe("—");
+  });
+});
+
+describe("feature status helpers", () => {
+  it("maps booleans to enabled, disabled, or unknown", () => {
+    expect(booleanToFeatureStatus(true)).toBe("enabled");
+    expect(booleanToFeatureStatus(false)).toBe("disabled");
+    expect(booleanToFeatureStatus(undefined)).toBe("unknown");
+  });
+
+  it("treats vMotion as enabled when any host supports it", () => {
+    const hosts: InventoryHost[] = [
+      { vmotionSupported: false },
+      { vmotionSupported: true },
+    ];
+    expect(hostCapabilityStatus(hosts, "vmotionSupported")).toBe("enabled");
+  });
+
+  it("treats vMotion as disabled when every known host reports false", () => {
+    const hosts: InventoryHost[] = [
+      { vmotionSupported: false },
+      { vmotionSupported: false },
+    ];
+    expect(hostCapabilityStatus(hosts, "vmotionSupported")).toBe("disabled");
+  });
+
+  it("treats missing host capability flags as unknown", () => {
+    expect(hostCapabilityStatus([{}], "vmotionSupported")).toBe("unknown");
+    expect(hostCapabilityStatus([], "vmotionSupported")).toBe("unknown");
+  });
+
+  it("detects vSAN from datastore type or disk type", () => {
+    expect(
+      vsanStatus(
+        createInfra({
+          datastores: [{ type: "vSAN" }],
+        }),
+      ),
+    ).toBe("enabled");
+    expect(
+      vsanStatus(createInfra(), { total: 10, diskTypes: { vSAN: {} } }),
+    ).toBe("enabled");
+    expect(vsanStatus(createInfra({ datastores: [] }))).toBe("disabled");
+    expect(vsanStatus()).toBe("unknown");
+  });
+});
+
+describe("buildInfrastructureSummary", () => {
+  it("maps inventory metadata into the summary card model", () => {
+    const summary = buildInfrastructureSummary({
+      infra: createInfra({
+        totalHosts: 12,
+        totalDatacenters: 1,
+      }),
+      vcenterVersion: "7.0.3.0",
+      vcenterId: "vc-1",
+      clusters: {},
+    });
+
+    expect(summary).toEqual({
+      vmwareVersion: "vSphere 7.0.3",
+      datacenters: 1,
+      vCenters: 1,
+      esxiHosts: 12,
+    });
+  });
+
+  it("falls back to clustersPerDatacenter length and unique vCenter ids", () => {
+    const summary = buildInfrastructureSummary({
+      infra: createInfra({
+        totalHosts: 7,
+        clustersPerDatacenter: [1, 1],
+      }),
+      clusters: {
+        A: {
+          infra: createInfra(),
+          vms: { total: 1 },
+          vcenter: { id: "vc-a" },
+        },
+        B: {
+          infra: createInfra(),
+          vms: { total: 1 },
+          vcenter: { id: "vc-b" },
+        },
+      },
+    });
+
+    expect(summary.datacenters).toBe(2);
+    expect(summary.vCenters).toBe(2);
+  });
+});
+
+describe("countVCenters", () => {
+  it("returns undefined when no vCenter identity is present", () => {
+    expect(countVCenters(undefined, undefined)).toBeUndefined();
+  });
+});
+
+describe("cluster details", () => {
+  it("builds sorted aggregate rows from cluster features", () => {
+    const clusters: Record<string, InventoryCluster> = {
+      "Cluster-Dev-02": {
+        infra: createInfra({
+          totalHosts: 7,
+          hosts: [{ vmotionSupported: true }],
+          datastores: [],
+        }),
+        vms: { total: 350 },
+        clusterFeatures: { drsEnabled: false, haEnabled: true },
+      },
+      "Cluster-Prod-01": {
+        infra: createInfra({
+          totalHosts: 5,
+          hosts: [{ vmotionSupported: true }],
+          datastores: [{ type: "vSAN" }],
+        }),
+        vms: { total: 280 },
+        clusterFeatures: { drsEnabled: true, haEnabled: true },
+      },
+    };
+
+    const rows = buildClusterDetailRows(clusters);
+    expect(rows.map((row) => row.name)).toEqual([
+      "Cluster-Dev-02",
+      "Cluster-Prod-01",
+    ]);
+    expect(rows[0]).toMatchObject({
+      hosts: 7,
+      vms: 350,
+      vmotion: "enabled",
+      drs: "disabled",
+      vsan: "disabled",
+    });
+    expect(rows[1]).toMatchObject({
+      hosts: 5,
+      vms: 280,
+      drs: "enabled",
+      vsan: "enabled",
+    });
+  });
+
+  it("builds the detailed cluster model including HA and network labels", () => {
+    const details = buildClusterDetails({
+      infra: createInfra({
+        totalHosts: 7,
+        hosts: [{ vmotionSupported: true }],
+        networks: [
+          { type: "distributed", name: "VDS-Dev", vlanId: "10" },
+          { type: "distributed", name: "VDS-Dev", vlanId: "11" },
+          { type: "dvswitch", name: "vDSwitch0" },
+        ],
+      }),
+      vms: { total: 350 },
+      clusterFeatures: { drsEnabled: false, haEnabled: true },
+    });
+
+    expect(details).toMatchObject({
+      hosts: 7,
+      vms: 350,
+      networksDetected: 2,
+      vmotion: "enabled",
+      drs: "disabled",
+      ha: "enabled",
+      vsan: "disabled",
+    });
+    expect(details?.networks.map((network) => network.displayName)).toEqual([
+      "VDS-Dev (VLAN 10)",
+      "VDS-Dev (VLAN 11)",
+    ]);
+  });
+});
+
+describe("visibleNetworks", () => {
+  it("omits unnamed networks and dvswitches", () => {
+    expect(
+      visibleNetworks(
+        createInfra({
+          networks: [
+            { type: "distributed", name: "  " },
+            { type: "dvswitch", name: "switch" },
+            { type: "standard", name: "VM Network" },
+          ],
+        }),
+      ),
+    ).toEqual([
+      { name: "VM Network", vlanId: undefined, displayName: "VM Network" },
+    ]);
+  });
+});

package/src/report/__tests__/powerStates.test.ts

@@ -0,0 +1,70 @@
+import { describe, expect, it } from "vitest";
+import {
+  buildHostPowerStateChart,
+  buildVmPowerStateChart,
+} from "../powerStates.js";
+
+describe("buildHostPowerStateChart", () => {
+  it("maps overallStatus green to powered on and keeps zero categories", () => {
+    const chart = buildHostPowerStateChart({ green: 7 });
+
+    expect(chart.total).toBe(7);
+    expect(chart.slices.map((slice) => [slice.name, slice.count])).toEqual([
+      ["Powered on", 7],
+      ["Powered off", 0],
+      ["Standby", 0],
+      ["Not responding", 0],
+      ["Maintenance", 0],
+    ]);
+    expect(chart.slices[0].countDisplay).toBe("7 hosts");
+  });
+
+  it("maps explicit host power and maintenance keys", () => {
+    const chart = buildHostPowerStateChart({
+      poweredOn: 5,
+      poweredOff: 1,
+      standBy: 1,
+      notResponding: 1,
+      inMaintenanceMode: 2,
+    });
+
+    expect(chart.total).toBe(10);
+    expect(
+      chart.slices.find((slice) => slice.name === "Maintenance")?.count,
+    ).toBe(2);
+    expect(
+      chart.slices.find((slice) => slice.name === "Not responding")?.count,
+    ).toBe(1);
+  });
+});
+
+describe("buildVmPowerStateChart", () => {
+  it("maps VM power states and omits unused suspended", () => {
+    const chart = buildVmPowerStateChart({
+      poweredOff: 297,
+      poweredOn: 53,
+    });
+
+    expect(chart.total).toBe(350);
+    expect(chart.slices.map((slice) => [slice.name, slice.count])).toEqual([
+      ["Powered off", 297],
+      ["Powered on", 53],
+    ]);
+    expect(chart.slices[0].countDisplay).toBe("297 VMs");
+  });
+
+  it("includes suspended when present", () => {
+    const chart = buildVmPowerStateChart({
+      poweredOn: 10,
+      poweredOff: 2,
+      suspended: 1,
+    });
+
+    expect(chart.slices.map((slice) => slice.name)).toEqual([
+      "Powered off",
+      "Powered on",
+      "Suspended",
+    ]);
+    expect(chart.slices[2].countDisplay).toBe("1 VM");
+  });
+});

package/src/report/constants.ts

@@ -25,4 +25,6 @@ export const REPORT_CARD_EMPTY_STATE_TITLES = {
   operatingSystems: "Operating system data not collected",
   migrationStatus: "Migration status data not collected",
   issuesBreakdown: "Issues breakdown data not collected",
+  hostPowerStates: "Host power state data not collected",
+  vmPowerStates: "VM power state data not collected",
 } as const;

package/src/report/index.ts

@@ -17,6 +17,43 @@ export {
   EmptySearchResults,
   type EmptySearchResultsProps,
 } from "./EmptySearchResults.js";
+export {
+  FeatureStatusBadge,
+  type FeatureStatusBadgeProps,
+} from "./FeatureStatusBadge.js";
+export {
+  HostPowerStates,
+  type HostPowerStatesProps,
+} from "./HostPowerStates.js";
+export {
+  InfrastructureSummary,
+  type InfrastructureSummaryProps,
+} from "./InfrastructureSummary.js";
+export type {
+  ClusterDetailRow,
+  ClusterDetailsModel,
+  FeatureStatus,
+  HostCapability,
+  InfrastructureSummaryModel,
+  InventoryCluster,
+  InventoryDatastore,
+  InventoryHost,
+  InventoryInfra,
+  InventoryNetwork,
+  InventoryVms,
+  NetworkLabel,
+} from "./infrastructureSummary.js";
+export {
+  booleanToFeatureStatus,
+  buildClusterDetailRows,
+  buildClusterDetails,
+  buildInfrastructureSummary,
+  countVCenters,
+  formatVSphereVersion,
+  hostCapabilityStatus,
+  visibleNetworks,
+  vsanStatus,
+} from "./infrastructureSummary.js";
 export { OSBarChart, OSDistribution } from "./OSDistribution.js";
 export { OsSupportTiersHelpPopover } from "./OsSupportTiersHelpPopover.js";
 export { OsUpgradeNotice } from "./OsUpgradeNotice.js";
@@ -45,6 +82,17 @@ export {
   SupportTier,
 } from "./osSupportTier.js";
 export { default as PopoverIcon } from "./PopoverIcon.js";
+export {
+  PowerStateCard,
+  type PowerStateCardProps,
+} from "./PowerStateCard.js";
+export type { PowerStateChartModel } from "./powerStates.js";
+export {
+  buildHostPowerStateChart,
+  buildVmPowerStateChart,
+  HOST_POWER_COLORS,
+  VM_POWER_COLORS,
+} from "./powerStates.js";
 export { SupportTierBadge } from "./SupportTierBadge.js";
 export {
   ALL_TIERS_FILTER,
@@ -52,3 +100,11 @@ export {
   type OsTableRow,
   useOsBarChartViewModel,
 } from "./useOsBarChartViewModel.js";
+export {
+  VCenterClusterDetails,
+  type VCenterClusterDetailsProps,
+} from "./VCenterClusterDetails.js";
+export {
+  VmPowerStates,
+  type VmPowerStatesProps,
+} from "./VmPowerStates.js";

package/src/report/infrastructureSummary.ts

@@ -0,0 +1,281 @@
+export type FeatureStatus = "enabled" | "disabled" | "unknown";
+
+export type HostCapability = "vmotionSupported" | "storageVmotionSupported";
+
+export type InventoryHost = {
+  vmotionSupported?: boolean;
+  storageVmotionSupported?: boolean;
+};
+
+export type InventoryDatastore = {
+  type?: string;
+};
+
+export type InventoryNetwork = {
+  name: string;
+  type?: string;
+  vlanId?: string;
+};
+
+export type InventoryInfra = {
+  totalHosts?: number;
+  totalDatacenters?: number;
+  hosts?: InventoryHost[];
+  clustersPerDatacenter?: number[];
+  networks?: InventoryNetwork[];
+  datastores?: InventoryDatastore[];
+};
+
+export type InventoryVms = {
+  total?: number;
+  diskTypes?: Record<string, unknown>;
+};
+
+export type InventoryCluster = {
+  infra?: InventoryInfra;
+  vms?: InventoryVms;
+  vcenter?: { id?: string };
+  clusterFeatures?: {
+    drsEnabled?: boolean;
+    haEnabled?: boolean;
+  };
+};
+
+export type InfrastructureSummaryModel = {
+  vmwareVersion: string;
+  datacenters: number | undefined;
+  vCenters: number | undefined;
+  esxiHosts: number | undefined;
+};
+
+export type NetworkLabel = {
+  name: string;
+  vlanId?: string;
+  displayName: string;
+};
+
+export type ClusterDetailRow = {
+  id: string;
+  name: string;
+  hosts: number;
+  vms: number;
+  vmotion: FeatureStatus;
+  drs: FeatureStatus;
+  vsan: FeatureStatus;
+};
+
+export type ClusterDetailsModel = {
+  hosts: number;
+  vms: number;
+  networksDetected: number;
+  vmotion: FeatureStatus;
+  drs: FeatureStatus;
+  ha: FeatureStatus;
+  vsan: FeatureStatus;
+  networks: NetworkLabel[];
+};
+
+const VSAN_TYPE_PATTERN = /vsan/i;
+
+export const formatVSphereVersion = (version?: string): string => {
+  if (!version?.trim()) {
+    return "—";
+  }
+
+  const withoutPrefix = version.trim().replace(/^vSphere\s+/i, "");
+  const parts = withoutPrefix.split(".");
+  while (parts.length > 3 && parts[parts.length - 1] === "0") {
+    parts.pop();
+  }
+
+  return `vSphere ${parts.join(".")}`;
+};
+
+export const booleanToFeatureStatus = (
+  value: boolean | undefined,
+): FeatureStatus => {
+  if (value === true) {
+    return "enabled";
+  }
+  if (value === false) {
+    return "disabled";
+  }
+  return "unknown";
+};
+
+export const hostCapabilityStatus = (
+  hosts: InventoryHost[] | undefined,
+  capability: HostCapability,
+): FeatureStatus => {
+  if (!hosts || hosts.length === 0) {
+    return "unknown";
+  }
+
+  const known = hosts
+    .map((host) => host[capability])
+    .filter((value): value is boolean => typeof value === "boolean");
+
+  if (known.length === 0) {
+    return "unknown";
+  }
+
+  return known.some(Boolean) ? "enabled" : "disabled";
+};
+
+export const vsanStatus = (
+  infra?: InventoryInfra,
+  vms?: InventoryVms,
+): FeatureStatus => {
+  const datastoreMatch = infra?.datastores?.some((datastore) =>
+    VSAN_TYPE_PATTERN.test(datastore.type ?? ""),
+  );
+  const diskTypeMatch = Object.keys(vms?.diskTypes ?? {}).some((type) =>
+    VSAN_TYPE_PATTERN.test(type),
+  );
+
+  if (datastoreMatch || diskTypeMatch) {
+    return "enabled";
+  }
+
+  if (infra?.datastores || vms?.diskTypes) {
+    return "disabled";
+  }
+
+  return "unknown";
+};
+
+const hostCount = (infra?: InventoryInfra): number | undefined => {
+  if (typeof infra?.totalHosts === "number") {
+    return infra.totalHosts;
+  }
+  if (infra?.hosts) {
+    return infra.hosts.length;
+  }
+  return undefined;
+};
+
+const datacenterCount = (infra?: InventoryInfra): number | undefined => {
+  if (typeof infra?.totalDatacenters === "number") {
+    return infra.totalDatacenters;
+  }
+  if (infra?.clustersPerDatacenter && infra.clustersPerDatacenter.length > 0) {
+    return infra.clustersPerDatacenter.length;
+  }
+  return undefined;
+};
+
+export const countVCenters = (
+  clusters?: Record<string, InventoryCluster>,
+  vcenterId?: string,
+): number | undefined => {
+  const ids = new Set<string>();
+  if (vcenterId) {
+    ids.add(vcenterId);
+  }
+  for (const cluster of Object.values(clusters ?? {})) {
+    if (cluster.vcenter?.id) {
+      ids.add(cluster.vcenter.id);
+    }
+  }
+  return ids.size > 0 ? ids.size : undefined;
+};
+
+const toNetworkLabel = (network: InventoryNetwork): NetworkLabel => {
+  const vlanId = network.vlanId?.trim();
+  return {
+    name: network.name,
+    vlanId: vlanId || undefined,
+    displayName: vlanId ? `${network.name} (VLAN ${vlanId})` : network.name,
+  };
+};
+
+export const visibleNetworks = (infra?: InventoryInfra): NetworkLabel[] =>
+  (infra?.networks ?? [])
+    .filter(
+      (network) => Boolean(network.name?.trim()) && network.type !== "dvswitch",
+    )
+    .map(toNetworkLabel);
+
+export const buildInfrastructureSummary = ({
+  infra,
+  vcenterVersion,
+  vcenterId,
+  clusters,
+}: {
+  infra?: InventoryInfra;
+  vcenterVersion?: string;
+  vcenterId?: string;
+  clusters?: Record<string, InventoryCluster>;
+}): InfrastructureSummaryModel => ({
+  vmwareVersion: formatVSphereVersion(vcenterVersion),
+  datacenters: datacenterCount(infra),
+  vCenters: countVCenters(clusters, vcenterId),
+  esxiHosts: hostCount(infra),
+});
+
+const clusterFeatureStatus = (
+  cluster: InventoryCluster,
+): Pick<ClusterDetailRow, "vmotion" | "drs" | "vsan"> & {
+  ha: FeatureStatus;
+} => ({
+  vmotion: hostCapabilityStatus(cluster.infra?.hosts, "vmotionSupported"),
+  drs: booleanToFeatureStatus(cluster.clusterFeatures?.drsEnabled),
+  ha: booleanToFeatureStatus(cluster.clusterFeatures?.haEnabled),
+  vsan: vsanStatus(cluster.infra, cluster.vms),
+});
+
+const compareClustersByVmCount = (
+  a: string,
+  b: string,
+  clusters: Record<string, InventoryCluster>,
+): number => {
+  const vmsA = clusters[a]?.vms?.total ?? 0;
+  const vmsB = clusters[b]?.vms?.total ?? 0;
+  return vmsB - vmsA || a.localeCompare(b);
+};
+
+export const buildClusterDetailRows = (
+  clusters?: Record<string, InventoryCluster>,
+): ClusterDetailRow[] => {
+  if (!clusters) {
+    return [];
+  }
+
+  return Object.keys(clusters)
+    .sort((a, b) => compareClustersByVmCount(a, b, clusters))
+    .map((id) => {
+      const cluster = clusters[id];
+      const features = clusterFeatureStatus(cluster);
+      return {
+        id,
+        name: id,
+        hosts: hostCount(cluster.infra) ?? 0,
+        vms: cluster.vms?.total ?? 0,
+        vmotion: features.vmotion,
+        drs: features.drs,
+        vsan: features.vsan,
+      };
+    });
+};
+
+export const buildClusterDetails = (
+  cluster?: InventoryCluster,
+): ClusterDetailsModel | undefined => {
+  if (!cluster) {
+    return undefined;
+  }
+
+  const networks = visibleNetworks(cluster.infra);
+  const features = clusterFeatureStatus(cluster);
+
+  return {
+    hosts: hostCount(cluster.infra) ?? 0,
+    vms: cluster.vms?.total ?? 0,
+    networksDetected: networks.length,
+    vmotion: features.vmotion,
+    drs: features.drs,
+    ha: features.ha,
+    vsan: features.vsan,
+    networks,
+  };
+};