@skyhook-io/radar-app 1.9.0 → 1.9.2

package/src/components/capacity/DemandNomination.test.tsx

@@ -0,0 +1,151 @@
+import { describe, expect, it, vi } from "vitest";
+import { renderToString } from "react-dom/server";
+import { MemoryRouter } from "react-router-dom";
+import { QueryClient, QueryClientProvider } from "@tanstack/react-query";
+import type {
+  CapacityBoundedResultMeta,
+  CapacityDemandGroup,
+  CapacityDemandResponse,
+  CapacityDemandSummary,
+  CapacityQuantityObservation,
+  CapacityResponseMeta,
+  CapacitySourceCoverage,
+} from "@skyhook-io/k8s-ui";
+import { CapacityView } from "./CapacityView";
+
+vi.mock("../../context/ConnectionContext", () => ({
+  useConnection: () => ({ connection: { state: "connected" } }),
+}));
+
+const generatedAt = "2026-07-13T08:00:00Z";
+
+function sourceCoverage(
+  status: CapacitySourceCoverage["status"] = "available",
+): CapacitySourceCoverage {
+  return {
+    status,
+    scope: "cluster",
+    observedAt: generatedAt,
+    impactFields: [],
+  };
+}
+
+const meta: CapacityResponseMeta = {
+  schemaVersion: "v1alpha1",
+  generatedAt,
+  clusterContext: { contextName: "radar-test-eks", clusterName: "radar-test" },
+  provider: {
+    type: "karpenter",
+    controllerMode: "self_managed",
+    apiVersionsByKind: { NodePool: ["v1"], NodeClaim: ["v1"] },
+    nodeClassKinds: [],
+    features: { staticCapacity: true, metrics: true },
+  },
+  coverage: {
+    nodePools: sourceCoverage(),
+    nodeClaims: sourceCoverage(),
+    nodeClasses: sourceCoverage(),
+    nodes: sourceCoverage(),
+    pods: sourceCoverage(),
+    workloads: sourceCoverage(),
+    nodeMetrics: sourceCoverage(),
+    karpenterObjectEvents: sourceCoverage(),
+    timeline: sourceCoverage(),
+  },
+};
+
+function quantity(
+  resources: Record<string, string>,
+): CapacityQuantityObservation {
+  return {
+    resources,
+    certainty: "exact",
+    sources: ["karpenter.status"],
+    asOf: generatedAt,
+    granularity: "aggregate",
+  };
+}
+
+function boundedMeta(count: number): CapacityBoundedResultMeta {
+  return { total: count, returned: count, truncated: false };
+}
+
+const demandGroup: CapacityDemandGroup = {
+  id: "grp-1",
+  fingerprint: "sched-fp:abc123",
+  owner: { kind: "Deployment", namespace: "payments", name: "checkout" },
+  pods: [{ ref: { kind: "Pod", namespace: "payments", name: "checkout-abc" } }],
+  podsMeta: boundedMeta(1),
+  namespace: "payments",
+  firstSeen: generatedAt,
+  lastSeen: generatedAt,
+  podCount: 3,
+  perPodRequests: quantity({ cpu: "2", memory: "4Gi" }),
+  aggregateRequests: quantity({ cpu: "6", memory: "12Gi" }),
+  schedulingSignature: {
+    fingerprint: "sched-fp:abc123",
+    constraints: [],
+    constraintsMeta: boundedMeta(0),
+    tolerations: [],
+    tolerationsMeta: boundedMeta(0),
+  },
+  state: "awaiting_capacity",
+  schedulerReasons: [],
+  schedulerReasonsMeta: boundedMeta(0),
+  poolEvaluations: [],
+  poolEvaluationsMeta: boundedMeta(0),
+  poolEvaluationCounts: { declaredCompatible: 0, incompatible: 0, unknown: 0 },
+  issues: [],
+};
+
+const demandSummary: CapacityDemandSummary = {
+  total: { podCount: 3, groupCount: 1 },
+  byState: {
+    waiting_for_scheduler: { podCount: 0, groupCount: 0 },
+    held: { podCount: 0, groupCount: 0 },
+    awaiting_capacity: { podCount: 3, groupCount: 1 },
+    blocked: { podCount: 0, groupCount: 0 },
+    unknown: { podCount: 0, groupCount: 0 },
+  },
+};
+
+function demandResponse(
+  group: CapacityDemandGroup = demandGroup,
+): CapacityDemandResponse {
+  return {
+    ...meta,
+    state: "available",
+    summary: demandSummary,
+    items: [group],
+    page: { hasMore: false },
+  };
+}
+
+function renderDemand(group: CapacityDemandGroup): string {
+  const client = new QueryClient({
+    defaultOptions: { queries: { retry: false, retryOnMount: false } },
+  });
+  client.setQueryData(
+    ["capacity", "demand", 25, undefined, undefined, undefined, undefined, undefined],
+    demandResponse(group),
+  );
+  return renderToString(
+    <MemoryRouter initialEntries={["/capacity/demand"]}>
+      <QueryClientProvider client={client}>
+        <CapacityView onOpenResource={() => {}} />
+      </QueryClientProvider>
+    </MemoryRouter>,
+  );
+}
+
+describe("CapacityDemand nomination chip", () => {
+  it("renders a nomination chip when the group holds nominated pods", () => {
+    const html = renderDemand({ ...demandGroup, nominatedPodCount: 2 });
+    expect(html).toContain("2 nominated");
+  });
+
+  it("omits the nomination chip when no pods are nominated", () => {
+    const html = renderDemand({ ...demandGroup, nominatedPodCount: undefined });
+    expect(html).not.toContain("nominated");
+  });
+});

package/src/components/capacity/certaintyGlyph.test.tsx

@@ -0,0 +1,191 @@
+import { describe, expect, it } from "vitest";
+import { renderToString } from "react-dom/server";
+import type {
+  CapacityActivityState,
+  CapacityQuantityObservation,
+} from "@skyhook-io/k8s-ui";
+import {
+  DeniedCapacityState,
+  ActivityStateBadge,
+  CertaintyGlyph,
+  InventoryQuantityCell,
+  QuantityInline,
+  certaintyGlyph,
+  managerStatusRank,
+} from "./shared";
+
+function observation(
+  certainty: CapacityQuantityObservation["certainty"],
+  resources: Record<string, string> = { cpu: "2" },
+): CapacityQuantityObservation {
+  return {
+    resources,
+    certainty,
+    sources: ["test"],
+    asOf: "2026-07-15T00:00:00Z",
+    granularity: "aggregate",
+  };
+}
+
+describe("certainty glyph mapping", () => {
+  // The =/≥/≤/? vocabulary is the feature's trust contract — pin every arm.
+  it("maps each certainty to its glyph", () => {
+    expect(certaintyGlyph("exact")).toBe("=");
+    expect(certaintyGlyph("lower_bound")).toBe("≥");
+    expect(certaintyGlyph("upper_bound")).toBe("≤");
+    expect(certaintyGlyph("unknown")).toBe("?");
+  });
+
+  it("renders a keyboard-reachable trigger", () => {
+    const html = renderToString(<CertaintyGlyph certainty="lower_bound" />);
+    expect(html).toContain('tabindex="0"');
+    expect(html).toContain("≥");
+  });
+});
+
+describe("QuantityInline certainty", () => {
+  it("renders exact values without a hedging glyph", () => {
+    const html = renderToString(
+      <QuantityInline observation={observation("exact")} empty="0" />,
+    );
+    expect(html).toContain("2 cores");
+    expect(html).not.toContain("≥");
+    expect(html).not.toContain("?");
+  });
+
+  it("hedges non-exact values with their glyph", () => {
+    const html = renderToString(
+      <QuantityInline observation={observation("lower_bound")} empty="0" />,
+    );
+    expect(html).toContain("≥");
+  });
+
+  it("never renders an empty unknown observation as the zero label", () => {
+    const html = renderToString(
+      <QuantityInline observation={observation("unknown", {})} empty="0" />,
+    );
+    expect(html).toContain("Unknown");
+    expect(html).not.toContain(">0<");
+  });
+
+  it("hedges an empty lower-bound observation instead of a bare zero", () => {
+    const html = renderToString(
+      <QuantityInline observation={observation("lower_bound", {})} empty="0" />,
+    );
+    expect(html).toContain("≥");
+  });
+});
+
+describe("observed zero vs unobserved source", () => {
+  // "Not observed" is this page's RBAC-gap wording. A pool scaled to zero is a
+  // measured zero and must not borrow it.
+  it("renders an exact empty observation as 0, not the unobserved label", () => {
+    const html = renderToString(
+      <InventoryQuantityCell
+        observation={observation("exact", {})}
+        empty="Not observed"
+      />,
+    );
+    expect(html).toContain(">0<");
+    expect(html).not.toContain("Not observed");
+  });
+
+  it("renders an absent observation as the unobserved label", () => {
+    const html = renderToString(
+      <InventoryQuantityCell observation={undefined} empty="Not observed" />,
+    );
+    expect(html).toContain("Not observed");
+    expect(html).not.toContain(">0<");
+  });
+
+  it("keeps an empty unknown observation as Unknown", () => {
+    const html = renderToString(
+      <InventoryQuantityCell
+        observation={observation("unknown", {})}
+        empty="Not observed"
+      />,
+    );
+    expect(html).toContain("Unknown");
+    expect(html).not.toContain(">0<");
+  });
+
+  it("keeps an empty lower-bound observation hedged, not zeroed", () => {
+    const html = renderToString(
+      <InventoryQuantityCell
+        observation={observation("lower_bound", {})}
+        empty="Not observed"
+      />,
+    );
+    expect(html).toContain("Not observed");
+    expect(html).toContain("≥");
+  });
+
+  it("applies the same rule to QuantityInline", () => {
+    expect(
+      renderToString(
+        <QuantityInline observation={observation("exact", {})} empty="—" />,
+      ),
+    ).toContain(">0<");
+    expect(
+      renderToString(<QuantityInline observation={undefined} empty="—" />),
+    ).toContain("—");
+  });
+});
+
+describe("managerStatusRank", () => {
+  it("ranks degraded worst and healthy best", () => {
+    expect(managerStatusRank("degraded")).toBeLessThan(
+      managerStatusRank("unknown"),
+    );
+    expect(managerStatusRank("unknown")).toBeLessThan(
+      managerStatusRank("healthy"),
+    );
+  });
+
+  it("ranks a status this build does not know as unknown", () => {
+    // A newer server adding a rollup status must not produce NaN comparisons
+    // that silently misrank a real degradation.
+    expect(managerStatusRank("suspended_for_maintenance")).toBe(
+      managerStatusRank("unknown"),
+    );
+  });
+});
+
+describe("ActivityStateBadge", () => {
+  const render = (state: CapacityActivityState) =>
+    renderToString(<ActivityStateBadge state={state} />);
+
+  it("renders `ended` without claiming success or failure", () => {
+    const html = render("ended");
+    expect(html).toContain("ended");
+    // Terminalized with no cause recorded — the success and error palettes
+    // would both assert evidence Radar never saw.
+    expect(html).not.toContain("emerald");
+    expect(html).not.toContain("red-");
+    expect(html).toContain("text-theme-text-secondary");
+  });
+
+  it("keeps completed and failed distinctly toned", () => {
+    expect(render("completed")).toContain("emerald");
+    expect(render("failed")).toContain("red-");
+  });
+
+  it("falls back to a neutral badge for a state this build does not know", () => {
+    const html = render("superseded" as CapacityActivityState);
+    expect(html).toContain("superseded");
+    expect(html).toContain("text-theme-text-secondary");
+  });
+});
+
+describe("DeniedCapacityState", () => {
+  it("converts the 403 into a next step: fallback guidance plus the exact grant", () => {
+    const html = renderToString(
+      <DeniedCapacityState detail="no access to NodePools (cluster-scoped resource requires explicit RBAC)" />,
+    );
+    expect(html).toContain("Capacity access denied");
+    expect(html).toContain("Pod drawer and Issues");
+    expect(html).toContain("Permissions to request");
+    expect(html).toContain("radar-capacity-viewer");
+    expect(html).toContain("nodepools");
+  });
+});

package/src/components/capacity/coverageCertainty.test.ts

@@ -0,0 +1,162 @@
+import { describe, expect, it } from "vitest";
+import type { CapacitySourceCoverage } from "@skyhook-io/k8s-ui";
+import {
+  autoscalerDetectionFailure,
+  autoscalerNotPublishedDetail,
+  coverageCertainty,
+  nodeGroupsCertainty,
+} from "./CapacityOverview";
+
+function cov(
+  status: CapacitySourceCoverage["status"],
+  scope: CapacitySourceCoverage["scope"] = "cluster",
+): CapacitySourceCoverage {
+  return { status, scope, impactFields: [] };
+}
+
+function reasoned(
+  status: CapacitySourceCoverage["status"],
+  reasonCode: string,
+): CapacitySourceCoverage {
+  return { status, reasonCode, scope: "cluster", impactFields: [] };
+}
+
+describe("coverageCertainty", () => {
+  it("is exact only for an observed, cluster-scoped source", () => {
+    expect(coverageCertainty(cov("available"))).toBe("exact");
+  });
+
+  it("is a lower bound when observed but namespace-scoped or partial", () => {
+    expect(coverageCertainty(cov("available", "explicit_namespaces"))).toBe(
+      "lower_bound",
+    );
+    expect(coverageCertainty(cov("partial"))).toBe("lower_bound");
+  });
+
+  it("is unknown — never a false exact — when the source was not observed", () => {
+    // The trust thesis: syncing / unavailable / error / absent must not read
+    // as "=" (exact) on the KPI glyphs.
+    for (const status of [
+      "denied",
+      "syncing",
+      "unavailable",
+      "error",
+    ] as const) {
+      expect(coverageCertainty(cov(status))).toBe("unknown");
+    }
+    expect(coverageCertainty(undefined)).toBe("unknown");
+  });
+});
+
+describe("nodeGroupsCertainty", () => {
+  it("is exact only when nodes and NodePools were both observed", () => {
+    expect(
+      nodeGroupsCertainty(
+        { nodes: cov("available"), nodePools: cov("available") },
+        "available",
+      ).certainty,
+    ).toBe("exact");
+  });
+
+  it("is a lower bound when NodePools are hidden — zero-node groups vanish", () => {
+    for (const status of [
+      "denied",
+      "unavailable",
+      "error",
+      "syncing",
+    ] as const) {
+      const result = nodeGroupsCertainty(
+        { nodes: cov("available"), nodePools: cov(status) },
+        "denied",
+      );
+      expect(result.certainty).toBe("lower_bound");
+      expect(result.title).toContain("lower bound");
+    }
+  });
+
+  it("stays unknown when nodes themselves were not observed", () => {
+    expect(
+      nodeGroupsCertainty(
+        { nodes: cov("denied"), nodePools: cov("denied") },
+        "denied",
+      ).certainty,
+    ).toBe("unknown");
+  });
+
+  it("does not hedge a cluster that simply has no NodePool source", () => {
+    expect(
+      nodeGroupsCertainty({ nodes: cov("available") }, "not_detected")
+        .certainty,
+    ).toBe("exact");
+  });
+
+  it("does not hedge when Karpenter is absent — nothing is hidden", () => {
+    // The server reports unavailable NodePool coverage on a Karpenter-less
+    // cluster, but there are no NodePools to conceal scale-to-zero groups.
+    const result = nodeGroupsCertainty(
+      { nodes: cov("available"), nodePools: cov("unavailable") },
+      "not_detected",
+    );
+    expect(result.certainty).toBe("exact");
+    expect(result.title).not.toContain("lower bound");
+  });
+});
+
+describe("autoscalerDetectionFailure", () => {
+  it("reports every unreadable source as a detection failure", () => {
+    expect(autoscalerDetectionFailure(cov("denied"))).toContain("permissions");
+    for (const reasonCode of [
+      "autoscaler_status_cache_scope",
+      "autoscaler_status_cache_unavailable",
+      "autoscaler_status_read_failed",
+      "autoscaler_status_parse_failed",
+    ]) {
+      expect(
+        autoscalerDetectionFailure(reasoned("unavailable", reasonCode)),
+      ).toBeTruthy();
+    }
+    expect(autoscalerDetectionFailure(cov("error"))).toBeTruthy();
+  });
+
+  it("treats a published-nothing reading as an observation, not a failure", () => {
+    // This is the ONLY reading that may render as "None detected".
+    expect(
+      autoscalerDetectionFailure(
+        reasoned("unavailable", "autoscaler_status_not_published"),
+      ),
+    ).toBeNull();
+    expect(autoscalerDetectionFailure(cov("available"))).toBeNull();
+    expect(autoscalerDetectionFailure(undefined)).toBeNull();
+  });
+});
+
+describe("autoscalerNotPublishedDetail", () => {
+  it("scopes the claim to the namespace the server probed", () => {
+    // Unscoped, "None detected" reads as "this cluster has no autoscaler" when
+    // it only means "no status ConfigMap in the one place it can live".
+    expect(
+      autoscalerNotPublishedDetail({
+        ...reasoned("unavailable", "autoscaler_status_not_published"),
+        namespaces: ["kube-system"],
+      }),
+    ).toBe("No cluster-autoscaler-status ConfigMap in kube-system.");
+  });
+
+  it("names kube-system when the server reported no namespace list", () => {
+    expect(
+      autoscalerNotPublishedDetail(
+        reasoned("unavailable", "autoscaler_status_not_published"),
+      ),
+    ).toContain("kube-system");
+  });
+
+  it("says nothing for any other reading", () => {
+    expect(
+      autoscalerNotPublishedDetail(
+        reasoned("unavailable", "autoscaler_status_read_failed"),
+      ),
+    ).toBeNull();
+    expect(autoscalerNotPublishedDetail(cov("available"))).toBeNull();
+    expect(autoscalerNotPublishedDetail(undefined)).toBeNull();
+  });
+});

package/src/components/capacity/podDemandGate.test.ts

@@ -0,0 +1,47 @@
+import { describe, expect, it } from "vitest";
+import { podAwaitsScheduling, workloadPodAwaitsScheduling } from "./podDemandGate";
+
+describe("podAwaitsScheduling", () => {
+  it("admits a Pending pod the scheduler has not placed", () => {
+    expect(podAwaitsScheduling({ status: { phase: "Pending" } })).toBe(true);
+  });
+
+  it("rejects a Pending pod that already holds a node", () => {
+    // ContainerCreating / ImagePullBackOff pods are Pending but absent from
+    // Demand — linking them there is a dead end.
+    expect(
+      podAwaitsScheduling({
+        spec: { nodeName: "ip-10-0-1-1" },
+        status: { phase: "Pending" },
+      }),
+    ).toBe(false);
+  });
+
+  it("rejects running, succeeded and unknown-shape pods", () => {
+    expect(
+      podAwaitsScheduling({
+        spec: { nodeName: "ip-10-0-1-1" },
+        status: { phase: "Running" },
+      }),
+    ).toBe(false);
+    expect(podAwaitsScheduling({ status: { phase: "Succeeded" } })).toBe(false);
+    expect(podAwaitsScheduling({})).toBe(false);
+    expect(podAwaitsScheduling(undefined)).toBe(false);
+  });
+});
+
+describe("workloadPodAwaitsScheduling (flat WorkloadPodInfo shape)", () => {
+  it("admits an unscheduled Pending pod", () => {
+    expect(workloadPodAwaitsScheduling({ phase: "Pending" })).toBe(true);
+  });
+  it("rejects Pending pods already bound to a node", () => {
+    expect(
+      workloadPodAwaitsScheduling({ phase: "Pending", nodeName: "ip-10-0-0-1" }),
+    ).toBe(false);
+  });
+  it("rejects running, empty, and absent pods", () => {
+    expect(workloadPodAwaitsScheduling({ phase: "Running" })).toBe(false);
+    expect(workloadPodAwaitsScheduling({})).toBe(false);
+    expect(workloadPodAwaitsScheduling(undefined)).toBe(false);
+  });
+});

package/src/components/capacity/podDemandGate.ts

@@ -0,0 +1,22 @@
+interface PodLike {
+  spec?: { nodeName?: string };
+  status?: { phase?: string };
+}
+
+/**
+ * Whether Capacity Demand would have anything to say about this pod. Demand
+ * only admits pods the scheduler has not placed, so a Pending pod that already
+ * holds a node (ContainerCreating, ImagePullBackOff) must not be offered a link
+ * that lands on a screen it is absent from.
+ */
+export function podAwaitsScheduling(pod: PodLike | undefined | null): boolean {
+  return pod?.status?.phase === "Pending" && !pod?.spec?.nodeName;
+}
+
+// The workload page's pods arrive as the flattened WorkloadPodInfo wire shape
+// rather than full Pod objects — same rule, different field paths.
+export function workloadPodAwaitsScheduling(
+  pod: { phase?: string; nodeName?: string } | undefined | null,
+): boolean {
+  return pod?.phase === "Pending" && !pod?.nodeName;
+}