Skip to content

Lightweight server monitoring with historical data, docker stats, and alerts.

36.9 KB
Raw Blame
//go:build testing

package agent

import (
	"math"
	"os"
	"path/filepath"
	"runtime"
	"testing"
	"time"

	"github.com/henrygd/beszel/internal/entities/system"
	"github.com/shirou/gopsutil/v4/disk"
	"github.com/stretchr/testify/assert"
	"github.com/stretchr/testify/require"
)

func TestParseFilesystemEntry(t *testing.T) {
	tests := []struct {
		name         string
		input        string
		expectedFs   string
		expectedName string
	}{
		{
			name:         "simple device name",
			input:        "sda1",
			expectedFs:   "sda1",
			expectedName: "",
		},
		{
			name:         "device with custom name",
			input:        "sda1__my-storage",
			expectedFs:   "sda1",
			expectedName: "my-storage",
		},
		{
			name:         "full device path with custom name",
			input:        "/dev/sdb1__backup-drive",
			expectedFs:   "/dev/sdb1",
			expectedName: "backup-drive",
		},
		{
			name:         "NVMe device with custom name",
			input:        "nvme0n1p2__fast-ssd",
			expectedFs:   "nvme0n1p2",
			expectedName: "fast-ssd",
		},
		{
			name:         "whitespace trimmed",
			input:        "  sda2__trimmed-name  ",
			expectedFs:   "sda2",
			expectedName: "trimmed-name",
		},
		{
			name:         "empty custom name",
			input:        "sda3__",
			expectedFs:   "sda3",
			expectedName: "",
		},
		{
			name:         "empty device name",
			input:        "__just-custom",
			expectedFs:   "",
			expectedName: "just-custom",
		},
		{
			name:         "multiple underscores in custom name",
			input:        "sda1__my_custom_drive",
			expectedFs:   "sda1",
			expectedName: "my_custom_drive",
		},
		{
			name:         "custom name with spaces",
			input:        "sda1__My Storage Drive",
			expectedFs:   "sda1",
			expectedName: "My Storage Drive",
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			fs, customName := parseFilesystemEntry(tt.input)

			assert.Equal(t, tt.expectedFs, fs)
			assert.Equal(t, tt.expectedName, customName)
		})
	}
}

func TestExtraFilesystemPartitionInfo(t *testing.T) {
	t.Run("uses partition device for label-only mountpoint", func(t *testing.T) {
		device, customName := extraFilesystemPartitionInfo(disk.PartitionStat{
			Device:     "/dev/sdc",
			Mountpoint: "/extra-filesystems/Share",
		})

		assert.Equal(t, "/dev/sdc", device)
		assert.Equal(t, "", customName)
	})

	t.Run("uses custom name from mountpoint suffix", func(t *testing.T) {
		device, customName := extraFilesystemPartitionInfo(disk.PartitionStat{
			Device:     "/dev/sdc",
			Mountpoint: "/extra-filesystems/sdc__Share",
		})

		assert.Equal(t, "/dev/sdc", device)
		assert.Equal(t, "Share", customName)
	})

	t.Run("falls back to folder device when partition device is unavailable", func(t *testing.T) {
		device, customName := extraFilesystemPartitionInfo(disk.PartitionStat{
			Mountpoint: "/extra-filesystems/sdc__Share",
		})

		assert.Equal(t, "sdc", device)
		assert.Equal(t, "Share", customName)
	})

	t.Run("supports custom name without folder device prefix", func(t *testing.T) {
		device, customName := extraFilesystemPartitionInfo(disk.PartitionStat{
			Device:     "/dev/sdc",
			Mountpoint: "/extra-filesystems/__Share",
		})

		assert.Equal(t, "/dev/sdc", device)
		assert.Equal(t, "Share", customName)
	})
}

func TestBuildFsStatRegistration(t *testing.T) {
	t.Run("uses basename for non-windows exact io match", func(t *testing.T) {
		key, stats, ok := registerFilesystemStats(
			map[string]*system.FsStats{},
			"/dev/sda1",
			"/mnt/data",
			false,
			"archive",
			fsRegistrationContext{
				isWindows: false,
				diskIoCounters: map[string]disk.IOCountersStat{
					"sda1": {Name: "sda1"},
				},
			},
		)

		assert.True(t, ok)
		assert.Equal(t, "sda1", key)
		assert.Equal(t, "/mnt/data", stats.Mountpoint)
		assert.Equal(t, "archive", stats.Name)
		assert.False(t, stats.Root)
	})

	t.Run("maps root partition to io device by prefix", func(t *testing.T) {
		key, stats, ok := registerFilesystemStats(
			map[string]*system.FsStats{},
			"/dev/ada0p2",
			"/",
			true,
			"",
			fsRegistrationContext{
				isWindows: false,
				diskIoCounters: map[string]disk.IOCountersStat{
					"ada0": {Name: "ada0", ReadBytes: 1000, WriteBytes: 1000},
				},
			},
		)

		assert.True(t, ok)
		assert.Equal(t, "ada0", key)
		assert.True(t, stats.Root)
		assert.Equal(t, "/", stats.Mountpoint)
	})

	t.Run("uses filesystem setting as root fallback", func(t *testing.T) {
		key, _, ok := registerFilesystemStats(
			map[string]*system.FsStats{},
			"overlay",
			"/",
			true,
			"",
			fsRegistrationContext{
				filesystem: "nvme0n1p2",
				isWindows:  false,
				diskIoCounters: map[string]disk.IOCountersStat{
					"nvme0n1": {Name: "nvme0n1", ReadBytes: 1000, WriteBytes: 1000},
				},
			},
		)

		assert.True(t, ok)
		assert.Equal(t, "nvme0n1", key)
	})

	t.Run("prefers parsed extra-filesystems device over mapper device", func(t *testing.T) {
		key, stats, ok := registerFilesystemStats(
			map[string]*system.FsStats{},
			"/dev/mapper/luks-2bcb02be-999d-4417-8d18-5c61e660fb6e",
			"/extra-filesystems/nvme0n1p2__Archive",
			false,
			"Archive",
			fsRegistrationContext{
				isWindows: false,
				diskIoCounters: map[string]disk.IOCountersStat{
					"dm-1":      {Name: "dm-1", Label: "luks-2bcb02be-999d-4417-8d18-5c61e660fb6e"},
					"nvme0n1p2": {Name: "nvme0n1p2"},
				},
			},
		)

		assert.True(t, ok)
		assert.Equal(t, "nvme0n1p2", key)
		assert.Equal(t, "Archive", stats.Name)
	})

	t.Run("falls back to mapper io device when folder device cannot be resolved", func(t *testing.T) {
		key, stats, ok := registerFilesystemStats(
			map[string]*system.FsStats{},
			"/dev/mapper/luks-2bcb02be-999d-4417-8d18-5c61e660fb6e",
			"/extra-filesystems/Archive",
			false,
			"Archive",
			fsRegistrationContext{
				isWindows: false,
				diskIoCounters: map[string]disk.IOCountersStat{
					"dm-1": {Name: "dm-1", Label: "luks-2bcb02be-999d-4417-8d18-5c61e660fb6e"},
				},
			},
		)

		assert.True(t, ok)
		assert.Equal(t, "dm-1", key)
		assert.Equal(t, "Archive", stats.Name)
	})

	t.Run("uses full device name on windows", func(t *testing.T) {
		key, _, ok := registerFilesystemStats(
			map[string]*system.FsStats{},
			`C:`,
			`C:\\`,
			false,
			"",
			fsRegistrationContext{
				isWindows: true,
				diskIoCounters: map[string]disk.IOCountersStat{
					`C:`: {Name: `C:`},
				},
			},
		)

		assert.True(t, ok)
		assert.Equal(t, `C:`, key)
	})

	t.Run("skips existing key", func(t *testing.T) {
		key, stats, ok := registerFilesystemStats(
			map[string]*system.FsStats{"sda1": {Mountpoint: "/existing"}},
			"/dev/sda1",
			"/mnt/data",
			false,
			"",
			fsRegistrationContext{
				isWindows: false,
				diskIoCounters: map[string]disk.IOCountersStat{
					"sda1": {Name: "sda1"},
				},
			},
		)

		assert.False(t, ok)
		assert.Empty(t, key)
		assert.Nil(t, stats)
	})

	t.Run("maps lvm symlinked device to io device through resolved name", func(t *testing.T) {
		setEvalSymlinks(t, func(path string) (string, error) {
			if path == "/dev/vg1/volume_1" {
				return "/dev/dm-1", nil
			}
			return path, nil
		})

		key, stats, ok := registerFilesystemStats(
			map[string]*system.FsStats{},
			"/dev/vg1/volume_1",
			"/volume1",
			false,
			"",
			fsRegistrationContext{
				isWindows: false,
				efPath:    "/extra-filesystems",
				diskIoCounters: map[string]disk.IOCountersStat{
					"dm-0": {Name: "dm-0", Label: "vg1-syno_vg_reserved_area"},
					"dm-1": {Name: "dm-1", Label: "vg1-volume_1"},
				},
			},
		)

		assert.True(t, ok)
		assert.Equal(t, "dm-1", key)
		assert.Equal(t, "/volume1", stats.Mountpoint)
	})

	t.Run("maps lvm device through resolved mapper label", func(t *testing.T) {
		setEvalSymlinks(t, func(path string) (string, error) {
			if path == "/dev/vg1/volume_1" {
				return "/dev/mapper/vg1-volume_1", nil
			}
			return path, nil
		})

		key, _, ok := registerFilesystemStats(
			map[string]*system.FsStats{},
			"/dev/vg1/volume_1",
			"/volume1",
			false,
			"",
			fsRegistrationContext{
				isWindows: false,
				efPath:    "/extra-filesystems",
				diskIoCounters: map[string]disk.IOCountersStat{
					"dm-1": {Name: "dm-1", Label: "vg1-volume_1"},
				},
			},
		)

		assert.True(t, ok)
		assert.Equal(t, "dm-1", key)
	})

	t.Run("maps lvm root device through resolved name", func(t *testing.T) {
		setEvalSymlinks(t, func(path string) (string, error) {
			if path == "/dev/vg1/volume_1" {
				return "/dev/dm-1", nil
			}
			return path, nil
		})

		key, stats, ok := registerFilesystemStats(
			map[string]*system.FsStats{},
			"/dev/vg1/volume_1",
			"/",
			true,
			"",
			fsRegistrationContext{
				isWindows: false,
				efPath:    "/extra-filesystems",
				diskIoCounters: map[string]disk.IOCountersStat{
					"dm-1": {Name: "dm-1", Label: "vg1-volume_1"},
				},
			},
		)

		assert.True(t, ok)
		assert.Equal(t, "dm-1", key)
		assert.True(t, stats.Root)
	})

	t.Run("resolved device wins over filesystem fallback", func(t *testing.T) {
		setEvalSymlinks(t, func(path string) (string, error) {
			if path == "/dev/vg1/volume_1" {
				return "/dev/dm-1", nil
			}
			return path, nil
		})

		key, _, ok := registerFilesystemStats(
			map[string]*system.FsStats{},
			"/dev/vg1/volume_1",
			"/",
			true,
			"",
			fsRegistrationContext{
				filesystem: "sda",
				isWindows:  false,
				efPath:     "/extra-filesystems",
				diskIoCounters: map[string]disk.IOCountersStat{
					"dm-1": {Name: "dm-1", Label: "vg1-volume_1"},
					"sda":  {Name: "sda"},
				},
			},
		)

		assert.True(t, ok)
		assert.Equal(t, "dm-1", key)
	})

	t.Run("keeps base name when symlink resolution fails", func(t *testing.T) {
		setEvalSymlinks(t, func(path string) (string, error) {
			return "", os.ErrNotExist
		})

		key, _, ok := registerFilesystemStats(
			map[string]*system.FsStats{},
			"/dev/vg1/volume_1",
			"/volume1",
			false,
			"",
			fsRegistrationContext{
				isWindows: false,
				efPath:    "/extra-filesystems",
				diskIoCounters: map[string]disk.IOCountersStat{
					"dm-1": {Name: "dm-1", Label: "vg1-volume_1"},
				},
			},
		)

		assert.True(t, ok)
		assert.Equal(t, "volume_1", key)
	})

	t.Run("does not resolve symlinks for relative device names", func(t *testing.T) {
		setEvalSymlinks(t, func(path string) (string, error) {
			return "/dev/sdb1", nil
		})

		key, _, ok := registerFilesystemStats(
			map[string]*system.FsStats{},
			"data",
			"/mnt/data",
			false,
			"",
			fsRegistrationContext{
				isWindows: false,
				efPath:    "/extra-filesystems",
				diskIoCounters: map[string]disk.IOCountersStat{
					"sdb1": {Name: "sdb1"},
				},
			},
		)

		assert.True(t, ok)
		assert.Equal(t, "data", key)
	})
}

// setEvalSymlinks swaps the device-symlink resolver for the duration of a test.
func setEvalSymlinks(t *testing.T, fn func(string) (string, error)) {
	t.Helper()
	old := evalSymlinks
	evalSymlinks = fn
	t.Cleanup(func() { evalSymlinks = old })
}

func TestAddConfiguredRootFs(t *testing.T) {
	t.Run("adds root from matching partition", func(t *testing.T) {
		agent := &Agent{fsStats: make(map[string]*system.FsStats)}
		discovery := diskDiscovery{
			agent:          agent,
			rootMountPoint: "/",
			partitions:     []disk.PartitionStat{{Device: "/dev/ada0p2", Mountpoint: "/"}},
			ctx: fsRegistrationContext{
				filesystem:     "/dev/ada0p2",
				filesystemName: "root disk",
				isWindows:      false,
				diskIoCounters: map[string]disk.IOCountersStat{
					"ada0": {Name: "ada0", ReadBytes: 1000, WriteBytes: 1000},
				},
			},
		}

		ok := discovery.addConfiguredRootFs()

		assert.True(t, ok)
		stats, exists := agent.fsStats["ada0"]
		assert.True(t, exists)
		assert.True(t, stats.Root)
		assert.Equal(t, "/", stats.Mountpoint)
		assert.Equal(t, "root disk", stats.Name)
	})

	t.Run("adds root from io device when partition is missing", func(t *testing.T) {
		agent := &Agent{fsStats: make(map[string]*system.FsStats)}
		discovery := diskDiscovery{
			agent:          agent,
			rootMountPoint: "/sysroot",
			ctx: fsRegistrationContext{
				filesystem:     "zroot",
				filesystemName: "root pool",
				isWindows:      false,
				diskIoCounters: map[string]disk.IOCountersStat{
					"nda0": {Name: "nda0", Label: "zroot", ReadBytes: 1000, WriteBytes: 1000},
				},
			},
		}

		ok := discovery.addConfiguredRootFs()

		assert.True(t, ok)
		stats, exists := agent.fsStats["nda0"]
		assert.True(t, exists)
		assert.True(t, stats.Root)
		assert.Equal(t, "/sysroot", stats.Mountpoint)
		assert.Equal(t, "root pool", stats.Name)
	})

	t.Run("returns false when filesystem cannot be resolved", func(t *testing.T) {
		agent := &Agent{fsStats: make(map[string]*system.FsStats)}
		discovery := diskDiscovery{
			agent:          agent,
			rootMountPoint: "/",
			ctx: fsRegistrationContext{
				filesystem:     "missing-disk",
				isWindows:      false,
				diskIoCounters: map[string]disk.IOCountersStat{},
			},
		}

		ok := discovery.addConfiguredRootFs()

		assert.False(t, ok)
		assert.Empty(t, agent.fsStats)
	})
}

func TestAddPartitionRootFs(t *testing.T) {
	t.Run("adds root from fallback partition candidate", func(t *testing.T) {
		agent := &Agent{fsStats: make(map[string]*system.FsStats)}
		discovery := diskDiscovery{
			agent: agent,
			ctx: fsRegistrationContext{
				isWindows: false,
				diskIoCounters: map[string]disk.IOCountersStat{
					"nvme0n1": {Name: "nvme0n1", ReadBytes: 1000, WriteBytes: 1000},
				},
			},
		}

		ok := discovery.addPartitionRootFs("/dev/nvme0n1p2", "/")

		assert.True(t, ok)
		stats, exists := agent.fsStats["nvme0n1"]
		assert.True(t, exists)
		assert.True(t, stats.Root)
		assert.Equal(t, "/", stats.Mountpoint)
	})

	t.Run("returns false when no io device matches", func(t *testing.T) {
		agent := &Agent{fsStats: make(map[string]*system.FsStats)}
		discovery := diskDiscovery{agent: agent, ctx: fsRegistrationContext{diskIoCounters: map[string]disk.IOCountersStat{}}}

		ok := discovery.addPartitionRootFs("/dev/mapper/root", "/")

		assert.False(t, ok)
		assert.Empty(t, agent.fsStats)
	})
}

func TestAddLastResortRootFs(t *testing.T) {
	t.Run("uses most active io device when available", func(t *testing.T) {
		agent := &Agent{fsStats: make(map[string]*system.FsStats)}
		discovery := diskDiscovery{agent: agent, rootMountPoint: "/", ctx: fsRegistrationContext{diskIoCounters: map[string]disk.IOCountersStat{
			"sda": {Name: "sda", ReadBytes: 5000, WriteBytes: 5000},
			"sdb": {Name: "sdb", ReadBytes: 1000, WriteBytes: 1000},
		}}}

		discovery.addLastResortRootFs()

		stats, exists := agent.fsStats["sda"]
		assert.True(t, exists)
		assert.True(t, stats.Root)
	})

	t.Run("falls back to root key when mountpoint basename collides", func(t *testing.T) {
		agent := &Agent{fsStats: map[string]*system.FsStats{
			"sysroot": {Mountpoint: "/extra-filesystems/sysroot"},
		}}
		discovery := diskDiscovery{agent: agent, rootMountPoint: "/sysroot", ctx: fsRegistrationContext{diskIoCounters: map[string]disk.IOCountersStat{}}}

		discovery.addLastResortRootFs()

		stats, exists := agent.fsStats["root"]
		assert.True(t, exists)
		assert.True(t, stats.Root)
		assert.Equal(t, "/sysroot", stats.Mountpoint)
	})
}

func TestAddConfiguredExtraFsEntry(t *testing.T) {
	t.Run("uses matching partition when present", func(t *testing.T) {
		agent := &Agent{fsStats: make(map[string]*system.FsStats)}
		discovery := diskDiscovery{
			agent:      agent,
			partitions: []disk.PartitionStat{{Device: "/dev/sdb1", Mountpoint: "/mnt/backup"}},
			usageFn: func(string) (*disk.UsageStat, error) {
				t.Fatal("usage fallback should not be called when partition matches")
				return nil, nil
			},
			ctx: fsRegistrationContext{
				isWindows: false,
				diskIoCounters: map[string]disk.IOCountersStat{
					"sdb1": {Name: "sdb1"},
				},
			},
		}

		discovery.addConfiguredExtraFsEntry("sdb1", "backup")

		stats, exists := agent.fsStats["sdb1"]
		assert.True(t, exists)
		assert.Equal(t, "/mnt/backup", stats.Mountpoint)
		assert.Equal(t, "backup", stats.Name)
	})

	t.Run("falls back to usage-validated path", func(t *testing.T) {
		agent := &Agent{fsStats: make(map[string]*system.FsStats)}
		discovery := diskDiscovery{
			agent: agent,
			usageFn: func(path string) (*disk.UsageStat, error) {
				assert.Equal(t, "/srv/archive", path)
				return &disk.UsageStat{}, nil
			},
			ctx: fsRegistrationContext{
				isWindows: false,
				diskIoCounters: map[string]disk.IOCountersStat{
					"archive": {Name: "archive"},
				},
			},
		}

		discovery.addConfiguredExtraFsEntry("/srv/archive", "archive")

		stats, exists := agent.fsStats["archive"]
		assert.True(t, exists)
		assert.Equal(t, "/srv/archive", stats.Mountpoint)
		assert.Equal(t, "archive", stats.Name)
	})

	t.Run("ignores invalid filesystem entry", func(t *testing.T) {
		agent := &Agent{fsStats: make(map[string]*system.FsStats)}
		discovery := diskDiscovery{
			agent: agent,
			usageFn: func(string) (*disk.UsageStat, error) {
				return nil, os.ErrNotExist
			},
		}

		discovery.addConfiguredExtraFsEntry("/missing/archive", "")

		assert.Empty(t, agent.fsStats)
	})
}

func TestAddConfiguredExtraFilesystems(t *testing.T) {
	t.Run("parses and registers multiple configured filesystems", func(t *testing.T) {
		agent := &Agent{fsStats: make(map[string]*system.FsStats)}
		discovery := diskDiscovery{
			agent:      agent,
			partitions: []disk.PartitionStat{{Device: "/dev/sda1", Mountpoint: "/mnt/fast"}},
			usageFn: func(path string) (*disk.UsageStat, error) {
				if path == "/srv/archive" {
					return &disk.UsageStat{}, nil
				}
				return nil, os.ErrNotExist
			},
			ctx: fsRegistrationContext{
				isWindows: false,
				diskIoCounters: map[string]disk.IOCountersStat{
					"sda1":    {Name: "sda1"},
					"archive": {Name: "archive"},
				},
			},
		}

		discovery.addConfiguredExtraFilesystems("sda1__fast,/srv/archive__cold")

		assert.Contains(t, agent.fsStats, "sda1")
		assert.Equal(t, "fast", agent.fsStats["sda1"].Name)
		assert.Contains(t, agent.fsStats, "archive")
		assert.Equal(t, "cold", agent.fsStats["archive"].Name)
	})
}

func TestAddExtraFilesystemFolders(t *testing.T) {
	t.Run("adds missing folders and skips existing mountpoints", func(t *testing.T) {
		agent := &Agent{fsStats: map[string]*system.FsStats{
			"existing": {Mountpoint: filepath.FromSlash("/extra-filesystems/existing")},
		}}
		discovery := diskDiscovery{
			agent: agent,
			ctx: fsRegistrationContext{
				isWindows: false,
				efPath:    filepath.FromSlash("/extra-filesystems"),
				diskIoCounters: map[string]disk.IOCountersStat{
					"newdisk": {Name: "newdisk"},
				},
			},
		}

		discovery.addExtraFilesystemFolders([]string{"existing", "newdisk__Archive"})

		require.Len(t, agent.fsStats, 2)
		stats, exists := agent.fsStats["newdisk"]
		require.True(t, exists)
		assert.Equal(t, filepath.FromSlash("/extra-filesystems/newdisk__Archive"), stats.Mountpoint)
		assert.Equal(t, "Archive", stats.Name)
	})
}

func TestAddPartitionExtraFs(t *testing.T) {
	makeDiscovery := func(agent *Agent) diskDiscovery {
		return diskDiscovery{
			agent: agent,
			ctx: fsRegistrationContext{
				isWindows: false,
				efPath:    filepath.FromSlash("/extra-filesystems"),
				diskIoCounters: map[string]disk.IOCountersStat{
					"nvme0n1p1": {Name: "nvme0n1p1"},
					"nvme1n1":   {Name: "nvme1n1"},
				},
			},
		}
	}

	t.Run("registers direct child of extra-filesystems", func(t *testing.T) {
		agent := &Agent{fsStats: make(map[string]*system.FsStats)}
		d := makeDiscovery(agent)

		d.addPartitionExtraFs(disk.PartitionStat{
			Device:     "/dev/nvme0n1p1",
			Mountpoint: filepath.FromSlash("/extra-filesystems/nvme0n1p1__caddy1-root"),
		})

		stats, exists := agent.fsStats["nvme0n1p1"]
		require.True(t, exists)
		assert.Equal(t, filepath.FromSlash("/extra-filesystems/nvme0n1p1__caddy1-root"), stats.Mountpoint)
		assert.Equal(t, "caddy1-root", stats.Name)
	})

	t.Run("skips nested mount under extra-filesystem bind mount", func(t *testing.T) {
		agent := &Agent{fsStats: make(map[string]*system.FsStats)}
		d := makeDiscovery(agent)

		// These simulate the virtual mounts that appear when host / is bind-mounted
		// with disk.Partitions(all=true) — e.g. /proc, /sys, /dev visible under the mount.
		for _, nested := range []string{
			filepath.FromSlash("/extra-filesystems/nvme0n1p1__caddy1-root/proc"),
			filepath.FromSlash("/extra-filesystems/nvme0n1p1__caddy1-root/sys"),
			filepath.FromSlash("/extra-filesystems/nvme0n1p1__caddy1-root/dev"),
			filepath.FromSlash("/extra-filesystems/nvme0n1p1__caddy1-root/run"),
		} {
			d.addPartitionExtraFs(disk.PartitionStat{Device: "tmpfs", Mountpoint: nested})
		}

		assert.Empty(t, agent.fsStats)
	})

	t.Run("registers both direct children, skips their nested mounts", func(t *testing.T) {
		agent := &Agent{fsStats: make(map[string]*system.FsStats)}
		d := makeDiscovery(agent)

		partitions := []disk.PartitionStat{
			{Device: "/dev/nvme0n1p1", Mountpoint: filepath.FromSlash("/extra-filesystems/nvme0n1p1__caddy1-root")},
			{Device: "/dev/nvme1n1", Mountpoint: filepath.FromSlash("/extra-filesystems/nvme1n1__caddy1-docker")},
			{Device: "proc", Mountpoint: filepath.FromSlash("/extra-filesystems/nvme0n1p1__caddy1-root/proc")},
			{Device: "sysfs", Mountpoint: filepath.FromSlash("/extra-filesystems/nvme0n1p1__caddy1-root/sys")},
			{Device: "overlay", Mountpoint: filepath.FromSlash("/extra-filesystems/nvme0n1p1__caddy1-root/var/lib/docker")},
		}
		for _, p := range partitions {
			d.addPartitionExtraFs(p)
		}

		require.Len(t, agent.fsStats, 2)
		require.Contains(t, agent.fsStats, "nvme0n1p1")
		assert.Equal(t, "caddy1-root", agent.fsStats["nvme0n1p1"].Name)
		require.Contains(t, agent.fsStats, "nvme1n1")
		assert.Equal(t, "caddy1-docker", agent.fsStats["nvme1n1"].Name)
	})

	t.Run("skips partition not under extra-filesystems", func(t *testing.T) {
		agent := &Agent{fsStats: make(map[string]*system.FsStats)}
		d := makeDiscovery(agent)

		d.addPartitionExtraFs(disk.PartitionStat{
			Device:     "/dev/nvme0n1p1",
			Mountpoint: "/",
		})

		assert.Empty(t, agent.fsStats)
	})
}

func TestFindIoDevice(t *testing.T) {
	t.Run("matches by device name", func(t *testing.T) {
		ioCounters := map[string]disk.IOCountersStat{
			"sda": {Name: "sda"},
			"sdb": {Name: "sdb"},
		}

		device, ok := findIoDevice("sdb", ioCounters)
		assert.True(t, ok)
		assert.Equal(t, "sdb", device)
	})

	t.Run("matches by device label", func(t *testing.T) {
		ioCounters := map[string]disk.IOCountersStat{
			"sda": {Name: "sda", Label: "rootfs"},
			"sdb": {Name: "sdb"},
		}

		device, ok := findIoDevice("rootfs", ioCounters)
		assert.True(t, ok)
		assert.Equal(t, "sda", device)
	})

	t.Run("returns no match when not found", func(t *testing.T) {
		ioCounters := map[string]disk.IOCountersStat{
			"sda": {Name: "sda"},
			"sdb": {Name: "sdb"},
		}

		device, ok := findIoDevice("nvme0n1p1", ioCounters)
		assert.False(t, ok)
		assert.Equal(t, "", device)
	})

	t.Run("uses uncertain unique prefix fallback", func(t *testing.T) {
		ioCounters := map[string]disk.IOCountersStat{
			"nvme0n1": {Name: "nvme0n1"},
			"sda":     {Name: "sda"},
		}

		device, ok := findIoDevice("nvme0n1p2", ioCounters)
		assert.True(t, ok)
		assert.Equal(t, "nvme0n1", device)
	})

	t.Run("uses dominant activity when prefix matches are ambiguous", func(t *testing.T) {
		ioCounters := map[string]disk.IOCountersStat{
			"sda": {Name: "sda", ReadBytes: 5000, WriteBytes: 5000, ReadCount: 100, WriteCount: 100},
			"sdb": {Name: "sdb", ReadBytes: 1000, WriteBytes: 1000, ReadCount: 50, WriteCount: 50},
		}

		device, ok := findIoDevice("sd", ioCounters)
		assert.True(t, ok)
		assert.Equal(t, "sda", device)
	})

	t.Run("uses highest activity when ambiguous without dominance", func(t *testing.T) {
		ioCounters := map[string]disk.IOCountersStat{
			"sda": {Name: "sda", ReadBytes: 3000, WriteBytes: 3000, ReadCount: 50, WriteCount: 50},
			"sdb": {Name: "sdb", ReadBytes: 2500, WriteBytes: 2500, ReadCount: 40, WriteCount: 40},
		}

		device, ok := findIoDevice("sd", ioCounters)
		assert.True(t, ok)
		assert.Equal(t, "sda", device)
	})

	t.Run("matches /dev/-prefixed partition to parent disk", func(t *testing.T) {
		ioCounters := map[string]disk.IOCountersStat{
			"nda0": {Name: "nda0", ReadBytes: 1000, WriteBytes: 1000},
		}

		device, ok := findIoDevice("/dev/nda0p2", ioCounters)
		assert.True(t, ok)
		assert.Equal(t, "nda0", device)
	})

	t.Run("uses deterministic name tie-breaker", func(t *testing.T) {
		ioCounters := map[string]disk.IOCountersStat{
			"sdb": {Name: "sdb", ReadBytes: 2000, WriteBytes: 2000, ReadCount: 10, WriteCount: 10},
			"sda": {Name: "sda", ReadBytes: 2000, WriteBytes: 2000, ReadCount: 10, WriteCount: 10},
		}

		device, ok := findIoDevice("sd", ioCounters)
		assert.True(t, ok)
		assert.Equal(t, "sda", device)
	})
}

func TestFilesystemMatchesPartitionSetting(t *testing.T) {
	p := disk.PartitionStat{Device: "/dev/ada0p2", Mountpoint: "/"}

	t.Run("matches mountpoint setting", func(t *testing.T) {
		assert.True(t, filesystemMatchesPartitionSetting("/", p))
	})

	t.Run("matches exact partition setting", func(t *testing.T) {
		assert.True(t, filesystemMatchesPartitionSetting("ada0p2", p))
		assert.True(t, filesystemMatchesPartitionSetting("/dev/ada0p2", p))
	})

	t.Run("matches prefix-style parent setting", func(t *testing.T) {
		assert.True(t, filesystemMatchesPartitionSetting("ada0", p))
		assert.True(t, filesystemMatchesPartitionSetting("/dev/ada0", p))
	})

	t.Run("does not match unrelated device", func(t *testing.T) {
		assert.False(t, filesystemMatchesPartitionSetting("sda", p))
		assert.False(t, filesystemMatchesPartitionSetting("nvme0n1", p))
		assert.False(t, filesystemMatchesPartitionSetting("", p))
	})
}

func TestMostActiveIoDevice(t *testing.T) {
	t.Run("returns most active device", func(t *testing.T) {
		ioCounters := map[string]disk.IOCountersStat{
			"nda0": {Name: "nda0", ReadBytes: 5000, WriteBytes: 5000, ReadCount: 100, WriteCount: 100},
			"nda1": {Name: "nda1", ReadBytes: 1000, WriteBytes: 1000, ReadCount: 50, WriteCount: 50},
		}
		assert.Equal(t, "nda0", mostActiveIoDevice(ioCounters))
	})

	t.Run("uses deterministic tie-breaker", func(t *testing.T) {
		ioCounters := map[string]disk.IOCountersStat{
			"sdb": {Name: "sdb", ReadBytes: 1000, WriteBytes: 1000, ReadCount: 10, WriteCount: 10},
			"sda": {Name: "sda", ReadBytes: 1000, WriteBytes: 1000, ReadCount: 10, WriteCount: 10},
		}
		assert.Equal(t, "sda", mostActiveIoDevice(ioCounters))
	})

	t.Run("returns empty for empty map", func(t *testing.T) {
		assert.Equal(t, "", mostActiveIoDevice(map[string]disk.IOCountersStat{}))
	})
}

func TestIsDockerSpecialMountpoint(t *testing.T) {
	testCases := []struct {
		name       string
		mountpoint string
		expected   bool
	}{
		{name: "hosts", mountpoint: "/etc/hosts", expected: true},
		{name: "resolv", mountpoint: "/etc/resolv.conf", expected: true},
		{name: "hostname", mountpoint: "/etc/hostname", expected: true},
		{name: "root", mountpoint: "/", expected: false},
		{name: "passwd", mountpoint: "/etc/passwd", expected: false},
		{name: "extra-filesystem", mountpoint: "/extra-filesystems/sda1", expected: false},
	}

	for _, tc := range testCases {
		t.Run(tc.name, func(t *testing.T) {
			assert.Equal(t, tc.expected, isDockerSpecialMountpoint(tc.mountpoint))
		})
	}
}

func TestFsStatsWithCustomNames(t *testing.T) {
	// Test that FsStats properly stores custom names
	fsStats := &system.FsStats{
		Mountpoint: "/mnt/storage",
		Name:       "my-custom-storage",
		DiskTotal:  100.0,
		DiskUsed:   50.0,
	}

	assert.Equal(t, "my-custom-storage", fsStats.Name)
	assert.Equal(t, "/mnt/storage", fsStats.Mountpoint)
	assert.Equal(t, 100.0, fsStats.DiskTotal)
	assert.Equal(t, 50.0, fsStats.DiskUsed)
}

func TestExtraFsKeyGeneration(t *testing.T) {
	// Test the logic for generating ExtraFs keys with custom names
	testCases := []struct {
		name        string
		deviceName  string
		customName  string
		expectedKey string
	}{
		{
			name:        "with custom name",
			deviceName:  "sda1",
			customName:  "my-storage",
			expectedKey: "my-storage",
		},
		{
			name:        "without custom name",
			deviceName:  "sda1",
			customName:  "",
			expectedKey: "sda1",
		},
		{
			name:        "empty custom name falls back to device",
			deviceName:  "nvme0n1p2",
			customName:  "",
			expectedKey: "nvme0n1p2",
		},
	}

	for _, tc := range testCases {
		t.Run(tc.name, func(t *testing.T) {
			// Simulate the key generation logic from agent.go
			key := tc.deviceName
			if tc.customName != "" {
				key = tc.customName
			}
			assert.Equal(t, tc.expectedKey, key)
		})
	}
}

func TestDiskUsageCaching(t *testing.T) {
	t.Run("caching disabled updates all filesystems", func(t *testing.T) {
		agent := &Agent{
			fsStats: map[string]*system.FsStats{
				"sda": {Root: true, Mountpoint: "/"},
				"sdb": {Root: false, Mountpoint: "/mnt/storage"},
			},
			diskUsageCacheDuration: 0, // caching disabled
		}

		var stats system.Stats
		agent.updateDiskUsage(&stats)

		// Both should be updated (non-zero values from disk.Usage)
		// Root stats should be populated in systemStats
		assert.True(t, agent.lastDiskUsageUpdate.IsZero() || !agent.lastDiskUsageUpdate.IsZero(),
			"lastDiskUsageUpdate should be set when caching is disabled")
	})

	t.Run("caching enabled always updates root filesystem", func(t *testing.T) {
		agent := &Agent{
			fsStats: map[string]*system.FsStats{
				"sda": {Root: true, Mountpoint: "/", DiskTotal: 100, DiskUsed: 50},
				"sdb": {Root: false, Mountpoint: "/mnt/storage", DiskTotal: 200, DiskUsed: 100},
			},
			diskUsageCacheDuration: 1 * time.Hour,
			lastDiskUsageUpdate:    time.Now(), // cache is fresh
		}

		// Store original extra fs values
		originalExtraTotal := agent.fsStats["sdb"].DiskTotal
		originalExtraUsed := agent.fsStats["sdb"].DiskUsed

		var stats system.Stats
		agent.updateDiskUsage(&stats)

		// Root should be updated (systemStats populated from disk.Usage call)
		// We can't easily check if disk.Usage was called, but we verify the flow works

		// Extra filesystem should retain cached values (not reset)
		assert.Equal(t, originalExtraTotal, agent.fsStats["sdb"].DiskTotal,
			"extra filesystem DiskTotal should be unchanged when cached")
		assert.Equal(t, originalExtraUsed, agent.fsStats["sdb"].DiskUsed,
			"extra filesystem DiskUsed should be unchanged when cached")
	})

	t.Run("first call always updates all filesystems", func(t *testing.T) {
		agent := &Agent{
			fsStats: map[string]*system.FsStats{
				"sda": {Root: true, Mountpoint: "/"},
				"sdb": {Root: false, Mountpoint: "/mnt/storage"},
			},
			diskUsageCacheDuration: 1 * time.Hour,
			// lastDiskUsageUpdate is zero (first call)
		}

		var stats system.Stats
		agent.updateDiskUsage(&stats)

		// After first call, lastDiskUsageUpdate should be set
		assert.False(t, agent.lastDiskUsageUpdate.IsZero(),
			"lastDiskUsageUpdate should be set after first call")
	})

	t.Run("expired cache updates extra filesystems", func(t *testing.T) {
		agent := &Agent{
			fsStats: map[string]*system.FsStats{
				"sda": {Root: true, Mountpoint: "/"},
				"sdb": {Root: false, Mountpoint: "/mnt/storage"},
			},
			diskUsageCacheDuration: 1 * time.Millisecond,
			lastDiskUsageUpdate:    time.Now().Add(-1 * time.Second), // cache expired
		}

		var stats system.Stats
		agent.updateDiskUsage(&stats)

		// lastDiskUsageUpdate should be refreshed since cache expired
		assert.True(t, time.Since(agent.lastDiskUsageUpdate) < time.Second,
			"lastDiskUsageUpdate should be refreshed when cache expires")
	})
}

func TestHasSameDiskUsage(t *testing.T) {
	const toleranceBytes uint64 = 16 * 1024 * 1024

	t.Run("returns true when totals and usage are equal", func(t *testing.T) {
		a := &disk.UsageStat{Total: 100 * 1024 * 1024 * 1024, Used: 42 * 1024 * 1024 * 1024}
		b := &disk.UsageStat{Total: 100 * 1024 * 1024 * 1024, Used: 42 * 1024 * 1024 * 1024}
		assert.True(t, hasSameDiskUsage(a, b))
	})

	t.Run("returns true within tolerance", func(t *testing.T) {
		a := &disk.UsageStat{Total: 100 * 1024 * 1024 * 1024, Used: 42 * 1024 * 1024 * 1024}
		b := &disk.UsageStat{
			Total: a.Total + toleranceBytes - 1,
			Used:  a.Used - toleranceBytes + 1,
		}
		assert.True(t, hasSameDiskUsage(a, b))
	})

	t.Run("returns false when total exceeds tolerance", func(t *testing.T) {
		a := &disk.UsageStat{Total: 100 * 1024 * 1024 * 1024, Used: 42 * 1024 * 1024 * 1024}
		b := &disk.UsageStat{
			Total: a.Total + toleranceBytes + 1,
			Used:  a.Used,
		}
		assert.False(t, hasSameDiskUsage(a, b))
	})

	t.Run("returns false for nil or zero total", func(t *testing.T) {
		assert.False(t, hasSameDiskUsage(nil, &disk.UsageStat{Total: 1, Used: 1}))
		assert.False(t, hasSameDiskUsage(&disk.UsageStat{Total: 1, Used: 1}, nil))
		assert.False(t, hasSameDiskUsage(&disk.UsageStat{Total: 0, Used: 0}, &disk.UsageStat{Total: 1, Used: 1}))
	})
}

func TestInitializeDiskIoStatsResetsTrackedDevices(t *testing.T) {
	agent := &Agent{
		fsStats: map[string]*system.FsStats{
			"sda": {},
			"sdb": {},
		},
		fsNames: []string{"stale", "sda"},
	}

	agent.initializeDiskIoStats(map[string]disk.IOCountersStat{
		"sda": {Name: "sda", ReadBytes: 10, WriteBytes: 20},
		"sdb": {Name: "sdb", ReadBytes: 30, WriteBytes: 40},
	})

	assert.ElementsMatch(t, []string{"sda", "sdb"}, agent.fsNames)
	assert.Len(t, agent.fsNames, 2)
	assert.Equal(t, uint64(10), agent.fsStats["sda"].TotalRead)
	assert.Equal(t, uint64(20), agent.fsStats["sda"].TotalWrite)
	assert.Equal(t, uint64(10), agent.diskBaseline["sda"].readBytes)
	assert.Equal(t, uint64(40), agent.diskBaseline["sdb"].writeBytes)
	assert.False(t, agent.diskBaseline["sda"].at.IsZero())
	assert.False(t, agent.diskBaseline["sdb"].at.IsZero())

	agent.initializeDiskIoStats(map[string]disk.IOCountersStat{
		"sdb": {Name: "sdb", ReadBytes: 50, WriteBytes: 60},
	})

	assert.Equal(t, []string{"sdb"}, agent.fsNames)
	assert.Equal(t, uint64(50), agent.fsStats["sdb"].TotalRead)
	assert.Equal(t, uint64(60), agent.fsStats["sdb"].TotalWrite)
}

func TestIoTimeDelta(t *testing.T) {
	assert.Equal(t, uint64(300), ioTimeDelta(1200, 900))

	// A lower value is a 32-bit wrap only on Linux. Other platforms
	// report 64-bit counters, so there it is a reset.
	var want uint64
	if runtime.GOOS == "linux" {
		want = 1200
	}
	assert.Equal(t, want, ioTimeDelta(200, math.MaxUint32+1-1000))

	assert.Equal(t, uint64(0), ioTimeDelta(200, math.MaxUint32+1000))
}

func TestNormalizeDeviceName(t *testing.T) {
	// A Windows volume name is not a path element, so every spelling of the
	// same drive has to normalize to the same key. filepath.Base cannot do
	// this: on Windows it strips the "C:" specifier and returns "\", which
	// collapses every drive letter onto one key (#2417).
	for _, spelling := range []string{"C:", `C:\`, "C:/", `C:\\`} {
		assert.Equal(t, "C:", normalizeDeviceName(spelling), "spelling %q", spelling)
	}
	// Drive letters are case-insensitive, so the letter is uppercased.
	assert.Equal(t, "D:", normalizeDeviceName("d:"))
	assert.Equal(t, "C:", normalizeDeviceName(" c: "))
	assert.Equal(t, "C:", normalizeDeviceName(`c:\`))

	// Non-volume inputs keep using filepath.Base.
	assert.Equal(t, "sda1", normalizeDeviceName("/dev/sda1"))
	assert.Equal(t, "sda1", normalizeDeviceName("/dev/sda1/"))
	assert.Equal(t, "nvme0n1p2", normalizeDeviceName("  /dev/nvme0n1p2  "))
	assert.Equal(t, "", normalizeDeviceName("."))
	assert.Equal(t, "", normalizeDeviceName("   "))

	// A drive-relative path is a path, not a volume.
	assert.Equal(t, filepath.Base(`C:data`), normalizeDeviceName(`C:data`))
}

func TestFindIoDeviceWindowsVolumeNames(t *testing.T) {
	// Every drive normalizes to a distinct key, so the root drive resolves
	// exactly instead of to whichever counter the map yielded first (#2417).
	ioCounters := map[string]disk.IOCountersStat{
		"C:": {Name: "C:", ReadBytes: 10, WriteBytes: 10},
		"D:": {Name: "D:", ReadBytes: 20, WriteBytes: 20},
		"P:": {Name: "P:", ReadBytes: 30, WriteBytes: 30},
	}

	for i := 0; i < 32; i++ {
		device, ok := findIoDevice("C:", ioCounters)
		assert.True(t, ok)
		assert.Equal(t, "C:", device)
	}

	// The drive may arrive with a trailing separator, as a mount point does.
	device, ok := findIoDevice(`C:\`, ioCounters)
	assert.True(t, ok)
	assert.Equal(t, "C:", device)
}

func TestAddPartitionRootFsWindowsDrive(t *testing.T) {
	agent := &Agent{fsStats: make(map[string]*system.FsStats)}
	discovery := diskDiscovery{
		agent: agent,
		ctx: fsRegistrationContext{
			isWindows: true,
			diskIoCounters: map[string]disk.IOCountersStat{
				"C:": {Name: "C:"},
				"D:": {Name: "D:"},
				"P:": {Name: "P:"},
			},
		},
	}

	ok := discovery.addPartitionRootFs("C:", `C:\`)

	assert.True(t, ok)
	assert.Len(t, agent.fsStats, 1)
	stats, exists := agent.fsStats["C:"]
	assert.True(t, exists)
	assert.True(t, stats.Root)
}

func TestAddPartitionRootFsKeyAlreadyRegistered(t *testing.T) {
	// The root drive is also listed in EXTRA_FILESYSTEMS, so its key is taken
	// before the root fallback runs. The existing entry must be promoted to root
	// rather than falling back to the most active device, which here is D:.
	agent := &Agent{fsStats: map[string]*system.FsStats{
		"C:": {Mountpoint: `C:\`, Name: "System"},
		"D:": {Mountpoint: `D:\`},
	}}
	discovery := diskDiscovery{
		agent:          agent,
		rootMountPoint: `C:\`,
		ctx: fsRegistrationContext{
			isWindows: true,
			diskIoCounters: map[string]disk.IOCountersStat{
				"C:": {Name: "C:", ReadBytes: 10},
				"D:": {Name: "D:", ReadBytes: 100},
			},
		},
	}

	ok := discovery.addPartitionRootFs("C:", `C:\`)
	assert.True(t, ok)
	assert.Len(t, agent.fsStats, 2)
	assert.True(t, agent.fsStats["C:"].Root)
	assert.Equal(t, `C:\`, agent.fsStats["C:"].Mountpoint)
	assert.Equal(t, "System", agent.fsStats["C:"].Name)
	assert.False(t, agent.fsStats["D:"].Root)
}