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.1 KB
Raw Blame
import { describe, expect, it } from 'vitest';
import {
  buildKubernetesWorkloadMetadataId,
  buildProxmoxGuestNativeId,
  canonicalizeWorkloadFilterType,
  getWorkloadCPUFraction,
  getWorkloadCPUPercent,
  normalizeWorkloadViewModeParam,
  resolveWorkloadType,
  resolveWorkloadTypeFromString,
  getWorkloadMetricsKind,
  getCanonicalWorkloadId,
  getWorkloadMetadataIdForResource,
  getWorkloadMetadataId,
  getWorkloadMetadataIdCandidates,
  isDockerManagedAppContainer,
  getWebInterfaceTargetLabelForWorkload,
} from '@/utils/workloads';
import type { WorkloadGuest } from '@/types/workloads';

describe('workload CPU normalization', () => {
  it('round-trips canonical percent without applying allocated core count', () => {
    const canonicalPercent = 0.58;
    const ratio = getWorkloadCPUFraction(canonicalPercent);

    expect(ratio).toBe(0.0058);
    expect(getWorkloadCPUPercent(ratio)).toBeCloseTo(canonicalPercent);
  });

  it('keeps ratios above one as percentages above 100 instead of reinterpreting units', () => {
    expect(getWorkloadCPUPercent(2)).toBe(200);
  });

  it('rejects non-finite values and clamps negative observations to zero', () => {
    expect(getWorkloadCPUPercent(Number.NaN)).toBeUndefined();
    expect(getWorkloadCPUFraction(Number.POSITIVE_INFINITY)).toBe(0);
    expect(getWorkloadCPUPercent(-0.5)).toBe(0);
    expect(getWorkloadCPUFraction(-50)).toBe(0);
  });
});

describe('resolveWorkloadType', () => {
  it('returns workloadType when present', () => {
    const guest = { workloadType: 'vm' as const, type: 'system-container' };
    expect(resolveWorkloadType(guest)).toBe('vm');
  });

  it('returns vm for VM type (case insensitive)', () => {
    const guest = { type: 'VM' };
    expect(resolveWorkloadType(guest)).toBe('vm');
  });

  it('returns system-container for oci-container type', () => {
    const guest = { type: 'oci-container' };
    expect(resolveWorkloadType(guest)).toBe('system-container');
  });

  it('returns app-container for docker type', () => {
    const guest = { type: 'docker' };
    expect(resolveWorkloadType(guest)).toBe('app-container');
  });

  it('does not map removed docker-container type alias', () => {
    const guest = { type: 'docker-container' };
    expect(resolveWorkloadType(guest)).toBe('system-container');
  });

  it('does not map removed docker_container type alias', () => {
    const guest = { type: 'docker_container' };
    expect(resolveWorkloadType(guest)).toBe('system-container');
  });

  it('returns pod for k8s type', () => {
    const guest = { type: 'k8s' };
    expect(resolveWorkloadType(guest)).toBe('pod');
  });

  it('returns pod for pod type', () => {
    const guest = { type: 'pod' };
    expect(resolveWorkloadType(guest)).toBe('pod');
  });

  it('returns pod for kubernetes type', () => {
    const guest = { type: 'kubernetes' };
    expect(resolveWorkloadType(guest)).toBe('pod');
  });

  it('defaults to system-container for unknown type', () => {
    const guest = { type: 'unknown' };
    expect(resolveWorkloadType(guest)).toBe('system-container');
  });

  it('defaults to system-container for empty type', () => {
    const guest = { type: '' };
    expect(resolveWorkloadType(guest)).toBe('system-container');
  });

  it('defaults to system-container for undefined type', () => {
    const guest = { type: undefined } as unknown as WorkloadGuest;
    expect(resolveWorkloadType(guest)).toBe('system-container');
  });
});

describe('resolveWorkloadTypeFromString', () => {
  it('returns vm for canonical vm type', () => {
    expect(resolveWorkloadTypeFromString('vm')).toBe('vm');
  });

  it('returns system-container for canonical system-container type', () => {
    expect(resolveWorkloadTypeFromString('system-container')).toBe('system-container');
  });

  it('returns system-container for canonical oci-container type', () => {
    expect(resolveWorkloadTypeFromString('oci-container')).toBe('system-container');
  });

  it('normalizes qemu to vm', () => {
    expect(resolveWorkloadTypeFromString('qemu')).toBe('vm');
  });

  it('normalizes lxc to system-container', () => {
    expect(resolveWorkloadTypeFromString('lxc')).toBe('system-container');
  });

  it('does not normalize removed container alias', () => {
    expect(resolveWorkloadTypeFromString('container')).toBeNull();
  });

  it('does not normalize removed docker-container alias', () => {
    expect(resolveWorkloadTypeFromString('docker-container')).toBeNull();
  });

  it('does not normalize removed docker_container alias', () => {
    expect(resolveWorkloadTypeFromString('docker_container')).toBeNull();
  });
});

describe('canonicalizeWorkloadFilterType', () => {
  it('canonicalizes supported workload filter aliases to v6 keys', () => {
    expect(canonicalizeWorkloadFilterType('docker')).toBe('app-container');
    expect(canonicalizeWorkloadFilterType('k8s')).toBe('pod');
    expect(canonicalizeWorkloadFilterType('host')).toBe('agent');
  });

  it('preserves unknown and removed aliases instead of inventing compatibility', () => {
    expect(canonicalizeWorkloadFilterType('docker-container')).toBe('docker-container');
    expect(canonicalizeWorkloadFilterType('custom-type')).toBe('custom-type');
    expect(canonicalizeWorkloadFilterType('')).toBe('');
  });
});

describe('getWorkloadMetricsKind', () => {
  it('returns vm for vm workload', () => {
    const guest = { workloadType: 'vm' as const, type: 'vm' };
    expect(getWorkloadMetricsKind(guest)).toBe('vm');
  });

  it('returns container for system-container workload', () => {
    const guest = { workloadType: 'system-container' as const, type: 'system-container' };
    expect(getWorkloadMetricsKind(guest)).toBe('container');
  });

  it('returns dockerContainer for app-container workload', () => {
    const guest = { workloadType: 'app-container' as const, type: 'docker' };
    expect(getWorkloadMetricsKind(guest)).toBe('dockerContainer');
  });

  it('returns k8s for pod workload', () => {
    const guest = { workloadType: 'pod' as const, type: 'k8s-pod' };
    expect(getWorkloadMetricsKind(guest)).toBe('k8s');
  });

  it('defaults to container for unknown workload type', () => {
    const guest = { workloadType: 'unknown' as unknown as 'vm', type: 'unknown' };
    expect(getWorkloadMetricsKind(guest)).toBe('container');
  });
});

describe('getCanonicalWorkloadId', () => {
  it('preserves the supplied VM identity when provider coordinates exist', () => {
    const guest = { id: 'orig', type: 'vm', instance: 'homelab', node: 'node1', vmid: 100 };
    expect(getCanonicalWorkloadId(guest)).toBe('orig');
  });

  it('preserves the supplied container identity when provider coordinates exist', () => {
    const guest = {
      id: 'orig',
      type: 'system-container',
      instance: 'homelab',
      node: 'node2',
      vmid: 200,
    };
    expect(getCanonicalWorkloadId(guest)).toBe('orig');
  });

  it('returns id for app-container workloads (no instance/node/vmid)', () => {
    const guest = {
      id: 'app-container:docker-main:container-123',
      type: 'docker',
      workloadType: 'app-container' as const,
      instance: '',
      node: '',
      vmid: 0,
    };
    expect(getCanonicalWorkloadId(guest)).toBe('app-container:docker-main:container-123');
  });

  it('returns id for pod workloads (no instance/node/vmid)', () => {
    const guest = {
      id: 'pod-456',
      type: 'pod',
      workloadType: 'pod' as const,
      instance: '',
      node: '',
      vmid: 0,
    };
    expect(getCanonicalWorkloadId(guest)).toBe('pod-456');
  });

  it('returns id when vmid is 0', () => {
    const guest = { id: 'test', type: 'vm', instance: 'homelab', node: 'node1', vmid: 0 };
    expect(getCanonicalWorkloadId(guest)).toBe('test');
  });

  it('returns id when instance is missing', () => {
    const guest = { id: 'test', type: 'vm', instance: '', node: 'node1', vmid: 100 };
    expect(getCanonicalWorkloadId(guest)).toBe('test');
  });

  it('returns id when node is missing', () => {
    const guest = { id: 'test', type: 'vm', instance: 'homelab', node: '', vmid: 100 };
    expect(getCanonicalWorkloadId(guest)).toBe('test');
  });
});

describe('buildProxmoxGuestNativeId', () => {
  it('builds legacy metadata keys from instance, node, and vmid', () => {
    expect(
      buildProxmoxGuestNativeId({
        instance: 'Core Fabric',
        node: 'pve2',
        vmid: 112,
      }),
    ).toBe('Core Fabric:pve2:112');
  });

  it('returns null when any provider coordinate is missing', () => {
    expect(buildProxmoxGuestNativeId({ instance: 'Core Fabric', node: '', vmid: 112 })).toBeNull();
    expect(buildProxmoxGuestNativeId({ instance: '', node: 'pve2', vmid: 112 })).toBeNull();
    expect(
      buildProxmoxGuestNativeId({ instance: 'Core Fabric', node: 'pve2', vmid: 0 }),
    ).toBeNull();
  });
});

describe('getWorkloadMetadataId', () => {
  it('uses a stable host-and-name key for Docker-managed app-container URLs', () => {
    const guest = {
      id: 'app-container:docker-main:container-123',
      name: '/grafana',
      type: 'docker',
      workloadType: 'app-container' as const,
      dockerHostId: 'docker-main',
      instance: '',
      node: '',
      vmid: 0,
    };

    expect(getWorkloadMetadataId(guest)).toBe('app-container:docker-main:name:grafana');
    expect(getWorkloadMetadataIdCandidates(guest)).toEqual([
      'app-container:docker-main:name:grafana',
      'app-container:docker-main:container-123',
    ]);
  });

  it('falls back to the canonical workload id when a Docker host id is unavailable', () => {
    const guest = {
      id: 'app-container:truenas-main:nextcloud',
      name: 'nextcloud',
      type: 'app-container',
      workloadType: 'app-container' as const,
      platformType: 'truenas',
      instance: '',
      node: '',
      vmid: 0,
    };

    expect(getWorkloadMetadataId(guest)).toBe('app-container:truenas-main:nextcloud');
    expect(getWorkloadMetadataIdCandidates(guest)).toEqual([
      'app-container:truenas-main:nextcloud',
    ]);
  });

  it('uses cluster, kind, namespace, and name for Kubernetes pod URL identity', () => {
    const oldPod = {
      id: 'k8s:cluster-a:pod:pod-uid-old',
      name: 'checkout',
      type: 'pod',
      workloadType: 'pod' as const,
      kubernetesClusterId: 'cluster-a',
      namespace: 'payments',
      instance: '',
      node: '',
      vmid: 0,
    };
    const recreatedPod = {
      ...oldPod,
      id: 'k8s:cluster-a:pod:pod-uid-new',
    };

    expect(buildKubernetesWorkloadMetadataId(oldPod)).toBe(
      'k8s-workload:cluster-a:pod:payments:checkout',
    );
    expect(getWorkloadMetadataIdCandidates(oldPod)).toEqual([
      'k8s-workload:cluster-a:pod:payments:checkout',
      'k8s:cluster-a:pod:pod-uid-old',
    ]);
    expect(getWorkloadMetadataId(recreatedPod)).toBe(
      'k8s-workload:cluster-a:pod:payments:checkout',
    );
  });

  it('does not build a Kubernetes URL identity without every isolation scope', () => {
    expect(
      buildKubernetesWorkloadMetadataId({
        kubernetesClusterId: '',
        namespace: 'payments',
        name: 'checkout',
      }),
    ).toBeNull();
    expect(
      buildKubernetesWorkloadMetadataId({
        kubernetesClusterId: 'cluster-a',
        namespace: '',
        name: 'checkout',
      }),
    ).toBeNull();
    expect(
      buildKubernetesWorkloadMetadataId({
        kubernetesClusterId: 'cluster-a',
        namespace: 'payments',
        name: '',
      }),
    ).toBeNull();
  });
});

describe('getWorkloadMetadataIdForResource', () => {
  it('uses proxmox guest identity for vm and system-container resources', () => {
    expect(
      getWorkloadMetadataIdForResource({
        id: 'system-container-45cf61f16a6e2c16',
        type: 'system-container',
        clusterId: 'Core Fabric',
        proxmox: {
          node: 'pve2',
          vmid: 112,
        },
      } as any),
    ).toBe('Core Fabric:pve2:112');
  });

  it('falls back to the resource id when provider metadata coordinates are incomplete', () => {
    expect(
      getWorkloadMetadataIdForResource({
        id: 'vm-123',
        type: 'vm',
        clusterId: '',
        proxmox: {
          node: 'pve1',
          vmid: 0,
        },
      } as any),
    ).toBe('vm-123');
  });
});

describe('isDockerManagedAppContainer', () => {
  it('returns true for docker-platform app containers', () => {
    expect(
      isDockerManagedAppContainer({
        workloadType: 'app-container',
        type: 'app-container',
        platformType: 'docker',
        containerRuntime: 'docker',
      }),
    ).toBe(true);
  });

  it('returns false for TrueNAS app containers even when runtime metadata is docker', () => {
    expect(
      isDockerManagedAppContainer({
        workloadType: 'app-container',
        type: 'app-container',
        platformType: 'truenas',
        containerRuntime: 'docker',
      }),
    ).toBe(false);
  });
});

describe('getWebInterfaceTargetLabelForWorkload', () => {
  it('labels app-container workloads as container', () => {
    const guest = { workloadType: 'app-container' as const, type: 'docker' };
    expect(getWebInterfaceTargetLabelForWorkload(guest)).toBe('container');
  });

  it('labels pod workloads as workload', () => {
    const guest = { workloadType: 'pod' as const, type: 'pod' };
    expect(getWebInterfaceTargetLabelForWorkload(guest)).toBe('workload');
  });

  it('labels vm workloads as workload', () => {
    const guest = { workloadType: 'vm' as const, type: 'qemu' };
    expect(getWebInterfaceTargetLabelForWorkload(guest)).toBe('workload');
  });
});

describe('normalizeWorkloadViewModeParam', () => {
  it('normalizes supported dashboard view mode aliases', () => {
    expect(normalizeWorkloadViewModeParam('all')).toBe('all');
    expect(normalizeWorkloadViewModeParam('VM')).toBe('vm');
    expect(normalizeWorkloadViewModeParam('container')).toBe('container');
    expect(normalizeWorkloadViewModeParam('system-container')).toBe('system-container');
    expect(normalizeWorkloadViewModeParam('docker')).toBe('app-container');
    expect(normalizeWorkloadViewModeParam('app-container')).toBe('app-container');
    expect(normalizeWorkloadViewModeParam('k8s')).toBe('pod');
    expect(normalizeWorkloadViewModeParam('Kubernetes')).toBe('pod');
    expect(normalizeWorkloadViewModeParam('pod')).toBe('pod');
  });

  it('rejects unsupported dashboard view mode aliases', () => {
    expect(normalizeWorkloadViewModeParam('host')).toBeNull();
    expect(normalizeWorkloadViewModeParam('')).toBeNull();
  });
});

describe('canonical workload identity across placement changes', () => {
  it.each(['vm', 'system-container'] as const)(
    'keeps the %s resource identity across node migration',
    (workloadType) => {
      const guest = {
        id: 'legacy-row-key',
        canonicalResourceId: 'stable-resource',
        workloadType,
        type: workloadType,
        instance: 'cluster-a',
        node: 'node-1',
        vmid: 101,
      };
      expect(getCanonicalWorkloadId(guest)).toBe('stable-resource');
      expect(getCanonicalWorkloadId({ ...guest, node: 'node-2' })).toBe('stable-resource');
      expect(getCanonicalWorkloadId({ ...guest, canonicalResourceId: 'independent-clone' })).toBe(
        'independent-clone',
      );
    },
  );

  it('uses the supplied resource ID rather than deriving an identity from provider coordinates', () => {
    const guest = {
      id: 'stable-resource',
      type: 'vm',
      instance: 'cluster-a',
      node: 'node-1',
      vmid: 101,
    };
    expect(getCanonicalWorkloadId(guest)).toBe('stable-resource');
  });
});

describe('Proxmox metadata compatibility boundary', () => {
  it('retains provider metadata keys while the row uses stable resource identity', () => {
    const guest = {
      id: 'stable-resource',
      canonicalResourceId: 'stable-resource',
      name: 'guest-101',
      type: 'vm',
      instance: 'cluster-a',
      node: 'node-1',
      vmid: 101,
    };
    expect(getWorkloadMetadataId(guest)).toBe('cluster-a:node-1:101');
    expect(getWorkloadMetadataIdCandidates(guest)).toEqual([
      'cluster-a:node-1:101',
      'stable-resource',
    ]);
    expect(getWorkloadMetadataId({ ...guest, node: 'node-2' })).toBe('cluster-a:node-2:101');
    expect(getCanonicalWorkloadId({ ...guest, node: 'node-2' })).toBe('stable-resource');
  });
});