Relocate Valid4ByteAsn function to common lib, add to CloudWAN Network Policy Doc Data Source

.changelog/27305.txt

@@ -0,0 +1,3 @@
+```release-note:note
+Add plan-time validation for `aws_networkmanager_core_network_policy_document.core_network_configuration.edge_locations[].asn`
+```

internal/service/ec2/transitgateway_connect_peer.go

@@ -50,7 +50,7 @@ func ResourceTransitGatewayConnectPeer() *schema.Resource {
 				Optional:     true,
 				Computed:     true,
 				ForceNew:     true,
-				ValidateFunc: valid4ByteASN,
+				ValidateFunc: verify.Valid4ByteASNString,
 			},
 			"inside_cidr_blocks": {
 				Type:     schema.TypeSet,

internal/service/ec2/validate.go

@@ -64,18 +64,3 @@ func validAmazonSideASN(v interface{}, k string) (ws []string, errors []error) {
 	}
 	return
 }
-
-func valid4ByteASN(v interface{}, k string) (ws []string, errors []error) {
-	value := v.(string)
-
-	asn, err := strconv.ParseInt(value, 10, 64)
-	if err != nil {
-		errors = append(errors, fmt.Errorf("%q (%q) must be a 64-bit integer", k, v))
-		return
-	}
-
-	if asn < 0 || asn > 4294967295 {
-		errors = append(errors, fmt.Errorf("%q (%q) must be in the range 0 to 4294967295", k, v))
-	}
-	return
-}

internal/service/ec2/validate_test.go

@@ -74,34 +74,3 @@ func TestValidAmazonSideASN(t *testing.T) {
 		}
 	}
 }
-
-func TestValid4ByteASN(t *testing.T) {
-	validAsns := []string{
-		"0",
-		"1",
-		"65534",
-		"65535",
-		"4294967294",
-		"4294967295",
-	}
-	for _, v := range validAsns {
-		_, errors := valid4ByteASN(v, "bgp_asn")
-		if len(errors) != 0 {
-			t.Fatalf("%q should be a valid ASN: %q", v, errors)
-		}
-	}
-
-	invalidAsns := []string{
-		"-1",
-		"ABCDEFG",
-		"",
-		"4294967296",
-		"9999999999",
-	}
-	for _, v := range invalidAsns {
-		_, errors := valid4ByteASN(v, "bgp_asn")
-		if len(errors) == 0 {
-			t.Fatalf("%q should be an invalid ASN", v)
-		}
-	}
-}

internal/service/ec2/vpnsite_customer_gateway.go

@@ -37,7 +37,7 @@ func ResourceCustomerGateway() *schema.Resource {
 				Type:         schema.TypeString,
 				Required:     true,
 				ForceNew:     true,
-				ValidateFunc: valid4ByteASN,
+				ValidateFunc: verify.Valid4ByteASNString,
 			},
 			"certificate_arn": {
 				Type:         schema.TypeString,

internal/service/networkmanager/core_network_policy_document_data_source.go

@@ -160,8 +160,9 @@ func DataSourceCoreNetworkPolicyDocument() *schema.Resource {
 										ValidateFunc: verify.ValidRegionName,
 									},
 									"asn": {
-										Type:     schema.TypeInt,
-										Optional: true,
+										Type:         schema.TypeInt,
+										Optional:     true,
+										ValidateFunc: verify.Valid4ByteASN,
 									},
 									"inside_cidr_blocks": {
 										Type:     schema.TypeList,

internal/verify/validate.go

@@ -20,6 +20,27 @@ var accountIDRegexp = regexp.MustCompile(`^(aws|aws-managed|\d{12})$`)
 var partitionRegexp = regexp.MustCompile(`^aws(-[a-z]+)*$`)
 var regionRegexp = regexp.MustCompile(`^[a-z]{2}(-[a-z]+)+-\d$`)
 
+func Valid4ByteASN(v interface{}, k string) (ws []string, errors []error) {
+	stringValue := strconv.Itoa(v.(int))
+
+	return Valid4ByteASNString(stringValue, k)
+}
+
+func Valid4ByteASNString(v interface{}, k string) (ws []string, errors []error) {
+	value := v.(string)
+
+	asn, err := strconv.ParseInt(value, 10, 64)
+	if err != nil {
+		errors = append(errors, fmt.Errorf("%q (%q) must be a 64-bit integer", k, v))
+		return
+	}
+
+	if asn < 0 || asn > 4294967295 {
+		errors = append(errors, fmt.Errorf("%q (%q) must be in the range 0 to 4294967295", k, v))
+	}
+	return
+}
+
 func ValidARN(v interface{}, k string) (ws []string, errors []error) {
 	value := v.(string)
 

internal/verify/validate_test.go

@@ -9,6 +9,66 @@ import (
 	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/validation"
 )
 
+func TestValid4ByteAsn(t *testing.T) {
+	validAsns := []int{
+		0,
+		1,
+		65534,
+		65535,
+		4294967294,
+		4294967295,
+	}
+	for _, v := range validAsns {
+		_, errors := Valid4ByteASN(v, "bgp_asn")
+		if len(errors) != 0 {
+			t.Fatalf("%q should be a valid ASN: %q", v, errors)
+		}
+	}
+
+	invalidAsns := []int{
+		-1,
+		4294967296,
+		9999999999,
+	}
+	for _, v := range invalidAsns {
+		_, errors := Valid4ByteASN(v, "bgp_asn")
+		if len(errors) == 0 {
+			t.Fatalf("%q should be an invalid ASN", v)
+		}
+	}
+}
+
+func TestValid4ByteASNString(t *testing.T) {
+	validAsns := []string{
+		"0",
+		"1",
+		"65534",
+		"65535",
+		"4294967294",
+		"4294967295",
+	}
+	for _, v := range validAsns {
+		_, errors := Valid4ByteASNString(v, "bgp_asn")
+		if len(errors) != 0 {
+			t.Fatalf("%q should be a valid ASN: %q", v, errors)
+		}
+	}
+
+	invalidAsns := []string{
+		"-1",
+		"ABCDEFG",
+		"",
+		"4294967296",
+		"9999999999",
+	}
+	for _, v := range invalidAsns {
+		_, errors := Valid4ByteASNString(v, "bgp_asn")
+		if len(errors) == 0 {
+			t.Fatalf("%q should be an invalid ASN", v)
+		}
+	}
+}
+
 func TestValidTypeStringNullableBoolean(t *testing.T) {
 	testCases := []struct {
 		val         interface{}