@skyhook-io/radar-app 1.12.2 → 1.13.0

package/src/components/settings/settings-state.test.ts

@@ -0,0 +1,42 @@
+import { describe, expect, it } from "vitest";
+import {
+  costSourceApplyLabel,
+  shouldOfferCostReview,
+  shouldShowSettingsFooter,
+} from "./settings-state";
+
+describe("Cost settings state", () => {
+  it("keeps source drafts inline while the Cost section is open", () => {
+    expect(shouldOfferCostReview(true, "cost")).toBe(false);
+    expect(
+      shouldShowSettingsFooter({
+        canEditConfig: true,
+        confirmingClose: false,
+        configDirty: false,
+        costIntegrationDirty: true,
+        section: "cost",
+        hasSaveMessage: false,
+      }),
+    ).toBe(false);
+  });
+
+  it("offers review from other sections and retains the close guard", () => {
+    expect(shouldOfferCostReview(true, "overview")).toBe(true);
+    expect(
+      shouldShowSettingsFooter({
+        canEditConfig: true,
+        confirmingClose: true,
+        configDirty: false,
+        costIntegrationDirty: true,
+        section: "cost",
+        hasSaveMessage: false,
+      }),
+    ).toBe(true);
+  });
+
+  it("only claims to test sources that the backend probes", () => {
+    expect(costSourceApplyLabel("auto")).toBe("Test & apply source");
+    expect(costSourceApplyLabel("kubecost")).toBe("Test & apply source");
+    expect(costSourceApplyLabel("prometheus")).toBe("Apply source");
+  });
+});

package/src/components/settings/settings-state.ts

@@ -0,0 +1,39 @@
+export type SettingsSectionId =
+  | 'overview'
+  | 'perms'
+  | 'connection'
+  | 'prometheus'
+  | 'cost'
+  | 'argocd'
+  | 'ai'
+  | 'advanced'
+
+export function shouldOfferCostReview(
+  costIntegrationDirty: boolean,
+  section: SettingsSectionId,
+): boolean {
+  return costIntegrationDirty && section !== 'cost'
+}
+
+export function shouldShowSettingsFooter(input: {
+  canEditConfig: boolean
+  confirmingClose: boolean
+  configDirty: boolean
+  costIntegrationDirty: boolean
+  section: SettingsSectionId
+  hasSaveMessage: boolean
+}): boolean {
+  return (
+    input.canEditConfig &&
+    (input.confirmingClose ||
+      input.configDirty ||
+      shouldOfferCostReview(input.costIntegrationDirty, input.section) ||
+      input.hasSaveMessage)
+  )
+}
+
+export function costSourceApplyLabel(
+  source: 'auto' | 'prometheus' | 'kubecost',
+): string {
+  return source === 'prometheus' ? 'Apply source' : 'Test & apply source'
+}

package/src/components/ui/ErrorBoundary.test.tsx

@@ -0,0 +1,55 @@
+import { describe, expect, it } from 'vitest'
+
+import { ErrorBoundary } from './ErrorBoundary'
+
+// Navigating re-renders this boundary rather than remounting it, so a boundary
+// that only latched would keep the fallback on screen for the rest of the
+// session. These drive the lifecycle hooks directly - a caught error needs a
+// real render loop, which the SSR-string tests used elsewhere here cannot give.
+const caught = (resetKey: string) => ({
+  hasError: true,
+  error: new Error("Cannot read properties of undefined (reading 'nodeCount')"),
+  resetKey,
+})
+
+describe('ErrorBoundary reset', () => {
+  it('clears a caught error when resetKey changes', () => {
+    expect(ErrorBoundary.getDerivedStateFromProps({ children: null, resetKey: '/topology' }, caught('/'))).toEqual({
+      hasError: false,
+      error: null,
+      resetKey: '/topology',
+    })
+  })
+
+  it('clears it when only a later path segment changes', () => {
+    // The view is just the first path segment, so /resources/pods and
+    // /resources/services are the same view. Resetting per view would leave a
+    // crash under /resources trapping the user as they switch kinds.
+    const next = ErrorBoundary.getDerivedStateFromProps(
+      { children: null, resetKey: '/resources/services' },
+      caught('/resources/pods'),
+    )
+    expect(next?.hasError).toBe(false)
+  })
+
+  it('clears it when only the query changes', () => {
+    // Selection rides in the query, so a path-only key would strand a crash on
+    // the view that produced it.
+    const next = ErrorBoundary.getDerivedStateFromProps(
+      { children: null, resetKey: '/resources/pods?resource=kube-system/coredns' },
+      caught('/resources/pods'),
+    )
+    expect(next?.hasError).toBe(false)
+  })
+
+  it('holds the error while resetKey is unchanged', () => {
+    expect(ErrorBoundary.getDerivedStateFromProps({ children: null, resetKey: '/' }, caught('/'))).toBeNull()
+  })
+
+  it('records the error', () => {
+    expect(ErrorBoundary.getDerivedStateFromError(new Error('boom'))).toEqual({
+      hasError: true,
+      error: new Error('boom'),
+    })
+  })
+})

package/src/components/ui/ErrorBoundary.tsx

@@ -3,20 +3,35 @@ import { AlertTriangle, RefreshCw } from 'lucide-react'
 
 interface Props {
   children: ReactNode
+  /**
+   * Clears a caught error whenever this value changes - pass whatever selects
+   * the children, typically the route. A boundary latches: nothing resets
+   * hasError on its own, so without this a view that throws keeps the fallback
+   * on screen and navigating away cannot escape it. Preferred over remounting
+   * via `key`, which would also discard the children's state on every change
+   * while nothing is wrong.
+   */
+  resetKey: string | number
 }
 
 interface State {
   hasError: boolean
   error: Error | null
+  resetKey: string | number
 }
 
 export class ErrorBoundary extends Component<Props, State> {
-  state: State = { hasError: false, error: null }
+  state: State = { hasError: false, error: null, resetKey: this.props.resetKey }
 
-  static getDerivedStateFromError(error: Error): State {
+  static getDerivedStateFromError(error: Error): Pick<State, 'hasError' | 'error'> {
     return { hasError: true, error }
   }
 
+  static getDerivedStateFromProps(props: Props, state: State): State | null {
+    if (Object.is(props.resetKey, state.resetKey)) return null
+    return { hasError: false, error: null, resetKey: props.resetKey }
+  }
+
   componentDidCatch(error: Error, info: React.ErrorInfo) {
     console.error('[ErrorBoundary]', error, info.componentStack)
   }

package/src/components/ui/UpdateNotification.test.tsx

@@ -0,0 +1,49 @@
+import { QueryClient, QueryClientProvider } from '@tanstack/react-query'
+import { renderToString } from 'react-dom/server'
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+
+let deploymentMode = 'local'
+
+vi.mock('../../api/client', () => ({
+  useCapabilities: () => ({ data: { deployment: { mode: deploymentMode } } }),
+  useVersionCheck: () => ({
+    data: {
+      currentVersion: '1.2.3',
+      latestVersion: '1.3.0',
+      updateAvailable: true,
+      installMethod: 'direct',
+      releaseUrl: 'https://github.com/skyhook-io/radar/releases/tag/v1.3.0',
+    },
+  }),
+  useStartDesktopUpdate: () => ({ mutate: vi.fn(), isPending: false }),
+  useDesktopUpdateStatus: () => ({ data: undefined }),
+  useApplyDesktopUpdate: () => ({ mutate: vi.fn() }),
+}))
+
+import { UpdateNotification } from './UpdateNotification'
+
+function renderNotification() {
+  const client = new QueryClient()
+  return renderToString(
+    <QueryClientProvider client={client}>
+      <UpdateNotification />
+    </QueryClientProvider>,
+  )
+}
+
+describe('UpdateNotification', () => {
+  beforeEach(() => {
+    deploymentMode = 'local'
+  })
+
+  it('keeps the update popup for local installations', () => {
+    const html = renderNotification()
+    expect(html).toContain('Update Available')
+    expect(html).toContain('1.3.0')
+  })
+
+  it('suppresses the update popup for shared in-cluster viewers', () => {
+    deploymentMode = 'in-cluster'
+    expect(renderNotification()).toBe('')
+  })
+})

package/src/components/ui/UpdateNotification.tsx

@@ -3,6 +3,7 @@ import { Download, X, Copy, Check, RotateCw, ArrowDownToLine, Loader2 } from 'lu
 import { useQueryClient } from '@tanstack/react-query'
 import {
   useVersionCheck,
+  useCapabilities,
   useStartDesktopUpdate,
   useDesktopUpdateStatus,
   useApplyDesktopUpdate,
@@ -14,6 +15,8 @@ const DISMISSED_KEY = 'radar-update-dismissed'
 
 export function UpdateNotification() {
   const queryClient = useQueryClient()
+  const { data: capabilities } = useCapabilities()
+  const deploymentMode = capabilities ? (capabilities.deployment?.mode ?? 'local') : undefined
   const { data: versionInfo } = useVersionCheck()
   const [dismissed, setDismissed] = useState(false)
   const [copied, setCopied] = useState(false)
@@ -98,8 +101,9 @@ export function UpdateNotification() {
     })
   }
 
-  // Don't show if no update available, dismissed, or error
-  if (!versionInfo?.updateAvailable || dismissed) {
+  // Shared in-cluster viewers get a persistent Home notice instead of a
+  // floating action prompt they may not be able to act on.
+  if (!versionInfo?.updateAvailable || dismissed || deploymentMode === undefined || deploymentMode === 'in-cluster' || deploymentMode === 'cloud') {
     return null
   }
 

package/src/components/workload/WorkloadView.test.ts

@@ -0,0 +1,60 @@
+import { describe, expect, it } from 'vitest'
+
+import { gitOpsOwnerFromRelationships } from '@skyhook-io/k8s-ui'
+import type { Relationships } from '../../types'
+import { findInheritedGitOpsLookupRef } from './WorkloadView'
+
+describe('findInheritedGitOpsLookupRef', () => {
+  it('follows a referenced ReplicaSet to its parent workload for inherited ownership', () => {
+    const relationships: Relationships = {
+      managedBy: [
+        {
+          kind: 'Deployment',
+          group: 'apps',
+          namespace: 'prod',
+          name: 'web',
+        },
+      ],
+    }
+
+    expect(
+      findInheritedGitOpsLookupRef(relationships, null, {
+        kind: 'ReplicaSet',
+        group: 'apps',
+        namespace: 'prod',
+        name: 'web-7b8d9',
+      }),
+    ).toEqual({
+      kind: 'Deployment',
+      group: 'apps',
+      namespace: 'prod',
+      name: 'web',
+    })
+  })
+
+  it('does not fetch a parent when the target has a direct GitOps owner', () => {
+    const relationships: Relationships = {
+      managedBy: [
+        {
+          kind: 'Application',
+          group: 'argoproj.io',
+          namespace: 'argocd',
+          name: 'web',
+        },
+      ],
+    }
+
+    expect(
+      findInheritedGitOpsLookupRef(
+        relationships,
+        gitOpsOwnerFromRelationships(relationships),
+        {
+          kind: 'Deployment',
+          group: 'apps',
+          namespace: 'prod',
+          name: 'web',
+        },
+      ),
+    ).toBeNull()
+  })
+})