From 5a4761723ead4811800887dd924345911bda2016 Mon Sep 17 00:00:00 2001 From: Matt Burgess <549318+mattburgess@users.noreply.github.com> Date: Sat, 25 Mar 2023 00:45:13 +0000 Subject: [PATCH] Convert to plugin framework --- .../opensearchserverless/exports_test.go | 6 + .../service_package_gen.go | 6 +- .../opensearchserverless/vpc_endpoint.go | 363 ++++++++++++------ .../opensearchserverless/vpc_endpoint_test.go | 20 +- 4 files changed, 271 insertions(+), 124 deletions(-) create mode 100644 internal/service/opensearchserverless/exports_test.go diff --git a/internal/service/opensearchserverless/exports_test.go b/internal/service/opensearchserverless/exports_test.go new file mode 100644 index 000000000000..bb9a6e4aceb5 --- /dev/null +++ b/internal/service/opensearchserverless/exports_test.go @@ -0,0 +1,6 @@ +package opensearchserverless + +// Exports for use in tests only. +var ( + ResourceVPCEndpoint = newResourceVpcEndpoint +) diff --git a/internal/service/opensearchserverless/service_package_gen.go b/internal/service/opensearchserverless/service_package_gen.go index 669a35f103b1..177db5353e69 100644 --- a/internal/service/opensearchserverless/service_package_gen.go +++ b/internal/service/opensearchserverless/service_package_gen.go @@ -16,7 +16,11 @@ func (p *servicePackage) FrameworkDataSources(ctx context.Context) []*types.Serv } func (p *servicePackage) FrameworkResources(ctx context.Context) []*types.ServicePackageFrameworkResource { - return []*types.ServicePackageFrameworkResource{} + return []*types.ServicePackageFrameworkResource{ + { + Factory: newResourceVpcEndpoint, + }, + } } func (p *servicePackage) SDKDataSources(ctx context.Context) []*types.ServicePackageSDKDataSource { diff --git a/internal/service/opensearchserverless/vpc_endpoint.go b/internal/service/opensearchserverless/vpc_endpoint.go index 11a19b4c2494..984d83e49685 100644 --- a/internal/service/opensearchserverless/vpc_endpoint.go +++ b/internal/service/opensearchserverless/vpc_endpoint.go @@ -3,203 +3,340 @@ package opensearchserverless import ( "context" "errors" + "fmt" "log" "time" "github.com/aws/aws-sdk-go-v2/aws" "github.com/aws/aws-sdk-go-v2/service/opensearchserverless" - "github.com/aws/aws-sdk-go-v2/service/opensearchserverless/types" - "github.com/hashicorp/terraform-plugin-sdk/v2/diag" - "github.com/hashicorp/terraform-plugin-sdk/v2/helper/resource" - "github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema" - "github.com/hashicorp/terraform-plugin-sdk/v2/helper/validation" - "github.com/hashicorp/terraform-provider-aws/internal/conns" + awstypes "github.com/aws/aws-sdk-go-v2/service/opensearchserverless/types" + "github.com/hashicorp/terraform-plugin-framework-timeouts/resource/timeouts" + "github.com/hashicorp/terraform-plugin-framework-validators/setvalidator" + "github.com/hashicorp/terraform-plugin-framework-validators/stringvalidator" + "github.com/hashicorp/terraform-plugin-framework/diag" + "github.com/hashicorp/terraform-plugin-framework/path" + "github.com/hashicorp/terraform-plugin-framework/resource" + "github.com/hashicorp/terraform-plugin-framework/resource/schema" + "github.com/hashicorp/terraform-plugin-framework/schema/validator" + "github.com/hashicorp/terraform-plugin-framework/types" + sdkresource "github.com/hashicorp/terraform-plugin-sdk/v2/helper/resource" "github.com/hashicorp/terraform-provider-aws/internal/create" + "github.com/hashicorp/terraform-provider-aws/internal/errs/fwdiag" "github.com/hashicorp/terraform-provider-aws/internal/flex" + "github.com/hashicorp/terraform-provider-aws/internal/framework" "github.com/hashicorp/terraform-provider-aws/internal/tfresource" "github.com/hashicorp/terraform-provider-aws/names" ) -func ResourceVPCEndpoint() *schema.Resource { - return &schema.Resource{ - CreateWithoutTimeout: resourceVPCEndpointCreate, - ReadWithoutTimeout: resourceVPCEndpointRead, - UpdateWithoutTimeout: resourceVPCEndpointUpdate, - DeleteWithoutTimeout: resourceVPCEndpointDelete, +// @FrameworkResource +func newResourceVpcEndpoint(_ context.Context) (resource.ResourceWithConfigure, error) { + return &resourceVpcEndpoint{}, nil +} - Importer: &schema.ResourceImporter{ - StateContext: schema.ImportStatePassthroughContext, - }, +type resourceVpcEndpointData struct { + ID types.String `tfsdk:"id"` + Name types.String `tfsdk:"name"` + SecurityGroupIds types.Set `tfsdk:"security_group_ids"` + SubnetIds types.Set `tfsdk:"subnet_ids"` + Timeouts timeouts.Value `tfsdk:"timeouts"` + VpcId types.String `tfsdk:"vpc_id"` +} - Timeouts: &schema.ResourceTimeout{ - Create: schema.DefaultTimeout(30 * time.Minute), - Update: schema.DefaultTimeout(30 * time.Minute), - Delete: schema.DefaultTimeout(30 * time.Minute), - }, +const ( + ResNameVPCEndpoint = "VPC Endpoint" +) - Schema: map[string]*schema.Schema{ - "name": { - Type: schema.TypeString, - Required: true, - ValidateFunc: validation.StringLenBetween(3, 32), - ForceNew: true, +type resourceVpcEndpoint struct { + framework.ResourceWithConfigure +} + +func (r *resourceVpcEndpoint) Metadata(_ context.Context, request resource.MetadataRequest, response *resource.MetadataResponse) { + response.TypeName = "aws_opensearchserverless_vpc_endpoint" +} + +func (r *resourceVpcEndpoint) Schema(ctx context.Context, req resource.SchemaRequest, resp *resource.SchemaResponse) { + resp.Schema = schema.Schema{ + Attributes: map[string]schema.Attribute{ + "id": framework.IDAttribute(), + "name": schema.StringAttribute{ + Required: true, + Validators: []validator.String{ + stringvalidator.LengthBetween(3, 32), + }, }, - "security_group_ids": { - Type: schema.TypeSet, - Optional: true, - Computed: true, - MinItems: 1, - MaxItems: 5, - Elem: &schema.Schema{Type: schema.TypeString}, + "security_group_ids": schema.SetAttribute{ + ElementType: types.StringType, + Optional: true, + Computed: true, + Validators: []validator.Set{ + setvalidator.SizeBetween(1, 5), + }, }, - "subnet_ids": { - Type: schema.TypeSet, - Required: true, - MinItems: 1, - MaxItems: 6, - Elem: &schema.Schema{Type: schema.TypeString}, + "subnet_ids": schema.SetAttribute{ + ElementType: types.StringType, + Required: true, + Validators: []validator.Set{ + setvalidator.SizeBetween(1, 6), + }, }, - "vpc_id": { - Type: schema.TypeString, - Required: true, - ForceNew: true, - ValidateFunc: validation.StringLenBetween(1, 255), + "vpc_id": schema.StringAttribute{ + Required: true, + Validators: []validator.String{ + stringvalidator.LengthBetween(1, 255), + }, }, }, + Blocks: map[string]schema.Block{ + "timeouts": timeouts.Block(ctx, timeouts.Opts{ + Create: true, + Update: true, + Delete: true, + }), + }, } } -const ( - ResNameVPCEndpoint = "VPC Endpoint" -) +func (r *resourceVpcEndpoint) Create(ctx context.Context, req resource.CreateRequest, resp *resource.CreateResponse) { + var plan resourceVpcEndpointData + + resp.Diagnostics.Append(req.Plan.Get(ctx, &plan)...) + + if resp.Diagnostics.HasError() { + return + } -func resourceVPCEndpointCreate(ctx context.Context, d *schema.ResourceData, meta interface{}) diag.Diagnostics { - conn := meta.(*conns.AWSClient).OpenSearchServerlessClient() + createTimeout, diags := plan.Timeouts.Create(ctx, 30*time.Minute) + + resp.Diagnostics.Append(diags...) + + if resp.Diagnostics.HasError() { + return + } + + ctx, cancel := context.WithTimeout(ctx, createTimeout) + defer cancel() + + conn := r.Meta().OpenSearchServerlessClient() in := &opensearchserverless.CreateVpcEndpointInput{ - ClientToken: aws.String(resource.UniqueId()), - Name: aws.String(d.Get("name").(string)), - VpcId: aws.String(d.Get("vpc_id").(string)), - SubnetIds: flex.ExpandStringValueSet(d.Get("subnet_ids").(*schema.Set)), + ClientToken: aws.String(sdkresource.UniqueId()), + Name: aws.String(plan.Name.ValueString()), + SubnetIds: flex.ExpandFrameworkStringValueSet(ctx, plan.SubnetIds), + VpcId: aws.String(plan.VpcId.ValueString()), } - if v, ok := d.GetOk("security_group_ids"); ok { - in.SecurityGroupIds = flex.ExpandStringValueSet(v.(*schema.Set)) + if !plan.SecurityGroupIds.IsNull() { + in.SecurityGroupIds = flex.ExpandFrameworkStringValueSet(ctx, plan.SecurityGroupIds) } out, err := conn.CreateVpcEndpoint(ctx, in) if err != nil { - return create.DiagError(names.OpenSearchServerless, create.ErrActionCreating, ResNameVPCEndpoint, d.Get("name").(string), err) + resp.Diagnostics.AddError( + create.ProblemStandardMessage(names.OpenSearchServerless, create.ErrActionCreating, ResNameVPCEndpoint, plan.Name.String(), nil), + err.Error(), + ) + return } - if out == nil || out.CreateVpcEndpointDetail == nil { - return create.DiagError(names.OpenSearchServerless, create.ErrActionCreating, ResNameVPCEndpoint, d.Get("name").(string), errors.New("empty output")) + if _, err := waitVPCEndpointCreated(ctx, conn, *out.CreateVpcEndpointDetail.Id, createTimeout); err != nil { + resp.Diagnostics.AddError( + create.ProblemStandardMessage(names.OpenSearchServerless, create.ErrActionWaitingForCreation, ResNameVPCEndpoint, plan.Name.String(), nil), + err.Error(), + ) + return } - d.SetId(aws.ToString(out.CreateVpcEndpointDetail.Id)) - - if _, err := waitVPCEndpointCreated(ctx, conn, d.Id(), d.Timeout(schema.TimeoutCreate)); err != nil { - return create.DiagError(names.OpenSearchServerless, create.ErrActionWaitingForCreation, ResNameVPCEndpoint, d.Id(), err) + // The create operation only returns the Id and Name so retrieve the newly + // created VPC Endpoint so we can store the possibly computed + // security_group_ids in state + vpcEndpoint, err := findVPCEndpointByID(ctx, conn, *out.CreateVpcEndpointDetail.Id) + if err != nil { + resp.Diagnostics.AddError( + create.ProblemStandardMessage(names.OpenSearchServerless, create.ErrActionChecking, ResNameVPCEndpoint, plan.Name.String(), nil), + err.Error(), + ) + return } - return resourceVPCEndpointRead(ctx, d, meta) + state := plan + resp.Diagnostics.Append(state.refreshFromOutput(ctx, vpcEndpoint)...) + resp.Diagnostics.Append(resp.State.Set(ctx, &state)...) + } -func resourceVPCEndpointRead(ctx context.Context, d *schema.ResourceData, meta interface{}) diag.Diagnostics { - conn := meta.(*conns.AWSClient).OpenSearchServerlessClient() - out, err := findVPCEndpointByID(ctx, conn, d.Id()) +func (r *resourceVpcEndpoint) Read(ctx context.Context, req resource.ReadRequest, resp *resource.ReadResponse) { + conn := r.Meta().OpenSearchServerlessClient() - if !d.IsNewResource() && tfresource.NotFound(err) { - log.Printf("[WARN] OpenSearchServerless VPC Endpoint (%s) not found, removing from state", d.Id()) - d.SetId("") - return nil + var state resourceVpcEndpointData + resp.Diagnostics.Append(req.State.Get(ctx, &state)...) + if resp.Diagnostics.HasError() { + return } - if err != nil { - return create.DiagError(names.OpenSearchServerless, create.ErrActionReading, ResNameVPCEndpoint, d.Id(), err) + out, err := findVPCEndpointByID(ctx, conn, state.ID.ValueString()) + if tfresource.NotFound(err) { + resp.Diagnostics.Append(fwdiag.NewResourceNotFoundWarningDiagnostic(err)) + resp.State.RemoveResource(ctx) + return } - d.Set("name", out.Name) - d.Set("security_group_ids", flex.FlattenStringValueSet(out.SecurityGroupIds)) - d.Set("subnet_ids", flex.FlattenStringValueSet(out.SubnetIds)) - d.Set("vpc_id", out.VpcId) - - return nil + resp.Diagnostics.Append(state.refreshFromOutput(ctx, out)...) + resp.Diagnostics.Append(resp.State.Set(ctx, &state)...) } -func resourceVPCEndpointUpdate(ctx context.Context, d *schema.ResourceData, meta interface{}) diag.Diagnostics { - conn := meta.(*conns.AWSClient).OpenSearchServerlessClient() +func (r *resourceVpcEndpoint) Update(ctx context.Context, req resource.UpdateRequest, resp *resource.UpdateResponse) { + conn := r.Meta().OpenSearchServerlessClient() update := false - in := &opensearchserverless.UpdateVpcEndpointInput{ - ClientToken: aws.String(resource.UniqueId()), - Id: aws.String(d.Id()), + var plan, state resourceVpcEndpointData + resp.Diagnostics.Append(req.State.Get(ctx, &state)...) + resp.Diagnostics.Append(req.Plan.Get(ctx, &plan)...) + if resp.Diagnostics.HasError() { + return + } + + updateTimeout, diags := plan.Timeouts.Update(ctx, 30*time.Minute) + + resp.Diagnostics.Append(diags...) + + if resp.Diagnostics.HasError() { + return } - if d.HasChange("security_group_ids") { - old, new := d.GetChange("security_group_ids") - if add := flex.ExpandStringValueSet(new.(*schema.Set).Difference(old.(*schema.Set))); len(add) > 0 { - in.AddSecurityGroupIds = add + ctx, cancel := context.WithTimeout(ctx, updateTimeout) + defer cancel() + + input := &opensearchserverless.UpdateVpcEndpointInput{ + ClientToken: aws.String(sdkresource.UniqueId()), + Id: aws.String(plan.ID.ValueString()), + } + + newSGs := flex.ExpandFrameworkStringValueSet(ctx, plan.SecurityGroupIds) + if len(newSGs) > 0 && !plan.SecurityGroupIds.Equal(state.SecurityGroupIds) { + oldSGs := flex.ExpandFrameworkStringValueSet(ctx, state.SecurityGroupIds) + if add := newSGs.Difference(oldSGs); len(add) > 0 { + input.AddSecurityGroupIds = add } - if del := flex.ExpandStringValueSet(old.(*schema.Set).Difference(new.(*schema.Set))); len(del) > 0 { - in.RemoveSecurityGroupIds = del + if del := oldSGs.Difference(newSGs); len(del) > 0 { + input.RemoveSecurityGroupIds = del } + update = true } - if d.HasChange("subnet_ids") { - old, new := d.GetChange("subnet_ids") - if add := flex.ExpandStringValueSet(new.(*schema.Set).Difference(old.(*schema.Set))); len(add) > 0 { - in.AddSubnetIds = add + if !plan.SubnetIds.Equal(state.SubnetIds) { + old := flex.ExpandFrameworkStringValueSet(ctx, state.SubnetIds) + new := flex.ExpandFrameworkStringValueSet(ctx, plan.SubnetIds) + + if add := new.Difference(old); len(add) > 0 { + input.AddSubnetIds = add } - if del := flex.ExpandStringValueSet(old.(*schema.Set).Difference(new.(*schema.Set))); len(del) > 0 { - in.RemoveSubnetIds = del + if del := old.Difference(new); len(del) > 0 { + input.RemoveSubnetIds = del } + update = true } if !update { - return nil + return } - log.Printf("[DEBUG] Updating OpenSearchServerless VPC Endpoint (%s): %#v", d.Id(), in) - out, err := conn.UpdateVpcEndpoint(ctx, in) + log.Printf("[DEBUG] Updating OpenSearchServerless VPC Endpoint (%s): %#v", plan.ID.ValueString(), input) + out, err := conn.UpdateVpcEndpoint(ctx, input) if err != nil { - return create.DiagError(names.OpenSearchServerless, create.ErrActionUpdating, ResNameVPCEndpoint, d.Id(), err) + resp.Diagnostics.AddError(fmt.Sprintf("updating VPC Endpoint (%s)", plan.ID.ValueString()), err.Error()) + return } - if _, err := waitVPCEndpointUpdated(ctx, conn, aws.ToString(out.UpdateVpcEndpointDetail.Id), d.Timeout(schema.TimeoutUpdate)); err != nil { - return create.DiagError(names.OpenSearchServerless, create.ErrActionWaitingForUpdate, ResNameVPCEndpoint, d.Id(), err) + if _, err := waitVPCEndpointUpdated(ctx, conn, *out.UpdateVpcEndpointDetail.Id, updateTimeout); err != nil { + resp.Diagnostics.AddError( + create.ProblemStandardMessage(names.OpenSearchServerless, create.ErrActionWaitingForUpdate, ResNameVPCEndpoint, plan.Name.String(), nil), + err.Error(), + ) + return } - return resourceVPCEndpointRead(ctx, d, meta) + // The update operation only returns security_group_ids if those were + // changed so retrieve the updated VPC Endpoint so we can store the + // actual security_group_ids in state + vpcEndpoint, err := findVPCEndpointByID(ctx, conn, *out.UpdateVpcEndpointDetail.Id) + if err != nil { + resp.Diagnostics.AddError( + create.ProblemStandardMessage(names.OpenSearchServerless, create.ErrActionChecking, ResNameVPCEndpoint, plan.Name.String(), nil), + err.Error(), + ) + return + } + resp.Diagnostics.Append(state.refreshFromOutput(ctx, vpcEndpoint)...) + resp.Diagnostics.Append(resp.State.Set(ctx, &state)...) } -func resourceVPCEndpointDelete(ctx context.Context, d *schema.ResourceData, meta interface{}) diag.Diagnostics { - conn := meta.(*conns.AWSClient).OpenSearchServerlessClient() +func (r *resourceVpcEndpoint) Delete(ctx context.Context, req resource.DeleteRequest, resp *resource.DeleteResponse) { + conn := r.Meta().OpenSearchServerlessClient() + + var state resourceVpcEndpointData + resp.Diagnostics.Append(req.State.Get(ctx, &state)...) + if resp.Diagnostics.HasError() { + return + } + + deleteTimeout, diags := state.Timeouts.Delete(ctx, 30*time.Minute) + + resp.Diagnostics.Append(diags...) + + if resp.Diagnostics.HasError() { + return + } - log.Printf("[INFO] Deleting OpenSearchServerless VPC Endpoint %s", d.Id()) + ctx, cancel := context.WithTimeout(ctx, deleteTimeout) + defer cancel() _, err := conn.DeleteVpcEndpoint(ctx, &opensearchserverless.DeleteVpcEndpointInput{ - ClientToken: aws.String(resource.UniqueId()), - Id: aws.String(d.Id()), + ClientToken: aws.String(sdkresource.UniqueId()), + Id: aws.String(state.ID.ValueString()), }) if err != nil { - var nfe *types.ResourceNotFoundException + var nfe *awstypes.ResourceNotFoundException if errors.As(err, &nfe) { - return nil + return } + resp.Diagnostics.AddError( + create.ProblemStandardMessage(names.OpenSearchServerless, create.ErrActionDeleting, ResNameVPCEndpoint, state.Name.String(), nil), + err.Error(), + ) + } - return create.DiagError(names.OpenSearchServerless, create.ErrActionDeleting, ResNameVPCEndpoint, d.Id(), err) + if _, err := waitVPCEndpointDeleted(ctx, conn, state.ID.ValueString(), deleteTimeout); err != nil { + resp.Diagnostics.AddError( + create.ProblemStandardMessage(names.OpenSearchServerless, create.ErrActionWaitingForDeletion, ResNameVPCEndpoint, state.Name.String(), nil), + err.Error(), + ) + return } +} + +func (r *resourceVpcEndpoint) ImportState(ctx context.Context, request resource.ImportStateRequest, response *resource.ImportStateResponse) { + resource.ImportStatePassthroughID(ctx, path.Root("id"), request, response) +} + +// refreshFromOutput writes state data from an AWS response object +func (rd *resourceVpcEndpointData) refreshFromOutput(ctx context.Context, out *awstypes.VpcEndpointDetail) diag.Diagnostics { + var diags diag.Diagnostics - if _, err := waitVPCEndpointDeleted(ctx, conn, d.Id(), d.Timeout(schema.TimeoutDelete)); err != nil { - return create.DiagError(names.OpenSearchServerless, create.ErrActionWaitingForDeletion, ResNameVPCEndpoint, d.Id(), err) + if out == nil { + return diags } - return nil + rd.ID = flex.StringToFramework(ctx, out.Id) + rd.Name = flex.StringToFramework(ctx, out.Name) + rd.SecurityGroupIds = flex.FlattenFrameworkStringValueSet(ctx, out.SecurityGroupIds) + rd.SubnetIds = flex.FlattenFrameworkStringValueSet(ctx, out.SubnetIds) + rd.VpcId = flex.StringToFramework(ctx, out.VpcId) + + return diags } diff --git a/internal/service/opensearchserverless/vpc_endpoint_test.go b/internal/service/opensearchserverless/vpc_endpoint_test.go index 3372f1357d78..b84047cabf1f 100644 --- a/internal/service/opensearchserverless/vpc_endpoint_test.go +++ b/internal/service/opensearchserverless/vpc_endpoint_test.go @@ -23,15 +23,15 @@ func TestAccOpenSearchServerlessVPCEndpoint_basic(t *testing.T) { if testing.Short() { t.Skip("skipping long-running test in short mode") } - + ctx := acctest.Context(t) var vpcendpoint opensearchserverless.BatchGetVpcEndpointOutput rName := sdkacctest.RandomWithPrefix(acctest.ResourcePrefix) resourceName := "aws_opensearchserverless_vpc_endpoint.test" resource.ParallelTest(t, resource.TestCase{ PreCheck: func() { - acctest.PreCheck(t) - acctest.PreCheckPartitionHasService(names.OpenSearchServerlessEndpointID, t) + acctest.PreCheck(ctx, t) + acctest.PreCheckPartitionHasService(t, names.OpenSearchServerlessEndpointID) testAccPreCheck(t) }, ErrorCheck: acctest.ErrorCheck(t, names.OpenSearchServerlessEndpointID), @@ -59,15 +59,15 @@ func TestAccOpenSearchServerlessVPCEndpoint_update(t *testing.T) { if testing.Short() { t.Skip("skipping long-running test in short mode") } - + ctx := acctest.Context(t) var vpcendpoint1, vpcendpoint2, vpcendpoint3 opensearchserverless.BatchGetVpcEndpointOutput rName := sdkacctest.RandomWithPrefix(acctest.ResourcePrefix) resourceName := "aws_opensearchserverless_vpc_endpoint.test" resource.ParallelTest(t, resource.TestCase{ PreCheck: func() { - acctest.PreCheck(t) - acctest.PreCheckPartitionHasService(names.OpenSearchServerlessEndpointID, t) + acctest.PreCheck(ctx, t) + acctest.PreCheckPartitionHasService(t, names.OpenSearchServerlessEndpointID) testAccPreCheck(t) }, ErrorCheck: acctest.ErrorCheck(t, names.OpenSearchServerlessEndpointID), @@ -113,15 +113,15 @@ func TestAccOpenSearchServerlessVPCEndpoint_disappears(t *testing.T) { if testing.Short() { t.Skip("skipping long-running test in short mode") } - + ctx := acctest.Context(t) var vpcendpoint opensearchserverless.BatchGetVpcEndpointOutput rName := sdkacctest.RandomWithPrefix(acctest.ResourcePrefix) resourceName := "aws_opensearchserverless_vpc_endpoint.test" resource.ParallelTest(t, resource.TestCase{ PreCheck: func() { - acctest.PreCheck(t) - acctest.PreCheckPartitionHasService(names.OpenSearchServerlessEndpointID, t) + acctest.PreCheck(ctx, t) + acctest.PreCheckPartitionHasService(t, names.OpenSearchServerlessEndpointID) testAccPreCheck(t) }, ErrorCheck: acctest.ErrorCheck(t, names.OpenSearchServerlessEndpointID), @@ -132,7 +132,7 @@ func TestAccOpenSearchServerlessVPCEndpoint_disappears(t *testing.T) { Config: testAccVPCEndpointConfig_basic(rName), Check: resource.ComposeTestCheckFunc( testAccCheckVPCEndpointExists(resourceName, &vpcendpoint), - acctest.CheckResourceDisappears(acctest.Provider, tfopensearchserverless.ResourceVPCEndpoint(), resourceName), + acctest.CheckFrameworkResourceDisappears(ctx, acctest.Provider, tfopensearchserverless.ResourceVPCEndpoint, resourceName), ), ExpectNonEmptyPlan: true, },