@skyhook-io/k8s-ui 1.17.0 → 1.18.0

package/src/components/resources/column-order.test.ts

@@ -0,0 +1,104 @@
+import { describe, expect, it } from 'vitest'
+import { applyColumnOrder, moveColumn, pinnedColumnCount, sanitizeColumnOrder } from './column-order'
+
+const cols = (...keys: string[]) => keys.map(key => ({ key }))
+const keysOf = (list: { key: string }[]) => list.map(c => c.key)
+
+const PODS = cols('name', 'namespace', 'ready', 'status', 'restarts', 'age', 'node')
+
+describe('applyColumnOrder', () => {
+  it('keeps definition order when no saved order is provided', () => {
+    expect(keysOf(applyColumnOrder(PODS, undefined))).toEqual(keysOf(PODS))
+    expect(keysOf(applyColumnOrder(PODS, null))).toEqual(keysOf(PODS))
+    expect(keysOf(applyColumnOrder(PODS, []))).toEqual(keysOf(PODS))
+  })
+
+  it('applies the saved order and keeps Name first', () => {
+    const order = ['age', 'restarts', 'namespace', 'ready', 'status', 'node']
+    expect(keysOf(applyColumnOrder(PODS, order)))
+      .toEqual(['name', 'age', 'restarts', 'namespace', 'ready', 'status', 'node'])
+  })
+
+  it('ignores a saved Name position', () => {
+    const order = ['age', 'name', 'namespace', 'ready', 'status', 'restarts', 'node']
+    expect(keysOf(applyColumnOrder(PODS, order))[0]).toBe('name')
+  })
+
+  it('keeps host columns that lead Name in front of it', () => {
+    const fleet = cols('cluster', 'name', 'namespace', 'age')
+    expect(keysOf(applyColumnOrder(fleet, ['age', 'cluster', 'namespace'])))
+      .toEqual(['cluster', 'name', 'age', 'namespace'])
+  })
+
+  it('puts a column added after the save in its default position', () => {
+    // 'ip' arrives between status and restarts; the user had moved age up.
+    const next = cols('name', 'namespace', 'ready', 'status', 'ip', 'restarts', 'age', 'node')
+    const order = ['age', 'namespace', 'ready', 'status', 'restarts', 'node']
+    expect(keysOf(applyColumnOrder(next, order)))
+      .toEqual(['name', 'age', 'namespace', 'ready', 'status', 'ip', 'restarts', 'node'])
+  })
+
+  it('appends a new trailing column, such as a label column, at the end', () => {
+    const next = [...PODS, { key: 'label:app' }]
+    const order = ['node', 'age', 'namespace', 'ready', 'status', 'restarts']
+    expect(keysOf(applyColumnOrder(next, order)).at(-1)).toBe('label:app')
+  })
+
+  it('keeps several new adjacent columns in their definition order', () => {
+    const next = cols('name', 'a', 'b', 'namespace', 'age')
+    expect(keysOf(applyColumnOrder(next, ['age', 'namespace'])))
+      .toEqual(['name', 'age', 'a', 'b', 'namespace'])
+  })
+
+  it('keeps a hidden column in place: order is independent of visibility', () => {
+    const order = ['age', 'restarts', 'namespace', 'ready', 'status', 'node']
+    const ordered = applyColumnOrder(PODS, order)
+    const visible = new Set(['name', 'age', 'namespace', 'ready', 'status', 'node'])
+    expect(keysOf(ordered.filter(c => visible.has(c.key))))
+      .toEqual(['name', 'age', 'namespace', 'ready', 'status', 'node'])
+    visible.add('restarts')
+    expect(keysOf(ordered.filter(c => visible.has(c.key))))
+      .toEqual(['name', 'age', 'restarts', 'namespace', 'ready', 'status', 'node'])
+  })
+
+  it('drops saved keys for columns that no longer exist', () => {
+    const order = ['gone', 'age', 'namespace', 'ready', 'status', 'restarts', 'node']
+    expect(keysOf(applyColumnOrder(PODS, order)))
+      .toEqual(['name', 'age', 'namespace', 'ready', 'status', 'restarts', 'node'])
+  })
+})
+
+describe('sanitizeColumnOrder', () => {
+  it('reads anything that is not a key list as no order', () => {
+    expect(sanitizeColumnOrder(undefined)).toBeNull()
+    expect(sanitizeColumnOrder('age')).toBeNull()
+    expect(sanitizeColumnOrder({ 0: 'age' })).toBeNull()
+    expect(sanitizeColumnOrder([1, null])).toBeNull()
+  })
+
+  it('keeps string keys, first occurrence wins', () => {
+    expect(sanitizeColumnOrder(['age', 3, 'node', 'age'])).toEqual(['age', 'node'])
+  })
+})
+
+describe('moveColumn', () => {
+  it('returns the movable keys with the column moved', () => {
+    expect(moveColumn(PODS, 'age', 0)).toEqual(['age', 'namespace', 'ready', 'status', 'restarts', 'node'])
+    expect(moveColumn(PODS, 'namespace', 5)).toEqual(['ready', 'status', 'restarts', 'age', 'node', 'namespace'])
+  })
+
+  it('returns null for a no-op, an out-of-range edge move, or a pinned column', () => {
+    expect(moveColumn(PODS, 'namespace', -1)).toBeNull()
+    expect(moveColumn(PODS, 'node', 99)).toBeNull()
+    expect(moveColumn(PODS, 'name', 2)).toBeNull()
+    expect(moveColumn(PODS, 'missing', 0)).toBeNull()
+  })
+})
+
+describe('pinnedColumnCount', () => {
+  it('pins through Name, and nothing when there is no Name column', () => {
+    expect(pinnedColumnCount(PODS)).toBe(1)
+    expect(pinnedColumnCount(cols('cluster', 'name', 'age'))).toBe(2)
+    expect(pinnedColumnCount(cols('age'))).toBe(0)
+  })
+})

package/src/components/resources/column-order.ts

@@ -0,0 +1,64 @@
+// The user's column order for a resource table, kept apart from visibility: it
+// lists every movable column, hidden ones included, so a column hidden and later
+// re-shown comes back where it was.
+
+interface Keyed {
+  key: string
+}
+
+/** Columns up to and including Name stay where the kind defines them. Name is
+ *  the flexible column and the row link; host-injected leading columns sit in
+ *  front of it by contract. */
+export function pinnedColumnCount(columns: readonly Keyed[]): number {
+  return columns.findIndex(c => c.key === 'name') + 1
+}
+
+/** A saved order read from localStorage: only string keys, first occurrence
+ *  wins. Anything else reads as "no saved order". */
+export function sanitizeColumnOrder(raw: unknown): string[] | null {
+  if (!Array.isArray(raw)) return null
+  const seen = new Set<string>()
+  for (const k of raw) {
+    if (typeof k === 'string' && !seen.has(k)) seen.add(k)
+  }
+  return seen.size ? Array.from(seen) : null
+}
+
+/**
+ * Columns in the user's saved order.
+ *
+ * Saved keys that no longer exist are ignored. A column the saved order does not
+ * name (a built-in, printer, or custom column) goes
+ * where it sits by default: right before the column that follows it in the
+ * definition, or at the end when nothing that follows it is in the saved order.
+ */
+export function applyColumnOrder<T extends Keyed>(columns: readonly T[], order: readonly string[] | null | undefined): T[] {
+  if (!order?.length) return [...columns]
+  const pinned = pinnedColumnCount(columns)
+  const movable = columns.slice(pinned)
+  const rank = new Map(order.map((k, i) => [k, i]))
+  const result = movable
+    .filter(c => rank.has(c.key))
+    .sort((a, b) => rank.get(a.key)! - rank.get(b.key)!)
+  movable.forEach((c, i) => {
+    if (rank.has(c.key)) return
+    const anchor = movable.slice(i + 1).find(n => rank.has(n.key))
+    const at = anchor ? result.indexOf(anchor) : -1
+    if (at === -1) result.push(c)
+    else result.splice(at, 0, c)
+  })
+  return [...columns.slice(0, pinned), ...result]
+}
+
+/** The movable keys of `columns` (already in display order) after moving `key`
+ *  to `toIndex` within them. Returns null when nothing would change. */
+export function moveColumn(columns: readonly Keyed[], key: string, toIndex: number): string[] | null {
+  const keys = columns.slice(pinnedColumnCount(columns)).map(c => c.key)
+  const from = keys.indexOf(key)
+  if (from === -1) return null
+  const to = Math.max(0, Math.min(keys.length - 1, toIndex))
+  if (to === from) return null
+  keys.splice(from, 1)
+  keys.splice(to, 0, key)
+  return keys
+}

package/src/components/resources/curated-column-ownership.test.ts

@@ -108,8 +108,8 @@ describe('curated column ownership', () => {
   // Brace-counting, not parsing: assert the extraction actually saw the whole
   // table, or a silently-missed key would let the guard above pass vacuously.
   it('extracted every curated key', () => {
-    expect(CURATED.length).toBe(239)
-    expect(OWNED.size).toBe(201)
+    expect(CURATED.length).toBe(240)
+    expect(OWNED.size).toBe(202)
     expect(CURATED).toContain('pods')
     expect(CURATED).toContain('crossplanemanagedresources')
     expect([...OWNED]).toContain('awsmanagedcontrolplanes')
@@ -166,7 +166,7 @@ describe('every declaration resolves', () => {
     .map(m => [m[1], m[2].split(',').map(g => g.trim().replace(/'/g, ''))] as const)
 
   it('covers the whole ownership table', () => {
-    expect(DECLARED.length).toBe(201)
+    expect(DECLARED.length).toBe(202)
   })
 
   it.each(DECLARED)('%s is curated under each group it claims', (key, groups) => {

package/src/components/resources/renderers/ArgoApplicationRenderer.test.tsx

@@ -0,0 +1,15 @@
+import { renderToStaticMarkup } from 'react-dom/server'
+import { describe, expect, it } from 'vitest'
+import { ArgoApplicationRenderer } from './ArgoApplicationRenderer'
+
+describe('Argo Helm value files', () => {
+  it.each([true, false, undefined])('shows missing-file behavior for single and multiple sources: %s', optional => {
+    const source = { chart: 'cluster', repoURL: 'https://cloudnative-pg.github.io/charts', helm: { valueFiles: ['values.yaml', 'overrides.yaml'], ignoreMissingValueFiles: optional } }
+    for (const spec of [{ source }, { sources: [source] }]) {
+      const html = renderToStaticMarkup(<ArgoApplicationRenderer data={{ metadata: { name: 'app' }, spec }} />)
+      expect(html).toContain('values.yaml, overrides.yaml')
+      expect(html).toContain('If a Value File Is Missing')
+      expect(html).toContain(optional ? 'Skipped' : 'Render fails')
+    }
+  })
+})

package/src/components/resources/renderers/ArgoApplicationRenderer.tsx

@@ -81,7 +81,10 @@ function SourceProperties({ source }: { source: any }) {
       )}
       {source.chart && <Property label="Helm Chart" value={source.chart} />}
       {source.helm?.valueFiles && source.helm.valueFiles.length > 0 && (
-        <Property label="Value Files" value={source.helm.valueFiles.join(', ')} />
+        <>
+          <Property label="Value Files" value={source.helm.valueFiles.join(', ')} />
+          <Property label="If a Value File Is Missing" value={source.helm.ignoreMissingValueFiles === true ? 'Skipped' : 'Render fails'} />
+        </>
       )}
       {source.helm?.parameters && source.helm.parameters.length > 0 && (
         <Property

package/src/components/resources/renderers/AutoscalingReferences.test.tsx

@@ -0,0 +1,286 @@
+// @vitest-environment jsdom
+import { act } from "react";
+import { createRoot } from "react-dom/client";
+import { renderToStaticMarkup } from "react-dom/server";
+import { expect, it, vi } from "vitest";
+import { HPARenderer } from "./HPARenderer";
+import { VPARenderer } from "./VPARenderer";
+import { KedaScaledObjectRenderer } from "./KedaScaledObjectRenderer";
+import {
+  initNavigationMap,
+  resetNavigationMap,
+} from "../../../utils/navigation";
+Object.assign(globalThis, { IS_REACT_ACT_ENVIRONMENT: true });
+
+it.each(["HPA", "VPA"])(
+  "retains a %s custom scale target API group",
+  async (kind) => {
+    initNavigationMap([
+      {
+        group: "custom.example.io",
+        version: "v1",
+        kind: "Deployment",
+        name: "deployments",
+        namespaced: true,
+        isCrd: true,
+        verbs: ["get"],
+      },
+    ]);
+    const element = document.createElement("div");
+    const root = createRoot(element);
+    const onNavigate = vi.fn();
+    const target = {
+      apiVersion: "custom.example.io/v1",
+      kind: "Deployment",
+      name: "same-name",
+    };
+    const data = {
+      metadata: { namespace: "team" },
+      spec: kind === "HPA" ? { scaleTargetRef: target } : { targetRef: target },
+    };
+    try {
+      await act(async () =>
+        root.render(
+          kind === "HPA" ? (
+            <HPARenderer data={data} onNavigate={onNavigate} />
+          ) : (
+            <VPARenderer data={data} onNavigate={onNavigate} />
+          ),
+        ),
+      );
+      const button = [...element.querySelectorAll("button")].find(
+        (b) => b.textContent === "Deployment/same-name",
+      );
+      expect(button).toBeDefined();
+      expect([...element.querySelectorAll("button")].filter(b => b.textContent?.startsWith("Deployment/same-name"))).toHaveLength(1);
+      await act(async () => button!.click());
+      expect(onNavigate).toHaveBeenCalledWith({
+        kind: "Deployment",
+        namespace: "team",
+        name: "same-name",
+        group: "custom.example.io",
+      });
+    } finally {
+      await act(async () => root.unmount());
+      resetNavigationMap();
+    }
+  },
+);
+
+it.each(["v1", "", undefined])("keeps Object metric resources separate from the scale target and measures its own Namespace (apiVersion %s)", async (namespaceAPIVersion) => {
+  const element = document.createElement("div");
+  const root = createRoot(element);
+  const onNavigate = vi.fn();
+  const data = {
+    metadata: { namespace: "team" },
+    spec: {
+      scaleTargetRef: {
+        apiVersion: "apps/v1",
+        kind: "Deployment",
+        name: "workload",
+      },
+      metrics: [
+        {
+          type: "Object",
+          object: {
+            metric: { name: "requests" },
+            describedObject: {
+              apiVersion: "networking.k8s.io/v1",
+              kind: "Ingress",
+              name: "frontend",
+            },
+          },
+        },
+        {
+          type: "Object",
+          object: {
+            metric: { name: "queue" },
+            describedObject: {
+              apiVersion: "custom.example.io/v1",
+              kind: "Widget",
+              name: "input",
+            },
+          },
+        },
+        {
+          type: "Object",
+          object: {
+            metric: { name: "namespace-metric" },
+            describedObject: {
+              apiVersion: namespaceAPIVersion,
+              kind: "Namespace",
+              name: "cannot-escape",
+            },
+          },
+        },
+      ],
+    },
+  };
+  try {
+    await act(async () =>
+      root.render(<HPARenderer data={data} onNavigate={onNavigate} />),
+    );
+    for (const [label, expected] of [
+      [
+        "Ingress/frontend",
+        { kind: "Ingress", group: "networking.k8s.io", namespace: "team", name: "frontend" },
+      ],
+      [
+        "Widget/input",
+        {
+          kind: "Widget",
+          group: "custom.example.io",
+          namespace: "team",
+          name: "input",
+        },
+      ],
+      [
+        "Namespace/team",
+        { kind: "Namespace", group: "", namespace: "", name: "team" },
+      ],
+    ] as const) {
+      const button = [...element.querySelectorAll("button")].find(
+        (b) => b.textContent === label,
+      );
+      expect(button).toBeDefined();
+      await act(async () => button!.click());
+      expect(onNavigate).toHaveBeenLastCalledWith(expected);
+    }
+    expect(element.textContent).toContain("Object metric sources");
+    expect(element.textContent).toContain("This HPA's namespace");
+    expect(element.textContent).not.toContain("Namespace/cannot-escape");
+  } finally {
+    await act(async () => root.unmount());
+  }
+});
+
+it.each(["HPA", "VPA"])("does not infer missing %s target identity", (kind) => {
+  const target = { name: "ambiguous" };
+  const data = {
+    metadata: { namespace: "team" },
+    spec: kind === "HPA" ? { scaleTargetRef: target } : { targetRef: target },
+  };
+  const html = renderToStaticMarkup(
+    kind === "HPA" ? (
+      <HPARenderer data={data} onNavigate={() => {}} />
+    ) : (
+      <VPARenderer data={data} onNavigate={() => {}} />
+    ),
+  );
+  const doc = new DOMParser().parseFromString(html, "text/html");
+  expect(
+    [...doc.querySelectorAll("button")].some((b) =>
+      b.textContent?.includes("ambiguous"),
+    ),
+  ).toBe(false);
+  expect(html).not.toContain("Deployment/ambiguous");
+});
+
+it.each([
+  [
+    { name: "worker" },
+    { kind: "Deployment", group: "apps", namespace: "team", name: "worker" },
+  ],
+  [
+    { name: "worker", apiVersion: "", kind: "" },
+    { kind: "Deployment", group: "apps", namespace: "team", name: "worker" },
+  ],
+  [
+    { apiVersion: "custom.example.io/v1", kind: "Deployment", name: "worker" },
+    {
+      kind: "Deployment",
+      group: "custom.example.io",
+      namespace: "team",
+      name: "worker",
+    },
+  ],
+])(
+  "preserves KEDA documented defaults and explicit custom API identity",
+  async (target, expected) => {
+    const element = document.createElement("div");
+    const root = createRoot(element);
+    const onNavigate = vi.fn();
+    try {
+      await act(async () =>
+        root.render(
+          <KedaScaledObjectRenderer
+            data={{
+              metadata: { namespace: "team" },
+              spec: { scaleTargetRef: target },
+            }}
+            onNavigate={onNavigate}
+          />,
+        ),
+      );
+      const button = [...element.querySelectorAll("button")].find(
+        (b) => b.textContent === "Deployment/worker",
+      );
+      expect(button).toBeDefined();
+      await act(async () => button!.click());
+      expect(onNavigate).toHaveBeenCalledWith(expected);
+    } finally {
+      await act(async () => root.unmount());
+    }
+  },
+);
+
+it.each([
+  ["Deployment", "apps"], ["StatefulSet", "apps"], ["DaemonSet", "apps"], ["ReplicaSet", "apps"],
+  ["Job", "batch"], ["CronJob", "batch"], ["ReplicationController", ""],
+])("keeps versionless VPA %s target navigation", async (kind, group) => {
+  const element = document.createElement("div");
+  const root = createRoot(element);
+  const onNavigate = vi.fn();
+  try {
+    await act(async () => root.render(<VPARenderer data={{ metadata: { namespace: "team" }, spec: { targetRef: { kind, name: "workload" } } }} onNavigate={onNavigate} />));
+    const link = [...element.querySelectorAll("button")].find(button => button.textContent === `${kind}/workload`);
+    expect(link).toBeDefined();
+    await act(async () => link!.click());
+    expect(onNavigate).toHaveBeenLastCalledWith({ kind, group, namespace: "team", name: "workload" });
+  } finally {
+    await act(async () => root.unmount());
+  }
+});
+
+it("pairs each diagnosis metric card with its declared Object source once", async () => {
+  const element = document.createElement("div");
+  const root = createRoot(element);
+  const onNavigate = vi.fn();
+  const objects = [
+    { metric: { name: "requests" }, describedObject: { apiVersion: "v1", kind: "Endpoints", name: "input" } },
+    { metric: { name: "requests" }, describedObject: { apiVersion: "custom.example.io/v1", kind: "Endpoints", name: "input" } },
+    { metric: { name: "queue_depth" }, describedObject: { kind: "Namespace", name: "ignored" } },
+  ];
+  try {
+    await act(async () => root.render(<HPARenderer
+      data={{ metadata: { namespace: "team" }, spec: { metrics: objects.map(object => ({ type: "Object", object })) } }}
+      hpaDiagnosis={{ state: "stabilized", summary: "Stabilized", target: {}, bounds: { min: 1, max: 3, current: 2, desired: 2 }, metrics: [
+        { type: "Object", name: "Endpoints/input/requests", current: "10", status: "ok" },
+        { type: "Object", name: "Endpoints (custom.example.io)/input/requests", current: "20", status: "ok" },
+        { type: "Object", name: "Namespace/team/queue_depth", current: "7", status: "ok" },
+        { type: "Object", name: "Service/stale/requests", current: "3", status: "status_only" },
+      ] }} onNavigate={onNavigate} />));
+    expect(element.textContent).not.toContain("Object metric sources");
+    expect(element.textContent).not.toContain("ignored");
+    const endpoints = [...element.querySelectorAll("button")].filter(button => button.textContent === "Endpoints/input");
+    expect(endpoints).toHaveLength(2);
+    await act(async () => endpoints[0].click());
+    expect(onNavigate).toHaveBeenLastCalledWith({ kind: "Endpoints", group: "", namespace: "team", name: "input" });
+    await act(async () => endpoints[1].click());
+    expect(onNavigate).toHaveBeenLastCalledWith({ kind: "Endpoints", group: "custom.example.io", namespace: "team", name: "input" });
+    const namespace = [...element.querySelectorAll("button")].find(button => button.textContent === "Namespace/team");
+    expect(namespace).toBeDefined();
+    await act(async () => namespace!.click());
+    expect(onNavigate).toHaveBeenLastCalledWith({ kind: "Namespace", group: "", namespace: "", name: "team" });
+    expect([...element.querySelectorAll("button")].some(button => button.textContent === "Service/stale")).toBe(false);
+    for (const value of ["Current 10", "Current 20", "Current 7"]) expect(element.textContent).toContain(value);
+  } finally {
+    await act(async () => root.unmount());
+  }
+});
+
+it("shows the documented default Target API for KEDA", () => {
+  const html = renderToStaticMarkup(<KedaScaledObjectRenderer data={{ metadata: { namespace: "team" }, spec: { scaleTargetRef: { name: "worker" } } }} />);
+  expect(html).toContain("Target API");
+  expect(html).toContain("apps/v1");
+});

package/src/components/resources/renderers/CAPIClusterRenderer.tsx

@@ -27,6 +27,7 @@ export function CAPIClusterRenderer({ data, onNavigate, apiBase = '', canConnect
   const className = getClusterClass(data)
   const version = getClusterVersion(data)
   const topology = spec.topology || {}
+  const classNamespace = (topology.classRef?.name ? topology.classRef.namespace : topology.classNamespace) || data.metadata?.namespace || ''
 
   // v1beta2 replica fields
   const cpReady = status.controlPlane?.readyReplicas ?? status.controlPlane?.replicas
@@ -201,10 +202,10 @@ export function CAPIClusterRenderer({ data, onNavigate, apiBase = '', canConnect
       </Section>
 
       {/* Topology (ClusterClass-based) */}
-      {topology.class && (
+      {className !== '-' && (
         <Section title="Topology" icon={Layers}>
           <PropertyList>
-            <Property label="Class" value={topology.class} />
+            <Property label="Class" value={<ResourceLink name={className} kind="clusterclasses" group="cluster.x-k8s.io" namespace={classNamespace} onNavigate={onNavigate} />} />
             {topology.version && <Property label="Version" value={topology.version} />}
             {topology.controlPlane?.replicas != null && (
               <Property label="CP Replicas" value={String(topology.controlPlane.replicas)} />

package/src/components/resources/renderers/CAPIExactReferenceNavigation.test.tsx

@@ -0,0 +1,27 @@
+// @vitest-environment jsdom
+import { act, type ReactNode } from 'react'
+import { createRoot } from 'react-dom/client'
+import { describe, expect, it, vi } from 'vitest'
+import { CAPIClusterRenderer } from './CAPIClusterRenderer'
+
+async function rendered(element: ReactNode, check: (container: HTMLDivElement) => Promise<void> | void) {
+ Object.assign(globalThis, { IS_REACT_ACT_ENVIRONMENT: true })
+ const container = document.createElement('div')
+ const root = createRoot(container)
+ try { await act(async () => root.render(element)); await check(container) }
+ finally { await act(async () => root.unmount()); Object.assign(globalThis, { IS_REACT_ACT_ENVIRONMENT: false }) }
+}
+async function click(container: HTMLDivElement, text: string) {
+ const button = [...container.querySelectorAll('button')].find(button => button.textContent === text)
+ expect(button, `missing link ${text}`).toBeDefined()
+ await act(async () => button!.click())
+}
+
+describe('exact reference navigation', () => {
+ it('uses the v1beta2 ClusterClass reference namespace',async()=>{
+  const navigate=vi.fn()
+  await rendered(<CAPIClusterRenderer data={{metadata:{namespace:'app'},spec:{topology:{classRef:{name:'standard',namespace:'classes'}}}}} onNavigate={navigate}/>,async container=>{
+   await click(container,'standard');expect(navigate).toHaveBeenCalledWith({kind:'clusterclasses',group:'cluster.x-k8s.io',namespace:'classes',name:'standard'})
+  })
+ })
+})

package/src/components/resources/renderers/CNPGBackupRenderer.test.tsx

@@ -27,3 +27,26 @@ describe('CNPGBackupRenderer — spec.target is instance selection, not a restor
     expect(html(backup())).not.toContain('Backup Target')
   })
 })
+
+
+describe('CNPGBackupRenderer plugin destination', () => {
+  it.each([undefined, { barmanObjectName: 'ignored-store', serverName: 'ignored-server' }, { serverName: 'ignored-server' }])('explains the Cluster destination and ignored parameters: %j', (parameters) => {
+    const out = renderToString(<CNPGBackupRenderer data={backup({ spec: { method: 'plugin', pluginConfiguration: { name: 'barman-cloud.cloudnative-pg.io', parameters } } })} onNavigate={() => {}} />)
+    expect(out).toContain('From the Cluster')
+    expect(out).toContain('barman-cloud plugin')
+    expect(out).not.toContain('Object Store')
+    expect(out).not.toContain('ignored-store')
+    expect(out).not.toContain('ignored-server')
+    expect(out.match(/<button[^>]*>(?:pg|ignored-store|ignored-server)<\/button>/g)).toHaveLength(1)
+    expect(out.includes('Ignored by the barman-cloud plugin')).toBe(!!parameters)
+  })
+
+  it('does not assert a third-party parameter is an ObjectStore destination', () => {
+    const out = html(backup({ spec: { method: 'plugin', pluginConfiguration: { name: 'other.example.com', parameters: { barmanObjectName: 'custom-store' } } } }))
+    expect(out).toContain('other.example.com')
+    expect(out).toContain('Unknown: Radar does not model this plugin')
+    expect(out).not.toContain('custom-store')
+    expect(out).not.toContain('Object Store')
+    expect(out).not.toContain('Ignored by')
+  })
+})

package/src/components/resources/renderers/CNPGBackupRenderer.tsx

@@ -12,7 +12,7 @@ import {
   getCNPGBackupServerName,
   getCNPGBackupError,
   getCNPGBackupTarget,
-  CNPG_BARMAN_OBJECTSTORE_GROUP,
+  CNPG_BARMAN_PLUGIN_NAME,
 } from '../resource-utils-cnpg'
 
 interface CNPGBackupRendererProps {
@@ -51,24 +51,16 @@ export function CNPGBackupRenderer({ data, onNavigate }: CNPGBackupRendererProps
         <PropertyList>
           <Property label="Phase" value={phase} />
           <Property label="Method" value={getCNPGBackupMethod(data)} />
-          {/* A plugin-taken backup lands in an ObjectStore rather than in the
-              Cluster's own barmanObjectStore, so naming the plugin is what
-              tells an operator where to go looking. */}
           {backupPlugin && <Property label="Plugin" value={backupPlugin.name} />}
-          {backupPlugin?.parameters?.barmanObjectName && (
+          {backupPlugin && (
             <Property
-              label="Object Store"
-              value={
-                <ResourceLink
-                  name={backupPlugin.parameters.barmanObjectName}
-                  kind="objectstores"
-                  group={CNPG_BARMAN_OBJECTSTORE_GROUP}
-                  namespace={data.metadata?.namespace || ''}
-                  onNavigate={onNavigate}
-                />
-              }
+              label="Destination"
+              value={backupPlugin.name === CNPG_BARMAN_PLUGIN_NAME ? "From the Cluster's barman-cloud plugin" : 'Unknown: Radar does not model this plugin’s destination'}
             />
           )}
+          {backupPlugin?.name === CNPG_BARMAN_PLUGIN_NAME && backupPlugin.parameters && Object.keys(backupPlugin.parameters).length > 0 && (
+            <Property label="Plugin parameters" value="Ignored by the barman-cloud plugin; the destination comes from the Cluster" />
+          )}
           <Property label="Duration" value={getCNPGBackupDuration(data)} />
           <Property label="Backup Name" value={getCNPGBackupName(data)} />
           {data.status?.instanceID?.podName && (
@@ -102,10 +94,7 @@ export function CNPGBackupRenderer({ data, onNavigate }: CNPGBackupRendererProps
             }
             return clusterName
           })()} />
-          {/* Destination and server name are in-tree barmanObjectStore fields.
-              Under the plugin method they are never populated because both live
-              on the ObjectStore, and rendering them as "-" reads as "not
-              configured" rather than "recorded elsewhere". */}
+          {/* Plugin backups do not report the in-tree destination fields. */}
           {!backupPlugin && (
             <>
               <Property label="Destination" value={getCNPGBackupDestinationPath(data)} />