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.

Restore the PBS web-interface shortcut in Backups

pulse-triage[bot]ea34298da15e
diff --git a/frontend-modern/browser-tests/pbs-web-interface.cjs b/frontend-modern/browser-tests/pbs-web-interface.cjs
new file mode 100644
index 0000000000..7437d11e9d
--- /dev/null
+++ b/frontend-modern/browser-tests/pbs-web-interface.cjs
@@ -0,0 +1,263 @@
+// Real PBS table, inline drawer and CSS on synthetic resources. No external navigation.
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const path = require('node:path');
+const crypto = require('node:crypto');
+const { pathToFileURL } = require('node:url');
+const { chromium, webkit } = require('playwright');
+const root = '/workspace/frontend-modern';
+const output = '/workspace/tmp/pbs-web-interface-proof';
+const origin = 'http://127.0.0.1:5337';
+const hash = (file) => crypto.createHash('sha256').update(fs.readFileSync(file)).digest('hex');
+const result = {
+ result: 'incomplete',
+ playwright: require('playwright/package.json').version,
+ binding: JSON.parse(fs.readFileSync(output + '/binding.json')),
+ sources: {},
+ cases: [],
+ captures: [],
+ cleanup: {},
+ limits:
+ 'Production PBS table, shared URL control, inline drawer and CSS in a synthetic fixture. Link activation is intercepted before navigation. No live PBS, guest, full application shell, installed release or reporter acceptance.',
+};
+assert.equal(
+ result.playwright,
+ JSON.parse(fs.readFileSync('/workspace/tests/integration/package-lock.json')).packages[
+ 'node_modules/@playwright/test'
+ ].version,
+);
+for (const [file, digest] of Object.entries(result.binding.inputs)) {
+ assert.equal(hash('/workspace/' + file), digest);
+}
+
+(async () => {
+ let server;
+ let browser;
+ try {
+ const { createServer } = await import(
+ pathToFileURL(path.join(root, 'node_modules/vite/dist/node/index.js'))
+ );
+ const { default: solid } = await import(
+ pathToFileURL(path.join(root, 'node_modules/vite-plugin-solid/dist/esm/index.mjs'))
+ );
+ const { default: tailwind } = await import(
+ pathToFileURL(path.join(root, 'node_modules/@tailwindcss/vite/dist/index.mjs'))
+ );
+ server = await createServer({
+ root,
+ configFile: false,
+ envFile: false,
+ publicDir: false,
+ plugins: [
+ {
+ name: 'pbs-proof-source-observation',
+ enforce: 'pre',
+ transform(_code, id) {
+ const file = id.split('?')[0];
+ if (file.startsWith(root + '/src/') && fs.existsSync(file)) {
+ result.sources[path.relative('/workspace', file)] = hash(file);
+ }
+ },
+ },
+ solid(),
+ tailwind(),
+ ],
+ resolve: { alias: { '@': root + '/src' } },
+ optimizeDeps: { noDiscovery: true, esbuildOptions: { target: 'esnext' } },
+ server: { host: '127.0.0.1', port: 5337, strictPort: true, hmr: false },
+ });
+ await server.listen();
+ for (const [name, engine, width, height, dark] of [
+ ['desktop', chromium, 1365, 900, false],
+ ['phone', webkit, 390, 844, true],
+ ]) {
+ browser = await engine.launch(
+ engine === chromium
+ ? { headless: true, channel: 'chromium', args: ['--no-sandbox'] }
+ : { headless: true },
+ );
+ const context = await browser.newContext({
+ viewport: { width, height },
+ isMobile: width < 768,
+ hasTouch: width < 768,
+ locale: 'en-GB',
+ reducedMotion: 'reduce',
+ });
+ const page = await context.newPage();
+ page.setDefaultTimeout(10000);
+ const record = {
+ name,
+ width,
+ height,
+ dark,
+ browser: browser.version(),
+ reads: [],
+ errors: [],
+ };
+ result.cases.push(record);
+ page.on('pageerror', (error) => record.errors.push(error.message));
+ await page.route('**/*', (route) => {
+ const url = new URL(route.request().url());
+ assert.equal(url.origin, origin, 'no external request');
+ if (!url.pathname.startsWith('/api/')) return route.continue();
+ assert.equal(route.request().method(), 'GET', 'no mutation');
+ assert(!/diagnostics|guest-agent|qemu|\/run/.test(url.pathname), 'no live probe');
+ record.reads.push(url.pathname);
+ return route.fulfill({
+ json: { success: true, data: [], alerts: [], anomalies: [], config: null },
+ });
+ });
+ await page.addInitScript((dark) => {
+ window.__pbsActivations = [];
+ document.addEventListener(
+ 'click',
+ (event) => {
+ const anchor = event.target.closest('a[target="_blank"]');
+ if (anchor) {
+ event.preventDefault();
+ window.__pbsActivations.push(anchor.getAttribute('href'));
+ }
+ },
+ true,
+ );
+ document.addEventListener('DOMContentLoaded', () =>
+ document.documentElement.classList.toggle('dark', dark),
+ );
+ }, dark);
+ await page.goto(origin + '/browser-tests/pbs-web-interface.html', {
+ waitUntil: 'domcontentloaded',
+ timeout: 45000,
+ });
+ const table = page.locator('[data-proxmox-backups-table="servers"]');
+ const east = table.locator('a[href="https://east.example:8007/proxy/"]').first();
+ await east.waitFor();
+ assert.equal(await table.getByRole('link').count(), 6);
+ assert.equal(await table.locator('a[href="http://[2001:db8::2]:8007/"]').count(), 2);
+ assert.equal(await table.locator('a[href*="WRONG-HOST"]').count(), 0);
+ assert.equal(
+ await table
+ .getByRole('img', { name: 'Web interface URL for unsafe-url is invalid' })
+ .count(),
+ 2,
+ );
+ const row = east.locator('xpath=ancestor::tr');
+ const identity = await row.elementHandle();
+ const label = row.locator('span[title="pbs-main"]');
+ const capture = async (state) => {
+ const file = `${name}-${state}.png`;
+ await page.screenshot({ path: output + '/' + file, fullPage: true });
+ result.captures.push({ file, sha256: hash(output + '/' + file) });
+ };
+ record.geometry = await label.evaluate((element) => ({
+ visible: element.clientWidth,
+ full: element.scrollWidth,
+ }));
+ assert(record.geometry.visible > 0 && record.geometry.full <= record.geometry.visible + 1);
+ const box = await east.boundingBox();
+ const cellBox = await row.locator('td').first().boundingBox();
+ assert(box.width >= 24 && box.height >= 24, 'shared target remains usable');
+ assert(box.x >= cellBox.x && box.x + box.width <= cellBox.x + cellBox.width + 1);
+ assert.equal(await east.getAttribute('rel'), 'noopener noreferrer');
+ assert.equal(await east.getAttribute('target'), '_blank');
+ // Real Tab order and Enter, not a synthetic click standing in for keyboard activation.
+ for (let step = 0; step < 30; step++) {
+ await page.keyboard.press('Tab');
+ if (await east.evaluate((element) => element === document.activeElement)) break;
+ }
+ assert.equal(
+ await page.locator(':focus').getAttribute('href'),
+ 'https://east.example:8007/proxy/',
+ );
+ await capture('keyboard-link');
+ await page.keyboard.press('Enter');
+ if (width < 768) await east.tap();
+ else await east.click();
+ assert.deepEqual(await page.evaluate(() => window.__pbsActivations), [
+ 'https://east.example:8007/proxy/',
+ 'https://east.example:8007/proxy/',
+ ]);
+ assert.equal(await page.locator('[data-inline-platform-resource-detail-for]').count(), 0);
+ if (width < 768) {
+ // Shared platform rows use the full row touch target on phones.
+ await label.tap();
+ } else {
+ const toggle = row.getByRole('button', { name: 'Expand details for pbs-main' });
+ await toggle.focus();
+ await page.keyboard.press('Space');
+ }
+ await page.locator('[data-inline-platform-resource-detail-for="pbs-east"]').waitFor();
+ assert.equal(await page.locator('[data-inline-platform-resource-detail-for]').count(), 1);
+ await capture('same-server-details');
+ await label.click();
+ await page.evaluate(() => {
+ window.__pbsWeb.reverse();
+ window.__pbsWeb.update('pbs-east', 'javascript:alert(1)');
+ });
+ await page.waitForFunction(
+ () => !document.querySelector('a[href="https://east.example:8007/proxy/"]'),
+ );
+ assert.equal(
+ await table.getByRole('img', { name: 'Web interface URL for pbs-main is invalid' }).count(),
+ 2,
+ );
+ assert.equal(await table.locator('a[href="http://[2001:db8::2]:8007/"]').count(), 2);
+ assert(await identity.evaluate((element) => element.isConnected));
+ await page.evaluate(() => window.__pbsWeb.update('pbs-east', ''));
+ await page.waitForFunction(
+ () =>
+ ![...document.querySelectorAll('[role="img"]')].some(
+ (element) =>
+ element.getAttribute('aria-label') === 'Web interface URL for pbs-main is invalid',
+ ),
+ );
+ assert.equal(await identity.evaluate((element) => element.querySelectorAll('a').length), 0);
+ await page.evaluate(() =>
+ window.__pbsWeb.update('pbs-east', ' https://edited.example:8443/pbs/ '),
+ );
+ await table.locator('a[href="https://edited.example:8443/pbs/"]').first().waitFor();
+ assert.equal(await table.locator('a[href="https://edited.example:8443/pbs/"]').count(), 2);
+ await capture('edited-url');
+ if (width < 768) {
+ await page.setViewportSize({ width: 320, height });
+ await page.waitForTimeout(100);
+ const narrow = await table
+ .locator('a[href="https://edited.example:8443/pbs/"]')
+ .first()
+ .boundingBox();
+ assert(narrow.width >= 24 && narrow.height >= 24);
+ await capture('narrow-320');
+ }
+ assert(await page.evaluate(() => document.documentElement.scrollWidth <= innerWidth + 1));
+ assert.deepEqual(record.errors, []);
+ record.checks = [
+ 'service-owned targets',
+ 'invalid/unset/revoked targets',
+ 'Tab/Enter and pointer/touch',
+ 'separate real drawer disclosure',
+ 'same keyed rows after reordering',
+ 'no horizontal overflow',
+ ];
+ await context.close();
+ await browser.close();
+ browser = undefined;
+ record.closed = true;
+ }
+ assert.equal(
+ result.sources['frontend-modern/src/features/proxmox/ProxmoxBackupServersTable.tsx'],
+ result.binding.inputs['frontend-modern/src/features/proxmox/ProxmoxBackupServersTable.tsx'],
+ );
+ result.result = 'passed';
+ } catch (error) {
+ result.error = error.message;
+ throw error;
+ } finally {
+ if (browser) await browser.close();
+ result.cleanup.browser_closed = true;
+ if (server) await server.close();
+ result.cleanup.server_closed = true;
+ fs.writeFileSync(output + '/result.json', JSON.stringify(result, null, 2) + '\n');
+ }
+})().catch((error) => {
+ console.error(error);
+ process.exitCode = 1;
+});
diff --git a/frontend-modern/browser-tests/pbs-web-interface.html b/frontend-modern/browser-tests/pbs-web-interface.html
new file mode 100644
index 0000000000..813842a286
--- /dev/null
+++ b/frontend-modern/browser-tests/pbs-web-interface.html
@@ -0,0 +1,12 @@
+<!doctype html>
+<html>
+ <head>
+ <meta charset="UTF-8" />
+ <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+ <title>PBS web-interface parity</title>
+ </head>
+ <body>
+ <div id="root"></div>
+ <script type="module" src="/browser-tests/pbs-web-interface.tsx"></script>
+ </body>
+</html>
diff --git a/frontend-modern/browser-tests/pbs-web-interface.tsx b/frontend-modern/browser-tests/pbs-web-interface.tsx
new file mode 100644
index 0000000000..0b68f8d9e0
--- /dev/null
+++ b/frontend-modern/browser-tests/pbs-web-interface.tsx
@@ -0,0 +1,94 @@
+// Real Backups server table/drawer/CSS; synthetic, credential-free resources only.
+import { createSignal } from 'solid-js';
+import { render } from 'solid-js/web';
+import { Router, Route } from '@solidjs/router';
+import { ProxmoxBackupServersTable } from '../src/features/proxmox/ProxmoxBackupServersTable';
+import type { Resource } from '../src/types/resource';
+import { DarkModeContext, WebSocketContext } from '../src/contexts/appRuntime';
+import { syncAIRuntimeSettings } from '../src/stores/aiRuntimeState';
+import '../src/index.css';
+
+// Explicit offline context, not a live WebSocket or automatic discovery probe.
+syncAIRuntimeSettings({ discovery_enabled: false });
+const server = (id: string, name: string, customUrl?: string): Resource => ({
+ id,
+ type: 'pbs',
+ name,
+ displayName: name,
+ platformId: id,
+ platformType: 'proxmox-pbs',
+ sourceType: 'api',
+ sources: ['pbs'],
+ status: 'online',
+ lastSeen: Date.now(),
+ customUrl,
+ pbs: {
+ instanceId: id,
+ nodeName: 'host.example',
+ linkedAgentId: 'agent-host',
+ connectionHealth: 'healthy',
+ version: '3.2.1',
+ datastores: [
+ { name: 'archive', total: 1000, used: 400, available: 600, status: 'available' },
+ { name: 'main', total: 1000, used: 200, available: 800, status: 'available' },
+ ],
+ },
+});
+const initial = [
+ server('pbs-east', 'pbs-main', 'https://east.example:8007/proxy/'),
+ server('pbs-west', 'pbs-main', 'http://[2001:db8::2]:8007/'),
+ server(
+ 'pbs-long',
+ 'backup-server-with-a-very-long-readable-identity',
+ 'https://long.example:8007',
+ ),
+ server('pbs-invalid', 'unsafe-url', 'javascript:alert(1)'),
+ server('pbs-unset', 'no-url'),
+];
+const host: Resource = {
+ id: 'host',
+ type: 'agent',
+ name: 'pbs-main',
+ displayName: 'pbs-main',
+ platformId: 'host',
+ platformType: 'proxmox-pbs',
+ sourceType: 'agent',
+ status: 'online',
+ lastSeen: Date.now(),
+ agent: { agentId: 'agent-host', hostname: 'host.example' },
+ customUrl: 'https://WRONG-HOST.example:9000',
+};
+function Fixture() {
+ const [servers, setServers] = createSignal([...initial, host]);
+ (window as any).__pbsWeb = {
+ update: (id: string, url: string) =>
+ setServers((current) => current.map((r) => (r.id === id ? { ...r, customUrl: url } : r))),
+ reverse: () =>
+ setServers((current) =>
+ [...current].reverse().map((r) => ({
+ ...r,
+ pbs: r.pbs ? { ...r.pbs, datastores: [...r.pbs.datastores!].reverse() } : undefined,
+ })),
+ ),
+ };
+ return (
+ <main class="min-h-screen bg-surface p-3 text-base-content">
+ <h1 class="mb-3 text-base font-semibold">Backup servers</h1>
+ <ProxmoxBackupServersTable servers={servers()} />
+ </main>
+ );
+}
+render(
+ () => (
+ <WebSocketContext.Provider
+ value={{ state: { pmg: [] }, activeAlerts: {}, connected: () => false } as any}
+ >
+ <DarkModeContext.Provider value={() => document.documentElement.classList.contains('dark')}>
+ <Router>
+ <Route path="/*" component={Fixture} />
+ </Router>
+ </DarkModeContext.Provider>
+ </WebSocketContext.Provider>
+ ),
+ document.getElementById('root')!,
+);
diff --git a/frontend-modern/browser-verification/a0e792288e1a34c9.json b/frontend-modern/browser-verification/a0e792288e1a34c9.json
new file mode 100644
index 0000000000..a6a8d8be7a
--- /dev/null
+++ b/frontend-modern/browser-verification/a0e792288e1a34c9.json
@@ -0,0 +1,41 @@
+{
+ "version": 1,
+ "result": "passed",
+ "base_sha": "2e491f8b5b767bfb8c567dd07fd7c2750a5ebbbc",
+ "changed_paths": [
+ "frontend-modern/src/features/proxmox/ProxmoxBackupServersTable.tsx"
+ ],
+ "content_sha256": {
+ "frontend-modern/src/features/proxmox/ProxmoxBackupServersTable.tsx": "38d53d52decca63bb80afd7372ee8d2be0122dd476dcd7742dfc934c6f58af3a"
+ },
+ "routes": [
+ "/browser-tests/pbs-web-interface.html \u2014 real Backups server table and inline ResourceDetailDrawer, synthetic resources; not the full App"
+ ],
+ "states": [
+ "Two datastores per service; repeated PBS labels and a same-named linked host with a different URL",
+ "Invalid or absent URL; invalid, cleared and edited URL on surviving keyed rows",
+ "Real same-server details open, then closed; existing capacity and History identity unchanged"
+ ],
+ "interactions": [
+ "Native Tab/Enter and pointer/touch open only the explicit service-owned URL, intercepted before external navigation",
+ "Desktop keyboard Space and phone row touch open only the selected real inline drawer",
+ "Reorder datastores and same-labelled services, revoke URL, then edit; no old or host target substitution",
+ "Inspect seven screenshots, target bounds and horizontal overflow on light desktop and dark phone"
+ ],
+ "viewports": [
+ {
+ "width": 1365,
+ "height": 900
+ },
+ {
+ "width": 390,
+ "height": 844
+ },
+ {
+ "width": 320,
+ "height": 844
+ }
+ ],
+ "verified_at": "2026-10-09T10:12:00.970973Z",
+ "browser_evidence": "pulse-worker-browser frontend-modern/browser-tests/pbs-web-interface.cjs; Playwright 1.56.1; Chromium 141.0.7390.37 and WebKit 26.0; two successful engine cases; seven inspected captures; completed browser/server closure. Source/fixture/lock hashes in retained outcome dossier. No off-origin request, live PBS, full-shell or release acceptance."
+}
diff --git a/frontend-modern/src/features/proxmox/ProxmoxBackupServersTable.tsx b/frontend-modern/src/features/proxmox/ProxmoxBackupServersTable.tsx
index 18b98637e8..81bc015757 100644
--- a/frontend-modern/src/features/proxmox/ProxmoxBackupServersTable.tsx
+++ b/frontend-modern/src/features/proxmox/ProxmoxBackupServersTable.tsx
@@ -2,6 +2,7 @@ import { For, Show, createMemo, type Accessor, type JSX } from 'solid-js';
import { unwrap } from 'solid-js/store';
import { StatusDot } from '@/components/shared/StatusDot';
+import { ResourceNameWithWebInterfaceLink } from '@/components/shared/WebInterfaceLink';
import { TableCell, TableHead, TableRow } from '@/components/shared/Table';
import {
formatPlatformTableBytesValue,
@@ -538,9 +539,12 @@ export function ProxmoxBackupServersTable(props: {
controlsId={detailRowId()}
onToggle={() => detail.toggle(rowIdentity)}
/>
- <div class="min-w-0 truncate" title={row.serverName}>
- {row.serverName}
- </div>
+ <ResourceNameWithWebInterfaceLink
+ name={row.serverName}
+ url={row.resource.customUrl}
+ class="min-w-0 flex-1"
+ nameClass="block min-w-0 flex-1 truncate"
+ />
</div>
</TableCell>
<TableCell class={getPlatformTableCellClassForKind('text')}>
diff --git a/frontend-modern/src/features/proxmox/__tests__/ProxmoxBackupServersTable.webInterface.test.tsx b/frontend-modern/src/features/proxmox/__tests__/ProxmoxBackupServersTable.webInterface.test.tsx
new file mode 100644
index 0000000000..906ec7e2b2
--- /dev/null
+++ b/frontend-modern/src/features/proxmox/__tests__/ProxmoxBackupServersTable.webInterface.test.tsx
@@ -0,0 +1,153 @@
+import { cleanup, fireEvent, render, waitFor, within } from '@solidjs/testing-library';
+import { createSignal } from 'solid-js';
+import { afterEach, describe, expect, it, vi } from 'vitest';
+import type { Resource } from '@/types/resource';
+import { ProxmoxBackupServersTable } from '../ProxmoxBackupServersTable';
+
+vi.mock('@/components/Infrastructure/ResourceDetailDrawer', () => ({
+ ResourceDetailDrawer: (props: { resource: Resource }) => (
+ <div data-testid="pbs-detail" data-resource-id={props.resource.id}>
+ PBS details
+ </div>
+ ),
+}));
+afterEach(cleanup);
+
+const server = (
+ id = 'pbs-east',
+ customUrl: string | undefined = 'https://pbs-east.example:8007',
+): Resource => ({
+ id,
+ type: 'pbs',
+ name: 'pbs-main',
+ displayName: 'pbs-main',
+ platformId: id,
+ platformType: 'proxmox-pbs',
+ sourceType: 'api',
+ status: 'online',
+ lastSeen: 1_790_000_000_000,
+ customUrl,
+ pbs: {
+ instanceId: id,
+ nodeName: 'host.example',
+ linkedAgentId: 'agent-host',
+ connectionHealth: 'healthy',
+ datastores: [
+ { name: 'archive', total: 1000, used: 400, available: 600 },
+ { name: 'main', total: 1000, used: 200, available: 800 },
+ ],
+ },
+});
+const host: Resource = {
+ id: 'host',
+ type: 'agent',
+ name: 'pbs-main',
+ displayName: 'pbs-main',
+ platformId: 'host',
+ platformType: 'proxmox-pbs',
+ sourceType: 'agent',
+ status: 'online',
+ lastSeen: 1_790_000_000_000,
+ agent: { agentId: 'agent-host', hostname: 'host.example' },
+ customUrl: 'https://UNRELATED-HOST.example:9000',
+};
+
+describe('PBS Backups web-interface parity', () => {
+ it.each([320, 390, 768, 1365])(
+ 'uses the service-owned URL on every datastore at width %s without opening details',
+ (width) => {
+ const ancestorKeydown = vi.fn();
+ const { container } = render(() => (
+ <div onKeyDown={ancestorKeydown}>
+ <ProxmoxBackupServersTable servers={[server(), host]} layoutWidth={() => width} />
+ </div>
+ ));
+ const links = within(container).getAllByRole('link', {
+ name: 'Open web interface for pbs-main',
+ });
+ expect(links).toHaveLength(2);
+ for (const link of links) {
+ expect(link).toHaveAttribute('href', 'https://pbs-east.example:8007');
+ expect(link).toHaveAttribute('target', '_blank');
+ expect(link).toHaveAttribute('rel', 'noopener noreferrer');
+ // Solid delegates key events: check its actual ancestor handler, not a
+ // native intermediate listener that runs before delegated dispatch.
+ link.addEventListener('click', (event) => event.preventDefault());
+ fireEvent.keyDown(link, { key: 'Enter' });
+ fireEvent.click(link);
+ expect(ancestorKeydown).not.toHaveBeenCalled();
+ expect(within(container).queryByTestId('pbs-detail')).not.toBeInTheDocument();
+ }
+ expect(container.innerHTML).not.toContain('UNRELATED-HOST');
+ fireEvent.click(
+ within(container).getAllByRole('button', { name: 'Expand details for pbs-main' })[0],
+ );
+ expect(within(container).getByTestId('pbs-detail')).toHaveAttribute(
+ 'data-resource-id',
+ 'pbs-east',
+ );
+ },
+ );
+
+ it('keeps same-labelled services and reordered datastores bound to their own endpoints', async () => {
+ const east = server();
+ const west = server('pbs-west', 'http://[2001:db8::2]:8007/proxy/');
+ const [servers, setServers] = createSignal([east, west, host]);
+ const { container } = render(() => <ProxmoxBackupServersTable servers={servers()} />);
+ const hrefs = () =>
+ within(container)
+ .getAllByRole('link')
+ .map((a) => a.getAttribute('href'));
+ expect(hrefs()).toEqual([east.customUrl, east.customUrl, west.customUrl, west.customUrl]);
+ setServers([
+ { ...west, pbs: { ...west.pbs!, datastores: [...west.pbs!.datastores!].reverse() } },
+ east,
+ ]);
+ await waitFor(() =>
+ expect(hrefs()).toEqual([east.customUrl, east.customUrl, west.customUrl, west.customUrl]),
+ );
+ });
+
+ it.each([
+ 'javascript:alert(1)',
+ 'data:text/html,test',
+ '//pbs.example:8007',
+ '/pbs',
+ 'not a URL',
+ ])('warns rather than navigating an unsafe persisted URL %s', (url) => {
+ const { container } = render(() => (
+ <ProxmoxBackupServersTable servers={[server('pbs-east', url)]} />
+ ));
+ expect(within(container).queryByRole('link')).not.toBeInTheDocument();
+ expect(
+ within(container).getAllByRole('img', { name: 'Web interface URL for pbs-main is invalid' }),
+ ).toHaveLength(2);
+ expect(within(container).getAllByText('pbs-main')).toHaveLength(2);
+ });
+
+ it('withdraws an edited or cleared URL without replacing it with a host, name or remembered endpoint', async () => {
+ const pbs = server();
+ const [servers, setServers] = createSignal([pbs, host]);
+ const { container } = render(() => <ProxmoxBackupServersTable servers={servers()} />);
+ expect(within(container).getAllByRole('link')).toHaveLength(2);
+ setServers([{ ...pbs, customUrl: 'javascript:alert(1)' }, host]);
+ await waitFor(() => expect(within(container).queryByRole('link')).not.toBeInTheDocument());
+ setServers([{ ...pbs, customUrl: '' }, host]);
+ await waitFor(() => expect(within(container).queryByRole('img')).not.toBeInTheDocument());
+ expect(within(container).queryByRole('link')).not.toBeInTheDocument();
+ setServers([{ ...pbs, customUrl: ' https://new.example:8443/pbs/ ' }]);
+ await waitFor(() =>
+ expect(within(container).getAllByRole('link')[0]).toHaveAttribute(
+ 'href',
+ 'https://new.example:8443/pbs/',
+ ),
+ );
+ });
+
+ it('does not invent an endpoint when a server has no custom URL or datastore', () => {
+ const pbs = { ...server(), customUrl: undefined, pbs: { ...server().pbs!, datastores: [] } };
+ const { container } = render(() => <ProxmoxBackupServersTable servers={[pbs, host]} />);
+ expect(within(container).queryByRole('link')).not.toBeInTheDocument();
+ expect(within(container).getByText('pbs-main')).toBeInTheDocument();
+ });
+});