@skyhook-io/k8s-ui 1.16.1 → 1.16.3

package/src/components/resources/resource-utils-cnpg.ts

@@ -600,7 +600,7 @@ export interface CNPGObjectStoreRecoveryWindow {
   firstRecoverabilityPoint?: string
   lastSuccessfulBackupTime?: string
   lastFailedBackupTime?: string
-  /** A failure newer than the last success — the window has stopped advancing. */
+  /** A failure newer than the last success, or a failure and no success at all. */
   failingSinceLastSuccess: boolean
 }
 
@@ -641,7 +641,7 @@ export function getCNPGObjectStoreRecoveryWindows(resource: any): CNPGObjectStor
 export function getCNPGObjectStoreStatus(resource: any): StatusBadge {
   const windows = getCNPGObjectStoreRecoveryWindows(resource)
   if (windows.length === 0) {
-    return { text: 'No backups yet', color: healthColors.unknown, level: 'unknown' }
+    return { text: 'No backup recorded', color: healthColors.unknown, level: 'unknown' }
   }
   if (windows.some((w) => w.failingSinceLastSuccess)) {
     return { text: 'Backups Failing', color: healthColors.unhealthy, level: 'unhealthy' }
@@ -649,7 +649,7 @@ export function getCNPGObjectStoreStatus(resource: any): StatusBadge {
   // Every timestamp on a recovery window is optional, so a server can be listed
   // with no recovery point at all. The entry existing is not a backup existing.
   if (!windows.some((w) => w.firstRecoverabilityPoint || w.lastSuccessfulBackupTime)) {
-    return { text: 'No recovery point', color: healthColors.unknown, level: 'unknown' }
+    return { text: 'Recovery point not reported', color: healthColors.unknown, level: 'unknown' }
   }
   return { text: 'Recoverable', color: healthColors.healthy, level: 'healthy' }
 }

package/src/components/resources/status-overclaim.test.ts

@@ -141,7 +141,7 @@ describe('getCNPGObjectStoreStatus', () => {
     // Every timestamp on a RecoveryWindow is optional, so the server can be
     // listed while holding nothing restorable.
     expect(getCNPGObjectStoreStatus({ status: { serverRecoveryWindow: { pg: {} } } }))
-      .toMatchObject({ text: 'No recovery point', level: 'unknown' })
+      .toMatchObject({ text: 'Recovery point not reported', level: 'unknown' })
   })
 
   it('reports recoverable once a real point exists', () => {

package/src/components/shared/EditableYamlView.test.tsx

@@ -0,0 +1,268 @@
+// @vitest-environment jsdom
+//
+// Applying a reviewed edit can be refused because the resource changed after
+// the review. The review then refreshes against the latest version and says
+// so, once. That notice belongs to one attempt: a retry that fails for another
+// reason shows its own error.
+import { act } from "react";
+import { createRoot, type Root } from "react-dom/client";
+import { afterEach, beforeEach, expect, it, vi } from "vitest";
+
+vi.mock("../ui/YamlEditor", async () => {
+  const { useEffect } = await import("react");
+  return {
+    YamlEditor: () => <div />,
+    YamlDiffEditor: ({
+      onReadyChange,
+    }: {
+      onReadyChange?: (ready: boolean) => void;
+    }) => {
+      useEffect(() => onReadyChange?.(true), [onReadyChange]);
+      return <div />;
+    },
+  };
+});
+
+const { EditableYamlView } = await import("./EditableYamlView");
+
+vi.stubGlobal("IS_REACT_ACT_ENVIRONMENT", true);
+vi.stubGlobal(
+  "ResizeObserver",
+  class {
+    observe() {}
+    unobserve() {}
+    disconnect() {}
+  },
+);
+let root: Root;
+let host: HTMLDivElement;
+beforeEach(() => {
+  localStorage.clear();
+  sessionStorage.clear();
+  host = document.createElement("div");
+  document.body.appendChild(host);
+  root = createRoot(host);
+});
+afterEach(() => {
+  act(() => root.unmount());
+  host.remove();
+});
+
+const resource = { kind: "ConfigMap", namespace: "shop", name: "app" };
+const data = {
+  apiVersion: "v1",
+  kind: "ConfigMap",
+  metadata: { name: "app", namespace: "shop" },
+  data: { a: "1" },
+};
+const reviewed = (rv: string) => ({
+  documents: [
+    {
+      index: 0,
+      kind: "ConfigMap",
+      name: "app",
+      namespace: "shop",
+      status: "accepted" as const,
+      action: "update" as const,
+      reviewedResourceVersion: rv,
+    },
+  ],
+  nonAtomic: false,
+});
+
+function render(props: {
+  onSave: () => Promise<void>;
+  onPreview: () => Promise<ReturnType<typeof reviewed>>;
+  saveError?: string | null;
+}) {
+  act(() =>
+    root.render(
+      <EditableYamlView
+        resource={resource as never}
+        data={data}
+        onCopy={() => {}}
+        copied={false}
+        onSave={props.onSave}
+        onPreview={props.onPreview}
+        saveError={props.saveError ?? null}
+      />,
+    ),
+  );
+}
+
+const click = async (label: RegExp) => {
+  const b = [...document.querySelectorAll("button")].find((x) =>
+    label.test(x.textContent ?? ""),
+  );
+  if (!b) throw new Error(`no button ${label} in ${document.body.textContent}`);
+  await act(async () => {
+    b.click();
+    await new Promise((r) => setTimeout(r, 0));
+  });
+};
+const text = () => document.body.textContent ?? "";
+
+it("says the resource changed after review, and only for the attempt that found it", async () => {
+  const onPreview = vi
+    .fn()
+    .mockResolvedValueOnce(reviewed("1")) // the review
+    .mockResolvedValueOnce(reviewed("2")) // refresh after the conflict: a newer version
+    .mockRejectedValueOnce(new Error("preview unavailable")); // refresh after the second failure
+  const onSave = vi
+    .fn()
+    .mockRejectedValueOnce(new Error("conflict"))
+    .mockRejectedValueOnce(new Error("forbidden"));
+  render({ onSave, onPreview });
+
+  await click(/^Edit$/);
+  await click(/Review changes/);
+  await click(/Apply reviewed changes/);
+  render({
+    onSave,
+    onPreview,
+    saveError:
+      "resource changed after review; review the latest version before applying",
+  });
+  expect(text()).toContain("This resource changed after your review");
+  expect(text()).not.toContain("review the latest version before applying");
+
+  await click(/Apply reviewed changes/);
+  render({
+    onSave,
+    onPreview,
+    saveError: "forbidden: cannot patch configmaps",
+  });
+  expect(text()).not.toContain("This resource changed after your review");
+  expect(text()).toContain("forbidden: cannot patch configmaps");
+  expect(onSave).toHaveBeenCalledTimes(2);
+  expect(onPreview).toHaveBeenCalledTimes(3);
+});
+
+it("says nothing extra when the refreshed review found the same version", async () => {
+  const onPreview = vi.fn().mockResolvedValue(reviewed("1"));
+  const onSave = vi.fn().mockRejectedValueOnce(new Error("webhook denied"));
+  render({ onSave, onPreview });
+  await click(/^Edit$/);
+  await click(/Review changes/);
+  await click(/Apply reviewed changes/);
+  render({
+    onSave,
+    onPreview,
+    saveError: "admission webhook denied the request",
+  });
+  expect(text()).not.toContain("This resource changed after your review");
+  expect(text()).toContain("admission webhook denied the request");
+  expect(onPreview).toHaveBeenCalledTimes(2);
+});
+
+it("doesn't call a deleted resource changed", async () => {
+  const gone = {
+    documents: [
+      {
+        index: 0,
+        kind: "ConfigMap",
+        name: "app",
+        namespace: "shop",
+        status: "rejected" as const,
+        message: 'configmaps "app" not found',
+      },
+    ],
+    nonAtomic: false,
+  };
+  const onPreview = vi
+    .fn()
+    .mockResolvedValueOnce(reviewed("1"))
+    .mockResolvedValueOnce(gone);
+  const onSave = vi.fn().mockRejectedValueOnce(new Error("not found"));
+  render({ onSave, onPreview });
+  await click(/^Edit$/);
+  await click(/Review changes/);
+  await click(/Apply reviewed changes/);
+  render({ onSave, onPreview, saveError: 'configmaps "app" not found' });
+  expect(text()).not.toContain("This resource changed after your review");
+  expect(text()).toContain('configmaps "app" not found');
+});
+
+it("doesn't call a switched cluster a changed resource", async () => {
+  const onPreview = vi
+    .fn()
+    .mockResolvedValueOnce({ ...reviewed("1"), context: "kind-a" })
+    .mockResolvedValueOnce({ ...reviewed("2"), context: "kind-b" });
+  const onSave = vi.fn().mockRejectedValueOnce(new Error("cluster changed"));
+  render({ onSave, onPreview });
+  await click(/^Edit$/);
+  await click(/Review changes/);
+  await click(/Apply reviewed changes/);
+  render({
+    onSave,
+    onPreview,
+    saveError: "the active cluster changed after review",
+  });
+  expect(text()).not.toContain("This resource changed after your review");
+  expect(text()).toContain("the active cluster changed after review");
+});
+
+it("ignores an earlier attempt's refresh that lands after a newer attempt", async () => {
+  let finishFirstRefresh: (v: ReturnType<typeof reviewed>) => void = () => {};
+  const onPreview = vi
+    .fn()
+    .mockResolvedValueOnce(reviewed("1"))
+    .mockReturnValueOnce(
+      new Promise<ReturnType<typeof reviewed>>((r) => {
+        finishFirstRefresh = r;
+      }),
+    )
+    .mockRejectedValueOnce(new Error("preview unavailable"));
+  const onSave = vi
+    .fn()
+    .mockRejectedValueOnce(new Error("conflict"))
+    .mockRejectedValueOnce(new Error("forbidden"));
+  render({ onSave, onPreview });
+  await click(/^Edit$/);
+  await click(/Review changes/);
+  await click(/Apply reviewed changes/);
+  await click(/Apply reviewed changes/);
+  await act(async () => {
+    finishFirstRefresh(reviewed("2"));
+    await new Promise((r) => setTimeout(r, 0));
+  });
+  render({
+    onSave,
+    onPreview,
+    saveError: "forbidden: cannot patch configmaps",
+  });
+  expect(text()).not.toContain("This resource changed after your review");
+  expect(text()).toContain("forbidden: cannot patch configmaps");
+});
+
+it("drops a refresh from an apply made before going back to a newer review", async () => {
+  let finishFirstRefresh: (v: ReturnType<typeof reviewed>) => void = () => {};
+  const onPreview = vi
+    .fn()
+    .mockResolvedValueOnce(reviewed("1"))
+    .mockReturnValueOnce(
+      new Promise<ReturnType<typeof reviewed>>((r) => {
+        finishFirstRefresh = r;
+      }),
+    )
+    .mockResolvedValueOnce(reviewed("3"));
+  const onSave = vi
+    .fn()
+    .mockRejectedValueOnce(new Error("conflict"))
+    .mockResolvedValueOnce(undefined);
+  render({ onSave, onPreview });
+  await click(/^Edit$/);
+  await click(/Review changes/);
+  await click(/Apply reviewed changes/);
+  await click(/Back to edit/);
+  await click(/Review changes/);
+  await act(async () => {
+    finishFirstRefresh(reviewed("2"));
+    await new Promise((r) => setTimeout(r, 0));
+  });
+  expect(text()).not.toContain("This resource changed after your review");
+  await click(/Apply reviewed changes/);
+  expect(onSave).toHaveBeenLastCalledWith(
+    expect.objectContaining({ reviewedResourceVersion: "3" }),
+  );
+});

package/src/components/shared/EditableYamlView.tsx

@@ -202,6 +202,9 @@ export function EditableYamlView({
   // All sessionStorage calls are wrapped in try-catch — storage can throw
   // QuotaExceededError or be blocked by browser security policies.
   const savedDraft = useRef(readOnly ? null : safeSessionGet(draftKey))
+  // Bumped by every apply and every change of review, so a refresh that lands
+  // late never replaces the review that is on screen now.
+  const reviewGeneration = useRef(0)
   const [isEditing, setIsEditing] = useState(savedDraft.current !== null)
   const [editedYaml, setEditedYaml] = useState(savedDraft.current ?? '')
   const [yamlErrors, setYamlErrors] = useState<string[]>([])
@@ -216,6 +219,8 @@ export function EditableYamlView({
     documents: YamlPreviewResult[]
     nonAtomic: boolean
     context?: string
+    // An apply failed and the refreshed review found a newer resource version.
+    changedSinceReview?: boolean
   } | null>(null)
 
   // Clean up restored draft flag
@@ -253,6 +258,7 @@ export function EditableYamlView({
 
   const handleStartEdit = useCallback(() => {
     if (readOnly) return
+    reviewGeneration.current++
     setEditedYaml(resourceToYaml(data))
     setYamlErrors([])
     setPreview(null)
@@ -260,6 +266,7 @@ export function EditableYamlView({
   }, [data, readOnly])
 
   const handleCancelEdit = useCallback(() => {
+    reviewGeneration.current++
     setIsEditing(false)
     setEditedYaml('')
     setYamlErrors([])
@@ -268,6 +275,7 @@ export function EditableYamlView({
 
   const handleSaveEdit = useCallback(async () => {
     if (yamlErrors.length > 0 || !onSave) return
+    reviewGeneration.current++
 
     try {
       if (onPreview) {
@@ -308,6 +316,10 @@ export function EditableYamlView({
 
   const handleApplyReviewed = useCallback(async () => {
     if (!preview || !onSave) return
+    // The notice belongs to one attempt: a retry that fails for another reason
+    // (and can't refresh) must show its own error, not the last notice.
+    const attempt = ++reviewGeneration.current
+    if (preview.changedSinceReview) setPreview({ ...preview, changedSinceReview: false })
     try {
       await onSave({
         kind: resource.kind,
@@ -335,11 +347,19 @@ export function EditableYamlView({
               name: resource.name,
             },
           })
+          if (attempt !== reviewGeneration.current) return
+          // Changed means the same resource, on the same cluster, at a newer
+          // version. A deleted resource has no version, and a cluster switch
+          // is its own error.
+          const before = preview.documents[0]?.reviewedResourceVersion
+          const after = refreshed.documents[0]?.reviewedResourceVersion
           setPreview({
             ...preview,
             documents: refreshed.documents,
             nonAtomic: refreshed.nonAtomic,
             context: refreshed.context,
+            changedSinceReview:
+              !!after && after !== before && refreshed.context === preview.context,
           })
         } catch {
           // Keep the last review visible when refresh is unavailable.
@@ -368,7 +388,11 @@ export function EditableYamlView({
           force={preview.force}
           isApplying={isSaving}
           applyError={saveError}
-          onBack={() => setPreview(null)}
+          changedSinceReview={preview.changedSinceReview}
+          onBack={() => {
+            reviewGeneration.current++
+            setPreview(null)
+          }}
           onApply={handleApplyReviewed}
         />
       )