From 1c3bdec608c2d79d34f43ad2f4bfd618002ffaca Mon Sep 17 00:00:00 2001 From: Kit Ewbank Date: Thu, 22 Jun 2023 14:01:22 -0400 Subject: [PATCH 1/4] Add 'awsbase.ErrCodeEquals', AWS SDK for Go v2 variants of helper in v2/awsv1shim/tfawserr. --- errors.go | 26 ++++-- errors_test.go | 180 ++++++++++++++++++++++++++++++++++++++++++ internal/errs/errs.go | 21 +++++ 3 files changed, 221 insertions(+), 6 deletions(-) create mode 100644 errors_test.go create mode 100644 internal/errs/errs.go diff --git a/errors.go b/errors.go index aaebeb9a..9d250e17 100644 --- a/errors.go +++ b/errors.go @@ -4,9 +4,9 @@ package awsbase import ( - "errors" - + smithy "github.com/aws/smithy-go" "github.com/hashicorp/aws-sdk-go-base/v2/internal/config" + "github.com/hashicorp/aws-sdk-go-base/v2/internal/errs" ) // CannotAssumeRoleError occurs when AssumeRole cannot complete. @@ -14,8 +14,7 @@ type CannotAssumeRoleError = config.CannotAssumeRoleError // IsCannotAssumeRoleError returns true if the error contains the CannotAssumeRoleError type. func IsCannotAssumeRoleError(err error) bool { - var e CannotAssumeRoleError - return errors.As(err, &e) + return errs.IsA[CannotAssumeRoleError](err) } // NoValidCredentialSourcesError occurs when all credential lookup methods have been exhausted without results. @@ -23,6 +22,21 @@ type NoValidCredentialSourcesError = config.NoValidCredentialSourcesError // IsNoValidCredentialSourcesError returns true if the error contains the NoValidCredentialSourcesError type. func IsNoValidCredentialSourcesError(err error) bool { - var e NoValidCredentialSourcesError - return errors.As(err, &e) + return errs.IsA[NoValidCredentialSourcesError](err) +} + +// AWS SDK for Go v2 variants of helpers in v2/awsv1shim/tfawserr. + +// ErrCodeEquals returns true if the error matches all these conditions: +// - err is of type smithy.APIError +// - Error.Code() equals one of the passed codes +func ErrCodeEquals(err error, codes ...string) bool { + if apiErr, ok := errs.As[smithy.APIError](err); ok { + for _, code := range codes { + if apiErr.ErrorCode() == code { + return true + } + } + } + return false } diff --git a/errors_test.go b/errors_test.go new file mode 100644 index 00000000..0370effd --- /dev/null +++ b/errors_test.go @@ -0,0 +1,180 @@ +// Copyright (c) HashiCorp, Inc. +// SPDX-License-Identifier: MPL-2.0 + +package awsbase + +import ( + "fmt" + "testing" + + "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/service/sts/types" + smithy "github.com/aws/smithy-go" +) + +func TestIsCannotAssumeRoleError(t *testing.T) { + testCases := []struct { + Name string + Err error + Expected bool + }{ + { + Name: "nil error", + }, + { + Name: "Top-level NoValidCredentialSourcesError", + Err: NoValidCredentialSourcesError{}, + }, + { + Name: "Top-level CannotAssumeRoleError", + Err: CannotAssumeRoleError{}, + Expected: true, + }, + { + Name: "Nested CannotAssumeRoleError", + Err: fmt.Errorf("test: %w", CannotAssumeRoleError{}), + Expected: true, + }, + } + + for _, testCase := range testCases { + testCase := testCase + + t.Run(testCase.Name, func(t *testing.T) { + got := IsCannotAssumeRoleError(testCase.Err) + + if got != testCase.Expected { + t.Errorf("got %t, expected %t", got, testCase.Expected) + } + }) + } +} + +func TestIsNoValidCredentialSourcesError(t *testing.T) { + testCases := []struct { + Name string + Err error + Expected bool + }{ + { + Name: "nil error", + }, + { + Name: "Top-level CannotAssumeRoleError", + Err: CannotAssumeRoleError{}, + }, + { + Name: "Top-level NoValidCredentialSourcesError", + Err: NoValidCredentialSourcesError{}, + Expected: true, + }, + { + Name: "Nested NoValidCredentialSourcesError", + Err: fmt.Errorf("test: %w", NoValidCredentialSourcesError{}), + Expected: true, + }, + } + + for _, testCase := range testCases { + testCase := testCase + + t.Run(testCase.Name, func(t *testing.T) { + got := IsNoValidCredentialSourcesError(testCase.Err) + + if got != testCase.Expected { + t.Errorf("got %t, expected %t", got, testCase.Expected) + } + }) + } +} + +func TestErrCodeEquals(t *testing.T) { + testCases := []struct { + Name string + Err error + Codes []string + Expected bool + }{ + { + Name: "nil error", + }, + { + Name: "Top-level CannotAssumeRoleError", + Err: CannotAssumeRoleError{}, + }, + { + Name: "Top-level smithy.GenericAPIError matching first code", + Err: &smithy.GenericAPIError{Code: "TestCode", Message: "TestMessage"}, + Codes: []string{"TestCode"}, + Expected: true, + }, + { + Name: "Top-level smithy.GenericAPIError matching last code", + Err: &smithy.GenericAPIError{Code: "TestCode", Message: "TestMessage"}, + Codes: []string{"NotMatching", "TestCode"}, + Expected: true, + }, + { + Name: "Top-level smithy.GenericAPIError no code", + Err: &smithy.GenericAPIError{Code: "TestCode", Message: "TestMessage"}, + }, + { + Name: "Top-level smithy.GenericAPIError non-matching codes", + Err: &smithy.GenericAPIError{Code: "TestCode", Message: "TestMessage"}, + Codes: []string{"NotMatching", "AlsoNotMatching"}, + }, + { + Name: "Wrapped smithy.GenericAPIError matching first code", + Err: fmt.Errorf("test: %w", &smithy.GenericAPIError{Code: "TestCode", Message: "TestMessage"}), + Codes: []string{"TestCode"}, + Expected: true, + }, + { + Name: "Wrapped smithy.GenericAPIError matching last code", + Err: fmt.Errorf("test: %w", &smithy.GenericAPIError{Code: "TestCode", Message: "TestMessage"}), + Codes: []string{"NotMatching", "TestCode"}, + Expected: true, + }, + { + Name: "Wrapped smithy.GenericAPIError non-matching codes", + Err: fmt.Errorf("test: %w", &smithy.GenericAPIError{Code: "TestCode", Message: "TestMessage"}), + Codes: []string{"NotMatching", "AlsoNotMatching"}, + }, + { + Name: "Top-level sts ExpiredTokenException matching first code", + Err: &types.ExpiredTokenException{ErrorCodeOverride: aws.String("TestCode"), Message: aws.String("TestMessage")}, + Codes: []string{"TestCode"}, + Expected: true, + }, + { + Name: "Top-level sts ExpiredTokenException matching last code", + Err: &types.ExpiredTokenException{ErrorCodeOverride: aws.String("TestCode"), Message: aws.String("TestMessage")}, + Codes: []string{"NotMatching", "TestCode"}, + Expected: true, + }, + { + Name: "Wrapped sts ExpiredTokenException matching first code", + Err: fmt.Errorf("test: %w", &types.ExpiredTokenException{ErrorCodeOverride: aws.String("TestCode"), Message: aws.String("TestMessage")}), + Codes: []string{"TestCode"}, + Expected: true, + }, + { + Name: "Wrapped sts ExpiredTokenException matching last code", + Err: fmt.Errorf("test: %w", &types.ExpiredTokenException{ErrorCodeOverride: aws.String("TestCode"), Message: aws.String("TestMessage")}), + Codes: []string{"NotMatching", "TestCode"}, + Expected: true, + }, + } + + for _, testCase := range testCases { + testCase := testCase + + t.Run(testCase.Name, func(t *testing.T) { + got := ErrCodeEquals(testCase.Err, testCase.Codes...) + + if got != testCase.Expected { + t.Errorf("got %t, expected %t", got, testCase.Expected) + } + }) + } +} diff --git a/internal/errs/errs.go b/internal/errs/errs.go new file mode 100644 index 00000000..ab6017d9 --- /dev/null +++ b/internal/errs/errs.go @@ -0,0 +1,21 @@ +// Copyright (c) HashiCorp, Inc. +// SPDX-License-Identifier: MPL-2.0 + +package errs + +import ( + "errors" +) + +// IsA indicates whether an error matches an error type. +func IsA[T error](err error) bool { + _, ok := As[T](err) + return ok +} + +// As is equivalent to errors.As(), but returns the value in-line. +func As[T error](err error) (T, bool) { + var as T + ok := errors.As(err, &as) + return as, ok +} From e6b68a1cce777243599da2a9138bf02ab8bde6e0 Mon Sep 17 00:00:00 2001 From: Graham Davison Date: Thu, 22 Jun 2023 14:59:41 -0700 Subject: [PATCH 2/4] Moves `ErrCodeEquals` to `tfawserr` --- errors.go | 17 ------- errors_test.go | 95 ------------------------------------ tfawserr/awserr.go | 23 +++++++++ tfawserr/awserr_test.go | 105 ++++++++++++++++++++++++++++++++++++++++ 4 files changed, 128 insertions(+), 112 deletions(-) create mode 100644 tfawserr/awserr.go create mode 100644 tfawserr/awserr_test.go diff --git a/errors.go b/errors.go index 9d250e17..e12af673 100644 --- a/errors.go +++ b/errors.go @@ -4,7 +4,6 @@ package awsbase import ( - smithy "github.com/aws/smithy-go" "github.com/hashicorp/aws-sdk-go-base/v2/internal/config" "github.com/hashicorp/aws-sdk-go-base/v2/internal/errs" ) @@ -24,19 +23,3 @@ type NoValidCredentialSourcesError = config.NoValidCredentialSourcesError func IsNoValidCredentialSourcesError(err error) bool { return errs.IsA[NoValidCredentialSourcesError](err) } - -// AWS SDK for Go v2 variants of helpers in v2/awsv1shim/tfawserr. - -// ErrCodeEquals returns true if the error matches all these conditions: -// - err is of type smithy.APIError -// - Error.Code() equals one of the passed codes -func ErrCodeEquals(err error, codes ...string) bool { - if apiErr, ok := errs.As[smithy.APIError](err); ok { - for _, code := range codes { - if apiErr.ErrorCode() == code { - return true - } - } - } - return false -} diff --git a/errors_test.go b/errors_test.go index 0370effd..c36b315c 100644 --- a/errors_test.go +++ b/errors_test.go @@ -6,10 +6,6 @@ package awsbase import ( "fmt" "testing" - - "github.com/aws/aws-sdk-go-v2/aws" - "github.com/aws/aws-sdk-go-v2/service/sts/types" - smithy "github.com/aws/smithy-go" ) func TestIsCannotAssumeRoleError(t *testing.T) { @@ -87,94 +83,3 @@ func TestIsNoValidCredentialSourcesError(t *testing.T) { }) } } - -func TestErrCodeEquals(t *testing.T) { - testCases := []struct { - Name string - Err error - Codes []string - Expected bool - }{ - { - Name: "nil error", - }, - { - Name: "Top-level CannotAssumeRoleError", - Err: CannotAssumeRoleError{}, - }, - { - Name: "Top-level smithy.GenericAPIError matching first code", - Err: &smithy.GenericAPIError{Code: "TestCode", Message: "TestMessage"}, - Codes: []string{"TestCode"}, - Expected: true, - }, - { - Name: "Top-level smithy.GenericAPIError matching last code", - Err: &smithy.GenericAPIError{Code: "TestCode", Message: "TestMessage"}, - Codes: []string{"NotMatching", "TestCode"}, - Expected: true, - }, - { - Name: "Top-level smithy.GenericAPIError no code", - Err: &smithy.GenericAPIError{Code: "TestCode", Message: "TestMessage"}, - }, - { - Name: "Top-level smithy.GenericAPIError non-matching codes", - Err: &smithy.GenericAPIError{Code: "TestCode", Message: "TestMessage"}, - Codes: []string{"NotMatching", "AlsoNotMatching"}, - }, - { - Name: "Wrapped smithy.GenericAPIError matching first code", - Err: fmt.Errorf("test: %w", &smithy.GenericAPIError{Code: "TestCode", Message: "TestMessage"}), - Codes: []string{"TestCode"}, - Expected: true, - }, - { - Name: "Wrapped smithy.GenericAPIError matching last code", - Err: fmt.Errorf("test: %w", &smithy.GenericAPIError{Code: "TestCode", Message: "TestMessage"}), - Codes: []string{"NotMatching", "TestCode"}, - Expected: true, - }, - { - Name: "Wrapped smithy.GenericAPIError non-matching codes", - Err: fmt.Errorf("test: %w", &smithy.GenericAPIError{Code: "TestCode", Message: "TestMessage"}), - Codes: []string{"NotMatching", "AlsoNotMatching"}, - }, - { - Name: "Top-level sts ExpiredTokenException matching first code", - Err: &types.ExpiredTokenException{ErrorCodeOverride: aws.String("TestCode"), Message: aws.String("TestMessage")}, - Codes: []string{"TestCode"}, - Expected: true, - }, - { - Name: "Top-level sts ExpiredTokenException matching last code", - Err: &types.ExpiredTokenException{ErrorCodeOverride: aws.String("TestCode"), Message: aws.String("TestMessage")}, - Codes: []string{"NotMatching", "TestCode"}, - Expected: true, - }, - { - Name: "Wrapped sts ExpiredTokenException matching first code", - Err: fmt.Errorf("test: %w", &types.ExpiredTokenException{ErrorCodeOverride: aws.String("TestCode"), Message: aws.String("TestMessage")}), - Codes: []string{"TestCode"}, - Expected: true, - }, - { - Name: "Wrapped sts ExpiredTokenException matching last code", - Err: fmt.Errorf("test: %w", &types.ExpiredTokenException{ErrorCodeOverride: aws.String("TestCode"), Message: aws.String("TestMessage")}), - Codes: []string{"NotMatching", "TestCode"}, - Expected: true, - }, - } - - for _, testCase := range testCases { - testCase := testCase - - t.Run(testCase.Name, func(t *testing.T) { - got := ErrCodeEquals(testCase.Err, testCase.Codes...) - - if got != testCase.Expected { - t.Errorf("got %t, expected %t", got, testCase.Expected) - } - }) - } -} diff --git a/tfawserr/awserr.go b/tfawserr/awserr.go new file mode 100644 index 00000000..7c4b4721 --- /dev/null +++ b/tfawserr/awserr.go @@ -0,0 +1,23 @@ +// Copyright (c) HashiCorp, Inc. +// SPDX-License-Identifier: MPL-2.0 + +package tfawserr + +import ( + smithy "github.com/aws/smithy-go" + "github.com/hashicorp/aws-sdk-go-base/v2/internal/errs" +) + +// ErrCodeEquals returns true if the error matches all these conditions: +// - err is of type smithy.APIError +// - Error.Code() equals one of the passed codes +func ErrCodeEquals(err error, codes ...string) bool { + if apiErr, ok := errs.As[smithy.APIError](err); ok { + for _, code := range codes { + if apiErr.ErrorCode() == code { + return true + } + } + } + return false +} diff --git a/tfawserr/awserr_test.go b/tfawserr/awserr_test.go new file mode 100644 index 00000000..73498388 --- /dev/null +++ b/tfawserr/awserr_test.go @@ -0,0 +1,105 @@ +// Copyright (c) HashiCorp, Inc. +// SPDX-License-Identifier: MPL-2.0 + +package tfawserr + +import ( + "fmt" + "testing" + + "github.com/aws/aws-sdk-go-v2/service/sts/types" + "github.com/aws/aws-sdk-go/aws" + smithy "github.com/aws/smithy-go" + awsbase "github.com/hashicorp/aws-sdk-go-base/v2" +) + +func TestErrCodeEquals(t *testing.T) { + testCases := []struct { + Name string + Err error + Codes []string + Expected bool + }{ + { + Name: "nil error", + }, + { + Name: "Top-level CannotAssumeRoleError", + Err: awsbase.CannotAssumeRoleError{}, + }, + { + Name: "Top-level smithy.GenericAPIError matching first code", + Err: &smithy.GenericAPIError{Code: "TestCode", Message: "TestMessage"}, + Codes: []string{"TestCode"}, + Expected: true, + }, + { + Name: "Top-level smithy.GenericAPIError matching last code", + Err: &smithy.GenericAPIError{Code: "TestCode", Message: "TestMessage"}, + Codes: []string{"NotMatching", "TestCode"}, + Expected: true, + }, + { + Name: "Top-level smithy.GenericAPIError no code", + Err: &smithy.GenericAPIError{Code: "TestCode", Message: "TestMessage"}, + }, + { + Name: "Top-level smithy.GenericAPIError non-matching codes", + Err: &smithy.GenericAPIError{Code: "TestCode", Message: "TestMessage"}, + Codes: []string{"NotMatching", "AlsoNotMatching"}, + }, + { + Name: "Wrapped smithy.GenericAPIError matching first code", + Err: fmt.Errorf("test: %w", &smithy.GenericAPIError{Code: "TestCode", Message: "TestMessage"}), + Codes: []string{"TestCode"}, + Expected: true, + }, + { + Name: "Wrapped smithy.GenericAPIError matching last code", + Err: fmt.Errorf("test: %w", &smithy.GenericAPIError{Code: "TestCode", Message: "TestMessage"}), + Codes: []string{"NotMatching", "TestCode"}, + Expected: true, + }, + { + Name: "Wrapped smithy.GenericAPIError non-matching codes", + Err: fmt.Errorf("test: %w", &smithy.GenericAPIError{Code: "TestCode", Message: "TestMessage"}), + Codes: []string{"NotMatching", "AlsoNotMatching"}, + }, + { + Name: "Top-level sts ExpiredTokenException matching first code", + Err: &types.ExpiredTokenException{ErrorCodeOverride: aws.String("TestCode"), Message: aws.String("TestMessage")}, + Codes: []string{"TestCode"}, + Expected: true, + }, + { + Name: "Top-level sts ExpiredTokenException matching last code", + Err: &types.ExpiredTokenException{ErrorCodeOverride: aws.String("TestCode"), Message: aws.String("TestMessage")}, + Codes: []string{"NotMatching", "TestCode"}, + Expected: true, + }, + { + Name: "Wrapped sts ExpiredTokenException matching first code", + Err: fmt.Errorf("test: %w", &types.ExpiredTokenException{ErrorCodeOverride: aws.String("TestCode"), Message: aws.String("TestMessage")}), + Codes: []string{"TestCode"}, + Expected: true, + }, + { + Name: "Wrapped sts ExpiredTokenException matching last code", + Err: fmt.Errorf("test: %w", &types.ExpiredTokenException{ErrorCodeOverride: aws.String("TestCode"), Message: aws.String("TestMessage")}), + Codes: []string{"NotMatching", "TestCode"}, + Expected: true, + }, + } + + for _, testCase := range testCases { + testCase := testCase + + t.Run(testCase.Name, func(t *testing.T) { + got := ErrCodeEquals(testCase.Err, testCase.Codes...) + + if got != testCase.Expected { + t.Errorf("got %t, expected %t", got, testCase.Expected) + } + }) + } +} From e5db2870398893e239eb50a030d1ec8584eb1f15 Mon Sep 17 00:00:00 2001 From: Graham Davison Date: Thu, 22 Jun 2023 15:03:36 -0700 Subject: [PATCH 3/4] Test cleanup --- tfawserr/awserr_test.go | 54 ++++++++++++++++------------------------- 1 file changed, 21 insertions(+), 33 deletions(-) diff --git a/tfawserr/awserr_test.go b/tfawserr/awserr_test.go index 73498388..31c37255 100644 --- a/tfawserr/awserr_test.go +++ b/tfawserr/awserr_test.go @@ -10,91 +10,79 @@ import ( "github.com/aws/aws-sdk-go-v2/service/sts/types" "github.com/aws/aws-sdk-go/aws" smithy "github.com/aws/smithy-go" - awsbase "github.com/hashicorp/aws-sdk-go-base/v2" ) func TestErrCodeEquals(t *testing.T) { - testCases := []struct { - Name string + testCases := map[string]struct { Err error Codes []string Expected bool }{ - { - Name: "nil error", + "nil error": { + Err: nil, + Expected: false, }, - { - Name: "Top-level CannotAssumeRoleError", - Err: awsbase.CannotAssumeRoleError{}, + "other error": { + Err: fmt.Errorf("other error"), + Expected: false, }, - { - Name: "Top-level smithy.GenericAPIError matching first code", + "Top-level smithy.GenericAPIError matching first code": { Err: &smithy.GenericAPIError{Code: "TestCode", Message: "TestMessage"}, Codes: []string{"TestCode"}, Expected: true, }, - { - Name: "Top-level smithy.GenericAPIError matching last code", + "Top-level smithy.GenericAPIError matching last code": { Err: &smithy.GenericAPIError{Code: "TestCode", Message: "TestMessage"}, Codes: []string{"NotMatching", "TestCode"}, Expected: true, }, - { - Name: "Top-level smithy.GenericAPIError no code", - Err: &smithy.GenericAPIError{Code: "TestCode", Message: "TestMessage"}, + "Top-level smithy.GenericAPIError no code": { + Err: &smithy.GenericAPIError{Code: "TestCode", Message: "TestMessage"}, }, - { - Name: "Top-level smithy.GenericAPIError non-matching codes", + "Top-level smithy.GenericAPIError non-matching codes": { Err: &smithy.GenericAPIError{Code: "TestCode", Message: "TestMessage"}, Codes: []string{"NotMatching", "AlsoNotMatching"}, }, - { - Name: "Wrapped smithy.GenericAPIError matching first code", + "Wrapped smithy.GenericAPIError matching first code": { Err: fmt.Errorf("test: %w", &smithy.GenericAPIError{Code: "TestCode", Message: "TestMessage"}), Codes: []string{"TestCode"}, Expected: true, }, - { - Name: "Wrapped smithy.GenericAPIError matching last code", + "Wrapped smithy.GenericAPIError matching last code": { Err: fmt.Errorf("test: %w", &smithy.GenericAPIError{Code: "TestCode", Message: "TestMessage"}), Codes: []string{"NotMatching", "TestCode"}, Expected: true, }, - { - Name: "Wrapped smithy.GenericAPIError non-matching codes", + "Wrapped smithy.GenericAPIError non-matching codes": { Err: fmt.Errorf("test: %w", &smithy.GenericAPIError{Code: "TestCode", Message: "TestMessage"}), Codes: []string{"NotMatching", "AlsoNotMatching"}, }, - { - Name: "Top-level sts ExpiredTokenException matching first code", + "Top-level sts ExpiredTokenException matching first code": { Err: &types.ExpiredTokenException{ErrorCodeOverride: aws.String("TestCode"), Message: aws.String("TestMessage")}, Codes: []string{"TestCode"}, Expected: true, }, - { - Name: "Top-level sts ExpiredTokenException matching last code", + "Top-level sts ExpiredTokenException matching last code": { Err: &types.ExpiredTokenException{ErrorCodeOverride: aws.String("TestCode"), Message: aws.String("TestMessage")}, Codes: []string{"NotMatching", "TestCode"}, Expected: true, }, - { - Name: "Wrapped sts ExpiredTokenException matching first code", + "Wrapped sts ExpiredTokenException matching first code": { Err: fmt.Errorf("test: %w", &types.ExpiredTokenException{ErrorCodeOverride: aws.String("TestCode"), Message: aws.String("TestMessage")}), Codes: []string{"TestCode"}, Expected: true, }, - { - Name: "Wrapped sts ExpiredTokenException matching last code", + "Wrapped sts ExpiredTokenException matching last code": { Err: fmt.Errorf("test: %w", &types.ExpiredTokenException{ErrorCodeOverride: aws.String("TestCode"), Message: aws.String("TestMessage")}), Codes: []string{"NotMatching", "TestCode"}, Expected: true, }, } - for _, testCase := range testCases { + for name, testCase := range testCases { testCase := testCase - t.Run(testCase.Name, func(t *testing.T) { + t.Run(name, func(t *testing.T) { got := ErrCodeEquals(testCase.Err, testCase.Codes...) if got != testCase.Expected { From f31cf73ae5aa0de9cf5390728aee3c0261bff40a Mon Sep 17 00:00:00 2001 From: Graham Davison Date: Thu, 22 Jun 2023 15:08:03 -0700 Subject: [PATCH 4/4] Fixes copy-paste error --- tfawserr/awserr_test.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tfawserr/awserr_test.go b/tfawserr/awserr_test.go index 31c37255..b5f2520d 100644 --- a/tfawserr/awserr_test.go +++ b/tfawserr/awserr_test.go @@ -7,8 +7,8 @@ import ( "fmt" "testing" + "github.com/aws/aws-sdk-go-v2/aws" "github.com/aws/aws-sdk-go-v2/service/sts/types" - "github.com/aws/aws-sdk-go/aws" smithy "github.com/aws/smithy-go" )