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.

15.5 KB
Raw Blame
import { renderHook } from '@solidjs/testing-library';
import { createSignal } from 'solid-js';
import { createStore, reconcile } from 'solid-js/store';
import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';

import { AlertsAPI } from '@/api/alerts';
import { createAlertAcknowledgementRequests } from '@/stores/alertAcknowledgementRequests';
import { notificationStore } from '@/stores/notifications';
import type { Alert, AlertDeliveryDiagnosis } from '@/types/api';
import { RELATIVE_TIME_TICK_MS } from '@/utils/relativeTimeClock';

import { useAlertOverviewState } from '../useAlertOverviewState';

vi.mock('@/api/alerts', () => ({
  AlertsAPI: {
    getDeliveryDiagnoses: vi.fn(),
    acknowledge: vi.fn(),
    bulkAcknowledge: vi.fn(),
    unacknowledge: vi.fn(),
  },
}));

vi.mock('@/stores/notifications', () => ({
  notificationStore: {
    error: vi.fn(),
    success: vi.fn(),
  },
}));

vi.mock('@/utils/logger', () => ({
  logger: {
    error: vi.fn(),
  },
}));

function makeAlert(id: string, startTime: string, acknowledged = false): Alert {
  return {
    id,
    type: 'cpu',
    level: 'warning',
    resourceId: `vm-${id}`,
    resourceName: `VM ${id}`,
    node: 'node-1',
    message: `CPU high on ${id}`,
    startTime,
    acknowledged,
  } as Alert;
}

describe('useAlertOverviewState', () => {
  beforeEach(() => {
    vi.useFakeTimers();
    vi.setSystemTime(new Date('2026-03-22T12:00:00Z'));
    vi.mocked(AlertsAPI.getDeliveryDiagnoses).mockReset().mockResolvedValue([]);
    vi.mocked(AlertsAPI.acknowledge).mockReset();
    vi.mocked(AlertsAPI.unacknowledge).mockReset();
    vi.mocked(AlertsAPI.bulkAcknowledge).mockReset();
    vi.mocked(notificationStore.success).mockReset();
    vi.mocked(notificationStore.error).mockReset();
  });

  afterEach(() => {
    vi.useRealTimers();
  });

  it('invalidates pending diagnosis reads when the active set becomes empty', async () => {
    let finish!: (value: AlertDeliveryDiagnosis[]) => void;
    vi.mocked(AlertsAPI.getDeliveryDiagnoses).mockReturnValueOnce(
      new Promise((resolve) => {
        finish = resolve;
      }),
    );
    const [activeAlerts, setActiveAlerts] = createSignal<Record<string, Alert>>({
      a1: makeAlert('a1', new Date().toISOString()),
    });
    const { result } = renderHook(() =>
      useAlertOverviewState({
        activeAlerts,
        overrides: () => [],
        showAcknowledged: () => true,
        updateAlert: vi.fn(),
        acknowledgementRequests: createAlertAcknowledgementRequests(),
      }),
    );
    expect(AlertsAPI.getDeliveryDiagnoses).toHaveBeenCalledOnce();
    setActiveAlerts({});
    finish([{ alertIdentifier: 'a1', reason: 'ready' } as AlertDeliveryDiagnosis]);
    await Promise.resolve();
    expect(result.deliveryDiagnoses()).toEqual({});
  });

  it('does not accept an older success when a newer periodic refresh fails', async () => {
    let finishOlder!: (value: AlertDeliveryDiagnosis[]) => void;
    const retained = {
      alertIdentifier: 'a1',
      reason: 'notifications_disabled',
    } as AlertDeliveryDiagnosis;
    vi.mocked(AlertsAPI.getDeliveryDiagnoses)
      .mockResolvedValueOnce([retained])
      .mockReturnValueOnce(
        new Promise((resolve) => {
          finishOlder = resolve;
        }),
      )
      .mockRejectedValueOnce(new Error('refresh unavailable'));
    const { result } = renderHook(() =>
      useAlertOverviewState({
        activeAlerts: () => ({ a1: makeAlert('a1', new Date().toISOString()) }),
        overrides: () => [],
        showAcknowledged: () => true,
        updateAlert: vi.fn(),
        acknowledgementRequests: createAlertAcknowledgementRequests(),
      }),
    );
    await Promise.resolve();
    expect(result.deliveryDiagnoses()).toEqual({ a1: retained });
    await vi.advanceTimersByTimeAsync(60_000);
    await vi.advanceTimersByTimeAsync(60_000);
    expect(AlertsAPI.getDeliveryDiagnoses).toHaveBeenCalledTimes(3);
    finishOlder([{ alertIdentifier: 'a1', reason: 'ready' } as AlertDeliveryDiagnosis]);
    await Promise.resolve();
    expect(result.deliveryDiagnoses()).toEqual({ a1: retained });
  });

  it('refreshes diagnoses once a minute, not on the 30-second age clock', async () => {
    renderHook(() =>
      useAlertOverviewState({
        activeAlerts: () => ({ a1: makeAlert('a1', new Date().toISOString()) }),
        overrides: () => [],
        showAcknowledged: () => true,
        updateAlert: vi.fn(),
        acknowledgementRequests: createAlertAcknowledgementRequests(),
      }),
    );
    expect(AlertsAPI.getDeliveryDiagnoses).toHaveBeenCalledOnce();
    await vi.advanceTimersByTimeAsync(RELATIVE_TIME_TICK_MS);
    expect(AlertsAPI.getDeliveryDiagnoses).toHaveBeenCalledOnce();
    await vi.advanceTimersByTimeAsync(60_000 - RELATIVE_TIME_TICK_MS);
    expect(AlertsAPI.getDeliveryDiagnoses).toHaveBeenCalledTimes(2);
  });

  it('ignores pending responses and stops periodic reads after disposal', async () => {
    let finish!: (value: AlertDeliveryDiagnosis[]) => void;
    vi.mocked(AlertsAPI.getDeliveryDiagnoses).mockReturnValueOnce(
      new Promise((resolve) => {
        finish = resolve;
      }),
    );
    const { result, cleanup } = renderHook(() =>
      useAlertOverviewState({
        activeAlerts: () => ({ a1: makeAlert('a1', new Date().toISOString()) }),
        overrides: () => [],
        showAcknowledged: () => true,
        updateAlert: vi.fn(),
        acknowledgementRequests: createAlertAcknowledgementRequests(),
      }),
    );
    cleanup();
    finish([{ alertIdentifier: 'a1', reason: 'ready' } as AlertDeliveryDiagnosis]);
    await Promise.resolve();
    await vi.advanceTimersByTimeAsync(120_000);
    expect(result.deliveryDiagnoses()).toEqual({});
    expect(AlertsAPI.getDeliveryDiagnoses).toHaveBeenCalledOnce();
  });

  it('owns overview stats, filtering, and acknowledge flows outside the tab shell', async () => {
    const now = Date.now();
    const warning = () => makeAlert('warning', new Date(now - 60_000).toISOString(), false);
    // Keyed like the websocket store: updateAlert merges into the stored
    // alert and server payloads replace it in place.
    const [alertsById, setAlertsById] = createStore<Record<string, Alert>>({
      warning: warning(),
      acknowledged: makeAlert('acknowledged', new Date(now - 2 * 60_000).toISOString(), true),
      old: makeAlert('old', new Date(now - 3 * 86_400_000).toISOString(), false),
    });
    const activeAlerts = () => alertsById;
    const [showAcknowledged, setShowAcknowledged] = createSignal(false);
    const updateAlert = vi.fn((alertIdentifier: string, updates: Partial<Alert>) => {
      setAlertsById(alertIdentifier, { ...alertsById[alertIdentifier], ...updates });
    });

    vi.mocked(AlertsAPI.acknowledge).mockResolvedValue(undefined as any);
    vi.mocked(AlertsAPI.unacknowledge).mockResolvedValue(undefined as any);
    vi.mocked(AlertsAPI.bulkAcknowledge).mockResolvedValue({
      results: [
        { alertIdentifier: 'warning', success: true },
        { alertIdentifier: 'old', success: false },
      ],
    } as any);

    const { result } = renderHook(() =>
      useAlertOverviewState({
        activeAlerts,
        overrides: () => [],
        showAcknowledged,
        updateAlert,
        acknowledgementRequests: createAlertAcknowledgementRequests(),
      }),
    );

    expect(result.alertStats()).toMatchObject({
      active: 2,
      acknowledged: 1,
      total24h: 2,
      overrides: 0,
    });
    expect(result.filteredAlerts().map((alert) => alert.id)).toEqual(['warning', 'old']);

    await result.handleAlertAcknowledgement(activeAlerts().warning);

    expect(AlertsAPI.acknowledge).toHaveBeenCalledWith('warning');
    expect(updateAlert).toHaveBeenCalledWith(
      'warning',
      expect.objectContaining({ acknowledged: true }),
    );
    expect(notificationStore.success).toHaveBeenCalledWith('Alert acknowledged');
    expect(result.processingAlerts().has('warning')).toBe(true);
    // Hiding/counting acknowledgement is not deletion or measured recovery.
    expect(result.alertStats()).toMatchObject({ active: 1, acknowledged: 2 });
    expect(result.filteredAlerts().map((alert) => alert.id)).toEqual(['old']);
    expect(Object.keys(activeAlerts())).toHaveLength(3);
    setShowAcknowledged(true);
    expect(result.filteredAlerts().map((alert) => alert.id)).toEqual([
      'old',
      'warning',
      'acknowledged',
    ]);
    setShowAcknowledged(false);
    // The server confirms, then another session unacknowledges: the card
    // returns without a reload.
    setAlertsById('warning', reconcile({ ...warning(), acknowledged: true, ackUser: 'admin' }));
    expect(result.filteredAlerts().map((alert) => alert.id)).toEqual(['old']);
    setAlertsById('warning', reconcile(warning()));
    expect(result.filteredAlerts().map((alert) => alert.id)).toEqual(['warning', 'old']);
    expect(result.alertStats()).toMatchObject({ active: 2, acknowledged: 1 });

    vi.advanceTimersByTime(1500);
    expect(result.processingAlerts().has('warning')).toBe(false);

    await result.handleAlertAcknowledgement(alertsById.warning);
    vi.advanceTimersByTime(1500);
    await result.handleBulkAcknowledge();

    expect(AlertsAPI.bulkAcknowledge).toHaveBeenCalledWith(['old']);
    expect(updateAlert).toHaveBeenCalledWith(
      'warning',
      expect.objectContaining({ acknowledged: true }),
    );
    expect(notificationStore.error).toHaveBeenCalledWith('Failed to acknowledge 1 alert.');
  });

  it('keeps a stable id order for alerts sharing a startTime (#1218)', () => {
    const sharedStart = new Date(Date.now() - 60_000).toISOString();
    const [activeAlerts] = createSignal<Record<string, Alert>>({
      zeta: makeAlert('zeta', sharedStart),
      alpha: makeAlert('alpha', sharedStart),
      mid: makeAlert('mid', sharedStart),
    });

    const { result } = renderHook(() =>
      useAlertOverviewState({
        activeAlerts,
        overrides: () => [],
        showAcknowledged: () => true,
        updateAlert: vi.fn(),
        acknowledgementRequests: createAlertAcknowledgementRequests(),
      }),
    );

    expect(result.filteredAlerts().map((alert) => alert.id)).toEqual(['alpha', 'mid', 'zeta']);
  });

  it('counts alerts with missing startTime in total24h', () => {
    const now = Date.now();
    const [activeAlerts] = createSignal<Record<string, Alert>>({
      recent: makeAlert('recent', new Date(now - 60_000).toISOString()),
      missing: { ...makeAlert('missing', ''), startTime: undefined as unknown as string },
      invalid: { ...makeAlert('invalid', 'bad-date'), startTime: 'not-a-date' },
      old: makeAlert('old', new Date(now - 3 * 86_400_000).toISOString()),
    });

    const { result } = renderHook(() =>
      useAlertOverviewState({
        activeAlerts,
        overrides: () => [],
        showAcknowledged: () => true,
        updateAlert: vi.fn(),
        acknowledgementRequests: createAlertAcknowledgementRequests(),
      }),
    );

    const stats = result.alertStats();
    expect(stats.active).toBe(4);
    expect(stats.total24h).toBe(3);
    expect(stats.acknowledged).toBe(0);
  });

  it('groups only explicit shared-system correlations across resources', () => {
    const startTime = new Date(Date.now() - 60_000).toISOString();
    const connection = {
      ...makeAlert('connection', startTime),
      resourceId: 'pve:delly',
      correlation: {
        key: 'pve:delly',
        kind: 'shared-system' as const,
        role: 'primary' as const,
        reason: 'proxmox-connection-ownership',
      },
    };
    const node = {
      ...makeAlert('node', startTime),
      resourceId: 'node/delly/pve-1',
      level: 'critical' as const,
      correlation: {
        key: 'pve:delly',
        kind: 'shared-system' as const,
        role: 'supporting' as const,
        reason: 'proxmox-node-membership',
      },
    };
    const [activeAlerts] = createSignal<Record<string, Alert>>({ connection, node });

    const { result } = renderHook(() =>
      useAlertOverviewState({
        activeAlerts,
        overrides: () => [],
        showAcknowledged: () => true,
        updateAlert: vi.fn(),
        acknowledgementRequests: createAlertAcknowledgementRequests(),
      }),
    );

    expect(result.groupedAlerts()).toEqual([
      expect.objectContaining({
        key: 'correlation:shared-system:pve:delly',
        primary: connection,
        related: [node],
        correlated: true,
      }),
    ]);
  });

  it('groups explicit infrastructure synthesis without hiding the supporting detector', () => {
    const startTime = new Date(Date.now() - 60_000).toISOString();
    const root = {
      ...makeAlert('root', startTime),
      resourceId: 'agent:edge-1',
      correlation: {
        key: 'infrastructure:root',
        kind: 'infrastructure-incident' as const,
        role: 'primary' as const,
        reason: 'Supported by canonical relationships.',
        failureClass: 'runtime' as const,
        inference: 'supported-cause' as const,
      },
    };
    const symptom = {
      ...makeAlert('symptom', startTime),
      resourceId: 'availability:checkout',
      correlation: {
        key: 'infrastructure:root',
        kind: 'infrastructure-incident' as const,
        role: 'supporting' as const,
        reason: 'Grouped beneath Edge host.',
        failureClass: 'network-path' as const,
        inference: 'supported-cause' as const,
      },
    };
    const [activeAlerts] = createSignal<Record<string, Alert>>({ root, symptom });

    const { result } = renderHook(() =>
      useAlertOverviewState({
        activeAlerts,
        overrides: () => [],
        showAcknowledged: () => true,
        updateAlert: vi.fn(),
        acknowledgementRequests: createAlertAcknowledgementRequests(),
      }),
    );

    expect(result.groupedAlerts()).toEqual([
      expect.objectContaining({
        key: 'correlation:infrastructure-incident:infrastructure:root',
        primary: root,
        related: [symptom],
        correlated: true,
      }),
    ]);
  });

  it('does not infer correlation by truncating resource paths', () => {
    const startTime = new Date(Date.now() - 60_000).toISOString();
    const first = { ...makeAlert('first', startTime), resourceId: 'host/one/disk:sda' };
    const second = { ...makeAlert('second', startTime), resourceId: 'host/one/disk:sdb' };
    const [activeAlerts] = createSignal<Record<string, Alert>>({ first, second });

    const { result } = renderHook(() =>
      useAlertOverviewState({
        activeAlerts,
        overrides: () => [],
        showAcknowledged: () => true,
        updateAlert: vi.fn(),
        acknowledgementRequests: createAlertAcknowledgementRequests(),
      }),
    );

    expect(result.groupedAlerts()).toHaveLength(2);
    expect(result.groupedAlerts().every((group) => !group.correlated)).toBe(true);
  });

  it('still groups multiple detector signals for the exact same resource', () => {
    const startTime = new Date(Date.now() - 60_000).toISOString();
    const first = { ...makeAlert('first', startTime), resourceId: 'vm/delly/100' };
    const second = { ...makeAlert('second', startTime), resourceId: 'vm/delly/100' };
    const [activeAlerts] = createSignal<Record<string, Alert>>({ first, second });

    const { result } = renderHook(() =>
      useAlertOverviewState({
        activeAlerts,
        overrides: () => [],
        showAcknowledged: () => true,
        updateAlert: vi.fn(),
        acknowledgementRequests: createAlertAcknowledgementRequests(),
      }),
    );

    expect(result.groupedAlerts()).toEqual([
      expect.objectContaining({
        key: 'resource:vm/delly/100',
        related: [second],
        correlated: false,
      }),
    ]);
  });
});