Merge pull request hashicorp#33571 from hashicorp/td-sweeper-fixes

Tech debt: Various sweeper fixes

internal/service/codestarconnections/sweep.go

@@ -15,6 +15,7 @@ import (
 	"github.com/hashicorp/terraform-plugin-testing/helper/resource"
 	"github.com/hashicorp/terraform-provider-aws/internal/sweep"
 	"github.com/hashicorp/terraform-provider-aws/internal/sweep/awsv2"
+	"github.com/hashicorp/terraform-provider-aws/names"
 )
 
 func init() {
@@ -34,6 +35,10 @@ func init() {
 
 func sweepConnections(region string) error {
 	ctx := sweep.Context(region)
+	if region == names.USGovEast1RegionID || region == names.USGovWest1RegionID {
+		log.Printf("[WARN] Skipping CodeStar Connections Connection sweep for region: %s", region)
+		return nil
+	}
 	client, err := sweep.SharedRegionalSweepClient(ctx, region)
 	if err != nil {
 		return fmt.Errorf("error getting client: %w", err)
@@ -75,6 +80,10 @@ func sweepConnections(region string) error {
 
 func sweepHosts(region string) error {
 	ctx := sweep.Context(region)
+	if region == names.USGovEast1RegionID || region == names.USGovWest1RegionID {
+		log.Printf("[WARN] Skipping CodeStar Connections Host sweep for region: %s", region)
+		return nil
+	}
 	client, err := sweep.SharedRegionalSweepClient(ctx, region)
 	if err != nil {
 		return fmt.Errorf("error getting client: %w", err)

internal/service/codestarnotifications/sweep.go

@@ -14,6 +14,7 @@ import (
 	"github.com/aws/aws-sdk-go-v2/service/codestarnotifications"
 	"github.com/hashicorp/terraform-plugin-testing/helper/resource"
 	"github.com/hashicorp/terraform-provider-aws/internal/sweep"
+	"github.com/hashicorp/terraform-provider-aws/internal/sweep/awsv2"
 )
 
 func init() {
@@ -37,7 +38,7 @@ func sweepNotificationRules(region string) error {
 	for pages.HasMorePages() {
 		page, err := pages.NextPage(ctx)
 
-		if sweep.SkipSweepError(err) {
+		if awsv2.SkipSweepError(err) {
 			log.Printf("[WARN] Skipping CodeStar Notification Rule sweep for %s: %s", region, err)
 			return nil
 		}

internal/service/elasticsearch/sweep.go

@@ -65,6 +65,11 @@ func sweepDomains(region string) error {
 
 		name := aws.StringValue(domainInfo.DomainName)
 
+		if engineType := aws.StringValue(domainInfo.EngineType); engineType != elasticsearchservice.EngineTypeElasticsearch {
+			log.Printf("[INFO] Skipping Elasticsearch Domain %s: EngineType = %s", name, engineType)
+			continue
+		}
+
 		// Elasticsearch Domains have regularly gotten stuck in a "being deleted" state
 		// e.g. Deleted and Processing are both true for days in the API
 		// Filter out domains that are Deleted already.

internal/service/emrserverless/sweep.go

@@ -15,6 +15,7 @@ import (
 	"github.com/aws/aws-sdk-go-v2/service/emrserverless/types"
 	"github.com/hashicorp/terraform-plugin-testing/helper/resource"
 	"github.com/hashicorp/terraform-provider-aws/internal/sweep"
+	"github.com/hashicorp/terraform-provider-aws/internal/sweep/awsv2"
 )
 
 func init() {
@@ -38,7 +39,7 @@ func sweepApplications(region string) error {
 	for pages.HasMorePages() {
 		page, err := pages.NextPage(ctx)
 
-		if sweep.SkipSweepError(err) {
+		if awsv2.SkipSweepError(err) {
 			log.Printf("[WARN] Skipping EMR Serverless Application sweep for %s: %s", region, err)
 			return nil
 		}

internal/service/iam/sweep.go

@@ -53,6 +53,8 @@ func init() {
 			"aws_iam_group",
 			"aws_iam_role",
 			"aws_iam_user",
+			"aws_quicksight_group",
+			"aws_quicksight_user",
 		},
 	})
 
@@ -430,6 +432,12 @@ func sweepPolicies(region string) error {
 
 		for _, v := range page.Policies {
 			arn := aws.StringValue(v.Arn)
+
+			if n := aws.Int64Value(v.AttachmentCount); n > 0 {
+				log.Printf("[INFO] Skipping IAM Policy %s: AttachmentCount=%d", arn, n)
+				continue
+			}
+
 			r := ResourcePolicy()
 			d := r.Data(nil)
 			d.SetId(arn)

internal/service/opensearch/inbound_connection_accepter.go

@@ -98,11 +98,10 @@ func resourceInboundConnectionRead(ctx context.Context, d *schema.ResourceData,
 func resourceInboundConnectionDelete(ctx context.Context, d *schema.ResourceData, meta interface{}) diag.Diagnostics {
 	conn := meta.(*conns.AWSClient).OpenSearchConn(ctx)
 
-	req := &opensearchservice.DeleteInboundConnectionInput{
+	log.Printf("[DEBUG] Deleting OpenSearch Inbound Connection: %s", d.Id())
+	_, err := conn.DeleteInboundConnectionWithContext(ctx, &opensearchservice.DeleteInboundConnectionInput{
 		ConnectionId: aws.String(d.Id()),
-	}
-
-	_, err := conn.DeleteInboundConnectionWithContext(ctx, req)
+	})
 
 	if tfawserr.ErrCodeEquals(err, "ResourceNotFoundException") {
 		return nil

internal/service/opensearch/outbound_connection.go

@@ -108,11 +108,10 @@ func resourceOutboundConnectionRead(ctx context.Context, d *schema.ResourceData,
 func resourceOutboundConnectionDelete(ctx context.Context, d *schema.ResourceData, meta interface{}) diag.Diagnostics {
 	conn := meta.(*conns.AWSClient).OpenSearchConn(ctx)
 
-	req := &opensearchservice.DeleteOutboundConnectionInput{
+	log.Printf("[DEBUG] Deleting OpenSearch Outbound Connection: %s", d.Id())
+	_, err := conn.DeleteOutboundConnectionWithContext(ctx, &opensearchservice.DeleteOutboundConnectionInput{
 		ConnectionId: aws.String(d.Id()),
-	}
-
-	_, err := conn.DeleteOutboundConnectionWithContext(ctx, req)
+	})
 
 	if tfawserr.ErrCodeEquals(err, "ResourceNotFoundException") {
 		return nil

internal/service/opensearch/sweep.go

@@ -21,17 +21,29 @@ func init() {
 	resource.AddTestSweepers("aws_opensearch_domain", &resource.Sweeper{
 		Name: "aws_opensearch_domain",
 		F:    sweepDomains,
+		Dependencies: []string{
+			"aws_opensearch_inbound_connection_accepter",
+			"aws_opensearch_outbound_connection",
+		},
+	})
+
+	resource.AddTestSweepers("aws_opensearch_inbound_connection_accepter", &resource.Sweeper{
+		Name: "aws_opensearch_inbound_connection_accepter",
+		F:    sweepInboundConnections,
+	})
+
+	resource.AddTestSweepers("aws_opensearch_outbound_connection", &resource.Sweeper{
+		Name: "aws_opensearch_outbound_connection",
+		F:    sweepOutboundConnections,
 	})
 }
 
 func sweepDomains(region string) error {
 	ctx := sweep.Context(region)
 	client, err := sweep.SharedRegionalSweepClient(ctx, region)
-
 	if err != nil {
 		return fmt.Errorf("error getting client: %w", err)
 	}
-
 	conn := client.OpenSearchConn(ctx)
 	sweepResources := make([]sweep.Sweepable, 0)
 	var errs *multierror.Error
@@ -65,6 +77,11 @@ func sweepDomains(region string) error {
 
 		name := aws.StringValue(domainInfo.DomainName)
 
+		if engineType := aws.StringValue(domainInfo.EngineType); engineType != opensearchservice.EngineTypeOpenSearch {
+			log.Printf("[INFO] Skipping OpenSearch Domain %s: EngineType = %s", name, engineType)
+			continue
+		}
+
 		// OpenSearch Domains have regularly gotten stuck in a "being deleted" state
 		// e.g. Deleted and Processing are both true for days in the API
 		// Filter out domains that are Deleted already.
@@ -101,3 +118,99 @@ func sweepDomains(region string) error {
 
 	return errs.ErrorOrNil()
 }
+
+func sweepInboundConnections(region string) error {
+	ctx := sweep.Context(region)
+	client, err := sweep.SharedRegionalSweepClient(ctx, region)
+	if err != nil {
+		return fmt.Errorf("error getting client: %w", err)
+	}
+	conn := client.OpenSearchConn(ctx)
+	input := &opensearchservice.DescribeInboundConnectionsInput{}
+	sweepResources := make([]sweep.Sweepable, 0)
+
+	err = conn.DescribeInboundConnectionsPagesWithContext(ctx, input, func(page *opensearchservice.DescribeInboundConnectionsOutput, lastPage bool) bool {
+		if page == nil {
+			return !lastPage
+		}
+
+		for _, v := range page.Connections {
+			if aws.StringValue(v.ConnectionStatus.StatusCode) != opensearchservice.InboundConnectionStatusCodeDeleted {
+				continue
+			}
+
+			r := ResourceInboundConnectionAccepter()
+			d := r.Data(nil)
+			d.SetId(aws.StringValue(v.ConnectionId))
+
+			sweepResources = append(sweepResources, sweep.NewSweepResource(r, d, client))
+		}
+
+		return !lastPage
+	})
+
+	if sweep.SkipSweepError(err) {
+		log.Printf("[WARN] Skipping OpenSearch Inbound Connection sweep for %s: %s", region, err)
+		return nil
+	}
+
+	if err != nil {
+		return fmt.Errorf("error listing OpenSearch Inbound Connections: %w", err)
+	}
+
+	err = sweep.SweepOrchestrator(ctx, sweepResources)
+
+	if err != nil {
+		return fmt.Errorf("error sweeping OpenSearch Inbound Connections (%s): %w", region, err)
+	}
+
+	return nil
+}
+
+func sweepOutboundConnections(region string) error {
+	ctx := sweep.Context(region)
+	client, err := sweep.SharedRegionalSweepClient(ctx, region)
+	if err != nil {
+		return fmt.Errorf("error getting client: %w", err)
+	}
+	conn := client.OpenSearchConn(ctx)
+	input := &opensearchservice.DescribeOutboundConnectionsInput{}
+	sweepResources := make([]sweep.Sweepable, 0)
+
+	err = conn.DescribeOutboundConnectionsPagesWithContext(ctx, input, func(page *opensearchservice.DescribeOutboundConnectionsOutput, lastPage bool) bool {
+		if page == nil {
+			return !lastPage
+		}
+
+		for _, v := range page.Connections {
+			if aws.StringValue(v.ConnectionStatus.StatusCode) != opensearchservice.OutboundConnectionStatusCodeDeleted {
+				continue
+			}
+
+			r := ResourceOutboundConnection()
+			d := r.Data(nil)
+			d.SetId(aws.StringValue(v.ConnectionId))
+
+			sweepResources = append(sweepResources, sweep.NewSweepResource(r, d, client))
+		}
+
+		return !lastPage
+	})
+
+	if sweep.SkipSweepError(err) {
+		log.Printf("[WARN] Skipping OpenSearch Outbound Connection sweep for %s: %s", region, err)
+		return nil
+	}
+
+	if err != nil {
+		return fmt.Errorf("error listing OpenSearch Outbound Connections: %w", err)
+	}
+
+	err = sweep.SweepOrchestrator(ctx, sweepResources)
+
+	if err != nil {
+		return fmt.Errorf("error sweeping OpenSearch Outbound Connections (%s): %w", region, err)
+	}
+
+	return nil
+}

internal/service/quicksight/sweep.go

@@ -35,13 +35,20 @@ func init() {
 		Name: "aws_quicksight_folder",
 		F:    sweepFolders,
 	})
+	resource.AddTestSweepers("aws_quicksight_group", &resource.Sweeper{
+		Name: "aws_quicksight_group",
+		F:    sweepGroups,
+	})
 	resource.AddTestSweepers("aws_quicksight_template", &resource.Sweeper{
 		Name: "aws_quicksight_template",
 		F:    sweepTemplates,
 	})
 	resource.AddTestSweepers("aws_quicksight_user", &resource.Sweeper{
 		Name: "aws_quicksight_user",
 		F:    sweepUsers,
+		Dependencies: []string{
+			"aws_quicksight_group",
+		},
 	})
 }
 
@@ -50,6 +57,10 @@ const (
 	acctestResourcePrefix = "tf-acc-test"
 )
 
+// TODO
+// TODO Use paginated listers.
+// TODO
+
 func sweepDashboards(region string) error {
 	ctx := sweep.Context(region)
 	client, err := sweep.SharedRegionalSweepClient(ctx, region)
@@ -248,7 +259,52 @@ func sweepFolders(region string) error {
 	}
 
 	return nil
+}
+
+func sweepGroups(region string) error {
+	ctx := sweep.Context(region)
+	client, err := sweep.SharedRegionalSweepClient(ctx, region)
+
+	if err != nil {
+		return fmt.Errorf("getting client: %w", err)
+	}
+
+	conn := client.QuickSightConn(ctx)
+	awsAccountId := client.AccountID
+	sweepResources := make([]sweep.Sweepable, 0)
+
+	input := &quicksight.ListGroupsInput{
+		AwsAccountId: aws.String(awsAccountId),
+		Namespace:    aws.String(DefaultUserNamespace),
+	}
 
+	out, err := conn.ListGroupsWithContext(ctx, input)
+	for _, user := range out.GroupList {
+		groupname := aws.StringValue(user.GroupName)
+		if !strings.HasPrefix(groupname, acctestResourcePrefix) {
+			continue
+		}
+
+		r := ResourceGroup()
+		d := r.Data(nil)
+		d.SetId(fmt.Sprintf("%s/%s/%s", awsAccountId, DefaultUserNamespace, groupname))
+
+		sweepResources = append(sweepResources, sweep.NewSweepResource(r, d, client))
+	}
+
+	if skipSweepUserError(err) {
+		log.Printf("[WARN] Skipping QuickSight Group sweep for %s: %s", region, err)
+		return nil
+	}
+	if err != nil {
+		return fmt.Errorf("listing QuickSight Groups: %w", err)
+	}
+
+	if err := sweep.SweepOrchestrator(ctx, sweepResources); err != nil {
+		return fmt.Errorf("sweeping QuickSight Groups for %s: %w", region, err)
+	}
+
+	return nil
 }
 
 func sweepTemplates(region string) error {