openk8s 1.0.1 → 1.0.2

package/src/lib/kubectl/__tests__/kubectl-helpers.test.ts

@@ -0,0 +1,343 @@
+import { describe, expect, test } from "bun:test";
+import {
+  normalizeKind,
+  normalizeResourceTarget,
+  normalizeLogTarget,
+  normalizePortForwardTarget,
+  supportsRolloutRestart,
+  supportsScale,
+  resourceStatus,
+  resourceSummary,
+  curatedKinds,
+} from "../kubectl-helpers";
+import type { ResourceRef, ResourceKind } from "../../k8s/types";
+import type { ApiResourceItem } from "../kubectl-types";
+
+// ── normalizeKind ────────────────────────────────────────────────────────────
+
+describe("normalizeKind", () => {
+  test("lowercases", () => expect(normalizeKind("Deployment")).toBe("deployment"));
+  test("trims whitespace", () => expect(normalizeKind("  Pod  ")).toBe("pod"));
+});
+
+// ── normalizeResourceTarget ──────────────────────────────────────────────────
+
+describe("normalizeResourceTarget", () => {
+  test("formats kind/name", () => {
+    expect(normalizeResourceTarget({ kind: "Deployment", name: "nginx" })).toBe("deployment/nginx");
+  });
+});
+
+// ── normalizeLogTarget ───────────────────────────────────────────────────────
+
+describe("normalizeLogTarget", () => {
+  test("pod target", () => {
+    const result = normalizeLogTarget({ kind: "Pod", name: "my-pod" });
+    expect(result).toEqual({ target: "pod/my-pod", includeAllPods: false });
+  });
+
+  test("deployment target with includeAllPods", () => {
+    const result = normalizeLogTarget({ kind: "Deployment", name: "web" });
+    expect(result).toEqual({ target: "deployment/web", includeAllPods: true });
+  });
+
+  test("job target with includeAllPods", () => {
+    const result = normalizeLogTarget({ kind: "Job", name: "backup" });
+    expect(result).toEqual({ target: "job/backup", includeAllPods: true });
+  });
+
+  test("returns undefined for unsupported kinds", () => {
+    expect(normalizeLogTarget({ kind: "ConfigMap", name: "cfg" })).toBeUndefined();
+  });
+});
+
+// ── normalizePortForwardTarget ───────────────────────────────────────────────
+
+describe("normalizePortForwardTarget", () => {
+  test("pod target", () => {
+    expect(normalizePortForwardTarget({ kind: "Pod", name: "my-pod" })).toBe("pod/my-pod");
+  });
+
+  test("service target", () => {
+    expect(normalizePortForwardTarget({ kind: "Service", name: "web" })).toBe("service/web");
+  });
+
+  test("deployment target", () => {
+    expect(normalizePortForwardTarget({ kind: "Deployment", name: "app" })).toBe("deployment/app");
+  });
+
+  test("returns undefined for unsupported", () => {
+    expect(normalizePortForwardTarget({ kind: "Ingress", name: "ing" })).toBeUndefined();
+  });
+});
+
+// ── supports helpers ─────────────────────────────────────────────────────────
+
+describe("supportsRolloutRestart", () => {
+  const makeRef = (kind: string): ResourceRef => ({ kind, name: "test" });
+
+  test("deployment", () => expect(supportsRolloutRestart(makeRef("Deployment"))).toBe(true));
+  test("statefulset", () => expect(supportsRolloutRestart(makeRef("StatefulSet"))).toBe(true));
+  test("daemonset", () => expect(supportsRolloutRestart(makeRef("DaemonSet"))).toBe(true));
+  test("pod does not support", () => expect(supportsRolloutRestart(makeRef("Pod"))).toBe(false));
+  test("service does not support", () => expect(supportsRolloutRestart(makeRef("Service"))).toBe(false));
+});
+
+describe("supportsScale", () => {
+  const makeRef = (kind: string): ResourceRef => ({ kind, name: "test" });
+
+  test("deployment", () => expect(supportsScale(makeRef("Deployment"))).toBe(true));
+  test("statefulset", () => expect(supportsScale(makeRef("StatefulSet"))).toBe(true));
+  test("replicaset", () => expect(supportsScale(makeRef("ReplicaSet"))).toBe(true));
+  test("pod does not support", () => expect(supportsScale(makeRef("Pod"))).toBe(false));
+  test("daemonset does not support", () => expect(supportsScale(makeRef("DaemonSet"))).toBe(false));
+});
+
+// ── resourceStatus ───────────────────────────────────────────────────────────
+
+describe("resourceStatus", () => {
+  test("events return type field", () => {
+    expect(resourceStatus({ kind: "Event", type: "Warning" } as any)).toBe("Warning");
+    expect(resourceStatus({ kind: "Event" } as any)).toBe("Normal");
+  });
+
+  test("HPA shows current/max replicas", () => {
+    expect(resourceStatus({ kind: "HorizontalPodAutoscaler", spec: { maxReplicas: 5 }, status: { currentReplicas: 3 } } as any)).toBe("3/5 replicas");
+  });
+
+  test("HPA with missing fields", () => {
+    expect(resourceStatus({ kind: "HorizontalPodAutoscaler" } as any)).toBe("-/- replicas");
+  });
+
+  test("CronJob active state", () => {
+    expect(resourceStatus({ kind: "CronJob", status: { active: [{}, {}] } } as any)).toBe("active");
+  });
+
+  test("CronJob idle state", () => {
+    expect(resourceStatus({ kind: "CronJob", status: {} } as any)).toBe("idle");
+  });
+
+  test("Node Ready", () => {
+    expect(resourceStatus({ kind: "Node", status: { conditions: [{ type: "Ready", status: "True" }] } } as any)).toBe("Ready");
+  });
+
+  test("Node NotReady", () => {
+    expect(resourceStatus({ kind: "Node", status: { conditions: [{ type: "Ready", status: "False" }] } } as any)).toBe("NotReady");
+  });
+
+  test("Node MemoryPressure", () => {
+    expect(resourceStatus({ kind: "Node", status: { conditions: [{ type: "MemoryPressure", status: "True" }] } } as any)).toBe("MemoryPressure");
+  });
+
+  test("Node DiskPressure", () => {
+    expect(resourceStatus({ kind: "Node", status: { conditions: [{ type: "DiskPressure", status: "True" }] } } as any)).toBe("DiskPressure");
+  });
+
+  test("RoleBinding shows subject count", () => {
+    expect(resourceStatus({ kind: "RoleBinding", subjects: [{}, {}] } as any)).toBe("2 subjects");
+  });
+
+  test("Phase-based status", () => {
+    expect(resourceStatus({ kind: "Pod", status: { phase: "Running" } } as any)).toBe("Running");
+  });
+
+  test("Ready replicas status", () => {
+    expect(resourceStatus({ kind: "Deployment", spec: { replicas: 3 }, status: { readyReplicas: 3 } } as any)).toBe("3/3 ready");
+  });
+
+  test("Available replicas status", () => {
+    expect(resourceStatus({ kind: "Deployment", spec: { replicas: 2 }, status: { availableReplicas: 1 } } as any)).toBe("1/2 available");
+  });
+
+  test("Non-specific kind with capacity falls back", () => {
+    expect(resourceStatus({ kind: "PersistentVolume", status: { capacity: { storage: "10Gi" } } } as any)).toBe("capacity");
+  });
+
+  test("Default status", () => {
+    expect(resourceStatus({ kind: "ConfigMap" } as any)).toBe("-");
+  });
+});
+
+// ── resourceSummary ──────────────────────────────────────────────────────────
+
+describe("resourceSummary", () => {
+  test("Events show reason and message", () => {
+    expect(resourceSummary({ kind: "Event", reason: "Created", message: "Pod created successfully" } as any)).toBe("Created: Pod created successfully");
+  });
+
+  test("HPA summary", () => {
+    expect(resourceSummary({ kind: "HorizontalPodAutoscaler", spec: { minReplicas: 1, maxReplicas: 10, scaleTargetRef: { name: "web" } } } as any)).toBe("min:1 max:10 ref:web");
+  });
+
+  test("CronJob summary", () => {
+    const ts = new Date(Date.now() - 300_000).toISOString();
+    const result = resourceSummary({ kind: "CronJob", spec: { schedule: "*/5 * * * *" }, status: { lastScheduleTime: ts } } as any);
+    expect(result).toMatch(/5 \* \* \* \*  last:/);
+  });
+
+  test("Node summary shows kubelet version", () => {
+    expect(resourceSummary({ kind: "Node", status: { nodeInfo: { kubeletVersion: "v1.28" } }, metadata: { labels: { "node-role.kubernetes.io/worker": "true" } } } as any)).toBe("v1.28  roles: worker");
+  });
+
+  test("Node summary without role label", () => {
+    expect(resourceSummary({ kind: "Node", status: { nodeInfo: { kubeletVersion: "v1.28" } }, metadata: { labels: {} } } as any)).toBe("v1.28  roles: worker");
+  });
+
+  test("Role summary shows rule count", () => {
+    expect(resourceSummary({ kind: "Role", rules: [{}, {}] } as any)).toBe("2 rules");
+  });
+
+  test("RoleBinding summary shows roleRef", () => {
+    expect(resourceSummary({ kind: "RoleBinding", roleRef: { kind: "Role", name: "admin" } } as any)).toBe("→ Role/admin");
+  });
+
+  test("Services show clusterIP", () => {
+    expect(resourceSummary({ kind: "Service", spec: { clusterIP: "10.0.0.1" } } as any)).toBe("clusterIP 10.0.0.1");
+  });
+
+  test("Pods with nodeName", () => {
+    expect(resourceSummary({ kind: "Pod", spec: { nodeName: "node-1" } } as any)).toBe("node node-1");
+  });
+
+  test("Default empty summary", () => {
+    expect(resourceSummary({ kind: "ConfigMap" } as any)).toBe("");
+  });
+});
+
+// ── api-resources JSON mapping ────────────────────────────────────────────────
+
+describe("api-resources JSON to ResourceKind mapping", () => {
+  test("maps core resource (no group) with undefined group", () => {
+    const items: ApiResourceItem[] = [
+      { name: "pods", singularName: "pod", namespaced: true, version: "v1", kind: "Pod", verbs: ["list"], shortNames: ["po"] },
+    ];
+
+    const kinds = items.map((item) => ({
+      name: item.name,
+      namespaced: item.namespaced,
+      group: item.group || undefined,
+      shortNames: item.shortNames ?? [],
+    }));
+
+    expect(kinds).toEqual([
+      { name: "pods", namespaced: true, group: undefined, shortNames: ["po"] },
+    ]);
+  });
+
+  test("maps namespaced resource with API group", () => {
+    const items: ApiResourceItem[] = [
+      { name: "deployments", singularName: "deployment", namespaced: true, group: "apps", version: "v1", kind: "Deployment", verbs: ["list"], shortNames: ["deploy"] },
+    ];
+
+    const kinds = items.map((item) => ({
+      name: item.name,
+      namespaced: item.namespaced,
+      group: item.group || undefined,
+      shortNames: item.shortNames ?? [],
+    }));
+
+    expect(kinds).toEqual([
+      { name: "deployments", namespaced: true, group: "apps", shortNames: ["deploy"] },
+    ]);
+  });
+
+  test("maps resource without shortNames to empty array", () => {
+    const items: ApiResourceItem[] = [
+      { name: "bindings", singularName: "binding", namespaced: true, version: "v1", kind: "Binding", verbs: ["create"] },
+    ];
+
+    const kinds = items.map((item) => ({
+      name: item.name,
+      namespaced: item.namespaced,
+      group: item.group || undefined,
+      shortNames: item.shortNames ?? [],
+    }));
+
+    expect(kinds).toEqual([
+      { name: "bindings", namespaced: true, group: undefined, shortNames: [] },
+    ]);
+  });
+
+  test("maps cluster-scoped resource", () => {
+    const items: ApiResourceItem[] = [
+      { name: "nodes", singularName: "node", namespaced: false, version: "v1", kind: "Node", verbs: ["list"], shortNames: ["no"] },
+    ];
+
+    const kinds = items.map((item) => ({
+      name: item.name,
+      namespaced: item.namespaced,
+      group: item.group || undefined,
+      shortNames: item.shortNames ?? [],
+    }));
+
+    expect(kinds).toEqual([
+      { name: "nodes", namespaced: false, group: undefined, shortNames: ["no"] },
+    ]);
+  });
+
+  test("passes through to curatedKinds correctly", () => {
+    const items: ApiResourceItem[] = [
+      { name: "services", singularName: "service", namespaced: true, version: "v1", kind: "Service", verbs: ["list"], shortNames: ["svc"] },
+      { name: "pods", singularName: "pod", namespaced: true, version: "v1", kind: "Pod", verbs: ["list"], shortNames: ["po"] },
+      { name: "deployments", singularName: "deployment", namespaced: true, group: "apps", version: "v1", kind: "Deployment", verbs: ["list"], shortNames: ["deploy"] },
+      { name: "pods.metrics.k8s.io", singularName: "podmetrics", namespaced: true, group: "metrics.k8s.io", version: "v1beta1", kind: "PodMetrics", verbs: ["get", "list"], shortNames: [] },
+    ];
+
+    const kinds = items.map((item) => ({
+      name: item.name,
+      namespaced: item.namespaced,
+      group: item.group || undefined,
+      shortNames: item.shortNames ?? [],
+    }));
+
+    const curated = curatedKinds(kinds);
+
+    // metrics.k8s.io/podmetrics should be filtered out by curatedKinds
+    expect(curated.find((k) => k.name === "pods.metrics.k8s.io")).toBeUndefined();
+    // core pods should be included
+    expect(curated.find((k) => k.name === "pods")).toBeDefined();
+  });
+});
+
+// ── curatedKinds ─────────────────────────────────────────────────────────────
+
+describe("curatedKinds", () => {
+  const allKinds: ResourceKind[] = [
+    { name: "services", namespaced: true, shortNames: ["svc"] },
+    { name: "pods", namespaced: true, shortNames: ["po"] },
+    { name: "deployments", namespaced: true, shortNames: ["deploy"] },
+    { name: "configmaps", namespaced: true, shortNames: ["cm"] },
+  ];
+
+  test("reorders kinds based on preferred order", () => {
+    const result = curatedKinds(allKinds);
+    expect(result[0]?.name).toBe("pods");
+    expect(result[1]?.name).toBe("deployments");
+    expect(result[2]?.name).toBe("services");
+  });
+
+  test("returns empty when input is empty", () => {
+    expect(curatedKinds([])).toEqual([]);
+  });
+
+  test("includes only matching kinds", () => {
+    const kinds: ResourceKind[] = [
+      { name: "pods", namespaced: true, shortNames: ["po"] },
+      { name: "custom", namespaced: true, shortNames: ["cst"] },
+      { name: "deployments", namespaced: true, shortNames: ["deploy"] },
+    ];
+    const result = curatedKinds(kinds);
+    expect(result).toHaveLength(2);
+    expect(result[0]?.name).toBe("pods");
+    expect(result[1]?.name).toBe("deployments");
+  });
+
+  test("falls back to first 20 when no preferred matches", () => {
+    const kinds: ResourceKind[] = [
+      { name: "a", namespaced: false, shortNames: [] },
+      { name: "b", namespaced: false, shortNames: [] },
+    ];
+    const result = curatedKinds(kinds);
+    expect(result).toHaveLength(2);
+  });
+});

package/src/lib/kubectl/__tests__/metrics-utils.test.ts

@@ -0,0 +1,84 @@
+import { describe, expect, test } from "bun:test";
+import { parseCpuNano, parseMemBytes, formatCpu, formatMem } from "../metrics-utils";
+
+// ── parseCpuNano ─────────────────────────────────────────────────────────────
+
+describe("parseCpuNano", () => {
+  test("nanocores (suffix 'n')", () => {
+    expect(parseCpuNano("500000000n")).toBe(500000000);
+  });
+
+  test("millicores (suffix 'm')", () => {
+    expect(parseCpuNano("100m")).toBe(100_000_000);
+  });
+
+  test("whole cores", () => {
+    expect(parseCpuNano("2")).toBe(2_000_000_000);
+  });
+
+  test("fractional cores", () => {
+    expect(parseCpuNano("0.5")).toBe(500_000_000);
+  });
+
+  test("empty string", () => {
+    expect(parseCpuNano("")).toBe(0);
+  });
+
+  test("invalid string", () => {
+    expect(parseCpuNano("abc")).toBe(0);
+  });
+});
+
+// ── parseMemBytes ────────────────────────────────────────────────────────────
+
+describe("parseMemBytes", () => {
+  test("Ki", () => expect(parseMemBytes("512Ki")).toBe(512 * 1024));
+  test("Mi", () => expect(parseMemBytes("256Mi")).toBe(256 * 1024 ** 2));
+  test("Gi", () => expect(parseMemBytes("2Gi")).toBe(2 * 1024 ** 3));
+  test("K (decimal)", () => expect(parseMemBytes("1000K")).toBe(1000 * 1000));
+  test("M (decimal)", () => expect(parseMemBytes("10M")).toBe(10 * 1000 ** 2));
+  test("G (decimal)", () => expect(parseMemBytes("1G")).toBe(1000 ** 3));
+  test("plain bytes", () => expect(parseMemBytes("1024")).toBe(1024));
+  test("empty string", () => expect(parseMemBytes("")).toBe(0));
+  test("invalid", () => expect(parseMemBytes("abc")).toBe(0));
+});
+
+// ── formatCpu ────────────────────────────────────────────────────────────────
+
+describe("formatCpu", () => {
+  test("formats cores", () => {
+    expect(formatCpu(2_000_000_000)).toBe("2.00");
+  });
+
+  test("formats millicores", () => {
+    expect(formatCpu(100_000_000)).toBe("100m");
+  });
+
+  test("formats small millicores", () => {
+    expect(formatCpu(1_000_000)).toBe("1m");
+  });
+});
+
+// ── formatMem ────────────────────────────────────────────────────────────────
+
+describe("formatMem", () => {
+  test("formats GiB", () => {
+    expect(formatMem(2 * 1024 ** 3)).toBe("2.0Gi");
+  });
+
+  test("formats MiB", () => {
+    expect(formatMem(256 * 1024 ** 2)).toBe("256Mi");
+  });
+
+  test("formats KiB", () => {
+    expect(formatMem(512 * 1024)).toBe("512Ki");
+  });
+
+  test("formats bytes", () => {
+    expect(formatMem(500)).toBe("500B");
+  });
+
+  test("formats zero", () => {
+    expect(formatMem(0)).toBe("0B");
+  });
+});

package/src/lib/kubectl/__tests__/spawn-utils.test.ts

@@ -0,0 +1,56 @@
+import { describe, expect, test } from "bun:test";
+import { runCommand, runText, runJson, startPersistentProcess } from "../spawn-utils";
+
+describe("runCommand", () => {
+  test("successfully runs echo", async () => {
+    const result = await runCommand({ command: "echo", args: ["hello"], timeoutMs: 5000 });
+    expect(result.stdout.trim()).toBe("hello");
+    expect(result.stderr).toBe("");
+  });
+
+  test("captures stdout only (no exitCode in result)", async () => {
+    const result = await runCommand({ command: "echo", args: ["-n", "hello world"], timeoutMs: 5000 });
+    expect(result.stdout).toBe("hello world");
+  });
+
+  test("throws on non-zero exit", async () => {
+    expect(
+      runCommand({ command: "sh", args: ["-c", "exit 1"], timeoutMs: 5000 }),
+    ).rejects.toThrow();
+  });
+
+  test("throws on timeout", async () => {
+    expect(
+      runCommand({ command: "sleep", args: ["10"], timeoutMs: 100 }),
+    ).rejects.toThrow();
+  });
+});
+
+describe("runText", () => {
+  test("returns stdout as string", async () => {
+    const text = await runText({ command: "echo", args: ["-n", "hello world"], timeoutMs: 5000 });
+    expect(text).toBe("hello world");
+  });
+});
+
+describe("runJson", () => {
+  test("parses JSON output", async () => {
+    const result = await runJson<{ name: string }>({ command: "echo", args: ["-n", '{"name":"test"}'], timeoutMs: 5000 });
+    expect(result.name).toBe("test");
+  });
+
+  test("throws on invalid JSON", async () => {
+    expect(
+      runJson({ command: "echo", args: ["-n", "not-json"], timeoutMs: 5000 }),
+    ).rejects.toThrow();
+  });
+});
+
+describe("startPersistentProcess", () => {
+  test("starts a process and returns object with pid", () => {
+    const child = startPersistentProcess({ command: "echo", args: ["hello"], stdio: ["ignore", "pipe", "pipe"] });
+    expect(child).toBeDefined();
+    expect(typeof child.pid).toBe("number");
+    child.kill();
+  });
+});