// Code generated by smithy-go-codegen DO NOT EDIT.

//go:build response_snapshot

package signin

import (
	"bufio"
	"bytes"
	"context"
	"errors"
	"fmt"
	"github.com/aws/aws-sdk-go-v2/service/signin/types"
	smithyendpoints "github.com/aws/smithy-go/endpoints"
	"github.com/aws/smithy-go/middleware"
	"github.com/aws/smithy-go/ptr"
	smithytesting "github.com/aws/smithy-go/testing"
	smithyhttp "github.com/aws/smithy-go/transport/http"
	"io"
	"io/fs"
	"net/http"
	"net/url"
	"os"
	"strconv"
	"strings"
	"testing"
)

const serdeRespSSPrefix = "response_snapshot"

func serdeRespSSPath(op string) string {
	return fmt.Sprintf("%s/%s.snap", serdeRespSSPrefix, op)
}

// serdeRespReadSnapshot parses a frozen wire response fixture: a status-code
// line, HTTP headers, a blank line, then the raw body.
func serdeRespReadSnapshot(op string) (int, http.Header, []byte, error) {
	raw, err := os.ReadFile(serdeRespSSPath(op))
	if err != nil {
		return 0, nil, nil, err
	}

	r := bufio.NewReader(bytes.NewReader(raw))
	statusLine, err := r.ReadString('\n')
	if err != nil {
		return 0, nil, nil, fmt.Errorf("read status line: %w", err)
	}
	status, err := strconv.Atoi(strings.TrimSpace(statusLine))
	if err != nil {
		return 0, nil, nil, fmt.Errorf("parse status: %w", err)
	}

	header := http.Header{}
	for {
		line, err := r.ReadString('\n')
		if err != nil && err != io.EOF {
			return 0, nil, nil, err
		}
		trimmed := strings.TrimRight(line, "\r\n")
		if trimmed == "" {
			break
		}
		k, v, ok := strings.Cut(trimmed, ": ")
		if !ok {
			return 0, nil, nil, fmt.Errorf("malformed header %q", trimmed)
		}
		header.Add(k, v)
		if err == io.EOF {
			break
		}
	}

	body, err := io.ReadAll(r)
	if err != nil {
		return 0, nil, nil, err
	}
	return status, header, body, nil
}

type serdeRespEndpointResolver struct{}

func (*serdeRespEndpointResolver) ResolveEndpoint(ctx context.Context, params EndpointParameters) (smithyendpoints.Endpoint, error) {
	return smithyendpoints.Endpoint{URI: url.URL{Scheme: "https", Host: "test.example.com"}}, nil
}

func serdeRespClient(status int, header http.Header, body []byte) *Client {
	return New(Options{
		Region: "us-east-1",
		HTTPClient: smithyhttp.ClientDoFunc(func(req *http.Request) (*http.Response, error) {
			resp := &http.Response{StatusCode: status, Header: header, Request: req}
			if len(body) > 0 {
				resp.ContentLength = int64(len(body))
				resp.Body = io.NopCloser(bytes.NewReader(body))
			} else {
				resp.Body = http.NoBody
			}
			return resp, nil
		}),
		EndpointResolverV2: &serdeRespEndpointResolver{},
		APIOptions: []func(*middleware.Stack) error{
			func(s *middleware.Stack) error {
				s.Finalize.Clear()
				s.Initialize.Remove("OperationInputValidation")
				return nil
			},
		},
	})
}
func TestCheckResponseSnapshot_CreateOAuth2Token(t *testing.T) {
	want := &CreateOAuth2TokenOutput{
		TokenOutput: &types.CreateOAuth2TokenResponseBody{
			AccessToken: &types.AccessToken{
				AccessKeyId:     ptr.String("__AccessKeyId__"),
				SecretAccessKey: ptr.String("__SecretAccessKey__"),
				SessionToken:    ptr.String("__SessionToken__"),
			},
			TokenType:    ptr.String("__TokenType__"),
			ExpiresIn:    ptr.Int32(1),
			RefreshToken: ptr.String("__RefreshToken__"),
			IdToken:      ptr.String("__IdToken__"),
		},
	}
	status, header, body, err := serdeRespReadSnapshot("CreateOAuth2Token.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.CreateOAuth2Token(context.Background(), &CreateOAuth2TokenInput{
		TokenInput: &types.CreateOAuth2TokenRequestBody{
			ClientId:     ptr.String("__ClientId__"),
			GrantType:    ptr.String("__GrantType__"),
			Code:         ptr.String("__Code__"),
			RedirectUri:  ptr.String("__RedirectUri__"),
			CodeVerifier: ptr.String("__CodeVerifier__"),
			RefreshToken: ptr.String("__RefreshToken__"),
		},
	})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "CreateOAuth2Token.response", err)
	}
}

func TestCheckResponseSnapshot_CreateOAuth2TokenWithIAM(t *testing.T) {
	want := &CreateOAuth2TokenWithIAMOutput{
		AccessToken: ptr.String("__AccessToken__"),
		TokenType:   ptr.String("__TokenType__"),
		ExpiresIn:   ptr.Int32(1),
	}
	status, header, body, err := serdeRespReadSnapshot("CreateOAuth2TokenWithIAM.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.CreateOAuth2TokenWithIAM(context.Background(), &CreateOAuth2TokenWithIAMInput{
		GrantType: ptr.String("__GrantType__"),
		Resource:  ptr.String("__Resource__"),
	})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "CreateOAuth2TokenWithIAM.response", err)
	}
}

func TestCheckResponseSnapshot_DeleteConsoleAuthorizationConfiguration(t *testing.T) {
	want := &DeleteConsoleAuthorizationConfigurationOutput{
		TargetId:                    ptr.String("__TargetId__"),
		Scope:                       ptr.String("__Scope__"),
		ConsoleAuthorizationEnabled: ptr.Bool(true),
	}
	status, header, body, err := serdeRespReadSnapshot("DeleteConsoleAuthorizationConfiguration.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.DeleteConsoleAuthorizationConfiguration(context.Background(), &DeleteConsoleAuthorizationConfigurationInput{
		TargetId: ptr.String("__TargetId__"),
	})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "DeleteConsoleAuthorizationConfiguration.response", err)
	}
}

func TestCheckResponseSnapshot_DeleteResourcePermissionStatement(t *testing.T) {
	want := &DeleteResourcePermissionStatementOutput{}
	status, header, body, err := serdeRespReadSnapshot("DeleteResourcePermissionStatement.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.DeleteResourcePermissionStatement(context.Background(), &DeleteResourcePermissionStatementInput{
		StatementId: ptr.String("__StatementId__"),
		ClientToken: ptr.String("__ClientToken__"),
	})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "DeleteResourcePermissionStatement.response", err)
	}
}

func TestCheckResponseSnapshot_GetConsoleAuthorizationConfiguration(t *testing.T) {
	want := &GetConsoleAuthorizationConfigurationOutput{
		TargetId:                    ptr.String("__TargetId__"),
		Scope:                       ptr.String("__Scope__"),
		ConsoleAuthorizationEnabled: ptr.Bool(true),
	}
	status, header, body, err := serdeRespReadSnapshot("GetConsoleAuthorizationConfiguration.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.GetConsoleAuthorizationConfiguration(context.Background(), &GetConsoleAuthorizationConfigurationInput{
		TargetId: ptr.String("__TargetId__"),
	})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GetConsoleAuthorizationConfiguration.response", err)
	}
}

func TestCheckResponseSnapshot_GetResourcePolicy(t *testing.T) {
	want := &GetResourcePolicyOutput{
		SigninResourceBasedPolicy: &types.SigninResourceBasedPolicy{
			Version: ptr.String("__Version__"),
			Statement: []types.PolicyStatement{
				{
					Effect: ptr.String("__Effect__"),
					Principal: map[string]string{
						"key0": "__Value__",
					},
					Action: []string{
						"__Member__",
						"__Member__",
					},
					Resource: ptr.String("__Resource__"),
					Condition: map[string]map[string][]string{
						"key0": {
							"key0": {
								"__Member__",
								"__Member__",
							},
						},
					},
				},
				{
					Effect: ptr.String("__Effect__"),
					Principal: map[string]string{
						"key0": "__Value__",
					},
					Action: []string{
						"__Member__",
						"__Member__",
					},
					Resource: ptr.String("__Resource__"),
					Condition: map[string]map[string][]string{
						"key0": {
							"key0": {
								"__Member__",
								"__Member__",
							},
						},
					},
				},
			},
		},
	}
	status, header, body, err := serdeRespReadSnapshot("GetResourcePolicy.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.GetResourcePolicy(context.Background(), &GetResourcePolicyInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GetResourcePolicy.response", err)
	}
}

func TestCheckResponseSnapshot_IntrospectOAuth2TokenWithIAM(t *testing.T) {
	want := &IntrospectOAuth2TokenWithIAMOutput{
		Active:        ptr.Bool(true),
		ClientId:      ptr.String("__ClientId__"),
		UserId:        ptr.String("__UserId__"),
		TokenType:     ptr.String("__TokenType__"),
		Exp:           ptr.Int64(1),
		Iat:           ptr.Int64(1),
		Nbf:           ptr.Int64(1),
		Sub:           ptr.String("__Sub__"),
		Aud:           ptr.String("__Aud__"),
		Iss:           ptr.String("__Iss__"),
		Jti:           ptr.String("__Jti__"),
		AccountId:     ptr.String("__AccountId__"),
		SigninSession: ptr.String("__SigninSession__"),
		Resource:      ptr.String("__Resource__"),
	}
	status, header, body, err := serdeRespReadSnapshot("IntrospectOAuth2TokenWithIAM.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.IntrospectOAuth2TokenWithIAM(context.Background(), &IntrospectOAuth2TokenWithIAMInput{
		Token:         ptr.String("__Token__"),
		TokenTypeHint: ptr.String("__TokenTypeHint__"),
	})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "IntrospectOAuth2TokenWithIAM.response", err)
	}
}

func TestCheckResponseSnapshot_ListResourcePermissionStatements(t *testing.T) {
	want := &ListResourcePermissionStatementsOutput{
		PermissionStatements: []types.PermissionStatementSummary{
			{
				Sid: ptr.String("__Sid__"),
				Condition: map[string]map[string][]string{
					"key0": {
						"key0": {
							"__Member__",
							"__Member__",
						},
					},
				},
			},
			{
				Sid: ptr.String("__Sid__"),
				Condition: map[string]map[string][]string{
					"key0": {
						"key0": {
							"__Member__",
							"__Member__",
						},
					},
				},
			},
		},
		NextToken: ptr.String("__NextToken__"),
	}
	status, header, body, err := serdeRespReadSnapshot("ListResourcePermissionStatements.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.ListResourcePermissionStatements(context.Background(), &ListResourcePermissionStatementsInput{
		MaxResults: ptr.Int32(1),
		NextToken:  ptr.String("__NextToken__"),
	})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "ListResourcePermissionStatements.response", err)
	}
}

func TestCheckResponseSnapshot_PutConsoleAuthorizationConfiguration(t *testing.T) {
	want := &PutConsoleAuthorizationConfigurationOutput{
		TargetId:                    ptr.String("__TargetId__"),
		Scope:                       ptr.String("__Scope__"),
		ConsoleAuthorizationEnabled: ptr.Bool(true),
	}
	status, header, body, err := serdeRespReadSnapshot("PutConsoleAuthorizationConfiguration.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.PutConsoleAuthorizationConfiguration(context.Background(), &PutConsoleAuthorizationConfigurationInput{
		TargetId: ptr.String("__TargetId__"),
	})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "PutConsoleAuthorizationConfiguration.response", err)
	}
}

func TestCheckResponseSnapshot_PutResourcePermissionStatement(t *testing.T) {
	want := &PutResourcePermissionStatementOutput{
		StatementId: ptr.String("__StatementId__"),
	}
	status, header, body, err := serdeRespReadSnapshot("PutResourcePermissionStatement.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.PutResourcePermissionStatement(context.Background(), &PutResourcePermissionStatementInput{
		SourceVpc:         ptr.String("__SourceVpc__"),
		SigninSourceVpce:  ptr.String("__SigninSourceVpce__"),
		ConsoleSourceVpce: ptr.String("__ConsoleSourceVpce__"),
		VpcSourceIp:       ptr.String("__VpcSourceIp__"),
		SourceIp:          ptr.String("__SourceIp__"),
		RequestedRegion:   ptr.String("__RequestedRegion__"),
		ExcludedPrincipal: ptr.String("__ExcludedPrincipal__"),
		ClientToken:       ptr.String("__ClientToken__"),
	})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "PutResourcePermissionStatement.response", err)
	}
}

func TestCheckResponseSnapshot_RevokeOAuth2TokenWithIAM(t *testing.T) {
	want := &RevokeOAuth2TokenWithIAMOutput{}
	status, header, body, err := serdeRespReadSnapshot("RevokeOAuth2TokenWithIAM.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.RevokeOAuth2TokenWithIAM(context.Background(), &RevokeOAuth2TokenWithIAMInput{
		Token: ptr.String("__Token__"),
	})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "RevokeOAuth2TokenWithIAM.response", err)
	}
}

func TestCheckResponseSnapshot_Error_AccessDeniedException(t *testing.T) {
	want := &types.AccessDeniedException{
		Error_:  types.OAuth2ErrorCode("TOKEN_EXPIRED"),
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("AccessDeniedException.error")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	_, opErr := svc.CreateOAuth2Token(context.Background(), &CreateOAuth2TokenInput{
		TokenInput: &types.CreateOAuth2TokenRequestBody{
			ClientId:     ptr.String("__ClientId__"),
			GrantType:    ptr.String("__GrantType__"),
			Code:         ptr.String("__Code__"),
			RedirectUri:  ptr.String("__RedirectUri__"),
			CodeVerifier: ptr.String("__CodeVerifier__"),
			RefreshToken: ptr.String("__RefreshToken__"),
		},
	})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.AccessDeniedException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.AccessDeniedException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "AccessDeniedException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_ConflictException(t *testing.T) {
	want := &types.ConflictException{
		Error_:  types.OAuth2ErrorCode("TOKEN_EXPIRED"),
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("ConflictException.error")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	_, opErr := svc.PutConsoleAuthorizationConfiguration(context.Background(), &PutConsoleAuthorizationConfigurationInput{
		TargetId: ptr.String("__TargetId__"),
	})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.ConflictException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.ConflictException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "ConflictException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_InternalServerException(t *testing.T) {
	want := &types.InternalServerException{
		Error_:  types.OAuth2ErrorCode("TOKEN_EXPIRED"),
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("InternalServerException.error")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	_, opErr := svc.CreateOAuth2Token(context.Background(), &CreateOAuth2TokenInput{
		TokenInput: &types.CreateOAuth2TokenRequestBody{
			ClientId:     ptr.String("__ClientId__"),
			GrantType:    ptr.String("__GrantType__"),
			Code:         ptr.String("__Code__"),
			RedirectUri:  ptr.String("__RedirectUri__"),
			CodeVerifier: ptr.String("__CodeVerifier__"),
			RefreshToken: ptr.String("__RefreshToken__"),
		},
	})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.InternalServerException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.InternalServerException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "InternalServerException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_ResourceNotFoundException(t *testing.T) {
	want := &types.ResourceNotFoundException{
		Error_:  types.OAuth2ErrorCode("TOKEN_EXPIRED"),
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("ResourceNotFoundException.error")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	_, opErr := svc.DeleteConsoleAuthorizationConfiguration(context.Background(), &DeleteConsoleAuthorizationConfigurationInput{
		TargetId: ptr.String("__TargetId__"),
	})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.ResourceNotFoundException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.ResourceNotFoundException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "ResourceNotFoundException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_ServiceQuotaExceededException(t *testing.T) {
	want := &types.ServiceQuotaExceededException{
		Error_:  types.OAuth2ErrorCode("TOKEN_EXPIRED"),
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("ServiceQuotaExceededException.error")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	_, opErr := svc.PutResourcePermissionStatement(context.Background(), &PutResourcePermissionStatementInput{
		SourceVpc:         ptr.String("__SourceVpc__"),
		SigninSourceVpce:  ptr.String("__SigninSourceVpce__"),
		ConsoleSourceVpce: ptr.String("__ConsoleSourceVpce__"),
		VpcSourceIp:       ptr.String("__VpcSourceIp__"),
		SourceIp:          ptr.String("__SourceIp__"),
		RequestedRegion:   ptr.String("__RequestedRegion__"),
		ExcludedPrincipal: ptr.String("__ExcludedPrincipal__"),
		ClientToken:       ptr.String("__ClientToken__"),
	})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.ServiceQuotaExceededException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.ServiceQuotaExceededException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "ServiceQuotaExceededException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_TooManyRequestsError(t *testing.T) {
	want := &types.TooManyRequestsError{
		Error_:  types.OAuth2ErrorCode("TOKEN_EXPIRED"),
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("TooManyRequestsError.error")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	_, opErr := svc.CreateOAuth2Token(context.Background(), &CreateOAuth2TokenInput{
		TokenInput: &types.CreateOAuth2TokenRequestBody{
			ClientId:     ptr.String("__ClientId__"),
			GrantType:    ptr.String("__GrantType__"),
			Code:         ptr.String("__Code__"),
			RedirectUri:  ptr.String("__RedirectUri__"),
			CodeVerifier: ptr.String("__CodeVerifier__"),
			RefreshToken: ptr.String("__RefreshToken__"),
		},
	})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.TooManyRequestsError
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.TooManyRequestsError, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "TooManyRequestsError.error", err)
	}
}

func TestCheckResponseSnapshot_Error_ValidationException(t *testing.T) {
	want := &types.ValidationException{
		Error_:  types.OAuth2ErrorCode("TOKEN_EXPIRED"),
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("ValidationException.error")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	_, opErr := svc.CreateOAuth2Token(context.Background(), &CreateOAuth2TokenInput{
		TokenInput: &types.CreateOAuth2TokenRequestBody{
			ClientId:     ptr.String("__ClientId__"),
			GrantType:    ptr.String("__GrantType__"),
			Code:         ptr.String("__Code__"),
			RedirectUri:  ptr.String("__RedirectUri__"),
			CodeVerifier: ptr.String("__CodeVerifier__"),
			RefreshToken: ptr.String("__RefreshToken__"),
		},
	})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.ValidationException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.ValidationException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "ValidationException.error", err)
	}
}