@skyhook-io/k8s-ui 1.12.0 → 1.13.0

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

@@ -0,0 +1,221 @@
+import { describe, expect, it } from 'vitest'
+import { renderToString } from 'react-dom/server'
+import { VeleroBackupRenderer } from './VeleroBackupRenderer'
+
+const backup = (location: string) => ({
+  metadata: { name: 'nightly', namespace: 'velero' },
+  spec: { storageLocation: location, ttl: '720h0m0s' },
+  status: { phase: 'Completed', startTimestamp: '2026-08-14T01:00:00Z' },
+})
+
+/**
+ * A backup cannot see the bucket behind it. Its own status says Completed and
+ * keeps saying it after the storage location goes Unavailable, which is exactly
+ * when someone opens this page to ask whether they can restore to this point.
+ */
+describe('a backup whose storage location is unreachable', () => {
+  it('says so on the backup, not one screen away', () => {
+    const html = renderToString(
+      <VeleroBackupRenderer data={backup('dr-replica')} storageLocationPhase="Unavailable" />,
+    )
+    expect(html).toContain('nothing here to restore from')
+    expect(html).toContain('Unavailable')
+  })
+
+  // On a healthy location this would be a warning about nothing, on every backup
+  // in the cluster.
+  it('stays quiet when the location is fine', () => {
+    const html = renderToString(
+      <VeleroBackupRenderer data={backup('default')} storageLocationPhase="Available" />,
+    )
+    expect(html).not.toContain('nothing here to restore from')
+  })
+
+  // The distinction that matters: a location we have not read is not a healthy
+  // one, and must not render as one.
+  it('claims nothing while the lookup is unresolved', () => {
+    const html = renderToString(<VeleroBackupRenderer data={backup('default')} />)
+    expect(html).not.toContain('nothing here to restore from')
+    expect(html).not.toContain('Unavailable')
+  })
+})
+
+/**
+ * FailedValidation is the one outcome where Velero usually explains itself, in
+ * status.failureReason. Radar's own sentence is the fallback for when it does
+ * not — a run rejected before it started leaves no errors, no warnings and no
+ * item counts, so without either the page is an empty red banner.
+ */
+describe('a run Velero refused to start', () => {
+  const rejected = (failureReason?: string) => ({
+    metadata: { name: 'live-rejected', namespace: 'velero' },
+    spec: { storageLocation: 'dr-replica' },
+    status: {
+      phase: 'FailedValidation',
+      ...(failureReason ? { failureReason } : {}),
+      validationErrors: ['Backup storage location "dr-replica" is unavailable'],
+    },
+  })
+
+  // Velero's own words beat ours whenever it supplies them.
+  it('leads with the reason Velero gave', () => {
+    const html = renderToString(
+      <VeleroBackupRenderer data={rejected('backup storage location is in read-only mode')} />,
+    )
+    expect(html).toContain('backup storage location is in read-only mode')
+    expect(html).not.toContain('Velero rejected this backup before it started')
+  })
+
+  it('says nothing was backed up when Velero gave no reason', () => {
+    const html = renderToString(<VeleroBackupRenderer data={rejected()} />)
+    expect(html).toContain('nothing was backed up')
+    // The validation errors are the actionable half either way.
+    expect(html).toContain('dr-replica&quot; is unavailable')
+  })
+})
+
+/**
+ * Velero resolves an unset spec.storageLocation to whichever location carries
+ * spec.default, which is a flag and not a name. An install that renamed its
+ * default location has no object called "default" at all, so resolving by name
+ * finds nothing: the unavailable-location warning never appears and the link
+ * points at something that does not exist.
+ */
+describe('a backup that names no location', () => {
+  const unset = {
+    metadata: { name: 'nightly', namespace: 'velero' },
+    spec: { ttl: '720h0m0s' },
+    status: { phase: 'Completed' },
+  }
+
+  it('links the location that actually holds it', () => {
+    const html = renderToString(
+      <VeleroBackupRenderer data={unset} storageLocationName="primary" onNavigate={() => {}} />,
+    )
+    expect(html).toContain('primary')
+  })
+
+  it('still warns when that location is the unavailable one', () => {
+    const html = renderToString(
+      <VeleroBackupRenderer data={unset} storageLocationName="primary" storageLocationPhase="Unavailable" />,
+    )
+    expect(html).toContain('nothing here to restore from')
+  })
+
+  // Replaced the by-name fallback assertion: it checked for the substring
+  // "default", which the "Velero's default location, not yet resolved" sentence
+  // also contains — so it passed while documenting the opposite of what the
+  // renderer now does. A host that does not resolve gets no asserted name.
+  it('asserts no location name when the host does not resolve one', () => {
+    const html = renderToString(<VeleroBackupRenderer data={unset} onNavigate={() => {}} />)
+    expect(html).toContain('not yet resolved')
+  })
+})
+
+/**
+ * Three states, not two. The lookup can be unanswered, answered-and-found, or
+ * answered-and-the-location-is-gone — and the last one has no phase to report,
+ * so without saying it the backup renders exactly as it would on a healthy
+ * bucket.
+ */
+describe('what the page claims before the location lookup answers', () => {
+  const unset = {
+    metadata: { name: 'nightly', namespace: 'velero' },
+    spec: {},
+    status: { phase: 'Completed' },
+  }
+  const named = {
+    metadata: { name: 'nightly', namespace: 'velero' },
+    spec: { storageLocation: 'dr-replica' },
+    status: { phase: 'Completed' },
+  }
+
+  // Scoped to the Storage Location row: "default" is also the rendered value of
+  // two unset fields in Options, so a whole-document match proves nothing.
+  const storageCell = (html: string) => {
+    const i = html.indexOf('Storage Location')
+    if (i < 0) return ''
+    // Up to the end of this property row only. A fixed-width window runs into
+    // the next Section's header, which is itself a <button>, so every case
+    // matched a link whether or not one was rendered.
+    const end = html.indexOf('</div>', i)
+    return html.slice(i, end < 0 ? undefined : end)
+  }
+
+  // An unset location is only knowable from the list. Printing "default" before
+  // it answers is a guess that is wrong on any install that renamed it.
+  it('does not name a location it has not resolved', () => {
+    const cell = storageCell(renderToString(<VeleroBackupRenderer data={unset} onNavigate={() => {}} />))
+    expect(cell).toContain('not yet resolved')
+    expect(cell).not.toContain('>default<')
+  })
+
+  // A backup that names its own location is known regardless of the lookup.
+  it('still shows a location the backup names itself', () => {
+    const html = renderToString(<VeleroBackupRenderer data={named} onNavigate={() => {}} />)
+    expect(html).toContain('dr-replica')
+    expect(html).not.toContain('not yet resolved')
+  })
+
+  it('says so when the location it names is gone', () => {
+    const html = renderToString(
+      <VeleroBackupRenderer data={named} storageLocationName="dr-replica" storageLocationMissing onNavigate={() => {}} />,
+    )
+    expect(html).toContain('Not found')
+    expect(html).toContain('no longer exists')
+  })
+
+  // A link to an object that is not there is worse than plain text. Scoped to
+  // the cell: every collapsible Section header is itself a <button>, so the
+  // whole document always matches.
+  it('does not link a location that is gone', () => {
+    const missing = storageCell(renderToString(
+      <VeleroBackupRenderer data={named} storageLocationName="dr-replica" storageLocationMissing onNavigate={() => {}} />,
+    ))
+    const present = storageCell(renderToString(
+      <VeleroBackupRenderer data={named} storageLocationName="dr-replica" onNavigate={() => {}} />,
+    ))
+    expect(present).toContain('<button')
+    expect(missing).not.toContain('<button')
+  })
+})
+
+/**
+ * Where the name came from changes what can be said about it. A backup that
+ * names its own location and cannot find it has named something missing. A
+ * backup that names nothing has not — the name was produced by Velero's
+ * fallback rule, and blaming the object for it invents a claim.
+ */
+describe('a location that cannot be found', () => {
+  const named = {
+    metadata: { name: 'nightly', namespace: 'velero' },
+    spec: { storageLocation: 'dr-replica' },
+    status: { phase: 'Completed' },
+  }
+  const unset = {
+    metadata: { name: 'nightly', namespace: 'velero' },
+    spec: {},
+    status: { phase: 'Completed' },
+  }
+
+  it('blames the backup only when the backup named it', () => {
+    const html = renderToString(
+      <VeleroBackupRenderer data={named} storageLocationName="dr-replica" storageLocationMissing />,
+    )
+    expect(html).toContain('names a storage location that no longer exists')
+    expect(html).toContain('Not found')
+  })
+
+  // The fallback resolved to the literal "default" because nothing carries
+  // spec.default. Saying the backup "names" that is attributing an invented
+  // name to the object.
+  it('says the namespace has no default when the backup named nothing', () => {
+    const html = renderToString(
+      <VeleroBackupRenderer data={unset} storageLocationName="default" storageLocationMissing />,
+    )
+    expect(html).toContain('names no storage location')
+    expect(html).toContain('this namespace has none')
+    expect(html).toContain('No default location')
+    expect(html).not.toContain('names a storage location that no longer exists')
+  })
+})

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

@@ -1,8 +1,10 @@
+import { VeleroRunMessages, type VeleroRunMessagesFetch } from './VeleroRunMessages'
 import { Archive, Clock, HardDrive, Filter } from 'lucide-react'
-import { Section, PropertyList, Property, ConditionsSection, AlertBanner } from '../../ui/drawer-components'
+import { clsx } from 'clsx'
+import { HEALTH_BADGE_COLORS } from '../../../utils/badge-colors'
+import { Section, PropertyList, Property, ConditionsSection, AlertBanner, ResourceLink } from '../../ui/drawer-components'
 import {
   getBackupStatus,
-  getBackupStorageLocation,
   getBackupIncludedNamespaces,
   getBackupExcludedNamespaces,
   getBackupIncludedResources,
@@ -14,6 +16,7 @@ import {
   getBackupWarnings,
   getBackupValidationErrors,
   getBackupTTL,
+  getBackupItemOperationTimeout,
   getBackupSnapshotVolumes,
   getBackupDefaultVolumesToFsBackup,
   getBackupVolumeSnapshotLocations,
@@ -22,13 +25,48 @@ import {
   isBackupPartialFailurePhase,
 } from '../resource-utils-velero'
 import { VeleroPhaseValue } from './velero-cells'
+import { veleroPhaseLabel } from '../resource-utils-velero'
 import { formatAge } from '../resource-utils'
 
 interface VeleroBackupRendererProps {
   data: any
+  /**
+   * The phase of the storage location this backup was written to, when the host
+   * looked it up. Undefined means unresolved — not "healthy".
+   *
+   * A backup cannot observe the health of the bucket holding it. Its own status
+   * keeps saying Completed, accurately, while the location goes Unavailable and
+   * there is nothing to restore from. This page is where someone checks whether
+   * they can go back to this point, so the fact belongs here rather than one
+   * screen away.
+   */
+  storageLocationPhase?: string
+  /**
+   * The location this backup is actually stored in, resolved by the host
+   * against the location list. An unset `spec.storageLocation` means "whichever
+   * location carries spec.default", which this component cannot see.
+   *
+   * Undefined means the lookup has not answered. A backup that names its own
+   * location is still known by name in that state; one that does not is not
+   * known at all, and this page says so rather than printing the conventional
+   * name as though it had been resolved.
+   */
+  storageLocationName?: string
+  /**
+   * The lookup answered and no location by that name exists. Distinct from an
+   * unresolved lookup: a backup whose storage location has been deleted cannot
+   * be restored from, and without this it renders exactly like a healthy one.
+   */
+  storageLocationMissing?: boolean
+  /** Wired by the host, which owns the fetch. Optional: a consumer that does
+   *  not wire it gets the counts on their own, with no button. */
+  messages?: VeleroRunMessagesFetch
+  /** Without it the location renders as plain text: the page names a location as
+   *  the reason nothing can be restored and gives no way to go look at it. */
+  onNavigate?: (ref: { kind: string; namespace: string; name: string; group?: string }) => void
 }
 
-export function VeleroBackupRenderer({ data }: VeleroBackupRendererProps) {
+export function VeleroBackupRenderer({ data, storageLocationPhase, storageLocationName, storageLocationMissing, messages, onNavigate }: VeleroBackupRendererProps) {
   const status = data.status || {}
   const conditions = status.conditions || []
 
@@ -86,7 +124,9 @@ export function VeleroBackupRenderer({ data }: VeleroBackupRendererProps) {
         <AlertBanner
           variant="warning"
           title={`${warnings} Warning(s)`}
-          message={`Backup completed with ${warnings} warning(s).`}
+          message={phase === 'Completed'
+            ? `This backup completed, with ${warnings} warning(s).`
+            : `This backup has reported ${warnings} warning(s) so far. It is ${veleroPhaseLabel(phase).toLowerCase()}, so this is not a final count.`}
         />
       )}
 
@@ -118,6 +158,7 @@ export function VeleroBackupRenderer({ data }: VeleroBackupRendererProps) {
               : '0'
           } />
         </PropertyList>
+        {messages && <VeleroRunMessages {...messages} errors={errors} warnings={warnings} />}
       </Section>
 
       {/* Progress section (if in progress) */}
@@ -196,12 +237,83 @@ export function VeleroBackupRenderer({ data }: VeleroBackupRendererProps) {
       {/* Storage section */}
       <Section title="Storage" icon={HardDrive} defaultExpanded>
         <PropertyList>
-          <Property label="Storage Location" value={getBackupStorageLocation(data)} />
+          {/* A backup that names its location is known by name whatever the
+              lookup is doing. One that does not is only known once the list
+              answers, because "unset" means whichever location carries
+              spec.default — so until then this says what the field says and
+              claims nothing further. */}
+          <Property
+            label="Storage Location"
+            value={(() => {
+              const declared = data?.spec?.storageLocation as string | undefined
+              const name = storageLocationName || declared
+              if (!name) {
+                return (
+                  <span className="text-sm text-theme-text-tertiary">
+                    Velero&rsquo;s default location, not yet resolved
+                  </span>
+                )
+              }
+              return (
+                <span className="flex items-center gap-2">
+                  {/* Not a link when the object is not there: a link to nothing
+                      is worse than a name. */}
+                  {storageLocationMissing ? (
+                    <span className="text-sm font-mono text-theme-text-primary">{name}</span>
+                  ) : (
+                    <ResourceLink
+                      name={name}
+                      kind="BackupStorageLocation"
+                      namespace={data?.metadata?.namespace ?? ''}
+                      group="velero.io"
+                      onNavigate={onNavigate}
+                    />
+                  )}
+                  {storageLocationMissing && (
+                    <span className={clsx('badge', HEALTH_BADGE_COLORS.unhealthy)}>
+                      {declared ? 'Not found' : 'No default location'}
+                    </span>
+                  )}
+                  {storageLocationPhase && storageLocationPhase !== 'Available' && (
+                    <span className={clsx('badge', HEALTH_BADGE_COLORS.unhealthy)}>{storageLocationPhase}</span>
+                  )}
+                </span>
+              )
+            })()}
+          />
+          {/* A location that is gone is not a location that is unhealthy, and
+              Velero writes no phase for one that does not exist — so without
+              this the backup renders exactly as it would on a healthy bucket.
+              Worded from where the name came from: a backup that names nothing
+              has not "named a location that no longer exists", and saying so
+              would attribute to the object a name the fallback invented. */}
+          {storageLocationMissing && (
+            <div className="text-xs text-warning-text">
+              {data?.spec?.storageLocation
+                ? 'This backup names a storage location that no longer exists in this namespace. Velero restores from the location recorded on the backup, so there is nothing here to restore from until it is recreated.'
+                : 'This backup names no storage location, which Velero resolves to the one marked default — and this namespace has none. Which location holds it cannot be determined here.'}
+            </div>
+          )}
+          {/* Only when it changes the answer. On a healthy location this would be
+              a warning about nothing, on every backup in the cluster. */}
+          {storageLocationPhase && storageLocationPhase !== 'Available' && (
+            <div className="text-xs text-warning-text">
+              {`This backup is stored in a location Velero reports as ${storageLocationPhase}. Its own phase does not change when that happens — until the location recovers, there is nothing here to restore from.`}
+            </div>
+          )}
           {vslLocations.length > 0 && (
             <Property label="Volume Snapshot Locations" value={
               <div className="flex flex-wrap gap-1">
                 {vslLocations.map((loc: string) => (
-                  <span key={loc} className="badge-sm bg-theme-hover text-theme-text-secondary">{loc}</span>
+                  <span key={loc} className="badge-sm bg-theme-hover text-theme-text-secondary">
+                    <ResourceLink
+                      name={loc}
+                      kind="VolumeSnapshotLocation"
+                      namespace={data?.metadata?.namespace ?? ''}
+                      group="velero.io"
+                      onNavigate={onNavigate}
+                    />
+                  </span>
                 ))}
               </div>
             } />
@@ -213,6 +325,7 @@ export function VeleroBackupRenderer({ data }: VeleroBackupRendererProps) {
       <Section title="Options" icon={Clock}>
         <PropertyList>
           <Property label="TTL" value={getBackupTTL(data)} />
+          <Property label="Item Operation Timeout" value={getBackupItemOperationTimeout(data)} />
           <Property label="Snapshot Volumes" value={getBackupSnapshotVolumes(data)} />
           <Property label="Default FS Backup" value={getBackupDefaultVolumesToFsBackup(data)} />
         </PropertyList>

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

@@ -0,0 +1,69 @@
+import { describe, expect, it } from 'vitest'
+import { renderToString } from 'react-dom/server'
+import { VeleroBackupRepositoryRenderer } from './VeleroBackupRepositoryRenderer'
+
+const repo = (over: { phase?: string; message?: string } = {}) => ({
+  metadata: { name: 'repo-notready', namespace: 'velero' },
+  spec: {
+    repositoryType: 'kopia',
+    volumeNamespace: 'legacy-app',
+    backupStorageLocation: 'dr-replica',
+    maintenanceFrequency: '1h0m0s',
+  },
+  status: {
+    phase: over.phase ?? 'NotReady',
+    ...(over.message !== undefined ? { message: over.message } : {}),
+  },
+})
+
+/**
+ * A BackupRepository raises `BackupRepositoryNotReady`, and `status.message` is
+ * the only place Velero records why. Without a renderer of its own the issue
+ * pointed at a generic drawer, so the one fact worth arriving for was the one
+ * the page could not show.
+ */
+describe('a repository Velero reports as not ready', () => {
+  it('leads with the reason Velero gave', () => {
+    const html = renderToString(
+      <VeleroBackupRepositoryRenderer
+        data={repo({ message: 'error running maintenance: unable to connect to repository' })}
+      />,
+    )
+    expect(html).toContain('unable to connect to repository')
+  })
+
+  // Velero can set NotReady with no message. Saying nothing would leave a red
+  // badge and no consequence, so the page states what not-ready costs.
+  it('names the consequence when Velero gave no reason', () => {
+    const html = renderToString(<VeleroBackupRepositoryRenderer data={repo()} />)
+    expect(html).toContain('legacy-app')
+    expect(html).toContain('cannot be written')
+  })
+
+  it('says nothing alarming when the repository is ready', () => {
+    const html = renderToString(
+      <VeleroBackupRepositoryRenderer data={repo({ phase: 'Ready' })} />,
+    )
+    expect(html).not.toContain('Repository Not Ready')
+    expect(html).not.toContain('cannot be written')
+  })
+
+  // The same dead end this integration closed on Backup and Restore: naming a
+  // Velero object the reader cannot reach.
+  it('lets the reader reach the location it writes into', () => {
+    const html = renderToString(
+      <VeleroBackupRepositoryRenderer data={repo()} onNavigate={() => {}} />,
+    )
+    expect(html).toContain('dr-replica')
+    expect(html).toMatch(/role="button"|<button|cursor-pointer/)
+  })
+
+  // Maintenance frequency alone does not say whether maintenance is happening.
+  // The pair does, which is why both are on the page.
+  it('shows the maintenance schedule beside the last run', () => {
+    const html = renderToString(<VeleroBackupRepositoryRenderer data={repo({ phase: 'Ready' })} />)
+    expect(html).toContain('Maintenance Frequency')
+    expect(html).toContain('1h0m0s')
+    expect(html).toContain('Last Maintenance')
+  })
+})

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

@@ -0,0 +1,96 @@
+import { Database, Clock } from 'lucide-react'
+import { Section, PropertyList, Property, ConditionsSection, AlertBanner, ResourceLink } from '../../ui/drawer-components'
+import {
+  getBackupRepositoryStatus,
+  getBackupRepositoryType,
+  getBackupRepositoryVolumeNamespace,
+  getBackupRepositoryLocation,
+  getBackupRepositoryMaintenanceFrequency,
+  getBackupRepositoryLastMaintenance,
+  getBackupRepositoryMessage,
+} from '../resource-utils-velero'
+import { VeleroPhaseValue } from './velero-cells'
+
+interface VeleroBackupRepositoryRendererProps {
+  data: any
+  onNavigate?: (ref: { kind: string; namespace: string; name: string; group?: string }) => void
+}
+
+/**
+ * A BackupRepository is where Velero's file-level backups of a namespace's
+ * volumes are written. It raises its own issue when it goes `NotReady`, and
+ * `status.message` is the only place the reason for that exists.
+ */
+export function VeleroBackupRepositoryRenderer({ data, onNavigate }: VeleroBackupRepositoryRendererProps) {
+  const status = data.status || {}
+  const repoStatus = getBackupRepositoryStatus(data)
+  const message = getBackupRepositoryMessage(data)
+  const volumeNamespace = getBackupRepositoryVolumeNamespace(data)
+  const location = getBackupRepositoryLocation(data)
+
+  return (
+    <>
+      {/* The reason, not just the state. A repository that is not ready means
+          volume backups for its namespace are not being written, and Velero puts
+          that consequence nowhere on the object. */}
+      {repoStatus.level === 'unhealthy' && (
+        <AlertBanner
+          variant="error"
+          title="Repository Not Ready"
+          message={message
+            ? message
+            : `Velero reported this repository as not ready and gave no reason. Volume backups for ${volumeNamespace === '-' ? 'its namespace' : volumeNamespace} cannot be written while it stays that way.`}
+        />
+      )}
+
+      <Section title="Status" icon={Clock} defaultExpanded>
+        <PropertyList>
+          <Property label="Phase" value={
+            <VeleroPhaseValue status={repoStatus} phase={status.phase || ''} />
+          } />
+          {/* Velero runs maintenance on its own schedule; a repository whose
+              last run is far older than its frequency is the shape of a
+              controller that has stopped. The two are shown together so that
+              comparison does not need a second screen. */}
+          <Property label="Last Maintenance" value={getBackupRepositoryLastMaintenance(data)} />
+          <Property label="Maintenance Frequency" value={getBackupRepositoryMaintenanceFrequency(data)} />
+        </PropertyList>
+      </Section>
+
+      <Section title="Repository" icon={Database} defaultExpanded>
+        <PropertyList>
+          <Property label="Type" value={getBackupRepositoryType(data)} />
+          {/* What this repository is for. Velero partitions repositories by
+              namespace, so this is the namespace whose volumes it holds, not
+              the namespace the object lives in. */}
+          <Property label="Volume Namespace" value={
+            volumeNamespace === '-' ? '-' : (
+              <ResourceLink
+                name={volumeNamespace}
+                kind="Namespace"
+                namespace=""
+                onNavigate={onNavigate}
+              />
+            )
+          } />
+          {/* Reachable, like every other location reference in this integration.
+              A repository is written into a storage location, and its own status
+              says nothing about that location's health. */}
+          <Property label="Storage Location" value={
+            location === '-' ? '-' : (
+              <ResourceLink
+                name={location}
+                kind="BackupStorageLocation"
+                namespace={data?.metadata?.namespace ?? ''}
+                group="velero.io"
+                onNavigate={onNavigate}
+              />
+            )
+          } />
+        </PropertyList>
+      </Section>
+
+      <ConditionsSection conditions={status.conditions || []} />
+    </>
+  )
+}

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

@@ -0,0 +1,55 @@
+import { describe, expect, it } from 'vitest'
+import { renderToString } from 'react-dom/server'
+import { VeleroRestoreRenderer } from './VeleroRestoreRenderer'
+
+const restore = (status: Record<string, unknown>) => ({
+  metadata: { name: 'live-restore', namespace: 'velero' },
+  spec: { backupName: 'live-completed' },
+  status,
+})
+
+/**
+ * The restore side carries the same claims as the backup side and its own
+ * wording for them, so pinning one does not pin the other. Both banners below
+ * were wrong in the same way at the same time.
+ */
+describe('what a restore claims about itself', () => {
+  // A count taken mid-run is not a final count. Velero raises warnings as it
+  // goes, so a restore still working can already have several.
+  it('does not say a restore in flight completed', () => {
+    const html = renderToString(
+      <VeleroRestoreRenderer data={restore({ phase: 'InProgress', warnings: 2 })} />,
+    )
+    expect(html).not.toMatch(/completed, with/)
+    expect(html).toContain('not a final count')
+  })
+
+  it('still says completed when it did', () => {
+    const html = renderToString(
+      <VeleroRestoreRenderer data={restore({ phase: 'Completed', warnings: 2 })} />,
+    )
+    expect(html).toContain('completed, with 2 warning(s)')
+    expect(html).not.toContain('not a final count')
+  })
+
+  // Velero's own words beat ours whenever it supplies them.
+  it('leads with the reason Velero gave for refusing to start', () => {
+    const html = renderToString(
+      <VeleroRestoreRenderer
+        data={restore({ phase: 'FailedValidation', failureReason: 'backup not found' })}
+      />,
+    )
+    expect(html).toContain('backup not found')
+    expect(html).not.toContain('Velero rejected this restore before it started')
+  })
+
+  it('says nothing was restored when Velero gave no reason', () => {
+    const html = renderToString(
+      <VeleroRestoreRenderer
+        data={restore({ phase: 'FailedValidation', validationErrors: ['Backup live-completed not found'] })}
+      />,
+    )
+    expect(html).toContain('nothing was restored')
+    expect(html).toContain('Backup live-completed not found')
+  })
+})