@skyhook-io/radar-app 1.17.0 → 1.17.1

package/src/components/cnpg/CNPGClusterActivity.tsx

@@ -1,8 +1,9 @@
 import { useState } from 'react'
 import { PaneLoader, TimelineList, formatAge, type NavigateToResource } from '@skyhook-io/k8s-ui'
 import { useCNPGClusterActivity } from '../../api/cnpg'
-import { Notice } from '../capacity/shared'
-import { Segments } from './shared'
+import { useCNPGClusterActivityWindow } from '../../api/cnpg-history'
+import { CNPGIntervalBanner, useCNPGIntervalParams } from './CNPGTrends'
+import { Notice, RefreshFailedNotice, Segments } from '../workspace/layout'
 
 const RANGES = [
   { id: '6', label: '6 h' },
@@ -18,22 +19,30 @@ const RANGES = [
  */
 export function CNPGClusterActivity({ namespace, name, onNavigate }: { namespace: string; name: string; onNavigate?: NavigateToResource }) {
   const [hours, setHours] = useState<string>('24')
-  const q = useCNPGClusterActivity(namespace, name, Number(hours))
+  const interval = useCNPGIntervalParams()
+  const ranged = useCNPGClusterActivity(namespace, name, Number(hours))
+  const windowed = useCNPGClusterActivityWindow(namespace, name, interval?.since ?? '', interval?.until ?? '', !!interval)
+  const q = interval ? windowed : ranged
 
   return (
     <div className="flex h-full min-h-0 flex-col gap-3 p-4">
-      <div className="flex flex-wrap items-center gap-3">
-        <Segments label="Range" value={hours} onChange={setHours} options={RANGES.map((r) => ({ id: r.id, label: r.label }))} />
-        <span className="text-xs text-theme-text-tertiary">
-          Kubernetes events and changes for the Cluster, its instances, Backups, Poolers and declarations.
-        </span>
-      </div>
+      {interval ? (
+        <CNPGIntervalBanner since={interval.since} until={interval.until} note="Selected on a History chart: events and changes inside this interval only." onClear={interval.clear} />
+      ) : (
+        <div className="flex flex-wrap items-center gap-3">
+          <Segments label="Range" value={hours} onChange={setHours} options={RANGES.map((r) => ({ id: r.id, label: r.label }))} />
+          <span className="text-xs text-theme-text-tertiary">
+            Kubernetes events and changes for the Cluster, its instances, Backups, Poolers and declarations.
+          </span>
+        </div>
+      )}
       <div className="text-xs text-theme-text-tertiary">
         {q.data?.attributionSince
           ? `The earliest recorded event linking a Backup, Pooler or declaration to this cluster is ${formatAge(q.data.attributionSince)} old. Deleted child objects from before Radar recorded that link are not shown.`
           : 'Radar has not recorded any Backup, Pooler or declaration events linked to this cluster yet, so deleted child objects may be missing.'}
         {' '}Events for kinds you cannot list are omitted.
       </div>
+      <RefreshFailedNotice queries={[q]} />
       {q.data?.truncated && <Notice>Showing the most recent events only; narrow the range to see all of them.</Notice>}
       {q.error && !q.data ? (
         <Notice>Activity could not be loaded: {q.error instanceof Error ? q.error.message : 'unknown error'}</Notice>

package/src/components/cnpg/CNPGClusterLogs.compatibility.test.tsx

@@ -0,0 +1,130 @@
+import { renderToStaticMarkup } from 'react-dom/server'
+import { MemoryRouter } from 'react-router-dom'
+import { beforeEach, expect, it, vi } from 'vitest'
+import { CNPGClusterLogs } from './CNPGClusterLogs'
+import { guardRadarFeature, radarFeatureSupport } from '../../api/radarFeatures'
+import { fetchJSON } from '../../api/client'
+
+const state = vi.hoisted(() => ({ props: undefined as any, capabilities: { features: { resourceIssues: true } } as any, capabilitiesPending: false, fetchStatus: 'idle' as 'idle' | 'fetching' | 'paused', interval: null as null | { since: string; until: string; clear: () => void } }))
+vi.mock('@skyhook-io/k8s-ui', async (original) => ({ ...await original<typeof import('@skyhook-io/k8s-ui')>(), WorkloadLogsViewer: (props: any) => { state.props = props; return <div>logs</div> } }))
+vi.mock('../../api/client', () => ({ fetchJSON: vi.fn(async () => ({ pods: [], logs: [] })), useCapabilities: () => ({ isPending: state.capabilitiesPending, isFetching: state.fetchStatus === 'fetching', fetchStatus: state.fetchStatus, refetch: vi.fn() }), useRadarFeature: () => {
+  const support = radarFeatureSupport('cnpgWorkspace', state.capabilities, 'v1.16.0')
+  return { support, guard: (fn: () => Promise<unknown>) => guardRadarFeature('cnpgWorkspace', support, {}, fn) }
+} }))
+vi.mock('../../hooks/useDesktopDownload', () => ({ useDesktopDownload: () => undefined }))
+vi.mock('../../context/ThemeContext', () => ({ useTheme: () => ({ theme: 'light' }) }))
+vi.mock('./useCNPGNavigate', () => ({ useCNPGNavigate: () => vi.fn() }))
+vi.mock('./useCNPGSidebarWorkspace', () => ({ useCNPGFleet: () => ({ fleet: null }) }))
+vi.mock('./CNPGTrends', () => ({ useCNPGIntervalParams: () => state.interval, CNPGIntervalBanner: ({ note }: { note: string }) => <div>{note}</div> }))
+beforeEach(() => { state.props = undefined; state.capabilities = { features: { resourceIssues: true } }; state.capabilitiesPending = false; state.fetchStatus = 'idle'; state.interval = null; vi.clearAllMocks(); vi.unstubAllGlobals() })
+function mount(search = '') { return renderToStaticMarkup(<MemoryRouter initialEntries={[{ pathname: '/cnpg/clusters/db/pg', search }]}><CNPGClusterLogs namespace="db" name="pg" /></MemoryRouter>) }
+
+it('retains ordinary snapshot selectors and follows on the actual missing-flag capability state', async () => {
+  mount()
+  await state.props.fetchAll({ container: 'postgres', tailLines: 40, sinceSeconds: 60 })
+  expect(fetchJSON).toHaveBeenCalledWith('/cnpg/clusters/db/pg/logs?container=postgres&tailLines=40&sinceSeconds=60', { signal: undefined })
+  const eventSource = vi.fn(function (url: string) { return { url } })
+  vi.stubGlobal('EventSource', eventSource)
+  state.props.createStream({ container: 'postgres' })
+  expect(eventSource).toHaveBeenCalledWith('/api/cnpg/clusters/db/pg/logs/stream?container=postgres&tailLines=50', { withCredentials: false })
+})
+it('uses the old postgres default for empty and all selectors in both snapshot and SSE requests', async () => {
+  mount()
+  expect(state.props.initialContainer).toBe('postgres')
+  expect(state.props.allowAllContainers).toBe(false)
+  mount('?container=all')
+  expect(state.props.initialContainer).toBe('postgres')
+  expect(state.props.allowAllContainers).toBe(false)
+  const eventSource = vi.fn(function (url: string) { return { url } })
+  vi.stubGlobal('EventSource', eventSource)
+  for (const container of [undefined, 'all']) {
+    await state.props.fetchAll({ container, tailLines: 40, sinceSeconds: 60 })
+    const path = vi.mocked(fetchJSON).mock.lastCall![0]
+    expect(Object.fromEntries(new URL(path, 'http://radar.test').searchParams)).toEqual({ tailLines: '40', sinceSeconds: '60' })
+    state.props.createStream({ container, sinceSeconds: 60 })
+    const streamPath = eventSource.mock.lastCall![0]
+    expect(Object.fromEntries(new URL(streamPath, 'http://radar.test').searchParams)).toEqual({ tailLines: '50', sinceSeconds: '60' })
+  }
+})
+it('retains exact plugin-container selection supported by the old producer', async () => {
+  mount('?container=plugin-barman-cloud')
+  expect(state.props.initialContainer).toBe('plugin-barman-cloud')
+  await state.props.fetchAll({ container: 'plugin-barman-cloud' })
+  expect(fetchJSON).toHaveBeenCalledWith('/cnpg/clusters/db/pg/logs?container=plugin-barman-cloud', { signal: undefined })
+  const eventSource = vi.fn(function (url: string) { return { url } })
+  vi.stubGlobal('EventSource', eventSource)
+  state.props.createStream({ container: 'plugin-barman-cloud' })
+  expect(eventSource).toHaveBeenCalledWith('/api/cnpg/clusters/db/pg/logs/stream?container=plugin-barman-cloud&tailLines=50', { withCredentials: false })
+})
+it('only requests all-container snapshots and SSE after confirmed support', async () => {
+  const eventSource = vi.fn(function (url: string) { return { url } })
+  vi.stubGlobal('EventSource', eventSource)
+  state.capabilities = undefined
+  mount()
+  expect(state.props.initialContainer).toBe('postgres')
+  expect(state.props.allowAllContainers).toBe(false)
+  await state.props.fetchAll({})
+  expect(fetchJSON).toHaveBeenLastCalledWith('/cnpg/clusters/db/pg/logs', { signal: undefined })
+  state.props.createStream({})
+  expect(eventSource).toHaveBeenLastCalledWith('/api/cnpg/clusters/db/pg/logs/stream?tailLines=50', { withCredentials: false })
+  state.capabilities = { features: { cnpgWorkspace: true } }
+  mount()
+  expect(state.props.initialContainer).toBeUndefined()
+  expect(state.props.allowAllContainers).toBe(true)
+  mount('?container=all')
+  expect(state.props.initialContainer).toBeUndefined()
+  await state.props.fetchAll({})
+  expect(fetchJSON).toHaveBeenLastCalledWith('/cnpg/clusters/db/pg/logs?container=all', { signal: undefined })
+  state.props.createStream({})
+  expect(eventSource).toHaveBeenLastCalledWith('/api/cnpg/clusters/db/pg/logs/stream?container=all&tailLines=50', { withCredentials: false })
+})
+it('refuses both-bound interval semantics on that old server without an unbounded request', async () => {
+  state.interval = { since: '2026-10-13T00:00:00Z', until: '2026-10-13T01:00:00Z', clear: vi.fn() }
+  expect(mount()).toContain('Clear it to read ordinary logs')
+  await expect(state.props.fetchAll({ tailLines: 40 })).rejects.toMatchObject({ feature: 'cnpgWorkspace' })
+  expect(fetchJSON).not.toHaveBeenCalled()
+  expect(state.props.createStream).toBeUndefined()
+})
+it('uses the advertised interval contract without tailing or streaming', async () => {
+  state.capabilities = { features: { cnpgWorkspace: true } }
+  state.interval = { since: '2026-10-13T00:00:00Z', until: '2026-10-13T01:00:00Z', clear: vi.fn() }
+  mount()
+  await state.props.fetchAll({ tailLines: 40, sinceSeconds: 60 })
+  const path = vi.mocked(fetchJSON).mock.calls[0][0]
+  const params = new URL(path, 'http://radar.test').searchParams
+  expect(Object.fromEntries(params)).toEqual({ sinceTime: state.interval.since, untilTime: state.interval.until, container: 'all' })
+  expect(state.props.createStream).toBeUndefined()
+})
+it('waits for capabilities before offering interval semantics, while ordinary logs remain immediate', () => {
+  state.capabilities = undefined
+  state.capabilitiesPending = true
+  state.interval = { since: '2026-10-13T00:00:00Z', until: '2026-10-13T01:00:00Z', clear: vi.fn() }
+  expect(mount()).toContain('Checking interval support')
+  expect(state.props).toBeUndefined()
+  state.interval = null
+  mount()
+  expect(state.props.createStream).toBeTypeOf('function')
+})
+it('settles a failed capabilities read without loading forever or issuing an interval request', () => {
+  state.capabilities = undefined
+  state.interval = { since: '2026-10-13T00:00:00Z', until: '2026-10-13T01:00:00Z', clear: vi.fn() }
+  const html = mount()
+  expect(html).toContain('Interval log support could not be checked')
+  expect(html).toContain('Clear this interval to read ordinary logs')
+  expect(html).toContain('Retry')
+  expect(html).not.toContain('Checking interval support')
+  expect(state.props).toBeUndefined()
+  expect(fetchJSON).not.toHaveBeenCalled()
+})
+it('keeps the clear-interval fallback available while an offline request is paused', () => {
+  state.capabilities = undefined
+  state.capabilitiesPending = true
+  state.fetchStatus = 'paused'
+  state.interval = { since: '2026-10-13T00:00:00Z', until: '2026-10-13T01:00:00Z', clear: vi.fn() }
+  const html = mount()
+  expect(html).toContain('Clear this interval to read ordinary logs')
+  expect(html).toContain('Waiting for connection')
+  expect(html).not.toContain('Checking interval support')
+  expect(state.props).toBeUndefined()
+  expect(fetchJSON).not.toHaveBeenCalled()
+})

package/src/components/cnpg/CNPGClusterLogs.empty.test.tsx

@@ -0,0 +1,29 @@
+import { renderToStaticMarkup } from 'react-dom/server'
+import { MemoryRouter } from 'react-router-dom'
+import { expect, it, vi } from 'vitest'
+import { CNPGClusterLogs } from './CNPGClusterLogs'
+const state = vi.hoisted(() => ({ props: {} as any, navigate: vi.fn(), problems: [{ job: 'initdb', severity: 'critical', title: 'First instance cannot be scheduled' }] as any[] }))
+vi.mock('@skyhook-io/k8s-ui', async (original) => ({ ...await original<typeof import('@skyhook-io/k8s-ui')>(), WorkloadLogsViewer: (props: any) => { state.props = props; return <div>{props.emptySourceState}</div> } }))
+vi.mock('../../api/client', () => ({ useCapabilities: () => ({ isPending: false }), useRadarFeature: () => ({ guard: (fn: () => unknown) => fn(), support: 'supported' }), fetchJSON: vi.fn() }))
+vi.mock('../../hooks/useDesktopDownload', () => ({ useDesktopDownload: () => undefined }))
+vi.mock('../../context/ThemeContext', () => ({ useTheme: () => ({ theme: 'light' }) }))
+vi.mock('./useCNPGNavigate', () => ({ useCNPGNavigate: () => state.navigate }))
+vi.mock('./useCNPGSidebarWorkspace', () => ({ useCNPGFleet: () => ({ fleet: { rows: [{ namespace: 'db', name: 'analytics', problems: state.problems }] } }) }))
+vi.mock('./CNPGTrends', () => ({ useCNPGIntervalParams: () => null }))
+it('supplies the first-instance problem and Overview link from the CNPG host', () => {
+  const html = renderToStaticMarkup(<MemoryRouter initialEntries={[{ pathname: '/cnpg/clusters/db/analytics', search: '?ctx=test&tab=logs&drawer=x', state: { returnLabel: 'Clusters' } }]}><CNPGClusterLogs namespace="db" name="analytics" /></MemoryRouter>)
+  expect(html).toContain('First instance cannot be scheduled')
+  expect(html).toContain('See Overview’s problem')
+  state.props.emptySourceState.props.children[1].props.onClick()
+  expect(state.navigate).toHaveBeenCalledWith('/cnpg/clusters/db/analytics?ctx=test&tab=overview&drawer=x&problems=all', { replace: true, state: { returnLabel: 'Clusters' } })
+  expect(state.props.disableSourceControlsWithoutSource).toBe(true)
+})
+
+it('does not invent a first-instance cause or use an unrelated problem', () => {
+  state.problems = [{ severity: 'critical', title: 'Backup failed' }]
+  const html = renderToStaticMarkup(<MemoryRouter><CNPGClusterLogs namespace="db" name="analytics" /></MemoryRouter>)
+  expect(html).toContain('No instance log source yet')
+  expect(html).toContain('Open Overview')
+  expect(html).not.toContain('first instance has not started')
+  expect(html).not.toContain('Backup failed')
+})

package/src/components/cnpg/CNPGClusterLogs.test.ts

@@ -0,0 +1,9 @@
+import { expect, it } from 'vitest'
+import { query, intervalQuery } from './CNPGClusterLogs'
+it('requests all containers explicitly for snapshots, streams and bounded intervals', () => {
+  expect(new URLSearchParams(query({}).slice(1)).get('container')).toBe('all')
+  expect(new URLSearchParams(query({}, 50).slice(1)).get('container')).toBe('all')
+  expect(new URLSearchParams(intervalQuery({}, 'from', 'to').slice(1)).get('container')).toBe('all')
+  expect(new URLSearchParams(query({ container: 'plugin-barman-cloud' }).slice(1)).get('container')).toBe('plugin-barman-cloud')
+  expect(new URLSearchParams(intervalQuery({ container: 'postgres' }, 'from', 'to').slice(1)).get('container')).toBe('postgres')
+})

package/src/components/cnpg/CNPGClusterLogs.tsx

@@ -1,18 +1,23 @@
 import { useCallback } from 'react'
-import { useSearchParams } from 'react-router-dom'
-import { WorkloadLogsViewer, type WorkloadLogsFetchParams, type WorkloadLogsResult } from '@skyhook-io/k8s-ui'
-import { fetchJSON } from '../../api/client'
+import { useLocation, useSearchParams } from 'react-router-dom'
+import { PaneLoader, WorkloadLogsViewer, type WorkloadLogsFetchParams, type WorkloadLogsResult } from '@skyhook-io/k8s-ui'
+import { fetchJSON, useCapabilities, useRadarFeature } from '../../api/client'
 import { getApiBase, getCredentialsMode } from '../../api/config'
 import { useDesktopDownload } from '../../hooks/useDesktopDownload'
 import { useTheme } from '../../context/ThemeContext'
+import { CNPGIntervalBanner, useCNPGIntervalParams } from './CNPGTrends'
+import { useCNPGFleet } from './useCNPGSidebarWorkspace'
+import { useCNPGNavigate } from './useCNPGNavigate'
+import { cnpgClusterProblemsPath, cnpgWithinDetail } from './paths'
 
 function logsPath(namespace: string, name: string) {
   return `/cnpg/clusters/${encodeURIComponent(namespace)}/${encodeURIComponent(name)}/logs`
 }
 
-function query(params: WorkloadLogsFetchParams, tailDefault?: number) {
+export function query(params: WorkloadLogsFetchParams, tailDefault?: number, allContainersSupported = true) {
   const q = new URLSearchParams()
-  if (params.container) q.set('container', params.container)
+  const container = params.container || (allContainersSupported ? 'all' : '')
+  if (container && (container !== 'all' || allContainersSupported)) q.set('container', container)
   const tail = params.tailLines ?? tailDefault
   if (tail) q.set('tailLines', String(tail))
   if (params.sinceSeconds) q.set('sinceSeconds', String(params.sinceSeconds))
@@ -20,43 +25,95 @@ function query(params: WorkloadLogsFetchParams, tailDefault?: number) {
   return s ? `?${s}` : ''
 }
 
+// An interval is read from its start with both bounds applied server-side; the
+// viewer's line-count and since selectors do not apply to it.
+export function intervalQuery(params: WorkloadLogsFetchParams, since: string, until: string) {
+  const q = new URLSearchParams({ sinceTime: since, untilTime: until })
+  q.set('container', params.container || 'all')
+  return `?${q.toString()}`
+}
+
 /**
  * Logs merged from every instance Pod of a CloudNativePG Cluster. `?pod=`
- * preselects one instance (the fleet's "Logs" action and "Open instance logs").
+ * preselects one instance (the fleet's "Logs" action and "Open instance logs"),
+ * `?container=` one container (e.g. the plugin-barman-cloud sidecar);
+ * `?since=&until=` bounds them to an interval selected on a History chart.
  */
 export function CNPGClusterLogs({ namespace, name }: { namespace: string; name: string }) {
   const [searchParams] = useSearchParams()
+  const navigate = useCNPGNavigate()
+  const location = useLocation()
+  const { fleet } = useCNPGFleet([namespace])
+  const row = fleet?.rows.find((r) => r.namespace === namespace && r.name === name)
+  const problem = row?.problems.find((p) => p.job === 'initdb')
+  const overviewPath = `${cnpgClusterProblemsPath(namespace, name, searchParams.get('ctx') ?? undefined)}&tab=overview`
+  const inPlace = cnpgWithinDetail(location.pathname, location.search, overviewPath)
   const pod = searchParams.get('pod')
+  const container = searchParams.get('container')
+  const interval = useCNPGIntervalParams()
   const desktopDownload = useDesktopDownload()
   const { theme } = useTheme()
+  const since = interval?.since
+  const until = interval?.until
 
+  const { guard, support } = useRadarFeature('cnpgWorkspace')
+  const capabilities = useCapabilities()
+  const allContainersSupported = support === 'supported'
   const fetchAll = useCallback(
     (params: WorkloadLogsFetchParams) =>
-      fetchJSON<WorkloadLogsResult>(`${logsPath(namespace, name)}${query(params)}`, { signal: params.signal }),
-    [namespace, name],
+      since && until
+        ? guard(() => fetchJSON<WorkloadLogsResult>(`${logsPath(namespace, name)}${intervalQuery(params, since, until)}`, { signal: params.signal }))
+        : fetchJSON<WorkloadLogsResult>(`${logsPath(namespace, name)}${query(params, undefined, allContainersSupported)}`, { signal: params.signal }),
+    [guard, namespace, name, since, until, allContainersSupported],
   )
-  const createStream = useCallback(
+  const stream = useCallback(
     (params: WorkloadLogsFetchParams) =>
-      new EventSource(`${getApiBase()}${logsPath(namespace, name)}/stream${query(params, 50)}`, {
+      new EventSource(`${getApiBase()}${logsPath(namespace, name)}/stream${query(params, 50, allContainersSupported)}`, {
         withCredentials: getCredentialsMode() === 'include',
       }),
-    [namespace, name],
+    [namespace, name, allContainersSupported],
   )
 
+  if (interval && support === 'unknown') return capabilities.isPending && capabilities.fetchStatus !== 'paused'
+    ? <PaneLoader label="Checking interval support…" className="flex-1" />
+    : <div className="space-y-2 p-3">
+        <CNPGIntervalBanner since={interval.since} until={interval.until} note="Interval log support could not be checked. Clear this interval to read ordinary logs." onClear={interval.clear} />
+        <button type="button" className="btn-secondary" disabled={capabilities.isFetching || capabilities.fetchStatus === 'paused'} onClick={() => void capabilities.refetch()}>{capabilities.fetchStatus === 'paused' ? 'Waiting for connection' : capabilities.isFetching ? 'Checking…' : 'Retry'}</button>
+      </div>
+
   return (
-    <div className="h-full">
-      <WorkloadLogsViewer
-        key={pod ?? ''}
-        name={name}
-        fetchAll={fetchAll}
-        createStream={createStream}
-        overrideDownload={desktopDownload}
-        forceDark={theme === 'dark' ? true : undefined}
-        // Light logs on a dark app are never wanted: dark theme pins the palette,
-        // light theme only sets where it starts and leaves the toggle available.
-        defaultDark={false}
-        initialPods={pod ? [pod] : undefined}
-      />
+    <div className="flex h-full flex-col">
+      {interval && (
+        <div className="px-3 pt-3">
+          <CNPGIntervalBanner
+            since={interval.since}
+            until={interval.until}
+            note={support === 'unsupported' ? 'This interval needs a newer Radar. Clear it to read ordinary logs.' : 'Selected on a History chart. Lines from the start of the interval, up to 64 KiB per instance; the line-count selector does not apply and streaming is off.'}
+            onClear={interval.clear}
+          />
+        </div>
+      )}
+      <div className="min-h-0 flex-1">
+        <WorkloadLogsViewer
+          key={`${pod ?? ''}|${container ?? ''}|${since ?? ''}|${until ?? ''}|${allContainersSupported}`}
+          name={name}
+          allowAllContainers={allContainersSupported}
+          disableSourceControlsWithoutSource
+          emptySourceState={<div className="space-y-2 text-sm text-theme-text-secondary">
+            <p>No instance log source yet. {row?.hibernated ? 'The Cluster is hibernated.' : problem?.title}</p>
+            <button type="button" className="text-accent-text hover:underline" onClick={() => navigate(inPlace ?? overviewPath, { replace: !!inPlace, state: location.state })}>{problem ? 'See Overview’s problem →' : 'Open Overview →'}</button>
+          </div>}
+          fetchAll={fetchAll}
+          createStream={interval ? undefined : stream}
+          overrideDownload={desktopDownload}
+          forceDark={theme === 'dark' ? true : undefined}
+          // Light logs on a dark app are never wanted: dark theme pins the palette,
+          // light theme only sets where it starts and leaves the toggle available.
+          defaultDark={false}
+          initialPods={pod ? [pod] : undefined}
+          initialContainer={container && container !== 'all' ? container : allContainersSupported ? undefined : 'postgres'}
+        />
+      </div>
     </div>
   )
 }

package/src/components/cnpg/CNPGClusterTabs.test.tsx

@@ -0,0 +1,152 @@
+import { renderToStaticMarkup } from 'react-dom/server'
+import { MemoryRouter } from 'react-router-dom'
+import { beforeEach, expect, it, vi } from 'vitest'
+import type { CNPGDimension } from '@skyhook-io/k8s-ui'
+import { CNPGBackupsTab, CNPGStorageTab } from './CNPGClusterTabs'
+const state = vi.hoisted(() => ({
+  coverage: 'full',
+  primary: {} as any,
+  storageProps: {} as any,
+  schedules: [] as any[],
+  dimensions: [] as CNPGDimension[],
+}))
+const cluster = {
+  apiVersion: 'postgresql.cnpg.io/v1',
+  kind: 'Cluster',
+  metadata: { name: 'pg', namespace: 'db' },
+  status: { currentPrimary: 'pg-1' } as any,
+  spec: {} as any,
+}
+vi.mock('../../api/client', () => ({ useRadarFeature: () => ({ support: 'supported' }) }))
+vi.mock('../../api/cnpg', () => ({
+  useCNPGRuntime: () => ({ data: { permission: { proxy: 'denied' }, instances: [state.primary] } }),
+}))
+vi.mock('./useCNPGClusterAssessment', () => ({
+  useCNPGClusterAssessment: () => ({
+    dimensions: state.dimensions,
+    row: {
+      cluster,
+      problems: [],
+      protection: { walArchiving: { text: 'Not archived: no destination configured', tone: 'neutral' } },
+    },
+    query: {
+      data: { coverage: { backups: { state: state.coverage } }, objects: { backups: [], clusters: [cluster] } },
+    },
+    runtime: {},
+  }),
+}))
+vi.mock('./useCNPGSidebarWorkspace', () => ({
+  useCNPGFleet: () => ({
+    query: {
+      data: {
+        installed: true,
+        coverage: { backups: { state: state.coverage } },
+        objects: { backups: [], scheduledBackups: state.schedules },
+      },
+    },
+    fleet: { rows: [{ name: 'pg', namespace: 'db', cluster }] },
+  }),
+}))
+vi.mock('../../api/cnpg-recovery', () => ({ useCNPGRestoreCapability: () => ({ data: { allowed: true } }) }))
+vi.mock('./CNPGProtection', () => ({ CNPGProtection: () => null }))
+vi.mock('./CNPGArchivingRepair', () => ({ CNPGArchivingRepair: () => null }))
+vi.mock('./CNPGStorage', () => ({
+  CNPGStorage: (props: any) => {
+    state.storageProps = props
+    return null
+  },
+}))
+vi.mock('./recovery/CNPGRestoreButton', () => ({
+  CNPGRestoreButton: ({ disabledReason }: { disabledReason?: string }) => (
+    <button disabled={!!disabledReason}>Restore</button>
+  ),
+}))
+vi.mock('../../context/ConnectionContext', () => ({ useConnection: () => ({ connection: { context: 'test' } }) }))
+beforeEach(() => {
+  state.coverage = 'full'
+  state.primary = {}
+  state.schedules = []
+  state.dimensions = []
+  cluster.spec = {}
+  delete cluster.status.lastSuccessfulBackup
+})
+it('passes primary identity through to Storage when database reads are denied', () => {
+  state.primary = { pod: 'pg-1', role: 'primary', metrics: { state: 'denied' } }
+  renderToStaticMarkup(<CNPGStorageTab namespace="db" name="pg" />)
+  expect(state.storageProps.primary).toBe(state.primary)
+  expect(state.storageProps.runtime.data.permission.proxy).toBe('denied')
+})
+it('uses the shared restore assessment for the Backups button', () => {
+  const render = () =>
+    renderToStaticMarkup(
+      <MemoryRouter>
+        <CNPGBackupsTab namespace="db" name="pg" onInspect={() => {}} />
+      </MemoryRouter>,
+    )
+  state.coverage = 'full'
+  expect(render()).toContain('disabled=""')
+  expect(render()).toContain('Nothing to restore from yet')
+  state.coverage = 'denied'
+  expect(render()).not.toContain('disabled=""')
+  expect(render()).not.toContain('Nothing to restore from yet')
+})
+
+it('starts a single guided setup path beside restore, without treating a schedule as protection', () => {
+  state.schedules = [{ metadata: { name: 'pg-nightly', namespace: 'db' }, spec: { cluster: { name: 'pg' } } }]
+  const html = renderToStaticMarkup(
+    <MemoryRouter>
+      <CNPGBackupsTab namespace="db" name="pg" onInspect={() => {}} onOpenYaml={() => {}} />
+    </MemoryRouter>,
+  )
+  expect(html).toContain('Set up backups…')
+  expect(html).toContain('Nothing to restore from yet')
+  expect(html).not.toContain('Configure spec.backup.barmanObjectStore')
+})
+
+it('keeps the protection verdict ahead of setup without repeating the blocker', () => {
+  state.schedules = [{ metadata: { name: 'pg-nightly', namespace: 'db' }, spec: { cluster: { name: 'pg' } } }]
+  state.dimensions = [
+    {
+      id: 'protection',
+      label: 'Backups',
+      tone: 'degraded',
+      text: 'Backup schedule pg-nightly cannot run: no backup destination',
+      source: 'ScheduledBackup method against its target Cluster spec',
+    },
+  ]
+  const html = renderToStaticMarkup(
+    <MemoryRouter>
+      <CNPGBackupsTab namespace="db" name="pg" onInspect={() => {}} onOpenYaml={() => {}} />
+    </MemoryRouter>,
+  )
+  expect(html.match(/cannot run:/g)).toHaveLength(1)
+  expect(html.indexOf(state.dimensions[0].text)).toBeLessThan(html.indexOf('Set up backups…'))
+})
+
+it('does not invent a missing destination for an enabled third-party plugin', () => {
+  cluster.spec.plugins = [{ name: 'third-party-backup' }]
+  const html = renderToStaticMarkup(
+    <MemoryRouter>
+      <CNPGBackupsTab namespace="db" name="pg" onInspect={() => {}} />
+    </MemoryRouter>,
+  )
+  expect(html).not.toContain('Configure spec.backup')
+  delete cluster.spec.plugins
+})
+
+it('passes recovery certainty instead of equating a destination with a usable backup', () => {
+  const renderStorage = () => renderToStaticMarkup(<CNPGStorageTab namespace="db" name="pg" />)
+  state.coverage = 'full'
+  cluster.spec.backup = { barmanObjectStore: { destinationPath: 's3://backups' } }
+  renderStorage()
+  expect(state.storageProps.restoreState).toBe('none')
+  cluster.status.lastSuccessfulBackup = '2026-10-01T00:00:00Z'
+  renderStorage()
+  expect(state.storageProps.restoreState).toBe('available')
+  delete cluster.status.lastSuccessfulBackup
+  state.coverage = 'denied'
+  renderStorage()
+  expect(state.storageProps.restoreState).toBe('unknown')
+  state.coverage = 'full'
+  delete cluster.spec.backup
+})