@skyhook-io/k8s-ui 1.17.0 → 1.17.1

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

@@ -0,0 +1,121 @@
+import { describe, expect, it } from 'vitest'
+import { cnpgLogicalLocation, cnpgLogicalPaths, cnpgLogicalSlotFact, cnpgResolvePublisher } from './logicalReplication'
+
+const G = 'postgresql.cnpg.io/v1'
+const cluster = (name: string, ns: string, spec: any = {}, status: any = {}) => ({ apiVersion: G, kind: 'Cluster', metadata: { name, namespace: ns }, spec: { instances: 3, ...spec }, status })
+const sub = (spec: any, status: any = {}) => ({ apiVersion: G, kind: 'Subscription', metadata: { name: 'orders-sub', namespace: 'dst' }, spec: { cluster: { name: 'dst' }, name: 'orders_sub', dbname: 'app', publicationName: 'orders_pub', externalClusterName: 'src', ...spec }, status })
+const pub = { apiVersion: G, kind: 'Publication', metadata: { name: 'orders-pub', namespace: 'src' }, spec: { cluster: { name: 'src' }, name: 'orders_pub', dbname: 'app', target: { allTables: true } }, status: { applied: true } }
+const subscriber = (host: string) => cluster('dst', 'dst', { externalClusters: [{ name: 'src', connectionParameters: { host, dbname: 'app', user: 'app' } }] })
+const synced = (major: number) => cluster('src', 'src', { replicationSlots: { highAvailability: { synchronizeLogicalDecoding: true } } }, { pgDataImageInfo: { majorVersion: major } })
+
+describe('cnpgResolvePublisher', () => {
+  const clusters = [cluster('src', 'src'), cluster('dst', 'dst')]
+  it('resolves -rw/-ro/-r Service hosts in any spelling to the visible Cluster', () => {
+    for (const host of ['src-rw.src.svc', 'src-rw.src.svc.cluster.local', 'src-ro.src', 'SRC-R.src.svc']) {
+      const p = cnpgResolvePublisher(host, 'dst', clusters, [])
+      expect(p.kind === 'cluster' && p.name).toBe('src')
+    }
+  })
+  it('resolves through a Pooler Service, and a bare name in the subscriber namespace', () => {
+    const p = cnpgResolvePublisher('src-pooler.src.svc', 'dst', clusters, [{ metadata: { name: 'src-pooler', namespace: 'src' }, spec: { cluster: { name: 'src' } } }])
+    expect(p.kind === 'cluster' && p.via).toBe('Pooler src-pooler')
+    expect(cnpgResolvePublisher('dst-rw', 'dst', clusters, []).kind).toBe('cluster')
+  })
+  it('never guesses a cluster from an external host', () => {
+    expect(cnpgResolvePublisher('src-rw.example.com', 'dst', clusters, []).kind).toBe('external')
+    expect(cnpgResolvePublisher('other-rw.src.svc', 'dst', clusters, []).kind).toBe('external')
+    expect(cnpgResolvePublisher(undefined, 'dst', clusters, []).kind).toBe('external')
+  })
+})
+
+describe('cnpgLogicalPaths', () => {
+  it('walks subscription → external cluster → publisher → publication object → slot', () => {
+    const [p] = cnpgLogicalPaths([sub({})], [synced(17), subscriber('src-rw.src.svc')], [pub], [])
+    expect(p.publisher.kind === 'cluster' && `${p.publisher.namespace}/${p.publisher.name}`).toBe('src/src')
+    expect(p.publication.object?.name).toBe('orders-pub')
+    expect(p.publication.dbname).toBe('app')
+    expect(p.slot.name).toBe('orders_sub')
+  })
+  it('says when the external cluster is not declared or the publication is not a CNPG object', () => {
+    const [missing] = cnpgLogicalPaths([sub({ externalClusterName: 'nope' })], [synced(17), subscriber('src-rw.src.svc')], [pub], [])
+    expect(missing.publisher.kind).toBe('external')
+    expect(missing.externalCluster.declared).toBe(false)
+    const [sqlOnly] = cnpgLogicalPaths([sub({ publicationName: 'made_in_sql' })], [synced(17), subscriber('src-rw.src.svc')], [pub], [])
+    expect(sqlOnly.publication.object).toBeUndefined()
+  })
+  it('says a Publication is unknown when the publisher namespace\'s Publications are unreadable', () => {
+    const [p] = cnpgLogicalPaths([sub({})], [synced(17), subscriber('src-rw.src.svc')], [], [], (ns) => (ns === 'src' ? 'No access to Publications' : null))
+    expect(p.publication.object).toBeUndefined()
+    expect(p.publication.unavailable).toBe('No access to Publications')
+    const [readable] = cnpgLogicalPaths([sub({})], [synced(17), subscriber('src-rw.src.svc')], [], [], () => null)
+    expect(readable.publication.unavailable).toBeUndefined()
+  })
+  it('names the slot from slot_name, and none for slot_name = NONE', () => {
+    expect(cnpgLogicalPaths([sub({ parameters: { slot_name: 'custom' } })], [], [], [])[0].slot.name).toBe('custom')
+    expect(cnpgLogicalPaths([sub({ parameters: { slot_name: 'NONE' } })], [], [], [])[0].slot.name).toBeUndefined()
+  })
+})
+
+describe('slot failover', () => {
+  const failoverOf = (publisher: any, params?: any) =>
+    cnpgLogicalPaths([sub(params ? { parameters: params } : {})], [publisher, subscriber('src-rw.src.svc')], [], [])[0].failover
+  it('is lost when the publisher does not synchronize logical slots', () => {
+    const f = failoverOf(cluster('src', 'src'))
+    expect(f.tone).toBe('degraded')
+    expect(f.text).toContain('synchronizeLogicalDecoding is off')
+  })
+  it('on PostgreSQL 17 needs the subscription to request failover', () => {
+    expect(failoverOf(synced(17)).tone).toBe('degraded')
+    expect(failoverOf(synced(17), { failover: 'true' }).tone).toBe('healthy')
+  })
+  it('is lost when HA slots are disabled, whatever synchronizeLogicalDecoding says', () => {
+    const off = cluster('src', 'src', { replicationSlots: { highAvailability: { enabled: false, synchronizeLogicalDecoding: true } } }, { pgDataImageInfo: { majorVersion: 17 } })
+    const f = failoverOf(off, { failover: 'true' })
+    expect(f.tone).toBe('degraded')
+    expect(f.text).toContain('HA replication slots are disabled')
+  })
+  it('is unknown before 17 (pg_failover_slots), without a major, or outside Radar', () => {
+    expect(failoverOf(synced(16)).tone).toBe('unknown')
+    expect(failoverOf(cluster('src', 'src', { replicationSlots: { highAvailability: { synchronizeLogicalDecoding: true } } })).tone).toBe('unknown')
+    expect(cnpgLogicalPaths([sub({})], [subscriber('db.example.com')], [], [])[0].failover.tone).toBe('unknown')
+  })
+})
+
+describe('cnpgLogicalSlotFact', () => {
+  const [path] = cnpgLogicalPaths([sub({}, { applied: true })], [synced(17), subscriber('src-rw.src.svc')], [pub], [])
+  it('never reads a denied or unread runtime as a missing slot', () => {
+    expect(cnpgLogicalSlotFact(path, { state: 'denied' }).tone).toBe('unknown')
+    expect(cnpgLogicalSlotFact(path, { state: 'unavailable', reason: 'unreachable' }).text).toContain('not read (unreachable)')
+  })
+  it('reports the observed slot, and a missing one only from a readable report', () => {
+    const ok = cnpgLogicalSlotFact(path, { state: 'ok', slots: [{ name: 'orders_sub', type: 'logical', active: true, retainedBytes: 2048, walStatus: 'reserved' }] })
+    expect(ok.text).toBe('Slot orders_sub · logical · active · retains 2.0 KiB of WAL · WAL reserved')
+    expect(ok.tone).toBe('healthy')
+    expect(cnpgLogicalSlotFact(path, { state: 'ok', slots: [{ name: 'orders_sub', active: false }] }).tone).toBe('degraded')
+    const capped = cnpgLogicalSlotFact(path, { state: 'partial', reason: '250 replication slots; the first 200 are shown', slots: [] })
+    expect(capped.text).toContain('not in the reported slots (report incomplete: 250 replication slots')
+    expect(capped.tone).toBe('unknown')
+    const stale = cnpgLogicalSlotFact(path, { state: 'ok', stale: true, slots: [{ name: 'orders_sub', type: 'logical', active: true }] })
+    expect(stale.tone).toBe('unknown')
+    expect(stale.text).toContain('from an earlier read')
+    const gone = cnpgLogicalSlotFact(path, { state: 'ok', slots: [] })
+    expect(gone.text).toContain('not found')
+    expect(gone.tone).toBe('degraded')
+  })
+})
+
+describe('cnpgLogicalLocation', () => {
+  it('says an unknown database in words', () => {
+    expect(cnpgLogicalLocation('upstream', 'app')).toBe('upstream/app')
+    expect(cnpgLogicalLocation('external cluster upstream', undefined)).toBe('external cluster upstream · database unknown')
+    expect(cnpgLogicalLocation('x', undefined)).not.toContain('?')
+  })
+})
+
+it('keeps stale Publication and Subscription results pending on the logical path', () => {
+  const staleSub = { ...sub({}, { applied: true, observedGeneration: 1 }), metadata: { ...sub({}).metadata, generation: 2 } }
+  const stalePub = { ...pub, metadata: { ...pub.metadata, generation: 2 }, status: { applied: true, observedGeneration: 1 } }
+  const [path] = cnpgLogicalPaths([staleSub], [synced(17), subscriber('src-rw.src.svc')], [stalePub], [])
+  expect(path.subscription.applied).toBeNull()
+  expect(path.publication.object?.applied).toBeNull()
+})

package/src/components/cnpg/logicalReplication.ts

@@ -0,0 +1,252 @@
+import { getCNPGPostgresMajor } from '../resources/resource-utils-cnpg'
+import { cnpgRoleState } from './databaseRole'
+import { cnpgFormatBytes } from './workspace'
+import { type Fact } from '../facts'
+
+/** Where a Subscription's publisher lives, as far as the subscriber's spec shows. */
+export type CNPGPublisher =
+  | { kind: 'cluster'; namespace: string; name: string; via: string; cluster: any }
+  | { kind: 'external'; host?: string; reason: string }
+
+export interface CNPGLogicalPath {
+  subscription: { namespace: string; name: string; sqlName?: string; dbname?: string; cluster?: string; applied: boolean | null; message?: string }
+  externalCluster: { name?: string; declared: boolean; host?: string; dbname?: string }
+  publisher: CNPGPublisher
+  publication: {
+    name?: string
+    dbname?: string
+    /** The Publication object on the publisher Cluster declaring it, when one is visible. */
+    object?: { namespace: string; name: string; applied: boolean | null }
+    /** Why Publication objects in the publisher's namespace could not be read; absence then proves nothing. */
+    unavailable?: string
+  }
+  /** The slot PostgreSQL creates for the subscription: `slot_name`, else the subscription's name. */
+  slot: { name?: string; reason?: string }
+  failover: Fact
+}
+
+const SERVICE_SUFFIXES = ['-rw', '-ro', '-r']
+
+function stripHost(host: string): { name: string; namespace?: string } {
+  const h = host.trim().toLowerCase().replace(/\.$/, '').replace(/\.svc\.cluster\.local$/, '').replace(/\.svc$/, '')
+  const [name, namespace] = h.split('.')
+  return { name, namespace }
+}
+
+/**
+ * Resolves an external cluster's host to a visible CNPG Cluster through its
+ * -rw / -ro / -r Service or a Pooler's Service. Anything else stays external:
+ * the host is never guessed to be a cluster it only resembles.
+ */
+export function cnpgResolvePublisher(host: string | undefined, subscriberNs: string, clusters: any[], poolers: any[]): CNPGPublisher {
+  if (!host) return { kind: 'external', reason: 'the external cluster names no host' }
+  const { name, namespace = subscriberNs } = stripHost(host)
+  if (host.includes('.') && !/\.svc(\.cluster\.local)?\.?$/i.test(host.trim()) && host.split('.').length > 2) {
+    return { kind: 'external', host, reason: 'the host is not a Kubernetes Service name' }
+  }
+  const inNs = (list: any[]) => list.filter((o) => o?.metadata?.namespace === namespace)
+  for (const suffix of SERVICE_SUFFIXES) {
+    if (!name.endsWith(suffix)) continue
+    const base = name.slice(0, -suffix.length)
+    const c = inNs(clusters).find((x) => x.metadata?.name === base)
+    if (c) return { kind: 'cluster', namespace, name: base, via: `${name}.${namespace}`, cluster: c }
+  }
+  const pooler = inNs(poolers).find((p) => p.metadata?.name === name)
+  if (pooler?.spec?.cluster?.name) {
+    const c = inNs(clusters).find((x) => x.metadata?.name === pooler.spec.cluster.name)
+    if (c) return { kind: 'cluster', namespace, name: c.metadata.name, via: `Pooler ${name}`, cluster: c }
+  }
+  return { kind: 'external', host, reason: 'no visible CloudNativePG Cluster serves this host' }
+}
+
+/**
+ * The namespace a Subscription's publisher host names, so a host can read that
+ * namespace too before resolving the publisher. Undefined when the subscriber
+ * or its external cluster is not visible, or the host names none.
+ */
+export function cnpgSubscriptionHostNamespace(subscription: any, clusters: any[]): string | undefined {
+  const ns = subscription?.metadata?.namespace
+  const subscriber = clusters.find((c) => c?.metadata?.namespace === ns && c?.metadata?.name === subscription?.spec?.cluster?.name)
+  const ext = (subscriber?.spec?.externalClusters ?? []).find((e: any) => e?.name === subscription?.spec?.externalClusterName)
+  const host = ext?.connectionParameters?.host
+  return host ? stripHost(host).namespace ?? ns : undefined
+}
+
+
+function truthy(v: unknown): boolean | undefined {
+  if (v === undefined || v === null) return undefined
+  const s = String(v).trim().toLowerCase()
+  if (['true', 'on', 'yes', '1'].includes(s)) return true
+  if (['false', 'off', 'no', '0'].includes(s)) return false
+  return undefined
+}
+
+const FAILOVER_SOURCE = "Publisher's spec.replicationSlots.highAvailability (enabled and synchronizeLogicalDecoding), its PostgreSQL major and the Subscription's failover parameter; /pg/status does not report a slot's failover flag"
+
+/**
+ * Whether the publisher's slot for this subscription is kept on its standbys,
+ * so a failover of the publisher does not lose it. Declared configuration
+ * only: CloudNativePG does not report which slots were actually synchronized.
+ */
+export function cnpgSlotFailover(publisher: CNPGPublisher, subscription: any): Fact {
+  if (publisher.kind !== 'cluster') {
+    return { text: 'Unknown: the publisher is not a CloudNativePG Cluster Radar can see', tone: 'unknown', source: FAILOVER_SOURCE }
+  }
+  const c = publisher.cluster
+  if ((c?.spec?.instances ?? 1) <= 1) {
+    return { text: 'No standby to fail over to: a single-instance publisher', tone: 'neutral', source: FAILOVER_SOURCE }
+  }
+  const ha = c?.spec?.replicationSlots?.highAvailability
+  // GetEnabled defaults to true; the operator enables sync only with both.
+  if (ha?.synchronizeLogicalDecoding === true && ha?.enabled === false) {
+    return {
+      text: 'Lost on failover: synchronizeLogicalDecoding is on, but HA replication slots are disabled, so standbys have no physical slot to synchronize through',
+      tone: 'degraded',
+      source: FAILOVER_SOURCE,
+    }
+  }
+  const sync = ha?.synchronizeLogicalDecoding === true
+  if (!sync) {
+    return {
+      text: 'Lost on failover: the publisher does not synchronize logical slots to standbys (synchronizeLogicalDecoding is off)',
+      tone: 'degraded',
+      source: FAILOVER_SOURCE,
+    }
+  }
+  const major = getCNPGPostgresMajor(c)
+  if (major === undefined) {
+    return { text: 'Unknown: synchronization is on, but the publisher\'s PostgreSQL major is not reported', tone: 'unknown', source: FAILOVER_SOURCE }
+  }
+  if (major < 17) {
+    return {
+      text: 'Synchronized only if pg_failover_slots is loaded on the publisher (PostgreSQL < 17); Radar cannot tell',
+      tone: 'unknown',
+      source: FAILOVER_SOURCE,
+    }
+  }
+  const failover = truthy(subscription?.spec?.parameters?.failover)
+  if (failover === true) {
+    return { text: 'Kept on standbys (declared): synchronization is on and the subscription requests failover', tone: 'healthy', source: FAILOVER_SOURCE }
+  }
+  return {
+    text: "Lost on failover: PostgreSQL 17 synchronizes only slots created with failover = true, and the subscription's parameters do not set it",
+    tone: 'degraded',
+    source: FAILOVER_SOURCE,
+  }
+}
+
+export function cnpgLogicalPaths(
+  subscriptions: any[],
+  clusters: any[],
+  publications: any[],
+  poolers: any[],
+  /** Why Publications in a namespace are not readable (coverage), or null when they are. */
+  publicationsUnavailable?: (namespace: string) => string | null,
+): CNPGLogicalPath[] {
+  return subscriptions.map((sub) => {
+    const ns: string = sub?.metadata?.namespace ?? ''
+    const subscriber = clusters.find((c) => c?.metadata?.namespace === ns && c?.metadata?.name === sub?.spec?.cluster?.name)
+    const extName: string | undefined = sub?.spec?.externalClusterName
+    const ext = (subscriber?.spec?.externalClusters ?? []).find((e: any) => e?.name === extName)
+    const params = ext?.connectionParameters ?? {}
+    const publisher: CNPGPublisher = !subscriber
+      ? { kind: 'external', reason: 'the subscriber Cluster is not visible, so its external cluster cannot be read' }
+      : !ext
+        ? { kind: 'external', reason: `external cluster ${extName ?? '(unset)'} is not declared on ${subscriber.metadata?.name}` }
+        : cnpgResolvePublisher(params.host, ns, clusters, poolers)
+    const pubDb: string | undefined = sub?.spec?.publicationDBName || params.dbname
+    const pubName: string | undefined = sub?.spec?.publicationName
+    const pubObj =
+      publisher.kind === 'cluster'
+        ? publications.find(
+            (p) =>
+              p?.metadata?.namespace === publisher.namespace &&
+              p?.spec?.cluster?.name === publisher.name &&
+              p?.spec?.name === pubName &&
+              (!pubDb || p?.spec?.dbname === pubDb),
+          )
+        : undefined
+    const slotParam: string | undefined = sub?.spec?.parameters?.slot_name
+    const createSlot = truthy(sub?.spec?.parameters?.create_slot)
+    const slot =
+      slotParam && slotParam.toLowerCase() === 'none'
+        ? { reason: 'slot_name = NONE: the subscription uses no slot' }
+        : slotParam
+          ? { name: slotParam }
+          : createSlot === false
+            ? { name: sub?.spec?.name, reason: 'create_slot = false: the slot must be created by hand' }
+            : { name: sub?.spec?.name }
+    return {
+      subscription: {
+        namespace: ns,
+        name: sub?.metadata?.name,
+        sqlName: sub?.spec?.name,
+        dbname: sub?.spec?.dbname,
+        cluster: sub?.spec?.cluster?.name,
+        applied: cnpgRoleState(sub) === 'pending' ? null : cnpgRoleState(sub) === 'applied',
+        message: sub?.status?.message || undefined,
+      },
+      externalCluster: { name: extName, declared: !!ext, host: params.host, dbname: params.dbname },
+      publisher,
+      publication: {
+        name: pubName,
+        dbname: pubDb,
+        object: pubObj
+          ? { namespace: pubObj.metadata.namespace, name: pubObj.metadata.name, applied: cnpgRoleState(pubObj) === 'pending' ? null : cnpgRoleState(pubObj) === 'applied' }
+          : undefined,
+        unavailable: !pubObj && publisher.kind === 'cluster' ? publicationsUnavailable?.(publisher.namespace) ?? undefined : undefined,
+      },
+      slot,
+      failover: cnpgSlotFailover(publisher, sub),
+    }
+  })
+}
+
+/** What the publisher primary's instance manager says about one slot, in a shape independent of the runtime API. */
+export interface CNPGPublisherSlots {
+  /** partial: the report was capped or incomplete, so a slot missing from it may exist. */
+  state: 'ok' | 'partial' | 'denied' | 'unavailable' | 'notRead'
+  reason?: string
+  /** The latest refresh failed; slots are from an earlier read. */
+  stale?: boolean
+  slots?: { name: string; type?: string; active?: boolean; walStatus?: string; retainedBytes?: number; database?: string }[]
+}
+
+const SLOT_SOURCE = "Publisher primary's instance manager (/pg/status replicationSlotsInfo) and exporter (retained WAL)"
+
+export function cnpgLogicalSlotFact(path: CNPGLogicalPath, observed: CNPGPublisherSlots): Fact {
+  if (!path.slot.name) return { text: path.slot.reason ?? 'No slot', tone: 'neutral' }
+  if (path.publisher.kind !== 'cluster') return { text: `Slot ${path.slot.name}: not observable (publisher outside this cluster's view)`, tone: 'unknown' }
+  if (observed.state === 'denied') return { text: `Slot ${path.slot.name}: no access (needs get pods/proxy on the publisher)`, tone: 'unknown', source: SLOT_SOURCE }
+  if ((observed.state !== 'ok' && observed.state !== 'partial') || !observed.slots) {
+    return { text: `Slot ${path.slot.name}: not read${observed.reason ? ` (${observed.reason})` : ''}`, tone: 'unknown', source: SLOT_SOURCE }
+  }
+  const s = observed.slots.find((x) => x.name === path.slot.name)
+  if (!s && (observed.state === 'partial' || observed.stale)) {
+    return {
+      text: `Slot ${path.slot.name}: not in the reported slots (${observed.stale ? 'from an earlier read; the latest refresh failed' : `report incomplete${observed.reason ? `: ${observed.reason}` : ''}`})`,
+      tone: 'unknown',
+      source: SLOT_SOURCE,
+    }
+  }
+  if (!s) {
+    return {
+      text: `Slot ${path.slot.name} not found on the publisher primary${path.slot.reason ? `: ${path.slot.reason}` : ''}`,
+      tone: path.subscription.applied === true ? 'degraded' : 'unknown',
+      source: SLOT_SOURCE,
+    }
+  }
+  const parts = [`Slot ${s.name}`, s.type ?? 'type unknown', s.active === undefined ? 'activity unknown' : s.active ? 'active' : 'inactive']
+  if (s.retainedBytes !== undefined) parts.push(`retains ${cnpgFormatBytes(s.retainedBytes)} of WAL`)
+  if (s.walStatus) parts.push(`WAL ${s.walStatus}`)
+  const bad = s.active === false || s.walStatus === 'lost' || s.walStatus === 'unreserved'
+  if (observed.stale) {
+    return { text: `${parts.join(' · ')} (from an earlier read; the latest refresh failed)`, tone: 'unknown', source: SLOT_SOURCE }
+  }
+  return { text: parts.join(' · '), tone: s.walStatus === 'lost' ? 'unhealthy' : bad ? 'degraded' : 'healthy', source: SLOT_SOURCE }
+}
+
+/** "cluster/database", with an unknown database said in words rather than as "?". */
+export function cnpgLogicalLocation(where: string, dbname: string | undefined): string {
+  return dbname ? `${where}/${dbname}` : `${where} · database unknown`
+}

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

@@ -0,0 +1,84 @@
+import { describe, expect, it } from 'vitest'
+import { poolerPressureCoverage, poolerPressureFact, aggregatePoolerPools, observedPause, poolerBackendService, poolerReadiness, poolerPodPressure } from './pooler'
+
+describe('poolerReadiness', () => {
+  it('reads readiness from the Deployment, never from the scheduled count', () => {
+    expect(poolerReadiness({ name: 'p', state: 'ok', replicas: 2, readyReplicas: 2 })).toMatchObject({ text: '2/2 ready', level: 'healthy' })
+    expect(poolerReadiness({ name: 'p', state: 'ok', replicas: 2, readyReplicas: 1 }).level).toBe('degraded')
+    expect(poolerReadiness({ name: 'p', state: 'ok', replicas: 2, readyReplicas: 0 }).level).toBe('unhealthy')
+  })
+  it('says unknown, not failed, when the Deployment is unreadable', () => {
+    expect(poolerReadiness({ name: 'p', state: 'unreadable' })).toMatchObject({ text: 'Unknown', level: 'unknown' })
+    expect(poolerReadiness(undefined).level).toBe('unknown')
+  })
+})
+
+describe('aggregatePoolerPools', () => {
+  it('sums each pool over the Pods that reported it and keeps unreported fields undefined', () => {
+    const rows = aggregatePoolerPools([
+      { pod: 'a', state: 'ok', pools: [{ database: 'app', user: 'app', clActive: 3, clWaiting: 1, maxwaitSeconds: 0.5, poolMode: 'transaction' }] },
+      { pod: 'b', state: 'ok', pools: [{ database: 'app', user: 'app', clActive: 2, clWaiting: 0, maxwaitSeconds: 2, poolMode: 'transaction' }] },
+    ])
+    expect(rows).toHaveLength(1)
+    expect(rows[0]).toMatchObject({ clActive: 5, clWaiting: 1, maxwaitSeconds: 2, pods: 2, poolModes: ['transaction'] })
+    expect(rows[0].svActive).toBeUndefined()
+  })
+})
+
+describe('observedPause', () => {
+  it('distinguishes all, some and unreadable', () => {
+    expect(observedPause({ state: 'ok', pods: [{ pod: 'a', state: 'ok', paused: true }, { pod: 'b', state: 'ok', paused: true }] })?.text).toBe('Paused on 2 of 2 PgBouncers')
+    expect(observedPause({ state: 'ok', pods: [{ pod: 'a', state: 'ok', paused: true }, { pod: 'b', state: 'ok', paused: false }] })?.level).toBe('alert')
+    expect(observedPause({ state: 'ok', pods: [{ pod: 'a', state: 'ok', paused: false }, { pod: 'b', state: 'error' }] })?.text).toBe('Serving (not paused) on 1 of 2 PgBouncers · 1 not read: b (error)')
+    expect(observedPause({ state: 'denied', grant: { verb: 'create', resource: 'pods', subresource: 'exec', namespace: 'x' }, pods: [] })?.text).toContain('create pods/exec')
+  })
+})
+
+describe('poolerBackendService', () => {
+  it('names the Cluster Service by type', () => {
+    expect(poolerBackendService('pg', 'rw')).toBe('pg-rw')
+    expect(poolerBackendService('pg', 'ro')).toBe('pg-ro')
+    expect(poolerBackendService('pg', undefined)).toBeUndefined()
+  })
+})
+
+describe('poolerPodPressure', () => {
+  it('totals each Pod on its own so one queuing Pod is visible', () => {
+    const rows = poolerPodPressure([
+      { pod: 'pooler-b', state: 'ok', pools: [{ database: 'app', user: 'app', clActive: 2, clWaiting: 0, svActive: 1 }, { database: 'app', user: 'ro', clActive: 1, clWaiting: 0, svActive: 0 }] },
+      { pod: 'pooler-a', state: 'ok', pools: [{ database: 'app', user: 'app', clActive: 20, clWaiting: 15, svActive: 20, maxwaitSeconds: 4.2 }] },
+      { pod: 'pooler-c', state: 'unreachable', error: 'no answer within 5s' },
+    ] as never)
+    expect(rows).toEqual([
+      { pod: 'pooler-a', state: 'ok', error: undefined, clActive: 20, clWaiting: 15, svActive: 20, maxwaitSeconds: 4.2 },
+      { pod: 'pooler-b', state: 'ok', error: undefined, clActive: 3, clWaiting: 0, svActive: 1 },
+      { pod: 'pooler-c', state: 'unreachable', error: 'no answer within 5s' },
+    ])
+  })
+})
+
+describe('pooler pressure certainty', () => {
+  it('says idle only when every Pod answered in full', () => {
+    const a = { pod: 'a', state: 'ok', pools: [] }
+    expect(poolerPressureCoverage([a]).empty).toBe('Idle: no client pools open')
+    for (const state of ['partial', 'unreachable']) {
+      const c = poolerPressureCoverage([a, { pod: 'b', state, reason: 'pool list capped' }])
+      expect(c.complete).toBe(false)
+      expect(c.empty).toBe('No pools seen in what was read')
+      expect(c.limitation).toContain('b:')
+      expect(c.limitation).toContain('pool list capped')
+    }
+  })
+  it('shows unknown for partial zero and a lower bound for partial positive counts', () => {
+    const p = { pod: 'a', state: 'partial', pools: [{ database: 'app', user: 'app', clWaiting: 0, clActive: 3 }] }
+    expect(poolerPressureFact([p], 'clWaiting')).toMatchObject({ text: 'Unknown', tone: 'unknown' })
+    expect(poolerPressureFact([p], 'clActive')).toMatchObject({ text: '≥3', tone: 'unknown' })
+    expect(poolerPressureFact([{ ...p, state: 'ok' }], 'clWaiting').text).toBe('0')
+    expect(poolerPressureFact([{ ...p, state: 'ok' }, { pod: 'b', state: 'unreachable' }], 'clWaiting').text).toBe('Unknown')
+  })
+  it('qualifies a total when a pool omitted the field, even with complete Pod reads', () => {
+    const pods = [{ pod: 'a', state: 'ok', pools: [{ database: 'app', user: 'a', clActive: 2 }, { database: 'app', user: 'b' }] }]
+    expect(poolerPressureFact(pods, 'clActive').text).toBe('≥2')
+    expect(poolerPressureFact(pods, 'clWaiting').text).toBe('Unknown')
+  })
+})