func ExampleCognitoIdentity_MergeDeveloperIdentities() {
svc := cognitoidentity.New(nil)
params := &cognitoidentity.MergeDeveloperIdentitiesInput{
DestinationUserIdentifier: aws.String("DeveloperUserIdentifier"), // Required
DeveloperProviderName: aws.String("DeveloperProviderName"), // Required
IdentityPoolID: aws.String("IdentityPoolId"), // Required
SourceUserIdentifier: aws.String("DeveloperUserIdentifier"), // Required
}
resp, err := svc.MergeDeveloperIdentities(params)
if err != nil {
if awsErr, ok := err.(awserr.Error); ok {
// Generic AWS error with Code, Message, and original error (if any)
fmt.Println(awsErr.Code(), awsErr.Message(), awsErr.OrigErr())
if reqErr, ok := err.(awserr.RequestFailure); ok {
// A service error occurred
fmt.Println(reqErr.Code(), reqErr.Message(), reqErr.StatusCode(), reqErr.RequestID())
}
} else {
// This case should never be hit, the SDK should always return an
// error which satisfies the awserr.Error interface.
fmt.Println(err.Error())
}
}
// Pretty-print the response data.
fmt.Println(awsutil.Prettify(resp))
}
func ExampleCognitoIdentity_LookupDeveloperIdentity() {
svc := cognitoidentity.New(nil)
params := &cognitoidentity.LookupDeveloperIdentityInput{
IdentityPoolID: aws.String("IdentityPoolId"), // Required
DeveloperUserIdentifier: aws.String("DeveloperUserIdentifier"),
IdentityID: aws.String("IdentityId"),
MaxResults: aws.Int64(1),
NextToken: aws.String("PaginationKey"),
}
resp, err := svc.LookupDeveloperIdentity(params)
if err != nil {
if awsErr, ok := err.(awserr.Error); ok {
// Generic AWS error with Code, Message, and original error (if any)
fmt.Println(awsErr.Code(), awsErr.Message(), awsErr.OrigErr())
if reqErr, ok := err.(awserr.RequestFailure); ok {
// A service error occurred
fmt.Println(reqErr.Code(), reqErr.Message(), reqErr.StatusCode(), reqErr.RequestID())
}
} else {
// This case should never be hit, the SDK should always return an
// error which satisfies the awserr.Error interface.
fmt.Println(err.Error())
}
}
// Pretty-print the response data.
fmt.Println(awsutil.Prettify(resp))
}
func ExampleCognitoIdentity_DeleteIdentityPool() {
svc := cognitoidentity.New(nil)
params := &cognitoidentity.DeleteIdentityPoolInput{
IdentityPoolID: aws.String("IdentityPoolId"), // Required
}
resp, err := svc.DeleteIdentityPool(params)
if err != nil {
if awsErr, ok := err.(awserr.Error); ok {
// Generic AWS error with Code, Message, and original error (if any)
fmt.Println(awsErr.Code(), awsErr.Message(), awsErr.OrigErr())
if reqErr, ok := err.(awserr.RequestFailure); ok {
// A service error occurred
fmt.Println(reqErr.Code(), reqErr.Message(), reqErr.StatusCode(), reqErr.RequestID())
}
} else {
// This case should never be hit, the SDK should always return an
// error which satisfies the awserr.Error interface.
fmt.Println(err.Error())
}
}
// Pretty-print the response data.
fmt.Println(awsutil.StringValue(resp))
}
func ExampleCognitoIdentity_UnlinkIdentity() {
svc := cognitoidentity.New(nil)
params := &cognitoidentity.UnlinkIdentityInput{
IdentityID: aws.String("IdentityId"), // Required
Logins: map[string]*string{ // Required
"Key": aws.String("IdentityProviderToken"), // Required
// More values...
},
LoginsToRemove: []*string{ // Required
aws.String("IdentityProviderName"), // Required
// More values...
},
}
resp, err := svc.UnlinkIdentity(params)
if err != nil {
if awsErr, ok := err.(awserr.Error); ok {
// Generic AWS error with Code, Message, and original error (if any)
fmt.Println(awsErr.Code(), awsErr.Message(), awsErr.OrigErr())
if reqErr, ok := err.(awserr.RequestFailure); ok {
// A service error occurred
fmt.Println(reqErr.Code(), reqErr.Message(), reqErr.StatusCode(), reqErr.RequestID())
}
} else {
// This case should never be hit, the SDK should always return an
// error which satisfies the awserr.Error interface.
fmt.Println(err.Error())
}
}
// Pretty-print the response data.
fmt.Println(awsutil.StringValue(resp))
}
func ExampleCognitoIdentity_DeleteIdentities() {
sess, err := session.NewSession()
if err != nil {
fmt.Println("failed to create session,", err)
return
}
svc := cognitoidentity.New(sess)
params := &cognitoidentity.DeleteIdentitiesInput{
IdentityIdsToDelete: []*string{ // Required
aws.String("IdentityId"), // Required
// More values...
},
}
resp, err := svc.DeleteIdentities(params)
if err != nil {
// Print the error, cast err to awserr.Error to get the Code and
// Message from an error.
fmt.Println(err.Error())
return
}
// Pretty-print the response data.
fmt.Println(resp)
}
func ExampleCognitoIdentity_UnlinkIdentity() {
svc := cognitoidentity.New(session.New())
params := &cognitoidentity.UnlinkIdentityInput{
IdentityId: aws.String("IdentityId"), // Required
Logins: map[string]*string{ // Required
"Key": aws.String("IdentityProviderToken"), // Required
// More values...
},
LoginsToRemove: []*string{ // Required
aws.String("IdentityProviderName"), // Required
// More values...
},
}
resp, err := svc.UnlinkIdentity(params)
if err != nil {
// Print the error, cast err to awserr.Error to get the Code and
// Message from an error.
fmt.Println(err.Error())
return
}
// Pretty-print the response data.
fmt.Println(resp)
}
func ExampleCognitoIdentity_SetIdentityPoolRoles() {
sess, err := session.NewSession()
if err != nil {
fmt.Println("failed to create session,", err)
return
}
svc := cognitoidentity.New(sess)
params := &cognitoidentity.SetIdentityPoolRolesInput{
IdentityPoolId: aws.String("IdentityPoolId"), // Required
Roles: map[string]*string{ // Required
"Key": aws.String("ARNString"), // Required
// More values...
},
}
resp, err := svc.SetIdentityPoolRoles(params)
if err != nil {
// Print the error, cast err to awserr.Error to get the Code and
// Message from an error.
fmt.Println(err.Error())
return
}
// Pretty-print the response data.
fmt.Println(resp)
}
func ExampleCognitoIdentity_UnlinkDeveloperIdentity() {
sess, err := session.NewSession()
if err != nil {
fmt.Println("failed to create session,", err)
return
}
svc := cognitoidentity.New(sess)
params := &cognitoidentity.UnlinkDeveloperIdentityInput{
DeveloperProviderName: aws.String("DeveloperProviderName"), // Required
DeveloperUserIdentifier: aws.String("DeveloperUserIdentifier"), // Required
IdentityId: aws.String("IdentityId"), // Required
IdentityPoolId: aws.String("IdentityPoolId"), // Required
}
resp, err := svc.UnlinkDeveloperIdentity(params)
if err != nil {
// Print the error, cast err to awserr.Error to get the Code and
// Message from an error.
fmt.Println(err.Error())
return
}
// Pretty-print the response data.
fmt.Println(resp)
}
func ExampleCognitoIdentity_LookupDeveloperIdentity() {
sess, err := session.NewSession()
if err != nil {
fmt.Println("failed to create session,", err)
return
}
svc := cognitoidentity.New(sess)
params := &cognitoidentity.LookupDeveloperIdentityInput{
IdentityPoolId: aws.String("IdentityPoolId"), // Required
DeveloperUserIdentifier: aws.String("DeveloperUserIdentifier"),
IdentityId: aws.String("IdentityId"),
MaxResults: aws.Int64(1),
NextToken: aws.String("PaginationKey"),
}
resp, err := svc.LookupDeveloperIdentity(params)
if err != nil {
// Print the error, cast err to awserr.Error to get the Code and
// Message from an error.
fmt.Println(err.Error())
return
}
// Pretty-print the response data.
fmt.Println(resp)
}
func ExampleCognitoIdentity_ListIdentities() {
sess, err := session.NewSession()
if err != nil {
fmt.Println("failed to create session,", err)
return
}
svc := cognitoidentity.New(sess)
params := &cognitoidentity.ListIdentitiesInput{
IdentityPoolId: aws.String("IdentityPoolId"), // Required
MaxResults: aws.Int64(1), // Required
HideDisabled: aws.Bool(true),
NextToken: aws.String("PaginationKey"),
}
resp, err := svc.ListIdentities(params)
if err != nil {
// Print the error, cast err to awserr.Error to get the Code and
// Message from an error.
fmt.Println(err.Error())
return
}
// Pretty-print the response data.
fmt.Println(resp)
}
func ExampleCognitoIdentity_GetOpenIdTokenForDeveloperIdentity() {
sess, err := session.NewSession()
if err != nil {
fmt.Println("failed to create session,", err)
return
}
svc := cognitoidentity.New(sess)
params := &cognitoidentity.GetOpenIdTokenForDeveloperIdentityInput{
IdentityPoolId: aws.String("IdentityPoolId"), // Required
Logins: map[string]*string{ // Required
"Key": aws.String("IdentityProviderToken"), // Required
// More values...
},
IdentityId: aws.String("IdentityId"),
TokenDuration: aws.Int64(1),
}
resp, err := svc.GetOpenIdTokenForDeveloperIdentity(params)
if err != nil {
// Print the error, cast err to awserr.Error to get the Code and
// Message from an error.
fmt.Println(err.Error())
return
}
// Pretty-print the response data.
fmt.Println(resp)
}
func ExampleCognitoIdentity_UpdateIdentityPool() {
svc := cognitoidentity.New(nil)
params := &cognitoidentity.IdentityPool{
AllowUnauthenticatedIdentities: aws.Bool(true), // Required
IdentityPoolId: aws.String("IdentityPoolId"), // Required
IdentityPoolName: aws.String("IdentityPoolName"), // Required
DeveloperProviderName: aws.String("DeveloperProviderName"),
OpenIdConnectProviderARNs: []*string{
aws.String("ARNString"), // Required
// More values...
},
SupportedLoginProviders: map[string]*string{
"Key": aws.String("IdentityProviderId"), // Required
// More values...
},
}
resp, err := svc.UpdateIdentityPool(params)
if err != nil {
// Print the error, cast err to awserr.Error to get the Code and
// Message from an error.
fmt.Println(err.Error())
return
}
// Pretty-print the response data.
fmt.Println(resp)
}
func ExampleCognitoIdentity_GetCredentialsForIdentity() {
sess, err := session.NewSession()
if err != nil {
fmt.Println("failed to create session,", err)
return
}
svc := cognitoidentity.New(sess)
params := &cognitoidentity.GetCredentialsForIdentityInput{
IdentityId: aws.String("IdentityId"), // Required
CustomRoleArn: aws.String("ARNString"),
Logins: map[string]*string{
"Key": aws.String("IdentityProviderToken"), // Required
// More values...
},
}
resp, err := svc.GetCredentialsForIdentity(params)
if err != nil {
// Print the error, cast err to awserr.Error to get the Code and
// Message from an error.
fmt.Println(err.Error())
return
}
// Pretty-print the response data.
fmt.Println(resp)
}
func ExampleCognitoIdentity_CreateIdentityPool() {
sess, err := session.NewSession()
if err != nil {
fmt.Println("failed to create session,", err)
return
}
svc := cognitoidentity.New(sess)
params := &cognitoidentity.CreateIdentityPoolInput{
AllowUnauthenticatedIdentities: aws.Bool(true), // Required
IdentityPoolName: aws.String("IdentityPoolName"), // Required
CognitoIdentityProviders: []*cognitoidentity.Provider{
{ // Required
ClientId: aws.String("ProviderClientId"),
ProviderName: aws.String("ProviderName"),
},
// More values...
},
DeveloperProviderName: aws.String("DeveloperProviderName"),
OpenIdConnectProviderARNs: []*string{
aws.String("ARNString"), // Required
// More values...
},
SamlProviderARNs: []*string{
aws.String("ARNString"), // Required
// More values...
},
SupportedLoginProviders: map[string]*string{
"Key": aws.String("IdentityProviderId"), // Required
// More values...
},
}
resp, err := svc.CreateIdentityPool(params)
if err != nil {
// Print the error, cast err to awserr.Error to get the Code and
// Message from an error.
fmt.Println(err.Error())
return
}
// Pretty-print the response data.
fmt.Println(resp)
}
func ExampleCognitoIdentity_DescribeIdentity() {
svc := cognitoidentity.New(session.New())
params := &cognitoidentity.DescribeIdentityInput{
IdentityId: aws.String("IdentityId"), // Required
}
resp, err := svc.DescribeIdentity(params)
if err != nil {
// Print the error, cast err to awserr.Error to get the Code and
// Message from an error.
fmt.Println(err.Error())
return
}
// Pretty-print the response data.
fmt.Println(resp)
}
func ExampleCognitoIdentity_GetIdentityPoolRoles() {
svc := cognitoidentity.New(nil)
params := &cognitoidentity.GetIdentityPoolRolesInput{
IdentityPoolId: aws.String("IdentityPoolId"), // Required
}
resp, err := svc.GetIdentityPoolRoles(params)
if err != nil {
// Print the error, cast err to awserr.Error to get the Code and
// Message from an error.
fmt.Println(err.Error())
return
}
// Pretty-print the response data.
fmt.Println(resp)
}
func ExampleCognitoIdentity_ListIdentityPools() {
svc := cognitoidentity.New(session.New())
params := &cognitoidentity.ListIdentityPoolsInput{
MaxResults: aws.Int64(1), // Required
NextToken: aws.String("PaginationKey"),
}
resp, err := svc.ListIdentityPools(params)
if err != nil {
// Print the error, cast err to awserr.Error to get the Code and
// Message from an error.
fmt.Println(err.Error())
return
}
// Pretty-print the response data.
fmt.Println(resp)
}
func ExampleCognitoIdentity_MergeDeveloperIdentities() {
svc := cognitoidentity.New(session.New())
params := &cognitoidentity.MergeDeveloperIdentitiesInput{
DestinationUserIdentifier: aws.String("DeveloperUserIdentifier"), // Required
DeveloperProviderName: aws.String("DeveloperProviderName"), // Required
IdentityPoolId: aws.String("IdentityPoolId"), // Required
SourceUserIdentifier: aws.String("DeveloperUserIdentifier"), // Required
}
resp, err := svc.MergeDeveloperIdentities(params)
if err != nil {
// Print the error, cast err to awserr.Error to get the Code and
// Message from an error.
fmt.Println(err.Error())
return
}
// Pretty-print the response data.
fmt.Println(resp)
}
func ExampleCognitoIdentity_GetOpenIdToken() {
svc := cognitoidentity.New(nil)
params := &cognitoidentity.GetOpenIdTokenInput{
IdentityId: aws.String("IdentityId"), // Required
Logins: map[string]*string{
"Key": aws.String("IdentityProviderToken"), // Required
// More values...
},
}
resp, err := svc.GetOpenIdToken(params)
if err != nil {
// Print the error, cast err to awserr.Error to get the Code and
// Message from an error.
fmt.Println(err.Error())
return
}
// Pretty-print the response data.
fmt.Println(resp)
}
func ExampleCognitoIdentity_UpdateIdentityPool() {
svc := cognitoidentity.New(nil)
params := &cognitoidentity.IdentityPool{
AllowUnauthenticatedIdentities: aws.Boolean(true), // Required
IdentityPoolID: aws.String("IdentityPoolId"), // Required
IdentityPoolName: aws.String("IdentityPoolName"), // Required
DeveloperProviderName: aws.String("DeveloperProviderName"),
OpenIDConnectProviderARNs: []*string{
aws.String("ARNString"), // Required
// More values...
},
SupportedLoginProviders: map[string]*string{
"Key": aws.String("IdentityProviderId"), // Required
// More values...
},
}
resp, err := svc.UpdateIdentityPool(params)
if err != nil {
if awsErr, ok := err.(awserr.Error); ok {
// Generic AWS error with Code, Message, and original error (if any)
fmt.Println(awsErr.Code(), awsErr.Message(), awsErr.OrigErr())
if reqErr, ok := err.(awserr.RequestFailure); ok {
// A service error occurred
fmt.Println(reqErr.Code(), reqErr.Message(), reqErr.StatusCode(), reqErr.RequestID())
}
} else {
// This case should never be hit, the SDK should always return an
// error which satisfies the awserr.Error interface.
fmt.Println(err.Error())
}
}
// Pretty-print the response data.
fmt.Println(awsutil.StringValue(resp))
}
package cognitoidentity_test
import (
"testing"
"github.com/aws/aws-sdk-go/aws"
"github.com/aws/aws-sdk-go/service/cognitoidentity"
"github.com/stretchr/testify/assert"
)
var svc = cognitoidentity.New(&aws.Config{
Region: "mock-region",
})
func TestUnsignedRequest_GetID(t *testing.T) {
req, _ := svc.GetIDRequest(&cognitoidentity.GetIDInput{
IdentityPoolID: aws.String("IdentityPoolId"),
})
err := req.Sign()
assert.NoError(t, err)
assert.Equal(t, "", req.HTTPRequest.Header.Get("Authorization"))
}
func TestUnsignedRequest_GetOpenIDToken(t *testing.T) {
req, _ := svc.GetOpenIDTokenRequest(&cognitoidentity.GetOpenIDTokenInput{
IdentityID: aws.String("IdentityId"),
})
err := req.Sign()
assert.NoError(t, err)
func init() {
Before("@cognitoidentity", func() {
World["client"] = cognitoidentity.New(smoke.Session)
})
}
package cognitoidentity_test
import (
"testing"
"github.com/aws/aws-sdk-go/aws"
"github.com/aws/aws-sdk-go/awstesting/unit"
"github.com/aws/aws-sdk-go/service/cognitoidentity"
"github.com/stretchr/testify/assert"
)
var svc = cognitoidentity.New(unit.Session)
func TestUnsignedRequest_GetID(t *testing.T) {
req, _ := svc.GetIdRequest(&cognitoidentity.GetIdInput{
IdentityPoolId: aws.String("IdentityPoolId"),
})
err := req.Sign()
assert.NoError(t, err)
assert.Equal(t, "", req.HTTPRequest.Header.Get("Authorization"))
}
func TestUnsignedRequest_GetOpenIDToken(t *testing.T) {
req, _ := svc.GetOpenIdTokenRequest(&cognitoidentity.GetOpenIdTokenInput{
IdentityId: aws.String("IdentityId"),
})
err := req.Sign()
assert.NoError(t, err)
assert.Equal(t, "", req.HTTPRequest.Header.Get("Authorization"))
// Client configures and returns a fully initialized AWSClient
func (c *Config) Client() (interface{}, error) {
var client AWSClient
// Get the auth and region. This can fail if keys/regions were not
// specified and we're attempting to use the environment.
var errs []error
log.Println("[INFO] Building AWS region structure")
err := c.ValidateRegion()
if err != nil {
errs = append(errs, err)
}
if len(errs) == 0 {
// store AWS region in client struct, for region specific operations such as
// bucket storage in S3
client.region = c.Region
log.Println("[INFO] Building AWS auth structure")
// We fetched all credential sources in Provider. If they are
// available, they'll already be in c. See Provider definition.
creds := credentials.NewStaticCredentials(c.AccessKey, c.SecretKey, c.Token)
awsConfig := &aws.Config{
Credentials: creds,
Region: aws.String(c.Region),
MaxRetries: aws.Int(c.MaxRetries),
HTTPClient: cleanhttp.DefaultClient(),
}
log.Println("[INFO] Initializing IAM Connection")
sess := session.New(awsConfig)
client.iamconn = iam.New(sess)
err := c.ValidateCredentials(client.iamconn)
if err != nil {
errs = append(errs, err)
}
// Some services exist only in us-east-1, e.g. because they manage
// resources that can span across multiple regions, or because
// signature format v4 requires region to be us-east-1 for global
// endpoints:
// http://docs.aws.amazon.com/general/latest/gr/sigv4_changes.html
usEast1AwsConfig := &aws.Config{
Credentials: creds,
Region: aws.String("us-east-1"),
MaxRetries: aws.Int(c.MaxRetries),
HTTPClient: cleanhttp.DefaultClient(),
}
usEast1Sess := session.New(usEast1AwsConfig)
awsDynamoDBConfig := *awsConfig
awsDynamoDBConfig.Endpoint = aws.String(c.DynamoDBEndpoint)
log.Println("[INFO] Initializing DynamoDB connection")
dynamoSess := session.New(&awsDynamoDBConfig)
client.dynamodbconn = dynamodb.New(dynamoSess)
log.Println("[INFO] Initializing ELB connection")
client.elbconn = elb.New(sess)
log.Println("[INFO] Initializing S3 connection")
client.s3conn = s3.New(sess)
log.Println("[INFO] Initializing SQS connection")
client.sqsconn = sqs.New(sess)
log.Println("[INFO] Initializing SNS connection")
client.snsconn = sns.New(sess)
log.Println("[INFO] Initializing RDS Connection")
client.rdsconn = rds.New(sess)
awsKinesisConfig := *awsConfig
awsKinesisConfig.Endpoint = aws.String(c.KinesisEndpoint)
log.Println("[INFO] Initializing Kinesis Connection")
kinesisSess := session.New(&awsKinesisConfig)
client.kinesisconn = kinesis.New(kinesisSess)
authErr := c.ValidateAccountId(client.iamconn)
if authErr != nil {
errs = append(errs, authErr)
}
log.Println("[INFO] Initializing Kinesis Firehose Connection")
client.firehoseconn = firehose.New(sess)
log.Println("[INFO] Initializing AutoScaling connection")
client.autoscalingconn = autoscaling.New(sess)
log.Println("[INFO] Initializing EC2 Connection")
client.ec2conn = ec2.New(sess)
log.Println("[INFO] Initializing ECS Connection")
client.ecsconn = ecs.New(sess)
log.Println("[INFO] Initializing EFS Connection")
client.efsconn = efs.New(sess)
log.Println("[INFO] Initializing ElasticSearch Connection")
client.esconn = elasticsearch.New(sess)
log.Println("[INFO] Initializing Route 53 connection")
client.r53conn = route53.New(usEast1Sess)
log.Println("[INFO] Initializing Elasticache Connection")
client.elasticacheconn = elasticache.New(sess)
log.Println("[INFO] Initializing Lambda Connection")
client.lambdaconn = lambda.New(sess)
log.Println("[INFO] Initializing Cloudformation Connection")
client.cfconn = cloudformation.New(sess)
log.Println("[INFO] Initializing CloudWatch SDK connection")
client.cloudwatchconn = cloudwatch.New(sess)
log.Println("[INFO] Initializing CloudTrail connection")
client.cloudtrailconn = cloudtrail.New(sess)
log.Println("[INFO] Initializing CloudWatch Logs connection")
client.cloudwatchlogsconn = cloudwatchlogs.New(sess)
log.Println("[INFO] Initializing OpsWorks Connection")
client.opsworksconn = opsworks.New(usEast1Sess)
log.Println("[INFO] Initializing Directory Service connection")
client.dsconn = directoryservice.New(sess)
log.Println("[INFO] Initializing Glacier connection")
client.glacierconn = glacier.New(sess)
log.Println("[INFO] Initializing CodeDeploy Connection")
client.codedeployconn = codedeploy.New(sess)
log.Println("[INFO] Initializing CodeCommit SDK connection")
client.codecommitconn = codecommit.New(usEast1Sess)
log.Println("[INFO] Initializing CognitoIdentity SDK connection")
client.cognitoidconn = cognitoidentity.New(usEast1Sess)
log.Println("[INFO] Initializing APIGateway SDK connection")
client.apigatewayconn = apigateway.New(usEast1Sess)
}
if len(errs) > 0 {
return nil, &multierror.Error{Errors: errs}
}
return &client, nil
}
func init() {
Before("@cognitoidentity", func() {
World["client"] = cognitoidentity.New(nil)
})
}
func TestInterface(t *testing.T) {
assert.Implements(t, (*cognitoidentityiface.CognitoIdentityAPI)(nil), cognitoidentity.New(nil))
}
package cognitoidentity_test
import (
"testing"
"github.com/aws/aws-sdk-go/aws"
"github.com/aws/aws-sdk-go/service/cognitoidentity"
"github.com/stretchr/testify/assert"
)
var svc = cognitoidentity.New(&aws.Config{
Region: aws.String("mock-region"),
})
func TestUnsignedRequest_GetID(t *testing.T) {
req, _ := svc.GetIdRequest(&cognitoidentity.GetIdInput{
IdentityPoolId: aws.String("IdentityPoolId"),
})
err := req.Sign()
assert.NoError(t, err)
assert.Equal(t, "", req.HTTPRequest.Header.Get("Authorization"))
}
func TestUnsignedRequest_GetOpenIDToken(t *testing.T) {
req, _ := svc.GetOpenIdTokenRequest(&cognitoidentity.GetOpenIdTokenInput{
IdentityId: aws.String("IdentityId"),
})
err := req.Sign()
assert.NoError(t, err)