test: Enhance cluster tests with memory and CPU configurations, integrating new state utilities for validation and conversion

Author: scott-the-programmer

minikube/generator/schema_builder.go

@@ -71,9 +71,11 @@ var schemaOverrides map[string]SchemaOverride = map[string]SchemaOverride{
 		ValidateDiagFunc: "state_utils.ResourceSizeValidator()",
 	},
 	"cpus": {
-		Default:     "2",
-		Description: "Number of CPUs allocated to Kubernetes. Use \\\"max\\\" to use the maximum number of CPUs. Use \\\"no-limit\\\" to not specify a limit (Docker/Podman only)",
-		Type:        String,
+		Default:          "2",
+		Description:      "Number of CPUs allocated to Kubernetes. Use \\\"max\\\" to use the maximum number of CPUs. Use \\\"no-limit\\\" to not specify a limit (Docker/Podman only)",
+		Type:             String,
+		StateFunc:        "state_utils.CPUConverter()",
+		ValidateDiagFunc: "state_utils.CPUValidator()",
 	},
 	// Customize the description to be the fullset of drivers
 	"driver": {

minikube/resource_cluster.go

@@ -276,6 +276,12 @@ func initialiseMinikubeClient(d *schema.ResourceData, m interface{}) (lib.Cluste
 		return nil, err
 	}
 
+	cpuStr := d.Get("cpus").(string)
+	cpus, err := state_utils.GetCPUs(cpuStr)
+	if err != nil {
+		return nil, err
+	}
+
 	diskStr := d.Get("disk_size").(string)
 	diskMb, err := pkgutil.CalculateSizeInMB(diskStr)
 	if err != nil {
@@ -371,22 +377,16 @@ func initialiseMinikubeClient(d *schema.ResourceData, m interface{}) (lib.Cluste
 	vc = lib.ResolveSpecialWaitOptions(vc)
 
 	cc := config.ClusterConfig{
-		Addons:        addonConfig,
-		APIServerPort: d.Get("apiserver_port").(int),
-		Name:          d.Get("cluster_name").(string),
-		KeepContext:   d.Get("keep_context").(bool),
-		EmbedCerts:    d.Get("embed_certs").(bool),
-		MinikubeISO:   state_utils.ReadSliceState(defaultIsos)[0],
-		KicBaseImage:  d.Get("base_image").(string),
-		Network:       d.Get("network").(string),
-		Memory:        memoryMb,
-		CPUs: func() int {
-			cpus, err := state_utils.GetCPUs(d.Get("cpus").(string))
-			if err != nil {
-				return 2 // Default to 2 CPUs if there's an error
-			}
-			return cpus
-		}(),
+		Addons:                  addonConfig,
+		APIServerPort:           d.Get("apiserver_port").(int),
+		Name:                    d.Get("cluster_name").(string),
+		KeepContext:             d.Get("keep_context").(bool),
+		EmbedCerts:              d.Get("embed_certs").(bool),
+		MinikubeISO:             state_utils.ReadSliceState(defaultIsos)[0],
+		KicBaseImage:            d.Get("base_image").(string),
+		Network:                 d.Get("network").(string),
+		Memory:                  memoryMb,
+		CPUs:                    cpus,
 		DiskSize:                diskMb,
 		Driver:                  driver,
 		ListenAddress:           d.Get("listen_address").(string),

minikube/resource_cluster_test.go

@@ -15,6 +15,7 @@ import (
 	"time"
 
 	"github.com/scott-the-programmer/terraform-provider-minikube/minikube/lib"
+	"github.com/scott-the-programmer/terraform-provider-minikube/minikube/state_utils"
 
 	"github.com/golang/mock/gomock"
 	"github.com/hashicorp/terraform-plugin-sdk/v2/diag"
@@ -35,12 +36,14 @@ type mockClusterClientProperties struct {
 	haNodes     int
 	workerNodes int
 	diskSize    int
+	memory      string
+	cpu         string
 }
 
 func TestClusterCreation(t *testing.T) {
 	resource.Test(t, resource.TestCase{
 		IsUnitTest: true,
-		Providers:  map[string]*schema.Provider{"minikube": NewProvider(mockSuccess(mockClusterClientProperties{t, "TestClusterCreation", 1, 0, 20000}))},
+		Providers:  map[string]*schema.Provider{"minikube": NewProvider(mockSuccess(mockClusterClientProperties{t, "TestClusterCreation", 1, 0, 20000, "4096mb", "1"}))},
 		Steps: []resource.TestStep{
 			{
 				Config: testUnitClusterConfig("some_driver", "TestClusterCreation"),
@@ -55,7 +58,7 @@ func TestClusterCreation(t *testing.T) {
 func TestClusterUpdate(t *testing.T) {
 	resource.Test(t, resource.TestCase{
 		IsUnitTest: true,
-		Providers:  map[string]*schema.Provider{"minikube": NewProvider(mockUpdate(mockClusterClientProperties{t, "TestClusterUpdate", 1, 0, 20000}))},
+		Providers:  map[string]*schema.Provider{"minikube": NewProvider(mockUpdate(mockClusterClientProperties{t, "TestClusterUpdate", 1, 0, 20000, "4096mb", "1"}))},
 		Steps: []resource.TestStep{
 			{
 				Config: testUnitClusterConfig("some_driver", "TestClusterUpdate"),
@@ -73,7 +76,7 @@ func TestClusterUpdate(t *testing.T) {
 func TestClusterHA(t *testing.T) {
 	resource.Test(t, resource.TestCase{
 		IsUnitTest: true,
-		Providers:  map[string]*schema.Provider{"minikube": NewProvider(mockSuccess(mockClusterClientProperties{t, "TestClusterCreationHA", 3, 5, 20000}))},
+		Providers:  map[string]*schema.Provider{"minikube": NewProvider(mockSuccess(mockClusterClientProperties{t, "TestClusterCreationHA", 3, 5, 20000, "4096mb", "1"}))},
 		Steps: []resource.TestStep{
 			{
 				Config: testUnitClusterHAConfig("some_driver", "TestClusterCreationHA"),
@@ -85,7 +88,7 @@ func TestClusterHA(t *testing.T) {
 func TestClusterDisk(t *testing.T) {
 	resource.Test(t, resource.TestCase{
 		IsUnitTest: true,
-		Providers:  map[string]*schema.Provider{"minikube": NewProvider(mockSuccess(mockClusterClientProperties{t, "TestClusterCreationDisk", 1, 0, 20480}))},
+		Providers:  map[string]*schema.Provider{"minikube": NewProvider(mockSuccess(mockClusterClientProperties{t, "TestClusterCreationDisk", 1, 0, 20480, "4096mb", "1"}))},
 		Steps: []resource.TestStep{
 			{
 				Config: testUnitClusterDiskConfig("some_driver", "TestClusterCreationDisk"),
@@ -97,7 +100,7 @@ func TestClusterDisk(t *testing.T) {
 func TestClusterWait(t *testing.T) {
 	resource.Test(t, resource.TestCase{
 		IsUnitTest: true,
-		Providers:  map[string]*schema.Provider{"minikube": NewProvider(mockSuccess(mockClusterClientProperties{t, "TestClusterCreationWait", 1, 0, 20000}))},
+		Providers:  map[string]*schema.Provider{"minikube": NewProvider(mockSuccess(mockClusterClientProperties{t, "TestClusterCreationWait", 1, 0, 20000, "4096mb", "1"}))},
 		Steps: []resource.TestStep{
 			{
 				Config: testUnitClusterWaitConfig("some_driver", "TestClusterCreationWait"),
@@ -329,7 +332,7 @@ func TestClusterCreation_HyperV(t *testing.T) {
 func TestClusterNoLimitMemory(t *testing.T) {
 	resource.Test(t, resource.TestCase{
 		IsUnitTest: true,
-		Providers:  map[string]*schema.Provider{"minikube": NewProvider(mockSuccess(mockClusterClientProperties{t, "TestClusterNoLimitMemory", 1, 0, 20000}))},
+		Providers:  map[string]*schema.Provider{"minikube": NewProvider(mockSuccess(mockClusterClientProperties{t, "TestClusterNoLimitMemory", 1, 0, 20000, "no-limit", "1"}))},
 		Steps: []resource.TestStep{
 			{
 				Config: testUnitClusterNoLimitMemoryConfig("some_driver", "TestClusterNoLimitMemory"),
@@ -341,7 +344,7 @@ func TestClusterNoLimitMemory(t *testing.T) {
 func TestClusterMaxMemory(t *testing.T) {
 	resource.Test(t, resource.TestCase{
 		IsUnitTest: true,
-		Providers:  map[string]*schema.Provider{"minikube": NewProvider(mockSuccess(mockClusterClientProperties{t, "TestClusterMaxMemory", 1, 0, 20000}))},
+		Providers:  map[string]*schema.Provider{"minikube": NewProvider(mockSuccess(mockClusterClientProperties{t, "TestClusterMaxMemory", 1, 0, 20000, "max", "1"}))},
 		Steps: []resource.TestStep{
 			{
 				Config: testUnitClusterMaxMemoryConfig("some_driver", "TestClusterMaxMemory"),
@@ -353,7 +356,7 @@ func TestClusterMaxMemory(t *testing.T) {
 func TestClusterNoLimitCPU(t *testing.T) {
 	resource.Test(t, resource.TestCase{
 		IsUnitTest: true,
-		Providers:  map[string]*schema.Provider{"minikube": NewProvider(mockSuccess(mockClusterClientProperties{t, "TestClusterNoLimitCPU", 1, 0, 20000}))},
+		Providers:  map[string]*schema.Provider{"minikube": NewProvider(mockSuccess(mockClusterClientProperties{t, "TestClusterNoLimitCPU", 1, 0, 20000, "4096mb", "no-limit"}))},
 		Steps: []resource.TestStep{
 			{
 				Config: testUnitClusterNoLimitCPUConfig("some_driver", "TestClusterNoLimitCPU"),
@@ -365,7 +368,7 @@ func TestClusterNoLimitCPU(t *testing.T) {
 func TestClusterMaxCPU(t *testing.T) {
 	resource.Test(t, resource.TestCase{
 		IsUnitTest: true,
-		Providers:  map[string]*schema.Provider{"minikube": NewProvider(mockSuccess(mockClusterClientProperties{t, "TestClusterMaxCPU", 1, 0, 20000}))},
+		Providers:  map[string]*schema.Provider{"minikube": NewProvider(mockSuccess(mockClusterClientProperties{t, "TestClusterMaxCPU", 1, 0, 20000, "4096mb", "max"}))},
 		Steps: []resource.TestStep{
 			{
 				Config: testUnitClusterMaxCPUConfig("some_driver", "TestClusterMaxCPU"),
@@ -377,7 +380,7 @@ func TestClusterMaxCPU(t *testing.T) {
 func mockUpdate(props mockClusterClientProperties) schema.ConfigureContextFunc {
 	ctrl := gomock.NewController(props.t)
 
-	mockClusterClient := getBaseMockClient(ctrl, props.name, props.haNodes, props.workerNodes, props.diskSize)
+	mockClusterClient := getBaseMockClient(props.t, ctrl, props.name, props.haNodes, props.workerNodes, props.diskSize, props.memory, props.cpu)
 
 	gomock.InOrder(
 		mockClusterClient.EXPECT().
@@ -414,7 +417,7 @@ func mockUpdate(props mockClusterClientProperties) schema.ConfigureContextFunc {
 func mockSuccess(props mockClusterClientProperties) schema.ConfigureContextFunc {
 	ctrl := gomock.NewController(props.t)
 
-	mockClusterClient := getBaseMockClient(ctrl, props.name, props.haNodes, props.workerNodes, props.diskSize)
+	mockClusterClient := getBaseMockClient(props.t, ctrl, props.name, props.haNodes, props.workerNodes, props.diskSize, props.memory, props.cpu)
 
 	mockClusterClient.EXPECT().
 		GetAddons().
@@ -432,7 +435,7 @@ func mockSuccess(props mockClusterClientProperties) schema.ConfigureContextFunc
 	return configureContext
 }
 
-func getBaseMockClient(ctrl *gomock.Controller, clusterName string, haNodes int, workerNodes int, diskSize int) *lib.MockClusterClient {
+func getBaseMockClient(t *testing.T, ctrl *gomock.Controller, clusterName string, haNodes int, workerNodes int, diskSize int, memory string, cpu string) *lib.MockClusterClient {
 	mockClusterClient := lib.NewMockClusterClient(ctrl)
 
 	os.Mkdir("test_output", 0755)
@@ -472,6 +475,16 @@ func getBaseMockClient(ctrl *gomock.Controller, clusterName string, haNodes int,
 		Worker:            true,
 	}
 
+	mem, err := state_utils.GetMemory(memory)
+	if err != nil {
+		t.Fatalf("Failed to get memory: %v", err)
+	}
+
+	c, err := state_utils.GetCPUs(cpu)
+	if err != nil {
+		t.Fatalf("Failed to get cpu: %v", err)
+	}
+
 	cc := config.ClusterConfig{
 		Name:                    "terraform-provider-minikube-acc",
 		APIServerPort:           clusterSchema["apiserver_port"].Default.(int),
@@ -480,8 +493,8 @@ func getBaseMockClient(ctrl *gomock.Controller, clusterName string, haNodes int,
 		MinikubeISO:             defaultIso,
 		KicBaseImage:            clusterSchema["base_image"].Default.(string),
 		Network:                 clusterSchema["network"].Default.(string),
-		Memory:                  4096,
-		CPUs:                    2,
+		Memory:                  mem,
+		CPUs:                    c,
 		DiskSize:                diskSize,
 		Driver:                  "some_driver",
 		ListenAddress:           clusterSchema["listen_address"].Default.(string),

minikube/schema_cluster.go

@@ -198,6 +198,8 @@ var (
 			ForceNew:			true,
 
 			Default:	"2",
+			StateFunc:	state_utils.CPUConverter(),
+			ValidateDiagFunc:	state_utils.CPUValidator(),
 		},
 
 		"cri_socket": {

minikube/state_utils/cpu.go

@@ -1,10 +1,15 @@
 package state_utils
 
 import (
-	"github.com/scott-the-programmer/terraform-provider-minikube/minikube/lib"
+	"errors"
+	"fmt"
 	"runtime"
 	"strconv"
-	"fmt"
+
+	"github.com/hashicorp/go-cty/cty"
+	"github.com/hashicorp/terraform-plugin-sdk/v2/diag"
+	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema"
+	"github.com/scott-the-programmer/terraform-provider-minikube/minikube/lib"
 )
 
 func GetCPUs(cpuStr string) (int, error) {
@@ -22,3 +27,59 @@ func GetCPUs(cpuStr string) (int, error) {
 	}
 	return cpus, nil
 }
+
+func CPUConverter() schema.SchemaStateFunc {
+	return func(val interface{}) string {
+		result, err := CPUConverterImpl(val)
+		if err != nil {
+			panic(err)
+		}
+		return result
+	}
+}
+
+func CPUConverterImpl(val interface{}) (string, error) {
+	cpuStr, ok := val.(string)
+	if !ok {
+		return "", errors.New("cpu value is not a string")
+	}
+
+	cpus, err := GetCPUs(cpuStr)
+	if err != nil {
+		return "", err
+	}
+
+	return strconv.Itoa(cpus), nil
+}
+
+func CPUValidator() schema.SchemaValidateDiagFunc {
+	return schema.SchemaValidateDiagFunc(func(val interface{}, path cty.Path) diag.Diagnostics {
+		err := CPUValidatorImpl(val)
+		if err != nil {
+			return diag.FromErr(err)
+		}
+		return nil
+	})
+}
+
+func CPUValidatorImpl(val interface{}) error {
+	cpuStr, ok := val.(string)
+	if !ok {
+		return errors.New("cpu value is not a string")
+	}
+
+	if cpuStr == lib.Max || cpuStr == lib.NoLimit {
+		return nil
+	}
+
+	cpus, err := strconv.Atoi(cpuStr)
+	if err != nil {
+		return fmt.Errorf("invalid CPU value: %v", err)
+	}
+
+	if cpus <= 0 {
+		return fmt.Errorf("CPU count must be positive: %d", cpus)
+	}
+
+	return nil
+}