@skyhook-io/radar-app 1.14.0 → 1.14.2

package/src/components/diagnose/investigationCase.test.tsx

@@ -18,9 +18,6 @@ import {
 import {
   resolveInvestigationCase,
   type InvestigationCaseResolution,
-  investigationCaseItemsStillRendered,
-  mergeInvestigationCases,
-  type InvestigationCaseItem,
 } from "./investigationCase";
 import { AssessmentSources, ResultCard, assessmentSourceRows } from "./parts";
 import type { Diagnosis, DiagnosisEvidenceItem } from "../../api/diagnose";
@@ -145,6 +142,7 @@ const diagnoseBundle = {
     },
   },
   pods: 1,
+  podNames: ["api-abc"],
   relatedIssues: [criticalIssue],
   logsCurrent: [
     { pod: "api-abc", container: "api", logs: logs(["ERROR auth failed"]) },
@@ -188,6 +186,263 @@ describe("agent case placement (D-1, D-1b)", () => {
     expect(html).not.toContain("data-agent-claim");
   });
 
+  it("forgives a group on a core kind and a named entry on a listing", () => {
+    const listRef = evidenceRef("c", "d");
+    const withListing = project(
+      tool("diag", "diagnose", diagnoseBundle, { evidenceRef: ref }),
+      tool(
+        "cms",
+        "list_resources",
+        [{ kind: "ConfigMap", name: "kube-root-ca.crt" }],
+        {
+          evidenceRef: listRef,
+          summary: JSON.stringify({ kind: "configmaps", namespace: "shop" }),
+        },
+      ),
+    );
+    const resolved = resolveInvestigationCase(
+      withListing,
+      {
+        evidence: [
+          linked(ref, "cause", "The previous log names the error.", {
+            group: "apps",
+            kind: "Pod",
+            namespace: "shop",
+            name: "api-abc",
+            container: "api",
+            stream: "previous",
+            observation: "logs",
+          }),
+          linked(listRef, "context", "Only the CA bundle exists.", {
+            kind: "ConfigMap",
+            namespace: "shop",
+            name: "kube-root-ca.crt",
+            observation: "resource",
+          }),
+          linked(listRef, "rules_out", "No nginx config lives here.", {
+            kind: "ConfigMap",
+            namespace: "shop",
+            observation: "resource",
+          }),
+          linked(ref, "symptom", "BackOff keeps firing on the pod.", {
+            kind: "Pod",
+            namespace: "shop",
+            name: "api-abc",
+            observation: "events",
+          }),
+        ],
+      },
+      0,
+    );
+    expect(resolved.items.map((item) => item.placement)).toEqual([
+      "card",
+      "card",
+      "card",
+      "card",
+    ]);
+  });
+
+  it("binds a Pod subject to events only for the target's own pod or a pod an event names whole", () => {
+    const workerRef = evidenceRef("e", "f");
+    const canaryBundle = {
+      ...diagnoseBundle,
+      events: [
+        {
+          reason: "BackOff",
+          message: "Back-off restarting failed container in pod api-abc-canary",
+          type: "Warning",
+          count: 4,
+          lastTimestamp: "2026-09-02T10:00:00Z",
+        },
+      ],
+    };
+    const withWorker = project(
+      tool("diag", "diagnose", canaryBundle, { evidenceRef: ref }),
+      tool(
+        "ev",
+        "get_events",
+        { events: [] },
+        {
+          evidenceRef: workerRef,
+          summary: JSON.stringify({
+            kind: "Deployment",
+            namespace: "shop",
+            name: "worker",
+          }),
+        },
+      ),
+    );
+    const podEvents = (name: string, cite = ref) =>
+      linked(cite, "symptom", `${name} keeps backing off.`, {
+        kind: "Pod",
+        namespace: "shop",
+        name,
+        observation: "events",
+      });
+    const resolved = resolveInvestigationCase(
+      withWorker,
+      {
+        evidence: [
+          podEvents("api-abc"),
+          podEvents("api-abc-canary"),
+          podEvents("abc-canary"),
+          podEvents("api-zzz"),
+          podEvents("api-abc", workerRef),
+        ],
+      },
+      0,
+    );
+    expect(resolved.items.map((item) => item.placement)).toEqual([
+      "card",
+      "card",
+      "source",
+      "source",
+      "source",
+    ]);
+  });
+
+  it("binds an alert citation to the rule it names when one result holds several rules", () => {
+    const rulesRef = evidenceRef("i", "j");
+    const rule = (name: string) => ({
+      group: "kubernetes-apps",
+      type: "alerting",
+      name,
+      query: "vector(1)",
+      state: "firing",
+      health: "ok",
+      labels: { severity: "warning" },
+      annotations: { summary: name },
+      alerts: [
+        {
+          state: "firing",
+          activeAt: "2026-09-07T07:58:00Z",
+          value: "1e+00",
+          labels: {
+            alertname: name,
+            namespace: "shop",
+            pod: "api-abc",
+            container: "api",
+          },
+        },
+      ],
+    });
+    const withRules = project(
+      tool("diag", "diagnose", diagnoseBundle, { evidenceRef: ref }),
+      tool(
+        "rules",
+        "get_prometheus_rules",
+        {
+          count: 2,
+          rules: [
+            rule("KubePodCrashLooping"),
+            rule("KubeDeploymentReplicasMismatch"),
+          ],
+        },
+        { evidenceRef: rulesRef, summary: JSON.stringify({ state: "firing" }) },
+      ),
+    );
+    const cite = (name?: string) =>
+      linked(rulesRef, "symptom", "The rule is firing for this pod.", {
+        kind: "PrometheusRule",
+        namespace: "shop",
+        ...(name ? { name } : {}),
+        observation: "alerts",
+      });
+    const resolved = resolveInvestigationCase(
+      withRules,
+      {
+        evidence: [
+          cite("KubeDeploymentReplicasMismatch"),
+          cite("KubePodCrashLooping"),
+          cite(),
+        ],
+      },
+      0,
+    );
+    expect(resolved.items.map((item) => item.placement)).toEqual([
+      "card",
+      "card",
+      "source",
+    ]);
+    expect(resolved.items[0].observation?.title).toContain(
+      "KubeDeploymentReplicasMismatch",
+    );
+    const wrongCase = resolveInvestigationCase(
+      withRules,
+      { evidence: [cite("kubepodcrashlooping")] },
+      0,
+    );
+    expect(wrongCase.items.map((item) => item.placement)).toEqual(["source"]);
+  });
+
+  it("still binds a named entry the listing does not hold to the listing", () => {
+    const listRef = evidenceRef("c", "d");
+    const withListing = project(
+      tool("diag", "diagnose", diagnoseBundle, { evidenceRef: ref }),
+      tool(
+        "cms",
+        "list_resources",
+        [{ kind: "ConfigMap", name: "kube-root-ca.crt" }],
+        {
+          evidenceRef: listRef,
+          summary: JSON.stringify({ kind: "configmaps", namespace: "shop" }),
+        },
+      ),
+    );
+    const resolved = resolveInvestigationCase(
+      withListing,
+      {
+        evidence: [
+          linked(listRef, "context", "The nginx config is mounted from here.", {
+            kind: "ConfigMap",
+            namespace: "shop",
+            name: "nginx-config",
+            observation: "resource",
+          }),
+        ],
+      },
+      0,
+    );
+    expect(resolved.items.map((item) => item.placement)).toEqual(["card"]);
+  });
+
+  it("places a Namespace citation on a namespace listing, whose call names no kind", () => {
+    const nsRef = evidenceRef("g", "h");
+    const withNamespaces = project(
+      tool("diag", "diagnose", diagnoseBundle, { evidenceRef: ref }),
+      tool(
+        "ns",
+        "list_namespaces",
+        [
+          { name: "shop", status: "Active" },
+          { name: "capi-system", status: "Terminating" },
+        ],
+        { evidenceRef: nsRef, summary: "{}" },
+      ),
+    );
+    const resolved = resolveInvestigationCase(
+      withNamespaces,
+      {
+        evidence: [
+          linked(nsRef, "context", "Only two namespaces exist.", {
+            kind: "Namespace",
+            observation: "resource",
+          }),
+          linked(nsRef, "rules_out", "shop is not terminating.", {
+            kind: "Namespace",
+            name: "shop",
+            observation: "resource",
+          }),
+        ],
+      },
+      0,
+    );
+    expect(resolved.items.map((item) => item.placement)).toEqual([
+      "card",
+      "card",
+    ]);
+  });
+
   it("pins a subject-bearing item to exactly the observation it names", () => {
     const resolved = resolveInvestigationCase(
       projection,
@@ -210,6 +465,11 @@ describe("agent case placement (D-1, D-1b)", () => {
             name: "api",
             observation: "events",
           }),
+          linked(ref, "context", "Namespace-named events land too.", {
+            kind: "Namespace",
+            name: "shop",
+            observation: "events",
+          }),
           linked(
             ref,
             "context",
@@ -240,6 +500,7 @@ describe("agent case placement (D-1, D-1b)", () => {
         kind: "resource",
       },
       "Events only repeat the back-off.": { placement: "card", kind: "events" },
+      "Namespace-named events land too.": { placement: "card", kind: "events" },
       "Ambiguous: two observations share this subject.": {
         placement: "source",
         kind: undefined,
@@ -1069,130 +1330,6 @@ describe("follow-up answers that cite evidence", () => {
   });
 });
 
-describe("carrying earlier assessments' card notes", () => {
-  const item = (
-    index: number,
-    groupId: string | undefined,
-    placement: "card" | "revision" | "source",
-    role: "cause" | "context" | "demoted" = "context",
-  ) =>
-    ({
-      index,
-      role,
-      claim: `claim ${index}`,
-      source: { id: `s${index}` },
-      placement,
-      groupId,
-    }) as unknown as InvestigationCaseItem;
-
-  it("keeps an earlier turn's note on a card the live turn did not address", () => {
-    const live = {
-      items: [item(0, "chart", "card")],
-      ruledOut: [],
-    } as unknown as InvestigationCaseResolution;
-    const first = {
-      items: [
-        item(0, "logs", "card", "demoted"),
-        item(1, "chart", "card", "cause"),
-        item(2, undefined, "source"),
-        item(3, "deploy", "revision"),
-      ],
-      ruledOut: [{ hypothesis: "x" }],
-    } as unknown as InvestigationCaseResolution;
-    const merged = mergeInvestigationCases(live, [first]);
-    expect(merged?.items.map((entry) => [entry.groupId, entry.role])).toEqual([
-      ["chart", "context"],
-      ["logs", "demoted"],
-      ["deploy", "context"],
-    ]);
-    expect(merged?.ruledOut).toEqual([]);
-  });
-
-  it("lets the newer earlier turn win a card and leaves a lone live case untouched", () => {
-    const live = {
-      items: [],
-      ruledOut: [],
-    } as unknown as InvestigationCaseResolution;
-    const newer = {
-      items: [item(0, "logs", "card", "context")],
-      ruledOut: [],
-    } as unknown as InvestigationCaseResolution;
-    const older = {
-      items: [item(0, "logs", "card", "demoted"), item(1, "pod", "card")],
-      ruledOut: [],
-    } as unknown as InvestigationCaseResolution;
-    const merged = mergeInvestigationCases(live, [newer, older]);
-    expect(merged?.items.map((entry) => [entry.groupId, entry.role])).toEqual([
-      ["logs", "context"],
-      ["pod", "context"],
-    ]);
-    expect(mergeInvestigationCases(live, [])).toBe(live);
-    expect(mergeInvestigationCases(undefined, [])).toBeUndefined();
-  });
-
-  it("recognises its own surviving notes across a re-resolved merge", () => {
-    // The pane feeds the merge freshly resolved copies of every turn, so the
-    // assessment's own items arrive equal but not identical. An identity test
-    // reported them as gone, which silently retired the conflict banner's
-    // reframing whenever any unrelated follow-up arrived.
-    const assessmentItems = [
-      item(0, "logs", "card", "demoted"),
-      item(1, "crash", "card", "demoted"),
-    ];
-    const reResolved = assessmentItems.map(
-      (entry) => ({ ...entry }) as InvestigationCaseItem,
-    );
-    expect(reResolved[0]).not.toBe(assessmentItems[0]);
-    expect(
-      investigationCaseItemsStillRendered(assessmentItems, reResolved).map(
-        (entry) => entry.groupId,
-      ),
-    ).toEqual(["logs", "crash"]);
-    // A note the merge dropped is correctly reported as gone.
-    expect(
-      investigationCaseItemsStillRendered(assessmentItems, [reResolved[0]]).map(
-        (entry) => entry.groupId,
-      ),
-    ).toEqual(["logs"]);
-    expect(investigationCaseItemsStillRendered(assessmentItems, [])).toEqual(
-      [],
-    );
-  });
-
-  it("carries every note the winning assessment left on a card, not just the first", () => {
-    // A card note and a note pinned to a superseded read are two readings of
-    // one group by the same assessment. Taking coverage per item dropped the
-    // second, so a visible Cause note could vanish behind a revision note.
-    const live = {
-      items: [item(0, "other", "card", "context")],
-      ruledOut: [],
-    } as unknown as InvestigationCaseResolution;
-    const winner = {
-      items: [
-        item(1, "logs", "revision", "context"),
-        item(2, "logs", "card", "cause"),
-      ],
-      ruledOut: [],
-    } as unknown as InvestigationCaseResolution;
-    const older = {
-      items: [item(3, "logs", "card", "demoted")],
-      ruledOut: [],
-    } as unknown as InvestigationCaseResolution;
-    const merged = mergeInvestigationCases(live, [winner, older]);
-    expect(
-      merged?.items.map((entry) => [
-        entry.groupId,
-        entry.placement,
-        entry.role,
-      ]),
-    ).toEqual([
-      ["other", "card", "context"],
-      ["logs", "revision", "context"],
-      ["logs", "card", "cause"],
-    ]);
-  });
-});
-
 describe("agent case robustness", () => {
   const ref = evidenceRef("a", "b");
 
@@ -1294,7 +1431,7 @@ describe("agent case robustness", () => {
     );
   });
 
-  it("keeps valid items when siblings are unlinked, malformed, foreign, or from another turn", () => {
+  it("keeps valid items when siblings are unlinked or malformed, and places an earlier turn's read", () => {
     const stale = evidenceRef("a", "z");
     const projection = projectInvestigationEvidence(
       [
@@ -1346,6 +1483,7 @@ describe("agent case robustness", () => {
     );
     expect(resolved.items.map((item) => [item.index, item.placement])).toEqual([
       [1, "card"],
+      [4, "revision"],
       [5, "source"],
     ]);
     expect(resolved.ruledOut.map((entry) => entry.hypothesis)).toEqual([
@@ -1553,7 +1691,7 @@ describe("the agent's contribution is one attributed row", () => {
 
   it("labels the role that says an adverse result is not a live problem", () => {
     const html = renderToStaticMarkup(<AgentRoleChip role="benign" />);
-    expect(html).toContain("Not a problem");
+    expect(html).toContain("Not a live problem");
   });
 
   it("still shows an attributed role when the agent left no sentence", () => {