Skip to content

armgit / Pulse

Public Imported from GitHub
0

Real-time monitoring dashboard for Proxmox VE, PBS, Docker, Kubernetes, TrueNAS and vSphere. Self-hosted, with alerts for failed backups, full disks, unhealthy containers and offline nodes.

Keep restore-point identity readable without hover

pulse-triage[bot]28e181830efe
diff --git a/docs/release-control/v6/internal/subsystems/frontend-primitives.md b/docs/release-control/v6/internal/subsystems/frontend-primitives.md
index 3e03903d50..c49b1ea819 100644
--- a/docs/release-control/v6/internal/subsystems/frontend-primitives.md
+++ b/docs/release-control/v6/internal/subsystems/frontend-primitives.md
@@ -10644,3 +10644,27 @@ usage and `Dialog.test.tsx` owns modal isolation/focus. Browser proof exercises
the consuming TrueNAS table with ordinary keyboard/phone taps, hover parity,
updates and dismissal, and natively inspected desktop/narrow pixels. This repairs
composition access, not the reporter's missing native ARC or I/O/History source.
+
+### Restore-point identity is readable before narrow-screen disclosure
+
+The existing Proxmox By date list groups workload name/type/target ID, PVE
+workload connection, source kind, reader connection and repository location in
+one wrapping identity cell below 720px table width. These are different scopes:
+a PBS reader/namespace never supplies an unknown guest's PVE connection. Age and
+state retain independent columns and their existing meanings. Wider tables keep
+separate source/location columns and expose PVE scope beneath the workload name;
+a hidden Target ID column never hides the ID itself. Full provider identifiers,
+size and existing owner links remain in the same single-point drawer. This
+changes no matching, posture, verification, pruning, filter, poll or API contract.
+
+The three-column narrow projection reserves enough width for the grouped
+identity, Unknown age and full state words instead of the old single-name 40%
+anchor. Normal-suite `recoverableIdentityAccess.test.tsx` exercises the real
+parsed inventory consumer across 320/479/480/719/720/1200px, namesakes, every source
+kind, unmatched/host scope and open-record live refresh/focus. The registered
+`ProxmoxBackupsTable.test.tsx` checks workload/reader separation before disclosure;
+`ProxmoxRecoverableTable.test.tsx` and `proxmoxBackupsTablePresentation.test.ts`
+protect grouped metadata, responsive columns and bounded rendering. Browser
+proof must exercise the consuming list at desktop/narrow widths, inspect actual
+pixels, identity, state/age fit, touch/keyboard disclosure, filters and live
+updates. This is safer evidence inspection, not a restore or installed recovery.
diff --git a/docs/release-control/v6/internal/subsystems/storage-recovery.md b/docs/release-control/v6/internal/subsystems/storage-recovery.md
index 0216b19dd1..c88a249966 100644
--- a/docs/release-control/v6/internal/subsystems/storage-recovery.md
+++ b/docs/release-control/v6/internal/subsystems/storage-recovery.md
@@ -8264,3 +8264,27 @@ invalid instants. Browser proof must inspect the actual consuming record at
desktop and narrow widths, including UTC text, keyboard/touch disclosure and
refresh/recovery with the open record preserved. This is evidence inspection,
not original incident recovery.
+
+### Restore-point identity is readable before narrow-screen disclosure
+
+The existing Proxmox By date list groups workload name/type/target ID, PVE
+workload connection, source kind, reader connection and repository location in
+one wrapping identity cell below 720px table width. These are different scopes:
+a PBS reader/namespace never supplies an unknown guest's PVE connection. Age and
+state retain independent columns and their existing meanings. Wider tables keep
+separate source/location columns and expose PVE scope beneath the workload name;
+a hidden Target ID column never hides the ID itself. Full provider identifiers,
+size and existing owner links remain in the same single-point drawer. This
+changes no matching, posture, verification, pruning, filter, poll or API contract.
+
+The three-column narrow projection reserves enough width for the grouped
+identity, Unknown age and full state words instead of the old single-name 40%
+anchor. Normal-suite `recoverableIdentityAccess.test.tsx` exercises the real
+parsed inventory consumer across 320/479/480/719/720/1200px, namesakes, every source
+kind, unmatched/host scope and open-record live refresh/focus. The registered
+`ProxmoxBackupsTable.test.tsx` checks workload/reader separation before disclosure;
+`ProxmoxRecoverableTable.test.tsx` and `proxmoxBackupsTablePresentation.test.ts`
+protect grouped metadata, responsive columns and bounded rendering. Browser
+proof must exercise the consuming list at desktop/narrow widths, inspect actual
+pixels, identity, state/age fit, touch/keyboard disclosure, filters and live
+updates. This is safer evidence inspection, not a restore or installed recovery.
diff --git a/docs/release-control/v6/internal/subsystems/unified-resources.md b/docs/release-control/v6/internal/subsystems/unified-resources.md
index af08eaa656..9ed78f5406 100644
--- a/docs/release-control/v6/internal/subsystems/unified-resources.md
+++ b/docs/release-control/v6/internal/subsystems/unified-resources.md
@@ -9018,3 +9018,27 @@ usage and `Dialog.test.tsx` owns modal isolation/focus. Browser proof exercises
the consuming TrueNAS table with ordinary keyboard/phone taps, hover parity,
updates and dismissal, and natively inspected desktop/narrow pixels. This repairs
composition access, not the reporter's missing native ARC or I/O/History source.
+
+### Restore-point identity is readable before narrow-screen disclosure
+
+The existing Proxmox By date list groups workload name/type/target ID, PVE
+workload connection, source kind, reader connection and repository location in
+one wrapping identity cell below 720px table width. These are different scopes:
+a PBS reader/namespace never supplies an unknown guest's PVE connection. Age and
+state retain independent columns and their existing meanings. Wider tables keep
+separate source/location columns and expose PVE scope beneath the workload name;
+a hidden Target ID column never hides the ID itself. Full provider identifiers,
+size and existing owner links remain in the same single-point drawer. This
+changes no matching, posture, verification, pruning, filter, poll or API contract.
+
+The three-column narrow projection reserves enough width for the grouped
+identity, Unknown age and full state words instead of the old single-name 40%
+anchor. Normal-suite `recoverableIdentityAccess.test.tsx` exercises the real
+parsed inventory consumer across 320/479/480/719/720/1200px, namesakes, every source
+kind, unmatched/host scope and open-record live refresh/focus. The registered
+`ProxmoxBackupsTable.test.tsx` checks workload/reader separation before disclosure;
+`ProxmoxRecoverableTable.test.tsx` and `proxmoxBackupsTablePresentation.test.ts`
+protect grouped metadata, responsive columns and bounded rendering. Browser
+proof must exercise the consuming list at desktop/narrow widths, inspect actual
+pixels, identity, state/age fit, touch/keyboard disclosure, filters and live
+updates. This is safer evidence inspection, not a restore or installed recovery.
diff --git a/frontend-modern/src/features/proxmox/ProxmoxRecoverableTable.tsx b/frontend-modern/src/features/proxmox/ProxmoxRecoverableTable.tsx
index 10bad4e7b1..920c18f81d 100644
--- a/frontend-modern/src/features/proxmox/ProxmoxRecoverableTable.tsx
+++ b/frontend-modern/src/features/proxmox/ProxmoxRecoverableTable.tsx
@@ -33,6 +33,7 @@ import { useObservedElementWidth } from '@/hooks/useObservedElementWidth';
import type { RecoverableArtifact } from './proxmoxBackupRecoveryModel';
import type { RecoverableSortKey } from './proxmoxBackupsTableModel';
import {
+ ArtifactSourceBadge,
ArtifactSourceIdentity,
ArtifactStateBadge,
PROXMOX_BACKUP_COLUMN_LABELS,
@@ -108,8 +109,8 @@ const artifactVerificationText = (artifact: RecoverableArtifact): string => {
return artifact.sourceKind === 'snapshot' ? '' : 'Not reported';
};
-// Phones drop the location, size and details columns, so the drawer is where
-// a restore point is always readable in full.
+// Size and provider identifiers remain progressive detail. Workload and
+// repository identity must also be readable before choosing a point on a phone.
const buildRecoverableDetailSections = (artifact: RecoverableArtifact): DetailSection[] => {
const source = getProxmoxBackupSourcePresentation(artifact.sourceKind);
return compactDetailSections([
@@ -204,6 +205,7 @@ export function ProxmoxRecoverableTable(props: {
: 'full';
});
const visibleColumns = createMemo(() => getRecoverableColumns(layoutMode()));
+ const stackedIdentity = () => isCompactBackupIdentityLayout(layoutMode());
const columnVisible = (column: RecoverableColumnId) =>
visibleColumns().some((candidate) => candidate.id === column);
const showDayGroups = () => props.groupByDay && props.sortKey() === 'created';
@@ -238,34 +240,54 @@ export function ProxmoxRecoverableTable(props: {
data-proxmox-backup-row="recoverable"
>
<TableCell class={`${getPlatformTableCellClassForKind('name')} text-base-content`}>
- <div class="flex min-w-0 items-center gap-1">
+ <div class={`flex min-w-0 gap-2 ${stackedIdentity() ? 'items-start' : 'items-center'}`}>
<PlatformResourceDetailToggleButton
expanded={drawer.isExpanded(artifact)}
resourceLabel={getBackupWorkloadDisclosureLabel(artifact.workload)}
controlsId={drawer.detailRowId(artifact)}
onToggle={() => drawer.toggle(artifact)}
/>
- <div
- class="min-w-0 truncate font-semibold"
- title={[
- artifact.workload.name || artifact.workload.label,
- artifact.workload.typeLabel,
- artifact.workload.vmid,
- // The phone projection has no location column, so the row's
- // hover title carries the repository instead.
- columnVisible('location') ? undefined : artifact.location,
- ]
- .filter(Boolean)
- .join(' · ')}
- >
- {artifact.workload.name || artifact.workload.label}
- </div>
- <Show when={isCompactBackupIdentityLayout(layoutMode())}>
- <span class="shrink-0 text-[10px] text-muted">
- {artifact.workload.typeLabel}
- <Show when={artifact.workload.vmid}> {artifact.workload.vmid}</Show>
+ <div class="min-w-0 flex-1">
+ <span
+ class={`block font-semibold ${stackedIdentity() ? 'whitespace-normal wrap-anywhere' : 'truncate'}`}
+ title={artifact.workload.label}
+ >
+ {artifact.workload.name || artifact.workload.label}
</span>
- </Show>
+ <Show when={!columnVisible('targetId') && artifact.workload.vmid}>
+ <span class="block text-[10px] text-muted">
+ {artifact.workload.typeLabel} {artifact.workload.vmid}
+ </span>
+ </Show>
+ <Show when={getBackupWorkloadPVEConnection(artifact.workload)}>
+ {(connection) => (
+ <span
+ class={`block text-[10px] text-muted ${stackedIdentity() ? 'whitespace-normal wrap-anywhere' : 'truncate'}`}
+ title={`PVE connection: ${connection()}`}
+ data-backup-workload-connection
+ >
+ PVE: {connection()}
+ </span>
+ )}
+ </Show>
+ <Show when={stackedIdentity()}>
+ <div class="mt-1 space-y-0.5 text-[10px] leading-snug">
+ <ArtifactSourceBadge artifact={artifact} wrap />
+ <span
+ class="block whitespace-normal text-muted wrap-anywhere"
+ data-backup-source-connection
+ >
+ Connection: {artifact.locationConnection || 'Unknown connection'}
+ </span>
+ <span
+ class="block whitespace-normal text-muted wrap-anywhere"
+ data-backup-location
+ >
+ Location: {artifact.location}
+ </span>
+ </div>
+ </Show>
+ </div>
</div>
</TableCell>
<Show when={columnVisible('type')}>
@@ -283,9 +305,11 @@ export function ProxmoxRecoverableTable(props: {
{artifact.workload.vmid || '—'}
</TableCell>
</Show>
- <TableCell class={`${getPlatformTableCellClassForKind('text')} text-base-content`}>
- <ArtifactSourceIdentity artifact={artifact} />
- </TableCell>
+ <Show when={columnVisible('source')}>
+ <TableCell class={`${getPlatformTableCellClassForKind('text')} text-base-content`}>
+ <ArtifactSourceIdentity artifact={artifact} />
+ </TableCell>
+ </Show>
<Show when={columnVisible('location')}>
<TableCell class={`${getPlatformTableCellClassForKind('text')} text-base-content`}>
<span class="block truncate" title={artifact.location}>
@@ -380,13 +404,13 @@ export function ProxmoxRecoverableTable(props: {
header={
<>
<SortableHead
- label="Workload"
+ label={stackedIdentity() ? 'Restore point' : 'Workload'}
sortKey="workload"
currentSort={props.sortKey}
direction={props.sortDirection}
onSort={props.onSort}
align="left"
- headClass={`${getPlatformTableHeadClassForKind('name')} platform-table-mobile-w-30`}
+ headClass={getPlatformTableHeadClassForKind('name')}
/>
<Show when={columnVisible('type')}>
<TableHead class={getPlatformTableHeadClassForKind('text')}>Type</TableHead>
@@ -396,15 +420,17 @@ export function ProxmoxRecoverableTable(props: {
{PROXMOX_BACKUP_COLUMN_LABELS.targetId}
</TableHead>
</Show>
- <SortableHead
- label={layoutMode() === 'compact' ? 'Via' : 'Source'}
- sortKey="source"
- currentSort={props.sortKey}
- direction={props.sortDirection}
- onSort={props.onSort}
- align="left"
- headClass={getPlatformTableHeadClassForKind('text')}
- />
+ <Show when={columnVisible('source')}>
+ <SortableHead
+ label="Source"
+ sortKey="source"
+ currentSort={props.sortKey}
+ direction={props.sortDirection}
+ onSort={props.onSort}
+ align="left"
+ headClass={getPlatformTableHeadClassForKind('text')}
+ />
+ </Show>
<Show when={columnVisible('location')}>
<SortableHead
label={layoutMode() === 'compact' ? 'Loc' : 'Location'}
@@ -458,7 +484,7 @@ export function ProxmoxRecoverableTable(props: {
items={tableItems}
keyExtractor={(item) => `${item.kind}:${item.key}`}
colSpan={visibleColumns().length}
- estimatedRowHeight={32}
+ estimatedRowHeight={stackedIdentity() ? 128 : 44}
reserveScrollExtent
>
{(item) => (
diff --git a/frontend-modern/src/features/proxmox/__tests__/ProxmoxBackupsTable.test.tsx b/frontend-modern/src/features/proxmox/__tests__/ProxmoxBackupsTable.test.tsx
index 697bd7d4e1..babffc2e31 100644
--- a/frontend-modern/src/features/proxmox/__tests__/ProxmoxBackupsTable.test.tsx
+++ b/frontend-modern/src/features/proxmox/__tests__/ProxmoxBackupsTable.test.tsx
@@ -2935,3 +2935,39 @@ describe('bare Backups entry retains its assessed workspace', () => {
await screen.findByText('No backups yet');
});
});
+
+describe('By-date restore-point scope', () => {
+ afterEach(() => vi.useRealTimers());
+ it('shows the workload connection independently of its backup reader before disclosure', async () => {
+ vi.useFakeTimers({ now: BACKUP_IDENTITY_NOW, toFake: ['Date'] });
+ window.history.replaceState({}, '', '/proxmox/backups/date');
+ apiFetchMock.mockImplementation((url: string) =>
+ Promise.resolve(
+ jsonResponse({
+ data:
+ url === '/api/backups/pbs'
+ ? { backups: [identityPBS({ instance: 'independent-pbs-reader' })] }
+ : { backupTasks: [], storageBackups: [], guestSnapshots: [] },
+ }),
+ ),
+ );
+ apiFetchJSONMock.mockResolvedValue({ data: [], policy: protectionPolicy });
+ renderInRouter(() => (
+ <ProxmoxBackupsTable
+ emptyIcon={<span />}
+ workloads={[identityGuest('east-100', 'east', 'pve-1')]}
+ />
+ ));
+ const toggle = await screen.findByRole('button', {
+ name: 'Expand details for east-100 (VM 100) · PVE connection: east',
+ });
+ const point = toggle.closest('tr')!;
+ expect(point.querySelector('[data-backup-workload-connection]')).toHaveTextContent('PVE: east');
+ expect(point.querySelector('[data-backup-source-connection]')).toHaveTextContent(
+ 'independent-pbs-reader',
+ );
+ expect(screen.queryByTestId('proxmox-recoverable-detail')).not.toBeInTheDocument();
+ expect(apiFetchMock).toHaveBeenCalledTimes(2);
+ vi.useRealTimers();
+ });
+});
diff --git a/frontend-modern/src/features/proxmox/__tests__/ProxmoxRecoverableTable.test.tsx b/frontend-modern/src/features/proxmox/__tests__/ProxmoxRecoverableTable.test.tsx
index 3bf7fee62a..0c7cb8d3d6 100644
--- a/frontend-modern/src/features/proxmox/__tests__/ProxmoxRecoverableTable.test.tsx
+++ b/frontend-modern/src/features/proxmox/__tests__/ProxmoxRecoverableTable.test.tsx
@@ -128,19 +128,20 @@ describe('ProxmoxRecoverableTable record drawer', () => {
});
describe('ProxmoxRecoverableTable responsive columns', () => {
- it('keeps source, location, recovery age, and state visible in compact containers', () => {
+ it('groups full restore-point identity beside age and state in compact containers', () => {
renderTable(330);
expect([...document.querySelectorAll('thead th')].map((th) => th.textContent?.trim())).toEqual([
- 'Workload',
- 'Via',
+ 'Restore point',
'Age▼',
'State',
]);
expect(document.body.textContent).toContain('VM 100');
- // The phone projection has no location column; the row title carries it.
- expect(document.body.textContent).not.toContain('main / pve1');
- expect(document.querySelector('td [title*="main / pve1"]')).not.toBeNull();
+ // No hover is needed to identify the repository on a phone.
+ expect(document.querySelector('[data-backup-location]')).toHaveTextContent('main / pve1');
+ expect(document.querySelector('[data-backup-source-connection]')).toHaveTextContent(
+ 'Connection: Unknown connection',
+ );
expect(document.body.textContent).not.toContain('5 PBS files');
});
diff --git a/frontend-modern/src/features/proxmox/__tests__/proxmoxBackupsTablePresentation.test.ts b/frontend-modern/src/features/proxmox/__tests__/proxmoxBackupsTablePresentation.test.ts
index c38384a1eb..bf281fc88b 100644
--- a/frontend-modern/src/features/proxmox/__tests__/proxmoxBackupsTablePresentation.test.ts
+++ b/frontend-modern/src/features/proxmox/__tests__/proxmoxBackupsTablePresentation.test.ts
@@ -190,22 +190,11 @@ describe('Proxmox backups responsive table presentation', () => {
});
it('keeps the recovery-point answer visible before verbose metadata', () => {
- expect(ids(getRecoverableColumns('compact'))).toEqual([
- 'workload',
- 'source',
- 'created',
- 'state',
- ]);
- expect(getRecoverableColumnWidthStyle('workload', 'compact')).toEqual({ width: '40%' });
- expect(getRecoverableColumnWidthStyle('created', 'compact')).toEqual({ width: '21%' });
- expect(getRecoverableColumnWidthStyle('state', 'compact')).toEqual({ width: '23%' });
- expect(ids(getRecoverableColumns('basic'))).toEqual([
- 'workload',
- 'source',
- 'location',
- 'created',
- 'state',
- ]);
+ expect(ids(getRecoverableColumns('compact'))).toEqual(['workload', 'created', 'state']);
+ expect(getRecoverableColumnWidthStyle('workload', 'compact')).toEqual({ width: '53%' });
+ expect(getRecoverableColumnWidthStyle('created', 'compact')).toEqual({ width: '22%' });
+ expect(getRecoverableColumnWidthStyle('state', 'compact')).toEqual({ width: '25%' });
+ expect(ids(getRecoverableColumns('basic'))).toEqual(['workload', 'created', 'state']);
expect(ids(getRecoverableColumns('expanded'))).not.toContain('details');
expect(ids(getRecoverableColumns('full'))).toHaveLength(9);
});
diff --git a/frontend-modern/src/features/proxmox/__tests__/recoverableIdentityAccess.test.tsx b/frontend-modern/src/features/proxmox/__tests__/recoverableIdentityAccess.test.tsx
new file mode 100644
index 0000000000..0936e54df8
--- /dev/null
+++ b/frontend-modern/src/features/proxmox/__tests__/recoverableIdentityAccess.test.tsx
@@ -0,0 +1,218 @@
+import { cleanup, fireEvent, render, screen, waitFor, within } from '@solidjs/testing-library';
+import { Route, Router } from '@solidjs/router';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+
+import { resetCreateNonSuspendingQueryCacheForTest } from '@/hooks/createNonSuspendingQuery';
+import type { PBSBackup, PVEBackupsPayload } from '@/types/api';
+import { protectionPolicy } from '@/utils/__fixtures__/protectionPosture';
+import { ProxmoxBackupsTable } from '../ProxmoxBackupsTable';
+import {
+ BACKUP_IDENTITY_NOW,
+ identityArchive,
+ identityGuest,
+ identityPBS,
+ identitySnapshot,
+} from '../__fixtures__/backupIdentity';
+
+const api = vi.hoisted(() => ({ fetch: vi.fn(), json: vi.fn(), width: 320 }));
+vi.mock('@/utils/apiClient', () => ({ apiFetch: api.fetch, apiFetchJSON: api.json }));
+vi.mock('@/hooks/useObservedElementWidth', () => ({
+ useObservedElementWidth: () => ({ setElement: () => {}, width: () => api.width }),
+}));
+
+const name = 'accounting-database-production-primary';
+const scopes = [
+ 'pve.cluster.production.london.example.internal',
+ 'pve.cluster.production.bristol.example.internal',
+];
+const workloads = () =>
+ scopes.map((scope, index) => ({
+ ...identityGuest(`guest-${index}`, scope, 'pve-1'),
+ name,
+ displayName: name,
+ }));
+const emptyPVE: PVEBackupsPayload = { storageBackups: [], guestSnapshots: [], backupTasks: [] };
+const response = (data: unknown) =>
+ new Response(JSON.stringify({ data }), { headers: { 'Content-Type': 'application/json' } });
+
+function mount({
+ guests = workloads(),
+ pve = () => ({
+ ...emptyPVE,
+ storageBackups: scopes.map((scope, index) =>
+ identityArchive({ id: `file-${index}`, instance: scope, storage: `repository-${index}` }),
+ ),
+ }),
+ pbs = () => [] as PBSBackup[],
+} = {}) {
+ api.fetch.mockImplementation((url: string) =>
+ Promise.resolve(response(url === '/api/backups/pbs' ? { backups: pbs() } : pve())),
+ );
+ api.json.mockResolvedValue({ data: [], policy: protectionPolicy });
+ render(() => (
+ <Router>
+ <Route
+ path="/*"
+ component={() => <ProxmoxBackupsTable emptyIcon={<span />} workloads={guests} />}
+ />
+ </Router>
+ ));
+}
+async function rows() {
+ await waitFor(() =>
+ expect(document.querySelector('[data-proxmox-backup-row="recoverable"]')).not.toBeNull(),
+ );
+ return Array.from(
+ document.querySelectorAll<HTMLElement>('[data-proxmox-backup-row="recoverable"]'),
+ );
+}
+
+beforeEach(() => {
+ vi.useFakeTimers({ now: BACKUP_IDENTITY_NOW, toFake: ['Date'] });
+ vi.resetAllMocks();
+ api.width = 320;
+ resetCreateNonSuspendingQueryCacheForTest();
+ window.history.replaceState({}, '', '/proxmox/backups/date');
+});
+afterEach(() => {
+ cleanup();
+ resetCreateNonSuspendingQueryCacheForTest();
+ vi.useRealTimers();
+});
+
+describe('restore-point identity without hover', () => {
+ it.each([320, 479, 480, 719, 720, 1200])(
+ 'keeps namesake workload and reader scope distinct at %ipx',
+ async (width) => {
+ api.width = width;
+ mount();
+ const points = await rows();
+ expect(points).toHaveLength(2);
+ for (const [index, scope] of scopes.entries()) {
+ const row = points.find((point) =>
+ point.querySelector('[data-backup-workload-connection]')?.textContent?.includes(scope),
+ )!;
+ expect(row).toBeDefined();
+ expect(row).toHaveTextContent(name);
+ expect(row).toHaveTextContent('100');
+ expect(row.querySelector('[data-backup-source-connection]')).toHaveTextContent(scope);
+ expect(row).toHaveTextContent(`repository-${index}`);
+ if (width < 720) {
+ for (const element of [
+ within(row).getByText(name, { exact: true }),
+ row.querySelector('[data-backup-workload-connection]')!,
+ row.querySelector('[data-backup-source-connection]')!,
+ row.querySelector('[data-backup-location]')!,
+ ]) {
+ expect(element).toHaveClass('whitespace-normal', 'wrap-anywhere');
+ expect(element).not.toHaveClass('truncate');
+ }
+ expect(row.children).toHaveLength(3);
+ expect(row.closest('table')?.querySelector('thead th')).toHaveTextContent('Restore point');
+ }
+ fireEvent.click(within(row).getByRole('button', { name: /Expand details/ }));
+ const panel = screen.getByTestId('proxmox-recoverable-detail');
+ expect(panel).toHaveTextContent(scope);
+ expect(panel).toHaveTextContent(`repository-${index}`);
+ expect(panel).not.toHaveTextContent(`repository-${1 - index}`);
+ expect(within(panel).getByRole('link', { name: `Open ${name}` })).toHaveAttribute(
+ 'href',
+ `/proxmox/overview?resource=guest-${index}`,
+ );
+ }
+ expect(api.fetch).toHaveBeenCalledTimes(2);
+ expect(screen.getByRole('button', { name: '2 unknown' })).toBeInTheDocument();
+ },
+ );
+
+ it.each(['pbs', 'archive', 'snapshot'] as const)(
+ 'exposes the complete %s reader/location without changing its source kind',
+ async (kind) => {
+ const reader = 'backup.connection.long-name.example.internal';
+ const location = 'repository-with-a-long-preserved-name';
+ mount({
+ guests: workloads().slice(0, 1),
+ pve: () => ({
+ ...emptyPVE,
+ storageBackups:
+ kind === 'archive' ? [identityArchive({ instance: scopes[0], storage: location })] : [],
+ guestSnapshots: kind === 'snapshot' ? [identitySnapshot({ instance: scopes[0] })] : [],
+ }),
+ pbs: () =>
+ kind === 'pbs'
+ ? [identityPBS({ instance: reader, namespace: 'pve-1', datastore: location })]
+ : [],
+ });
+ const [point] = await rows();
+ expect(point.querySelector('[data-backup-workload-connection]')).toHaveTextContent(scopes[0]);
+ expect(point.querySelector('[data-backup-source-connection]')).toHaveTextContent(
+ kind === 'pbs' ? reader : scopes[0],
+ );
+ expect(point.querySelector('[data-backup-location]')).toHaveTextContent(
+ kind === 'pbs' ? `${location} / pve-1` : kind === 'archive' ? location : 'pve-1',
+ );
+ expect(
+ within(point.children[0] as HTMLElement).getByText(
+ kind === 'pbs' ? 'PBS' : kind === 'archive' ? 'PVE file' : 'Snapshot',
+ ),
+ ).toBeInTheDocument();
+ expect(point).toHaveTextContent(
+ kind === 'pbs' ? 'Verified' : kind === 'snapshot' ? 'Snapshot' : 'Backup file',
+ );
+ },
+ );
+
+ it('does not borrow a reader connection for an ambiguous guest or host backup', async () => {
+ mount({
+ pve: () => emptyPVE,
+ pbs: () => [
+ identityPBS({ instance: 'shared-pbs', namespace: 'pve-1' }),
+ identityPBS({ id: 'host', instance: 'shared-pbs', backupType: 'host', vmid: '0' }),
+ ],
+ });
+ const points = await rows();
+ expect(points).toHaveLength(2);
+ const guest = points.find((point) => point.textContent?.includes('VM 100'))!;
+ expect(guest.querySelector('[data-backup-workload-connection]')).toHaveTextContent(
+ 'PVE: Not reported',
+ );
+ expect(guest.querySelector('[data-backup-source-connection]')).toHaveTextContent('shared-pbs');
+ const host = points.find((point) => point !== guest)!;
+ expect(host.querySelector('[data-backup-workload-connection]')).toBeNull();
+ expect(host.querySelector('[data-backup-source-connection]')).toHaveTextContent('shared-pbs');
+ fireEvent.click(within(guest).getByRole('button', { name: /Expand details/ }));
+ expect(within(screen.getByTestId('proxmox-recoverable-detail')).queryByRole('link')).toBeNull();
+ });
+
+ it('updates an open point in place without dropping focus or borrowing its new reader', async () => {
+ vi.useFakeTimers({
+ now: BACKUP_IDENTITY_NOW,
+ toFake: ['Date', 'setInterval', 'clearInterval'],
+ });
+ let reader = 'pbs-before';
+ let datastore = 'before';
+ mount({
+ guests: workloads().slice(0, 1),
+ pve: () => emptyPVE,
+ pbs: () => [identityPBS({ instance: reader, datastore })],
+ });
+ const [point] = await rows();
+ const toggle = within(point).getByRole('button', { name: /Expand details/ });
+ fireEvent.click(toggle);
+ toggle.focus();
+ const panel = screen.getByTestId('proxmox-recoverable-detail');
+ reader = 'pbs-after';
+ datastore = 'after';
+ await vi.advanceTimersByTimeAsync(30_000);
+ await waitFor(() =>
+ expect(point.querySelector('[data-backup-source-connection]')).toHaveTextContent(reader),
+ );
+ expect(point.querySelector('[data-backup-workload-connection]')).toHaveTextContent(scopes[0]);
+ expect(point.querySelector('[data-backup-location]')).toHaveTextContent('after / pve-1');
+ expect(screen.getByTestId('proxmox-recoverable-detail')).toBe(panel);
+ expect(panel).toHaveTextContent(reader);
+ expect(panel).not.toHaveTextContent('pbs-before');
+ expect(document.activeElement).toBe(toggle);
+ expect(api.fetch).toHaveBeenCalledTimes(4);
+ });
+});
diff --git a/frontend-modern/src/features/proxmox/proxmoxBackupsTablePresentation.ts b/frontend-modern/src/features/proxmox/proxmoxBackupsTablePresentation.ts
index 9c6cf2c440..dfc9dbd8da 100644
--- a/frontend-modern/src/features/proxmox/proxmoxBackupsTablePresentation.ts
+++ b/frontend-modern/src/features/proxmox/proxmoxBackupsTablePresentation.ts
@@ -263,14 +263,12 @@ export const RECOVERABLE_COLUMNS: readonly BackupTableColumn<RecoverableColumnId
];
const RECOVERABLE_VISIBLE: Record<ProxmoxBackupsTableLayoutMode, readonly RecoverableColumnId[]> = {
- // A recovery-point feed starts with identity, source, location, age, and
- // verification. Size and verbose details progressively return with usable
- // room; the full values remain available through their title affordance.
- // The phone projection keeps the source and state badges and the age whole;
- // the repository location returns with the first wider layout and stays in
- // the row's hover title meanwhile.
- compact: ['workload', 'source', 'created', 'state'],
- basic: ['workload', 'source', 'location', 'created', 'state'],
+ // Narrow restore-point rows group full workload/source/location identity in
+ // the first cell. Separate tiny columns hid namesake connections behind hover
+ // titles on touch devices. Age and state remain independent scan columns;
+ // size and provider identifiers stay progressive detail in the drawer.
+ compact: ['workload', 'created', 'state'],
+ basic: ['workload', 'created', 'state'],
operational: ['workload', 'type', 'source', 'location', 'created', 'size', 'state'],
expanded: ['workload', 'type', 'targetId', 'source', 'location', 'created', 'size', 'state'],
full: RECOVERABLE_COLUMNS.map((column) => column.id),
@@ -280,11 +278,10 @@ const RECOVERABLE_WEIGHTS: Record<
ProxmoxBackupsTableLayoutMode,
Partial<Record<RecoverableColumnId, number>>
> = {
- // Unknown is a safety answer, not an abbreviated age: reserve room for
- // the whole word alongside complete state badges (including Failed and
- // Running). Identity remains on the canonical 40% anchor.
- compact: { workload: 40, source: 16, created: 21, state: 23 },
- basic: { workload: 28, source: 14, location: 23, created: 18, state: 17 },
+ // Grouping identity needs more room than a single name. Keep Unknown ages
+ // and full state words readable rather than trading one hidden fact for another.
+ compact: { workload: 53, created: 22, state: 25 },
+ basic: { workload: 58, created: 20, state: 22 },
operational: {
workload: 24,
type: 8,
@@ -332,15 +329,6 @@ export const getRecoverableColumnWidthStyle = (
columnId,
RECOVERABLE_WEIGHTS[layout],
RECOVERABLE_VISIBLE[layout],
- layout === 'compact' || layout === 'basic'
- ? {
- columnId: 'workload',
- widthPercent:
- layout === 'compact'
- ? PLATFORM_TABLE_NARROW_IDENTITY_WIDTH_PERCENT
- : PLATFORM_TABLE_PHONE_IDENTITY_WIDTH_PERCENT,
- }
- : undefined,
);
export const isCompactBackupIdentityLayout = (layout: ProxmoxBackupsTableLayoutMode): boolean =>