//go:build testing

package agent

import (
	"errors"
	"fmt"
	"os/exec"
	"strings"
	"sync"
	"testing"
	"time"

	"github.com/henrygd/beszel/agent/btrfs"
	"github.com/henrygd/beszel/agent/zfs"
	"github.com/henrygd/beszel/internal/entities/system"
	"github.com/stretchr/testify/assert"
	"github.com/stretchr/testify/require"
)

func TestOptionalPoolSource(t *testing.T) {
	failure := errors.New("timeout")
	for _, err := range []error{nil, zfs.ErrNoZfs, fmt.Errorf("zpool: %w", exec.ErrNotFound), errors.ErrUnsupported, failure} {
		_, got := optionalPoolSource(func() ([]zfs.PoolStat, error) { return nil, err })()
		if err == failure {
			assert.ErrorIs(t, got, failure)
		} else {
			assert.NoError(t, got)
		}
	}
}

type poolTestBackend struct {
	name  string
	err   error
	alloc uint64
	read  uint64
	empty bool
}

func (state *poolTestBackend) backend() *poolBackend {
	name := "zfs"
	if strings.HasPrefix(state.name, "b:") {
		name = "btrfs"
	}
	return &poolBackend{
		name: name,
		poolStatsFn: func() ([]zfs.PoolStat, error) {
			if state.empty {
				return nil, state.err
			}
			return []zfs.PoolStat{{Name: state.name, Size: 100, Alloc: state.alloc}}, state.err
		},
		kernelStatsFn: func() ([]zfs.PoolKernelStat, error) {
			return []zfs.PoolKernelStat{{Name: state.name, NRead: state.read}}, state.err
		},
		poolStatusesFn: func() ([]zfs.PoolStatus, error) { return nil, nil },
		datasetsFn:     func() ([]zfs.Dataset, error) { return nil, nil },
	}
}

func TestIndependentPoolBackendCaches(t *testing.T) {
	for _, failed := range []int{0, 1} {
		t.Run([]string{"zfs", "btrfs"}[failed], func(t *testing.T) {
			states := []*poolTestBackend{{name: "tank", alloc: 10}, {name: "b:uuid", alloc: 10}}
			managers := []*poolBackend{states[0].backend(), states[1].backend()}
			zm := &StoragePoolManager{backends: managers, detailInterval: time.Hour}
			var stats system.Stats
			zm.Update(&stats)
			require.Len(t, stats.ZfsPools, 2)
			require.True(t, zm.GetDetail(true).Complete)
			baseline := poolKernelSample{at: time.Now().Add(-time.Second)}
			for i, m := range managers {
				m.lastPoolStats = time.Time{}
				m.kernelSamples[states[i].name] = baseline
				states[i].alloc = 20
				states[i].read = 100
			}
			states[failed].err = errors.New("collection failed")
			zm.Update(&stats)
			healthy := 1 - failed
			assert.Equal(t, uint64(10), managers[failed].poolData[0].Alloc)
			assert.Equal(t, uint64(20), managers[healthy].poolData[0].Alloc)
			assert.Equal(t, baseline, managers[failed].kernelSamples[states[failed].name])
			assert.Zero(t, stats.ZfsPools[states[failed].name].ReadBytes)
			assert.Positive(t, stats.ZfsPools[states[healthy].name].ReadBytes)
			partial := zm.GetDetail(true)
			assert.False(t, partial.Complete)
			assert.False(t, partial.CanRefreshPool(states[failed].name))
			assert.True(t, partial.CanRefreshPool(states[healthy].name))
			assert.Equal(t, uint64(10), partial.Pools[failed].Alloc)
			assert.Equal(t, uint64(20), partial.Pools[healthy].Alloc)
			assert.False(t, zm.GetDetail(false).Complete, "a failed forced refresh must not become complete from cache")

			// Successful empty inventory removes only the healthy backend's pool.
			states[healthy].empty = true
			managers[healthy].lastPoolStats = time.Time{}
			zm.Update(&stats)
			require.Len(t, stats.ZfsPools, 1)
			assert.Contains(t, stats.ZfsPools, states[failed].name)
			partial = zm.GetDetail(true)
			require.Len(t, partial.Pools, 1)
			assert.True(t, partial.CanRefreshPool(states[healthy].name))

			// Recovery uses the retained I/O baseline, then normal removal works.
			states[failed].err = nil
			managers[failed].lastPoolStats = time.Time{}
			zm.Update(&stats)
			assert.Positive(t, stats.ZfsPools[states[failed].name].ReadBytes)
			assert.True(t, zm.GetDetail(true).Complete)
			states[failed].empty = true
			managers[failed].lastPoolStats = time.Time{}
			zm.Update(&stats)
			assert.Empty(t, stats.ZfsPools)
			assert.Empty(t, zm.GetDetail(true).Pools)
		})
	}
}

func TestIndependentBackendsWithoutCache(t *testing.T) {
	z := &poolTestBackend{name: "tank", err: errors.New("ZFS failure")}
	b := &poolTestBackend{name: "b:uuid", alloc: 20}
	zm := &StoragePoolManager{backends: []*poolBackend{z.backend(), b.backend()}, detailInterval: time.Hour}
	var stats system.Stats
	zm.Update(&stats)
	require.Len(t, stats.ZfsPools, 1)
	assert.Contains(t, stats.ZfsPools, "b:uuid")
	detail := zm.GetDetail(true)
	require.Len(t, detail.Pools, 1)
	assert.False(t, detail.Complete)
	assert.Equal(t, []string{"btrfs"}, detail.CompleteBackends)
}

func TestConcurrentBackendDetailsAndMetrics(t *testing.T) {
	zm := &StoragePoolManager{backends: []*poolBackend{(&poolTestBackend{name: "tank"}).backend(), (&poolTestBackend{name: "b:uuid"}).backend()}, detailInterval: time.Hour}
	var wg sync.WaitGroup
	for i := 0; i < 3; i++ {
		wg.Add(1)
		go func(metrics bool) {
			defer wg.Done()
			for j := 0; j < 10; j++ {
				if metrics {
					zm.Update(&system.Stats{})
				} else {
					zm.GetDetail(true)
				}
			}
		}(i == 0)
	}
	wg.Wait()
}

func TestStoragePoolBackendOrder(t *testing.T) {
	z := (&poolTestBackend{name: "tank"}).backend()
	b := (&poolTestBackend{name: "b:uuid"}).backend()
	b.datasetsFn = nil // Btrfs does not expose datasets.
	z.datasetsFn = func() ([]zfs.Dataset, error) {
		return []zfs.Dataset{{Name: "tank/data", Mountpoint: "/tank", Used: 10}}, nil
	}
	m := &StoragePoolManager{backends: []*poolBackend{b, z}, detailInterval: time.Hour}
	var stats system.Stats
	m.Update(&stats)
	require.Len(t, stats.ZfsPools, 2)
	detail := m.GetDetail(true)
	require.True(t, detail.Complete)
	assert.Equal(t, []string{"btrfs", "zfs"}, detail.CompleteBackends)
	assert.Empty(t, detail.Pools[0].Datasets)
	assert.Len(t, detail.Pools[1].Datasets, 1)
	assert.Equal(t, uint64(10), m.DatasetUsage()["/tank"].used)

	b.poolData[0].MountID = "uuid"
	b.poolData[0].IODevice = "sda"
	calls := 0
	m.markDuplicateCharts(&stats, map[string]*system.FsStats{
		"sda": {Mountpoint: "/", DiskTotal: 100},
	}, func(string) string { calls++; return "uuid" })
	assert.Equal(t, 1, calls, "resolve each filesystem once across all backends")
	assert.True(t, stats.ZfsPools["b:uuid"].HideUsage)
	assert.True(t, stats.ZfsPools["b:uuid"].HideIO)
}

func TestUpdatePopulatesZfsPools(t *testing.T) {
	zm := &StoragePoolManager{detailInterval: time.Hour, backends: []*poolBackend{{name: "zfs"}}}
	zm.backends[0].poolStatsFn = func() ([]zfs.PoolStat, error) {
		return []zfs.PoolStat{{Name: "tank", Size: 23999000000000, Alloc: 12000000000000, Free: 11999000000000, Health: "DEGRADED"}}, nil
	}
	zm.backends[0].datasetsFn = func() ([]zfs.Dataset, error) {
		return []zfs.Dataset{
			{Name: "tank/apps", Used: 5000000000000, Avail: 11999000000000, Mountpoint: "/tank/apps"},
			{Name: "tank/backup", Used: 6000000000000, Avail: 11999000000000, Mountpoint: "/tank/backup"},
			// Small zvol (Proxmox VM EFI disk): must not round to zero.
			{Name: "rpool/vm-100-disk-2", Used: 4194304, Avail: 0, Mountpoint: "-"},
		}, nil
	}
	var kernelCalls int
	zm.backends[0].kernelStatsFn = func() ([]zfs.PoolKernelStat, error) {
		kernelCalls++
		return []zfs.PoolKernelStat{{
			Name: "tank", Health: "ONLINE",
			NRead: uint64(kernelCalls-1) * 1250, NWrite: uint64(kernelCalls-1) * 5120,
		}}, nil
	}

	var stats system.Stats
	// The first kernel sample establishes the cumulative-counter baseline.
	zm.Update(&stats)
	zm.backends[0].kernelSamples["tank"] = poolKernelSample{at: time.Now().Add(-time.Second)}
	zm.Update(&stats)
	require.NotNil(t, stats.ZfsPools)
	require.Contains(t, stats.ZfsPools, "tank")
	assert.InDelta(t, 22350.8105, stats.ZfsPools["tank"].Total, 0.0001) // Size in GiB
	assert.InDelta(t, 11175.8709, stats.ZfsPools["tank"].Used, 0.0001)  // Alloc in GiB
	assert.Equal(t, "ONLINE", stats.ZfsPools["tank"].Health)
	assert.InDelta(t, 1250, stats.ZfsPools["tank"].ReadBytes, 5)
	assert.InDelta(t, 5120, stats.ZfsPools["tank"].WriteBytes, 5)

}

// TestUpdateKernelStatsMissing verifies pools without a kernel sample report zero
// I/O instead of erroring.
func TestUpdateKernelStatsMissing(t *testing.T) {
	zm := &StoragePoolManager{detailInterval: time.Hour, backends: []*poolBackend{{name: "zfs"}}}
	zm.backends[0].poolStatsFn = func() ([]zfs.PoolStat, error) {
		return []zfs.PoolStat{{Name: "tank", Size: 1, Alloc: 1, Health: "ONLINE"}}, nil
	}
	zm.backends[0].datasetsFn = func() ([]zfs.Dataset, error) { return nil, nil }
	zm.backends[0].kernelStatsFn = func() ([]zfs.PoolKernelStat, error) {
		return nil, zfs.ErrNoZfs
	}

	var stats system.Stats
	zm.Update(&stats)
	require.NotNil(t, stats.ZfsPools)
	assert.Equal(t, uint64(0), stats.ZfsPools["tank"].ReadBytes)
	assert.Equal(t, uint64(0), stats.ZfsPools["tank"].WriteBytes)
}

func TestUpdateKernelCounterReset(t *testing.T) {
	zm := &StoragePoolManager{detailInterval: time.Hour, backends: []*poolBackend{{name: "zfs"}}}
	zm.backends[0].poolStatsFn = func() ([]zfs.PoolStat, error) {
		return []zfs.PoolStat{{Name: "tank", Health: "ONLINE"}}, nil
	}
	zm.backends[0].datasetsFn = func() ([]zfs.Dataset, error) { return nil, nil }
	zm.backends[0].kernelSamples = map[string]poolKernelSample{
		"tank": {nread: 100, nwrite: 200, at: time.Now().Add(-time.Second)},
	}
	zm.backends[0].kernelStatsFn = func() ([]zfs.PoolKernelStat, error) {
		return []zfs.PoolKernelStat{{Name: "tank", Health: "ONLINE", NRead: 10, NWrite: 20}}, nil
	}

	var stats system.Stats
	zm.Update(&stats)
	assert.Equal(t, uint64(0), stats.ZfsPools["tank"].ReadBytes)
	assert.Equal(t, uint64(0), stats.ZfsPools["tank"].WriteBytes)
}

func TestUpdateNoZfs(t *testing.T) {
	zm := &StoragePoolManager{detailInterval: time.Hour, backends: []*poolBackend{{name: "zfs"}}}
	calls := 0
	zm.backends[0].poolStatsFn = func() ([]zfs.PoolStat, error) {
		calls++
		return nil, zfs.ErrNoZfs
	}

	var stats system.Stats
	zm.Update(&stats)
	zm.Update(&stats)
	assert.Nil(t, stats.ZfsPools)
	assert.Equal(t, 1, calls, "failed pool discovery should be cached until the next refresh interval")
}

func TestUpdateEmptyPools(t *testing.T) {
	zm := &StoragePoolManager{detailInterval: time.Hour, backends: []*poolBackend{{name: "zfs"}}}
	calls := 0
	zm.backends[0].poolStatsFn = func() ([]zfs.PoolStat, error) {
		calls++
		return nil, nil
	}

	var stats system.Stats
	zm.Update(&stats)
	zm.Update(&stats)
	assert.Nil(t, stats.ZfsPools)
	assert.Equal(t, 1, calls, "an empty pool inventory should be cached until the next refresh interval")
}

func TestDatasetUsage(t *testing.T) {
	zm := &StoragePoolManager{detailInterval: time.Hour, backends: []*poolBackend{{name: "zfs"}}}
	calls := 0
	zm.backends[0].datasetsFn = func() ([]zfs.Dataset, error) {
		calls++
		return []zfs.Dataset{
			{Name: "tank", Used: 12000000000000, Avail: 11999000000000, Mountpoint: "/tank"},
			{Name: "tank/apps", Used: 1000000000000, Avail: 11999000000000, Mountpoint: "/tank/apps"},
			{Name: "rpool", Used: 900000000000, Avail: 300000000000, Mountpoint: "-"}, // zvol/unmounted: excluded
		}, nil
	}

	usage := zm.DatasetUsage()
	require.Len(t, usage, 2)
	assert.Equal(t, zfsDatasetUsage{used: 12000000000000, avail: 11999000000000}, usage["/tank"])
	assert.Equal(t, zfsDatasetUsage{used: 1000000000000, avail: 11999000000000}, usage["/tank/apps"])
	assert.Equal(t, 1, calls)

	// Second call within the refresh window must not re-run the collector.
	zm.DatasetUsage()
	assert.Equal(t, 1, calls)
}

func TestDatasetUsageRefreshOnErrorKeepsPrevious(t *testing.T) {
	zm := &StoragePoolManager{detailInterval: time.Hour, backends: []*poolBackend{{name: "zfs"}}}
	zm.backends[0].datasetsFn = func() ([]zfs.Dataset, error) {
		return []zfs.Dataset{{Name: "tank", Used: 1, Avail: 1, Mountpoint: "/tank"}}, nil
	}
	assert.Len(t, zm.DatasetUsage(), 1)

	// Force refresh window expiry, then a failing collector.
	zm.backends[0].lastUsageRefresh = time.Now().Add(-10 * time.Minute)
	zm.backends[0].datasetsFn = func() ([]zfs.Dataset, error) {
		return nil, zfs.ErrNoZfs
	}
	usage := zm.DatasetUsage()
	assert.Len(t, usage, 1, "previous usage should be retained on error")
}

func TestDatasetUsageClearsAbsentBackend(t *testing.T) {
	b := newZfsBackend()
	b.datasetUsage = map[string]zfsDatasetUsage{"/tank": {used: 1, avail: 1}}
	b.datasetsFn = optionalPoolSource(func() ([]zfs.Dataset, error) {
		return nil, zfs.ErrNoZfs
	})

	datasets, err := b.datasets()
	require.NoError(t, err, "an absent backend must not produce an error to log")
	assert.Empty(t, datasets)
	b.refreshDatasetUsage()
	assert.Empty(t, b.datasetUsage)
	assert.False(t, b.lastUsageRefresh.IsZero())
}

func TestGetDetailForceRefresh(t *testing.T) {
	zm := &StoragePoolManager{detailInterval: time.Hour, backends: []*poolBackend{{name: "zfs"}}}
	poolCalls := 0
	zm.backends[0].poolStatsFn = func() ([]zfs.PoolStat, error) {
		poolCalls++
		return []zfs.PoolStat{{Name: "tank", Alloc: uint64(poolCalls)}}, nil
	}
	zm.backends[0].poolStatusesFn = func() ([]zfs.PoolStatus, error) { return nil, nil }
	zm.backends[0].datasetsFn = func() ([]zfs.Dataset, error) { return nil, nil }

	first := zm.GetDetail(false)
	assert.True(t, first.Complete)
	require.Len(t, first.Pools, 1)
	assert.Equal(t, uint64(1), first.Pools[0].Alloc)

	cached := zm.GetDetail(false)
	require.Len(t, cached.Pools, 1)
	assert.Equal(t, uint64(1), cached.Pools[0].Alloc)
	assert.Equal(t, 1, poolCalls)

	refreshed := zm.GetDetail(true)
	assert.True(t, refreshed.Complete)
	require.Len(t, refreshed.Pools, 1)
	assert.Equal(t, uint64(2), refreshed.Pools[0].Alloc)
	assert.Equal(t, 2, poolCalls)
}

func TestGetDetailSuccessfulEmptyInventoryClearsCache(t *testing.T) {
	zm := &StoragePoolManager{detailInterval: time.Hour, backends: []*poolBackend{{name: "zfs"}}}
	zm.backends[0].poolStatsFn = func() ([]zfs.PoolStat, error) {
		return []zfs.PoolStat{{Name: "tank"}}, nil
	}
	zm.backends[0].poolStatusesFn = func() ([]zfs.PoolStatus, error) { return nil, nil }
	zm.backends[0].datasetsFn = func() ([]zfs.Dataset, error) { return nil, nil }

	require.Len(t, zm.GetDetail(false).Pools, 1)
	zm.backends[0].poolStatsFn = func() ([]zfs.PoolStat, error) { return nil, nil }
	empty := zm.GetDetail(true)
	assert.True(t, empty.Complete)
	assert.Empty(t, empty.Pools)
}

func TestGetDetailFailureReturnsIncompleteCachedInventory(t *testing.T) {
	zm := &StoragePoolManager{detailInterval: time.Hour, backends: []*poolBackend{{name: "zfs"}}}
	zm.backends[0].poolStatsFn = func() ([]zfs.PoolStat, error) {
		return []zfs.PoolStat{{Name: "tank"}}, nil
	}
	zm.backends[0].poolStatusesFn = func() ([]zfs.PoolStatus, error) {
		return []zfs.PoolStatus{{Name: "tank", Vdevs: []zfs.VdevStatus{{Name: "mirror-0"}}}}, nil
	}
	zm.backends[0].datasetsFn = func() ([]zfs.Dataset, error) {
		return []zfs.Dataset{{Name: "tank/data"}}, nil
	}
	first := zm.GetDetail(false)
	require.True(t, first.Complete)
	require.Len(t, first.Pools[0].Vdevs, 1)
	require.Len(t, first.Pools[0].Datasets, 1)

	zm.backends[0].poolStatusesFn = func() ([]zfs.PoolStatus, error) { return nil, zfs.ErrNoZfs }
	zm.backends[0].datasetsFn = func() ([]zfs.Dataset, error) { return nil, zfs.ErrNoZfs }
	partial := zm.GetDetail(true)
	require.True(t, partial.Complete)
	require.Len(t, partial.Pools[0].Vdevs, 1)
	require.Len(t, partial.Pools[0].Datasets, 1)

	zm.backends[0].poolStatsFn = func() ([]zfs.PoolStat, error) { return nil, zfs.ErrNoZfs }
	lastSuccessfulRefresh := zm.backends[0].lastDetailRefresh
	failed := zm.GetDetail(true)
	assert.False(t, failed.Complete)
	require.Len(t, failed.Pools, 1)
	assert.Equal(t, "tank", failed.Pools[0].Name)
	assert.Equal(t, lastSuccessfulRefresh, zm.backends[0].lastDetailRefresh)
}

func TestZfsMountpoints(t *testing.T) {
	zm := &StoragePoolManager{detailInterval: time.Hour, backends: []*poolBackend{{name: "zfs"}}}
	zm.backends[0].datasetsFn = func() ([]zfs.Dataset, error) {
		return []zfs.Dataset{
			{Name: "tank", Mountpoint: "/tank"},
			{Name: "rpool/ROOT/pve-1", Mountpoint: "/"},
		}, nil
	}
	mountpoints := zm.ZfsMountpoints()
	assert.Len(t, mountpoints, 2)
	assert.True(t, mountpoints["/tank"])
	assert.True(t, mountpoints["/"])
}

func TestBtrfsRawCapacityPropagates(t *testing.T) {
	zm := &StoragePoolManager{detailInterval: time.Hour, backends: []*poolBackend{{name: "zfs", poolStatsFn: func() ([]zfs.PoolStat, error) {
		return []zfs.PoolStat{btrfsPoolStats(btrfs.Filesystem{UUID: "raw", Name: "raw", Size: 200, Alloc: 100, Raw: true})}, nil
	},
		poolStatusesFn: func() ([]zfs.PoolStatus, error) { return nil, nil },
		datasetsFn:     func() ([]zfs.Dataset, error) { return nil, nil }}}}
	var stats system.Stats
	zm.Update(&stats)
	require.True(t, stats.ZfsPools["b:raw"].Raw)
	detail := zm.GetDetail(true)
	require.True(t, detail.Complete)
	require.Len(t, detail.Pools, 1)
	assert.True(t, detail.Pools[0].Raw)
}

func TestMarkDuplicatePoolCharts(t *testing.T) {
	for _, tc := range []struct {
		name, poolID, device string
		raw                  bool
		diskTotal            float64
		wantUsage, wantIO    bool
	}{
		{"single device root", "fs1", "dm-0", false, 100, true, true},
		{"multi device", "fs1", "", false, 100, true, false},
		{"different IO device", "fs1", "nvme0n1", false, 100, true, false},
		{"different filesystem", "fs2", "dm-0", false, 100, false, false},
		{"unknown identity", "", "dm-0", false, 100, false, false},
		{"raw usage", "fs1", "dm-0", true, 100, false, true},
		{"failed disk collection", "fs1", "dm-0", false, 0, false, false},
	} {
		t.Run(tc.name, func(t *testing.T) {
			zm := &StoragePoolManager{detailInterval: time.Hour, backends: []*poolBackend{{name: "zfs", poolData: []zfs.PoolStat{{Name: "arbitrary label", MountID: tc.poolID, IODevice: tc.device, Raw: tc.raw}}}}}
			stats := &system.Stats{ZfsPools: map[string]*system.ZfsPool{"arbitrary label": {}}}
			fs := map[string]*system.FsStats{"dm-0": {Root: true, Mountpoint: "/", DiskTotal: tc.diskTotal}}
			zm.markDuplicateCharts(stats, fs, func(string) string { return "fs1" })
			assert.Equal(t, tc.wantUsage, stats.ZfsPools["arbitrary label"].HideUsage)
			assert.Equal(t, tc.wantIO, stats.ZfsPools["arbitrary label"].HideIO)
			// Bind mounts and custom extra-filesystem names have the same identity.
			fs["dm-0"].Root = false
			fs["dm-0"].Mountpoint = "/extra-filesystems/storage"
			fs["dm-0"].Name = "custom name"
			stats.ZfsPools["arbitrary label"] = &system.ZfsPool{}
			zm.markDuplicateCharts(stats, fs, func(string) string { return "fs1" })
			assert.Equal(t, tc.wantUsage, stats.ZfsPools["arbitrary label"].HideUsage)
			assert.Equal(t, tc.wantIO, stats.ZfsPools["arbitrary label"].HideIO)
		})
	}
}

func TestBtrfsPoolIdentities(t *testing.T) {
	old := btrfsFilesystems
	t.Cleanup(func() { btrfsFilesystems = old })
	label := "tank"
	btrfsFilesystems = func() ([]btrfs.Filesystem, error) {
		return []btrfs.Filesystem{
			{UUID: "11111111-1111-4111-8111-111111111111", Name: label, Size: 100, Health: "ONLINE", NRead: 100, Devices: []btrfs.Device{{Name: "first"}}},
			{UUID: "22222222-2222-4222-8222-222222222222", Name: "tank", Size: 200, Health: "DEGRADED", NRead: 200, Devices: []btrfs.Device{{Name: "second"}}},
		}, nil
	}
	zm := &StoragePoolManager{detailInterval: time.Hour, backends: []*poolBackend{{name: "zfs", poolStatsFn: func() ([]zfs.PoolStat, error) { return []zfs.PoolStat{{Name: "tank", Size: 300}}, nil },
		kernelStatsFn: func() ([]zfs.PoolKernelStat, error) { return []zfs.PoolKernelStat{{Name: "tank", NRead: 300}}, nil },
		poolStatusesFn: func() ([]zfs.PoolStatus, error) {
			return []zfs.PoolStatus{{Name: "tank", Vdevs: []zfs.VdevStatus{{Name: "zfs-device"}}}}, nil
		},

		datasetsFn: func() ([]zfs.Dataset, error) { return []zfs.Dataset{{Name: "tank/data"}}, nil }}, newBtrfsBackend()}}
	first := "b:11111111-1111-4111-8111-111111111111"
	second := "b:22222222-2222-4222-8222-222222222222"
	var stats system.Stats
	zm.Update(&stats)
	require.Len(t, stats.ZfsPools, 3)
	assert.Contains(t, stats.ZfsPools, "tank")
	assert.Equal(t, "ONLINE", stats.ZfsPools[first].Health)
	assert.Equal(t, "DEGRADED", stats.ZfsPools[second].Health)
	assert.Equal(t, uint64(100), zm.backends[1].kernelSamples[first].nread)
	assert.Equal(t, uint64(200), zm.backends[1].kernelSamples[second].nread)
	detail := zm.GetDetail(true)
	require.Len(t, detail.Pools, 3)
	assert.Equal(t, "zfs-device", detail.Pools[0].Vdevs[0].Name)
	assert.Len(t, detail.Pools[0].Datasets, 1)
	assert.Equal(t, "first", detail.Pools[1].Vdevs[0].Name)
	assert.Empty(t, detail.Pools[1].Datasets)
	assert.Equal(t, "second", detail.Pools[2].Vdevs[0].Name)
	label = "renamed"
	zm.backends[0].lastPoolStats = time.Time{}
	zm.backends[1].lastPoolStats = time.Time{}
	zm.Update(&stats)
	require.Len(t, stats.ZfsPools, 3)
	assert.Equal(t, "renamed", stats.ZfsPools[first].DisplayName)
	assert.Equal(t, first, zm.GetDetail(true).Pools[1].Name)
	assert.Equal(t, "renamed", zm.GetDetail(true).Pools[1].DisplayName)
}