Add resolver_endpoint_type argument to aws_route53_resolver_endpoint

internal/service/route53resolver/endpoint.go

@@ -86,6 +86,12 @@ func ResourceEndpoint() *schema.Resource {
 				Optional:     true,
 				ValidateFunc: validResolverName,
 			},
+			"resolver_endpoint_type": {
+				Type:         schema.TypeString,
+				Optional:     true,
+				Computed:     true,
+				ValidateFunc: validation.StringInSlice(route53resolver.ResolverEndpointType_Values(), false),
+			},
 			"security_group_ids": {
 				Type:     schema.TypeSet,
 				Required: true,
@@ -123,6 +129,10 @@ func resourceEndpointCreate(ctx context.Context, d *schema.ResourceData, meta in
 		input.Name = aws.String(v.(string))
 	}
 
+	if v, ok := d.GetOk("resolver_endpoint_type"); ok {
+		input.ResolverEndpointType = aws.String(v.(string))
+	}
+
 	output, err := conn.CreateResolverEndpointWithContext(ctx, input)
 
 	if err != nil {
@@ -158,6 +168,7 @@ func resourceEndpointRead(ctx context.Context, d *schema.ResourceData, meta inte
 	d.Set("direction", ep.Direction)
 	d.Set("host_vpc_id", ep.HostVPCId)
 	d.Set("name", ep.Name)
+	d.Set("resolver_endpoint_type", ep.ResolverEndpointType)
 	d.Set("security_group_ids", aws.StringValueSlice(ep.SecurityGroupIds))
 
 	ipAddresses, err := findResolverEndpointIPAddressesByID(ctx, conn, d.Id())
@@ -230,6 +241,21 @@ func resourceEndpointUpdate(ctx context.Context, d *schema.ResourceData, meta in
 		}
 	}
 
+	if d.HasChange("resolver_endpoint_type") {
+		_, err := conn.UpdateResolverEndpointWithContext(ctx, &route53resolver.UpdateResolverEndpointInput{
+			ResolverEndpointType: aws.String(d.Get("resolver_endpoint_type").(string)),
+			ResolverEndpointId:   aws.String(d.Id()),
+		})
+
+		if err != nil {
+			return diag.Errorf("updating Route53 Resolver Endpoint (%s): %s", d.Id(), err)
+		}
+
+		if _, err := waitEndpointUpdated(ctx, conn, d.Id(), d.Timeout(schema.TimeoutUpdate)); err != nil {
+			return diag.Errorf("waiting for Route53 Resolver Endpoint (%s) update: %s", d.Id(), err)
+		}
+	}
+
 	return resourceEndpointRead(ctx, d, meta)
 }
 

internal/service/route53resolver/endpoint_data_source.go

@@ -58,6 +58,10 @@ func DataSourceEndpoint() *schema.Resource {
 				Type:     schema.TypeString,
 				Optional: true,
 			},
+			"resolver_endpoint_type": {
+				Type:     schema.TypeString,
+				Computed: true,
+			},
 			"status": {
 				Type:     schema.TypeString,
 				Computed: true,
@@ -116,6 +120,7 @@ func dataSourceEndpointRead(ctx context.Context, d *schema.ResourceData, meta in
 	d.Set("direction", ep.Direction)
 	d.Set("name", ep.Name)
 	d.Set("resolver_endpoint_id", ep.Id)
+	d.Set("resolver_endpoint_type", ep.ResolverEndpointType)
 	d.Set("status", ep.Status)
 	d.Set("vpc_id", ep.HostVPCId)
 

internal/service/route53resolver/endpoint_data_source_test.go

@@ -32,6 +32,7 @@ func TestAccRoute53ResolverEndpointDataSource_basic(t *testing.T) {
 					resource.TestCheckResourceAttrPair(datasourceName, "ip_addresses.#", resourceName, "ip_address.#"),
 					resource.TestCheckResourceAttrPair(datasourceName, "name", resourceName, "name"),
 					resource.TestCheckResourceAttrPair(datasourceName, "resolver_endpoint_id", resourceName, "id"),
+					resource.TestCheckResourceAttr(resourceName, "resolver_endpoint_type", "IPV4"),
 					resource.TestCheckResourceAttrPair(datasourceName, "vpc_id", resourceName, "host_vpc_id"),
 				),
 			},
@@ -60,6 +61,7 @@ func TestAccRoute53ResolverEndpointDataSource_filter(t *testing.T) {
 					resource.TestCheckResourceAttrPair(datasourceName, "ip_addresses.#", resourceName, "ip_address.#"),
 					resource.TestCheckResourceAttrPair(datasourceName, "name", resourceName, "name"),
 					resource.TestCheckResourceAttrPair(datasourceName, "resolver_endpoint_id", resourceName, "id"),
+					resource.TestCheckResourceAttr(resourceName, "resolver_endpoint_type", "IPV4"),
 					resource.TestCheckResourceAttrPair(datasourceName, "vpc_id", resourceName, "host_vpc_id"),
 				),
 			},

internal/service/route53resolver/endpoint_test.go

@@ -18,14 +18,31 @@ import (
 	"github.com/hashicorp/terraform-provider-aws/internal/tfresource"
 )
 
-func TestAccRoute53ResolverEndpoint_basic(t *testing.T) {
+func TestAccRoute53ResolverEndpoint_serial(t *testing.T) {
+	t.Parallel()
+
+	testCases := map[string]map[string]func(t *testing.T){
+		"ResolverEndpoint": {
+			"basic":                      testAccResolverEndpoint_basic,
+			"disappears":                 testAccResolverEndpoint_disappears,
+			"tags":                       testAccResolverEndpoint_tags,
+			"updateOutbound":             testAccResolverEndpoint_updateOutbound,
+			"updateResolverEndpointType": testAccResolverEndpoint_updateResolverEndpointType,
+			"ipv6":                       testAccResolverEndpoint_ipv6,
+		},
+	}
+
+	acctest.RunSerialTests2Levels(t, testCases, 0)
+}
+
+func testAccResolverEndpoint_basic(t *testing.T) {
 	ctx := acctest.Context(t)
 	var ep route53resolver.ResolverEndpoint
 	resourceName := "aws_route53_resolver_endpoint.test"
 	vpcResourceName := "aws_vpc.test"
 	rName := sdkacctest.RandomWithPrefix(acctest.ResourcePrefix)
 
-	resource.ParallelTest(t, resource.TestCase{
+	resource.Test(t, resource.TestCase{
 		PreCheck:                 func() { acctest.PreCheck(ctx, t); testAccPreCheck(ctx, t) },
 		ErrorCheck:               acctest.ErrorCheck(t, route53resolver.EndpointsID),
 		ProtoV5ProviderFactories: acctest.ProtoV5ProviderFactories,
@@ -53,13 +70,13 @@ func TestAccRoute53ResolverEndpoint_basic(t *testing.T) {
 	})
 }
 
-func TestAccRoute53ResolverEndpoint_disappears(t *testing.T) {
+func testAccResolverEndpoint_disappears(t *testing.T) {
 	ctx := acctest.Context(t)
 	var ep route53resolver.ResolverEndpoint
 	resourceName := "aws_route53_resolver_endpoint.test"
 	rName := sdkacctest.RandomWithPrefix(acctest.ResourcePrefix)
 
-	resource.ParallelTest(t, resource.TestCase{
+	resource.Test(t, resource.TestCase{
 		PreCheck:                 func() { acctest.PreCheck(ctx, t); testAccPreCheck(ctx, t) },
 		ErrorCheck:               acctest.ErrorCheck(t, route53resolver.EndpointsID),
 		ProtoV5ProviderFactories: acctest.ProtoV5ProviderFactories,
@@ -77,13 +94,13 @@ func TestAccRoute53ResolverEndpoint_disappears(t *testing.T) {
 	})
 }
 
-func TestAccRoute53ResolverEndpoint_tags(t *testing.T) {
+func testAccResolverEndpoint_tags(t *testing.T) {
 	ctx := acctest.Context(t)
 	var ep route53resolver.ResolverEndpoint
 	resourceName := "aws_route53_resolver_endpoint.test"
 	rName := sdkacctest.RandomWithPrefix(acctest.ResourcePrefix)
 
-	resource.ParallelTest(t, resource.TestCase{
+	resource.Test(t, resource.TestCase{
 		PreCheck:                 func() { acctest.PreCheck(ctx, t); testAccPreCheck(ctx, t) },
 		ErrorCheck:               acctest.ErrorCheck(t, route53resolver.EndpointsID),
 		ProtoV5ProviderFactories: acctest.ProtoV5ProviderFactories,
@@ -123,15 +140,15 @@ func TestAccRoute53ResolverEndpoint_tags(t *testing.T) {
 	})
 }
 
-func TestAccRoute53ResolverEndpoint_updateOutbound(t *testing.T) {
+func testAccResolverEndpoint_updateOutbound(t *testing.T) {
 	ctx := acctest.Context(t)
 	var ep route53resolver.ResolverEndpoint
 	resourceName := "aws_route53_resolver_endpoint.test"
 	rName := sdkacctest.RandomWithPrefix(acctest.ResourcePrefix)
 	initialName := sdkacctest.RandomWithPrefix(acctest.ResourcePrefix)
 	updatedName := sdkacctest.RandomWithPrefix(acctest.ResourcePrefix)
 
-	resource.ParallelTest(t, resource.TestCase{
+	resource.Test(t, resource.TestCase{
 		PreCheck:                 func() { acctest.PreCheck(ctx, t); testAccPreCheck(ctx, t) },
 		ErrorCheck:               acctest.ErrorCheck(t, route53resolver.EndpointsID),
 		ProtoV5ProviderFactories: acctest.ProtoV5ProviderFactories,
@@ -159,6 +176,78 @@ func TestAccRoute53ResolverEndpoint_updateOutbound(t *testing.T) {
 	})
 }
 
+func testAccResolverEndpoint_updateResolverEndpointType(t *testing.T) {
+	ctx := acctest.Context(t)
+	var ep route53resolver.ResolverEndpoint
+	resourceName := "aws_route53_resolver_endpoint.test"
+	rName := sdkacctest.RandomWithPrefix(acctest.ResourcePrefix)
+	initialResolverEndpointType := "IPV4"
+	updatedResolverEndpointType := "DUALSTACK"
+
+	resource.Test(t, resource.TestCase{
+		PreCheck:                 func() { acctest.PreCheck(ctx, t); testAccPreCheck(ctx, t) },
+		ErrorCheck:               acctest.ErrorCheck(t, route53resolver.EndpointsID),
+		ProtoV5ProviderFactories: acctest.ProtoV5ProviderFactories,
+		CheckDestroy:             testAccCheckEndpointDestroy(ctx),
+		Steps: []resource.TestStep{
+			{
+				Config: testAccEndpointConfig_ResolverEndpointType(rName, initialResolverEndpointType),
+				Check: resource.ComposeTestCheckFunc(
+					testAccCheckEndpointExists(ctx, resourceName, &ep),
+					resource.TestCheckResourceAttr(resourceName, "direction", "INBOUND"),
+					resource.TestCheckResourceAttr(resourceName, "ip_address.#", "3"),
+					resource.TestCheckResourceAttr(resourceName, "resolver_endpoint_type", initialResolverEndpointType),
+				),
+			},
+			{
+				Config: testAccEndpointConfig_updatedResolverEndpointType(rName, updatedResolverEndpointType),
+				Check: resource.ComposeTestCheckFunc(
+					testAccCheckEndpointExists(ctx, resourceName, &ep),
+					resource.TestCheckResourceAttr(resourceName, "direction", "INBOUND"),
+					resource.TestCheckResourceAttr(resourceName, "ip_address.#", "3"),
+					resource.TestCheckResourceAttr(resourceName, "resolver_endpoint_type", updatedResolverEndpointType),
+				),
+			},
+		},
+	})
+}
+
+func testAccResolverEndpoint_ipv6(t *testing.T) {
+	ctx := acctest.Context(t)
+	var ep route53resolver.ResolverEndpoint
+	resourceName := "aws_route53_resolver_endpoint.test"
+	vpcResourceName := "aws_vpc.test"
+	rName := sdkacctest.RandomWithPrefix(acctest.ResourcePrefix)
+
+	resource.Test(t, resource.TestCase{
+		PreCheck:                 func() { acctest.PreCheck(ctx, t); testAccPreCheck(ctx, t) },
+		ErrorCheck:               acctest.ErrorCheck(t, route53resolver.EndpointsID),
+		ProtoV5ProviderFactories: acctest.ProtoV5ProviderFactories,
+		CheckDestroy:             testAccCheckEndpointDestroy(ctx),
+		Steps: []resource.TestStep{
+			{
+				Config: testAccEndpointConfig_ipv6(rName),
+				Check: resource.ComposeAggregateTestCheckFunc(
+					testAccCheckEndpointExists(ctx, resourceName, &ep),
+					resource.TestCheckResourceAttrSet(resourceName, "arn"),
+					resource.TestCheckResourceAttr(resourceName, "direction", "INBOUND"),
+					resource.TestCheckResourceAttrPair(resourceName, "host_vpc_id", vpcResourceName, "id"),
+					resource.TestCheckResourceAttr(resourceName, "ip_address.#", "3"),
+					resource.TestCheckResourceAttr(resourceName, "name", ""),
+					resource.TestCheckResourceAttr(resourceName, "resolver_endpoint_type", "IPV6"),
+					resource.TestCheckResourceAttr(resourceName, "security_group_ids.#", "2"),
+					resource.TestCheckResourceAttr(resourceName, "tags.%", "0"),
+				),
+			},
+			{
+				ResourceName:      resourceName,
+				ImportState:       true,
+				ImportStateVerify: true,
+			},
+		},
+	})
+}
+
 func testAccCheckEndpointDestroy(ctx context.Context) resource.TestCheckFunc {
 	return func(s *terraform.State) error {
 		conn := acctest.Provider.Meta().(*conns.AWSClient).Route53ResolverConn(ctx)
@@ -230,6 +319,7 @@ func testAccEndpointConfig_base(rName string) string {
 	return acctest.ConfigCompose(acctest.ConfigAvailableAZsNoOptIn(), fmt.Sprintf(`
 resource "aws_vpc" "test" {
   cidr_block           = "10.0.0.0/16"
+  assign_generated_ipv6_cidr_block = true
   enable_dns_support   = true
   enable_dns_hostnames = true
 
@@ -239,11 +329,15 @@ resource "aws_vpc" "test" {
 }
 
 resource "aws_subnet" "test" {
-  count = 3
+  count = 6
 
-  vpc_id            = aws_vpc.test.id
-  availability_zone = data.aws_availability_zones.available.names[count.index]
-  cidr_block        = cidrsubnet(aws_vpc.test.cidr_block, 8, count.index)
+  vpc_id                                         = aws_vpc.test.id
+  availability_zone                              = data.aws_availability_zones.available.names[count.index %% 3]
+  cidr_block                                     = count.index <= 2 ? cidrsubnet(aws_vpc.test.cidr_block, 8, count.index) : null
+  ipv6_native                                    = count.index > 2 ? true : false
+  ipv6_cidr_block                                = cidrsubnet(aws_vpc.test.ipv6_cidr_block, 8, count.index)
+  assign_ipv6_address_on_creation                = count.index > 2 ? true : false
+  enable_resource_name_dns_aaaa_record_on_launch = count.index > 2 ? true : false
 
   tags = {
     Name = %[1]q
@@ -380,3 +474,75 @@ resource "aws_route53_resolver_endpoint" "test" {
 }
 `, name))
 }
+
+func testAccEndpointConfig_ResolverEndpointType(rName, ResolverEndpointType string) string {
+	return acctest.ConfigCompose(testAccEndpointConfig_base(rName), fmt.Sprintf(`
+resource "aws_route53_resolver_endpoint" "test" {
+  direction = "INBOUND"
+
+  security_group_ids = aws_security_group.test[*].id
+
+  ip_address {
+    subnet_id = aws_subnet.test[0].id
+  }
+
+  ip_address {
+    subnet_id = aws_subnet.test[1].id
+  }
+
+  ip_address {
+    subnet_id = aws_subnet.test[2].id
+  }
+
+  resolver_endpoint_type = %[1]q
+}
+`, ResolverEndpointType))
+}
+
+func testAccEndpointConfig_updatedResolverEndpointType(rName, ResolverEndpointType string) string {
+	return acctest.ConfigCompose(testAccEndpointConfig_base(rName), fmt.Sprintf(`
+resource "aws_route53_resolver_endpoint" "test" {
+  direction = "INBOUND"
+
+  security_group_ids = aws_security_group.test[*].id
+
+  ip_address {
+    subnet_id = aws_subnet.test[0].id
+  }
+
+  ip_address {
+    subnet_id = aws_subnet.test[1].id
+  }
+
+  ip_address {
+    subnet_id = aws_subnet.test[2].id
+  }
+
+  resolver_endpoint_type = %[1]q
+}
+`, ResolverEndpointType))
+}
+
+func testAccEndpointConfig_ipv6(rName string) string {
+	return acctest.ConfigCompose(testAccEndpointConfig_base(rName), `
+resource "aws_route53_resolver_endpoint" "test" {
+  direction = "INBOUND"
+
+  security_group_ids = aws_security_group.test[*].id
+
+  ip_address {
+    subnet_id = aws_subnet.test[3].id
+  }
+
+  ip_address {
+    subnet_id = aws_subnet.test[4].id
+  }
+
+  ip_address {
+    subnet_id = aws_subnet.test[5].id
+  }
+
+  resolver_endpoint_type = "IPV6"
+}
+`)
+}

website/docs/d/route53_resolver_endpoint.html.markdown

@@ -41,6 +41,7 @@ In addition to all arguments above, the following attributes are exported:
 * `arn` - Computed ARN of the Route53 Resolver Endpoint.
 * `direction` - Direction of the queries to or from the Resolver Endpoint .
 * `ip_addresses` - List of IPaddresses that have been associated with the Resolver Endpoint.
+* `resolver_endpoint_type` - The Resolver endpoint IP address type.
 * `status` - Current status of the Resolver Endpoint.
 * `vpc_id` - ID of the Host VPC that the Resolver Endpoint resides in.
 

website/docs/r/route53_resolver_endpoint.html.markdown

@@ -48,6 +48,7 @@ or `OUTBOUND` (resolver forwards DNS queries from the DNS service for a VPC to y
 to your network (for outbound endpoints) or on the way from your network to your VPCs (for inbound endpoints). Described below.
 * `security_group_ids` - (Required) The ID of one or more security groups that you want to use to control access to this VPC.
 * `name` - (Optional) The friendly name of the Route 53 Resolver endpoint.
+* `resolver_endpoint_type` - (Optional) The Resolver endpoint IP address type. The possible values are `IPV4`, `IPV6` and `DUALSTACK`.
 * `tags` - (Optional) A map of tags to assign to the resource. If configured with a provider [`default_tags` configuration block](https://registry.terraform.io/providers/hashicorp/aws/latest/docs#default_tags-configuration-block) present, tags with matching keys will overwrite those defined at the provider-level.
 
 The `ip_address` object supports the following: