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.
Go aialertsdashboarddockerdocker-monitoringgohomelabinfrastructure-monitoringkubernetesmonitoringmspproxmoxproxmox-backup-serverproxmox-mail-gatewayproxmox-veself-hostedtruenastypescriptvspherewebhooks
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);
});
});