@skyhook-io/k8s-ui 1.14.9 → 1.14.11

package/src/components/resources/renderers/JobSetRenderer.test.tsx

@@ -0,0 +1,280 @@
+import { describe, expect, it } from 'vitest'
+import { renderToString } from 'react-dom/server'
+import { JobSetRenderer, getJobSetConditionTone } from './JobSetRenderer'
+
+function render(data: any): string {
+  return renderToString(<JobSetRenderer data={data} />).replace(/<!-- -->/g, '')
+}
+
+function currentJobSet(): any {
+  return {
+    apiVersion: 'jobset.x-k8s.io/v1alpha2',
+    kind: 'JobSet',
+    metadata: { name: 'training', namespace: 'ml' },
+    spec: {
+      suspend: false,
+      replicatedJobs: [
+        {
+          name: 'leader',
+          groupName: 'control',
+          replicas: 1,
+          template: { spec: { parallelism: 1, completions: 1 } },
+        },
+        {
+          name: 'workers',
+          groupName: 'training',
+          replicas: 3,
+          dependsOn: [{ name: 'leader', status: 'Ready' }],
+          template: {
+            spec: {
+              parallelism: 2,
+              completions: 2,
+              completionMode: 'Indexed',
+              backoffLimit: 1,
+            },
+          },
+        },
+      ],
+      successPolicy: { operator: 'Any', targetReplicatedJobs: ['workers'] },
+      failurePolicy: {
+        maxRestarts: 3,
+        restartStrategy: 'Recreate',
+        rules: [
+          {
+            name: 'restart-workers',
+            action: 'RestartJob',
+            targetReplicatedJobs: ['workers'],
+            onJobFailureReasons: ['BackoffLimitExceeded'],
+            onJobFailureMessagePatterns: ['temporary.*'],
+          },
+        ],
+      },
+      coordinator: { replicatedJob: 'leader', jobIndex: 0, podIndex: 0 },
+      network: {
+        subdomain: 'training-workers',
+        enableDNSHostnames: true,
+        publishNotReadyAddresses: false,
+      },
+    },
+    status: {
+      restarts: 1,
+      restartsCountTowardsMax: 1,
+      replicatedJobsStatus: [
+        {
+          name: 'leader',
+          ready: 1,
+          active: 1,
+          succeeded: 0,
+          failed: 0,
+          suspended: 0,
+          jobRestarts: [0],
+          jobRestartsCountTowardsMax: [0],
+        },
+        {
+          name: 'workers',
+          ready: 2,
+          active: 3,
+          succeeded: 0,
+          failed: 0,
+          suspended: 0,
+          jobRestarts: [0, 1, 0],
+          jobRestartsCountTowardsMax: [0, 1, 0],
+        },
+      ],
+      conditions: [{ type: 'Suspended', status: 'False', reason: 'Resumed' }],
+    },
+  }
+}
+
+describe('JobSetRenderer', () => {
+  it('shows each replicated role without flattening away Job indexes or controller counts', () => {
+    const html = render(currentJobSet())
+
+    expect(html).toContain('Replicated jobs (2)')
+    expect(html).toContain('leader')
+    expect(html).toContain('workers')
+    expect(html).toContain('Group training')
+    expect(html).toContain('0–2')
+    expect(html).toContain('Parallelism / Job')
+    expect(html).toContain('Indexed')
+    expect(html).toContain('Ready</span> <span')
+    expect(html).toContain('>2/3</span>')
+    expect(html).toContain('Starts after')
+    expect(html).toContain('leader · Ready')
+  })
+
+  it('preserves current success and ordered failure-policy semantics', () => {
+    const html = render(currentJobSet())
+
+    expect(html).toContain('Completion and restart policies')
+    expect(html).toContain('Any')
+    expect(html).toContain('across workers')
+    expect(html).toContain('Restart limit')
+    expect(html).toContain('RestartJobSet')
+    expect(html).toContain('1. restart-workers')
+    expect(html).toContain('RestartJob')
+    expect(html).toContain('BackoffLimitExceeded')
+    expect(html).toContain('temporary.*')
+  })
+
+  it('reports native restart counters separately without assuming the RestartJob feature gate', () => {
+    const html = render(currentJobSet())
+
+    expect(html).toContain('Global restarts counted toward limit')
+    expect(html).toContain('Individual restarts counted toward limit')
+    expect(html).toContain('1 (2 of 2 roles reported)')
+    expect(html).not.toContain('Restart budget used')
+  })
+
+  it('distinguishes absent restart observations from a reported zero and partial role coverage', () => {
+    const data = currentJobSet()
+    data.status = {}
+    expect(render(data)).toContain('Not reported')
+    expect(render(data)).not.toContain('0 (2 of 2 roles reported)')
+    data.status = { restarts: 0, replicatedJobsStatus: [{ name: 'leader' }] }
+    expect(render(data)).toContain('0 (1 of 2 roles reported)')
+  })
+
+  it('keeps controller counts separate from the bounded member list and preserves missing status', () => {
+    const data = currentJobSet()
+    data.status.replicatedJobsStatus = [data.status.replicatedJobsStatus[0]]
+    const html = renderToString(<JobSetRenderer data={data} mode="overview" shownMemberCounts={new Map([['workers', 1]])} onSelectRole={() => {}} />).replace(/<!-- -->/g, '')
+    expect(html).toContain('Role progress')
+    expect(html).toContain('leader failed: 0')
+    expect(html).toContain('workers ready: not reported')
+    expect(html).toContain('Status not reported')
+    expect(html).toContain('Inspect members (1 shown)')
+    expect(html).toContain('leader Ready')
+    expect(html).not.toContain('Parallelism / Job')
+  })
+
+  it('explains external ownership without claiming that remote execution succeeded', () => {
+    const data = currentJobSet()
+    data.spec.managedBy = 'kueue.x-k8s.io/multikueue'
+    expect(render(data)).toContain('Execution may occur on another cluster')
+    data.spec.managedBy = 'jobset.sigs.k8s.io/jobset-controller'
+    expect(render(data)).not.toContain('does not create Jobs')
+  })
+
+  it('keeps zero-valued coordinator indexes and explicit network choices visible', () => {
+    const html = render(currentJobSet())
+
+    expect(html).toContain('Coordination and network')
+    expect(html).toContain('Coordinator Job index')
+    expect(html).toContain('Coordinator Pod index')
+    expect(html).toContain('training-workers')
+    expect(html).toContain('Enabled')
+    expect(html).toContain('No')
+  })
+
+  it('does not turn missing role status into zero progress', () => {
+    const data = currentJobSet()
+    data.status.replicatedJobsStatus = []
+    const html = render(data)
+
+    expect(html).toContain('Controller status has not been reported for this role.')
+    expect(html).not.toContain('Ready</span> <span')
+  })
+
+  it('uses the API default of one Job when replicas is omitted and preserves explicit zero', () => {
+    const defaulted = currentJobSet()
+    defaulted.spec.replicatedJobs = [{ name: 'defaulted', template: { spec: {} } }]
+    defaulted.status.replicatedJobsStatus = [{ name: 'defaulted', ready: 1 }]
+    const defaultedHtml = render(defaulted)
+
+    expect(defaultedHtml).toMatch(/Jobs<\/span><span[^>]*>1<\/span>/)
+    expect(defaultedHtml).toMatch(/Job indexes<\/span><span[^>]*>0<\/span>/)
+    expect(defaultedHtml).toContain('>1/1</span>')
+
+    const disabled = currentJobSet()
+    disabled.spec.replicatedJobs = [{ name: 'disabled', replicas: 0, template: { spec: {} } }]
+    disabled.status.replicatedJobsStatus = [{ name: 'disabled', ready: 0 }]
+    const disabledHtml = render(disabled)
+
+    expect(disabledHtml).toMatch(/Jobs<\/span><span[^>]*>0<\/span>/)
+    expect(disabledHtml).toMatch(/Job indexes<\/span><span[^>]*>None<\/span>/)
+    expect(disabledHtml).toContain('>0/0</span>')
+  })
+
+  it("raises only the JobSet controller's own terminal failure", () => {
+    const data = currentJobSet()
+    data.status.terminalState = 'Failed'
+    data.status.conditions = [
+      {
+        type: 'Failed',
+        status: 'True',
+        reason: 'RetriesExhausted',
+        message: 'Global restart limit reached',
+      },
+    ]
+    const html = render(data)
+
+    expect(html).toContain('Issue Detected')
+    expect(html).toContain('Global restart limit reached')
+  })
+
+  it('does not raise a stale failure condition after terminal completion', () => {
+    const data = currentJobSet()
+    data.status.terminalState = 'Completed'
+    data.status.conditions = [{ type: 'Failed', status: 'True', message: 'Stale failure' }]
+    const html = render(data)
+
+    expect(html).toContain('Completed')
+    expect(html).not.toContain('Issue Detected')
+    expect(html).toContain('Stale failure')
+  })
+
+  it('renders safely when the controller has not populated optional fields', () => {
+    const html = render({
+      apiVersion: 'jobset.x-k8s.io/v1alpha2',
+      kind: 'JobSet',
+      metadata: { name: 'new' },
+      spec: {},
+    })
+
+    expect(html).toContain('JobSet status')
+    expect(html).toContain('Unknown')
+    expect(html).not.toContain('Replicated jobs (')
+    expect(html).not.toContain('Coordination and network')
+  })
+})
+
+describe('JobSet condition polarity', () => {
+  it('treats normal incomplete work as unknown rather than failing', () => {
+    expect(getJobSetConditionTone({ type: 'Completed', status: 'False' })).toBe('unknown')
+  })
+
+  it('distinguishes intentional suspension from failure', () => {
+    expect(getJobSetConditionTone({ type: 'Suspended', status: 'True' })).toBe('warning')
+    expect(getJobSetConditionTone({ type: 'Failed', status: 'True' })).toBe('fail')
+  })
+
+  it('does not mark normal restart and startup transitions as failures', () => {
+    expect(getJobSetConditionTone({ type: 'RestartingJobSet', status: 'True' })).toBe('warning')
+    expect(getJobSetConditionTone({ type: 'RestartingJobSet', status: 'False' })).toBe('ok')
+    expect(
+      getJobSetConditionTone({
+        type: 'StartupPolicyInProgress',
+        status: 'True',
+      }),
+    ).toBe('unknown')
+    expect(
+      getJobSetConditionTone({
+        type: 'StartupPolicyInProgress',
+        status: 'False',
+      }),
+    ).toBe('ok')
+    expect(
+      getJobSetConditionTone({
+        type: 'StartupPolicyCompleted',
+        status: 'True',
+      }),
+    ).toBe('ok')
+    expect(
+      getJobSetConditionTone({
+        type: 'StartupPolicyCompleted',
+        status: 'False',
+      }),
+    ).toBe('unknown')
+  })
+})

package/src/components/resources/renderers/JobSetRenderer.tsx

@@ -0,0 +1,322 @@
+import { Activity, Boxes, Network as NetworkIcon, ShieldCheck } from 'lucide-react'
+import {
+  ConditionsSection,
+  ProblemAlerts,
+  Property,
+  PropertyList,
+  Section,
+  type ConditionTone,
+  type Problem,
+} from '../../ui/drawer-components'
+import { Badge } from '../../ui/Badge'
+import { getJobSetStatus } from '../resource-utils-jobset-lws'
+
+interface JobSetRendererProps {
+  data: any
+  mode?: 'detail' | 'overview' | 'configuration'
+  shownMemberCounts?: ReadonlyMap<string, number>
+  onSelectRole?: (role: string) => void
+}
+
+export function getJobSetConditionTone(condition: any): ConditionTone | undefined {
+  if (condition?.status !== 'True' && condition?.status !== 'False') return 'unknown'
+
+  switch (condition.type) {
+    case 'Failed':
+      return condition.status === 'True' ? 'fail' : 'ok'
+    case 'Completed':
+      return condition.status === 'True' ? 'ok' : 'unknown'
+    case 'Suspended':
+      return condition.status === 'True' ? 'warning' : 'ok'
+    case 'RestartingJobSet':
+      return condition.status === 'True' ? 'warning' : 'ok'
+    case 'StartupPolicyInProgress':
+      return condition.status === 'True' ? 'unknown' : 'ok'
+    case 'StartupPolicyCompleted':
+      return condition.status === 'True' ? 'ok' : 'unknown'
+    default:
+      return undefined
+  }
+}
+
+function jobIndexRange(replicas: unknown): string | undefined {
+  if (typeof replicas !== 'number') return undefined
+  if (replicas <= 0) return 'None'
+  return replicas === 1 ? '0' : `0–${replicas - 1}`
+}
+
+function sumCountArray(value: unknown): number | undefined {
+  if (!Array.isArray(value)) return undefined
+  return value.reduce((total: number, count: unknown) => total + (typeof count === 'number' ? count : 0), 0)
+}
+
+export function JobSetRenderer({ data, mode = 'detail', shownMemberCounts, onSelectRole }: JobSetRendererProps) {
+  const spec = data?.spec || {}
+  const status = data?.status || {}
+  const conditions: any[] = Array.isArray(status.conditions) ? status.conditions : []
+  const replicatedJobs: any[] = Array.isArray(spec.replicatedJobs) ? spec.replicatedJobs : []
+  const replicatedJobsStatus: any[] = Array.isArray(status.replicatedJobsStatus) ? status.replicatedJobsStatus : []
+  const statusByName = new Map(replicatedJobsStatus.map((entry) => [entry?.name, entry]))
+  const displayedStatus = getJobSetStatus(data)
+  const failedCondition = conditions.find((condition) => condition?.type === 'Failed' && condition?.status === 'True')
+  const problems: Problem[] =
+    displayedStatus.level === 'unhealthy'
+      ? [
+          {
+            color: 'red',
+            message: failedCondition?.message || failedCondition?.reason || 'The JobSet reached a terminal failed state.',
+          },
+        ]
+      : []
+  const successPolicy = spec.successPolicy
+  const failurePolicy = spec.failurePolicy
+  const failureRules: any[] = Array.isArray(failurePolicy?.rules) ? failurePolicy.rules : []
+  const globalCountedRestarts = status.restartsCountTowardsMax ?? (typeof status.restarts === 'number' ? 0 : undefined)
+  const individualCountedRestarts = Array.isArray(status.replicatedJobsStatus)
+    ? replicatedJobsStatus.reduce((total, entry) => total + (sumCountArray(entry?.jobRestartsCountTowardsMax) ?? 0), 0)
+    : undefined
+  const observedRoles = replicatedJobs.filter((role) => statusByName.has(role.name)).length
+  const externalController = spec.managedBy && spec.managedBy !== 'jobset.sigs.k8s.io/jobset-controller'
+  const showSummary = mode !== 'configuration'
+  const showConfiguration = mode !== 'overview'
+  const coordinator = spec.coordinator
+  const network = spec.network
+
+  return (
+    <>
+      {showSummary && <ProblemAlerts problems={problems} />}
+
+      {showSummary && externalController && (
+        <div className="mb-3 rounded border border-theme-border bg-theme-elevated p-3 text-sm text-theme-text-secondary">
+          Managed by <span className="font-mono">{spec.managedBy}</span>. The built-in JobSet controller does not create Jobs for this resource.
+          {spec.managedBy === 'kueue.x-k8s.io/multikueue' && ' Execution may occur on another cluster; local member absence does not establish remote execution state.'}
+        </div>
+      )}
+
+      {showSummary && <Section title="JobSet status" icon={Activity}>
+        {mode === 'overview' ? (
+          <div className="flex flex-wrap items-center gap-x-5 gap-y-2 text-sm text-theme-text-secondary">
+            <span className={`badge ${displayedStatus.color}`}>{displayedStatus.text}</span>
+            <span>Suspend requested: {spec.suspend ? 'Yes' : 'No'}</span>
+            <span>Global restarts: {status.restarts ?? 'Not reported'}</span>
+            {observedRoles < replicatedJobs.length && <span>Roles reporting status: {observedRoles} of {replicatedJobs.length}</span>}
+          </div>
+        ) : (
+        <PropertyList>
+          <Property label="State" value={<span className={`badge ${displayedStatus.color}`}>{displayedStatus.text}</span>} />
+          <Property label="Terminal state" value={status.terminalState} />
+          <Property label="Global restarts" value={status.restarts} />
+          <Property label="Suspend requested" value={spec.suspend ? 'Yes' : 'No'} />
+          <Property label="Managed by" value={spec.managedBy} />
+          <Property
+            label="Delete after finish"
+            value={spec.ttlSecondsAfterFinished === undefined ? undefined : `${spec.ttlSecondsAfterFinished}s`}
+          />
+        </PropertyList>
+        )}
+      </Section>}
+
+      {mode === 'overview' && replicatedJobs.length > 0 && (
+        <Section title="Role progress" icon={Boxes}>
+          <p className="mb-3 text-xs text-theme-text-secondary">Counts are controller-reported Jobs, not Pods. Active Jobs can have Pending Pods. Dependencies describe startup requirements.</p>
+          <div className="overflow-x-auto">
+            <table className="w-full text-left text-xs">
+              <thead className="text-theme-text-tertiary"><tr>
+                {['Role', 'Declared Jobs', 'Ready', 'Active', 'Succeeded', 'Failed', 'Suspended', 'Starts after', ...(onSelectRole ? ['Members'] : [])].map((label) => <th key={label} className="whitespace-nowrap border-b border-theme-border px-2 py-2 font-medium">{label}</th>)}
+              </tr></thead>
+              <tbody>{replicatedJobs.map((role) => {
+                const observation = statusByName.get(role.name)
+                const shown = shownMemberCounts?.get(role.name) ?? 0
+                return <tr key={role.name} className="border-b border-theme-border-subtle last:border-0">
+                  <th scope="row" className="px-2 py-3 font-medium text-theme-text-primary">{role.name}{!observation && <span className="mt-1 block font-normal text-theme-text-tertiary">Status not reported</span>}</th>
+                  <td className="px-2 py-3">{role.replicas ?? 1}</td>
+                  {['ready', 'active', 'succeeded', 'failed', 'suspended'].map((field) => <td key={field} className="px-2 py-3" aria-label={`${role.name} ${field}: ${observation?.[field] ?? 'not reported'}`}>{observation?.[field] ?? '—'}</td>)}
+                  <td className="px-2 py-3">{role.dependsOn?.map((dependency: any) => `${dependency.name} ${dependency.status}`).join(', ') || 'None'}</td>
+                  {onSelectRole && <td className="px-2 py-3"><button type="button" className="whitespace-nowrap text-accent-text hover:underline" onClick={() => onSelectRole(role.name)}>Inspect members{shown > 0 ? ` (${shown} shown)` : ''}</button></td>}
+                </tr>
+              })}</tbody>
+            </table>
+          </div>
+        </Section>
+      )}
+
+      {mode === 'configuration' && (spec.managedBy || spec.ttlSecondsAfterFinished !== undefined) && (
+        <PropertyList>
+          <Property label="Managed by" value={spec.managedBy} />
+          <Property label="Delete after finish" value={spec.ttlSecondsAfterFinished === undefined ? undefined : `${spec.ttlSecondsAfterFinished}s`} />
+        </PropertyList>
+      )}
+
+      {showConfiguration && replicatedJobs.length > 0 && (
+        <Section title={`Replicated jobs (${replicatedJobs.length})`} icon={Boxes} defaultExpanded={mode === 'detail'}>
+          <div className="space-y-2">
+            {replicatedJobs.map((replicatedJob, index) => {
+              const name = replicatedJob?.name || `Role ${index + 1}`
+              const roleStatus = statusByName.get(replicatedJob?.name)
+              const template = replicatedJob?.template?.spec || {}
+              const dependencies: any[] = Array.isArray(replicatedJob?.dependsOn) ? replicatedJob.dependsOn : []
+              const replicas = replicatedJob?.replicas ?? 1
+              const ready =
+                typeof roleStatus?.ready === 'number' && typeof replicas === 'number'
+                  ? `${roleStatus.ready}/${replicas}`
+                  : roleStatus?.ready
+              const counts = [
+                { label: 'Ready', value: ready },
+                { label: 'Active', value: roleStatus?.active },
+                { label: 'Succeeded', value: roleStatus?.succeeded },
+                { label: 'Failed', value: roleStatus?.failed },
+                { label: 'Suspended', value: roleStatus?.suspended },
+              ].filter((count) => count.value !== undefined && count.value !== null)
+              const jobRestarts = sumCountArray(roleStatus?.jobRestarts)
+
+              return (
+                <div key={`${name}-${index}`} className="card-inner space-y-2">
+                  <div className="flex flex-wrap items-center gap-2">
+                    <span className="font-medium text-theme-text-primary">{name}</span>
+                    {replicatedJob?.groupName && (
+                      <Badge tone="structural" size="sm">
+                        Group {replicatedJob.groupName}
+                      </Badge>
+                    )}
+                  </div>
+
+                  <PropertyList>
+                    <Property label="Jobs" value={replicas} />
+                    <Property label="Job indexes" value={jobIndexRange(replicas)} />
+                    <Property label="Parallelism / Job" value={template.parallelism} />
+                    <Property label="Completions / Job" value={template.completions} />
+                    <Property label="Completion mode" value={template.completionMode} />
+                    <Property label="Backoff limit" value={template.backoffLimit} />
+                    <Property label="Individual restarts" value={jobRestarts} />
+                  </PropertyList>
+
+                  {mode === 'detail' && (counts.length > 0 ? (
+                    <div className="flex flex-wrap gap-x-4 gap-y-1 border-t border-theme-border-subtle pt-2 text-xs text-theme-text-secondary">
+                      {counts.map((count) => (
+                        <span key={count.label}>
+                          <span className="text-theme-text-tertiary">{count.label}</span>{' '}
+                          <span className="font-medium text-theme-text-primary">{String(count.value)}</span>
+                        </span>
+                      ))}
+                    </div>
+                  ) : (
+                    <div className="border-t border-theme-border-subtle pt-2 text-xs text-theme-text-tertiary">
+                      Controller status has not been reported for this role.
+                    </div>
+                  ))}
+
+                  {mode === 'detail' && dependencies.length > 0 && (
+                    <div className="flex flex-wrap items-center gap-1.5 text-xs">
+                      <span className="text-theme-text-tertiary">Starts after</span>
+                      {dependencies.map((dependency, dependencyIndex) => (
+                        <Badge key={`${dependency?.name || 'dependency'}-${dependencyIndex}`} tone="structural" size="sm">
+                          {dependency?.name || 'Unknown role'}
+                          {dependency?.status ? ` · ${dependency.status}` : ''}
+                        </Badge>
+                      ))}
+                    </div>
+                  )}
+                </div>
+              )
+            })}
+          </div>
+        </Section>
+      )}
+
+      {showConfiguration && (successPolicy || failurePolicy || spec.startupPolicy) && (
+        <Section title="Completion and restart policies" icon={ShieldCheck} defaultExpanded={mode === 'detail'}>
+          <PropertyList>
+            {successPolicy?.operator && (
+              <Property
+                label="Success"
+                value={
+                  <span className="inline-flex flex-wrap items-center gap-1.5">
+                    <Badge tone="structural" size="sm">
+                      {successPolicy.operator}
+                    </Badge>
+                    <span>
+                      across{' '}
+                      {Array.isArray(successPolicy.targetReplicatedJobs) && successPolicy.targetReplicatedJobs.length > 0
+                        ? successPolicy.targetReplicatedJobs.join(', ')
+                        : 'all replicated jobs'}
+                    </span>
+                  </span>
+                }
+              />
+            )}
+            <Property label="Restart limit" value={failurePolicy?.maxRestarts} />
+            <Property label="Global restarts counted toward limit" value={globalCountedRestarts ?? 'Not reported'} />
+            <Property label="Individual restarts counted toward limit" value={individualCountedRestarts == null ? 'Not reported' : `${individualCountedRestarts} (${observedRoles} of ${replicatedJobs.length} roles reported)`} />
+            <Property label="Restart strategy" value={failurePolicy?.restartStrategy} />
+            {failureRules.length > 0 && <Property label="Default action" value="RestartJobSet" />}
+            <Property label="Startup order" value={spec.startupPolicy?.startupPolicyOrder} />
+          </PropertyList>
+
+          {failureRules.length > 0 && (
+            <div className="mt-3 space-y-2">
+              {failureRules.map((rule, index) => {
+                const targets =
+                  Array.isArray(rule?.targetReplicatedJobs) && rule.targetReplicatedJobs.length > 0
+                    ? rule.targetReplicatedJobs.join(', ')
+                    : 'All replicated jobs'
+                const reasons =
+                  Array.isArray(rule?.onJobFailureReasons) && rule.onJobFailureReasons.length > 0
+                    ? rule.onJobFailureReasons.join(', ')
+                    : 'Any Job failure reason'
+                const messagePatterns =
+                  Array.isArray(rule?.onJobFailureMessagePatterns) && rule.onJobFailureMessagePatterns.length > 0
+                    ? rule.onJobFailureMessagePatterns.join(', ')
+                    : 'Any failure message'
+
+                return (
+                  <div key={`${rule?.name || 'rule'}-${index}`} className="card-inner space-y-1.5">
+                    <div className="flex flex-wrap items-center gap-2">
+                      <span className="text-sm font-medium text-theme-text-primary">
+                        {index + 1}. {rule?.name || `Rule ${index + 1}`}
+                      </span>
+                      {rule?.action && (
+                        <Badge tone="structural" size="sm">
+                          {rule.action}
+                        </Badge>
+                      )}
+                    </div>
+                    <div className="text-xs text-theme-text-secondary">
+                      <span className="text-theme-text-tertiary">Applies to:</span> {targets}
+                    </div>
+                    <div className="text-xs text-theme-text-secondary">
+                      <span className="text-theme-text-tertiary">Reasons:</span> {reasons}
+                    </div>
+                    <div className="break-words text-xs text-theme-text-secondary">
+                      <span className="text-theme-text-tertiary">Messages:</span> {messagePatterns}
+                    </div>
+                  </div>
+                )
+              })}
+            </div>
+          )}
+        </Section>
+      )}
+
+      {showConfiguration && (coordinator || network) && (
+        <Section title="Coordination and network" icon={NetworkIcon} defaultExpanded={mode === 'detail'}>
+          <PropertyList>
+            <Property label="Coordinator role" value={coordinator?.replicatedJob} />
+            <Property label="Coordinator Job index" value={coordinator?.jobIndex} />
+            <Property label="Coordinator Pod index" value={coordinator?.podIndex} />
+            <Property label="Subdomain" value={network?.subdomain} />
+            <Property
+              label="DNS hostnames"
+              value={network?.enableDNSHostnames === undefined ? undefined : network.enableDNSHostnames ? 'Enabled' : 'Disabled'}
+            />
+            <Property
+              label="Publish before ready"
+              value={network?.publishNotReadyAddresses === undefined ? undefined : network.publishNotReadyAddresses ? 'Yes' : 'No'}
+            />
+          </PropertyList>
+        </Section>
+      )}
+
+      {showSummary && <ConditionsSection conditions={conditions} getConditionTone={getJobSetConditionTone} defaultExpanded={mode === 'overview' ? false : undefined} />}
+    </>
+  )
+}

package/src/components/resources/renderers/KueueProvisioningRenderers.test.tsx

@@ -0,0 +1,67 @@
+import { renderToStaticMarkup } from 'react-dom/server'
+import { describe, expect, it } from 'vitest'
+import { AdmissionCheckRenderer, ProvisioningRequestRenderer, provisioningConditionTone } from './KueueProvisioningRenderers'
+import { getAdmissionCheckStatus, getProvisioningRequestStatus, getProvisioningRequestMessage } from '../resource-utils-kueue'
+
+const resource = (conditions: any[] = []) => ({ apiVersion: 'autoscaling.x-k8s.io/v1', metadata: { generation: 3, namespace: 'ml' }, spec: { provisioningClassName: 'provider.example' }, status: { conditions } })
+const condition = (type: string, extra = {}) => ({ type, status: 'True', observedGeneration: 3, ...extra })
+
+describe('provisioning evidence', () => {
+  it('uses current provisioning progress while Accepted, without turning the false condition into failure', () => {
+    const data = resource([condition('Accepted', { message: 'Request accepted' }), condition('Provisioned', { status: 'False', message: 'Waiting for capacity' })])
+    expect(getProvisioningRequestStatus(data).text).toBe('Accepted')
+    expect(getProvisioningRequestMessage(data)).toBe('Waiting for capacity')
+    data.status.conditions[1].observedGeneration = 2
+    expect(getProvisioningRequestMessage(data)).toBe('Request accepted')
+  })
+  it('keeps negative outcomes above old success regardless of condition order', () => {
+    for (const type of ['Failed', 'CapacityRevoked', 'BookingExpired']) {
+      for (const conditions of [[condition('Provisioned'), condition(type)], [condition(type), condition('Provisioned')]]) {
+        expect(getProvisioningRequestStatus(resource(conditions)).text).toBe(type)
+      }
+    }
+    expect(getProvisioningRequestStatus(resource([condition('BookingExpired')])).level).toBe('neutral')
+    expect(getProvisioningRequestStatus(resource([condition('CapacityRevoked')])).level).toBe('unhealthy')
+  })
+  it('does not invent a pending or healthy outcome from missing, unknown or stale observations', () => {
+    expect(getProvisioningRequestStatus(resource()).text).toBe('Unknown')
+    expect(getProvisioningRequestStatus(resource([condition('Provisioned', { status: 'Unknown' })])).text).toBe('Unknown')
+    expect(getProvisioningRequestStatus(resource([condition('Provisioned', { observedGeneration: 2 })])).level).toBe('unknown')
+    expect(provisioningConditionTone(condition('Failed'))).toBe('fail')
+    expect(provisioningConditionTone(condition('BookingExpired'))).toBe('unknown')
+  })
+  it('renders requested template/count and outcome without claiming running Pods', () => {
+    const data = { ...resource([condition('Provisioned')]), spec: { provisioningClassName: 'provider.example', podSets: [{ podTemplateRef: { name: 'workers' }, count: 0 }, { podTemplateRef: { name: 'missing-count' } }] } }
+    const html = renderToStaticMarkup(<ProvisioningRequestRenderer data={data} />)
+    for (const text of ['workers', 'Requested Pods', 'Not specified', 'not a live check', 'Provisioned does not mean the Workload is running']) expect(html).toContain(text)
+    expect(html).toContain('>0<')
+  })
+  it('keeps failure reasons/messages and does not treat foreign Workload owners as Kueue', () => {
+    const data = resource([condition('Failed', { reason: 'CapacityUnavailable', message: 'No matching capacity' })])
+    Object.assign(data.metadata, { ownerReferences: [{ controller: true, kind: 'Workload', apiVersion: 'foreign.io/v1', name: 'foreign-owner' }] })
+    const html = renderToStaticMarkup(<ProvisioningRequestRenderer data={data} />)
+    expect(html).toContain('No matching capacity')
+    expect(html).toContain('CapacityUnavailable')
+    expect(html).not.toContain('foreign-owner')
+  })
+})
+
+describe('AdmissionCheck controller readiness', () => {
+  it('distinguishes active controller from Workload approval and preserves native failure', () => {
+    for (const version of ['v1beta1', 'v1beta2']) {
+      const data = { ...resource([condition('Active')]), apiVersion: `kueue.x-k8s.io/${version}`, spec: { controllerName: 'kueue.x-k8s.io/provisioning-request' } }
+      const html = renderToStaticMarkup(<AdmissionCheckRenderer data={data} />)
+      expect(html).toContain('Each Workload reports its own')
+      expect(getAdmissionCheckStatus(data).text).toBe('Active')
+      data.status.conditions = [condition('Active', { status: 'False', reason: 'BadParametersRef', message: 'Config not found' })]
+      expect(renderToStaticMarkup(<AdmissionCheckRenderer data={data} />)).toContain('Config not found')
+    }
+  })
+  it('keeps stale and missing readiness unknown, and only displays declared v1beta1 retry delay', () => {
+    const data = { ...resource([condition('Active', { observedGeneration: 2 })]), apiVersion: 'kueue.x-k8s.io/v1beta1', spec: { retryDelayMinutes: 0 } }
+    expect(getAdmissionCheckStatus(data).level).toBe('unknown')
+    expect(renderToStaticMarkup(<AdmissionCheckRenderer data={data} />)).toContain('0 minutes')
+    expect(renderToStaticMarkup(<AdmissionCheckRenderer data={{ ...data, apiVersion: 'kueue.x-k8s.io/v1beta2' }} />)).not.toContain('0 minutes')
+    expect(getAdmissionCheckStatus(resource()).level).toBe('unknown')
+  })
+})