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.

16.0 KB
Raw Blame
import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
import { render, screen, cleanup, fireEvent, within } from '@solidjs/testing-library';
import { createSignal } from 'solid-js';
import type { MemoryObservationPresentation } from '@/utils/memoryObservation';
import { StackedMemoryBar } from './StackedMemoryBar';

let resizeCallback: ResizeObserverCallback | undefined;
const mockObserve = vi.fn();
const mockDisconnect = vi.fn();

global.ResizeObserver = class ResizeObserver {
  constructor(cb: ResizeObserverCallback) {
    resizeCallback = cb;
  }
  observe = mockObserve;
  disconnect = mockDisconnect;
  unobserve = vi.fn();
};

function getSegments(container: HTMLElement): SVGRectElement[] {
  return Array.from(
    container.querySelectorAll<SVGRectElement>('rect[data-stacked-memory-segment="true"]'),
  );
}

function getSwapBar(container: HTMLElement): SVGRectElement | null {
  return container.querySelector('rect[data-stacked-memory-swap="true"]');
}

describe('StackedMemoryBar', () => {
  beforeEach(() => {
    Object.defineProperty(HTMLElement.prototype, 'offsetWidth', { configurable: true, value: 200 });
    resizeCallback = undefined;
    vi.clearAllMocks();
  });

  afterEach(() => {
    cleanup();
  });

  // ---- Utilization percent computation ----

  it('renders percentage label when used/total provided', () => {
    // 4GB used of 8GB total = 50%
    render(() => <StackedMemoryBar used={4 * 1024 ** 3} total={8 * 1024 ** 3} />);
    expect(screen.getByText('50%')).toBeInTheDocument();
  });

  it('renders N/A with no utilization segment when usage is unavailable', () => {
    const { container } = render(() => (
      <StackedMemoryBar used={0} total={8 * 1024 ** 3} unavailable />
    ));
    expect(screen.getByText('N/A')).toBeInTheDocument();
    expect(screen.queryByText('0%')).not.toBeInTheDocument();
    expect(getSegments(container)).toHaveLength(0);
  });

  it('keeps unavailable usage and its explanation in the opted-in accessible breakdown', () => {
    render(() => (
      <StackedMemoryBar
        used={0}
        total={32 * 1024 ** 3}
        cache={20 * 1024 ** 3}
        reading={{ state: 'unavailable', message: 'No current memory reading.' }}
        detailsLabel="Memory composition for unavailable host"
      />
    ));
    fireEvent.click(
      screen.getByRole('button', { name: 'Memory composition for unavailable host' }),
    );
    const dialog = screen.getByRole('dialog');
    expect(within(dialog).getByText('Unavailable', { exact: true })).toBeInTheDocument();
    expect(within(dialog).getByText('No current memory reading.')).toBeInTheDocument();
    expect(within(dialog).getByText('Total', { exact: true }).nextElementSibling).toHaveTextContent(
      '32.0 GB',
    );
    expect(within(dialog).queryByText('Free', { exact: true })).toBeNull();
    expect(within(dialog).queryByText('Reclaimable cache')).toBeNull();
  });

  it.each(['last-known', 'unknown'] as const)(
    'uses neutral %s bars and restores live decoration only with a current reading',
    (state) => {
      const [reading, setReading] = createSignal<MemoryObservationPresentation>({
        state,
        summary: 'Retained reading',
        message: 'Not a current measurement.',
        mayIncludeCache: false,
      });
      const { container } = render(() => (
        <StackedMemoryBar
          used={90}
          total={100}
          swapUsed={10}
          swapTotal={20}
          reading={reading()}
          anomaly={{
            resource_id: 'vm-100',
            resource_name: 'test-vm',
            resource_type: 'vm',
            metric: 'memory',
            current_value: 90,
            baseline_mean: 30,
            baseline_std_dev: 5,
            z_score: 12,
            severity: 'critical',
            description: 'Memory usage 3x above baseline',
          }}
        />
      ));
      const bar = getSegments(container)[0];
      const shell = container.firstElementChild;
      expect(screen.getByText('90%')).toBeInTheDocument();
      expect(bar).toHaveAttribute('fill', 'rgba(148, 163, 184, 0.5)');
      expect(getSwapBar(container)).toHaveAttribute('fill', 'rgba(148, 163, 184, 0.5)');
      expect(screen.queryByText('3.0x')).not.toBeInTheDocument();

      setReading({ ...reading(), state: 'current', message: 'Current.' });
      expect(container.firstElementChild).toBe(shell);
      expect(getSegments(container)[0]).toHaveAttribute('fill', 'rgba(239, 68, 68, 0.6)');
      expect(getSwapBar(container)).toHaveAttribute('fill', 'rgb(168 85 247)');
      expect(screen.getByText('3.0x')).toBeInTheDocument();

      setReading({ ...reading(), state: 'unavailable', message: 'Unavailable.' });
      expect(screen.getByText('N/A')).toBeInTheDocument();
      expect(screen.queryByText('90%')).not.toBeInTheDocument();
      expect(screen.queryByText('3.0x')).not.toBeInTheDocument();
      expect(getSwapBar(container)).toBeNull();
      expect(getSegments(container)).toEqual([]);
    },
  );

  it('renders 0% when both used and total are 0', () => {
    render(() => <StackedMemoryBar used={0} total={0} />);
    expect(screen.getByText('0%')).toBeInTheDocument();
  });

  it('uses percentOnly when total is 0', () => {
    render(() => <StackedMemoryBar used={0} total={0} percentOnly={73} />);
    expect(screen.getByText('73%')).toBeInTheDocument();
  });

  it('clamps percentOnly to 0-100 range', () => {
    render(() => <StackedMemoryBar used={0} total={0} percentOnly={150} />);
    expect(screen.getByText('100%')).toBeInTheDocument();
    cleanup();

    render(() => <StackedMemoryBar used={0} total={0} percentOnly={-20} />);
    expect(screen.getByText('0%')).toBeInTheDocument();
  });

  it('prefers used/total over percentOnly', () => {
    // 2GB/8GB = 25%, percentOnly = 90 should be ignored
    render(() => <StackedMemoryBar used={2 * 1024 ** 3} total={8 * 1024 ** 3} percentOnly={90} />);
    expect(screen.getByText('25%')).toBeInTheDocument();
  });

  it('allows used > total without clamping (intentional for VM overcommit)', () => {
    // 10GB used / 8GB total = 125% — intentionally not clamped
    const { container } = render(() => (
      <StackedMemoryBar used={10 * 1024 ** 3} total={8 * 1024 ** 3} />
    ));
    expect(screen.getByText('125%')).toBeInTheDocument();
    // Segment width also exceeds 100% (the SVG viewBox clips visually)
    const segment = getSegments(container)[0];
    expect(segment).toHaveAttribute('width', '125');
  });

  // ---- Segments ----

  it('renders a single active segment for normal memory usage', () => {
    const { container } = render(() => (
      <StackedMemoryBar used={2 * 1024 ** 3} total={8 * 1024 ** 3} />
    ));
    // The bar fills 25%
    const segments = getSegments(container);
    expect(segments.length).toBe(1);
    expect(segments[0]).toHaveAttribute('width', '25');
    expect(segments[0]).toHaveAttribute('x', '0');
  });

  it('renders reclaimable cache as a solid segment so the value label stays legible', () => {
    const { container } = render(() => (
      <StackedMemoryBar used={6 * 1024 ** 3} total={8 * 1024 ** 3} cache={1 * 1024 ** 3} />
    ));

    const segments = getSegments(container);
    expect(segments).toHaveLength(2);
    expect(segments[1].getAttribute('fill')).toContain('251, 191, 36');
    expect(container.querySelector('pattern')).not.toBeInTheDocument();
  });

  it('renders balloon segment when active ballooning is in effect', () => {
    // used=2GB, total=8GB, balloon=4GB — active ballooning
    const { container } = render(() => (
      <StackedMemoryBar used={2 * 1024 ** 3} total={8 * 1024 ** 3} balloon={4 * 1024 ** 3} />
    ));
    const segments = getSegments(container);
    // Active segment + Balloon segment
    expect(segments.length).toBe(2);
    // Active: 2/8 = 25%
    expect(segments[0]).toHaveAttribute('width', '25');
    // Balloon: (4/8)*100 - 25 = 25%
    expect(segments[1]).toHaveAttribute('width', '25');
    expect(segments[1]).toHaveAttribute('x', '25');
  });

  it('does not render balloon segment when balloon equals total', () => {
    // balloon == total means ballooning configured but at max — no actual ballooning
    const { container } = render(() => (
      <StackedMemoryBar used={2 * 1024 ** 3} total={8 * 1024 ** 3} balloon={8 * 1024 ** 3} />
    ));
    const segments = getSegments(container);
    expect(segments.length).toBe(1);
  });

  it('does not render balloon segment when balloon is 0', () => {
    const { container } = render(() => (
      <StackedMemoryBar used={2 * 1024 ** 3} total={8 * 1024 ** 3} balloon={0} />
    ));
    const segments = getSegments(container);
    expect(segments.length).toBe(1);
  });

  it('does not render balloon segment when used exceeds balloon', () => {
    // used=5GB > balloon=4GB — no room for balloon segment
    const { container } = render(() => (
      <StackedMemoryBar used={5 * 1024 ** 3} total={8 * 1024 ** 3} balloon={4 * 1024 ** 3} />
    ));
    const segments = getSegments(container);
    // Only active segment (balloon filtered out because used > balloon)
    expect(segments.length).toBe(1);
  });

  it('renders no segments when used is 0 and total > 0', () => {
    const { container } = render(() => <StackedMemoryBar used={0} total={8 * 1024 ** 3} />);
    const segments = getSegments(container);
    // bytes=0 is filtered out
    expect(segments.length).toBe(0);
  });

  it('renders percent-only segment (no bytes) when total is 0 but percentOnly > 0', () => {
    const { container } = render(() => <StackedMemoryBar used={0} total={0} percentOnly={60} />);
    const segments = getSegments(container);
    expect(segments.length).toBe(1);
    expect(segments[0]).toHaveAttribute('width', '60');
  });

  // ---- Swap ----

  it('renders swap indicator when swap data is present and used > 0', () => {
    const { container } = render(() => (
      <StackedMemoryBar
        used={4 * 1024 ** 3}
        total={8 * 1024 ** 3}
        swapUsed={1 * 1024 ** 3}
        swapTotal={2 * 1024 ** 3}
      />
    ));
    // Swap indicator is the 3px bar at the bottom
    const swapBar = getSwapBar(container);
    expect(swapBar).toBeInTheDocument();
    // 1/2 = 50%
    expect(swapBar).toHaveAttribute('width', '50');
  });

  it('does not render swap indicator when swapUsed is 0', () => {
    const { container } = render(() => (
      <StackedMemoryBar
        used={4 * 1024 ** 3}
        total={8 * 1024 ** 3}
        swapUsed={0}
        swapTotal={2 * 1024 ** 3}
      />
    ));
    const swapBar = getSwapBar(container);
    expect(swapBar).not.toBeInTheDocument();
  });

  it('does not render swap indicator when swapTotal is 0', () => {
    const { container } = render(() => (
      <StackedMemoryBar used={4 * 1024 ** 3} total={8 * 1024 ** 3} swapTotal={0} />
    ));
    const swapBar = getSwapBar(container);
    expect(swapBar).not.toBeInTheDocument();
  });

  it('clamps swap indicator width to 100% when swapUsed exceeds swapTotal', () => {
    const { container } = render(() => (
      <StackedMemoryBar
        used={4 * 1024 ** 3}
        total={8 * 1024 ** 3}
        swapUsed={3 * 1024 ** 3}
        swapTotal={2 * 1024 ** 3}
      />
    ));
    const swapBar = getSwapBar(container);
    expect(swapBar).toBeInTheDocument();
    // Math.min(150, 100) = 100%
    expect(swapBar).toHaveAttribute('width', '100');
  });

  // ---- Sublabel (bytes display) ----

  it('shows sublabel when space permits and total > 0', () => {
    render(() => <StackedMemoryBar used={4 * 1024 ** 3} total={8 * 1024 ** 3} />);
    // Width flows only from the ResizeObserver's initial delivery.
    resizeCallback?.(
      [{ contentRect: { width: 200 } } as ResizeObserverEntry],
      {} as ResizeObserver,
    );
    // Should show sublabel in parentheses with bytes format
    const sublabel = screen.getByText(/4\.00 GB/);
    expect(sublabel).toBeInTheDocument();
    expect(sublabel.parentElement).toHaveClass('shadow-xs');
  });

  it('hides sublabel when container is too narrow', () => {
    Object.defineProperty(HTMLElement.prototype, 'offsetWidth', { configurable: true, value: 20 });
    render(() => <StackedMemoryBar used={4 * 1024 ** 3} total={8 * 1024 ** 3} />);
    expect(screen.queryByText(/4\.00 GB/)).not.toBeInTheDocument();
  });

  it('does not show sublabel when total is 0', () => {
    render(() => <StackedMemoryBar used={0} total={0} percentOnly={50} />);
    const sublabelContainer = screen.queryByText(/\(/);
    expect(sublabelContainer).not.toBeInTheDocument();
  });

  it('updates sublabel visibility on resize', async () => {
    render(() => <StackedMemoryBar used={4 * 1024 ** 3} total={8 * 1024 ** 3} />);
    // Width flows only from the ResizeObserver, so the initial narrow
    // measurement arrives through its callback.
    resizeCallback?.([{ contentRect: { width: 20 } } as ResizeObserverEntry], {} as ResizeObserver);
    expect(screen.queryByText(/4\.00 GB/)).not.toBeInTheDocument();

    // Simulate resize to wider container
    resizeCallback?.(
      [{ contentRect: { width: 300 } } as ResizeObserverEntry],
      {} as ResizeObserver,
    );
    expect(await screen.findByText(/4\.00 GB/)).toBeInTheDocument();
  });

  // ---- Anomaly indicator ----

  it('renders anomaly indicator for high ratio anomaly', () => {
    const anomaly = {
      resource_id: 'vm-100',
      resource_name: 'test-vm',
      resource_type: 'vm',
      metric: 'memory',
      current_value: 90,
      baseline_mean: 30,
      baseline_std_dev: 5,
      z_score: 12,
      severity: 'critical',
      description: 'Memory usage 3x above baseline',
    };
    render(() => <StackedMemoryBar used={7 * 1024 ** 3} total={8 * 1024 ** 3} anomaly={anomaly} />);
    // 90/30 = 3.0x
    expect(screen.getByText('3.0x')).toBeInTheDocument();
    expect(screen.getByText('3.0x')).toHaveClass('text-red-400');
  });

  it('renders up-arrow anomaly for moderate anomaly', () => {
    const anomaly = {
      resource_id: 'vm-100',
      resource_name: 'test-vm',
      resource_type: 'vm',
      metric: 'memory',
      current_value: 50,
      baseline_mean: 30,
      baseline_std_dev: 5,
      z_score: 4,
      severity: 'medium',
      description: 'Memory usage above baseline',
    };
    render(() => <StackedMemoryBar used={4 * 1024 ** 3} total={8 * 1024 ** 3} anomaly={anomaly} />);
    // 50/30 = 1.67x → '↑↑'
    expect(screen.getByText('↑↑')).toBeInTheDocument();
    expect(screen.getByText('↑↑')).toHaveClass('text-yellow-400');
  });

  it('does not render anomaly indicator when anomaly is null', () => {
    render(() => <StackedMemoryBar used={4 * 1024 ** 3} total={8 * 1024 ** 3} anomaly={null} />);
    // No anomaly ratio text (Nx, ↑↑, ↑) should be present
    expect(screen.queryByText(/\dx$/)).not.toBeInTheDocument();
    expect(screen.queryByText('↑↑')).not.toBeInTheDocument();
    expect(screen.queryByText('↑')).not.toBeInTheDocument();
  });

  // ---- Threshold-based coloring ----

  it('uses green color for low memory usage', () => {
    const { container } = render(() => (
      <StackedMemoryBar used={2 * 1024 ** 3} total={8 * 1024 ** 3} />
    ));
    const segment = getSegments(container)[0];
    // 25% → normal → green
    expect(segment.getAttribute('fill')).toContain('34, 197, 94');
  });

  it('uses yellow color for warning-level memory usage', () => {
    const { container } = render(() => (
      <StackedMemoryBar used={6 * 1024 ** 3} total={8 * 1024 ** 3} />
    ));
    const segment = getSegments(container)[0];
    // 75% → warning → yellow
    expect(segment.getAttribute('fill')).toContain('234, 179, 8');
  });

  it('uses red color for critical memory usage', () => {
    const { container } = render(() => (
      <StackedMemoryBar used={7 * 1024 ** 3} total={8 * 1024 ** 3} />
    ));
    const segment = getSegments(container)[0];
    // 87.5% → critical → red
    expect(segment.getAttribute('fill')).toContain('239, 68, 68');
  });

  // ---- ResizeObserver lifecycle ----

  it('registers and cleans up ResizeObserver', () => {
    const { unmount } = render(() => (
      <StackedMemoryBar used={4 * 1024 ** 3} total={8 * 1024 ** 3} />
    ));
    expect(mockObserve).toHaveBeenCalledTimes(1);
    unmount();
    expect(mockDisconnect).toHaveBeenCalledTimes(1);
  });
});