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

//go:build response_snapshot

package sts

import (
	"bufio"
	"bytes"
	"context"
	"errors"
	"fmt"
	"github.com/aws/aws-sdk-go-v2/service/sts/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"
	"time"
)

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_AssumeRole(t *testing.T) {
	want := &AssumeRoleOutput{
		Credentials: &types.Credentials{
			AccessKeyId:     ptr.String("__AccessKeyId__"),
			SecretAccessKey: ptr.String("__SecretAccessKey__"),
			SessionToken:    ptr.String("__SessionToken__"),
			Expiration:      ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		},
		AssumedRoleUser: &types.AssumedRoleUser{
			AssumedRoleId: ptr.String("__AssumedRoleId__"),
			Arn:           ptr.String("__Arn__"),
		},
		PackedPolicySize:        ptr.Int32(1),
		SourceIdentity:          ptr.String("__SourceIdentity__"),
		SessionTokenUtilization: ptr.Int32(1),
		SessionTokenSize:        ptr.Int32(1),
	}
	status, header, body, err := serdeRespReadSnapshot("AssumeRole.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.AssumeRole(context.Background(), &AssumeRoleInput{
		RoleArn:         ptr.String("__RoleArn__"),
		RoleSessionName: ptr.String("__RoleSessionName__"),
		PolicyArns: []types.PolicyDescriptorType{
			{
				Arn: ptr.String("__Arn__"),
			},
			{
				Arn: ptr.String("__Arn__"),
			},
		},
		Policy:          ptr.String("__Policy__"),
		DurationSeconds: ptr.Int32(1),
		Tags: []types.Tag{
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
			},
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
			},
		},
		TransitiveTagKeys: []string{
			"__Member__",
			"__Member__",
		},
		ExternalId:     ptr.String("__ExternalId__"),
		SerialNumber:   ptr.String("__SerialNumber__"),
		TokenCode:      ptr.String("__TokenCode__"),
		SourceIdentity: ptr.String("__SourceIdentity__"),
		ProvidedContexts: []types.ProvidedContext{
			{
				ProviderArn:      ptr.String("__ProviderArn__"),
				ContextAssertion: ptr.String("__ContextAssertion__"),
			},
			{
				ProviderArn:      ptr.String("__ProviderArn__"),
				ContextAssertion: ptr.String("__ContextAssertion__"),
			},
		},
		MinimumSessionTokenSize: ptr.Int32(1),
	})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "AssumeRole.response", err)
	}
}

func TestCheckResponseSnapshot_AssumeRoleWithSAML(t *testing.T) {
	want := &AssumeRoleWithSAMLOutput{
		Credentials: &types.Credentials{
			AccessKeyId:     ptr.String("__AccessKeyId__"),
			SecretAccessKey: ptr.String("__SecretAccessKey__"),
			SessionToken:    ptr.String("__SessionToken__"),
			Expiration:      ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		},
		AssumedRoleUser: &types.AssumedRoleUser{
			AssumedRoleId: ptr.String("__AssumedRoleId__"),
			Arn:           ptr.String("__Arn__"),
		},
		PackedPolicySize:        ptr.Int32(1),
		Subject:                 ptr.String("__Subject__"),
		SubjectType:             ptr.String("__SubjectType__"),
		Issuer:                  ptr.String("__Issuer__"),
		Audience:                ptr.String("__Audience__"),
		NameQualifier:           ptr.String("__NameQualifier__"),
		SourceIdentity:          ptr.String("__SourceIdentity__"),
		SessionTokenUtilization: ptr.Int32(1),
		SessionTokenSize:        ptr.Int32(1),
	}
	status, header, body, err := serdeRespReadSnapshot("AssumeRoleWithSAML.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.AssumeRoleWithSAML(context.Background(), &AssumeRoleWithSAMLInput{
		RoleArn:       ptr.String("__RoleArn__"),
		PrincipalArn:  ptr.String("__PrincipalArn__"),
		SAMLAssertion: ptr.String("__SAMLAssertion__"),
		PolicyArns: []types.PolicyDescriptorType{
			{
				Arn: ptr.String("__Arn__"),
			},
			{
				Arn: ptr.String("__Arn__"),
			},
		},
		Policy:                  ptr.String("__Policy__"),
		DurationSeconds:         ptr.Int32(1),
		MinimumSessionTokenSize: ptr.Int32(1),
	})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "AssumeRoleWithSAML.response", err)
	}
}

func TestCheckResponseSnapshot_AssumeRoleWithWebIdentity(t *testing.T) {
	want := &AssumeRoleWithWebIdentityOutput{
		Credentials: &types.Credentials{
			AccessKeyId:     ptr.String("__AccessKeyId__"),
			SecretAccessKey: ptr.String("__SecretAccessKey__"),
			SessionToken:    ptr.String("__SessionToken__"),
			Expiration:      ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		},
		SubjectFromWebIdentityToken: ptr.String("__SubjectFromWebIdentityToken__"),
		AssumedRoleUser: &types.AssumedRoleUser{
			AssumedRoleId: ptr.String("__AssumedRoleId__"),
			Arn:           ptr.String("__Arn__"),
		},
		PackedPolicySize:        ptr.Int32(1),
		Provider:                ptr.String("__Provider__"),
		Audience:                ptr.String("__Audience__"),
		SourceIdentity:          ptr.String("__SourceIdentity__"),
		SessionTokenUtilization: ptr.Int32(1),
		SessionTokenSize:        ptr.Int32(1),
	}
	status, header, body, err := serdeRespReadSnapshot("AssumeRoleWithWebIdentity.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.AssumeRoleWithWebIdentity(context.Background(), &AssumeRoleWithWebIdentityInput{
		RoleArn:          ptr.String("__RoleArn__"),
		RoleSessionName:  ptr.String("__RoleSessionName__"),
		WebIdentityToken: ptr.String("__WebIdentityToken__"),
		ProviderId:       ptr.String("__ProviderId__"),
		PolicyArns: []types.PolicyDescriptorType{
			{
				Arn: ptr.String("__Arn__"),
			},
			{
				Arn: ptr.String("__Arn__"),
			},
		},
		Policy:                  ptr.String("__Policy__"),
		DurationSeconds:         ptr.Int32(1),
		MinimumSessionTokenSize: ptr.Int32(1),
	})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "AssumeRoleWithWebIdentity.response", err)
	}
}

func TestCheckResponseSnapshot_AssumeRoot(t *testing.T) {
	want := &AssumeRootOutput{
		Credentials: &types.Credentials{
			AccessKeyId:     ptr.String("__AccessKeyId__"),
			SecretAccessKey: ptr.String("__SecretAccessKey__"),
			SessionToken:    ptr.String("__SessionToken__"),
			Expiration:      ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		},
		SourceIdentity:          ptr.String("__SourceIdentity__"),
		SessionTokenUtilization: ptr.Int32(1),
		SessionTokenSize:        ptr.Int32(1),
	}
	status, header, body, err := serdeRespReadSnapshot("AssumeRoot.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.AssumeRoot(context.Background(), &AssumeRootInput{
		TargetPrincipal: ptr.String("__TargetPrincipal__"),
		TaskPolicyArn: &types.PolicyDescriptorType{
			Arn: ptr.String("__Arn__"),
		},
		DurationSeconds:         ptr.Int32(1),
		MinimumSessionTokenSize: ptr.Int32(1),
	})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "AssumeRoot.response", err)
	}
}

func TestCheckResponseSnapshot_DecodeAuthorizationMessage(t *testing.T) {
	want := &DecodeAuthorizationMessageOutput{
		DecodedMessage: ptr.String("__DecodedMessage__"),
	}
	status, header, body, err := serdeRespReadSnapshot("DecodeAuthorizationMessage.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.DecodeAuthorizationMessage(context.Background(), &DecodeAuthorizationMessageInput{
		EncodedMessage: ptr.String("__EncodedMessage__"),
	})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "DecodeAuthorizationMessage.response", err)
	}
}

func TestCheckResponseSnapshot_GetAccessKeyInfo(t *testing.T) {
	want := &GetAccessKeyInfoOutput{
		Account: ptr.String("__Account__"),
	}
	status, header, body, err := serdeRespReadSnapshot("GetAccessKeyInfo.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.GetAccessKeyInfo(context.Background(), &GetAccessKeyInfoInput{
		AccessKeyId: ptr.String("__AccessKeyId__"),
	})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GetAccessKeyInfo.response", err)
	}
}

func TestCheckResponseSnapshot_GetCallerIdentity(t *testing.T) {
	want := &GetCallerIdentityOutput{
		UserId:  ptr.String("__UserId__"),
		Account: ptr.String("__Account__"),
		Arn:     ptr.String("__Arn__"),
	}
	status, header, body, err := serdeRespReadSnapshot("GetCallerIdentity.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.GetCallerIdentity(context.Background(), &GetCallerIdentityInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GetCallerIdentity.response", err)
	}
}

func TestCheckResponseSnapshot_GetDelegatedAccessToken(t *testing.T) {
	want := &GetDelegatedAccessTokenOutput{
		Credentials: &types.Credentials{
			AccessKeyId:     ptr.String("__AccessKeyId__"),
			SecretAccessKey: ptr.String("__SecretAccessKey__"),
			SessionToken:    ptr.String("__SessionToken__"),
			Expiration:      ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		},
		PackedPolicySize: ptr.Int32(1),
		AssumedPrincipal: ptr.String("__AssumedPrincipal__"),
	}
	status, header, body, err := serdeRespReadSnapshot("GetDelegatedAccessToken.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.GetDelegatedAccessToken(context.Background(), &GetDelegatedAccessTokenInput{
		TradeInToken: ptr.String("__TradeInToken__"),
	})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GetDelegatedAccessToken.response", err)
	}
}

func TestCheckResponseSnapshot_GetFederationToken(t *testing.T) {
	want := &GetFederationTokenOutput{
		Credentials: &types.Credentials{
			AccessKeyId:     ptr.String("__AccessKeyId__"),
			SecretAccessKey: ptr.String("__SecretAccessKey__"),
			SessionToken:    ptr.String("__SessionToken__"),
			Expiration:      ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		},
		FederatedUser: &types.FederatedUser{
			FederatedUserId: ptr.String("__FederatedUserId__"),
			Arn:             ptr.String("__Arn__"),
		},
		PackedPolicySize:        ptr.Int32(1),
		SessionTokenUtilization: ptr.Int32(1),
		SessionTokenSize:        ptr.Int32(1),
	}
	status, header, body, err := serdeRespReadSnapshot("GetFederationToken.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.GetFederationToken(context.Background(), &GetFederationTokenInput{
		Name:   ptr.String("__Name__"),
		Policy: ptr.String("__Policy__"),
		PolicyArns: []types.PolicyDescriptorType{
			{
				Arn: ptr.String("__Arn__"),
			},
			{
				Arn: ptr.String("__Arn__"),
			},
		},
		DurationSeconds: ptr.Int32(1),
		Tags: []types.Tag{
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
			},
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
			},
		},
		MinimumSessionTokenSize: ptr.Int32(1),
	})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GetFederationToken.response", err)
	}
}

func TestCheckResponseSnapshot_GetSessionToken(t *testing.T) {
	want := &GetSessionTokenOutput{
		Credentials: &types.Credentials{
			AccessKeyId:     ptr.String("__AccessKeyId__"),
			SecretAccessKey: ptr.String("__SecretAccessKey__"),
			SessionToken:    ptr.String("__SessionToken__"),
			Expiration:      ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		},
		SessionTokenUtilization: ptr.Int32(1),
		SessionTokenSize:        ptr.Int32(1),
	}
	status, header, body, err := serdeRespReadSnapshot("GetSessionToken.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.GetSessionToken(context.Background(), &GetSessionTokenInput{
		DurationSeconds:         ptr.Int32(1),
		SerialNumber:            ptr.String("__SerialNumber__"),
		TokenCode:               ptr.String("__TokenCode__"),
		MinimumSessionTokenSize: ptr.Int32(1),
	})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GetSessionToken.response", err)
	}
}

func TestCheckResponseSnapshot_GetWebIdentityToken(t *testing.T) {
	want := &GetWebIdentityTokenOutput{
		WebIdentityToken: ptr.String("__WebIdentityToken__"),
		Expiration:       ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
	}
	status, header, body, err := serdeRespReadSnapshot("GetWebIdentityToken.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.GetWebIdentityToken(context.Background(), &GetWebIdentityTokenInput{
		Audience: []string{
			"__Member__",
			"__Member__",
		},
		DurationSeconds:  ptr.Int32(1),
		SigningAlgorithm: ptr.String("__SigningAlgorithm__"),
		Tags: []types.Tag{
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
			},
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
			},
		},
	})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GetWebIdentityToken.response", err)
	}
}

func TestCheckResponseSnapshot_Error_ExpiredTokenException(t *testing.T) {
	want := &types.ExpiredTokenException{
		Message: ptr.String("__Message__"),
	}
	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.AssumeRole(context.Background(), &AssumeRoleInput{
		RoleArn:         ptr.String("__RoleArn__"),
		RoleSessionName: ptr.String("__RoleSessionName__"),
		PolicyArns: []types.PolicyDescriptorType{
			{
				Arn: ptr.String("__Arn__"),
			},
			{
				Arn: ptr.String("__Arn__"),
			},
		},
		Policy:          ptr.String("__Policy__"),
		DurationSeconds: ptr.Int32(1),
		Tags: []types.Tag{
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
			},
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
			},
		},
		TransitiveTagKeys: []string{
			"__Member__",
			"__Member__",
		},
		ExternalId:     ptr.String("__ExternalId__"),
		SerialNumber:   ptr.String("__SerialNumber__"),
		TokenCode:      ptr.String("__TokenCode__"),
		SourceIdentity: ptr.String("__SourceIdentity__"),
		ProvidedContexts: []types.ProvidedContext{
			{
				ProviderArn:      ptr.String("__ProviderArn__"),
				ContextAssertion: ptr.String("__ContextAssertion__"),
			},
			{
				ProviderArn:      ptr.String("__ProviderArn__"),
				ContextAssertion: ptr.String("__ContextAssertion__"),
			},
		},
		MinimumSessionTokenSize: ptr.Int32(1),
	})
	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_ExpiredTradeInTokenException(t *testing.T) {
	want := &types.ExpiredTradeInTokenException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("ExpiredTradeInTokenException.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.GetDelegatedAccessToken(context.Background(), &GetDelegatedAccessTokenInput{
		TradeInToken: ptr.String("__TradeInToken__"),
	})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.ExpiredTradeInTokenException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.ExpiredTradeInTokenException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "ExpiredTradeInTokenException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_IDPCommunicationErrorException(t *testing.T) {
	want := &types.IDPCommunicationErrorException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("IDPCommunicationErrorException.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.AssumeRoleWithWebIdentity(context.Background(), &AssumeRoleWithWebIdentityInput{
		RoleArn:          ptr.String("__RoleArn__"),
		RoleSessionName:  ptr.String("__RoleSessionName__"),
		WebIdentityToken: ptr.String("__WebIdentityToken__"),
		ProviderId:       ptr.String("__ProviderId__"),
		PolicyArns: []types.PolicyDescriptorType{
			{
				Arn: ptr.String("__Arn__"),
			},
			{
				Arn: ptr.String("__Arn__"),
			},
		},
		Policy:                  ptr.String("__Policy__"),
		DurationSeconds:         ptr.Int32(1),
		MinimumSessionTokenSize: ptr.Int32(1),
	})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.IDPCommunicationErrorException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.IDPCommunicationErrorException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "IDPCommunicationErrorException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_IDPRejectedClaimException(t *testing.T) {
	want := &types.IDPRejectedClaimException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("IDPRejectedClaimException.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.AssumeRoleWithSAML(context.Background(), &AssumeRoleWithSAMLInput{
		RoleArn:       ptr.String("__RoleArn__"),
		PrincipalArn:  ptr.String("__PrincipalArn__"),
		SAMLAssertion: ptr.String("__SAMLAssertion__"),
		PolicyArns: []types.PolicyDescriptorType{
			{
				Arn: ptr.String("__Arn__"),
			},
			{
				Arn: ptr.String("__Arn__"),
			},
		},
		Policy:                  ptr.String("__Policy__"),
		DurationSeconds:         ptr.Int32(1),
		MinimumSessionTokenSize: ptr.Int32(1),
	})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.IDPRejectedClaimException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.IDPRejectedClaimException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "IDPRejectedClaimException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_InvalidAuthorizationMessageException(t *testing.T) {
	want := &types.InvalidAuthorizationMessageException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("InvalidAuthorizationMessageException.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.DecodeAuthorizationMessage(context.Background(), &DecodeAuthorizationMessageInput{
		EncodedMessage: ptr.String("__EncodedMessage__"),
	})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.InvalidAuthorizationMessageException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.InvalidAuthorizationMessageException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "InvalidAuthorizationMessageException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_InvalidIdentityTokenException(t *testing.T) {
	want := &types.InvalidIdentityTokenException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("InvalidIdentityTokenException.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.AssumeRoleWithSAML(context.Background(), &AssumeRoleWithSAMLInput{
		RoleArn:       ptr.String("__RoleArn__"),
		PrincipalArn:  ptr.String("__PrincipalArn__"),
		SAMLAssertion: ptr.String("__SAMLAssertion__"),
		PolicyArns: []types.PolicyDescriptorType{
			{
				Arn: ptr.String("__Arn__"),
			},
			{
				Arn: ptr.String("__Arn__"),
			},
		},
		Policy:                  ptr.String("__Policy__"),
		DurationSeconds:         ptr.Int32(1),
		MinimumSessionTokenSize: ptr.Int32(1),
	})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.InvalidIdentityTokenException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.InvalidIdentityTokenException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "InvalidIdentityTokenException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_JWTPayloadSizeExceededException(t *testing.T) {
	want := &types.JWTPayloadSizeExceededException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("JWTPayloadSizeExceededException.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.GetWebIdentityToken(context.Background(), &GetWebIdentityTokenInput{
		Audience: []string{
			"__Member__",
			"__Member__",
		},
		DurationSeconds:  ptr.Int32(1),
		SigningAlgorithm: ptr.String("__SigningAlgorithm__"),
		Tags: []types.Tag{
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
			},
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
			},
		},
	})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.JWTPayloadSizeExceededException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.JWTPayloadSizeExceededException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "JWTPayloadSizeExceededException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_MalformedPolicyDocumentException(t *testing.T) {
	want := &types.MalformedPolicyDocumentException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("MalformedPolicyDocumentException.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.AssumeRole(context.Background(), &AssumeRoleInput{
		RoleArn:         ptr.String("__RoleArn__"),
		RoleSessionName: ptr.String("__RoleSessionName__"),
		PolicyArns: []types.PolicyDescriptorType{
			{
				Arn: ptr.String("__Arn__"),
			},
			{
				Arn: ptr.String("__Arn__"),
			},
		},
		Policy:          ptr.String("__Policy__"),
		DurationSeconds: ptr.Int32(1),
		Tags: []types.Tag{
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
			},
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
			},
		},
		TransitiveTagKeys: []string{
			"__Member__",
			"__Member__",
		},
		ExternalId:     ptr.String("__ExternalId__"),
		SerialNumber:   ptr.String("__SerialNumber__"),
		TokenCode:      ptr.String("__TokenCode__"),
		SourceIdentity: ptr.String("__SourceIdentity__"),
		ProvidedContexts: []types.ProvidedContext{
			{
				ProviderArn:      ptr.String("__ProviderArn__"),
				ContextAssertion: ptr.String("__ContextAssertion__"),
			},
			{
				ProviderArn:      ptr.String("__ProviderArn__"),
				ContextAssertion: ptr.String("__ContextAssertion__"),
			},
		},
		MinimumSessionTokenSize: ptr.Int32(1),
	})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.MalformedPolicyDocumentException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.MalformedPolicyDocumentException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "MalformedPolicyDocumentException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_OutboundWebIdentityFederationDisabledException(t *testing.T) {
	want := &types.OutboundWebIdentityFederationDisabledException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("OutboundWebIdentityFederationDisabledException.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.GetWebIdentityToken(context.Background(), &GetWebIdentityTokenInput{
		Audience: []string{
			"__Member__",
			"__Member__",
		},
		DurationSeconds:  ptr.Int32(1),
		SigningAlgorithm: ptr.String("__SigningAlgorithm__"),
		Tags: []types.Tag{
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
			},
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
			},
		},
	})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.OutboundWebIdentityFederationDisabledException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.OutboundWebIdentityFederationDisabledException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "OutboundWebIdentityFederationDisabledException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_PackedPolicyTooLargeException(t *testing.T) {
	want := &types.PackedPolicyTooLargeException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("PackedPolicyTooLargeException.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.AssumeRole(context.Background(), &AssumeRoleInput{
		RoleArn:         ptr.String("__RoleArn__"),
		RoleSessionName: ptr.String("__RoleSessionName__"),
		PolicyArns: []types.PolicyDescriptorType{
			{
				Arn: ptr.String("__Arn__"),
			},
			{
				Arn: ptr.String("__Arn__"),
			},
		},
		Policy:          ptr.String("__Policy__"),
		DurationSeconds: ptr.Int32(1),
		Tags: []types.Tag{
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
			},
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
			},
		},
		TransitiveTagKeys: []string{
			"__Member__",
			"__Member__",
		},
		ExternalId:     ptr.String("__ExternalId__"),
		SerialNumber:   ptr.String("__SerialNumber__"),
		TokenCode:      ptr.String("__TokenCode__"),
		SourceIdentity: ptr.String("__SourceIdentity__"),
		ProvidedContexts: []types.ProvidedContext{
			{
				ProviderArn:      ptr.String("__ProviderArn__"),
				ContextAssertion: ptr.String("__ContextAssertion__"),
			},
			{
				ProviderArn:      ptr.String("__ProviderArn__"),
				ContextAssertion: ptr.String("__ContextAssertion__"),
			},
		},
		MinimumSessionTokenSize: ptr.Int32(1),
	})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.PackedPolicyTooLargeException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.PackedPolicyTooLargeException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "PackedPolicyTooLargeException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_RegionDisabledException(t *testing.T) {
	want := &types.RegionDisabledException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("RegionDisabledException.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.AssumeRole(context.Background(), &AssumeRoleInput{
		RoleArn:         ptr.String("__RoleArn__"),
		RoleSessionName: ptr.String("__RoleSessionName__"),
		PolicyArns: []types.PolicyDescriptorType{
			{
				Arn: ptr.String("__Arn__"),
			},
			{
				Arn: ptr.String("__Arn__"),
			},
		},
		Policy:          ptr.String("__Policy__"),
		DurationSeconds: ptr.Int32(1),
		Tags: []types.Tag{
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
			},
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
			},
		},
		TransitiveTagKeys: []string{
			"__Member__",
			"__Member__",
		},
		ExternalId:     ptr.String("__ExternalId__"),
		SerialNumber:   ptr.String("__SerialNumber__"),
		TokenCode:      ptr.String("__TokenCode__"),
		SourceIdentity: ptr.String("__SourceIdentity__"),
		ProvidedContexts: []types.ProvidedContext{
			{
				ProviderArn:      ptr.String("__ProviderArn__"),
				ContextAssertion: ptr.String("__ContextAssertion__"),
			},
			{
				ProviderArn:      ptr.String("__ProviderArn__"),
				ContextAssertion: ptr.String("__ContextAssertion__"),
			},
		},
		MinimumSessionTokenSize: ptr.Int32(1),
	})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.RegionDisabledException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.RegionDisabledException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "RegionDisabledException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_SessionDurationEscalationException(t *testing.T) {
	want := &types.SessionDurationEscalationException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("SessionDurationEscalationException.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.GetWebIdentityToken(context.Background(), &GetWebIdentityTokenInput{
		Audience: []string{
			"__Member__",
			"__Member__",
		},
		DurationSeconds:  ptr.Int32(1),
		SigningAlgorithm: ptr.String("__SigningAlgorithm__"),
		Tags: []types.Tag{
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
			},
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
			},
		},
	})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.SessionDurationEscalationException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.SessionDurationEscalationException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "SessionDurationEscalationException.error", err)
	}
}