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.

10.5 KB
Raw Blame
import { cleanup, fireEvent, render, screen, waitFor, within } from '@solidjs/testing-library';
import { Show, createSignal } from 'solid-js';
import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
import { useWorkloads, __resetWorkloadsCacheForTests } from '@/hooks/useWorkloads';
import { resetCreateNonSuspendingQueryCacheForTest } from '@/hooks/createNonSuspendingQuery';
import type { Resource } from '@/types/resource';
import { GuestDrawer } from '../GuestDrawer';
import { BackupIndicator, BackupStatusCell } from '../GuestRowCells';

const api = vi.hoisted(() => ({ json: vi.fn() }));
vi.mock('@/utils/apiClient', () => ({
  apiFetchJSON: api.json,
  getOrgID: () => 'default',
}));
vi.mock('@/stores/alertsActivation', () => ({
  useAlertsActivation: () => ({
    getBackupThresholds: () => ({ freshHours: 24, staleHours: 72 }),
    getMetricThresholds: () => null,
  }),
}));
vi.mock('@/api/charts', async () => {
  const actual = await vi.importActual<typeof import('@/api/charts')>('@/api/charts');
  return {
    ...actual,
    ChartsAPI: {
      ...actual.ChartsAPI,
      getMetricsHistory: vi.fn().mockResolvedValue({ metrics: {} }),
    },
  };
});
vi.mock('@/api/resourceOperatorState', () => ({
  getResourceOperatorState: vi.fn().mockResolvedValue(null),
}));
vi.mock('@/stores/license', () => ({
  isRangeLocked: () => false,
  loadRuntimeCapabilities: vi.fn(),
  maxHistoryDays: () => 90,
}));

const now = Date.parse('2026-10-04T12:00:00Z');
const valid = '2026-10-04T13:00:00.123456789+02:00';
const iso = '2026-10-04T11:00:00.123Z';
const malformed = ['2026-09-31T11:00:00Z', '2026-10-04T11:00:00', '2026-10-04'];

const rawResource = (
  lastBackup: string | undefined,
  type: 'vm' | 'system-container',
  running: boolean,
) => ({
  id: 'east-100',
  name: 'backup-time-guest',
  type,
  status: 'running',
  lastSeen: new Date(now).toISOString(),
  sources: ['proxmox'],
  proxmox: {
    vmid: 100,
    instance: 'east',
    node: 'pve-1',
    nodeName: 'pve-1',
    lastBackup,
    backupInProgress: running,
  },
});

function mount(
  transport: 'api' | 'snapshot',
  type: 'vm' | 'system-container',
  initialBackup: string | undefined = malformed[0],
) {
  let raw = rawResource(initialBackup, type, false);
  api.json.mockImplementation(() => Promise.resolve({ data: [raw], meta: { totalPages: 1 } }));
  const [snapshot, setSnapshot] = createSignal<Resource[]>([raw as unknown as Resource]);
  let source!: ReturnType<typeof useWorkloads>;
  render(() => {
    source = useWorkloads(
      () => true,
      transport === 'snapshot' ? { resourceSnapshot: snapshot } : {},
    );
    const guest = () => source.workloads()[0];
    return (
      <Show when={guest()}>
        <BackupStatusCell
          lastBackup={guest().lastBackup}
          backupRunning={guest().backupInProgress}
        />
        <BackupIndicator
          lastBackup={guest().lastBackup}
          backupRunning={guest().backupInProgress}
          isTemplate={false}
        />
        <GuestDrawer guest={guest()} onClose={() => {}} />
      </Show>
    );
  });
  return {
    source: () => source,
    update: async (value: string | undefined, running = false) => {
      raw = rawResource(value, type, running);
      if (transport === 'snapshot') setSnapshot([raw as unknown as Resource]);
      else await source.refetch();
    },
  };
}

const backupRow = () =>
  within(screen.getByTestId('guest-drawer-overview'))
    .getByText('Last completed backup')
    .closest('tr')!;

beforeEach(() => {
  vi.useFakeTimers({ now, toFake: ['Date'] });
  __resetWorkloadsCacheForTests();
  resetCreateNonSuspendingQueryCacheForTest();
  api.json.mockReset();
});
afterEach(() => {
  cleanup();
  __resetWorkloadsCacheForTests();
  resetCreateNonSuspendingQueryCacheForTest();
  vi.useRealTimers();
});

describe.each(['api', 'snapshot'] as const)(
  'backup time through %s resource producer',
  (transport) => {
    it.each(['vm', 'system-container'] as const)(
      '[regression] missing %s completion evidence never claims all-time absence or a first backup',
      async (type) => {
        const view = mount(transport, type, '');
        const badge = await screen.findByRole('button', {
          name: 'Backup status: no completed backup reported',
        });
        const details = screen.getByTestId('guest-technical-details') as HTMLDetailsElement;
        details.open = true;
        badge.focus();
        fireEvent.click(badge);
        const dialog = screen.getByRole('dialog', { name: /^Backup status details/ });
        const close = within(dialog).getByRole('button', { name: 'Close backup details' });
        close.focus();
        for (const value of [undefined, '', '0001-01-01T00:00:00Z']) {
          for (const running of [true, false]) {
            await view.update(value, running);
            await waitFor(() => expect(badge).toHaveTextContent(running ? 'Running' : 'Unknown'));
            expect(badge).toHaveAccessibleName(/no completed backup reported/);
            expect(badge.className).toContain(running ? 'blue' : 'yellow');
            expect(badge.className).not.toMatch(/red|green/);
            expect(dialog).toHaveTextContent(
              'No completed backup is reported in the current inventory',
            );
            expect(dialog).toHaveTextContent('Missing data does not mean no backups exist');
            expect(dialog).not.toHaveTextContent(/ever|first backup|no completed backup yet/i);
            expect(dialog.querySelector('time')).toBeNull();
            expect(backupRow()).toHaveTextContent('No completed backup reported');
            expect(backupRow().querySelector('td')).toHaveClass('text-amber-700');
            expect(screen.getByTestId('guest-drawer-overview').textContent).not.toContain('never');
            expect(
              within(dialog).queryByRole('link', { name: 'Change when backups count as old' }),
            ).toBeNull();
            expect(close).toHaveFocus();
          }
        }
        await view.update(valid);
        await waitFor(() => expect(badge).toHaveAccessibleName(/fresh/));
        expect(badge.className).toContain('green');
        expect(dialog.querySelector('time')).toHaveAttribute('datetime', iso);
        expect(backupRow().querySelector('time')).toHaveAttribute('datetime', iso);
        await view.update('');
        await waitFor(() => expect(badge).toHaveAccessibleName(/no completed backup reported/));
        expect(dialog.querySelector('time')).toBeNull();
        expect(backupRow().querySelector('time')).toBeNull();
        expect(screen.getByRole('dialog', { name: /^Backup status details/ })).toBe(dialog);
        expect(screen.getByTestId('guest-technical-details')).toBe(details);
        expect(close).toHaveFocus();
        fireEvent.click(close);
        expect(badge).toHaveFocus();
        if (transport === 'snapshot') expect(api.json).not.toHaveBeenCalled();
        else expect(api.json).toHaveBeenCalledTimes(9);
      },
    );

    it.each(['vm', 'system-container'] as const)(
      '[regression] keeps malformed %s evidence unknown through live recovery and recurrence',
      async (type) => {
        const view = mount(transport, type);
        const badge = await screen.findByRole('button', { name: /^Backup status:/ });
        const details = screen.getByTestId('guest-technical-details') as HTMLDetailsElement;
        details.open = true;
        badge.focus();
        fireEvent.click(badge);
        const dialog = screen.getByRole('dialog', { name: /^Backup status details/ });
        const close = within(dialog).getByRole('button', { name: 'Close backup details' });
        close.focus();
        for (const value of malformed) {
          await view.update(value);
          await waitFor(() => expect(badge).toHaveTextContent('Unknown'));
          expect(view.source().workloads()[0].lastBackup).toBeNaN();
          expect(badge.className).not.toContain('green');
          expect(
            screen.getByRole('button', { name: /^Backup time unavailable:/ }),
          ).toBeInTheDocument();
          expect(dialog.querySelector('time')).toBeNull();
          expect(backupRow()).toHaveTextContent('invalid timestamp');
          expect(backupRow().querySelector('time')).toBeNull();
          expect(screen.getByTestId('guest-technical-details')).toBe(details);
          expect(close).toHaveFocus();
        }
        await view.update(valid);
        await waitFor(() => expect(badge).toHaveAccessibleName(/fresh/));
        expect(view.source().workloads()[0].lastBackup).toBe(Date.parse(iso));
        expect(dialog.querySelector('time')).toHaveAttribute('datetime', iso);
        expect(backupRow().querySelector('time')).toHaveAttribute('datetime', iso);
        expect(dialog.querySelector('time')).toHaveTextContent('2026-10-04 11:00:00 UTC');
        expect(badge.className).toContain('green');
        await view.update(malformed[0], true);
        await waitFor(() => expect(badge).toHaveTextContent('Running'));
        expect(badge).toHaveAccessibleName(/invalid timestamp/);
        expect(dialog.querySelector('time')).toBeNull();
        expect(backupRow().querySelector('time')).toBeNull();
        expect(screen.getByTestId('guest-drawer-overview')).toHaveTextContent(
          'Running · not completed yet',
        );
        expect(screen.getByRole('dialog', { name: /^Backup status details/ })).toBe(dialog);
        expect(close).toHaveFocus();
        fireEvent.click(close);
        expect(badge).toHaveFocus();
        expect(view.source().workloads()[0]).toMatchObject({
          id: 'east-100',
          name: 'backup-time-guest',
          instance: 'east',
          vmid: 100,
          node: 'pve-1',
        });
        if (transport === 'snapshot') expect(api.json).not.toHaveBeenCalled();
        else expect(api.json).toHaveBeenCalledTimes(6);
      },
    );

    it('[control] preserves explicit absence, valid offsets and future uncertainty', async () => {
      const view = mount(transport, 'vm');
      const badge = await screen.findByRole('button', { name: /^Backup status:/ });
      for (const value of ['', '0001-01-01T00:00:00Z', '0001-01-01T00:00:00.000000000Z']) {
        await view.update(value);
        await waitFor(() => expect(badge).toHaveTextContent('Unknown'));
        expect(view.source().workloads()[0].lastBackup).toBe(0);
      }
      await view.update('2026-10-04T04:00:00-07:00');
      await waitFor(() => expect(badge).toHaveAccessibleName(/fresh/));
      await view.update('2026-10-04T12:00:01Z');
      await waitFor(() => expect(badge).toHaveAccessibleName(/timestamp is in the future/));
      expect(view.source().workloads()[0].lastBackup).toBe(now + 1000);
    });
  },
);