@skyhook-io/k8s-ui 1.19.0 → 1.20.0

package/src/components/resources/KueueAdmissionSection.test.tsx

@@ -84,6 +84,123 @@ describe('Kueue admission investigation', () => {
     expect(html.includes('Admission status; execution is shown separately.')).toBe(phase === 'admitted' || phase === 'quota_reserved')
   })
 
+  it('shows the server-classified admission state instead of the generic qualifier', () => {
+    const html = render(response({ decision: 'unsatisfied', kueue: { phase: 'pending', admission: { state: 'local_queue_missing', attention: 'action_needed', blocker: { code: 'local_queue_missing', source: 'condition', name: 'QuotaReserved', reason: 'Inadmissible', message: "LocalQueue gpu doesn't exist" } } } }))
+    expect(html).toContain('Pending admission')
+    expect(html).toContain('LocalQueue missing')
+  })
+
+  it('names an unrecognized reason verbatim and renders unknown codes as sent', () => {
+    expect(render(response({ kueue: { phase: 'pending', admission: { state: 'unrecognized', attention: 'unknown', blocker: { code: 'unrecognized', source: 'condition', name: 'QuotaReserved', reason: 'SomethingNew' } } } })))
+      .toContain('Kueue: <code>SomethingNew</code>')
+    // A coarse reason the primary condition already shows is not repeated.
+    const coarse = render(response({ primaryCondition: { type: 'QuotaReserved', status: 'False', reason: 'Pending', message: 'failed to assign flavors to pod set main: boom' }, kueue: { phase: 'pending', admission: { state: 'unrecognized', attention: 'unknown', blocker: { code: 'unrecognized', source: 'condition', name: 'QuotaReserved', reason: 'Pending' } } } }))
+    expect(coarse).not.toContain('Unclassified reason')
+    expect(coarse).not.toContain('Kueue: <code>Pending</code>')
+    expect(coarse).toContain('failed to assign flavors to pod set main: boom')
+    expect(render(response({ kueue: { phase: 'pending', admission: { state: 'a_future_code', attention: 'a_future_class' } } }))).toContain('a_future_code')
+  })
+
+  it('does not repeat the phase, and leads with the state for a withdrawn Workload', () => {
+    const admitted = render(response({ decision: 'satisfied', kueue: { phase: 'admitted', admission: { state: 'admitted', attention: 'none' } } }))
+    expect(admitted.match(/>Admitted</g)).toHaveLength(1)
+    const deactivated = render(response({ decision: 'held', kueue: { phase: 'pending', active: false, admission: { state: 'deactivated', attention: 'paused', inactive: { code: 'deactivated', source: 'spec', name: 'active' } } } }))
+    expect(deactivated).toContain('>Deactivated<')
+    expect(deactivated).not.toContain('Pending admission')
+    expect(deactivated).not.toContain('Workload inactive')
+    expect(deactivated).not.toContain('Admission held')
+  })
+
+  it('takes staleness from the server classification, once', () => {
+    const stale = render(response({ decision: 'satisfied', kueue: { phase: 'admitted', admission: { state: 'admitted', attention: 'none', stale: true } } }))
+    expect(stale.match(/>Admitted</g)).toHaveLength(1)
+    expect(stale).toContain('Reported before the Workload')
+    // A stale primary condition does not contradict a current classification.
+    const current = render(response({ decision: 'held', primaryCondition: { type: 'QuotaReserved', status: 'False', reason: 'Pending', observedGeneration: 1 }, kueue: { phase: 'pending', active: false, admission: { state: 'deactivated', attention: 'paused', inactive: { code: 'deactivated', source: 'spec', name: 'active' } } } }))
+    expect(current).not.toContain('Stale evidence')
+    expect(current).not.toContain('Reported before')
+  })
+
+  it('shows the condition behind the state only when nothing else on the card says it', () => {
+    const backoff = render(response({ primaryCondition: { type: 'QuotaReserved', status: 'False', reason: 'Pending', message: 'couldn\'t assign flavors' }, kueue: { phase: 'pending', admission: { state: 'requeue_backoff', attention: 'waiting', blocker: { code: 'requeue_backoff', source: 'condition', name: 'Requeued', reason: 'PodsReadyTimeout', message: 'Exceeded the PodsReady timeout' } } } }))
+    expect(backoff).toContain('Requeued · PodsReadyTimeout: Exceeded the PodsReady timeout')
+    const sameMessage = render(response({ primaryCondition: { type: 'QuotaReserved', status: 'False', reason: 'Pending', message: 'The workload is deactivated due to a rejected check' }, kueue: { phase: 'pending', active: false, admission: { state: 'deactivated_by_kueue', attention: 'action_needed', inactive: { code: 'deactivated_by_kueue', source: 'condition', name: 'Evicted', reason: 'DeactivatedDueToAdmissionCheck', message: 'The workload is deactivated due to a rejected check' } } } }))
+    expect(sameMessage.match(/deactivated due to a rejected check/g)).toHaveLength(1)
+    const check = render(response({ primaryCondition: { type: 'QuotaReserved', status: 'True', reason: 'QuotaReserved' }, kueue: { phase: 'quota_reserved', admission: { state: 'admission_check_rejected', attention: 'action_needed', blocker: { code: 'admission_check_rejected', source: 'admission_check', name: 'capacity', reason: 'Rejected', message: 'Provisioning request cannot satisfy this workload' } } } }))
+    expect(check).toContain('Admission check rejected')
+    expect(check).not.toContain('capacity · Rejected')
+  })
+
+  it('leads with the deciding evidence and its transition time while retaining the earlier condition in Technical details', () => {
+    const since = '2026-09-26T10:00:00Z'
+    const data = response({ primaryCondition: { type: 'QuotaReserved', status: 'False', reason: 'Pending', message: 'Earlier quota shortage', observedGeneration: 1 }, kueue: { phase: 'pending', admission: { state: 'requeue_backoff', attention: 'waiting', blocker: { code: 'requeue_backoff', source: 'condition', name: 'Requeued', reason: 'PodsReadyTimeout', message: 'Waiting for the retry delay', since } } } })
+    const html = render(data)
+    expect(html.indexOf('Waiting for the retry delay')).toBeLessThan(html.indexOf('Technical details<'))
+    expect(html.indexOf('Earlier quota shortage')).toBeGreaterThan(html.indexOf('Technical details<'))
+    expect(html).toContain(`Requeued since <time dateTime="${since}"`)
+    expect(html).toContain('condition in Technical details was reported before')
+    data.workloads[0].scheduling!.observations![0].primaryCondition!.message = 'Waiting for the retry delay'
+    const repeated = render(data)
+    expect(repeated).toContain(`Requeued since <time dateTime="${since}"`)
+    expect(repeated.match(/Waiting for the retry delay/g)).toHaveLength(1)
+    delete data.workloads[0].scheduling!.observations![0].kueue!.admission!.blocker!.since
+    expect(render(data)).not.toContain('Requeued since')
+  })
+
+  it('does not repeat an eviction the supporting evidence already lists', () => {
+    const html = render(response({ primaryCondition: { type: 'QuotaReserved', status: 'True', reason: 'QuotaReserved', message: 'Quota reserved' }, disruptions: [{ type: 'Evicted', status: 'True', reason: 'Preempted', message: 'Preempted to accommodate a workload' }], kueue: { phase: 'quota_reserved', admission: { state: 'preempted', attention: 'waiting', disruption: { code: 'preempted', source: 'condition', name: 'Evicted', reason: 'Preempted', message: 'Preempted to accommodate a workload' } } } }))
+    expect(html).not.toContain('Evicted · Preempted')
+  })
+
+  it('lets the classified state carry the tone instead of a warning phase badge', () => {
+    const waiting = render(response({ decision: 'unsatisfied', kueue: { phase: 'pending', admission: { state: 'insufficient_quota', attention: 'waiting' } } }))
+    expect(waiting).not.toContain('bg-amber')
+    expect(render(response({ decision: 'unsatisfied', kueue: { phase: 'pending' } }))).toMatch(/Pending admission/)
+  })
+
+  it('shows a fresh eviction next to the pending phase without repeating it', () => {
+    const html = render(response({ primaryCondition: { type: 'QuotaReserved', status: 'False', reason: 'Pending', message: 'Preempted to accommodate a workload' }, disruptions: [{ type: 'Evicted', status: 'True', reason: 'Preempted', message: 'Preempted to accommodate a workload' }], kueue: { phase: 'pending', admission: { state: 'preempted', attention: 'waiting', blocker: { code: 'no_decision' }, disruption: { code: 'preempted', source: 'condition', name: 'Evicted', reason: 'Preempted', message: 'Preempted to accommodate a workload' } } } }))
+    expect(html).toContain('Pending admission')
+    expect(html).toContain('>Preempted<')
+    expect(html.match(/Preempted to accommodate a workload/g)?.length).toBeLessThanOrEqual(2)
+  })
+
+  it('marks a stale withdrawn state without its hint', () => {
+    const html = render(response({ kueue: { phase: 'pending', admission: { state: 'deactivation_pending', attention: 'action_needed', stale: true, inactive: { code: 'deactivation_pending', source: 'condition', name: 'DeactivationTarget', reason: 'AdmissionCheck', stale: true } } } }))
+    expect(html).not.toContain('Pending admission')
+    expect(html).toContain('Deactivating')
+    expect(html).toContain('Reported before the Workload')
+    expect(html).not.toContain('Kueue is deactivating the Workload')
+  })
+
+  it('keeps the admitted phase for a Workload deactivated while still admitted', () => {
+    const html = render(response({ decision: 'satisfied', kueue: { phase: 'admitted', active: false, admission: { state: 'deactivated', attention: 'paused', inactive: { code: 'deactivated', source: 'spec', name: 'active' } } } }))
+    expect(html).toContain('>Admitted<')
+    expect(html).toContain('>Deactivated<')
+  })
+
+  it('flags a deactivation whose cause Kueue did not record', () => {
+    const html = render(response({ decision: 'held', primaryCondition: { type: 'QuotaReserved', status: 'False', reason: 'Pending' }, disruptions: [{ type: 'Evicted', status: 'True', reason: 'PodsReadyTimeout', message: 'Exceeded the PodsReady timeout' }], kueue: { phase: 'pending', active: false, admission: { state: 'deactivated', attention: 'unknown', inactive: { code: 'deactivated', source: 'condition', name: 'Evicted', reason: 'PodsReadyTimeout', message: 'Exceeded the PodsReady timeout' } } } }))
+    expect(html).toContain('>Deactivated<')
+    expect(html).toContain('doesn&#x27;t say whether Kueue or a person deactivated it')
+    expect(html).toContain('Exceeded the PodsReady timeout')
+  })
+
+  it('suggests what an actionable state usually asks, and nothing for normal waiting', () => {
+    expect(render(response({ kueue: { phase: 'pending', admission: { state: 'local_queue_missing', attention: 'action_needed' } } }))).toContain('ask an admin to create the LocalQueue')
+    expect(render(response({ kueue: { phase: 'pending', admission: { state: 'insufficient_quota', attention: 'waiting' } } }))).not.toContain('ask an admin')
+  })
+
+  it('quietly marks a stale primary condition under a current classification', () => {
+    const html = render(response({ primaryCondition: { type: 'QuotaReserved', status: 'False', reason: 'Pending', message: 'old', observedGeneration: 1 }, kueue: { phase: 'pending', admission: { state: 'requeue_backoff', attention: 'waiting', blocker: { code: 'requeue_backoff', source: 'condition', name: 'Requeued', reason: 'PodsReadyTimeout' } } } }))
+    expect(html).toContain('The condition in Technical details was reported before')
+    expect(html).not.toContain('Stale evidence')
+  })
+
+  it('keeps the generic qualifier when an older Radar sends no admission state', () => {
+    expect(render(response({ decision: 'unknown', kueue: { phase: 'pending' } }))).toContain('Admission unknown')
+  })
+
   it('keeps disruptions, inactive state, check retries and requeues distinct', () => {
     const html = render(response({ decision: 'held', kueue: { phase: 'pending', active: false, requeueState: { count: 0, requeueAt: '2026-09-22T00:00:00Z' } }, disruptions: [{ type: 'Evicted', status: 'True', reason: 'Preempted' }], gates: [{ kind: 'preemption_gate', name: 'gate', decision: 'unsatisfied', retryCount: 0, requeueAfterSeconds: 0 }] }))
     expect(html).toContain('Workload inactive')

package/src/components/resources/KueueAdmissionSection.tsx

@@ -1,10 +1,10 @@
-import { admissionCheckSeverity, isKueueConditionStale } from './resource-utils-kueue'
+import { admissionCheckSeverity, isKueueConditionStale, kueueAdmissionStateHint, kueueAdmissionStatePresentation } from './resource-utils-kueue'
 import { Disclosure } from '../ui/Disclosure'
 import { formatRelativeAgeTime } from '../../utils/format'
 import { Badge } from '../ui/Badge'
 import { AlertBanner, ResourceLink, Section } from '../ui/drawer-components'
 import { kindToPluralWithGroup } from '../../utils/navigation'
-import type { KueueAdmissionResponse, SchedulingCondition, SchedulingObservation, SchedulingRef } from '../../types/scheduling'
+import type { KueueAdmissionResponse, KueueAdmissionWorkload, SchedulingCondition, SchedulingObservation, SchedulingRef } from '../../types/scheduling'
 
 interface KueueAdmissionSectionProps {
   presentation?: 'card' | 'drawer'
@@ -17,11 +17,14 @@ interface KueueAdmissionSectionProps {
   hasOwner?: boolean
   onRetry?: () => void
   onNavigate?: (ref: { kind: string; namespace: string; name: string; group?: string }) => void
+  /** Host-supplied extra content for one Workload, e.g. Kueue's reported queue position. */
+  renderWorkloadExtra?: (workload: KueueAdmissionWorkload) => React.ReactNode
 }
 
 const phases = { pending: 'Pending admission', quota_reserved: 'Quota reserved', admitted: 'Admitted', finished: 'Finished' }
+const phaseStates = new Set(['admitted', 'quota_reserved', 'finished'])
 
-export function KueueAdmissionSection({ presentation = 'card', data, loading, error, forbidden, hinted, externalExecution, hasOwner, onRetry, onNavigate }: KueueAdmissionSectionProps) {
+export function KueueAdmissionSection({ presentation = 'card', data, loading, error, forbidden, hinted, externalExecution, hasOwner, onRetry, onNavigate, renderWorkloadExtra }: KueueAdmissionSectionProps) {
   if (!loading && !error && data && data.workloads.length === 0 && !hinted) return null
   const link = (name: string, ref?: SchedulingRef) => ref
     ? <ResourceLink {...ref} kind={kindToPluralWithGroup(ref.kind, ref.group ?? '')} label={name} onNavigate={onNavigate} />
@@ -40,6 +43,7 @@ export function KueueAdmissionSection({ presentation = 'card', data, loading, er
                   {workload.projection === 'unsupported' ? <p className="text-theme-text-secondary">Associated Workload found. Scheduling projection is unavailable for {workload.apiVersion}; inspect the resource for native evidence.</p>
                     : workload.projection === 'forbidden' ? <p className="text-theme-text-secondary">Associated Workload found, but permission to get this Workload is required for its scheduling detail.</p>
                       : workload.scheduling?.observations?.map((observation, index) => <AdmissionObservation key={index} presentation={presentation} observation={observation} identity={link(workload.name, workload.ref)} sourceLink={workload.ref && onNavigate ? link("View Workload details", workload.ref) : undefined} generation={workload.generation} deleting={workload.deleting} link={link} />)}
+                  {renderWorkloadExtra?.(workload)}
                   {workload.linksLimited && <p className="text-xs text-theme-text-tertiary">Some resource links are unavailable. Names already reported by the Workload remain visible.</p>}
                 </article>)}
               </div>}
@@ -95,7 +99,10 @@ function GateEvidence({ gate, link }: { gate: Gate; link: Link }) {
 function AdmissionObservation({ observation, identity, sourceLink, generation, deleting, presentation, link }: { observation: SchedulingObservation; identity: React.ReactNode; sourceLink?: React.ReactNode; generation: number; deleting: boolean; presentation: 'card' | 'drawer'; link: Link }) {
   const kueue = observation.kueue
   const condition = observation.primaryCondition
-  const stale = isKueueConditionStale(condition, observation.subjectGeneration)
+  const admission = kueue?.admission
+  // The server decides staleness from the evidence behind the state; an
+  // older Radar sends no admission block, so fall back to the condition.
+  const stale = admission ? !!admission.stale : isKueueConditionStale(condition, observation.subjectGeneration)
   const secondary = [...(observation.disruptions ?? []), kueue?.podsReady, kueue?.waitingForReplacementPods]
     .filter((entry) => entry != null)
     .filter((entry) => entry.type !== condition?.type)
@@ -113,8 +120,29 @@ function AdmissionObservation({ observation, identity, sourceLink, generation, d
   const split = presentation === 'card' && (visible.length > 0 || preemption.length > 0)
   const severity = stale || observation.decision === 'unknown' ? 'neutral'
     : kueue?.phase === 'finished' ? kueue.outcome === 'failed' ? 'error' : kueue.outcome === 'succeeded' ? 'success' : 'neutral'
-      : observation.decision === 'satisfied' ? 'success' : 'warning'
-  const qualifier = observation.decision === 'held' && kueue?.active !== false ? 'Admission held' : observation.decision === 'unknown' ? 'Admission unknown' : null
+      // With a classification, the state badge carries the tone unless the
+      // state is the phase itself.
+      : admission ? admission.state === 'admitted' ? 'success' : 'neutral'
+        : observation.decision === 'satisfied' ? 'success' : 'warning'
+  // The phase badge already says these states. A withdrawn Workload is not
+  // waiting, so its state replaces the pending phase rather than following it;
+  // one still admitted keeps its phase until it releases the quota.
+  // An unclassified reason the primary condition already states adds nothing.
+  const restatesPrimary = admission?.state === 'unrecognized' && admission.blocker?.reason === condition?.reason
+  const reason = admission && !phaseStates.has(admission.state) && !restatesPrimary ? kueueAdmissionStatePresentation(admission) : null
+  const withdrawn = !!admission?.inactive && kueue?.phase === 'pending'
+  // An unrecognized reason is Kueue's own word; say that rather than Radar's.
+  // Kueue's coarse reasons (Pending, Inadmissible) repeat what the phase and
+  // the primary condition already say, so name only a reason that adds to it.
+  const unrecognizedReason = admission?.state === 'unrecognized' && admission.blocker?.reason !== condition?.reason ? admission.blocker?.reason : undefined
+  const hint = admission && !admission.stale ? kueueAdmissionStateHint(admission) : undefined
+  // Show the condition behind the state when nothing else on the card says
+  // it: backoff or Kueue's deactivation cause. Checks have their own card.
+  const decidingFact = admission && [admission.inactive, admission.blocker, admission.disruption].find((fact) => fact?.code === admission.state)
+  const factEvidence = reason && decidingFact?.source === 'condition' && decidingFact.name !== condition?.type &&
+    !observation.disruptions?.some((entry) => entry.type === decidingFact.name)
+    ? decidingFact : undefined
+  const qualifier = admission ? null : observation.decision === 'held' && kueue?.active !== false ? 'Admission held' : observation.decision === 'unknown' ? 'Admission unknown' : null
   return <div className="@container/admission space-y-4">
     <div className={split ? 'grid min-w-0 items-start gap-4 @min-[1024px]/admission:grid-cols-[minmax(0,1.7fr)_minmax(320px,0.9fr)]' : 'space-y-4'}>
     <div className="min-w-0 space-y-4">
@@ -123,15 +151,26 @@ function AdmissionObservation({ observation, identity, sourceLink, generation, d
       <div className="space-y-2 p-3">
       <div className="flex flex-wrap items-center gap-2">
         <span className="font-medium break-all">{identity}</span>
-        <Badge severity={severity}>{kueue ? phases[kueue.phase] : 'Admission'}</Badge>
+        {!withdrawn && <Badge severity={severity}>{kueue ? phases[kueue.phase] : 'Admission'}</Badge>}
+        {reason && <Badge severity={reason.severity}>{unrecognizedReason ? <>Kueue: <code>{unrecognizedReason}</code></> : reason.label}</Badge>}
         {qualifier && <span className="text-xs text-theme-text-secondary">{qualifier}</span>}
-        {kueue?.active === false && <Badge severity="neutral">Workload inactive</Badge>}
+        {!admission && kueue?.active === false && <Badge severity="neutral">Workload inactive</Badge>}
         {deleting && <Badge severity="alert">Deleting</Badge>}
         {kueue?.outcome && <span>Outcome: {kueue.outcome}</span>}
       </div>
-        {stale && <p className="text-xs text-warning-text">Stale evidence: condition generation {condition!.observedGeneration}; Workload generation {observation.subjectGeneration}.</p>}
-        {condition ? <p className="max-w-3xl whitespace-pre-wrap break-words">{condition.message || <><code>{condition.reason}</code>{condition.reason && ' · '}{condition.type}={condition.status}</>}</p> : <p className="text-theme-text-secondary">No primary admission condition reported.</p>}
-        {condition?.lastTransitionTime && <p className="text-xs text-theme-text-tertiary">{condition.type}={condition.status} since {formatRelativeAgeTime(condition.lastTransitionTime)}</p>}
+        {stale && (admission
+          ? <p className={`text-xs ${reason ? 'text-warning-text' : 'text-theme-text-tertiary'}`}>Reported before the Workload's spec last changed; it may not reflect the current spec.</p>
+          : <p className="text-xs text-warning-text">Stale evidence: condition generation {condition!.observedGeneration}; Workload generation {observation.subjectGeneration}.</p>)}
+        {admission && !stale && isKueueConditionStale(condition, observation.subjectGeneration) && <p className="text-xs text-theme-text-tertiary">The {factEvidence ? 'condition in Technical details' : 'condition below'} was reported before the Workload's spec last changed.</p>}
+        {hint && <p className="max-w-3xl text-xs text-theme-text-secondary">{hint}</p>}
+        {factEvidence ? <>
+          <p className="max-w-3xl whitespace-pre-wrap break-words">{factEvidence.name}{factEvidence.reason && ` · ${factEvidence.reason}`}{factEvidence.message && `: ${factEvidence.message}`}</p>
+          {factEvidence.since && <p className="text-xs text-theme-text-tertiary">{factEvidence.name} since <time dateTime={factEvidence.since} title={factEvidence.since}>{formatRelativeAgeTime(factEvidence.since)}</time></p>}
+          {factEvidence.stale && <p className="text-xs text-theme-text-tertiary">This reported cause predates the Workload's current spec.</p>}
+        </> : <>
+          {condition ? <p className="max-w-3xl whitespace-pre-wrap break-words">{condition.message || <><code>{condition.reason}</code>{condition.reason && ' · '}{condition.type}={condition.status}</>}</p> : <p className="text-theme-text-secondary">No primary admission condition reported.</p>}
+          {condition?.lastTransitionTime && <p className="text-xs text-theme-text-tertiary">{condition.type}={condition.status} since {formatRelativeAgeTime(condition.lastTransitionTime)}</p>}
+        </>}
       <div className="empty:hidden flex flex-wrap gap-x-5 gap-y-2 border-t border-theme-border pt-2 text-xs text-theme-text-secondary">
       {sourceLink && <span>{sourceLink}</span>}
       {(!!observation.queues?.length || kueue?.concurrentAdmission) && <div className="flex flex-wrap gap-x-5 gap-y-1 text-xs text-theme-text-secondary">
@@ -148,7 +187,7 @@ function AdmissionObservation({ observation, identity, sourceLink, generation, d
         <p>Decision: {observation.decision} · Generation {generation}</p>
         {[condition, ...secondary].filter((entry) => entry != null).map((entry) => <div key={entry.type}>
           <p>{entry.type}={entry.status}{entry.reason && ` · Reason: ${entry.reason}`}{entry.observedGeneration != null && ` · Observed generation ${entry.observedGeneration}`}{entry.lastTransitionTime && ` · Status since ${formatRelativeAgeTime(entry.lastTransitionTime)}`}</p>
-          {supporting.includes(entry) && entry.message && <p className="whitespace-pre-wrap break-words">{entry.message}</p>}
+          {(supporting.includes(entry) || (factEvidence && entry === condition && entry.message !== factEvidence.message)) && entry.message && <p className="whitespace-pre-wrap break-words">{entry.message}</p>}
         </div>)}
         {(observation.gates ?? []).filter((gate) => gate.retryCount === 0 || gate.requeueAfterSeconds === 0).map((gate, index) => <p key={index}>{gate.kind === 'preemption_gate' ? 'Preemption gate' : 'Admission check'} {gate.name}{gate.retryCount === 0 && ' · Retries: 0'}{gate.requeueAfterSeconds === 0 && ' · Requeue delay: 0s'}</p>)}
         {kueue?.requeueState?.count === 0 && !kueue.requeueState.requeueAt && <p>Requeues: 0</p>}

package/src/components/resources/KueuePendingPosition.test.tsx

@@ -0,0 +1,97 @@
+// @vitest-environment jsdom
+import { renderToStaticMarkup } from 'react-dom/server'
+import { describe, expect, it } from 'vitest'
+import { KueuePendingPositionValue } from './KueuePendingPosition'
+import { KueueAdmissionSection } from './KueueAdmissionSection'
+import { KueueWorkloadRenderer } from './renderers/KueueWorkloadRenderer'
+import type { KueuePendingPosition } from '../../types/scheduling'
+
+const readAt = new Date(Date.now() - 12_000).toISOString()
+const text = (position?: KueuePendingPosition, props: Partial<React.ComponentProps<typeof KueuePendingPositionValue>> = {}) => {
+  const node = document.createElement('div')
+  node.innerHTML = renderToStaticMarkup(<KueuePendingPositionValue position={position} {...props} />)
+  return node.textContent ?? ''
+}
+
+describe('KueuePendingPositionValue', () => {
+  it('shows Kueue\'s 0-based ahead counts as 1-based places, with the read time and what it is not', () => {
+    const out = text({ status: 'listed', aheadInLocalQueue: 1, aheadInClusterQueue: 2, localQueue: 'pos', readAt })
+    expect(out).toContain('#2 in LocalQueue pos · #3 in its ClusterQueue')
+    expect(out).toContain('12s ago')
+    expect(out).toContain('Not a promise of admission order or a start time')
+  })
+
+  it('says when Kueue holds a ranked Workload back from retrying', () => {
+    const later = new Date(Date.now() + 600_000).toISOString()
+    expect(text({ status: 'listed', aheadInLocalQueue: 0, aheadInClusterQueue: 0, localQueue: 'pos', readAt }, { requeueAt: later })).toContain("won't try to admit it again before")
+    const earlier = new Date(Date.now() - 600_000).toISOString()
+    expect(text({ status: 'listed', aheadInLocalQueue: 0, aheadInClusterQueue: 0, localQueue: 'pos', readAt }, { requeueAt: earlier })).not.toContain("won't try")
+  })
+
+  it('never words an absent row as not pending', () => {
+    const out = text({ status: 'not_listed', localQueue: 'pos', rows: 0, rowLimit: 1000, readAt })
+    expect(out).toContain("Not in Kueue's pending list for LocalQueue pos")
+    expect(out).not.toMatch(/not pending/i)
+  })
+
+  it('claims no bound when Kueue returned a full page without the Workload', () => {
+    const out = text({ status: 'limit_reached', localQueue: 'pos', rows: 1000, rowLimit: 1000, readAt })
+    expect(out).toContain('Not among the first 1,000 Workloads Kueue listed for LocalQueue pos')
+    expect(out).toContain('Its position is unknown')
+  })
+
+  it('says why there is no position', () => {
+    expect(text({ status: 'not_served' })).toContain("didn't find Kueue's visibility API")
+    expect(text({ status: 'no_local_queue' })).toContain('No LocalQueue named')
+    expect(text({ status: 'queue_unknown', message: "Kueue doesn't know LocalQueue x in namespace y." })).toContain("Kueue doesn't know LocalQueue x")
+    expect(text({ status: 'unsupported', message: 'Kueue serves its visibility API at [v1alpha1]; Radar reads v1beta2 and v1beta1.' })).toContain('v1alpha1')
+    const denied = text({ status: 'unavailable', code: 'user_forbidden', message: "Your Kubernetes access doesn't allow this. Reading Kueue's pending order needs get on localqueues/pendingworkloads (visibility.kueue.x-k8s.io) in namespace ml." })
+    expect(denied).toContain('localqueues/pendingworkloads')
+    expect(denied).not.toContain('Retry')
+  })
+
+  it('offers a retry only where a retry can help', () => {
+    const retry = () => {}
+    expect(renderToStaticMarkup(<KueuePendingPositionValue position={{ status: 'unavailable', code: 'read_error', message: "Kueue's visibility server isn't available." }} onRetry={retry} />)).toContain('Retry')
+    expect(renderToStaticMarkup(<KueuePendingPositionValue position={{ status: 'unavailable', code: 'radar_forbidden', message: 'no' }} onRetry={retry} />)).not.toContain('Retry')
+    expect(renderToStaticMarkup(<KueuePendingPositionValue position={{ status: 'not_served' }} onRetry={retry} />)).toContain('Check again')
+  })
+
+  it('keeps the last answer visible but marked when a refresh failed', () => {
+    const out = text({ status: 'listed', aheadInLocalQueue: 0, aheadInClusterQueue: 0, localQueue: 'pos', readAt }, { refreshFailed: true })
+    expect(out).toContain('#1 in LocalQueue pos')
+    expect(out).toContain("Couldn't refresh · last read 12s ago")
+    expect(out).not.toContain("Kueue's pending order, read")
+  })
+
+  it('renders loading, request failure, an older Radar and unknown statuses honestly', () => {
+    expect(text(undefined, { loading: true })).toContain('Asking Kueue')
+    expect(text(undefined, { error: 'boom' })).toContain("Couldn't ask Kueue: boom")
+    expect(text(undefined, { upgrade: { feature: 'Kueue queue positions' } })).toContain('Kueue queue positions')
+    expect(text({ status: 'something_new' })).toContain('something_new')
+  })
+})
+
+describe('position slots', () => {
+  it('the Workload renderer shows a supplied position in its Admission section', () => {
+    const html = renderToStaticMarkup(<KueueWorkloadRenderer data={{ metadata: { name: 'w', namespace: 'ml' }, spec: { queueName: 'pos' } }} pendingPosition={<span>POSITION</span>} />)
+    expect(html).toContain('Queue Position')
+    expect(html).toContain('POSITION')
+    expect(renderToStaticMarkup(<KueueWorkloadRenderer data={{ metadata: { name: 'w', namespace: 'ml' }, spec: { queueName: 'pos' } }} />)).not.toContain('Queue Position')
+  })
+
+  it('the admission section renders host content per Workload', () => {
+    const ref = { kind: 'Workload', group: 'kueue.x-k8s.io', namespace: 'ml', name: 'w' }
+    const html = renderToStaticMarkup(<KueueAdmissionSection loading={false} hinted={false} externalExecution={false} data={{ uid: 'r', installed: true, total: 1, truncated: false, workloads: [{
+      apiVersion: 'kueue.x-k8s.io/v1beta2', name: 'w', namespace: 'ml', uid: 'wl', generation: 1, createdAt: null, deleting: false, ref, projection: 'available', linksLimited: false,
+      scheduling: { observations: [{ source: 'kueue', domain: 'admission', subject: ref, decision: 'unsatisfied', kueue: { phase: 'pending' } }] },
+    }] }} renderWorkloadExtra={(workload) => <span>EXTRA {workload.uid}</span>} />)
+    expect(html).toContain('EXTRA wl')
+  })
+  it('marks a retained unknown queue answer when a later refresh fails', () => {
+    const html = renderToStaticMarkup(<KueuePendingPositionValue position={{ status: 'queue_unknown', localQueue: 'q', readAt: '2026-11-03T01:00:00Z' }} refreshFailed />)
+    expect(html).toContain("Kueue doesn&#x27;t know LocalQueue")
+    expect(html).toContain("Couldn&#x27;t refresh")
+  })
+
+})

package/src/components/resources/KueuePendingPosition.tsx

@@ -0,0 +1,91 @@
+import { useEffect, useState } from 'react'
+import type { KueuePendingPosition } from '../../types/scheduling'
+import type { RadarUpgradeRequirement } from '../../types/fetch-error'
+import { RadarUpgradeNote } from '../ui/RadarUpgradeNote'
+import { formatRelativeAgeTime } from '../../utils/format'
+import { readActionFor } from '../../utils/read-actions'
+
+export interface KueuePendingPositionValueProps {
+  position?: KueuePendingPosition
+  loading?: boolean
+  /** The request failed and there is no answer to show. */
+  error?: string
+  /** The last refresh failed; the answer shown is from an earlier read. */
+  refreshFailed?: boolean
+  /** The connected Radar predates the position endpoint. */
+  upgrade?: RadarUpgradeRequirement
+  onRetry?: () => void
+  /** The Workload's status.requeueState.requeueAt: Kueue keeps a ranked Workload back until then. */
+  requeueAt?: string
+}
+
+function ReadAge({ readAt }: { readAt?: string }) {
+  const [, tick] = useState(0)
+  useEffect(() => {
+    if (!readAt) return
+    const id = setInterval(() => tick(n => n + 1), 15_000)
+    return () => clearInterval(id)
+  }, [readAt])
+  if (!readAt) return null
+  return <time dateTime={readAt} title={readAt}>{formatRelativeAgeTime(readAt)}</time>
+}
+
+function Retry({ onRetry, label = 'Retry' }: { onRetry?: () => void; label?: string }) {
+  if (!onRetry) return null
+  return <button type="button" className="ml-1 text-accent-text hover:underline" onClick={onRetry}>{label}</button>
+}
+
+/**
+ * One Workload's position as Kueue's visibility API reported it, or why
+ * there is none. Radar never derives a position; every state says what Kueue
+ * answered, when, or why it couldn't be asked.
+ */
+export function KueuePendingPositionValue({ position, loading, error, refreshFailed, upgrade, onRetry, requeueAt }: KueuePendingPositionValueProps) {
+  if (upgrade) return <RadarUpgradeNote requirement={upgrade} />
+  if (!position) {
+    if (error) return <span className="text-theme-text-secondary">Couldn't ask Kueue: {error}<Retry onRetry={onRetry} /></span>
+    return <span className="text-theme-text-tertiary">{loading ? 'Asking Kueue…' : 'Waiting for a current answer'}</span>
+  }
+  const queue = position.localQueue ? <span className="font-medium">{position.localQueue}</span> : 'its LocalQueue'
+  const caption = (text: React.ReactNode) => <span className="mt-0.5 block text-xs text-theme-text-tertiary">{text}</span>
+  const stale = refreshFailed && caption(<>Couldn't refresh{position.readAt && <> · last read <ReadAge readAt={position.readAt} /></>}<Retry onRetry={onRetry} /></>)
+  const content = (() => {
+    switch (position.status) {
+      case 'listed':
+        return <span>
+          <span className="text-theme-text-primary">
+            #{position.aheadInLocalQueue! + 1} in LocalQueue {queue}
+            {' · #'}{position.aheadInClusterQueue! + 1} in its ClusterQueue
+          </span>
+          {caption(<>Kueue's pending order{!refreshFailed && <>, read <ReadAge readAt={position.readAt} /></>}. Not a promise of admission order or a start time.</>)}
+          {requeueAt && Date.parse(requeueAt) > Date.now() && caption(<>Kueue won't try to admit it again before <time dateTime={requeueAt} title={requeueAt}>{new Date(requeueAt).toLocaleString()}</time>.</>)}
+        </span>
+      case 'not_listed':
+        return <span>
+          <span className="text-theme-text-secondary">Not in Kueue's pending list for LocalQueue {queue}</span>
+          {caption(<>{!refreshFailed && <>Read <ReadAge readAt={position.readAt} />. </>}It may have been admitted or deactivated since, or Kueue hasn't picked it up yet.</>)}
+        </span>
+      case 'limit_reached':
+        return <span>
+          <span className="text-theme-text-secondary">Not among the first {position.rows!.toLocaleString()} Workloads Kueue listed for LocalQueue {queue}</span>
+          {caption(<>{!refreshFailed && <>Read <ReadAge readAt={position.readAt} />. </>}Its position is unknown.</>)}
+        </span>
+      case 'queue_unknown':
+        return <span className="text-theme-text-secondary">{position.message || <>Kueue doesn't know LocalQueue {queue}.</>}<Retry onRetry={onRetry} /></span>
+      case 'no_local_queue':
+        return <span className="text-theme-text-tertiary">No LocalQueue named, so Kueue holds no position for it.</span>
+      case 'not_served':
+        return <span className="text-theme-text-tertiary">Radar's API discovery didn't find Kueue's visibility API (visibility.kueue.x-k8s.io).<Retry onRetry={onRetry} label="Check again" /></span>
+      case 'unsupported':
+        return <span className="text-theme-text-tertiary">{position.message || "Kueue serves its visibility API only at versions Radar doesn't read."}</span>
+      case 'unavailable':
+        return <span className="text-theme-text-secondary">
+          {position.message || "Radar couldn't get Kueue's answer."}
+          {readActionFor(position.code) === 'retry' && <Retry onRetry={onRetry} />}
+        </span>
+      default:
+        return <span className="text-theme-text-tertiary">Radar reported a position status this view doesn't know: {position.status}</span>
+    }
+  })()
+  return <span>{content}{stale}</span>
+}

package/src/components/resources/ResourcesSidebar.test.tsx

@@ -264,3 +264,11 @@ it('bounds a category total over kinds Radar collects in only some namespaces',
   // Each kind is exact where Radar collects it; their sum is exact for no scope.
   expect(html.slice(start, html.indexOf('</button>', start))).toContain('≥5')
 })
+
+it('matches CRD aliases only for the definition API identity', () => {
+  const crd = { group: 'apiextensions.k8s.io', kind: 'CustomResourceDefinition', name: 'customresourcedefinitions' }
+  expect(resourceMatchesSidebarFilter(crd, 'crd')).toBe(true)
+  expect(resourceMatchesSidebarFilter(crd, 'CRDS')).toBe(true)
+  expect(resourceMatchesSidebarFilter(horizontalPodAutoscaler, 'crd')).toBe(false)
+  expect(resourceMatchesSidebarFilter({ ...crd, group: 'other.io' }, 'crd')).toBe(false)
+})

package/src/components/resources/ResourcesSidebar.tsx

@@ -12,7 +12,7 @@ import {
 import { clsx } from 'clsx'
 import { Collapse, CollapseChevron, useDisclosure, disclosurePanelId } from '../ui/Collapse'
 import type { APIResource } from '../../types'
-import { categorizeResources, CORE_RESOURCES } from '../../utils/api-resources'
+import { categorizeResources, CORE_RESOURCES, resourceSearchAliases } from '../../utils/api-resources'
 import { getResourceIcon } from '../../utils/resource-icons'
 import { Tooltip } from '../ui/Tooltip'
 import { certaintyGlyph } from '../facts'
@@ -138,7 +138,8 @@ export function resourceMatchesSidebarFilter(resource: Pick<APIResource, 'kind'
   if (!normalized) return true
   return resource.kind.toLowerCase().includes(normalized) ||
     resource.name.toLowerCase().includes(normalized) ||
-    resource.group.toLowerCase().includes(normalized)
+    resource.group.toLowerCase().includes(normalized) ||
+    resourceSearchAliases(resource).some(alias => alias.includes(normalized))
 }
 
 export function rawCRDGroupTitle(resources: Pick<APIResource, 'group' | 'isCrd'>[]): string | undefined {

package/src/components/resources/ResourcesView.crd.test.tsx

@@ -0,0 +1,28 @@
+// @vitest-environment jsdom
+import { act } from 'react'
+import { createRoot } from 'react-dom/client'
+import { VirtuosoMockContext } from 'react-virtuoso'
+import { afterEach, expect, it, vi } from 'vitest'
+import { ResourcesView } from './ResourcesView'
+import { KeyboardShortcutProvider } from '../../hooks/useKeyboardShortcuts'
+import type { APIResource } from '../../types'
+
+;(globalThis as any).IS_REACT_ACT_ENVIRONMENT = true
+window.matchMedia = vi.fn().mockReturnValue({ matches: false, addEventListener: vi.fn(), removeEventListener: vi.fn() })
+Element.prototype.scrollIntoView = vi.fn()
+let root: ReturnType<typeof createRoot>
+let host: HTMLDivElement
+afterEach(() => { act(() => root?.unmount()); host?.remove(); localStorage.clear() })
+
+it('shows definition columns and only served versions, marking deprecated ones', async () => {
+  host = document.createElement('div'); document.body.append(host); root = createRoot(host)
+  const kind: APIResource = { group: 'apiextensions.k8s.io', version: 'v1', kind: 'CustomResourceDefinition', name: 'customresourcedefinitions', namespaced: false, isCrd: false, verbs: ['get', 'list'] }
+  const data = { apiVersion: 'apiextensions.k8s.io/v1', kind: 'CustomResourceDefinition', metadata: { name: 'widgets.example.io' }, spec: { group: 'example.io', names: { kind: 'Widget' }, scope: 'Namespaced', versions: [{ name: 'v1', served: true, storage: true }, { name: 'v1beta1', served: true, deprecated: true }, { name: 'v1alpha1', served: false }] }, status: { conditions: [{ type: 'Established', status: 'True' }] } }
+  await act(async () => root.render(<VirtuosoMockContext.Provider value={{ viewportHeight: 600, itemHeight: 48 }}><KeyboardShortcutProvider><ResourcesView namespaces={[]} apiResources={[kind]} resourceCounts={{ CustomResourceDefinition: 1 }} selectedKindQuery={{ isLoading: false, data: [data], resourceName: kind.name, group: kind.group }} locationPathname="/resources/customresourcedefinitions" locationSearch="?apiGroup=apiextensions.k8s.io" onNavigate={() => {}} /></KeyboardShortcutProvider></VirtuosoMockContext.Provider>))
+  const table = host.querySelector('table')!
+  expect(table).not.toBeNull()
+  for (const text of ['Name', 'Kind', 'Scope', 'Served Versions', 'Status', 'Age', 'Widget', 'Namespaced', 'deprecated', 'Established']) expect(table.textContent).toContain(text)
+  expect(table.textContent).not.toContain('storage')
+  expect(table.textContent).not.toContain('v1alpha1')
+  expect(Array.from(table.querySelectorAll('th')).map(th => th.textContent).join(',')).not.toContain('Namespace')
+})

package/src/components/resources/ResourcesView.node-pods.test.tsx

@@ -0,0 +1,25 @@
+// @vitest-environment jsdom
+import { act } from 'react'
+import { createRoot } from 'react-dom/client'
+import { VirtuosoMockContext } from 'react-virtuoso'
+import { afterEach, expect, it, vi } from 'vitest'
+import { ResourcesView } from './ResourcesView'
+import { KeyboardShortcutProvider } from '../../hooks/useKeyboardShortcuts'
+import type { APIResource } from '../../types'
+
+;(globalThis as any).IS_REACT_ACT_ENVIRONMENT = true
+window.matchMedia = vi.fn().mockReturnValue({ matches: false, addEventListener: vi.fn(), removeEventListener: vi.fn() })
+Element.prototype.scrollIntoView = vi.fn()
+let root: ReturnType<typeof createRoot>
+let host: HTMLDivElement
+afterEach(() => { act(() => root?.unmount()); host?.remove(); localStorage.clear() })
+
+it('shows an unknown Pod count, not zero, when node metrics are not loaded', async () => {
+  host = document.createElement('div'); document.body.append(host); root = createRoot(host)
+  const kind: APIResource = { group: '', version: 'v1', kind: 'Node', name: 'nodes', namespaced: false, isCrd: false, verbs: ['get', 'list'] }
+  const node = { apiVersion: 'v1', kind: 'Node', metadata: { name: 'gpu-a100-1', uid: 'n1' }, status: { allocatable: { pods: '110', cpu: '96', memory: '1100Gi' }, conditions: [{ type: 'Ready', status: 'True' }] } }
+  await act(async () => root.render(<VirtuosoMockContext.Provider value={{ viewportHeight: 600, itemHeight: 48 }}><KeyboardShortcutProvider><ResourcesView namespaces={['ml-research']} apiResources={[kind]} resourceCounts={{ Node: 1 }} selectedKindQuery={{ isLoading: false, data: [node], resourceName: kind.name, group: kind.group }} locationPathname="/resources/nodes" locationSearch="" onNavigate={() => {}} /></KeyboardShortcutProvider></VirtuosoMockContext.Provider>))
+  const table = host.querySelector('table')!
+  expect(table.textContent).toContain('gpu-a100-1')
+  expect(table.textContent).not.toContain('0 / 110')
+})

package/src/components/resources/ResourcesView.strimzi.test.tsx

@@ -0,0 +1,37 @@
+// @vitest-environment jsdom
+import { act } from 'react'
+import { createRoot } from 'react-dom/client'
+import { VirtuosoMockContext } from 'react-virtuoso'
+import { afterEach, expect, it, vi } from 'vitest'
+import { ResourcesView } from './ResourcesView'
+import { KeyboardShortcutProvider } from '../../hooks/useKeyboardShortcuts'
+import type { APIResource } from '../../types'
+import cases from '../../../../../testdata/strimzi/connector-status.json'
+import { getCellFilterValue } from './resource-utils'
+
+;(globalThis as any).IS_REACT_ACT_ENVIRONMENT = true
+window.matchMedia = vi.fn().mockReturnValue({ matches: false, addEventListener: vi.fn(), removeEventListener: vi.fn() })
+Element.prototype.scrollIntoView = vi.fn()
+let root: ReturnType<typeof createRoot>
+let host: HTMLDivElement
+afterEach(() => { act(() => root?.unmount()); host?.remove(); localStorage.clear() })
+
+it('replaces the native Ready printer column with task-aware snapshot status', async () => {
+  host = document.createElement('div'); document.body.append(host); root = createRoot(host)
+  const kind: APIResource = { group: 'kafka.strimzi.io', version: 'v1', kind: 'KafkaConnector', name: 'kafkaconnectors', namespaced: true, isCrd: true, verbs: ['get', 'list'] }
+  const data = {...cases[1].resource, metadata: {...cases[1].resource.metadata, uid: 'fixture'}}
+  const second = {...data, metadata:{...data.metadata,name:'zzz',uid:'second'},spec:{...data.spec,class:'AConnector'},status:{...data.status,connectorStatus:{...data.status.connectorStatus,tasks:Array.from({length:10},(_,id)=>({id,state:'RUNNING'}))}}}
+  await act(async () => root.render(<VirtuosoMockContext.Provider value={{ viewportHeight: 600, itemHeight: 48 }}><KeyboardShortcutProvider><ResourcesView printerTable={{kind:kind.name,group:kind.group,columns:[{name:'Ready',type:'string',jsonPath:'.status.conditions[?(@.type=="Ready")].status'}],cells:{fixture:['True']}}} namespaces={['lab']} apiResources={[kind]} resourceCounts={{ KafkaConnector: 2 }} selectedKindQuery={{ isLoading: false, data: [data,second], resourceName: kind.name, group: kind.group }} locationPathname="/resources/kafkaconnectors" locationSearch="?apiGroup=kafka.strimzi.io" onNavigate={() => {}} /></KeyboardShortcutProvider></VirtuosoMockContext.Provider>))
+  const table = host.querySelector('table')!
+  expect(table).not.toBeNull()
+  expect(table.textContent).toContain('Operator Snapshot')
+  expect(table.textContent).toContain('Tasks failed')
+  expect(table.textContent).not.toContain('Ready')
+  const classHeader = [...table.querySelectorAll('th')].find(th=>th.textContent?.trim()==='Class')!
+  act(() => classHeader.click())
+  expect(table.querySelector('tbody tr')?.textContent).toContain('zzz')
+  const tasksHeader = [...table.querySelectorAll('th')].find(th=>th.textContent?.trim()==='Tasks / Max')!
+  act(() => tasksHeader.click())
+  expect(table.querySelector('tbody tr')?.textContent).toContain('connector')
+  expect(getCellFilterValue(data, 'status', 'kafkaconnectors')).toBe('Tasks failed')
+})