DiAL/tests/server/checker/runner/mem/calculate.test.ts

import type { Systeminformation } from "systeminformation";

import { describe, expect, test } from "bun:test";

import { calculateMemStats } from "../../../../../src/server/checker/runner/mem/calculate";

function makeMemData(overrides: Partial<Systeminformation.MemData> = {}): Systeminformation.MemData {
  return {
    active: 4294967296,
    available: 8589934592,
    buffcache: 1073741824,
    buffers: 536870912,
    cached: 536870912,
    dirty: null,
    free: 4294967296,
    reclaimable: 0,
    slab: 0,
    swapfree: 0,
    swaptotal: 0,
    swapused: 0,
    total: 17179869184,
    used: 8589934592,
    writeback: null,
    ...overrides,
  };
}

describe("calculateMemStats", () => {
  test("usagePercent = activeBytes / totalBytes * 100", () => {
    const stats = calculateMemStats(makeMemData({ active: 4294967296, total: 8589934592 }));
    expect(stats.usagePercent).toBe(50);
  });

  test("usedPercent = usedBytes / totalBytes * 100", () => {
    const stats = calculateMemStats(makeMemData({ total: 8589934592, used: 6442450944 }));
    expect(stats.usedPercent).toBe(75);
  });

  test("freePercent = freeBytes / totalBytes * 100", () => {
    const stats = calculateMemStats(makeMemData({ free: 2147483648, total: 8589934592 }));
    expect(stats.freePercent).toBe(25);
  });

  test("activePercent = activeBytes / totalBytes * 100", () => {
    const stats = calculateMemStats(makeMemData({ active: 3221225472, total: 8589934592 }));
    expect(stats.activePercent).toBe(37.5);
  });

  test("availablePercent = availableBytes / totalBytes * 100", () => {
    const stats = calculateMemStats(makeMemData({ available: 6442450944, total: 8589934592 }));
    expect(stats.availablePercent).toBe(75);
  });

  test("保留 1 位小数", () => {
    const stats = calculateMemStats(makeMemData({ active: 3000000000, total: 8000000000 }));
    expect(stats.usagePercent).toBe(37.5);
  });

  test("round1 处理需要四舍五入的情况", () => {
    const stats = calculateMemStats(makeMemData({ active: 3333333333, total: 10000000000 }));
    expect(stats.usagePercent).toBe(33.3);
  });

  test("total 为 0 时百分比为 0", () => {
    const stats = calculateMemStats(makeMemData({ active: 0, available: 0, free: 0, total: 0, used: 0 }));
    expect(stats.usagePercent).toBe(0);
    expect(stats.usedPercent).toBe(0);
    expect(stats.freePercent).toBe(0);
  });

  test("buffcacheBytes 为 null 映射", () => {
    const stats = calculateMemStats(makeMemData({ buffcache: 0 }));
    expect(stats.buffcacheBytes).toBe(0);
  });

  test("buffcacheBytes 为正数时保留", () => {
    const stats = calculateMemStats(makeMemData({ buffcache: 1073741824 }));
    expect(stats.buffcacheBytes).toBe(1073741824);
  });

  test("所有字节字段正确映射", () => {
    const data = makeMemData({
      active: 1000,
      available: 2000,
      free: 3000,
      total: 4000,
      used: 3500,
    });
    const stats = calculateMemStats(data);
    expect(stats.activeBytes).toBe(1000);
    expect(stats.availableBytes).toBe(2000);
    expect(stats.freeBytes).toBe(3000);
    expect(stats.totalBytes).toBe(4000);
    expect(stats.usedBytes).toBe(3500);
  });
});

describe("calculateMemStats swap", () => {
  test("swap 不可用：swaptotal=0 时 swapUsagePercent=null", () => {
    const stats = calculateMemStats(makeMemData({ swapfree: 0, swaptotal: 0, swapused: 0 }));
    expect(stats.swapUsagePercent).toBe(null);
    expect(stats.swapTotalBytes).toBe(0);
    expect(stats.swapUsedBytes).toBe(0);
    expect(stats.swapFreeBytes).toBe(0);
  });

  test("swap 总量为 0，swapUsagePercent 为 null（不是 0）", () => {
    const stats = calculateMemStats(makeMemData({ swaptotal: 0 }));
    expect(stats.swapUsagePercent).toBe(null);
  });

  test("swap 已使用", () => {
    const stats = calculateMemStats(makeMemData({ swapfree: 1073741824, swaptotal: 4294967296, swapused: 3221225472 }));
    expect(stats.swapUsagePercent).toBe(75);
    expect(stats.swapTotalBytes).toBe(4294967296);
    expect(stats.swapUsedBytes).toBe(3221225472);
    expect(stats.swapFreeBytes).toBe(1073741824);
  });

  test("swap 未使用：swapUsagePercent=0（不是 null）", () => {
    const stats = calculateMemStats(makeMemData({ swapfree: 4294967296, swaptotal: 4294967296, swapused: 0 }));
    expect(stats.swapUsagePercent).toBe(0);
    expect(stats.swapUsedBytes).toBe(0);
    expect(stats.swapFreeBytes).toBe(4294967296);
  });

  test("swap 部分使用保留 1 位小数", () => {
    const stats = calculateMemStats(
      makeMemData({ swapfree: 3000000000, swaptotal: 10000000000, swapused: 7000000000 }),
    );
    expect(stats.swapUsagePercent).toBe(70);
  });

  test("swap 合法 0 不被转换为 null", () => {
    const stats = calculateMemStats(makeMemData({ swapfree: 4294967296, swaptotal: 4294967296, swapused: 0 }));
    expect(stats.swapUsedBytes).toBe(0);
    expect(stats.swapUsagePercent).toBe(0);
  });
});