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

//go:build response_snapshot

package ssooidc

import (
	"bufio"
	"bytes"
	"context"
	"errors"
	"fmt"
	"github.com/aws/aws-sdk-go-v2/service/ssooidc/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_CreateToken(t *testing.T) {
	want := &CreateTokenOutput{
		AccessToken:  ptr.String("__AccessToken__"),
		TokenType:    ptr.String("__TokenType__"),
		ExpiresIn:    1,
		RefreshToken: ptr.String("__RefreshToken__"),
		IdToken:      ptr.String("__IdToken__"),
	}
	status, header, body, err := serdeRespReadSnapshot("CreateToken.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.CreateToken(context.Background(), &CreateTokenInput{
		ClientId:     ptr.String("__ClientId__"),
		ClientSecret: ptr.String("__ClientSecret__"),
		GrantType:    ptr.String("__GrantType__"),
		DeviceCode:   ptr.String("__DeviceCode__"),
		Code:         ptr.String("__Code__"),
		RefreshToken: ptr.String("__RefreshToken__"),
		Scope: []string{
			"__Member__",
			"__Member__",
		},
		RedirectUri:  ptr.String("__RedirectUri__"),
		CodeVerifier: ptr.String("__CodeVerifier__"),
	})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "CreateToken.response", err)
	}
}

func TestCheckResponseSnapshot_CreateTokenWithIAM(t *testing.T) {
	want := &CreateTokenWithIAMOutput{
		AccessToken:     ptr.String("__AccessToken__"),
		TokenType:       ptr.String("__TokenType__"),
		ExpiresIn:       1,
		RefreshToken:    ptr.String("__RefreshToken__"),
		IdToken:         ptr.String("__IdToken__"),
		IssuedTokenType: ptr.String("__IssuedTokenType__"),
		Scope: []string{
			"__Member__",
			"__Member__",
		},
		AwsAdditionalDetails: &types.AwsAdditionalDetails{
			IdentityContext: ptr.String("__IdentityContext__"),
		},
	}
	status, header, body, err := serdeRespReadSnapshot("CreateTokenWithIAM.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.CreateTokenWithIAM(context.Background(), &CreateTokenWithIAMInput{
		ClientId:     ptr.String("__ClientId__"),
		GrantType:    ptr.String("__GrantType__"),
		Code:         ptr.String("__Code__"),
		RefreshToken: ptr.String("__RefreshToken__"),
		Assertion:    ptr.String("__Assertion__"),
		Scope: []string{
			"__Member__",
			"__Member__",
		},
		RedirectUri:        ptr.String("__RedirectUri__"),
		SubjectToken:       ptr.String("__SubjectToken__"),
		SubjectTokenType:   ptr.String("__SubjectTokenType__"),
		RequestedTokenType: ptr.String("__RequestedTokenType__"),
		CodeVerifier:       ptr.String("__CodeVerifier__"),
	})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "CreateTokenWithIAM.response", err)
	}
}

func TestCheckResponseSnapshot_RegisterClient(t *testing.T) {
	want := &RegisterClientOutput{
		ClientId:              ptr.String("__ClientId__"),
		ClientSecret:          ptr.String("__ClientSecret__"),
		ClientIdIssuedAt:      1,
		ClientSecretExpiresAt: 1,
		AuthorizationEndpoint: ptr.String("__AuthorizationEndpoint__"),
		TokenEndpoint:         ptr.String("__TokenEndpoint__"),
	}
	status, header, body, err := serdeRespReadSnapshot("RegisterClient.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.RegisterClient(context.Background(), &RegisterClientInput{
		ClientName: ptr.String("__ClientName__"),
		ClientType: ptr.String("__ClientType__"),
		Scopes: []string{
			"__Member__",
			"__Member__",
		},
		RedirectUris: []string{
			"__Member__",
			"__Member__",
		},
		GrantTypes: []string{
			"__Member__",
			"__Member__",
		},
		IssuerUrl:              ptr.String("__IssuerUrl__"),
		EntitledApplicationArn: ptr.String("__EntitledApplicationArn__"),
	})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "RegisterClient.response", err)
	}
}

func TestCheckResponseSnapshot_StartDeviceAuthorization(t *testing.T) {
	want := &StartDeviceAuthorizationOutput{
		DeviceCode:              ptr.String("__DeviceCode__"),
		UserCode:                ptr.String("__UserCode__"),
		VerificationUri:         ptr.String("__VerificationUri__"),
		VerificationUriComplete: ptr.String("__VerificationUriComplete__"),
		ExpiresIn:               1,
		Interval:                1,
	}
	status, header, body, err := serdeRespReadSnapshot("StartDeviceAuthorization.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.StartDeviceAuthorization(context.Background(), &StartDeviceAuthorizationInput{
		ClientId:     ptr.String("__ClientId__"),
		ClientSecret: ptr.String("__ClientSecret__"),
		StartUrl:     ptr.String("__StartUrl__"),
	})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "StartDeviceAuthorization.response", err)
	}
}

func TestCheckResponseSnapshot_Error_AccessDeniedException(t *testing.T) {
	want := &types.AccessDeniedException{
		Error_:            ptr.String("__Error___"),
		Reason:            types.AccessDeniedExceptionReason("KMS_AccessDeniedException"),
		Error_description: ptr.String("__Error_description__"),
	}
	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.CreateToken(context.Background(), &CreateTokenInput{
		ClientId:     ptr.String("__ClientId__"),
		ClientSecret: ptr.String("__ClientSecret__"),
		GrantType:    ptr.String("__GrantType__"),
		DeviceCode:   ptr.String("__DeviceCode__"),
		Code:         ptr.String("__Code__"),
		RefreshToken: ptr.String("__RefreshToken__"),
		Scope: []string{
			"__Member__",
			"__Member__",
		},
		RedirectUri:  ptr.String("__RedirectUri__"),
		CodeVerifier: ptr.String("__CodeVerifier__"),
	})
	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_AuthorizationPendingException(t *testing.T) {
	want := &types.AuthorizationPendingException{
		Error_:            ptr.String("__Error___"),
		Error_description: ptr.String("__Error_description__"),
	}
	status, header, body, err := serdeRespReadSnapshot("AuthorizationPendingException.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.CreateToken(context.Background(), &CreateTokenInput{
		ClientId:     ptr.String("__ClientId__"),
		ClientSecret: ptr.String("__ClientSecret__"),
		GrantType:    ptr.String("__GrantType__"),
		DeviceCode:   ptr.String("__DeviceCode__"),
		Code:         ptr.String("__Code__"),
		RefreshToken: ptr.String("__RefreshToken__"),
		Scope: []string{
			"__Member__",
			"__Member__",
		},
		RedirectUri:  ptr.String("__RedirectUri__"),
		CodeVerifier: ptr.String("__CodeVerifier__"),
	})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.AuthorizationPendingException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.AuthorizationPendingException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "AuthorizationPendingException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_ExpiredTokenException(t *testing.T) {
	want := &types.ExpiredTokenException{
		Error_:            ptr.String("__Error___"),
		Error_description: ptr.String("__Error_description__"),
	}
	status, header, body, err := serdeRespReadSnapshot("ExpiredTokenException.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.CreateToken(context.Background(), &CreateTokenInput{
		ClientId:     ptr.String("__ClientId__"),
		ClientSecret: ptr.String("__ClientSecret__"),
		GrantType:    ptr.String("__GrantType__"),
		DeviceCode:   ptr.String("__DeviceCode__"),
		Code:         ptr.String("__Code__"),
		RefreshToken: ptr.String("__RefreshToken__"),
		Scope: []string{
			"__Member__",
			"__Member__",
		},
		RedirectUri:  ptr.String("__RedirectUri__"),
		CodeVerifier: ptr.String("__CodeVerifier__"),
	})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.ExpiredTokenException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.ExpiredTokenException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "ExpiredTokenException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_InternalServerException(t *testing.T) {
	want := &types.InternalServerException{
		Error_:            ptr.String("__Error___"),
		Error_description: ptr.String("__Error_description__"),
	}
	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.CreateToken(context.Background(), &CreateTokenInput{
		ClientId:     ptr.String("__ClientId__"),
		ClientSecret: ptr.String("__ClientSecret__"),
		GrantType:    ptr.String("__GrantType__"),
		DeviceCode:   ptr.String("__DeviceCode__"),
		Code:         ptr.String("__Code__"),
		RefreshToken: ptr.String("__RefreshToken__"),
		Scope: []string{
			"__Member__",
			"__Member__",
		},
		RedirectUri:  ptr.String("__RedirectUri__"),
		CodeVerifier: ptr.String("__CodeVerifier__"),
	})
	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_InvalidClientException(t *testing.T) {
	want := &types.InvalidClientException{
		Error_:            ptr.String("__Error___"),
		Error_description: ptr.String("__Error_description__"),
	}
	status, header, body, err := serdeRespReadSnapshot("InvalidClientException.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.CreateToken(context.Background(), &CreateTokenInput{
		ClientId:     ptr.String("__ClientId__"),
		ClientSecret: ptr.String("__ClientSecret__"),
		GrantType:    ptr.String("__GrantType__"),
		DeviceCode:   ptr.String("__DeviceCode__"),
		Code:         ptr.String("__Code__"),
		RefreshToken: ptr.String("__RefreshToken__"),
		Scope: []string{
			"__Member__",
			"__Member__",
		},
		RedirectUri:  ptr.String("__RedirectUri__"),
		CodeVerifier: ptr.String("__CodeVerifier__"),
	})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.InvalidClientException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.InvalidClientException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "InvalidClientException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_InvalidClientMetadataException(t *testing.T) {
	want := &types.InvalidClientMetadataException{
		Error_:            ptr.String("__Error___"),
		Error_description: ptr.String("__Error_description__"),
	}
	status, header, body, err := serdeRespReadSnapshot("InvalidClientMetadataException.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.RegisterClient(context.Background(), &RegisterClientInput{
		ClientName: ptr.String("__ClientName__"),
		ClientType: ptr.String("__ClientType__"),
		Scopes: []string{
			"__Member__",
			"__Member__",
		},
		RedirectUris: []string{
			"__Member__",
			"__Member__",
		},
		GrantTypes: []string{
			"__Member__",
			"__Member__",
		},
		IssuerUrl:              ptr.String("__IssuerUrl__"),
		EntitledApplicationArn: ptr.String("__EntitledApplicationArn__"),
	})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.InvalidClientMetadataException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.InvalidClientMetadataException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "InvalidClientMetadataException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_InvalidGrantException(t *testing.T) {
	want := &types.InvalidGrantException{
		Error_:            ptr.String("__Error___"),
		Error_description: ptr.String("__Error_description__"),
	}
	status, header, body, err := serdeRespReadSnapshot("InvalidGrantException.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.CreateToken(context.Background(), &CreateTokenInput{
		ClientId:     ptr.String("__ClientId__"),
		ClientSecret: ptr.String("__ClientSecret__"),
		GrantType:    ptr.String("__GrantType__"),
		DeviceCode:   ptr.String("__DeviceCode__"),
		Code:         ptr.String("__Code__"),
		RefreshToken: ptr.String("__RefreshToken__"),
		Scope: []string{
			"__Member__",
			"__Member__",
		},
		RedirectUri:  ptr.String("__RedirectUri__"),
		CodeVerifier: ptr.String("__CodeVerifier__"),
	})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.InvalidGrantException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.InvalidGrantException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "InvalidGrantException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_InvalidRedirectUriException(t *testing.T) {
	want := &types.InvalidRedirectUriException{
		Error_:            ptr.String("__Error___"),
		Error_description: ptr.String("__Error_description__"),
	}
	status, header, body, err := serdeRespReadSnapshot("InvalidRedirectUriException.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.RegisterClient(context.Background(), &RegisterClientInput{
		ClientName: ptr.String("__ClientName__"),
		ClientType: ptr.String("__ClientType__"),
		Scopes: []string{
			"__Member__",
			"__Member__",
		},
		RedirectUris: []string{
			"__Member__",
			"__Member__",
		},
		GrantTypes: []string{
			"__Member__",
			"__Member__",
		},
		IssuerUrl:              ptr.String("__IssuerUrl__"),
		EntitledApplicationArn: ptr.String("__EntitledApplicationArn__"),
	})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.InvalidRedirectUriException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.InvalidRedirectUriException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "InvalidRedirectUriException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_InvalidRequestException(t *testing.T) {
	want := &types.InvalidRequestException{
		Error_:            ptr.String("__Error___"),
		Reason:            types.InvalidRequestExceptionReason("KMS_NotFoundException"),
		Error_description: ptr.String("__Error_description__"),
	}
	status, header, body, err := serdeRespReadSnapshot("InvalidRequestException.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.CreateToken(context.Background(), &CreateTokenInput{
		ClientId:     ptr.String("__ClientId__"),
		ClientSecret: ptr.String("__ClientSecret__"),
		GrantType:    ptr.String("__GrantType__"),
		DeviceCode:   ptr.String("__DeviceCode__"),
		Code:         ptr.String("__Code__"),
		RefreshToken: ptr.String("__RefreshToken__"),
		Scope: []string{
			"__Member__",
			"__Member__",
		},
		RedirectUri:  ptr.String("__RedirectUri__"),
		CodeVerifier: ptr.String("__CodeVerifier__"),
	})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.InvalidRequestException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.InvalidRequestException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "InvalidRequestException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_InvalidRequestRegionException(t *testing.T) {
	want := &types.InvalidRequestRegionException{
		Error_:            ptr.String("__Error___"),
		Error_description: ptr.String("__Error_description__"),
		Endpoint:          ptr.String("__Endpoint__"),
		Region:            ptr.String("__Region__"),
	}
	status, header, body, err := serdeRespReadSnapshot("InvalidRequestRegionException.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.CreateTokenWithIAM(context.Background(), &CreateTokenWithIAMInput{
		ClientId:     ptr.String("__ClientId__"),
		GrantType:    ptr.String("__GrantType__"),
		Code:         ptr.String("__Code__"),
		RefreshToken: ptr.String("__RefreshToken__"),
		Assertion:    ptr.String("__Assertion__"),
		Scope: []string{
			"__Member__",
			"__Member__",
		},
		RedirectUri:        ptr.String("__RedirectUri__"),
		SubjectToken:       ptr.String("__SubjectToken__"),
		SubjectTokenType:   ptr.String("__SubjectTokenType__"),
		RequestedTokenType: ptr.String("__RequestedTokenType__"),
		CodeVerifier:       ptr.String("__CodeVerifier__"),
	})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.InvalidRequestRegionException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.InvalidRequestRegionException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "InvalidRequestRegionException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_InvalidScopeException(t *testing.T) {
	want := &types.InvalidScopeException{
		Error_:            ptr.String("__Error___"),
		Error_description: ptr.String("__Error_description__"),
	}
	status, header, body, err := serdeRespReadSnapshot("InvalidScopeException.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.CreateToken(context.Background(), &CreateTokenInput{
		ClientId:     ptr.String("__ClientId__"),
		ClientSecret: ptr.String("__ClientSecret__"),
		GrantType:    ptr.String("__GrantType__"),
		DeviceCode:   ptr.String("__DeviceCode__"),
		Code:         ptr.String("__Code__"),
		RefreshToken: ptr.String("__RefreshToken__"),
		Scope: []string{
			"__Member__",
			"__Member__",
		},
		RedirectUri:  ptr.String("__RedirectUri__"),
		CodeVerifier: ptr.String("__CodeVerifier__"),
	})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.InvalidScopeException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.InvalidScopeException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "InvalidScopeException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_SlowDownException(t *testing.T) {
	want := &types.SlowDownException{
		Error_:            ptr.String("__Error___"),
		Error_description: ptr.String("__Error_description__"),
	}
	status, header, body, err := serdeRespReadSnapshot("SlowDownException.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.CreateToken(context.Background(), &CreateTokenInput{
		ClientId:     ptr.String("__ClientId__"),
		ClientSecret: ptr.String("__ClientSecret__"),
		GrantType:    ptr.String("__GrantType__"),
		DeviceCode:   ptr.String("__DeviceCode__"),
		Code:         ptr.String("__Code__"),
		RefreshToken: ptr.String("__RefreshToken__"),
		Scope: []string{
			"__Member__",
			"__Member__",
		},
		RedirectUri:  ptr.String("__RedirectUri__"),
		CodeVerifier: ptr.String("__CodeVerifier__"),
	})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.SlowDownException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.SlowDownException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "SlowDownException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_UnauthorizedClientException(t *testing.T) {
	want := &types.UnauthorizedClientException{
		Error_:            ptr.String("__Error___"),
		Error_description: ptr.String("__Error_description__"),
	}
	status, header, body, err := serdeRespReadSnapshot("UnauthorizedClientException.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.CreateToken(context.Background(), &CreateTokenInput{
		ClientId:     ptr.String("__ClientId__"),
		ClientSecret: ptr.String("__ClientSecret__"),
		GrantType:    ptr.String("__GrantType__"),
		DeviceCode:   ptr.String("__DeviceCode__"),
		Code:         ptr.String("__Code__"),
		RefreshToken: ptr.String("__RefreshToken__"),
		Scope: []string{
			"__Member__",
			"__Member__",
		},
		RedirectUri:  ptr.String("__RedirectUri__"),
		CodeVerifier: ptr.String("__CodeVerifier__"),
	})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.UnauthorizedClientException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.UnauthorizedClientException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "UnauthorizedClientException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_UnsupportedGrantTypeException(t *testing.T) {
	want := &types.UnsupportedGrantTypeException{
		Error_:            ptr.String("__Error___"),
		Error_description: ptr.String("__Error_description__"),
	}
	status, header, body, err := serdeRespReadSnapshot("UnsupportedGrantTypeException.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.CreateToken(context.Background(), &CreateTokenInput{
		ClientId:     ptr.String("__ClientId__"),
		ClientSecret: ptr.String("__ClientSecret__"),
		GrantType:    ptr.String("__GrantType__"),
		DeviceCode:   ptr.String("__DeviceCode__"),
		Code:         ptr.String("__Code__"),
		RefreshToken: ptr.String("__RefreshToken__"),
		Scope: []string{
			"__Member__",
			"__Member__",
		},
		RedirectUri:  ptr.String("__RedirectUri__"),
		CodeVerifier: ptr.String("__CodeVerifier__"),
	})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.UnsupportedGrantTypeException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.UnsupportedGrantTypeException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "UnsupportedGrantTypeException.error", err)
	}
}