Move functions to the verify package (#7846) (#5583)

* Move functions to the verity package

* Move validation_test.go to the verify package

* Move common_diff_suppression.go to the verify package

* Move common_diff_suppression_test.go to the verify package

* Replace the functions calls

* Add Deprecated doc

* Move common_diff_suppression.go and common_diff_suppression_test.go to the tpgresource package

Signed-off-by: Modular Magician <[email protected]>

Author: modular-magician

.changelog/7846.txt

@@ -0,0 +1,3 @@
+```release-note:none
+
+```

google-beta/appengine_operation.go

@@ -7,12 +7,13 @@ import (
 	"time"
 
 	transport_tpg "github.com/hashicorp/terraform-provider-google-beta/google-beta/transport"
+	"github.com/hashicorp/terraform-provider-google-beta/google-beta/verify"
 
 	"google.golang.org/api/appengine/v1"
 )
 
 var (
-	appEngineOperationIdRegexp = regexp.MustCompile(fmt.Sprintf("apps/%s/operations/(.*)", ProjectRegex))
+	appEngineOperationIdRegexp = regexp.MustCompile(fmt.Sprintf("apps/%s/operations/(.*)", verify.ProjectRegex))
 )
 
 type AppEngineOperationWaiter struct {

google-beta/common_diff_suppress.go

@@ -3,199 +3,135 @@
 package google
 
 import (
-	"crypto/sha256"
-	"encoding/hex"
-	"log"
 	"net"
 	"reflect"
-	"regexp"
-	"strconv"
-	"strings"
-	"time"
 
 	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema"
+	"github.com/hashicorp/terraform-provider-google-beta/google-beta/tpgresource"
 )
 
+// Deprecated: For backward compatibility OptionalPrefixSuppress is still working,
+// but all new code should use OptionalPrefixSuppress in the tpgresource package instead.
 func OptionalPrefixSuppress(prefix string) schema.SchemaDiffSuppressFunc {
-	return func(k, old, new string, d *schema.ResourceData) bool {
-		return prefix+old == new || prefix+new == old
-	}
+	return tpgresource.OptionalPrefixSuppress(prefix)
 }
 
+// Deprecated: For backward compatibility IgnoreMissingKeyInMap is still working,
+// but all new code should use IgnoreMissingKeyInMap in the tpgresource package instead.
 func IgnoreMissingKeyInMap(key string) schema.SchemaDiffSuppressFunc {
-	return func(k, old, new string, d *schema.ResourceData) bool {
-		log.Printf("[DEBUG] - suppressing diff %q with old %q, new %q", k, old, new)
-		if strings.HasSuffix(k, ".%") {
-			oldNum, err := strconv.Atoi(old)
-			if err != nil {
-				log.Printf("[ERROR] could not parse %q as number, no longer attempting diff suppress", old)
-				return false
-			}
-			newNum, err := strconv.Atoi(new)
-			if err != nil {
-				log.Printf("[ERROR] could not parse %q as number, no longer attempting diff suppress", new)
-				return false
-			}
-			return oldNum+1 == newNum
-		} else if strings.HasSuffix(k, "."+key) {
-			return old == ""
-		}
-		return false
-	}
+	return tpgresource.IgnoreMissingKeyInMap(key)
 }
 
+// Deprecated: For backward compatibility OptionalSurroundingSpacesSuppress is still working,
+// but all new code should use OptionalSurroundingSpacesSuppress in the tpgresource package instead.
 func OptionalSurroundingSpacesSuppress(k, old, new string, d *schema.ResourceData) bool {
-	return strings.TrimSpace(old) == strings.TrimSpace(new)
+	return tpgresource.OptionalSurroundingSpacesSuppress(k, old, new, d)
 }
 
+// Deprecated: For backward compatibility EmptyOrDefaultStringSuppress is still working,
+// but all new code should use EmptyOrDefaultStringSuppress in the tpgresource package instead.
 func EmptyOrDefaultStringSuppress(defaultVal string) schema.SchemaDiffSuppressFunc {
-	return func(k, old, new string, d *schema.ResourceData) bool {
-		return (old == "" && new == defaultVal) || (new == "" && old == defaultVal)
-	}
+	return tpgresource.EmptyOrDefaultStringSuppress(defaultVal)
 }
 
+// Deprecated: For backward compatibility IpCidrRangeDiffSuppress is still working,
+// but all new code should use IpCidrRangeDiffSuppress in the tpgresource package instead.
 func IpCidrRangeDiffSuppress(k, old, new string, d *schema.ResourceData) bool {
-	// The range may be a:
-	// A) single IP address (e.g. 10.2.3.4)
-	// B) CIDR format string (e.g. 10.1.2.0/24)
-	// C) netmask (e.g. /24)
-	//
-	// For A) and B), no diff to suppress, they have to match completely.
-	// For C), The API picks a network IP address and this creates a diff of the form:
-	// network_interface.0.alias_ip_range.0.ip_cidr_range: "10.128.1.0/24" => "/24"
-	// We should only compare the mask portion for this case.
-	if len(new) > 0 && new[0] == '/' {
-		oldNetmaskStartPos := strings.LastIndex(old, "/")
-
-		if oldNetmaskStartPos != -1 {
-			oldNetmask := old[strings.LastIndex(old, "/"):]
-			if oldNetmask == new {
-				return true
-			}
-		}
-	}
-
-	return false
+	return tpgresource.IpCidrRangeDiffSuppress(k, old, new, d)
 }
 
+// Deprecated: For backward compatibility Sha256DiffSuppress is still working,
+// but all new code should use Sha256DiffSuppress in the tpgresource package instead.
 // Sha256DiffSuppress
 // if old is the hex-encoded sha256 sum of new, treat them as equal
-func Sha256DiffSuppress(_, old, new string, _ *schema.ResourceData) bool {
-	return hex.EncodeToString(sha256.New().Sum([]byte(old))) == new
+func Sha256DiffSuppress(k, old, new string, d *schema.ResourceData) bool {
+	return tpgresource.Sha256DiffSuppress(k, old, new, d)
 }
 
-func CaseDiffSuppress(_, old, new string, _ *schema.ResourceData) bool {
-	return strings.ToUpper(old) == strings.ToUpper(new)
+// Deprecated: For backward compatibility CaseDiffSuppress is still working,
+// but all new code should use CaseDiffSuppress in the tpgresource package instead.
+func CaseDiffSuppress(k, old, new string, d *schema.ResourceData) bool {
+	return tpgresource.CaseDiffSuppress(k, old, new, d)
 }
 
+// Deprecated: For backward compatibility PortRangeDiffSuppress is still working,
+// but all new code should use PortRangeDiffSuppress in the tpgresource package instead.
 // Port range '80' and '80-80' is equivalent.
 // `old` is read from the server and always has the full range format (e.g. '80-80', '1024-2048').
 // `new` can be either a single port or a port range.
 func PortRangeDiffSuppress(k, old, new string, d *schema.ResourceData) bool {
-	return old == new+"-"+new
+	return tpgresource.PortRangeDiffSuppress(k, old, new, d)
 }
 
+// Deprecated: For backward compatibility Rfc3339TimeDiffSuppress is still working,
+// but all new code should use Rfc3339TimeDiffSuppress in the tpgresource package instead.
 // Single-digit hour is equivalent to hour with leading zero e.g. suppress diff 1:00 => 01:00.
 // Assume either value could be in either format.
 func Rfc3339TimeDiffSuppress(k, old, new string, d *schema.ResourceData) bool {
-	if (len(old) == 4 && "0"+old == new) || (len(new) == 4 && "0"+new == old) {
-		return true
-	}
-	return false
+	return tpgresource.Rfc3339TimeDiffSuppress(k, old, new, d)
 }
 
+// Deprecated: For backward compatibility EmptyOrUnsetBlockDiffSuppress is still working,
+// but all new code should use EmptyOrUnsetBlockDiffSuppress in the tpgresource package instead.
 // Suppress diffs for blocks where one version is completely unset and the other is set
 // to an empty block. This might occur in situations where removing a block completely
 // is impossible (if it's computed or part of an AtLeastOneOf), so instead the user sets
 // its values to empty.
 // NOTE: Using Optional + Computed is *strongly* preferred to this DSF, as it's
 // more well understood and resilient to API changes.
 func EmptyOrUnsetBlockDiffSuppress(k, old, new string, d *schema.ResourceData) bool {
-	o, n := d.GetChange(strings.TrimSuffix(k, ".#"))
-	return EmptyOrUnsetBlockDiffSuppressLogic(k, old, new, o, n)
+	return tpgresource.EmptyOrUnsetBlockDiffSuppress(k, old, new, d)
 }
 
+// Deprecated: For backward compatibility EmptyOrUnsetBlockDiffSuppressLogic is still working,
+// but all new code should use EmptyOrUnsetBlockDiffSuppressLogic in the tpgresource package instead.
 // The core logic for EmptyOrUnsetBlockDiffSuppress, in a format that is more conducive
 // to unit testing.
 func EmptyOrUnsetBlockDiffSuppressLogic(k, old, new string, o, n interface{}) bool {
-	if !strings.HasSuffix(k, ".#") {
-		return false
-	}
-	var l []interface{}
-	if old == "0" && new == "1" {
-		l = n.([]interface{})
-	} else if new == "0" && old == "1" {
-		l = o.([]interface{})
-	} else {
-		// we don't have one set and one unset, so don't suppress the diff
-		return false
-	}
-
-	contents, ok := l[0].(map[string]interface{})
-	if !ok {
-		return false
-	}
-	for _, v := range contents {
-		if !isEmptyValue(reflect.ValueOf(v)) {
-			return false
-		}
-	}
-	return true
+	return tpgresource.EmptyOrUnsetBlockDiffSuppressLogic(k, old, new, o, n)
 }
 
+// Deprecated: For backward compatibility LocationDiffSuppress is still working,
+// but all new code should use LocationDiffSuppress in the tpgresource package instead.
 // Suppress diffs for values that are equivalent except for their use of the words "location"
 // compared to "region" or "zone"
 func LocationDiffSuppress(k, old, new string, d *schema.ResourceData) bool {
-	return locationDiffSuppressHelper(old, new) || locationDiffSuppressHelper(new, old)
+	return tpgresource.LocationDiffSuppress(k, old, new, d)
 }
 
+// Deprecated: For backward compatibility locationDiffSuppressHelper is still working,
+// but all new code should use LocationDiffSuppressHelper in the tpgresource package instead.
 func locationDiffSuppressHelper(a, b string) bool {
-	return strings.Replace(a, "/locations/", "/regions/", 1) == b ||
-		strings.Replace(a, "/locations/", "/zones/", 1) == b
+	return tpgresource.LocationDiffSuppressHelper(a, b)
 }
 
+// Deprecated: For backward compatibility AbsoluteDomainSuppress is still working,
+// but all new code should use AbsoluteDomainSuppress in the tpgresource package instead.
 // For managed SSL certs, if new is an absolute FQDN (trailing '.') but old isn't, treat them as equals.
-func AbsoluteDomainSuppress(k, old, new string, _ *schema.ResourceData) bool {
-	if strings.HasPrefix(k, "managed.0.domains.") {
-		return old == strings.TrimRight(new, ".") || new == strings.TrimRight(old, ".")
-	}
-	return false
+func AbsoluteDomainSuppress(k, old, new string, d *schema.ResourceData) bool {
+	return tpgresource.AbsoluteDomainSuppress(k, old, new, d)
 }
 
+// Deprecated: For backward compatibility TimestampDiffSuppress is still working,
+// but all new code should use TimestampDiffSuppress in the tpgresource package instead.
 func TimestampDiffSuppress(format string) schema.SchemaDiffSuppressFunc {
-	return func(_, old, new string, _ *schema.ResourceData) bool {
-		oldT, err := time.Parse(format, old)
-		if err != nil {
-			return false
-		}
-
-		newT, err := time.Parse(format, new)
-		if err != nil {
-			return false
-		}
-
-		return oldT == newT
-	}
+	return tpgresource.TimestampDiffSuppress(format)
 }
 
+// Deprecated: For backward compatibility InternalIpDiffSuppress is still working,
+// but all new code should use InternalIpDiffSuppress in the tpgresource package instead.
 // suppress diff when saved is Ipv4 format while new is required a reference
 // this happens for an internal ip for Private Services Connect
-func InternalIpDiffSuppress(_, old, new string, _ *schema.ResourceData) bool {
-	return (net.ParseIP(old) != nil) && (net.ParseIP(new) == nil)
+func InternalIpDiffSuppress(k, old, new string, d *schema.ResourceData) bool {
+	return tpgresource.InternalIpDiffSuppress(k, old, new, d)
 }
 
+// Deprecated: For backward compatibility DurationDiffSuppress is still working,
+// but all new code should use DurationDiffSuppress in the tpgresource package instead.
 // Suppress diffs for duration format. ex "60.0s" and "60s" same
 // https://developers.google.com/protocol-buffers/docs/reference/google.protobuf#duration
 func DurationDiffSuppress(k, old, new string, d *schema.ResourceData) bool {
-	oDuration, err := time.ParseDuration(old)
-	if err != nil {
-		return false
-	}
-	nDuration, err := time.ParseDuration(new)
-	if err != nil {
-		return false
-	}
-	return oDuration == nDuration
+	return tpgresource.DurationDiffSuppress(k, old, new, d)
 }
 
 // Use this method when the field accepts either an IP address or a
@@ -211,43 +147,36 @@ func CompareIpAddressOrSelfLinkOrResourceName(_, old, new string, _ *schema.Reso
 	return compareSelfLinkOrResourceName("", old, new, nil)
 }
 
+// Deprecated: For backward compatibility AlwaysDiffSuppress is still working,
+// but all new code should use AlwaysDiffSuppress in the tpgresource package instead.
 // Suppress all diffs, used for Disk.Interface which is a nonfunctional field
-func AlwaysDiffSuppress(_, _, _ string, _ *schema.ResourceData) bool {
-	return true
+func AlwaysDiffSuppress(k, old, new string, d *schema.ResourceData) bool {
+	return tpgresource.AlwaysDiffSuppress(k, old, new, d)
 }
 
 // Use this method when subnet is optioanl and auto_create_subnetworks = true
 // API sometimes choose a subnet so the diff needs to be ignored
 func CompareOptionalSubnet(_, old, new string, _ *schema.ResourceData) bool {
-	if isEmptyValue(reflect.ValueOf(new)) {
+	if tpgresource.IsEmptyValue(reflect.ValueOf(new)) {
 		return true
 	}
 	// otherwise compare as self links
 	return compareSelfLinkOrResourceName("", old, new, nil)
 }
 
+// Deprecated: For backward compatibility LastSlashDiffSuppress is still working,
+// but all new code should use LastSlashDiffSuppress in the tpgresource package instead.
 // Suppress diffs in below cases
 // "https://hello-rehvs75zla-uc.a.run.app/" -> "https://hello-rehvs75zla-uc.a.run.app"
 // "https://hello-rehvs75zla-uc.a.run.app" -> "https://hello-rehvs75zla-uc.a.run.app/"
-func LastSlashDiffSuppress(_, old, new string, _ *schema.ResourceData) bool {
-	if last := len(new) - 1; last >= 0 && new[last] == '/' {
-		new = new[:last]
-	}
-
-	if last := len(old) - 1; last >= 0 && old[last] == '/' {
-		old = old[:last]
-	}
-	return new == old
+func LastSlashDiffSuppress(k, old, new string, d *schema.ResourceData) bool {
+	return tpgresource.LastSlashDiffSuppress(k, old, new, d)
 }
 
+// Deprecated: For backward compatibility ProjectNumberDiffSuppress is still working,
+// but all new code should use ProjectNumberDiffSuppress in the tpgresource package instead.
 // Suppress diffs when the value read from api
 // has the project number instead of the project name
-func ProjectNumberDiffSuppress(_, old, new string, _ *schema.ResourceData) bool {
-	var a2, b2 string
-	reN := regexp.MustCompile("projects/\\d+")
-	re := regexp.MustCompile("projects/[^/]+")
-	replacement := []byte("projects/equal")
-	a2 = string(reN.ReplaceAll([]byte(old), replacement))
-	b2 = string(re.ReplaceAll([]byte(new), replacement))
-	return a2 == b2
+func ProjectNumberDiffSuppress(k, old, new string, d *schema.ResourceData) bool {
+	return tpgresource.ProjectNumberDiffSuppress(k, old, new, d)
 }

google-beta/data_source_google_project.go

@@ -5,6 +5,7 @@ import (
 
 	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema"
 	transport_tpg "github.com/hashicorp/terraform-provider-google-beta/google-beta/transport"
+	"github.com/hashicorp/terraform-provider-google-beta/google-beta/verify"
 )
 
 func DataSourceGoogleProject() *schema.Resource {
@@ -13,7 +14,7 @@ func DataSourceGoogleProject() *schema.Resource {
 
 	addOptionalFieldsToSchema(dsSchema, "project_id")
 
-	dsSchema["project_id"].ValidateFunc = validateDSProjectID()
+	dsSchema["project_id"].ValidateFunc = verify.ValidateDSProjectID()
 	return &schema.Resource{
 		Read:   datasourceGoogleProjectRead,
 		Schema: dsSchema,

google-beta/data_source_google_service_account_access_token.go

@@ -21,7 +21,7 @@ func DataSourceGoogleServiceAccountAccessToken() *schema.Resource {
 			"target_service_account": {
 				Type:         schema.TypeString,
 				Required:     true,
-				ValidateFunc: verify.ValidateRegexp("(" + strings.Join(PossibleServiceAccountNames, "|") + ")"),
+				ValidateFunc: verify.ValidateRegexp("(" + strings.Join(verify.PossibleServiceAccountNames, "|") + ")"),
 			},
 			"access_token": {
 				Type:      schema.TypeString,
@@ -44,13 +44,13 @@ func DataSourceGoogleServiceAccountAccessToken() *schema.Resource {
 				Optional: true,
 				Elem: &schema.Schema{
 					Type:         schema.TypeString,
-					ValidateFunc: verify.ValidateRegexp(ServiceAccountLinkRegex),
+					ValidateFunc: verify.ValidateRegexp(verify.ServiceAccountLinkRegex),
 				},
 			},
 			"lifetime": {
 				Type:         schema.TypeString,
 				Optional:     true,
-				ValidateFunc: validateDuration(), // duration <=3600s; TODO: support validateDuration(min,max)
+				ValidateFunc: verify.ValidateDuration(), // duration <=3600s; TODO: support validateDuration(min,max)
 				Default:      "3600s",
 			},
 		},

google-beta/data_source_google_service_account_id_token.go

@@ -6,7 +6,6 @@ import (
 
 	transport_tpg "github.com/hashicorp/terraform-provider-google-beta/google-beta/transport"
 	"github.com/hashicorp/terraform-provider-google-beta/google-beta/verify"
-
 	iamcredentials "google.golang.org/api/iamcredentials/v1"
 	"google.golang.org/api/idtoken"
 	"google.golang.org/api/option"
@@ -31,14 +30,14 @@ func DataSourceGoogleServiceAccountIdToken() *schema.Resource {
 			"target_service_account": {
 				Type:         schema.TypeString,
 				Optional:     true,
-				ValidateFunc: verify.ValidateRegexp("(" + strings.Join(PossibleServiceAccountNames, "|") + ")"),
+				ValidateFunc: verify.ValidateRegexp("(" + strings.Join(verify.PossibleServiceAccountNames, "|") + ")"),
 			},
 			"delegates": {
 				Type:     schema.TypeSet,
 				Optional: true,
 				Elem: &schema.Schema{
 					Type:         schema.TypeString,
-					ValidateFunc: verify.ValidateRegexp(ServiceAccountLinkRegex),
+					ValidateFunc: verify.ValidateRegexp(verify.ServiceAccountLinkRegex),
 				},
 			},
 			"include_email": {