feat(260923-dhh): Proxmox-Modul Aufgabe 6 - Modulseite mit Auslastung

- ServerCard.tsx: einzige Stelle, die einen Messwert in Text verwandelt
  (formatMetric) — null wird ueberall "unbekannt", nie 0/NaN/leer;
  verzweigt ueber productType auf PVE/PBS/PMG; PBS ohne Sicherung zeigt
  "noch keine Sicherung" statt eines Fehlers; nicht erreichbarer Server
  zeigt Klartext-Ursache plus Zeitpunkt der letzten erfolgreichen Messung
- page.tsx: "Jetzt aktualisieren" fragt alle Server neu ab und laedt die
  Liste danach neu, waehrend des Laufs gesperrt; ruhiger Hinweis bei
  leerer Liste mit Weg zu den Einstellungen; Link zu den Einstellungen
  nur fuer Administratoren sichtbar (Anzeige, kein Zugriffsriegel)
- proxmox-api.ts: ProxmoxMetrics-Union (Pve/Pbs/Pmg) fuer typsichere
  Verzweigung im Frontend
- umlaut-dictionary.ts: zwei weitere korrekte Woerter auf die
  Positivliste (Messung, Prozessorlast)

Tore: web 708/708 (>=693), type-check 4/4, Biome apps/web 53 Warnungen
(unveraendert).

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
This commit is contained in:
2026-09-23 14:45:27 +02:00
parent 723cf6814b
commit 06fcdc0157
7 changed files with 622 additions and 34 deletions
@@ -0,0 +1,255 @@
import { cleanup, render, screen } from '@testing-library/react';
import { afterEach, describe, expect, it, vi } from 'vitest';
import type { ProxmoxServer } from '@/lib/proxmox-api';
vi.mock('next-intl', () => ({
useTranslations: () => (key: string, params?: Record<string, string | number>) => {
const translations: Record<string, string> = {
'card.unknownValue': 'unbekannt',
'card.lastPolledLabel': 'Letzte Abfrage',
'card.lastOkLabel': 'Letzte erfolgreiche Messung',
'card.pve.nodeCount': 'Knoten',
'card.pve.guests': '{running} laufend / {stopped} gestoppt',
'card.pve.cpu': 'Prozessorlast',
'card.pve.mem': 'Speicher',
'card.pbs.used': 'Belegt',
'card.pbs.lastBackup': 'Letzte Sicherung',
'card.pbs.noBackupYet': 'noch keine Sicherung',
'card.pbs.verifyState': 'Letzte Prüfung',
'card.pmg.countIn': 'Eingehend',
'card.pmg.countOut': 'Ausgehend',
'card.pmg.spamCount': 'Spam',
'card.pmg.virusCount': 'Viren',
'errors.netz': 'Der Server ist nicht erreichbar.',
'errors.zugang': 'Der Zugang wurde abgelehnt.',
'errors.rechte': 'Die Rechte reichen nicht aus.',
'errors.zertifikat': 'Das Zertifikat wurde abgelehnt.',
'errors.antwortform': 'Unerwartete Antwortform.',
'errors.server': 'Serverfehler.',
'errors.unbekannt': 'Unerwarteter Fehler.',
};
let result = translations[key] ?? key;
if (params) {
for (const [k, v] of Object.entries(params)) {
result = result.replace(`{${k}}`, String(v));
}
}
return result;
},
}));
afterEach(() => {
cleanup();
});
function makeServer(overrides: Partial<ProxmoxServer> = {}): ProxmoxServer {
return {
id: 'srv-1',
tenantId: 't1',
name: 'pve-1',
productType: 'pve',
baseUrl: 'https://pve.intern',
authMethod: 'token',
tokenId: 'root@pam!x',
username: null,
tlsRejectUnauthorized: true,
isActive: true,
pollIntervalMin: 5,
position: 0,
createdAt: '2026-01-01T00:00:00.000Z',
updatedAt: '2026-01-01T00:00:00.000Z',
status: null,
...overrides,
};
}
describe('ServerCard', () => {
it('PVE-Server zeigt Knotenzahl, laufende/gestoppte Gaeste sowie je Knoten Prozessorlast und Speicherbelegung', async () => {
const { ServerCard } = await import('./ServerCard');
const server = makeServer({
status: {
id: 's1',
serverId: 'srv-1',
lastPolledAt: '2026-09-23T10:00:00.000Z',
lastOkAt: '2026-09-23T10:00:00.000Z',
reachable: true,
errorKind: null,
errorDetail: null,
rawSample: null,
updatedAt: '2026-09-23T10:00:00.000Z',
metrics: {
productType: 'pve',
nodeCount: 2,
guestsRunning: 3,
guestsStopped: 1,
nodes: [
{ node: 'pve1', cpu: 0.25, maxcpu: 8, mem: 4_294_967_296, maxmem: 8_589_934_592 },
],
storages: [],
},
},
});
render(<ServerCard server={server} />);
expect(screen.getByText(/Knoten:/)).toHaveTextContent('Knoten: 2');
expect(screen.getByText(/laufend/)).toHaveTextContent('3 laufend / 1 gestoppt');
expect(screen.getByText(/Prozessorlast/)).toHaveTextContent('Prozessorlast: 25%');
expect(screen.getByText(/Speicher:/)).toHaveTextContent('4.0 GB / 8.0 GB');
});
it('PBS-Server zeigt je Datenspeicher Belegung, letzte Sicherung und Ergebnis der letzten Pruefung', async () => {
const { ServerCard } = await import('./ServerCard');
const server = makeServer({
productType: 'pbs',
status: {
id: 's1',
serverId: 'srv-1',
lastPolledAt: '2026-09-23T10:00:00.000Z',
lastOkAt: '2026-09-23T10:00:00.000Z',
reachable: true,
errorKind: null,
errorDetail: null,
rawSample: null,
updatedAt: '2026-09-23T10:00:00.000Z',
metrics: {
productType: 'pbs',
datastores: [
{ name: 'backup-store', total: 1000, used: 400, free: 600, lastBackupAt: 1758000000, lastVerifyState: 'ok' },
],
},
},
});
render(<ServerCard server={server} />);
expect(screen.getByText('backup-store')).toBeInTheDocument();
expect(screen.getByText(/Belegt:/)).toHaveTextContent('400 B / 1000 B');
expect(screen.getByText(/Letzte Prüfung/)).toHaveTextContent('ok');
});
it('PBS-Datenspeicher ohne Sicherung zeigt "noch keine Sicherung"', async () => {
const { ServerCard } = await import('./ServerCard');
const server = makeServer({
productType: 'pbs',
status: {
id: 's1',
serverId: 'srv-1',
lastPolledAt: '2026-09-23T10:00:00.000Z',
lastOkAt: null,
reachable: true,
errorKind: null,
errorDetail: null,
rawSample: null,
updatedAt: '2026-09-23T10:00:00.000Z',
metrics: {
productType: 'pbs',
datastores: [
{ name: 'leer', total: 10, used: 0, free: 10, lastBackupAt: null, lastVerifyState: null },
],
},
},
});
render(<ServerCard server={server} />);
expect(screen.getByText(/Letzte Sicherung/)).toHaveTextContent('noch keine Sicherung');
expect(screen.getByText(/Letzte Prüfung/)).toHaveTextContent('unbekannt');
});
it('PMG-Server zeigt die Tageszahlen eingehend, ausgehend, Spam und Viren', async () => {
const { ServerCard } = await import('./ServerCard');
const server = makeServer({
productType: 'pmg',
status: {
id: 's1',
serverId: 'srv-1',
lastPolledAt: '2026-09-23T10:00:00.000Z',
lastOkAt: '2026-09-23T10:00:00.000Z',
reachable: true,
errorKind: null,
errorDetail: null,
rawSample: null,
updatedAt: '2026-09-23T10:00:00.000Z',
metrics: { productType: 'pmg', countIn: 120, countOut: 45, spamCount: 12, virusCount: 0 },
},
});
render(<ServerCard server={server} />);
expect(screen.getByText(/Eingehend:/)).toHaveTextContent('120');
expect(screen.getByText(/Ausgehend:/)).toHaveTextContent('45');
expect(screen.getByText(/Spam:/)).toHaveTextContent('12');
expect(screen.getByText(/Viren:/)).toHaveTextContent('0');
});
it('ein Messwert, der null ist, erscheint als "unbekannt" — nie als 0, leer oder NaN', async () => {
const { ServerCard } = await import('./ServerCard');
const server = makeServer({
productType: 'pmg',
status: {
id: 's1',
serverId: 'srv-1',
lastPolledAt: '2026-09-23T10:00:00.000Z',
lastOkAt: null,
reachable: true,
errorKind: null,
errorDetail: null,
rawSample: null,
updatedAt: '2026-09-23T10:00:00.000Z',
metrics: { productType: 'pmg', countIn: null, countOut: null, spamCount: null, virusCount: null },
},
});
render(<ServerCard server={server} />);
expect(screen.getByText(/Eingehend:/)).toHaveTextContent('unbekannt');
expect(screen.queryByText(/Eingehend: 0/)).not.toBeInTheDocument();
expect(screen.queryByText(/NaN/)).not.toBeInTheDocument();
});
it('ein Server mit reachable:false zeigt den Klartext der Ursache und den Zeitpunkt der letzten erfolgreichen Messung', async () => {
const { ServerCard } = await import('./ServerCard');
const server = makeServer({
status: {
id: 's1',
serverId: 'srv-1',
lastPolledAt: '2026-09-23T10:05:00.000Z',
lastOkAt: '2026-09-23T09:00:00.000Z',
reachable: false,
errorKind: 'zugang',
errorDetail: null,
rawSample: null,
updatedAt: '2026-09-23T10:05:00.000Z',
metrics: null,
},
});
render(<ServerCard server={server} />);
expect(screen.getByText('Der Zugang wurde abgelehnt.')).toBeInTheDocument();
expect(screen.getByText(/Letzte erfolgreiche Messung/)).toBeInTheDocument();
});
it('der Zeitpunkt der letzten Abfrage steht bei jedem Server', async () => {
const { ServerCard } = await import('./ServerCard');
const server = makeServer({
status: {
id: 's1',
serverId: 'srv-1',
lastPolledAt: '2026-09-23T10:00:00.000Z',
lastOkAt: null,
reachable: true,
errorKind: null,
errorDetail: null,
rawSample: null,
updatedAt: '2026-09-23T10:00:00.000Z',
metrics: null,
},
});
render(<ServerCard server={server} />);
expect(screen.getByText(/Letzte Abfrage/)).toBeInTheDocument();
});
});
@@ -0,0 +1,196 @@
'use client';
import { useTranslations } from 'next-intl';
import type {
ProxmoxErrorKind,
ProxmoxPbsMetrics,
ProxmoxPmgMetrics,
ProxmoxPveMetrics,
ProxmoxServer,
} from '@/lib/proxmox-api';
/**
* Wandelt einen rohen Byte-Wert in eine lesbare Form (B/KB/MB/GB/TB).
*/
function formatBytes(bytes: number): string {
if (bytes < 1024) return `${bytes} B`;
const units = ['KB', 'MB', 'GB', 'TB'];
let value = bytes;
let unitIndex = -1;
do {
value /= 1024;
unitIndex++;
} while (value >= 1024 && unitIndex < units.length - 1);
return `${value.toFixed(1)} ${units[unitIndex]}`;
}
/** Prozentwert einer Auslastung (0..1) gerundet, z. B. `25%`. */
function formatPercent(fraction: number): string {
return `${Math.round(fraction * 100)}%`;
}
/**
* Die EINZIGE Stelle, die einen Messwert in Text verwandelt (Aufgabe 6):
* ist der Wert `null`/`undefined`, erscheint der uebersetzte Text
* "unbekannt" — sonst der Wert mit seiner Einheit. Dadurch kann kein Zweig
* versehentlich eine `0` anzeigen, wo nichts gemessen wurde. Die Feldnamen
* von PBS und PMG sind bis zur Pruefung am echten Server nur abgeleitet
* (Recherche, Annahmen A2/A3/A5), und ein still falscher Wert waere
* schlimmer als ein ehrliches "unbekannt".
*/
function formatMetric(
value: number | string | null | undefined,
unknownLabel: string,
formatter?: (v: number) => string,
): string {
if (value === null || value === undefined) return unknownLabel;
if (typeof value === 'number') {
if (Number.isNaN(value)) return unknownLabel;
return formatter ? formatter(value) : String(value);
}
return value;
}
function formatTimestamp(value: string | number | null | undefined, unknownLabel: string): string {
if (value === null || value === undefined) return unknownLabel;
const date = typeof value === 'number' ? new Date(value * 1000) : new Date(value);
if (Number.isNaN(date.getTime())) return unknownLabel;
return date.toLocaleString();
}
interface MetricsViewProps {
metrics: ProxmoxPveMetrics | ProxmoxPbsMetrics | ProxmoxPmgMetrics;
unknown: string;
}
function PveMetricsView({ metrics, unknown }: { metrics: ProxmoxPveMetrics; unknown: string }) {
const t = useTranslations('proxmox');
return (
<div className="space-y-2 text-sm">
<div>
{t('card.pve.nodeCount')}: {metrics.nodeCount}
</div>
<div>
{t('card.pve.guests', { running: metrics.guestsRunning, stopped: metrics.guestsStopped })}
</div>
{metrics.nodes.map((node) => (
<div key={node.node} className="rounded border border-border/60 px-2 py-1 text-xs">
<div className="font-medium">{node.node}</div>
<div>
{t('card.pve.cpu')}: {formatMetric(node.cpu, unknown, formatPercent)}
{' · '}
{t('card.pve.mem')}: {formatMetric(node.mem, unknown, formatBytes)}
{node.maxmem !== null && node.mem !== null
? ` / ${formatMetric(node.maxmem, unknown, formatBytes)}`
: ''}
</div>
</div>
))}
</div>
);
}
function PbsMetricsView({ metrics, unknown }: { metrics: ProxmoxPbsMetrics; unknown: string }) {
const t = useTranslations('proxmox');
return (
<div className="space-y-2 text-sm">
{metrics.datastores.map((ds) => (
<div key={ds.name} className="rounded border border-border/60 px-2 py-1 text-xs">
<div className="font-medium">{ds.name}</div>
<div>
{t('card.pbs.used')}: {formatMetric(ds.used, unknown, formatBytes)}
{ds.total !== null && ds.used !== null ? ` / ${formatMetric(ds.total, unknown, formatBytes)}` : ''}
</div>
<div>
{t('card.pbs.lastBackup')}:{' '}
{ds.lastBackupAt === null ? t('card.pbs.noBackupYet') : formatTimestamp(ds.lastBackupAt, unknown)}
</div>
<div>
{t('card.pbs.verifyState')}: {formatMetric(ds.lastVerifyState, unknown)}
</div>
</div>
))}
</div>
);
}
function PmgMetricsView({ metrics, unknown }: { metrics: ProxmoxPmgMetrics; unknown: string }) {
const t = useTranslations('proxmox');
return (
<div className="space-y-1 text-sm">
<div>
{t('card.pmg.countIn')}: {formatMetric(metrics.countIn, unknown)}
</div>
<div>
{t('card.pmg.countOut')}: {formatMetric(metrics.countOut, unknown)}
</div>
<div>
{t('card.pmg.spamCount')}: {formatMetric(metrics.spamCount, unknown)}
</div>
<div>
{t('card.pmg.virusCount')}: {formatMetric(metrics.virusCount, unknown)}
</div>
</div>
);
}
function MetricsView({ metrics, unknown }: MetricsViewProps) {
if (metrics.productType === 'pve') return <PveMetricsView metrics={metrics} unknown={unknown} />;
if (metrics.productType === 'pbs') return <PbsMetricsView metrics={metrics} unknown={unknown} />;
return <PmgMetricsView metrics={metrics} unknown={unknown} />;
}
function errorMessage(t: ReturnType<typeof useTranslations>, kind: ProxmoxErrorKind | null): string {
return t(`errors.${kind ?? 'unbekannt'}`);
}
interface ServerCardProps {
server: ProxmoxServer;
}
/**
* Anzeige EINES Servers (Aufgabe 6) — verzweigt ueber `productType` auf der
* unterscheidbaren Union aus Aufgabe 3.
*/
export function ServerCard({ server }: ServerCardProps) {
const t = useTranslations('proxmox');
const unknown = t('card.unknownValue');
const status = server.status;
return (
<div className="rounded-lg border border-border bg-card p-4 shadow-sm">
<div className="flex items-center justify-between">
<div>
<div className="font-medium">{server.name}</div>
<div className="text-xs uppercase text-muted-foreground">
{server.productType} — {server.baseUrl}
</div>
</div>
</div>
<div className="mt-2 text-xs text-muted-foreground">
{t('card.lastPolledLabel')}: {formatTimestamp(status?.lastPolledAt ?? null, unknown)}
</div>
{status && !status.reachable && (
<div className="mt-2 space-y-1 text-sm">
<p className="text-destructive">
{errorMessage(t, status.errorKind)}
{status.errorDetail ? ` (${status.errorDetail})` : ''}
</p>
{status.lastOkAt && (
<p className="text-xs text-muted-foreground">
{t('card.lastOkLabel')}: {formatTimestamp(status.lastOkAt, unknown)}
</p>
)}
</div>
)}
{status?.reachable && status.metrics && (
<div className="mt-3">
<MetricsView metrics={status.metrics} unknown={unknown} />
</div>
)}
</div>
);
}