support waiting for components

Author: scott-the-programmer

minikube/resource_cluster.go

@@ -75,8 +75,8 @@ func resourceClusterUpdate(ctx context.Context, d *schema.ResourceData, m interf
 	if d.HasChange("addons") {
 		config := client.GetConfig()
 		oldAddons, newAddons := d.GetChange("addons")
-		oldAddonStrings := getAddons(oldAddons.(*schema.Set))
-		newAddonStrings := getAddons(newAddons.(*schema.Set))
+		oldAddonStrings := state_utils.SetToSlice(oldAddons.(*schema.Set))
+		newAddonStrings := state_utils.SetToSlice(newAddons.(*schema.Set))
 
 		client.SetConfig(lib.MinikubeClientConfig{
 			ClusterConfig:   config.ClusterConfig,
@@ -248,7 +248,7 @@ func initialiseMinikubeClient(d *schema.ResourceData, m interface{}) (lib.Cluste
 		addons = &schema.Set{}
 	}
 
-	addonStrings := getAddons(addons.(*schema.Set))
+	addonStrings := state_utils.SetToSlice(addons.(*schema.Set))
 
 	defaultIsos, ok := d.GetOk("iso_url")
 	if !ok {
@@ -357,6 +357,12 @@ func initialiseMinikubeClient(d *schema.ResourceData, m interface{}) (lib.Cluste
 		return nil, errors.New("at least 3 nodes is required for high availability")
 	}
 
+	vcs := state_utils.SetToSlice(d.Get("wait").(*schema.Set))
+	vc := make(map[string]bool)
+	for _, c := range vcs {
+		vc[c] = true
+	}
+
 	cc := config.ClusterConfig{
 		Addons:                  addonConfig,
 		APIServerPort:           d.Get("apiserver_port").(int),
@@ -422,6 +428,7 @@ func initialiseMinikubeClient(d *schema.ResourceData, m interface{}) (lib.Cluste
 		GPUs:                  d.Get("gpus").(string),
 		SocketVMnetPath:       d.Get("socket_vmnet_path").(string),
 		SocketVMnetClientPath: d.Get("socket_vmnet_client_path").(string),
+		VerifyComponents:      vc,
 	}
 
 	clusterClient.SetConfig(lib.MinikubeClientConfig{
@@ -441,15 +448,3 @@ func initialiseMinikubeClient(d *schema.ResourceData, m interface{}) (lib.Cluste
 
 	return clusterClient, nil
 }
-
-func getAddons(addons *schema.Set) []string {
-	addonStrings := make([]string, addons.Len())
-	addonObjects := addons.List()
-	for i, v := range addonObjects {
-		addonStrings[i] = v.(string)
-	}
-
-	sort.Strings(addonStrings) //to ensure consistency with TF state
-
-	return addonStrings
-}

minikube/state_utils/slice.go

@@ -38,3 +38,15 @@ func ReadSliceState(slice interface{}) []string {
 
 	return stringSlice
 }
+
+func SetToSlice(s *schema.Set) []string {
+	ss := make([]string, s.Len())
+	so := s.List()
+	for i, v := range so {
+		ss[i] = v.(string)
+	}
+
+	sort.Strings(ss) //to ensure consistency with TF state
+
+	return ss
+}

minikube/state_utils/slice_test.go

@@ -86,3 +86,41 @@ func TestReadSliceState(t *testing.T) {
 		})
 	}
 }
+
+func TestSetToSlice(t *testing.T) {
+	tests := []struct {
+		name     string
+		input    *schema.Set
+		expected []string
+	}{
+		{
+			name:     "Empty set",
+			input:    schema.NewSet(schema.HashString, []interface{}{}),
+			expected: []string{},
+		},
+		{
+			name:     "Set with single item",
+			input:    schema.NewSet(schema.HashString, []interface{}{"apple"}),
+			expected: []string{"apple"},
+		},
+		{
+			name:     "Set with multiple items",
+			input:    schema.NewSet(schema.HashString, []interface{}{"banana", "apple", "cherry"}),
+			expected: []string{"apple", "banana", "cherry"},
+		},
+		{
+			name:     "Set with duplicate items",
+			input:    schema.NewSet(schema.HashString, []interface{}{"apple", "banana", "apple", "cherry"}),
+			expected: []string{"apple", "banana", "cherry"},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			result := SetToSlice(tt.input)
+			if !reflect.DeepEqual(result, tt.expected) {
+				t.Errorf("SetToSlice() = %v, want %v", result, tt.expected)
+			}
+		})
+	}
+}