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.

11.9 KB
Raw Blame
import { describe, expect, it } from 'vitest';

import { ALERT_RESOURCE_METRIC_OFF_VALUE } from '@/components/Alerts/alertResourceTableModel';
import type { AlertConfig } from '@/types/alerts';

import {
  ALERT_DOCKER_GAP_VALIDATION_ERROR,
  buildAlertsConfigurationPayload,
  createDefaultAlertsConfigurationSnapshot,
  FACTORY_DOCKER_DEFAULTS,
  FACTORY_GUEST_DEFAULTS,
  FACTORY_STORAGE_DEFAULT,
  readAlertsConfigurationSnapshot,
} from '../alertsConfigurationModel';

describe('alertsConfigurationModel', () => {
  it('creates the canonical default snapshot', () => {
    const snapshot = createDefaultAlertsConfigurationSnapshot();

    expect(snapshot.identitySchemaVersion).toBe(0);
    expect(snapshot.guestDefaults.cpu).toBe(FACTORY_GUEST_DEFAULTS.cpu);
    expect(snapshot.dockerDefaults.serviceWarnGapPercent).toBe(
      FACTORY_DOCKER_DEFAULTS.serviceWarnGapPercent,
    );
    expect(snapshot.storageDefault).toBe(FACTORY_STORAGE_DEFAULT);
    expect(snapshot.timeThresholds.guest).toBe(5);
    expect(snapshot.timeThresholds['vmware-host']).toBe(5);
    expect(snapshot.vmwareDefaults.usage).toBe(85);
    expect(snapshot.scheduleCooldown.enabled).toBe(true);
    expect(snapshot.initialNotify).toBe('all');
    expect(snapshot.backupDefaults.ignoreVMIDs).toEqual([]);
  });

  it('normalizes alert config into the runtime snapshot', () => {
    const config = {
      identitySchemaVersion: 1,
      enabled: true,
      guestDefaults: {
        cpu: { trigger: 91, clear: 86 },
        disableConnectivity: true,
        poweredOffSeverity: 'critical',
      },
      nodeDefaults: {},
      agentDefaults: {},
      storageDefault: { trigger: 88, clear: 83 },
      overrides: {},
      dockerDefaults: {
        serviceWarnGapPercent: 40,
        serviceCriticalGapPercent: 10,
        statePoweredOffSeverity: 'critical',
      },
      backupDefaults: {
        enabled: true,
        warningDays: 30,
        criticalDays: 10,
        ignoreVMIDs: [' 101 ', '101', ''],
      },
      vmwareDefaults: {
        cpu: { trigger: 83, clear: 78 },
        usage: { trigger: 91, clear: 86 },
      },
      snapshotDefaults: {
        enabled: true,
        warningDays: 25,
        criticalDays: 5,
      },
      schedule: {
        quietHours: {
          enabled: true,
          start: '21:00',
          end: '06:00',
          days: [1, 3, 5],
        },
        cooldown: 45,
        maxAlertsHour: 7,
        initialNotify: 'apprise',
        escalation: {
          enabled: true,
          levels: [{ after: 30, notify: 'APPRISE' }],
        },
      },
    } as AlertConfig;

    const snapshot = readAlertsConfigurationSnapshot(config);

    expect(snapshot.identitySchemaVersion).toBe(1);
    expect(snapshot.guestDefaults.cpu).toBe(91);
    expect(snapshot.guestDisableConnectivity).toBe(true);
    expect(snapshot.guestPoweredOffSeverity).toBe('critical');
    expect(snapshot.dockerDefaults.serviceWarnGapPercent).toBe(40);
    expect(snapshot.dockerDefaults.serviceCriticalGapPercent).toBe(40);
    expect(snapshot.backupDefaults.warningDays).toBe(10);
    expect(snapshot.vmwareDefaults.cpu).toBe(83);
    expect(snapshot.vmwareDefaults.usage).toBe(91);
    expect(snapshot.backupDefaults.criticalDays).toBe(10);
    expect(snapshot.backupDefaults.ignoreVMIDs).toEqual(['101']);
    expect(snapshot.snapshotDefaults.warningDays).toBe(5);
    expect(snapshot.snapshotDefaults.criticalDays).toBe(5);
    expect(snapshot.scheduleQuietHours.days).toEqual({
      sunday: false,
      monday: true,
      tuesday: false,
      wednesday: true,
      thursday: false,
      friday: true,
      saturday: false,
    });
    expect(snapshot.scheduleCooldown.maxAlerts).toBe(7);
    expect(snapshot.initialNotify).toBe('apprise');
    expect(snapshot.scheduleEscalation.levels).toEqual([{ after: 30, notify: 'apprise' }]);
  });

  it('builds the canonical save payload from the runtime snapshot', () => {
    const snapshot = createDefaultAlertsConfigurationSnapshot();
    snapshot.identitySchemaVersion = 1;
    snapshot.guestDefaults.cpu = 92;
    snapshot.dockerIgnoredPrefixes = [' web ', ''];
    snapshot.guestTagWhitelist = [' prod ', ''];
    snapshot.metricTimeThresholds = {
      Guest: { CPU: 17 },
    } as Record<string, Record<string, number>>;
    snapshot.metricEvaluationWindows = {
      ALL: { CPU: 300 },
      VM: { CPU: 0 },
    } as Record<string, Record<string, number>>;
    snapshot.scheduleCooldown = {
      enabled: true,
      minutes: 47,
      maxAlerts: 99,
    };
    snapshot.scheduleGrouping = {
      enabled: true,
      window: 2,
      byNode: true,
      byGuest: false,
    };
    snapshot.initialNotify = 'email';
    snapshot.scheduleEscalation = {
      enabled: true,
      repeatCritical: true,
      repeatEvery: 15,
      levels: [
        {
          after: 30,
          notify: 'webhook',
          destinationIds: ['webhook:pager'],
        },
      ],
    };
    snapshot.backupDefaults = {
      enabled: true,
      warningDays: 30,
      criticalDays: 10,
      freshHours: 12,
      staleHours: 48,
      alertOrphaned: true,
      ignoreVMIDs: [' 101 ', ''],
    };

    const result = buildAlertsConfigurationPayload({
      snapshot,
      rawOverridesConfig: { 'guest-1': { disabled: true } },
      alertsActivationState: 'active',
      alertsActivationConfig: {
        enabled: true,
        activationTime: '2026-03-22T10:00:00Z',
        observationWindowHours: 24,
      },
    });

    expect(result.dockerValidationError).toBeUndefined();
    expect(result.alertConfig).toBeDefined();
    expect(result.alertConfig?.identitySchemaVersion).toBe(1);
    expect(result.alertConfig?.guestDefaults.cpu).toEqual({ trigger: 92, clear: 87 });
    expect(result.alertConfig?.vmwareDefaults?.cpu).toEqual({ trigger: 80, clear: 75 });
    expect(result.alertConfig?.vmwareDefaults?.usage).toEqual({ trigger: 85, clear: 80 });
    expect(result.alertConfig?.dockerIgnoredContainerPrefixes).toEqual(['web']);
    expect(result.alertConfig?.guestTagWhitelist).toEqual(['prod']);
    expect(result.alertConfig?.metricTimeThresholds).toEqual({ guest: { cpu: 17 } });
    expect(result.alertConfig?.metricEvaluationWindows).toEqual({
      all: { cpu: 300 },
      vm: { cpu: 0 },
    });
    expect(result.alertConfig?.schedule?.cooldown).toBe(47);
    expect(result.alertConfig?.schedule?.initialNotify).toBe('email');
    expect(result.alertConfig?.schedule?.maxAlertsHour).toBe(10);
    expect(result.alertConfig?.schedule?.grouping).toEqual({
      enabled: true,
      window: 120,
      byNode: true,
      byGuest: false,
    });
    expect(result.alertConfig?.schedule?.escalation).toEqual({
      enabled: true,
      repeatCritical: true,
      repeatEvery: 15,
      levels: [
        {
          after: 30,
          notify: 'webhook',
          destinationIds: ['webhook:pager'],
        },
      ],
    });
    expect(result.alertConfig?.backupDefaults).toMatchObject({
      warningDays: 10,
      criticalDays: 10,
      ignoreVMIDs: ['101'],
    });
    expect(result.alertConfig?.overrides).toEqual({ 'guest-1': { disabled: true } });
  });

  it('returns the canonical docker-gap validation error before save', () => {
    const snapshot = createDefaultAlertsConfigurationSnapshot();
    snapshot.dockerDefaults.serviceWarnGapPercent = 60;
    snapshot.dockerDefaults.serviceCriticalGapPercent = 40;

    const result = buildAlertsConfigurationPayload({
      snapshot,
      rawOverridesConfig: {},
      alertsActivationState: null,
      alertsActivationConfig: null,
    });

    expect(result.alertConfig).toBeUndefined();
    expect(result.dockerValidationError).toBe(ALERT_DOCKER_GAP_VALIDATION_ERROR);
  });

  // The backend reads a negative default trigger as unset and restores the
  // factory threshold, so every Global Defaults Off must reach it as 0.
  it('writes an Off global default as trigger 0 in every section and reads it back Off', () => {
    const thresholdMetrics = {
      guestDefaults: ['cpu', 'memory', 'disk', 'diskRead', 'diskWrite', 'networkIn', 'networkOut'],
      nodeDefaults: ['cpu', 'memory', 'disk', 'temperature'],
      agentDefaults: ['cpu', 'memory', 'disk', 'diskTemperature'],
      pbsDefaults: ['cpu', 'memory'],
      kubernetesDefaults: [
        'cpu',
        'memory',
        'disk',
        'diskRead',
        'diskWrite',
        'networkIn',
        'networkOut',
      ],
      trueNASDefaults: [
        'cpu',
        'memory',
        'disk',
        'usage',
        'temperature',
        'diskRead',
        'diskWrite',
        'networkIn',
        'networkOut',
      ],
      trueNASDiskDefaults: ['temperature'],
      vmwareDefaults: [
        'cpu',
        'memory',
        'disk',
        'usage',
        'diskRead',
        'diskWrite',
        'networkIn',
        'networkOut',
      ],
      dockerDefaults: ['cpu', 'memory', 'disk'],
    } as const;
    const payloadSection = {
      guestDefaults: 'guestDefaults',
      nodeDefaults: 'nodeDefaults',
      agentDefaults: 'agentDefaults',
      pbsDefaults: 'pbsDefaults',
      kubernetesDefaults: 'kubernetesDefaults',
      trueNASDefaults: 'truenasDefaults',
      trueNASDiskDefaults: 'truenasDiskDefaults',
      vmwareDefaults: 'vmwareDefaults',
      dockerDefaults: 'dockerDefaults',
    } as const;

    type Section = keyof typeof thresholdMetrics;

    const snapshot = createDefaultAlertsConfigurationSnapshot();
    for (const [section, metrics] of Object.entries(thresholdMetrics)) {
      const defaults: Record<string, unknown> = snapshot[section as Section];
      for (const metric of metrics) {
        defaults[metric] = ALERT_RESOURCE_METRIC_OFF_VALUE;
      }
    }
    snapshot.storageDefault = ALERT_RESOURCE_METRIC_OFF_VALUE;

    const { alertConfig } = buildAlertsConfigurationPayload({
      snapshot,
      rawOverridesConfig: {},
      alertsActivationState: null,
      alertsActivationConfig: null,
    });
    expect(alertConfig).toBeTruthy();
    const payload = alertConfig as unknown as Record<string, Record<string, unknown>>;
    for (const [section, metrics] of Object.entries(thresholdMetrics)) {
      const written = payload[payloadSection[section as Section]];
      for (const metric of metrics) {
        expect(written[metric], `${section}.${metric}`).toEqual({ trigger: 0, clear: 0 });
      }
    }
    expect(alertConfig?.storageDefault).toEqual({ trigger: 0, clear: 0 });

    const reloaded = readAlertsConfigurationSnapshot(alertConfig as AlertConfig);
    for (const [section, metrics] of Object.entries(thresholdMetrics)) {
      const defaults: Record<string, unknown> = reloaded[section as Section];
      for (const metric of metrics) {
        expect(defaults[metric], `${section}.${metric}`).toBe(0);
      }
    }
    expect(reloaded.storageDefault).toBe(0);
  });

  // The backend reads a critical age of 0 as Off. The editor's Off toggle
  // stages -1, which used to be raised to the warning age, so backups and
  // snapshots went critical at the warning age instead of never.
  it('saves an Off backup or snapshot critical age as 0 and reads it back Off', () => {
    const snapshot = createDefaultAlertsConfigurationSnapshot();
    snapshot.backupDefaults = {
      ...snapshot.backupDefaults,
      warningDays: 7,
      criticalDays: ALERT_RESOURCE_METRIC_OFF_VALUE,
    };
    snapshot.snapshotDefaults = {
      ...snapshot.snapshotDefaults,
      warningDays: 30,
      criticalDays: ALERT_RESOURCE_METRIC_OFF_VALUE,
    };

    const { alertConfig } = buildAlertsConfigurationPayload({
      snapshot,
      rawOverridesConfig: {},
      alertsActivationState: null,
      alertsActivationConfig: null,
    });

    expect(alertConfig?.backupDefaults?.warningDays).toBe(7);
    expect(alertConfig?.backupDefaults?.criticalDays).toBe(0);
    expect(alertConfig?.snapshotDefaults?.warningDays).toBe(30);
    expect(alertConfig?.snapshotDefaults?.criticalDays).toBe(0);

    const reloaded = readAlertsConfigurationSnapshot(alertConfig as AlertConfig);
    expect(reloaded.backupDefaults.criticalDays).toBe(0);
    expect(reloaded.snapshotDefaults.criticalDays).toBe(0);
  });
});