@skyhook-io/k8s-ui 1.11.0 → 1.13.0

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

@@ -0,0 +1,104 @@
+import { describe, it, expect } from 'vitest'
+import {
+  splitCNPGDeclarativeByApplied,
+  getCNPGDeclarativeStatus,
+  getCNPGDeclarativeMessage,
+  getCNPGReclaimPolicy,
+  getCNPGImageCatalogEntries,
+} from './resource-utils-cnpg'
+
+/**
+ * `status.applied` has three meanings and the middle one is easy to lose.
+ * Verified against a live CNPG 1.27 operator: `demo-app` came back true,
+ * `demo-broken` came back false with `role "nobody-owns-this" does not exist`,
+ * and every object is briefly absent-status before the operator reaches it.
+ */
+describe('declarative object status', () => {
+  it('is healthy once the operator has applied it', () => {
+    expect(getCNPGDeclarativeStatus({ status: { applied: true } }).level).toBe('healthy')
+  })
+
+  it('is unhealthy when the operator tried and failed', () => {
+    expect(getCNPGDeclarativeStatus({ status: { applied: false } }).level).toBe('unhealthy')
+  })
+
+  // The one that matters: a freshly created object has no `applied` at all, and
+  // reporting that as failed condemns everything in its first seconds.
+  it('is unknown — not failed — before the operator has reconciled', () => {
+    expect(getCNPGDeclarativeStatus({}).level).toBe('unknown')
+    expect(getCNPGDeclarativeStatus({ status: {} }).level).toBe('unknown')
+    expect(getCNPGDeclarativeStatus({ status: { applied: undefined } }).text).toBe('Pending')
+  })
+
+  it('passes the operator’s message through untouched', () => {
+    const msg = 'while creating database "demo_broken": ERROR: role "nobody-owns-this" does not exist'
+    expect(getCNPGDeclarativeMessage({ status: { message: msg } })).toBe(msg)
+    expect(getCNPGDeclarativeMessage({ status: { message: '' } })).toBeUndefined()
+    expect(getCNPGDeclarativeMessage({})).toBeUndefined()
+  })
+})
+
+/**
+ * The reclaim policy decides whether deleting a manifest drops real data, so
+ * the destructive case has to be identified rather than printed.
+ */
+describe('reclaim policy', () => {
+  it('flags delete as destructive across all three kinds', () => {
+    expect(getCNPGReclaimPolicy({ spec: { databaseReclaimPolicy: 'delete' } }).destructive).toBe(true)
+    expect(getCNPGReclaimPolicy({ spec: { publicationReclaimPolicy: 'delete' } }).destructive).toBe(true)
+    expect(getCNPGReclaimPolicy({ spec: { subscriptionReclaimPolicy: 'delete' } }).destructive).toBe(true)
+  })
+
+  it('does not flag retain', () => {
+    expect(getCNPGReclaimPolicy({ spec: { databaseReclaimPolicy: 'retain' } }).destructive).toBe(false)
+  })
+
+  // CNPG defaults to retain, and defaulting the other way in the UI would
+  // warn about data loss that is not going to happen.
+  it('defaults to retain when unset', () => {
+    const r = getCNPGReclaimPolicy({ spec: {} })
+    expect(r.value).toBe('retain')
+    expect(r.destructive).toBe(false)
+  })
+})
+
+describe('image catalog entries', () => {
+  it('sorts by major so the list does not reshuffle between reads', () => {
+    const e = getCNPGImageCatalogEntries({
+      spec: { images: [{ major: 17, image: 'pg:17' }, { major: 15, image: 'pg:15' }, { major: 16, image: 'pg:16' }] },
+    })
+    expect(e.map((x) => x.major)).toEqual([15, 16, 17])
+  })
+
+  it('drops entries with no image rather than rendering a blank row', () => {
+    expect(getCNPGImageCatalogEntries({ spec: { images: [{ major: 16 }] } })).toEqual([])
+  })
+
+  it('returns nothing for a catalog with no images', () => {
+    expect(getCNPGImageCatalogEntries({ spec: {} })).toEqual([])
+    expect(getCNPGImageCatalogEntries({})).toEqual([])
+  })
+})
+
+/**
+ * The Database page renders these three buckets with three different claims, so
+ * collapsing pending into failed puts "this exists in Kubernetes and not in
+ * PostgreSQL" under an object nothing has looked at yet.
+ */
+describe('splitCNPGDeclarativeByApplied', () => {
+  it('keeps pending out of the failures', () => {
+    const live = { status: { applied: true } }
+    const broken = { status: { applied: false, message: 'boom' } }
+    const fresh = {}
+    const alsoFresh = { status: {} }
+
+    const out = splitCNPGDeclarativeByApplied([live, broken, fresh, alsoFresh])
+    expect(out.applied).toEqual([live])
+    expect(out.notApplied).toEqual([broken])
+    expect(out.pending).toEqual([fresh, alsoFresh])
+  })
+
+  it('returns three empty buckets for nothing', () => {
+    expect(splitCNPGDeclarativeByApplied([])).toEqual({ applied: [], notApplied: [], pending: [] })
+  })
+})

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

@@ -0,0 +1,122 @@
+import { describe, it, expect } from 'vitest'
+import {
+  getCNPGObjectStoreRecoveryWindows,
+  getCNPGObjectStoreStatus,
+  getCNPGObjectStoreProvider,
+  isCNPGObjectStore,
+} from './resource-utils-cnpg'
+
+// Field names verified against the real CRD (plugin-barman-cloud v0.14.0,
+// barmancloud.cnpg.io/v1) on a kind cluster — `lastSuccessfulBackupTime`, not
+// `lastSuccessfulBackup` as the Cluster status uses.
+const store = (status: any, spec: any = {}) => ({
+  apiVersion: 'barmancloud.cnpg.io/v1',
+  kind: 'ObjectStore',
+  metadata: { name: 'pg-store', namespace: 'pg' },
+  spec: { configuration: { destinationPath: 's3://b/pg' }, ...spec },
+  status,
+})
+
+describe('getCNPGObjectStoreRecoveryWindows', () => {
+  it('reads the per-server map and sorts by server', () => {
+    const w = getCNPGObjectStoreRecoveryWindows(
+      store({
+        serverRecoveryWindow: {
+          zeta: { firstRecoverabilityPoint: '2026-08-01T00:00:00Z', lastSuccessfulBackupTime: '2026-08-10T00:00:00Z' },
+          alpha: { firstRecoverabilityPoint: '2026-08-02T00:00:00Z', lastSuccessfulBackupTime: '2026-08-11T00:00:00Z' },
+        },
+      }),
+    )
+    expect(w.map((x) => x.server)).toEqual(['alpha', 'zeta'])
+  })
+
+  it('flags a failure newer than the last success', () => {
+    const [w] = getCNPGObjectStoreRecoveryWindows(
+      store({
+        serverRecoveryWindow: {
+          pg: {
+            lastSuccessfulBackupTime: '2026-08-05T00:00:00Z',
+            lastFailedBackupTime: '2026-08-12T00:00:00Z',
+          },
+        },
+      }),
+    )
+    expect(w.failingSinceLastSuccess).toBe(true)
+  })
+
+  it('does not flag a failure that predates the last success', () => {
+    const [w] = getCNPGObjectStoreRecoveryWindows(
+      store({
+        serverRecoveryWindow: {
+          pg: {
+            lastFailedBackupTime: '2026-08-05T00:00:00Z',
+            lastSuccessfulBackupTime: '2026-08-12T00:00:00Z',
+          },
+        },
+      }),
+    )
+    expect(w.failingSinceLastSuccess).toBe(false)
+  })
+
+  it('treats a failure with no success at all as failing', () => {
+    const [w] = getCNPGObjectStoreRecoveryWindows(
+      store({ serverRecoveryWindow: { pg: { lastFailedBackupTime: '2026-08-12T00:00:00Z' } } }),
+    )
+    expect(w.failingSinceLastSuccess).toBe(true)
+  })
+
+  it('returns nothing for a store that has never reported', () => {
+    expect(getCNPGObjectStoreRecoveryWindows(store({}))).toEqual([])
+    expect(getCNPGObjectStoreRecoveryWindows(store(undefined))).toEqual([])
+  })
+})
+
+describe('getCNPGObjectStoreStatus', () => {
+  // The load-bearing one: an empty status means nothing is restorable, and a
+  // green badge there would assert a recovery point that does not exist.
+  it('is unknown, not healthy, when no server has reported', () => {
+    const s = getCNPGObjectStoreStatus(store({}))
+    expect(s.level).toBe('unknown')
+    expect(s.text).toBe('No backups yet')
+  })
+
+  it('is unhealthy when any server is failing since its last success', () => {
+    const s = getCNPGObjectStoreStatus(
+      store({
+        serverRecoveryWindow: {
+          ok: { lastSuccessfulBackupTime: '2026-08-12T00:00:00Z' },
+          bad: { lastSuccessfulBackupTime: '2026-08-01T00:00:00Z', lastFailedBackupTime: '2026-08-12T00:00:00Z' },
+        },
+      }),
+    )
+    expect(s.level).toBe('unhealthy')
+  })
+
+  it('is healthy when every server has a clean latest backup', () => {
+    const s = getCNPGObjectStoreStatus(
+      store({ serverRecoveryWindow: { pg: { lastSuccessfulBackupTime: '2026-08-12T00:00:00Z' } } }),
+    )
+    expect(s.level).toBe('healthy')
+  })
+})
+
+describe('provider + group guards', () => {
+  it('names the provider without exposing credentials', () => {
+    expect(
+      getCNPGObjectStoreProvider(
+        store({}, { configuration: { destinationPath: 's3://b', s3Credentials: { accessKeyId: { name: 'x' } } } }),
+      ),
+    ).toBe('S3')
+    expect(
+      getCNPGObjectStoreProvider(store({}, { configuration: { azureCredentials: {} } })),
+    ).toBe('Azure Blob Storage')
+    expect(getCNPGObjectStoreProvider(store({}, { configuration: {} }))).toBeUndefined()
+  })
+
+  // `objectstores` is generic enough for another operator to claim.
+  it('does not claim a foreign objectstores CR', () => {
+    expect(isCNPGObjectStore(store({}))).toBe(true)
+    expect(isCNPGObjectStore({ apiVersion: 'minio.example.io/v1', kind: 'ObjectStore' })).toBe(false)
+    expect(isCNPGObjectStore({})).toBe(false)
+  })
+})

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

@@ -1,9 +1,13 @@
 import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest'
 import {
+  getCNPGScheduledBackupStatus,
+  getCNPGScheduledBackupNextSchedule,
   getCNPGClusterCertificateExpirations,
   getCNPGClusterStatus,
   getCNPGBackupStatus,
   getCNPGPoolerStatus,
+  isCNPGPoolerPaused,
+  getCNPGVolumeHealth,
   getCNPGClusterInstancesReportedState,
   getCNPGClusterBackupConfig,
   getCNPGClusterBarmanPlugin,
@@ -599,3 +603,116 @@ describe('an absent count is unknown, never zero', () => {
       .toMatchObject({ text: 'Scheduled', level: 'healthy' })
   })
 })
+
+describe('paused Pooler', () => {
+  // PgBouncer PAUSE holds client connections instead of serving them, while
+  // every pod stays scheduled and Ready. Reading only the pod counts rendered
+  // a pooler that serves nothing in healthy green.
+  const paused = { spec: { instances: 2, pgbouncer: { paused: true } }, status: { instances: 2 } }
+
+  it('does not read as healthy', () => {
+    expect(getCNPGPoolerStatus(paused)).toMatchObject({ text: 'Paused', level: 'degraded' })
+  })
+
+  it('treats pausing as intent, not a fault', () => {
+    // Same tier as a paused Velero Schedule: amber, not red.
+    expect(getCNPGPoolerStatus(paused).level).not.toBe('unhealthy')
+  })
+
+  it('lets a real fault outrank the pause', () => {
+    const pausedAndDown = { spec: { instances: 2, pgbouncer: { paused: true } }, status: { instances: 0 } }
+    expect(getCNPGPoolerStatus(pausedAndDown)).toMatchObject({ text: 'Not Scheduled', level: 'unhealthy' })
+  })
+
+  it('only an explicit true pauses', () => {
+    expect(getCNPGPoolerStatus({ spec: { instances: 2, pgbouncer: {} }, status: { instances: 2 } }))
+      .toMatchObject({ text: 'Scheduled', level: 'healthy' })
+    expect(getCNPGPoolerStatus({ spec: { instances: 2, pgbouncer: { paused: false } }, status: { instances: 2 } }))
+      .toMatchObject({ text: 'Scheduled', level: 'healthy' })
+    expect(isCNPGPoolerPaused({ spec: { pgbouncer: { paused: true } } })).toBe(true)
+    expect(isCNPGPoolerPaused({ spec: {} })).toBe(false)
+  })
+})
+
+describe('volume health', () => {
+  // Field names and shape verified against a live CloudNativePG 1.27 CRD and a
+  // running cluster: pvcCount is a number, the rest are arrays of PVC names.
+  const healthy = {
+    status: { pvcCount: 2, healthyPVC: ['pg-healthy-1', 'pg-healthy-2'] },
+  }
+
+  it('reads what the operator reports about volumes that exist', () => {
+    const h = getCNPGVolumeHealth(healthy)
+    expect(h).toMatchObject({ total: 2, healthy: ['pg-healthy-1', 'pg-healthy-2'], unusable: [] })
+  })
+
+  it('surfaces an unusable volume, which is why an instance cannot start', () => {
+    // Upstream: unusable means a paired volume is missing.
+    const h = getCNPGVolumeHealth({ status: { pvcCount: 3, healthyPVC: ['a'], unusablePVC: ['pg-main-3'] } })
+    expect(h?.unusable).toEqual(['pg-main-3'])
+  })
+
+  it('stays silent when the operator has reported nothing', () => {
+    // Absence must not render as "0 problems" — the section is hidden instead,
+    // so it never claims a check it did not perform.
+    expect(getCNPGVolumeHealth({ status: {} })).toBeNull()
+    expect(getCNPGVolumeHealth({})).toBeNull()
+  })
+
+  it('ignores malformed entries rather than rendering them', () => {
+    const h = getCNPGVolumeHealth({ status: { pvcCount: 1, healthyPVC: ['ok', 42, null] } })
+    expect(h?.healthy).toEqual(['ok'])
+  })
+})
+
+describe('CNPG scheduled backup lateness', () => {
+  const at = (ms: number) => new Date(Date.now() + ms).toISOString()
+  const MIN = 60 * 1000
+
+  const sb = (suspend: boolean, next?: string, lastScheduleTime?: string) => ({
+    spec: { schedule: '0 0 0 * * *', suspend },
+    status: { ...(next ? { nextScheduleTime: next } : {}), ...(lastScheduleTime ? { lastScheduleTime } : {}) },
+  })
+
+  it('reports a schedule that missed its own next-run time', () => {
+    // Ran once, then stopped. Both lastScheduleTime and nextScheduleTime are
+    // present, which is exactly the shape that used to read healthy.
+    const badge = getCNPGScheduledBackupStatus(sb(false, at(-200 * 24 * 60 * MIN), at(-200 * 24 * 60 * MIN)))
+    expect(badge.level).toBe('degraded')
+    expect(badge.text).toBe('Overdue')
+  })
+
+  it('stays healthy inside the operator reconcile window', () => {
+    const badge = getCNPGScheduledBackupStatus(sb(false, at(-1 * MIN), at(-24 * 60 * MIN)))
+    expect(badge.level).toBe('healthy')
+  })
+
+  it('keeps suspended as a deliberate state, not a missed backup', () => {
+    // The operator stops maintaining nextScheduleTime once suspended, so the
+    // stale value must not be read as a missed run.
+    const badge = getCNPGScheduledBackupStatus(sb(true, at(-200 * 24 * 60 * MIN)))
+    expect(badge.text).toBe('Suspended')
+  })
+
+  it('never says overdue while the badge still says healthy', () => {
+    // The two read from one test. Before this they disagreed: the badge said
+    // Active while this field said overdue on the same row.
+    const justPastDue = sb(false, at(-1 * MIN), at(-24 * 60 * MIN))
+    expect(getCNPGScheduledBackupStatus(justPastDue).level).toBe('healthy')
+    expect(getCNPGScheduledBackupNextSchedule(justPastDue)).toBe('due now')
+
+    const longPastDue = sb(false, at(-200 * 24 * 60 * MIN), at(-200 * 24 * 60 * MIN))
+    expect(getCNPGScheduledBackupStatus(longPastDue).level).toBe('degraded')
+    expect(getCNPGScheduledBackupNextSchedule(longPastDue)).toContain('overdue by')
+  })
+
+  it('does not count down to a run that is not coming', () => {
+    expect(getCNPGScheduledBackupNextSchedule(sb(true, at(60 * MIN)))).toBe('suspended')
+    expect(getCNPGScheduledBackupNextSchedule(sb(true, at(-60 * MIN)))).toBe('suspended')
+  })
+
+  it('says nothing when the operator published no next-run time', () => {
+    expect(getCNPGScheduledBackupNextSchedule(sb(false))).toBe('-')
+    expect(getCNPGScheduledBackupStatus(sb(false, undefined, at(-24 * 60 * MIN))).level).toBe('healthy')
+  })
+})