Add tests for weight/throttle device opts validators

opts/weightdevice.go and opts/throttledevice.go had no tests, unlike the
sibling opts. Add table-driven coverage for ValidateWeightDevice,
ValidateThrottleBpsDevice, ValidateThrottleIOpsDevice and the Set/GetList
paths, including boundary (weight 0/10/1000/overflow) and error cases.

Signed-off-by: Nikolaus Schuetz <nikolauspschuetz@gmail.com>

Author: nikolauspschuetz

opts/throttledevice_test.go

@@ -0,0 +1,83 @@
+package opts
+
+import (
+	"testing"
+
+	"gotest.tools/v3/assert"
+)
+
+func TestValidateThrottleBpsDevice(t *testing.T) {
+	tests := []struct {
+		name     string
+		val      string
+		wantErr  string
+		wantPath string
+		wantRate uint64
+	}{
+		{name: "plain integer", val: "/dev/sda:1000", wantPath: "/dev/sda", wantRate: 1000},
+		{name: "with unit", val: "/dev/sda:1mb", wantPath: "/dev/sda", wantRate: 1048576},
+		{name: "zero", val: "/dev/sda:0", wantPath: "/dev/sda", wantRate: 0},
+		{name: "missing colon", val: "/dev/sda", wantErr: "bad format: /dev/sda"},
+		{name: "empty device", val: ":1mb", wantErr: "bad format: :1mb"},
+		{name: "missing /dev/ prefix", val: "sda:1mb", wantErr: "bad format for device path: sda:1mb"},
+		{name: "non-numeric rate", val: "/dev/sda:foo", wantErr: "invalid rate for device"},
+	}
+	for _, tc := range tests {
+		t.Run(tc.name, func(t *testing.T) {
+			v, err := ValidateThrottleBpsDevice(tc.val)
+			if tc.wantErr != "" {
+				assert.ErrorContains(t, err, tc.wantErr)
+				assert.Assert(t, v == nil)
+				return
+			}
+			assert.NilError(t, err)
+			assert.Equal(t, v.Path, tc.wantPath)
+			assert.Equal(t, v.Rate, tc.wantRate)
+		})
+	}
+}
+
+func TestValidateThrottleIOpsDevice(t *testing.T) {
+	tests := []struct {
+		name     string
+		val      string
+		wantErr  string
+		wantPath string
+		wantRate uint64
+	}{
+		{name: "valid integer", val: "/dev/sda:100", wantPath: "/dev/sda", wantRate: 100},
+		{name: "fractional rejected", val: "/dev/sda:1.5", wantErr: "invalid rate for device"},
+		{name: "negative rejected", val: "/dev/sda:-5", wantErr: "invalid rate for device"},
+		{name: "unit suffix rejected (iops are integers)", val: "/dev/sda:1mb", wantErr: "invalid rate for device"},
+		{name: "missing /dev/ prefix", val: "sda:100", wantErr: "bad format for device path: sda:100"},
+	}
+	for _, tc := range tests {
+		t.Run(tc.name, func(t *testing.T) {
+			v, err := ValidateThrottleIOpsDevice(tc.val)
+			if tc.wantErr != "" {
+				assert.ErrorContains(t, err, tc.wantErr)
+				assert.Assert(t, v == nil)
+				return
+			}
+			assert.NilError(t, err)
+			assert.Equal(t, v.Path, tc.wantPath)
+			assert.Equal(t, v.Rate, tc.wantRate)
+		})
+	}
+}
+
+func TestThrottledeviceOptSetGetList(t *testing.T) {
+	opt := NewThrottledeviceOpt(ValidateThrottleBpsDevice)
+	assert.NilError(t, opt.Set("/dev/sda:1mb"))
+	assert.NilError(t, opt.Set("/dev/sdb:2mb"))
+
+	list := opt.GetList()
+	assert.Equal(t, len(list), 2)
+	assert.Equal(t, list[0].Path, "/dev/sda")
+	assert.Equal(t, list[0].Rate, uint64(1048576))
+	assert.Equal(t, list[1].Path, "/dev/sdb")
+	assert.Equal(t, list[1].Rate, uint64(2097152))
+
+	assert.ErrorContains(t, opt.Set("/dev/sdc:bad"), "invalid rate for device")
+	assert.Equal(t, opt.Type(), "list")
+}

opts/weightdevice_test.go

@@ -0,0 +1,56 @@
+package opts
+
+import (
+	"testing"
+
+	"gotest.tools/v3/assert"
+)
+
+func TestValidateWeightDevice(t *testing.T) {
+	tests := []struct {
+		name       string
+		val        string
+		wantErr    string
+		wantPath   string
+		wantWeight uint16
+	}{
+		{name: "valid minimum", val: "/dev/sda:10", wantPath: "/dev/sda", wantWeight: 10},
+		{name: "valid maximum", val: "/dev/sda:1000", wantPath: "/dev/sda", wantWeight: 1000},
+		{name: "zero is accepted (unset)", val: "/dev/sda:0", wantPath: "/dev/sda", wantWeight: 0},
+		{name: "below minimum", val: "/dev/sda:9", wantErr: "invalid weight for device: /dev/sda:9"},
+		{name: "above maximum", val: "/dev/sda:1001", wantErr: "invalid weight for device: /dev/sda:1001"},
+		{name: "overflows uint16", val: "/dev/sda:70000", wantErr: "invalid weight for device: /dev/sda:70000"},
+		{name: "missing colon", val: "/dev/sda", wantErr: "bad format: /dev/sda"},
+		{name: "empty device", val: ":100", wantErr: "bad format: :100"},
+		{name: "missing /dev/ prefix", val: "sda:100", wantErr: "bad format for device path: sda:100"},
+	}
+	for _, tc := range tests {
+		t.Run(tc.name, func(t *testing.T) {
+			v, err := ValidateWeightDevice(tc.val)
+			if tc.wantErr != "" {
+				assert.Error(t, err, tc.wantErr)
+				assert.Assert(t, v == nil)
+				return
+			}
+			assert.NilError(t, err)
+			assert.Equal(t, v.Path, tc.wantPath)
+			assert.Equal(t, v.Weight, tc.wantWeight)
+		})
+	}
+}
+
+func TestWeightdeviceOptSetGetList(t *testing.T) {
+	opt := NewWeightdeviceOpt(ValidateWeightDevice)
+	assert.NilError(t, opt.Set("/dev/sda:100"))
+	assert.NilError(t, opt.Set("/dev/sdb:200"))
+
+	list := opt.GetList()
+	assert.Equal(t, len(list), 2)
+	assert.Equal(t, list[0].Path, "/dev/sda")
+	assert.Equal(t, list[0].Weight, uint16(100))
+	assert.Equal(t, list[1].Path, "/dev/sdb")
+	assert.Equal(t, list[1].Weight, uint16(200))
+
+	assert.Error(t, opt.Set("/dev/sdc:1"), "invalid weight for device: /dev/sdc:1")
+	assert.Equal(t, opt.Type(), "list")
+}