Revert "Set ForceSendFields for boolean/integer values explicitly set to false/0 (#3385)" (#3627)

* Revert "Set ForceSendFields for boolean/integer values explicitly set to false/0 (#3385)"

This reverts commit 89fcf94.

* -

* cleanup

* -

* -

Author: tanmay-db

clusters/resource_cluster.go

@@ -656,11 +656,13 @@ func resourceClusterUpdate(ctx context.Context, d *schema.ResourceData, c *commo
 
 		// We prefer to use the resize API in cases when only the number of
 		// workers is changed because a resizing cluster can still serve queries
+
 		if isNumWorkersResizeForNonAutoscalingCluster ||
 			isAutoScalingToNonAutoscalingResize {
 			_, err = clusters.Resize(ctx, compute.ResizeCluster{
-				ClusterId:  clusterId,
-				NumWorkers: cluster.NumWorkers,
+				ClusterId:       clusterId,
+				NumWorkers:      cluster.NumWorkers,
+				ForceSendFields: []string{"NumWorkers"},
 			})
 			if err != nil {
 				return err
@@ -676,6 +678,7 @@ func resourceClusterUpdate(ctx context.Context, d *schema.ResourceData, c *commo
 			if err != nil {
 				return err
 			}
+			cluster.ForceSendFields = []string{"NumWorkers"}
 			_, err = clusters.Edit(ctx, cluster)
 		}
 		if err != nil {

common/force_send_fields.go

@@ -0,0 +1,71 @@
+package common
+
+import (
+	"fmt"
+	"reflect"
+	"strings"
+
+	"golang.org/x/exp/slices"
+)
+
+// SetForceSendFields adds any fields specified in the `fields` parameter to the ForceSendFields field of the
+// request structure if they are present in the resource state. The provided fields must match the JSON tag
+// for some field in the request structure. This ensures that fields explicitly set to the zero value of its
+// type (e.g. `0` for an `int`) will be serialized and sent to the platform.
+//
+// This function requires that the request structure has a `ForceSendFields` field of type `[]string`. If not,
+// it panics with an appropriate error message.
+func SetForceSendFields(req any, d attributeGetter, fields []string) {
+	rv := reflect.ValueOf(req)
+	if rv.Kind() != reflect.Ptr {
+		panic("request argument to setForceSendFields must be a pointer")
+	}
+	rv = rv.Elem()
+	forceSendFieldsField := rv.FieldByName("ForceSendFields")
+	if !forceSendFieldsField.IsValid() {
+		panic("request argument to setForceSendFields must have ForceSendFields field")
+	}
+	forceSendFields, ok := forceSendFieldsField.Interface().([]string)
+	if !ok {
+		panic(fmt.Errorf("request argument to setForceSendFields must have ForceSendFields field of type []string (got %s)", forceSendFieldsField.Type()))
+	}
+	fs := listAllFields(rv)
+	for _, fieldName := range fields {
+		found := false
+		var structField reflect.StructField
+		for _, f := range fs {
+			fn := chooseFieldName(f.sf)
+			if fn != "-" && fn == fieldName {
+				found = true
+				structField = f.sf
+				break
+			}
+		}
+		if !found {
+			allFieldNames := make([]string, 0)
+			for _, f := range fs {
+				fn := chooseFieldName(f.sf)
+				if fn == "-" || fn == "force_send_fields" {
+					continue
+				}
+				allFieldNames = append(allFieldNames, fn)
+			}
+			panic(fmt.Errorf("unexpected field %s not found in request structure, expected one of: %s", fieldName, strings.Join(allFieldNames, ", ")))
+		}
+		// Check if the field was ever set, even to the zero value of the type.
+		// Technically we should probably check this based on the the TF schema
+		// for this field, but this is a reasonable approximation.
+		v, ok := d.GetOkExists(fieldName)
+		if !(ok && isZeroValueOfType(v)) {
+			continue
+		}
+		if !slices.Contains[[]string, string](forceSendFields, structField.Name) {
+			forceSendFields = append(forceSendFields, structField.Name)
+		}
+	}
+	forceSendFieldsField.Set(reflect.ValueOf(forceSendFields))
+}
+
+func isZeroValueOfType(v any) bool {
+	return reflect.ValueOf(v).IsZero()
+}

common/force_send_fields_test.go

@@ -0,0 +1,93 @@
+package common
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func expectPanic(t *testing.T, message string) func() {
+	return func() {
+		r := recover()
+		if r == nil {
+			t.Errorf("expected panic: %s", message)
+		}
+		if str, ok := r.(string); ok && str != message {
+			t.Errorf("expected panic: %s, got: %v", message, r)
+		}
+		if err, ok := r.(error); ok && err.Error() != message {
+			t.Errorf("expected panic: %s, got: %v", message, r)
+		}
+	}
+}
+
+func TestSetForceSendFields_RequestMustBePointer(t *testing.T) {
+	defer expectPanic(t, "request argument to setForceSendFields must be a pointer")()
+
+	SetForceSendFields(1, nil, nil)
+}
+
+type noForceSendFields struct {
+	A string `json:"a"`
+}
+
+func TestSetForceSendFields_RequestMustHaveForceSendFields(t *testing.T) {
+	defer expectPanic(t, "request argument to setForceSendFields must have ForceSendFields field")()
+
+	SetForceSendFields(&noForceSendFields{}, nil, nil)
+}
+
+type incorrectForceSendFields struct {
+	A               string `json:"a"`
+	ForceSendFields int    `json:"force_send_fields"`
+}
+
+func TestSetForceSendFields_RequestMustHaveForceSendFieldsWithCorrectType(t *testing.T) {
+	defer expectPanic(t, "request argument to setForceSendFields must have ForceSendFields field of type []string (got int)")()
+
+	SetForceSendFields(&incorrectForceSendFields{}, nil, nil)
+}
+
+type withForceSendFields struct {
+	A               string   `json:"a"`
+	B               string   `json:"-"`
+	ForceSendFields []string `json:"force_send_fields"`
+}
+
+func TestSetForceSendFields_NoFields(t *testing.T) {
+	req := &withForceSendFields{}
+	SetForceSendFields(req, nil, nil)
+	assert.Len(t, req.ForceSendFields, 0)
+}
+
+func TestSetForceSendFields_ForceAWhenPresent(t *testing.T) {
+	req := &withForceSendFields{}
+	SetForceSendFields(req, data{"a": ""}, []string{"a"})
+	assert.Len(t, req.ForceSendFields, 1)
+	assert.Equal(t, "A", req.ForceSendFields[0])
+}
+
+func TestSetForceSendFields_DoNotForceAWhenAbsent(t *testing.T) {
+	req := &withForceSendFields{}
+	SetForceSendFields(req, data{}, []string{"a"})
+	assert.Len(t, req.ForceSendFields, 0)
+}
+
+func TestSetForceSendFields_DoNotDuplicate(t *testing.T) {
+	req := &withForceSendFields{ForceSendFields: []string{"A"}}
+	SetForceSendFields(req, data{"a": ""}, []string{"a"})
+	assert.Len(t, req.ForceSendFields, 1)
+	assert.Equal(t, "A", req.ForceSendFields[0])
+}
+
+func TestSetForceSendFields_CannotForceNonJsonFields(t *testing.T) {
+	defer expectPanic(t, "unexpected field b not found in request structure, expected one of: a")()
+	req := &withForceSendFields{}
+	SetForceSendFields(req, data{"b": ""}, []string{"b"})
+}
+
+func TestSetForceSendFields_CannotForceUnknownFields(t *testing.T) {
+	defer expectPanic(t, "unexpected field c not found in request structure, expected one of: a")()
+	req := &withForceSendFields{}
+	SetForceSendFields(req, data{"b": ""}, []string{"c"})
+}