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.

12.4 KB
Raw Blame
import { describe, expect, it } from 'vitest';
import {
  buildAvailabilitySettingsPath,
  buildAvailabilityTargetAddPath,
  getAvailabilityTargetAddKind,
  getAvailabilityTargetAddressLabel,
  getAvailabilityTargetKindLabel,
  getAvailabilityTargetMethodLabel,
  getAvailabilityTargetProbeSourceLabel,
  getAvailabilityTargetHealth,
  getAvailabilityTargetStatusClass,
  getAvailabilityTargetStatusLabel,
  getAvailabilityTargetStatusTitle,
  getAvailabilityTargetsSummary,
  normalizeAvailabilityTargetKind,
  shouldOpenAvailabilityTargetAddDialog,
} from '../availabilitySettingsModel';
import type { AvailabilityTarget } from '@/api/availabilityTargets';

const target = (overrides: Partial<AvailabilityTarget> = {}): AvailabilityTarget => ({
  id: 'mqtt-broker',
  name: 'MQTT broker',
  address: 'mqtt.local',
  protocol: 'tcp',
  port: 1883,
  enabled: true,
  ...overrides,
});

describe('availabilitySettingsModel', () => {
  it('owns the canonical monitoring availability settings path', () => {
    expect(buildAvailabilitySettingsPath()).toBe('/settings/monitoring/availability');
    expect(buildAvailabilityTargetAddPath()).toBe('/settings/monitoring/availability?add=target');
    expect(buildAvailabilityTargetAddPath('machine')).toBe(
      '/settings/monitoring/availability?add=target&targetKind=machine',
    );
    expect(buildAvailabilityTargetAddPath('service')).toBe(
      '/settings/monitoring/availability?add=target&targetKind=service',
    );
    expect(
      shouldOpenAvailabilityTargetAddDialog('/settings/monitoring/availability', '?add=target'),
    ).toBe(true);
    expect(
      shouldOpenAvailabilityTargetAddDialog(
        '/settings/monitoring/availability',
        '?add=target&targetKind=machine',
      ),
    ).toBe(true);
    expect(
      shouldOpenAvailabilityTargetAddDialog(
        '/settings/monitoring/availability',
        '?add=target&targetKind=vm',
      ),
    ).toBe(false);
    expect(
      getAvailabilityTargetAddKind(
        '/settings/monitoring/availability',
        '?add=target&targetKind=machine',
      ),
    ).toBe('machine');
    expect(getAvailabilityTargetAddKind('/settings/monitoring/availability', '?add=target')).toBe(
      undefined,
    );
    expect(
      shouldOpenAvailabilityTargetAddDialog('/settings/infrastructure', '?add=availability'),
    ).toBe(false);
    expect(normalizeAvailabilityTargetKind('Machine')).toBe('machine');
    expect(normalizeAvailabilityTargetKind('vm')).toBe(undefined);
  });

  it('formats endpoint methods and addresses without infrastructure copy', () => {
    expect(getAvailabilityTargetMethodLabel(target())).toBe('TCP 1883');
    expect(getAvailabilityTargetAddressLabel(target())).toBe('mqtt.local:1883');
    expect(
      getAvailabilityTargetAddressLabel(
        target({ protocol: 'http', address: 'http://sensor.local', path: '/health' }),
      ),
    ).toBe('http://sensor.local/health');
    expect(
      getAvailabilityTargetAddressLabel(
        target({ protocol: 'http', address: 'http://sensor.local/', path: '/health' }),
      ),
    ).toBe('http://sensor.local/health');
    expect(getAvailabilityTargetMethodLabel(target({ protocol: 'icmp', port: undefined }))).toBe(
      'ICMP ping',
    );
    expect(getAvailabilityTargetKindLabel(target({ targetKind: 'machine' }))).toBe('Machine');
    expect(getAvailabilityTargetKindLabel(target())).toBe('Service');
  });

  it('summarizes saved availability targets from their probe state', () => {
    expect(
      getAvailabilityTargetStatusLabel(
        target({
          status: {
            ...target(),
            targetId: 'mqtt-broker',
            available: true,
            lastChecked: '2026-10-05T00:00:00Z',
            latencyMillis: 12,
          },
        }),
      ),
    ).toBe('Online · 12 ms');
    expect(
      getAvailabilityTargetsSummary([
        target(),
        target({
          id: 'http-health',
          name: 'HTTP health',
          protocol: 'http',
          address: 'http://service.local',
          status: {
            ...target(),
            targetId: 'http-health',
            available: false,
            lastChecked: '2026-10-05T00:00:00Z',
          },
        }),
      ]),
    ).toBe('1 needs attention · 2 enabled');
    expect(
      getAvailabilityTargetsSummary([
        target({
          protocol: 'udp',
          port: 27015,
          status: {
            ...target(),
            targetId: 'steam-server',
            protocol: 'udp',
            available: false,
            lastChecked: '2026-10-05T00:00:00Z',
            outcome: 'indeterminate',
          },
        }),
      ]),
    ).toBe('1 needs attention · 1 enabled');
    expect(
      getAvailabilityTargetsSummary([
        target({
          id: 'closed-port',
          status: {
            ...target(),
            targetId: 'closed-port',
            available: false,
            lastChecked: '2026-10-05T00:00:00Z',
          },
        }),
        target({
          id: 'silent-port',
          protocol: 'udp',
          port: 27015,
          status: {
            ...target(),
            targetId: 'silent-port',
            protocol: 'udp',
            available: false,
            lastChecked: '2026-10-05T00:00:00Z',
            outcome: 'indeterminate',
          },
        }),
      ]),
    ).toBe('2 need attention · 2 enabled');
    expect(getAvailabilityTargetStatusClass(target({ enabled: false }))).toBe(
      'bg-surface-alt text-muted',
    );
    expect(getAvailabilityTargetStatusClass(target())).toBe(
      'bg-sky-100 text-sky-700 dark:bg-sky-900/25 dark:text-sky-300',
    );
    expect(
      getAvailabilityTargetStatusClass(
        target({
          status: {
            ...target(),
            targetId: 'mqtt-broker',
            available: true,
            lastChecked: '2026-10-05T00:00:00Z',
            latencyMillis: 12,
          },
        }),
      ),
    ).toBe('bg-emerald-100 text-emerald-700 dark:bg-emerald-900/25 dark:text-emerald-300');
    expect(
      getAvailabilityTargetStatusClass(
        target({
          status: {
            ...target(),
            targetId: 'mqtt-broker',
            available: false,
            lastChecked: '2026-10-05T00:00:00Z',
            consecutiveFailures: 2,
          },
        }),
      ),
    ).toBe('bg-rose-100 text-rose-700 dark:bg-rose-900/25 dark:text-rose-300');
  });

  it('attributes probe-reported results to the assigned agent host', () => {
    const options = [{ id: 'host-edge-01', label: 'Edge 01' }];
    const probed = target({
      probeAgentId: 'host-edge-01',
      status: {
        ...target(),
        targetId: 'mqtt-broker',
        available: true,
        lastChecked: '2026-10-05T00:00:00Z',
        latencyMillis: 12,
        probeAgentId: 'host-edge-01',
      },
    });

    expect(getAvailabilityTargetProbeSourceLabel(probed, options)).toBe('via Edge 01');
    // A locally executed check carries no attribution chip.
    expect(
      getAvailabilityTargetProbeSourceLabel(
        target({ status: { ...target(), targetId: 'mqtt-broker', available: true } }),
        options,
      ),
    ).toBeNull();
    // Unknown hosts degrade to the raw id rather than disappearing.
    expect(
      getAvailabilityTargetProbeSourceLabel(
        target({
          status: {
            ...target(),
            targetId: 'mqtt-broker',
            available: true,
            lastChecked: '2026-10-05T00:00:00Z',
            probeAgentId: 'host-gone',
          },
        }),
        options,
      ),
    ).toBe('via host-gone');
  });

  it('renders a stale probe assignment with the existing indeterminate treatment', () => {
    const stale = target({
      probeAgentId: 'host-edge-01',
      status: {
        ...target(),
        targetId: 'mqtt-broker',
        available: false,
        lastChecked: '2026-10-05T00:00:00Z',
        outcome: 'indeterminate',
        lastError: 'no recent report from probe agent',
        probeAgentId: 'host-edge-01',
      },
    });

    expect(getAvailabilityTargetStatusLabel(stale)).toBe('No recent probe report');
    // No new visual language: it reuses the amber indeterminate badge.
    expect(getAvailabilityTargetStatusClass(stale)).toBe(
      'bg-amber-100 text-amber-700 dark:bg-amber-900/25 dark:text-amber-300',
    );
    // The UDP open-or-filtered case keeps its own copy.
    expect(
      getAvailabilityTargetStatusLabel(
        target({
          status: {
            ...target(),
            targetId: 'mqtt-broker',
            available: true,
            lastChecked: '2026-10-05T00:00:00Z',
            outcome: 'indeterminate',
          },
        }),
      ),
    ).toBe('Open or filtered');
  });

  it('counts a failing check as offline only after its failure threshold, like Machines', () => {
    const failing = (consecutiveFailures: number) =>
      target({
        failureThreshold: 2,
        status: {
          ...target(),
          targetId: 'solar',
          available: false,
          lastChecked: '2026-10-05T00:00:00Z',
          consecutiveFailures,
          failureThreshold: 2,
          lastError: 'http probe returned 503 Service Unavailable',
        },
      });

    expect(getAvailabilityTargetHealth(failing(1))).toBe('attention');
    expect(getAvailabilityTargetHealth(failing(2))).toBe('offline');
    expect(getAvailabilityTargetsSummary([failing(1), failing(3), target()])).toBe(
      '2 need attention · 1 offline · 3 enabled',
    );
    expect(getAvailabilityTargetStatusClass(failing(1))).toContain('bg-amber-100');
    expect(getAvailabilityTargetStatusTitle(failing(1))).toBe(
      '1 failed check in a row. It counts as offline after 2.',
    );
    expect(getAvailabilityTargetStatusTitle(failing(2))).toBeUndefined();
  });

  it('keeps the threshold for a single-location check the backend marks unavailable', () => {
    const unavailable = (consecutiveFailures: number) =>
      target({
        status: {
          ...target(),
          targetId: 'mqtt-broker',
          available: false,
          lastChecked: '2026-10-05T00:00:00Z',
          aggregateState: 'unavailable',
          consecutiveFailures,
        },
      });

    // Default threshold is 2, as in internal/config/availability.go.
    expect(getAvailabilityTargetHealth(unavailable(1))).toBe('attention');
    expect(getAvailabilityTargetHealth(unavailable(2))).toBe('offline');
  });

  it('names expired loaded evidence without overriding pause or stopped-probe copy', () => {
    const start = Date.parse('2026-10-10T12:00:00Z');
    const check = target({
      status: {
        ...target(),
        targetId: 'mqtt-broker',
        available: true,
        aggregateState: 'healthy',
        expectedLocations: 2,
        lastChecked: new Date(start).toISOString(),
      },
    });
    const resource = {
      type: 'network-endpoint',
      platformType: 'availability',
      status: 'online',
      availability: {
        ...check.status,
        evidence: { validUntil: new Date(start + 10_000).toISOString() },
      },
    } as never;
    expect(getAvailabilityTargetStatusLabel(check, resource, start)).toBe(
      'Available from all 2 locations',
    );
    expect(getAvailabilityTargetStatusLabel(check, resource, start + 30_000)).toBe('Stale');
    expect(
      getAvailabilityTargetStatusLabel({ ...check, enabled: false }, resource, start + 30_000),
    ).toBe('Paused');
    expect(
      getAvailabilityTargetStatusLabel(
        {
          ...check,
          status: {
            ...check.status!,
            outcome: 'indeterminate',
            lastError: 'no recent report from probe agent',
          },
        },
        resource,
        start + 30_000,
      ),
    ).toBe('No recent probe report');
  });

  it('defers to the Machines status of the loaded resource', () => {
    const healthyTarget = target({
      status: {
        ...target(),
        targetId: 'mqtt-broker',
        available: true,
        lastChecked: '2026-10-05T00:00:00Z',
      },
    });
    const unresolvedResource = {
      id: 'availability:mqtt-broker',
      type: 'network-endpoint',
      name: 'MQTT broker',
      status: 'online',
      lastSeen: Date.now(),
      availability: { targetId: 'mqtt-broker', correlationState: 'unresolved' },
    } as never;

    expect(getAvailabilityTargetHealth(healthyTarget)).toBe('healthy');
    expect(getAvailabilityTargetHealth(healthyTarget, unresolvedResource)).toBe('attention');
    expect(getAvailabilityTargetsSummary([healthyTarget], () => unresolvedResource)).toBe(
      '1 needs attention · 1 enabled',
    );
  });
});