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.

18.7 KB
Raw Blame
import { describe, expect, it } from 'vitest';
import {
  parseFilter,
  parseFilterStack,
  evaluateFilterStack,
  splitSearchExclusions,
  matchesSearchTermSplit,
} from '@/utils/searchQuery';
import type { VM } from '@/types/api';
import type { WorkloadGuest } from '@/types/workloads';

describe('parseFilter', () => {
  it('parses metric conditions with > operator', () => {
    const result = parseFilter('cpu>80');
    expect(result).toEqual({
      type: 'metric',
      field: 'cpu',
      operator: '>',
      value: 80,
    });
  });

  it('parses metric conditions with < operator', () => {
    const result = parseFilter('memory<50');
    expect(result).toEqual({
      type: 'metric',
      field: 'memory',
      operator: '<',
      value: 50,
    });
  });

  it('parses metric conditions with >= operator', () => {
    const result = parseFilter('cpu>=50');
    expect(result).toEqual({
      type: 'metric',
      field: 'cpu',
      operator: '>=',
      value: 50,
    });
  });

  it('parses metric conditions with <= operator', () => {
    const result = parseFilter('disk<=90');
    expect(result).toEqual({
      type: 'metric',
      field: 'disk',
      operator: '<=',
      value: 90,
    });
  });

  it('parses metric conditions with = operator', () => {
    const result = parseFilter('cpu=100');
    expect(result).toEqual({
      type: 'metric',
      field: 'cpu',
      operator: '=',
      value: 100,
    });
  });

  it('parses metric conditions with == operator', () => {
    const result = parseFilter('cpu==50');
    expect(result).toEqual({
      type: 'metric',
      field: 'cpu',
      operator: '==',
      value: 50,
    });
  });

  it('parses metric conditions with decimal values', () => {
    const result = parseFilter('cpu>50.5');
    expect(result).toEqual({
      type: 'metric',
      field: 'cpu',
      operator: '>',
      value: 50.5,
    });
  });

  it('parses text conditions with colon', () => {
    const result = parseFilter('name:prod');
    expect(result).toEqual({
      type: 'text',
      field: 'name',
      value: 'prod',
    });
  });

  it('parses text conditions with tags field', () => {
    const result = parseFilter('tags:production');
    expect(result).toEqual({
      type: 'text',
      field: 'tags',
      value: 'production',
    });
  });

  it('parses text conditions with type field', () => {
    const result = parseFilter('type:VM');
    expect(result).toEqual({
      type: 'text',
      field: 'type',
      value: 'VM',
    });
  });

  it('treats unknown patterns as raw text', () => {
    const result = parseFilter('mysearch');
    expect(result).toEqual({
      type: 'raw',
      rawText: 'mysearch',
    });
  });

  it('trims whitespace from input', () => {
    const result = parseFilter('  cpu>80  ');
    expect(result).toEqual({
      type: 'metric',
      field: 'cpu',
      operator: '>',
      value: 80,
    });
  });

  it('is case-insensitive for field names', () => {
    const result = parseFilter('CPU>80');
    expect(result).toEqual({
      type: 'metric',
      field: 'cpu',
      operator: '>',
      value: 80,
    });
  });
});

describe('parseFilterStack', () => {
  it('returns empty stack for empty string', () => {
    const result = parseFilterStack('');
    expect(result.filters).toEqual([]);
    expect(result.operators).toEqual([]);
  });

  it('returns empty stack for whitespace only', () => {
    const result = parseFilterStack('   ');
    expect(result.filters).toEqual([]);
    expect(result.operators).toEqual([]);
  });

  it('parses single filter without operator', () => {
    const result = parseFilterStack('cpu>80');
    expect(result.filters).toHaveLength(1);
    expect(result.filters[0]).toEqual({
      type: 'metric',
      field: 'cpu',
      operator: '>',
      value: 80,
    });
    expect(result.operators).toHaveLength(0);
  });

  it('parses multiple filters with AND operator', () => {
    const result = parseFilterStack('cpu>80 AND memory<50');
    expect(result.filters).toHaveLength(2);
    expect(result.filters[0]).toEqual({
      type: 'metric',
      field: 'cpu',
      operator: '>',
      value: 80,
    });
    expect(result.filters[1]).toEqual({
      type: 'metric',
      field: 'memory',
      operator: '<',
      value: 50,
    });
    expect(result.operators).toEqual(['AND']);
  });

  it('parses multiple filters with OR operator', () => {
    const result = parseFilterStack('name:prod OR name:staging');
    expect(result.filters).toHaveLength(2);
    expect(result.operators).toEqual(['OR']);
  });

  it('handles mixed case operators', () => {
    const result = parseFilterStack('cpu>80 and memory<50');
    expect(result.operators).toEqual(['AND']);
  });

  it('parses complex filter stack', () => {
    const result = parseFilterStack('cpu>80 AND name:prod OR tags:production');
    expect(result.filters).toHaveLength(3);
    expect(result.operators).toEqual(['AND', 'OR']);
  });
});

describe('evaluateFilterStack', () => {
  const createVM = (overrides: Partial<VM> = {}): VM => ({
    id: 'vm-1',
    vmid: 100,
    name: 'test-vm',
    node: 'node1',
    instance: 'qemu',
    status: 'running',
    type: 'qemu',
    cpu: 0.5,
    cpus: 2,
    memory: { usage: 1024, total: 2048, used: 1024, free: 1024 },
    disk: { usage: 50, total: 100, used: 50, free: 50 },
    networkIn: 100,
    networkOut: 200,
    diskRead: 300,
    diskWrite: 400,
    uptime: 3600,
    template: false,
    lastBackup: 0,
    tags: ['production', 'web'],
    lock: '',
    lastSeen: '',
    ...overrides,
  });

  it('returns true for empty filter stack', () => {
    const vm = createVM();
    const result = evaluateFilterStack(vm, { filters: [], operators: [] });
    expect(result).toBe(true);
  });

  describe('metric conditions', () => {
    it('evaluates cpu > threshold', () => {
      const vm = createVM({ cpu: 0.8 }); // 80%
      const stack = parseFilterStack('cpu>50');
      const result = evaluateFilterStack(vm, stack);
      expect(result).toBe(true);
    });

    it('evaluates cpu < threshold (false)', () => {
      const vm = createVM({ cpu: 0.3 }); // 30%
      const stack = parseFilterStack('cpu>50');
      const result = evaluateFilterStack(vm, stack);
      expect(result).toBe(false);
    });

    it('evaluates current memory percentage threshold', () => {
      const vm = createVM({
        memory: {
          usage: 90,
          total: 2000,
          used: 1800,
          free: 200,
          observation: {
            state: 'current',
            source: 'status-mem',
            observedAt: '2026-10-08T00:00:00Z',
          },
        },
      });
      const stack = parseFilterStack('memory<95');
      const result = evaluateFilterStack(vm, stack);
      expect(result).toBe(true); // 90% < 95%
    });

    it('evaluates disk usage threshold', () => {
      const vm = createVM({ disk: { usage: 80, total: 100, used: 80, free: 20 } });
      const stack = parseFilterStack('disk<70');
      const result = evaluateFilterStack(vm, stack);
      expect(result).toBe(false); // 80% > 70%
    });

    it('evaluates uptime threshold', () => {
      const vm = createVM({ status: 'running', uptime: 10000 });
      const stack = parseFilterStack('uptime>3600');
      const result = evaluateFilterStack(vm, stack);
      expect(result).toBe(true);
    });

    it('returns 0 for uptime when not running', () => {
      const vm = createVM({ status: 'stopped', uptime: 0 });
      const stack = parseFilterStack('uptime>3600');
      const result = evaluateFilterStack(vm, stack);
      expect(result).toBe(false);
    });
  });

  describe('text conditions', () => {
    it('evaluates name field', () => {
      const vm = createVM({ name: 'production-web-01' });
      const stack = parseFilterStack('name:web');
      const result = evaluateFilterStack(vm, stack);
      expect(result).toBe(true);
    });

    it('evaluates node field', () => {
      const vm = createVM({ node: 'cluster-node-1' });
      const stack = parseFilterStack('node:cluster');
      const result = evaluateFilterStack(vm, stack);
      expect(result).toBe(true);
    });

    it('evaluates vmid field', () => {
      const vm = createVM({ vmid: 100 });
      const stack = parseFilterStack('vmid:100');
      const result = evaluateFilterStack(vm, stack);
      expect(result).toBe(true);
    });

    it('evaluates tags field with array', () => {
      const vm = createVM({ tags: ['production', 'web', 'api'] });
      const stack = parseFilterStack('tags:web');
      const result = evaluateFilterStack(vm, stack);
      expect(result).toBe(true);
    });

    it('evaluates tags field with string', () => {
      const vm = createVM({ tags: 'production,web,api' });
      const stack = parseFilterStack('tags:api');
      const result = evaluateFilterStack(vm, stack);
      expect(result).toBe(true);
    });

    it('evaluates comma-separated tag search (OR logic)', () => {
      const vm = createVM({ tags: ['production', 'web'] });
      const stack = parseFilterStack('tags:staging,development');
      const result = evaluateFilterStack(vm, stack);
      expect(result).toBe(false);
    });
  });

  describe('raw text conditions', () => {
    it('matches raw text in name', () => {
      const vm = createVM({ name: 'my-production-vm' });
      const stack = parseFilterStack('production');
      const result = evaluateFilterStack(vm, stack);
      expect(result).toBe(true);
    });

    it('matches raw text in status', () => {
      const vm = createVM({ status: 'running' });
      const stack = parseFilterStack('running');
      const result = evaluateFilterStack(vm, stack);
      expect(result).toBe(true);
    });

    it('matches raw text in tags', () => {
      const vm = createVM({ tags: ['production', 'web'] });
      const stack = parseFilterStack('production');
      const result = evaluateFilterStack(vm, stack);
      expect(result).toBe(true);
    });
  });

  describe('logical operators', () => {
    it('evaluates AND operator', () => {
      const vm = createVM({ cpu: 0.8, name: 'prod-vm' });
      const stack = parseFilterStack('cpu>50 AND name:prod');
      const result = evaluateFilterStack(vm, stack);
      expect(result).toBe(true);
    });

    it('evaluates AND with one false condition', () => {
      const vm = createVM({ cpu: 0.3, name: 'prod-vm' });
      const stack = parseFilterStack('cpu>50 AND name:prod');
      const result = evaluateFilterStack(vm, stack);
      expect(result).toBe(false);
    });

    it('evaluates OR operator', () => {
      const vm = createVM({ cpu: 0.3, name: 'prod-vm' });
      const stack = parseFilterStack('cpu>50 OR name:prod');
      const result = evaluateFilterStack(vm, stack);
      expect(result).toBe(true);
    });

    it('evaluates OR with both false', () => {
      const vm = createVM({ cpu: 0.3, name: 'dev-vm' });
      const stack = parseFilterStack('cpu>50 OR name:prod');
      const result = evaluateFilterStack(vm, stack);
      expect(result).toBe(false);
    });
  });

  describe('splitSearchExclusions', () => {
    it('splits -terms out of the positive needle', () => {
      expect(splitSearchExclusions('nginx -watchtower -Certbot')).toEqual({
        needle: 'nginx',
        excludes: ['watchtower', 'certbot'],
      });
    });

    it('keeps multi-word positive searches as one substring needle', () => {
      expect(splitSearchExclusions('  Web  Server ')).toEqual({
        needle: 'web server',
        excludes: [],
      });
    });

    it('supports exclusion-only searches', () => {
      expect(splitSearchExclusions('-backup')).toEqual({ needle: '', excludes: ['backup'] });
    });

    it('does not treat interior hyphens or a lone dash as exclusions', () => {
      expect(splitSearchExclusions('my-app -')).toEqual({
        needle: 'my-app -',
        excludes: [],
      });
    });

    it('returns empty state for blank input', () => {
      expect(splitSearchExclusions('   ')).toEqual({ needle: '', excludes: [] });
    });
  });

  describe('matchesSearchTermSplit', () => {
    it('hides haystacks containing any excluded term', () => {
      const split = splitSearchExclusions('-watchtower');
      expect(matchesSearchTermSplit('watchtower latest', split)).toBe(false);
      expect(matchesSearchTermSplit('nginx stable', split)).toBe(true);
    });

    it('requires the positive needle when present', () => {
      const split = splitSearchExclusions('nginx -prod');
      expect(matchesSearchTermSplit('nginx staging', split)).toBe(true);
      expect(matchesSearchTermSplit('nginx prod-eu', split)).toBe(false);
      expect(matchesSearchTermSplit('redis staging', split)).toBe(false);
    });

    it('matches everything when the split is empty', () => {
      const split = splitSearchExclusions('');
      expect(matchesSearchTermSplit('anything', split)).toBe(true);
    });

    it('treats comma-separated committed object terms as inclusive alternatives', () => {
      const split = splitSearchExclusions('pve1, docker-a');

      expect(split.alternatives).toEqual(['pve1', 'docker-a']);
      expect(matchesSearchTermSplit('node pve1 running', split)).toBe(true);
      expect(matchesSearchTermSplit('host docker-a online', split)).toBe(true);
      expect(matchesSearchTermSplit('host truenas-a online', split)).toBe(false);
    });
  });
});

describe('disk filter freshness and unknown values', () => {
  const guest = (overrides: Partial<WorkloadGuest> = {}): WorkloadGuest => ({
    id: 'fixture-vm',
    vmid: 101,
    name: 'retained-vm',
    node: 'pve1',
    instance: 'fixture',
    type: 'qemu',
    workloadType: 'vm',
    status: 'running',
    cpu: 0,
    cpus: 1,
    memory: { usage: 0, total: 100, used: 0, free: 100 },
    disk: { usage: 95, total: 100, used: 95, free: 5 },
    networkIn: 0,
    networkOut: 0,
    diskRead: 0,
    diskWrite: 0,
    uptime: 1,
    template: false,
    lastBackup: 0,
    tags: [],
    lock: '',
    lastSeen: '2026-10-09T11:33:33Z',
    ...overrides,
  });
  const matches = (vm: WorkloadGuest, query: string) =>
    evaluateFilterStack(vm, parseFilterStack(query));

  it.each(['>0', '>=0', '<100', '<=100', '=0', '==0'])(
    'does not match disk%s when the reading is absent, invalid or not current',
    (comparison) => {
      const unknown = [
        guest({ disk: undefined as unknown as WorkloadGuest['disk'] }),
        guest({ disk: { total: 0, used: 0, free: 0 } as WorkloadGuest['disk'] }),
        guest({ disk: { usage: -1, total: 100, used: 95, free: 5 } }),
        guest({ disk: { usage: NaN, total: 100, used: 95, free: 5 } }),
        guest({ disk: { usage: Infinity, total: 100, used: 95, free: 5 } }),
        guest({ diskStatusReason: 'prev-vm-locked' }),
        guest({ diskStatusReason: 'permission-denied' }),
        guest({
          telemetryAvailability: {
            cpu: true,
            memory: true,
            disk: false,
            networkIO: true,
            diskIO: true,
            uptime: true,
          },
        }),
      ];
      for (const vm of unknown) expect(matches(vm, `disk${comparison}`)).toBe(false);
    },
  );

  it('preserves valid reported zero and numeric disk comparisons', () => {
    expect(matches(guest({ disk: { usage: 0, total: 100, used: 0, free: 100 } }), 'disk=0')).toBe(
      true,
    );
    expect(matches(guest(), 'disk>90')).toBe(true);
    expect(matches(guest(), 'disk<90')).toBe(false);
    expect(matches(guest(), 'disk>=95 AND name:retained')).toBe(true);
  });

  it('keeps OR text matches and other metrics independent of unavailable disk readings', () => {
    const retained = guest({ diskStatusReason: 'prev-vm-locked' });
    expect(matches(retained, 'disk>90 OR name:retained')).toBe(true);
    expect(matches(retained, 'disk>90 AND name:retained')).toBe(false);
    expect(matches(retained, 'cpu=0')).toBe(true);
    expect(matches(retained, 'name:retained')).toBe(true);
  });
});

describe('memory filters use current percentages, not retained capacity or missing zero', () => {
  const guest = (memory: WorkloadGuest['memory']): WorkloadGuest =>
    ({
      id: 'fixture-memory',
      name: 'retained-memory',
      vmid: 101,
      node: 'pve1',
      instance: 'fixture',
      type: 'qemu',
      memory,
    }) as WorkloadGuest;
  const current = (usage: number): WorkloadGuest['memory'] => ({
    usage,
    total: 100,
    used: usage,
    free: 100 - usage,
    observation: { state: 'current', source: 'agent', observedAt: '2026-10-08T00:00:00Z' },
  });
  const matches = (row: WorkloadGuest, query: string) =>
    evaluateFilterStack(row, parseFilterStack(query));

  it.each(['>0', '>=0', '<100', '<=100', '=0', '==0'])(
    'does not match memory%s for non-current or missing readings',
    (comparison) => {
      const rows = [
        guest(undefined as unknown as WorkloadGuest['memory']),
        guest({ ...current(0), usageUnavailable: true }),
        guest({ ...current(95), observation: undefined }),
        guest({
          ...current(95),
          observation: { state: 'last-known', source: 'agent', observedAt: '2026-10-08T00:00:00Z' },
        }),
        guest({ ...current(0), observation: { state: 'unavailable', source: 'agent' } }),
        guest({
          ...current(95),
          observation: { state: 'current', source: 'agent', observedAt: 'invalid' },
        }),
        guest({
          ...current(95),
          observation: { state: 'current', source: 'agent', observedAt: '2099-01-01T00:00:00Z' },
        }),
        ...[-1, NaN, Infinity, 101].map((usage) => guest(current(usage))),
      ];
      const telemetryMissing = guest(current(0));
      telemetryMissing.telemetryAvailability = {
        cpu: true,
        memory: false,
        disk: true,
        networkIO: true,
        diskIO: true,
        uptime: true,
      };
      rows.push(telemetryMissing);
      for (const row of rows) expect(matches(row, `memory${comparison}`)).toBe(false);
    },
  );

  it('preserves valid zero and all percentage operators for a current reading', () => {
    expect(matches(guest(current(0)), 'memory=0')).toBe(true);
    const row = guest(current(90));
    for (const query of [
      'memory>85',
      'memory>=90',
      'memory<95',
      'memory<=90',
      'memory=90',
      'memory==90',
    ]) {
      expect(matches(row, query)).toBe(true);
    }
    expect(matches(row, 'memory<90')).toBe(false);
    expect(matches(row, 'memory>90')).toBe(false);
  });

  it('keeps text access and unrelated platform readings without inventing provenance', () => {
    const row = guest({ ...current(95), observation: { state: 'last-known', source: 'agent' } });
    expect(matches(row, 'memory>85 OR name:retained')).toBe(true);
    expect(matches(row, 'memory>85 AND name:retained')).toBe(false);
    const vmware = {
      ...guest({ ...current(90), observation: undefined }),
      platformScopes: ['vmware-vsphere'],
    };
    expect(matches(vmware, 'memory>85')).toBe(true);
    const docker = { ...vmware, type: 'docker', vmid: 0, platformScopes: ['docker'] };
    expect(matches(docker, 'memory>85')).toBe(true);
  });
});