repo_name stringlengths 1 52 | repo_creator stringclasses 6
values | programming_language stringclasses 4
values | code stringlengths 0 9.68M | num_lines int64 1 234k |
|---|---|---|---|---|
aws-sdk-go-v2 | aws | Go | //go:build integration
// +build integration
package codepipeline
import (
"context"
"errors"
"testing"
"time"
"github.com/aws/aws-sdk-go-v2/aws"
"github.com/aws/aws-sdk-go-v2/service/codepipeline"
"github.com/aws/aws-sdk-go-v2/service/internal/integrationtest"
"github.com/aws/smithy-go"
)
func TestInteg_00_ListPipelines(t *testing.T) {
ctx, cancelFn := context.WithTimeout(context.Background(), 5*time.Second)
defer cancelFn()
cfg, err := integrationtest.LoadConfigWithDefaultRegion("us-west-2")
if err != nil {
t.Fatalf("failed to load config, %v", err)
}
client := codepipeline.NewFromConfig(cfg)
params := &codepipeline.ListPipelinesInput{}
_, err = client.ListPipelines(ctx, params)
if err != nil {
t.Errorf("expect no error, got %v", err)
}
}
func TestInteg_01_GetPipeline(t *testing.T) {
ctx, cancelFn := context.WithTimeout(context.Background(), 5*time.Second)
defer cancelFn()
cfg, err := integrationtest.LoadConfigWithDefaultRegion("us-west-2")
if err != nil {
t.Fatalf("failed to load config, %v", err)
}
client := codepipeline.NewFromConfig(cfg)
params := &codepipeline.GetPipelineInput{
Name: aws.String("fake-pipeline"),
}
_, err = client.GetPipeline(ctx, params)
if err == nil {
t.Fatalf("expect request to fail")
}
var apiErr smithy.APIError
if !errors.As(err, &apiErr) {
t.Fatalf("expect error to be API error, was not, %v", err)
}
if len(apiErr.ErrorCode()) == 0 {
t.Errorf("expect non-empty error code")
}
if len(apiErr.ErrorMessage()) == 0 {
t.Errorf("expect non-empty error message")
}
}
| 64 |
aws-sdk-go-v2 | aws | Go | //go:build integration
// +build integration
package codestar
import (
"context"
"testing"
"time"
"github.com/aws/aws-sdk-go-v2/service/codestar"
"github.com/aws/aws-sdk-go-v2/service/internal/integrationtest"
)
func TestInteg_00_ListProjects(t *testing.T) {
ctx, cancelFn := context.WithTimeout(context.Background(), 5*time.Second)
defer cancelFn()
cfg, err := integrationtest.LoadConfigWithDefaultRegion("us-west-2")
if err != nil {
t.Fatalf("failed to load config, %v", err)
}
client := codestar.NewFromConfig(cfg)
params := &codestar.ListProjectsInput{}
_, err = client.ListProjects(ctx, params)
if err != nil {
t.Errorf("expect no error, got %v", err)
}
}
| 32 |
aws-sdk-go-v2 | aws | Go | //go:build integration
// +build integration
package cognitoidentityprovider
import (
"context"
"errors"
"testing"
"time"
"github.com/aws/aws-sdk-go-v2/aws"
"github.com/aws/aws-sdk-go-v2/service/cognitoidentityprovider"
"github.com/aws/aws-sdk-go-v2/service/internal/integrationtest"
"github.com/aws/smithy-go"
)
func TestInteg_00_ListUserPools(t *testing.T) {
ctx, cancelFn := context.WithTimeout(context.Background(), 5*time.Second)
defer cancelFn()
cfg, err := integrationtest.LoadConfigWithDefaultRegion("us-west-2")
if err != nil {
t.Fatalf("failed to load config, %v", err)
}
client := cognitoidentityprovider.NewFromConfig(cfg)
params := &cognitoidentityprovider.ListUserPoolsInput{
MaxResults: 10,
}
_, err = client.ListUserPools(ctx, params)
if err != nil {
t.Errorf("expect no error, got %v", err)
}
}
func TestInteg_01_DescribeUserPool(t *testing.T) {
ctx, cancelFn := context.WithTimeout(context.Background(), 5*time.Second)
defer cancelFn()
cfg, err := integrationtest.LoadConfigWithDefaultRegion("us-west-2")
if err != nil {
t.Fatalf("failed to load config, %v", err)
}
client := cognitoidentityprovider.NewFromConfig(cfg)
params := &cognitoidentityprovider.DescribeUserPoolInput{
UserPoolId: aws.String("us-east-1:aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee"),
}
_, err = client.DescribeUserPool(ctx, params)
if err == nil {
t.Fatalf("expect request to fail")
}
var apiErr smithy.APIError
if !errors.As(err, &apiErr) {
t.Fatalf("expect error to be API error, was not, %v", err)
}
if len(apiErr.ErrorCode()) == 0 {
t.Errorf("expect non-empty error code")
}
if len(apiErr.ErrorMessage()) == 0 {
t.Errorf("expect non-empty error message")
}
}
| 67 |
aws-sdk-go-v2 | aws | Go | //go:build integration
// +build integration
package configservice
import (
"context"
"errors"
"testing"
"time"
"github.com/aws/aws-sdk-go-v2/aws"
"github.com/aws/aws-sdk-go-v2/service/configservice"
"github.com/aws/aws-sdk-go-v2/service/configservice/types"
"github.com/aws/aws-sdk-go-v2/service/internal/integrationtest"
"github.com/aws/smithy-go"
)
func TestInteg_00_DescribeConfigurationRecorders(t *testing.T) {
ctx, cancelFn := context.WithTimeout(context.Background(), 5*time.Second)
defer cancelFn()
cfg, err := integrationtest.LoadConfigWithDefaultRegion("us-west-2")
if err != nil {
t.Fatalf("failed to load config, %v", err)
}
client := configservice.NewFromConfig(cfg)
params := &configservice.DescribeConfigurationRecordersInput{}
_, err = client.DescribeConfigurationRecorders(ctx, params)
if err != nil {
t.Errorf("expect no error, got %v", err)
}
}
func TestInteg_01_GetResourceConfigHistory(t *testing.T) {
ctx, cancelFn := context.WithTimeout(context.Background(), 5*time.Second)
defer cancelFn()
cfg, err := integrationtest.LoadConfigWithDefaultRegion("us-west-2")
if err != nil {
t.Fatalf("failed to load config, %v", err)
}
client := configservice.NewFromConfig(cfg)
params := &configservice.GetResourceConfigHistoryInput{
ResourceId: aws.String("fake-id"),
ResourceType: types.ResourceType("fake-type"),
}
_, err = client.GetResourceConfigHistory(ctx, params)
if err == nil {
t.Fatalf("expect request to fail")
}
var apiErr smithy.APIError
if !errors.As(err, &apiErr) {
t.Fatalf("expect error to be API error, was not, %v", err)
}
if len(apiErr.ErrorCode()) == 0 {
t.Errorf("expect non-empty error code")
}
if len(apiErr.ErrorMessage()) == 0 {
t.Errorf("expect non-empty error message")
}
}
| 67 |
aws-sdk-go-v2 | aws | Go | //go:build integration
// +build integration
package costandusagereportservice
import (
"context"
"testing"
"time"
"github.com/aws/aws-sdk-go-v2/service/costandusagereportservice"
"github.com/aws/aws-sdk-go-v2/service/internal/integrationtest"
)
func TestInteg_00_DescribeReportDefinitions(t *testing.T) {
ctx, cancelFn := context.WithTimeout(context.Background(), 5*time.Second)
defer cancelFn()
cfg, err := integrationtest.LoadConfigWithDefaultRegion("us-east-1")
if err != nil {
t.Fatalf("failed to load config, %v", err)
}
client := costandusagereportservice.NewFromConfig(cfg)
params := &costandusagereportservice.DescribeReportDefinitionsInput{}
_, err = client.DescribeReportDefinitions(ctx, params)
if err != nil {
t.Errorf("expect no error, got %v", err)
}
}
| 32 |
aws-sdk-go-v2 | aws | Go | //go:build integration
// +build integration
package databasemigrationservice
import (
"context"
"errors"
"testing"
"time"
"github.com/aws/aws-sdk-go-v2/aws"
"github.com/aws/aws-sdk-go-v2/service/databasemigrationservice"
"github.com/aws/aws-sdk-go-v2/service/internal/integrationtest"
"github.com/aws/smithy-go"
)
func TestInteg_00_DescribeEndpoints(t *testing.T) {
ctx, cancelFn := context.WithTimeout(context.Background(), 5*time.Second)
defer cancelFn()
cfg, err := integrationtest.LoadConfigWithDefaultRegion("us-west-2")
if err != nil {
t.Fatalf("failed to load config, %v", err)
}
client := databasemigrationservice.NewFromConfig(cfg)
params := &databasemigrationservice.DescribeEndpointsInput{}
_, err = client.DescribeEndpoints(ctx, params)
if err != nil {
t.Errorf("expect no error, got %v", err)
}
}
func TestInteg_01_DescribeTableStatistics(t *testing.T) {
ctx, cancelFn := context.WithTimeout(context.Background(), 5*time.Second)
defer cancelFn()
cfg, err := integrationtest.LoadConfigWithDefaultRegion("us-west-2")
if err != nil {
t.Fatalf("failed to load config, %v", err)
}
client := databasemigrationservice.NewFromConfig(cfg)
params := &databasemigrationservice.DescribeTableStatisticsInput{
ReplicationTaskArn: aws.String("arn:aws:acm:region:123456789012"),
}
_, err = client.DescribeTableStatistics(ctx, params)
if err == nil {
t.Fatalf("expect request to fail")
}
var apiErr smithy.APIError
if !errors.As(err, &apiErr) {
t.Fatalf("expect error to be API error, was not, %v", err)
}
if len(apiErr.ErrorCode()) == 0 {
t.Errorf("expect non-empty error code")
}
if len(apiErr.ErrorMessage()) == 0 {
t.Errorf("expect non-empty error message")
}
}
| 65 |
aws-sdk-go-v2 | aws | Go | //go:build integration
// +build integration
package devicefarm
import (
"context"
"errors"
"testing"
"time"
"github.com/aws/aws-sdk-go-v2/aws"
"github.com/aws/aws-sdk-go-v2/service/devicefarm"
"github.com/aws/aws-sdk-go-v2/service/internal/integrationtest"
"github.com/aws/smithy-go"
)
func TestInteg_00_ListDevices(t *testing.T) {
ctx, cancelFn := context.WithTimeout(context.Background(), 5*time.Second)
defer cancelFn()
cfg, err := integrationtest.LoadConfigWithDefaultRegion("us-west-2")
if err != nil {
t.Fatalf("failed to load config, %v", err)
}
client := devicefarm.NewFromConfig(cfg)
params := &devicefarm.ListDevicesInput{}
_, err = client.ListDevices(ctx, params)
if err != nil {
t.Errorf("expect no error, got %v", err)
}
}
func TestInteg_01_GetDevice(t *testing.T) {
ctx, cancelFn := context.WithTimeout(context.Background(), 5*time.Second)
defer cancelFn()
cfg, err := integrationtest.LoadConfigWithDefaultRegion("us-west-2")
if err != nil {
t.Fatalf("failed to load config, %v", err)
}
client := devicefarm.NewFromConfig(cfg)
params := &devicefarm.GetDeviceInput{
Arn: aws.String("arn:aws:devicefarm:us-west-2::device:000000000000000000000000fake-arn"),
}
_, err = client.GetDevice(ctx, params)
if err == nil {
t.Fatalf("expect request to fail")
}
var apiErr smithy.APIError
if !errors.As(err, &apiErr) {
t.Fatalf("expect error to be API error, was not, %v", err)
}
if len(apiErr.ErrorCode()) == 0 {
t.Errorf("expect non-empty error code")
}
if len(apiErr.ErrorMessage()) == 0 {
t.Errorf("expect non-empty error message")
}
}
| 65 |
aws-sdk-go-v2 | aws | Go | //go:build integration
// +build integration
package directconnect
import (
"context"
"errors"
"testing"
"time"
"github.com/aws/aws-sdk-go-v2/aws"
"github.com/aws/aws-sdk-go-v2/service/directconnect"
"github.com/aws/aws-sdk-go-v2/service/internal/integrationtest"
"github.com/aws/smithy-go"
)
func TestInteg_00_DescribeConnections(t *testing.T) {
ctx, cancelFn := context.WithTimeout(context.Background(), 5*time.Second)
defer cancelFn()
cfg, err := integrationtest.LoadConfigWithDefaultRegion("us-west-2")
if err != nil {
t.Fatalf("failed to load config, %v", err)
}
client := directconnect.NewFromConfig(cfg)
params := &directconnect.DescribeConnectionsInput{}
_, err = client.DescribeConnections(ctx, params)
if err != nil {
t.Errorf("expect no error, got %v", err)
}
}
func TestInteg_01_DescribeConnections(t *testing.T) {
ctx, cancelFn := context.WithTimeout(context.Background(), 5*time.Second)
defer cancelFn()
cfg, err := integrationtest.LoadConfigWithDefaultRegion("us-west-2")
if err != nil {
t.Fatalf("failed to load config, %v", err)
}
client := directconnect.NewFromConfig(cfg)
params := &directconnect.DescribeConnectionsInput{
ConnectionId: aws.String("fake-connection"),
}
_, err = client.DescribeConnections(ctx, params)
if err == nil {
t.Fatalf("expect request to fail")
}
var apiErr smithy.APIError
if !errors.As(err, &apiErr) {
t.Fatalf("expect error to be API error, was not, %v", err)
}
if len(apiErr.ErrorCode()) == 0 {
t.Errorf("expect non-empty error code")
}
if len(apiErr.ErrorMessage()) == 0 {
t.Errorf("expect non-empty error message")
}
}
| 65 |
aws-sdk-go-v2 | aws | Go | //go:build integration
// +build integration
package directoryservice
import (
"context"
"errors"
"testing"
"time"
"github.com/aws/aws-sdk-go-v2/aws"
"github.com/aws/aws-sdk-go-v2/service/directoryservice"
"github.com/aws/aws-sdk-go-v2/service/directoryservice/types"
"github.com/aws/aws-sdk-go-v2/service/internal/integrationtest"
"github.com/aws/smithy-go"
)
func TestInteg_00_DescribeDirectories(t *testing.T) {
ctx, cancelFn := context.WithTimeout(context.Background(), 5*time.Second)
defer cancelFn()
cfg, err := integrationtest.LoadConfigWithDefaultRegion("us-west-2")
if err != nil {
t.Fatalf("failed to load config, %v", err)
}
client := directoryservice.NewFromConfig(cfg)
params := &directoryservice.DescribeDirectoriesInput{}
_, err = client.DescribeDirectories(ctx, params)
if err != nil {
t.Errorf("expect no error, got %v", err)
}
}
func TestInteg_01_CreateDirectory(t *testing.T) {
ctx, cancelFn := context.WithTimeout(context.Background(), 5*time.Second)
defer cancelFn()
cfg, err := integrationtest.LoadConfigWithDefaultRegion("us-west-2")
if err != nil {
t.Fatalf("failed to load config, %v", err)
}
client := directoryservice.NewFromConfig(cfg)
params := &directoryservice.CreateDirectoryInput{
Name: aws.String(""),
Password: aws.String(""),
Size: types.DirectorySize(""),
}
_, err = client.CreateDirectory(ctx, params)
if err == nil {
t.Fatalf("expect request to fail")
}
var apiErr smithy.APIError
if !errors.As(err, &apiErr) {
t.Fatalf("expect error to be API error, was not, %v", err)
}
if len(apiErr.ErrorCode()) == 0 {
t.Errorf("expect non-empty error code")
}
if len(apiErr.ErrorMessage()) == 0 {
t.Errorf("expect non-empty error message")
}
}
| 68 |
aws-sdk-go-v2 | aws | Go | //go:build integration
// +build integration
package docdb
import (
"context"
"errors"
"testing"
"time"
"github.com/aws/aws-sdk-go-v2/aws"
"github.com/aws/aws-sdk-go-v2/service/docdb"
"github.com/aws/smithy-go"
"github.com/aws/aws-sdk-go-v2/service/internal/integrationtest"
)
func TestInteg_00_DescribeDBEngineVersions(t *testing.T) {
ctx, cancelFn := context.WithTimeout(context.Background(), 5*time.Second)
defer cancelFn()
cfg, err := integrationtest.LoadConfigWithDefaultRegion("us-west-2")
if err != nil {
t.Fatalf("failed to load config, %v", err)
}
client := docdb.NewFromConfig(cfg)
params := &docdb.DescribeDBEngineVersionsInput{}
_, err = client.DescribeDBEngineVersions(ctx, params)
if err != nil {
t.Errorf("expect no error, got %v", err)
}
}
func TestInteg_01_DescribeDBInstances(t *testing.T) {
ctx, cancelFn := context.WithTimeout(context.Background(), 5*time.Second)
defer cancelFn()
cfg, err := integrationtest.LoadConfigWithDefaultRegion("us-west-2")
if err != nil {
t.Fatalf("failed to load config, %v", err)
}
client := docdb.NewFromConfig(cfg)
params := &docdb.DescribeDBInstancesInput{
DBInstanceIdentifier: aws.String("fake-id"),
}
_, err = client.DescribeDBInstances(ctx, params)
if err == nil {
t.Fatalf("expect request to fail")
}
var apiErr smithy.APIError
if !errors.As(err, &apiErr) {
t.Fatalf("expect error to be API error, was not, %v", err)
}
if len(apiErr.ErrorCode()) == 0 {
t.Errorf("expect non-empty error code")
}
if len(apiErr.ErrorMessage()) == 0 {
t.Errorf("expect non-empty error message")
}
}
| 65 |
aws-sdk-go-v2 | aws | Go | //go:build integration
// +build integration
package dynamodb
import (
"context"
"errors"
"testing"
"time"
"github.com/aws/aws-sdk-go-v2/aws"
"github.com/aws/aws-sdk-go-v2/service/dynamodb"
"github.com/aws/smithy-go"
"github.com/aws/aws-sdk-go-v2/service/internal/integrationtest"
)
func TestInteg_00_ListTables(t *testing.T) {
ctx, cancelFn := context.WithTimeout(context.Background(), 5*time.Second)
defer cancelFn()
cfg, err := integrationtest.LoadConfigWithDefaultRegion("us-west-2")
if err != nil {
t.Fatalf("failed to load config, %v", err)
}
client := dynamodb.NewFromConfig(cfg)
params := &dynamodb.ListTablesInput{
Limit: aws.Int32(1),
}
_, err = client.ListTables(ctx, params)
if err != nil {
t.Errorf("expect no error, got %v", err)
}
}
func TestInteg_01_DescribeTable(t *testing.T) {
ctx, cancelFn := context.WithTimeout(context.Background(), 5*time.Second)
defer cancelFn()
cfg, err := integrationtest.LoadConfigWithDefaultRegion("us-west-2")
if err != nil {
t.Fatalf("failed to load config, %v", err)
}
client := dynamodb.NewFromConfig(cfg)
params := &dynamodb.DescribeTableInput{
TableName: aws.String("fake-table"),
}
_, err = client.DescribeTable(ctx, params)
if err == nil {
t.Fatalf("expect request to fail")
}
var apiErr smithy.APIError
if !errors.As(err, &apiErr) {
t.Fatalf("expect error to be API error, was not, %v", err)
}
if len(apiErr.ErrorCode()) == 0 {
t.Errorf("expect non-empty error code")
}
if len(apiErr.ErrorMessage()) == 0 {
t.Errorf("expect non-empty error message")
}
}
| 67 |
aws-sdk-go-v2 | aws | Go | //go:build integration
// +build integration
package ec2
import (
"context"
"errors"
"testing"
"time"
"github.com/aws/aws-sdk-go-v2/service/ec2"
"github.com/aws/smithy-go"
"github.com/aws/aws-sdk-go-v2/service/internal/integrationtest"
)
func TestInteg_00_DescribeRegions(t *testing.T) {
ctx, cancelFn := context.WithTimeout(context.Background(), 5*time.Second)
defer cancelFn()
cfg, err := integrationtest.LoadConfigWithDefaultRegion("us-west-2")
if err != nil {
t.Fatalf("failed to load config, %v", err)
}
client := ec2.NewFromConfig(cfg)
params := &ec2.DescribeRegionsInput{}
_, err = client.DescribeRegions(ctx, params)
if err != nil {
t.Errorf("expect no error, got %v", err)
}
}
func TestInteg_01_DescribeInstances(t *testing.T) {
ctx, cancelFn := context.WithTimeout(context.Background(), 5*time.Second)
defer cancelFn()
cfg, err := integrationtest.LoadConfigWithDefaultRegion("us-west-2")
if err != nil {
t.Fatalf("failed to load config, %v", err)
}
client := ec2.NewFromConfig(cfg)
params := &ec2.DescribeInstancesInput{
InstanceIds: []string{
"i-12345678",
},
}
_, err = client.DescribeInstances(ctx, params)
if err == nil {
t.Fatalf("expect request to fail")
}
var apiErr smithy.APIError
if !errors.As(err, &apiErr) {
t.Fatalf("expect error to be API error, was not, %v", err)
}
if len(apiErr.ErrorCode()) == 0 {
t.Errorf("expect non-empty error code")
}
if len(apiErr.ErrorMessage()) == 0 {
t.Errorf("expect non-empty error message")
}
}
| 66 |
aws-sdk-go-v2 | aws | Go | //go:build integration
// +build integration
package ecr
import (
"context"
"errors"
"testing"
"time"
"github.com/aws/aws-sdk-go-v2/aws"
"github.com/aws/aws-sdk-go-v2/service/ecr"
"github.com/aws/smithy-go"
"github.com/aws/aws-sdk-go-v2/service/internal/integrationtest"
)
func TestInteg_00_DescribeRepositories(t *testing.T) {
ctx, cancelFn := context.WithTimeout(context.Background(), 5*time.Second)
defer cancelFn()
cfg, err := integrationtest.LoadConfigWithDefaultRegion("us-west-2")
if err != nil {
t.Fatalf("failed to load config, %v", err)
}
client := ecr.NewFromConfig(cfg)
params := &ecr.DescribeRepositoriesInput{}
_, err = client.DescribeRepositories(ctx, params)
if err != nil {
t.Errorf("expect no error, got %v", err)
}
}
func TestInteg_01_ListImages(t *testing.T) {
ctx, cancelFn := context.WithTimeout(context.Background(), 5*time.Second)
defer cancelFn()
cfg, err := integrationtest.LoadConfigWithDefaultRegion("us-west-2")
if err != nil {
t.Fatalf("failed to load config, %v", err)
}
client := ecr.NewFromConfig(cfg)
params := &ecr.ListImagesInput{
RepositoryName: aws.String("not-a-real-repository"),
}
_, err = client.ListImages(ctx, params)
if err == nil {
t.Fatalf("expect request to fail")
}
var apiErr smithy.APIError
if !errors.As(err, &apiErr) {
t.Fatalf("expect error to be API error, was not, %v", err)
}
if len(apiErr.ErrorCode()) == 0 {
t.Errorf("expect non-empty error code")
}
if len(apiErr.ErrorMessage()) == 0 {
t.Errorf("expect non-empty error message")
}
}
| 65 |
aws-sdk-go-v2 | aws | Go | //go:build integration
// +build integration
package ecs
import (
"context"
"errors"
"testing"
"time"
"github.com/aws/aws-sdk-go-v2/aws"
"github.com/aws/aws-sdk-go-v2/service/ecs"
"github.com/aws/smithy-go"
"github.com/aws/aws-sdk-go-v2/service/internal/integrationtest"
)
func TestInteg_00_ListClusters(t *testing.T) {
ctx, cancelFn := context.WithTimeout(context.Background(), 5*time.Second)
defer cancelFn()
cfg, err := integrationtest.LoadConfigWithDefaultRegion("us-west-2")
if err != nil {
t.Fatalf("failed to load config, %v", err)
}
client := ecs.NewFromConfig(cfg)
params := &ecs.ListClustersInput{}
_, err = client.ListClusters(ctx, params)
if err != nil {
t.Errorf("expect no error, got %v", err)
}
}
func TestInteg_01_StopTask(t *testing.T) {
ctx, cancelFn := context.WithTimeout(context.Background(), 5*time.Second)
defer cancelFn()
cfg, err := integrationtest.LoadConfigWithDefaultRegion("us-west-2")
if err != nil {
t.Fatalf("failed to load config, %v", err)
}
client := ecs.NewFromConfig(cfg)
params := &ecs.StopTaskInput{
Task: aws.String("xxxxxxxxxxx-xxxxxxxxxxxx-xxxxxxxxxxx"),
}
_, err = client.StopTask(ctx, params)
if err == nil {
t.Fatalf("expect request to fail")
}
var apiErr smithy.APIError
if !errors.As(err, &apiErr) {
t.Fatalf("expect error to be API error, was not, %v", err)
}
if len(apiErr.ErrorCode()) == 0 {
t.Errorf("expect non-empty error code")
}
if len(apiErr.ErrorMessage()) == 0 {
t.Errorf("expect non-empty error message")
}
}
| 65 |
aws-sdk-go-v2 | aws | Go | //go:build integration
// +build integration
package efs
import (
"context"
"errors"
"testing"
"time"
"github.com/aws/aws-sdk-go-v2/aws"
"github.com/aws/aws-sdk-go-v2/service/efs"
"github.com/aws/smithy-go"
"github.com/aws/aws-sdk-go-v2/service/internal/integrationtest"
)
func TestInteg_00_DescribeFileSystems(t *testing.T) {
ctx, cancelFn := context.WithTimeout(context.Background(), 5*time.Second)
defer cancelFn()
cfg, err := integrationtest.LoadConfigWithDefaultRegion("us-west-2")
if err != nil {
t.Fatalf("failed to load config, %v", err)
}
client := efs.NewFromConfig(cfg)
params := &efs.DescribeFileSystemsInput{}
_, err = client.DescribeFileSystems(ctx, params)
if err != nil {
t.Errorf("expect no error, got %v", err)
}
}
func TestInteg_01_DeleteFileSystem(t *testing.T) {
ctx, cancelFn := context.WithTimeout(context.Background(), 5*time.Second)
defer cancelFn()
cfg, err := integrationtest.LoadConfigWithDefaultRegion("us-west-2")
if err != nil {
t.Fatalf("failed to load config, %v", err)
}
client := efs.NewFromConfig(cfg)
params := &efs.DeleteFileSystemInput{
FileSystemId: aws.String("fs-c5a1446c"),
}
_, err = client.DeleteFileSystem(ctx, params)
if err == nil {
t.Fatalf("expect request to fail")
}
var apiErr smithy.APIError
if !errors.As(err, &apiErr) {
t.Fatalf("expect error to be API error, was not, %v", err)
}
if len(apiErr.ErrorCode()) == 0 {
t.Errorf("expect non-empty error code")
}
if len(apiErr.ErrorMessage()) == 0 {
t.Errorf("expect non-empty error message")
}
}
| 65 |
aws-sdk-go-v2 | aws | Go | //go:build integration
// +build integration
package elasticache
import (
"context"
"errors"
"testing"
"time"
"github.com/aws/aws-sdk-go-v2/aws"
"github.com/aws/aws-sdk-go-v2/service/elasticache"
"github.com/aws/smithy-go"
"github.com/aws/aws-sdk-go-v2/service/internal/integrationtest"
)
func TestInteg_00_DescribeEvents(t *testing.T) {
ctx, cancelFn := context.WithTimeout(context.Background(), 5*time.Second)
defer cancelFn()
cfg, err := integrationtest.LoadConfigWithDefaultRegion("us-west-2")
if err != nil {
t.Fatalf("failed to load config, %v", err)
}
client := elasticache.NewFromConfig(cfg)
params := &elasticache.DescribeEventsInput{}
_, err = client.DescribeEvents(ctx, params)
if err != nil {
t.Errorf("expect no error, got %v", err)
}
}
func TestInteg_01_DescribeCacheClusters(t *testing.T) {
ctx, cancelFn := context.WithTimeout(context.Background(), 5*time.Second)
defer cancelFn()
cfg, err := integrationtest.LoadConfigWithDefaultRegion("us-west-2")
if err != nil {
t.Fatalf("failed to load config, %v", err)
}
client := elasticache.NewFromConfig(cfg)
params := &elasticache.DescribeCacheClustersInput{
CacheClusterId: aws.String("fake_cluster"),
}
_, err = client.DescribeCacheClusters(ctx, params)
if err == nil {
t.Fatalf("expect request to fail")
}
var apiErr smithy.APIError
if !errors.As(err, &apiErr) {
t.Fatalf("expect error to be API error, was not, %v", err)
}
if len(apiErr.ErrorCode()) == 0 {
t.Errorf("expect non-empty error code")
}
if len(apiErr.ErrorMessage()) == 0 {
t.Errorf("expect non-empty error message")
}
}
| 65 |
aws-sdk-go-v2 | aws | Go | //go:build integration
// +build integration
package elasticbeanstalk
import (
"context"
"errors"
"testing"
"time"
"github.com/aws/aws-sdk-go-v2/aws"
"github.com/aws/aws-sdk-go-v2/service/elasticbeanstalk"
"github.com/aws/smithy-go"
"github.com/aws/aws-sdk-go-v2/service/internal/integrationtest"
)
func TestInteg_00_ListAvailableSolutionStacks(t *testing.T) {
ctx, cancelFn := context.WithTimeout(context.Background(), 5*time.Second)
defer cancelFn()
cfg, err := integrationtest.LoadConfigWithDefaultRegion("us-west-2")
if err != nil {
t.Fatalf("failed to load config, %v", err)
}
client := elasticbeanstalk.NewFromConfig(cfg)
params := &elasticbeanstalk.ListAvailableSolutionStacksInput{}
_, err = client.ListAvailableSolutionStacks(ctx, params)
if err != nil {
t.Errorf("expect no error, got %v", err)
}
}
func TestInteg_01_DescribeEnvironmentResources(t *testing.T) {
ctx, cancelFn := context.WithTimeout(context.Background(), 5*time.Second)
defer cancelFn()
cfg, err := integrationtest.LoadConfigWithDefaultRegion("us-west-2")
if err != nil {
t.Fatalf("failed to load config, %v", err)
}
client := elasticbeanstalk.NewFromConfig(cfg)
params := &elasticbeanstalk.DescribeEnvironmentResourcesInput{
EnvironmentId: aws.String("fake_environment"),
}
_, err = client.DescribeEnvironmentResources(ctx, params)
if err == nil {
t.Fatalf("expect request to fail")
}
var apiErr smithy.APIError
if !errors.As(err, &apiErr) {
t.Fatalf("expect error to be API error, was not, %v", err)
}
if len(apiErr.ErrorCode()) == 0 {
t.Errorf("expect non-empty error code")
}
if len(apiErr.ErrorMessage()) == 0 {
t.Errorf("expect non-empty error message")
}
}
| 65 |
aws-sdk-go-v2 | aws | Go | //go:build integration
// +build integration
package elasticloadbalancing
import (
"context"
"errors"
"testing"
"time"
elb "github.com/aws/aws-sdk-go-v2/service/elasticloadbalancing"
"github.com/aws/smithy-go"
"github.com/aws/aws-sdk-go-v2/service/internal/integrationtest"
)
func TestInteg_00_DescribeLoadBalancers(t *testing.T) {
ctx, cancelFn := context.WithTimeout(context.Background(), 5*time.Second)
defer cancelFn()
cfg, err := integrationtest.LoadConfigWithDefaultRegion("us-west-2")
if err != nil {
t.Fatalf("failed to load config, %v", err)
}
client := elb.NewFromConfig(cfg)
params := &elb.DescribeLoadBalancersInput{}
_, err = client.DescribeLoadBalancers(ctx, params)
if err != nil {
t.Errorf("expect no error, got %v", err)
}
}
func TestInteg_01_DescribeLoadBalancers(t *testing.T) {
ctx, cancelFn := context.WithTimeout(context.Background(), 5*time.Second)
defer cancelFn()
cfg, err := integrationtest.LoadConfigWithDefaultRegion("us-west-2")
if err != nil {
t.Fatalf("failed to load config, %v", err)
}
client := elb.NewFromConfig(cfg)
params := &elb.DescribeLoadBalancersInput{
LoadBalancerNames: []string{
"fake_load_balancer",
},
}
_, err = client.DescribeLoadBalancers(ctx, params)
if err == nil {
t.Fatalf("expect request to fail")
}
var apiErr smithy.APIError
if !errors.As(err, &apiErr) {
t.Fatalf("expect error to be API error, was not, %v", err)
}
if len(apiErr.ErrorCode()) == 0 {
t.Errorf("expect non-empty error code")
}
if len(apiErr.ErrorMessage()) == 0 {
t.Errorf("expect non-empty error message")
}
}
| 66 |
aws-sdk-go-v2 | aws | Go | //go:build integration
// +build integration
package elasticsearchservice
import (
"context"
"errors"
"testing"
"time"
"github.com/aws/aws-sdk-go-v2/aws"
"github.com/aws/aws-sdk-go-v2/service/elasticsearchservice"
"github.com/aws/smithy-go"
"github.com/aws/aws-sdk-go-v2/service/internal/integrationtest"
)
func TestInteg_00_ListDomainNames(t *testing.T) {
ctx, cancelFn := context.WithTimeout(context.Background(), 5*time.Second)
defer cancelFn()
cfg, err := integrationtest.LoadConfigWithDefaultRegion("us-west-2")
if err != nil {
t.Fatalf("failed to load config, %v", err)
}
client := elasticsearchservice.NewFromConfig(cfg)
params := &elasticsearchservice.ListDomainNamesInput{}
_, err = client.ListDomainNames(ctx, params)
if err != nil {
t.Errorf("expect no error, got %v", err)
}
}
func TestInteg_01_DescribeElasticsearchDomain(t *testing.T) {
ctx, cancelFn := context.WithTimeout(context.Background(), 5*time.Second)
defer cancelFn()
cfg, err := integrationtest.LoadConfigWithDefaultRegion("us-west-2")
if err != nil {
t.Fatalf("failed to load config, %v", err)
}
client := elasticsearchservice.NewFromConfig(cfg)
params := &elasticsearchservice.DescribeElasticsearchDomainInput{
DomainName: aws.String("not-a-domain"),
}
_, err = client.DescribeElasticsearchDomain(ctx, params)
if err == nil {
t.Fatalf("expect request to fail")
}
var apiErr smithy.APIError
if !errors.As(err, &apiErr) {
t.Fatalf("expect error to be API error, was not, %v", err)
}
if len(apiErr.ErrorCode()) == 0 {
t.Errorf("expect non-empty error code")
}
if len(apiErr.ErrorMessage()) == 0 {
t.Errorf("expect non-empty error message")
}
}
| 65 |
aws-sdk-go-v2 | aws | Go | //go:build integration
// +build integration
package elastictranscoder
import (
"context"
"errors"
"testing"
"time"
"github.com/aws/aws-sdk-go-v2/aws"
"github.com/aws/aws-sdk-go-v2/service/elastictranscoder"
"github.com/aws/smithy-go"
"github.com/aws/aws-sdk-go-v2/service/internal/integrationtest"
)
func TestInteg_00_ListPresets(t *testing.T) {
ctx, cancelFn := context.WithTimeout(context.Background(), 5*time.Second)
defer cancelFn()
cfg, err := integrationtest.LoadConfigWithDefaultRegion("us-west-2")
if err != nil {
t.Fatalf("failed to load config, %v", err)
}
client := elastictranscoder.NewFromConfig(cfg)
params := &elastictranscoder.ListPresetsInput{}
_, err = client.ListPresets(ctx, params)
if err != nil {
t.Errorf("expect no error, got %v", err)
}
}
func TestInteg_01_ReadJob(t *testing.T) {
ctx, cancelFn := context.WithTimeout(context.Background(), 5*time.Second)
defer cancelFn()
cfg, err := integrationtest.LoadConfigWithDefaultRegion("us-west-2")
if err != nil {
t.Fatalf("failed to load config, %v", err)
}
client := elastictranscoder.NewFromConfig(cfg)
params := &elastictranscoder.ReadJobInput{
Id: aws.String("fake_job"),
}
_, err = client.ReadJob(ctx, params)
if err == nil {
t.Fatalf("expect request to fail")
}
var apiErr smithy.APIError
if !errors.As(err, &apiErr) {
t.Fatalf("expect error to be API error, was not, %v", err)
}
if len(apiErr.ErrorCode()) == 0 {
t.Errorf("expect non-empty error code")
}
if len(apiErr.ErrorMessage()) == 0 {
t.Errorf("expect non-empty error message")
}
}
| 65 |
aws-sdk-go-v2 | aws | Go | //go:build integration
// +build integration
package elasticloadbalancingv2
import (
"context"
"errors"
"testing"
"time"
elbv2 "github.com/aws/aws-sdk-go-v2/service/elasticloadbalancingv2"
"github.com/aws/aws-sdk-go-v2/service/internal/integrationtest"
"github.com/aws/smithy-go"
)
func TestInteg_00_DescribeLoadBalancers(t *testing.T) {
ctx, cancelFn := context.WithTimeout(context.Background(), 5*time.Second)
defer cancelFn()
cfg, err := integrationtest.LoadConfigWithDefaultRegion("us-west-2")
if err != nil {
t.Fatalf("failed to load config, %v", err)
}
client := elbv2.NewFromConfig(cfg)
params := &elbv2.DescribeLoadBalancersInput{}
_, err = client.DescribeLoadBalancers(ctx, params)
if err != nil {
t.Errorf("expect no error, got %v", err)
}
}
func TestInteg_01_DescribeLoadBalancers(t *testing.T) {
ctx, cancelFn := context.WithTimeout(context.Background(), 5*time.Second)
defer cancelFn()
cfg, err := integrationtest.LoadConfigWithDefaultRegion("us-west-2")
if err != nil {
t.Fatalf("failed to load config, %v", err)
}
client := elbv2.NewFromConfig(cfg)
params := &elbv2.DescribeLoadBalancersInput{
LoadBalancerArns: []string{
"fake_load_balancer",
},
}
_, err = client.DescribeLoadBalancers(ctx, params)
if err == nil {
t.Fatalf("expect request to fail")
}
var apiErr smithy.APIError
if !errors.As(err, &apiErr) {
t.Fatalf("expect error to be API error, was not, %v", err)
}
if len(apiErr.ErrorCode()) == 0 {
t.Errorf("expect non-empty error code")
}
if len(apiErr.ErrorMessage()) == 0 {
t.Errorf("expect non-empty error message")
}
}
| 66 |
aws-sdk-go-v2 | aws | Go | //go:build integration
// +build integration
package emr
import (
"context"
"errors"
"testing"
"time"
"github.com/aws/aws-sdk-go-v2/aws"
"github.com/aws/aws-sdk-go-v2/service/emr"
"github.com/aws/aws-sdk-go-v2/service/internal/integrationtest"
"github.com/aws/smithy-go"
)
func TestInteg_00_ListClusters(t *testing.T) {
ctx, cancelFn := context.WithTimeout(context.Background(), 5*time.Second)
defer cancelFn()
cfg, err := integrationtest.LoadConfigWithDefaultRegion("us-west-2")
if err != nil {
t.Fatalf("failed to load config, %v", err)
}
client := emr.NewFromConfig(cfg)
params := &emr.ListClustersInput{}
_, err = client.ListClusters(ctx, params)
if err != nil {
t.Errorf("expect no error, got %v", err)
}
}
func TestInteg_01_DescribeCluster(t *testing.T) {
ctx, cancelFn := context.WithTimeout(context.Background(), 5*time.Second)
defer cancelFn()
cfg, err := integrationtest.LoadConfigWithDefaultRegion("us-west-2")
if err != nil {
t.Fatalf("failed to load config, %v", err)
}
client := emr.NewFromConfig(cfg)
params := &emr.DescribeClusterInput{
ClusterId: aws.String("fake_cluster"),
}
_, err = client.DescribeCluster(ctx, params)
if err == nil {
t.Fatalf("expect request to fail")
}
var apiErr smithy.APIError
if !errors.As(err, &apiErr) {
t.Fatalf("expect error to be API error, was not, %v", err)
}
if len(apiErr.ErrorCode()) == 0 {
t.Errorf("expect non-empty error code")
}
if len(apiErr.ErrorMessage()) == 0 {
t.Errorf("expect non-empty error message")
}
}
| 65 |
aws-sdk-go-v2 | aws | Go | //go:build integration
// +build integration
package eventbridge
import (
"context"
"errors"
"testing"
"time"
"github.com/aws/aws-sdk-go-v2/aws"
"github.com/aws/aws-sdk-go-v2/service/eventbridge"
"github.com/aws/aws-sdk-go-v2/service/internal/integrationtest"
"github.com/aws/smithy-go"
)
func TestInteg_00_ListRules(t *testing.T) {
ctx, cancelFn := context.WithTimeout(context.Background(), 5*time.Second)
defer cancelFn()
cfg, err := integrationtest.LoadConfigWithDefaultRegion("us-west-2")
if err != nil {
t.Fatalf("failed to load config, %v", err)
}
client := eventbridge.NewFromConfig(cfg)
params := &eventbridge.ListRulesInput{}
_, err = client.ListRules(ctx, params)
if err != nil {
t.Errorf("expect no error, got %v", err)
}
}
func TestInteg_01_DescribeRule(t *testing.T) {
ctx, cancelFn := context.WithTimeout(context.Background(), 5*time.Second)
defer cancelFn()
cfg, err := integrationtest.LoadConfigWithDefaultRegion("us-west-2")
if err != nil {
t.Fatalf("failed to load config, %v", err)
}
client := eventbridge.NewFromConfig(cfg)
params := &eventbridge.DescribeRuleInput{
Name: aws.String("fake-rule"),
}
_, err = client.DescribeRule(ctx, params)
if err == nil {
t.Fatalf("expect request to fail")
}
var apiErr smithy.APIError
if !errors.As(err, &apiErr) {
t.Fatalf("expect error to be API error, was not, %v", err)
}
if len(apiErr.ErrorCode()) == 0 {
t.Errorf("expect non-empty error code")
}
if len(apiErr.ErrorMessage()) == 0 {
t.Errorf("expect non-empty error message")
}
}
| 65 |
aws-sdk-go-v2 | aws | Go | //go:build integration
// +build integration
package firehose
import (
"context"
"errors"
"testing"
"time"
"github.com/aws/aws-sdk-go-v2/aws"
"github.com/aws/aws-sdk-go-v2/service/firehose"
"github.com/aws/aws-sdk-go-v2/service/internal/integrationtest"
"github.com/aws/smithy-go"
)
func TestInteg_00_ListDeliveryStreams(t *testing.T) {
ctx, cancelFn := context.WithTimeout(context.Background(), 5*time.Second)
defer cancelFn()
cfg, err := integrationtest.LoadConfigWithDefaultRegion("us-west-2")
if err != nil {
t.Fatalf("failed to load config, %v", err)
}
client := firehose.NewFromConfig(cfg)
params := &firehose.ListDeliveryStreamsInput{}
_, err = client.ListDeliveryStreams(ctx, params)
if err != nil {
t.Errorf("expect no error, got %v", err)
}
}
func TestInteg_01_DescribeDeliveryStream(t *testing.T) {
ctx, cancelFn := context.WithTimeout(context.Background(), 5*time.Second)
defer cancelFn()
cfg, err := integrationtest.LoadConfigWithDefaultRegion("us-west-2")
if err != nil {
t.Fatalf("failed to load config, %v", err)
}
client := firehose.NewFromConfig(cfg)
params := &firehose.DescribeDeliveryStreamInput{
DeliveryStreamName: aws.String("bogus-stream-name"),
}
_, err = client.DescribeDeliveryStream(ctx, params)
if err == nil {
t.Fatalf("expect request to fail")
}
var apiErr smithy.APIError
if !errors.As(err, &apiErr) {
t.Fatalf("expect error to be API error, was not, %v", err)
}
if len(apiErr.ErrorCode()) == 0 {
t.Errorf("expect non-empty error code")
}
if len(apiErr.ErrorMessage()) == 0 {
t.Errorf("expect non-empty error message")
}
}
| 64 |
aws-sdk-go-v2 | aws | Go | //go:build integration
// +build integration
package gamelift
import (
"context"
"errors"
"testing"
"time"
"github.com/aws/aws-sdk-go-v2/aws"
"github.com/aws/aws-sdk-go-v2/service/gamelift"
"github.com/aws/aws-sdk-go-v2/service/internal/integrationtest"
"github.com/aws/smithy-go"
)
func TestInteg_00_ListBuilds(t *testing.T) {
ctx, cancelFn := context.WithTimeout(context.Background(), 5*time.Second)
defer cancelFn()
cfg, err := integrationtest.LoadConfigWithDefaultRegion("us-west-2")
if err != nil {
t.Fatalf("failed to load config, %v", err)
}
client := gamelift.NewFromConfig(cfg)
params := &gamelift.ListBuildsInput{}
_, err = client.ListBuilds(ctx, params)
if err != nil {
t.Errorf("expect no error, got %v", err)
}
}
func TestInteg_01_DescribePlayerSessions(t *testing.T) {
ctx, cancelFn := context.WithTimeout(context.Background(), 5*time.Second)
defer cancelFn()
cfg, err := integrationtest.LoadConfigWithDefaultRegion("us-west-2")
if err != nil {
t.Fatalf("failed to load config, %v", err)
}
client := gamelift.NewFromConfig(cfg)
params := &gamelift.DescribePlayerSessionsInput{
PlayerSessionId: aws.String("psess-fakeSessionId"),
}
_, err = client.DescribePlayerSessions(ctx, params)
if err == nil {
t.Fatalf("expect request to fail")
}
var apiErr smithy.APIError
if !errors.As(err, &apiErr) {
t.Fatalf("expect error to be API error, was not, %v", err)
}
if len(apiErr.ErrorCode()) == 0 {
t.Errorf("expect non-empty error code")
}
if len(apiErr.ErrorMessage()) == 0 {
t.Errorf("expect non-empty error message")
}
}
| 65 |
aws-sdk-go-v2 | aws | Go | //go:build integration
// +build integration
package glacier
import (
"context"
"errors"
"testing"
"time"
"github.com/aws/aws-sdk-go-v2/aws"
"github.com/aws/aws-sdk-go-v2/service/glacier"
"github.com/aws/aws-sdk-go-v2/service/internal/integrationtest"
"github.com/aws/smithy-go"
)
func TestInteg_00_ListVaults(t *testing.T) {
ctx, cancelFn := context.WithTimeout(context.Background(), 5*time.Second)
defer cancelFn()
cfg, err := integrationtest.LoadConfigWithDefaultRegion("us-west-2")
if err != nil {
t.Fatalf("failed to load config, %v", err)
}
client := glacier.NewFromConfig(cfg)
params := &glacier.ListVaultsInput{}
_, err = client.ListVaults(ctx, params)
if err != nil {
t.Errorf("expect no error, got %v", err)
}
}
func TestInteg_01_ListVaults(t *testing.T) {
ctx, cancelFn := context.WithTimeout(context.Background(), 5*time.Second)
defer cancelFn()
cfg, err := integrationtest.LoadConfigWithDefaultRegion("us-west-2")
if err != nil {
t.Fatalf("failed to load config, %v", err)
}
client := glacier.NewFromConfig(cfg)
params := &glacier.ListVaultsInput{
AccountId: aws.String("abcmnoxyz"),
}
_, err = client.ListVaults(ctx, params)
if err == nil {
t.Fatalf("expect request to fail")
}
var apiErr smithy.APIError
if !errors.As(err, &apiErr) {
t.Fatalf("expect error to be API error, was not, %v", err)
}
if len(apiErr.ErrorCode()) == 0 {
t.Errorf("expect non-empty error code")
}
if len(apiErr.ErrorMessage()) == 0 {
t.Errorf("expect non-empty error message")
}
}
| 65 |
aws-sdk-go-v2 | aws | Go | //go:build integration
// +build integration
package glue
import (
"context"
"testing"
"time"
"github.com/aws/aws-sdk-go-v2/service/glue"
"github.com/aws/aws-sdk-go-v2/service/internal/integrationtest"
)
func TestInteg_00_GetCatalogImportStatus(t *testing.T) {
ctx, cancelFn := context.WithTimeout(context.Background(), 5*time.Second)
defer cancelFn()
cfg, err := integrationtest.LoadConfigWithDefaultRegion("us-west-2")
if err != nil {
t.Fatalf("failed to load config, %v", err)
}
client := glue.NewFromConfig(cfg)
params := &glue.GetCatalogImportStatusInput{}
_, err = client.GetCatalogImportStatus(ctx, params)
if err != nil {
t.Errorf("expect no error, got %v", err)
}
}
| 31 |
aws-sdk-go-v2 | aws | Go | //go:build integration
// +build integration
package health
import (
"context"
"testing"
"time"
"github.com/aws/aws-sdk-go-v2/service/health"
"github.com/aws/aws-sdk-go-v2/service/internal/integrationtest"
)
func TestInteg_00_DescribeEntityAggregates(t *testing.T) {
ctx, cancelFn := context.WithTimeout(context.Background(), 5*time.Second)
defer cancelFn()
cfg, err := integrationtest.LoadConfigWithDefaultRegion("us-east-1")
if err != nil {
t.Fatalf("failed to load config, %v", err)
}
client := health.NewFromConfig(cfg)
params := &health.DescribeEntityAggregatesInput{}
_, err = client.DescribeEntityAggregates(ctx, params)
if err != nil {
t.Errorf("expect no error, got %v", err)
}
}
| 31 |
aws-sdk-go-v2 | aws | Go | //go:build integration
// +build integration
package iam
import (
"context"
"errors"
"testing"
"time"
"github.com/aws/aws-sdk-go-v2/aws"
"github.com/aws/aws-sdk-go-v2/service/iam"
"github.com/aws/aws-sdk-go-v2/service/internal/integrationtest"
"github.com/aws/smithy-go"
)
func TestInteg_00_ListUsers(t *testing.T) {
ctx, cancelFn := context.WithTimeout(context.Background(), 5*time.Second)
defer cancelFn()
cfg, err := integrationtest.LoadConfigWithDefaultRegion("us-east-1")
if err != nil {
t.Fatalf("failed to load config, %v", err)
}
client := iam.NewFromConfig(cfg)
params := &iam.ListUsersInput{}
_, err = client.ListUsers(ctx, params)
if err != nil {
t.Errorf("expect no error, got %v", err)
}
}
func TestInteg_01_GetUser(t *testing.T) {
ctx, cancelFn := context.WithTimeout(context.Background(), 5*time.Second)
defer cancelFn()
cfg, err := integrationtest.LoadConfigWithDefaultRegion("us-east-1")
if err != nil {
t.Fatalf("failed to load config, %v", err)
}
client := iam.NewFromConfig(cfg)
params := &iam.GetUserInput{
UserName: aws.String("fake_user"),
}
_, err = client.GetUser(ctx, params)
if err == nil {
t.Fatalf("expect request to fail")
}
var apiErr smithy.APIError
if !errors.As(err, &apiErr) {
t.Fatalf("expect error to be API error, was not, %v", err)
}
if len(apiErr.ErrorCode()) == 0 {
t.Errorf("expect non-empty error code")
}
if len(apiErr.ErrorMessage()) == 0 {
t.Errorf("expect non-empty error message")
}
}
| 65 |
aws-sdk-go-v2 | aws | Go | //go:build integration
// +build integration
package inspector
import (
"context"
"errors"
"testing"
"time"
"github.com/aws/aws-sdk-go-v2/aws"
"github.com/aws/aws-sdk-go-v2/service/inspector"
"github.com/aws/aws-sdk-go-v2/service/internal/integrationtest"
"github.com/aws/smithy-go"
)
func TestInteg_00_ListAssessmentTemplates(t *testing.T) {
ctx, cancelFn := context.WithTimeout(context.Background(), 5*time.Second)
defer cancelFn()
cfg, err := integrationtest.LoadConfigWithDefaultRegion("us-west-2")
if err != nil {
t.Fatalf("failed to load config, %v", err)
}
client := inspector.NewFromConfig(cfg)
params := &inspector.ListAssessmentTemplatesInput{}
_, err = client.ListAssessmentTemplates(ctx, params)
if err != nil {
t.Errorf("expect no error, got %v", err)
}
}
func TestInteg_01_ListTagsForResource(t *testing.T) {
ctx, cancelFn := context.WithTimeout(context.Background(), 5*time.Second)
defer cancelFn()
cfg, err := integrationtest.LoadConfigWithDefaultRegion("us-west-2")
if err != nil {
t.Fatalf("failed to load config, %v", err)
}
client := inspector.NewFromConfig(cfg)
params := &inspector.ListTagsForResourceInput{
ResourceArn: aws.String("fake-arn"),
}
_, err = client.ListTagsForResource(ctx, params)
if err == nil {
t.Fatalf("expect request to fail")
}
var apiErr smithy.APIError
if !errors.As(err, &apiErr) {
t.Fatalf("expect error to be API error, was not, %v", err)
}
if len(apiErr.ErrorCode()) == 0 {
t.Errorf("expect non-empty error code")
}
if len(apiErr.ErrorMessage()) == 0 {
t.Errorf("expect non-empty error message")
}
}
| 65 |
aws-sdk-go-v2 | aws | Go | //go:build integration
// +build integration
package iot
import (
"context"
"errors"
"testing"
"time"
"github.com/aws/aws-sdk-go-v2/aws"
"github.com/aws/aws-sdk-go-v2/service/iot"
"github.com/aws/aws-sdk-go-v2/service/internal/integrationtest"
"github.com/aws/smithy-go"
)
func TestInteg_00_ListPolicies(t *testing.T) {
ctx, cancelFn := context.WithTimeout(context.Background(), 5*time.Second)
defer cancelFn()
cfg, err := integrationtest.LoadConfigWithDefaultRegion("us-west-2")
if err != nil {
t.Fatalf("failed to load config, %v", err)
}
client := iot.NewFromConfig(cfg)
params := &iot.ListPoliciesInput{}
_, err = client.ListPolicies(ctx, params)
if err != nil {
t.Errorf("expect no error, got %v", err)
}
}
func TestInteg_01_DescribeThing(t *testing.T) {
ctx, cancelFn := context.WithTimeout(context.Background(), 5*time.Second)
defer cancelFn()
cfg, err := integrationtest.LoadConfigWithDefaultRegion("us-west-2")
if err != nil {
t.Fatalf("failed to load config, %v", err)
}
client := iot.NewFromConfig(cfg)
params := &iot.DescribeThingInput{
ThingName: aws.String("fake-thing"),
}
_, err = client.DescribeThing(ctx, params)
if err == nil {
t.Fatalf("expect request to fail")
}
var apiErr smithy.APIError
if !errors.As(err, &apiErr) {
t.Fatalf("expect error to be API error, was not, %v", err)
}
if len(apiErr.ErrorCode()) == 0 {
t.Errorf("expect non-empty error code")
}
if len(apiErr.ErrorMessage()) == 0 {
t.Errorf("expect non-empty error message")
}
}
| 65 |
aws-sdk-go-v2 | aws | Go | //go:build integration
// +build integration
package kinesis
import (
"context"
"errors"
"testing"
"time"
"github.com/aws/aws-sdk-go-v2/aws"
"github.com/aws/aws-sdk-go-v2/service/kinesis"
"github.com/aws/aws-sdk-go-v2/service/internal/integrationtest"
"github.com/aws/smithy-go"
)
func TestInteg_00_ListStreams(t *testing.T) {
ctx, cancelFn := context.WithTimeout(context.Background(), 5*time.Second)
defer cancelFn()
cfg, err := integrationtest.LoadConfigWithDefaultRegion("us-west-2")
if err != nil {
t.Fatalf("failed to load config, %v", err)
}
client := kinesis.NewFromConfig(cfg)
params := &kinesis.ListStreamsInput{}
_, err = client.ListStreams(ctx, params)
if err != nil {
t.Errorf("expect no error, got %v", err)
}
}
func TestInteg_01_DescribeStream(t *testing.T) {
ctx, cancelFn := context.WithTimeout(context.Background(), 5*time.Second)
defer cancelFn()
cfg, err := integrationtest.LoadConfigWithDefaultRegion("us-west-2")
if err != nil {
t.Fatalf("failed to load config, %v", err)
}
client := kinesis.NewFromConfig(cfg)
params := &kinesis.DescribeStreamInput{
StreamName: aws.String("bogus-stream-name"),
}
_, err = client.DescribeStream(ctx, params)
if err == nil {
t.Fatalf("expect request to fail")
}
var apiErr smithy.APIError
if !errors.As(err, &apiErr) {
t.Fatalf("expect error to be API error, was not, %v", err)
}
if len(apiErr.ErrorCode()) == 0 {
t.Errorf("expect non-empty error code")
}
if len(apiErr.ErrorMessage()) == 0 {
t.Errorf("expect non-empty error message")
}
}
| 65 |
aws-sdk-go-v2 | aws | Go | //go:build integration
// +build integration
package kms
import (
"context"
"errors"
"testing"
"time"
"github.com/aws/aws-sdk-go-v2/aws"
"github.com/aws/aws-sdk-go-v2/service/kms"
"github.com/aws/aws-sdk-go-v2/service/internal/integrationtest"
"github.com/aws/smithy-go"
)
func TestInteg_00_ListAliases(t *testing.T) {
ctx, cancelFn := context.WithTimeout(context.Background(), 5*time.Second)
defer cancelFn()
cfg, err := integrationtest.LoadConfigWithDefaultRegion("us-west-2")
if err != nil {
t.Fatalf("failed to load config, %v", err)
}
client := kms.NewFromConfig(cfg)
params := &kms.ListAliasesInput{}
_, err = client.ListAliases(ctx, params)
if err != nil {
t.Errorf("expect no error, got %v", err)
}
}
func TestInteg_01_GetKeyPolicy(t *testing.T) {
ctx, cancelFn := context.WithTimeout(context.Background(), 5*time.Second)
defer cancelFn()
cfg, err := integrationtest.LoadConfigWithDefaultRegion("us-west-2")
if err != nil {
t.Fatalf("failed to load config, %v", err)
}
client := kms.NewFromConfig(cfg)
params := &kms.GetKeyPolicyInput{
KeyId: aws.String("12345678-1234-1234-1234-123456789012"),
PolicyName: aws.String("fakePolicy"),
}
_, err = client.GetKeyPolicy(ctx, params)
if err == nil {
t.Fatalf("expect request to fail")
}
var apiErr smithy.APIError
if !errors.As(err, &apiErr) {
t.Fatalf("expect error to be API error, was not, %v", err)
}
if len(apiErr.ErrorCode()) == 0 {
t.Errorf("expect non-empty error code")
}
if len(apiErr.ErrorMessage()) == 0 {
t.Errorf("expect non-empty error message")
}
}
| 66 |
aws-sdk-go-v2 | aws | Go | //go:build integration
// +build integration
package lambda
import (
"context"
"errors"
"testing"
"time"
"github.com/aws/aws-sdk-go-v2/aws"
"github.com/aws/aws-sdk-go-v2/service/internal/integrationtest"
"github.com/aws/aws-sdk-go-v2/service/lambda"
"github.com/aws/smithy-go"
)
func TestInteg_00_ListFunctions(t *testing.T) {
ctx, cancelFn := context.WithTimeout(context.Background(), 5*time.Second)
defer cancelFn()
cfg, err := integrationtest.LoadConfigWithDefaultRegion("us-west-2")
if err != nil {
t.Fatalf("failed to load config, %v", err)
}
client := lambda.NewFromConfig(cfg)
params := &lambda.ListFunctionsInput{}
_, err = client.ListFunctions(ctx, params)
if err != nil {
t.Errorf("expect no error, got %v", err)
}
}
func TestInteg_01_Invoke(t *testing.T) {
ctx, cancelFn := context.WithTimeout(context.Background(), 5*time.Second)
defer cancelFn()
cfg, err := integrationtest.LoadConfigWithDefaultRegion("us-west-2")
if err != nil {
t.Fatalf("failed to load config, %v", err)
}
client := lambda.NewFromConfig(cfg)
params := &lambda.InvokeInput{
FunctionName: aws.String("bogus-function"),
}
_, err = client.Invoke(ctx, params)
if err == nil {
t.Fatalf("expect request to fail")
}
var apiErr smithy.APIError
if !errors.As(err, &apiErr) {
t.Fatalf("expect error to be API error, was not, %v", err)
}
if len(apiErr.ErrorCode()) == 0 {
t.Errorf("expect non-empty error code")
}
if len(apiErr.ErrorMessage()) == 0 {
t.Errorf("expect non-empty error message")
}
}
| 64 |
aws-sdk-go-v2 | aws | Go | //go:build integration
// +build integration
package lightsail
import (
"context"
"testing"
"time"
"github.com/aws/aws-sdk-go-v2/service/internal/integrationtest"
"github.com/aws/aws-sdk-go-v2/service/lightsail"
)
func TestInteg_00_GetActiveNames(t *testing.T) {
ctx, cancelFn := context.WithTimeout(context.Background(), 5*time.Second)
defer cancelFn()
cfg, err := integrationtest.LoadConfigWithDefaultRegion("us-west-2")
if err != nil {
t.Fatalf("failed to load config, %v", err)
}
client := lightsail.NewFromConfig(cfg)
params := &lightsail.GetActiveNamesInput{}
_, err = client.GetActiveNames(ctx, params)
if err != nil {
t.Errorf("expect no error, got %v", err)
}
}
func TestInteg_00_GetContainerServicePowers(t *testing.T) {
ctx, cancelFn := context.WithTimeout(context.Background(), 5*time.Second)
defer cancelFn()
cfg, err := integrationtest.LoadConfigWithDefaultRegion("us-west-2")
if err != nil {
t.Fatalf("failed to load config, %v", err)
}
client := lightsail.NewFromConfig(cfg)
params := &lightsail.GetContainerServicePowersInput{}
_, err = client.GetContainerServicePowers(ctx, params)
if err != nil {
t.Errorf("expect no error, got %v", err)
}
}
| 48 |
aws-sdk-go-v2 | aws | Go | //go:build integration
// +build integration
package marketplacecommerceanalytics
import (
"context"
"errors"
"testing"
"time"
"github.com/aws/aws-sdk-go-v2/aws"
"github.com/aws/aws-sdk-go-v2/service/internal/integrationtest"
"github.com/aws/aws-sdk-go-v2/service/marketplacecommerceanalytics"
"github.com/aws/aws-sdk-go-v2/service/marketplacecommerceanalytics/types"
"github.com/aws/smithy-go"
smithytime "github.com/aws/smithy-go/time"
)
func TestInteg_00_GenerateDataSet(t *testing.T) {
ctx, cancelFn := context.WithTimeout(context.Background(), 5*time.Second)
defer cancelFn()
cfg, err := integrationtest.LoadConfigWithDefaultRegion("us-east-1")
if err != nil {
t.Fatalf("failed to load config, %v", err)
}
client := marketplacecommerceanalytics.NewFromConfig(cfg)
params := &marketplacecommerceanalytics.GenerateDataSetInput{
DataSetPublicationDate: aws.Time(smithytime.ParseEpochSeconds(0.000000)),
DataSetType: types.DataSetTypeDailyBusinessFees,
DestinationS3BucketName: aws.String("fake-bucket"),
RoleNameArn: aws.String("fake-arn"),
SnsTopicArn: aws.String("fake-arn"),
}
_, err = client.GenerateDataSet(ctx, params)
if err == nil {
t.Fatalf("expect request to fail")
}
var apiErr smithy.APIError
if !errors.As(err, &apiErr) {
t.Fatalf("expect error to be API error, was not, %v", err)
}
if len(apiErr.ErrorCode()) == 0 {
t.Errorf("expect non-empty error code")
}
if len(apiErr.ErrorMessage()) == 0 {
t.Errorf("expect non-empty error message")
}
}
| 53 |
aws-sdk-go-v2 | aws | Go | //go:build integration
// +build integration
package neptune
import (
"context"
"errors"
"testing"
"time"
"github.com/aws/aws-sdk-go-v2/aws"
"github.com/aws/aws-sdk-go-v2/service/internal/integrationtest"
"github.com/aws/aws-sdk-go-v2/service/neptune"
"github.com/aws/smithy-go"
)
func TestInteg_00_DescribeDBEngineVersions(t *testing.T) {
ctx, cancelFn := context.WithTimeout(context.Background(), 5*time.Second)
defer cancelFn()
cfg, err := integrationtest.LoadConfigWithDefaultRegion("us-west-2")
if err != nil {
t.Fatalf("failed to load config, %v", err)
}
client := neptune.NewFromConfig(cfg)
params := &neptune.DescribeDBEngineVersionsInput{}
_, err = client.DescribeDBEngineVersions(ctx, params)
if err != nil {
t.Errorf("expect no error, got %v", err)
}
}
func TestInteg_01_DescribeDBInstances(t *testing.T) {
ctx, cancelFn := context.WithTimeout(context.Background(), 5*time.Second)
defer cancelFn()
cfg, err := integrationtest.LoadConfigWithDefaultRegion("us-west-2")
if err != nil {
t.Fatalf("failed to load config, %v", err)
}
client := neptune.NewFromConfig(cfg)
params := &neptune.DescribeDBInstancesInput{
DBInstanceIdentifier: aws.String("fake-id"),
}
_, err = client.DescribeDBInstances(ctx, params)
if err == nil {
t.Fatalf("expect request to fail")
}
var apiErr smithy.APIError
if !errors.As(err, &apiErr) {
t.Fatalf("expect error to be API error, was not, %v", err)
}
if len(apiErr.ErrorCode()) == 0 {
t.Errorf("expect non-empty error code")
}
if len(apiErr.ErrorMessage()) == 0 {
t.Errorf("expect non-empty error message")
}
}
| 64 |
aws-sdk-go-v2 | aws | Go | //go:build integration
// +build integration
package opsworks
import (
"context"
"errors"
"testing"
"time"
"github.com/aws/aws-sdk-go-v2/aws"
"github.com/aws/aws-sdk-go-v2/service/internal/integrationtest"
"github.com/aws/aws-sdk-go-v2/service/opsworks"
"github.com/aws/smithy-go"
)
func TestInteg_00_DescribeStacks(t *testing.T) {
ctx, cancelFn := context.WithTimeout(context.Background(), 5*time.Second)
defer cancelFn()
cfg, err := integrationtest.LoadConfigWithDefaultRegion("us-west-2")
if err != nil {
t.Fatalf("failed to load config, %v", err)
}
client := opsworks.NewFromConfig(cfg)
params := &opsworks.DescribeStacksInput{}
_, err = client.DescribeStacks(ctx, params)
if err != nil {
t.Errorf("expect no error, got %v", err)
}
}
func TestInteg_01_DescribeLayers(t *testing.T) {
ctx, cancelFn := context.WithTimeout(context.Background(), 5*time.Second)
defer cancelFn()
cfg, err := integrationtest.LoadConfigWithDefaultRegion("us-west-2")
if err != nil {
t.Fatalf("failed to load config, %v", err)
}
client := opsworks.NewFromConfig(cfg)
params := &opsworks.DescribeLayersInput{
StackId: aws.String("fake_stack"),
}
_, err = client.DescribeLayers(ctx, params)
if err == nil {
t.Fatalf("expect request to fail")
}
var apiErr smithy.APIError
if !errors.As(err, &apiErr) {
t.Fatalf("expect error to be API error, was not, %v", err)
}
if len(apiErr.ErrorCode()) == 0 {
t.Errorf("expect non-empty error code")
}
if len(apiErr.ErrorMessage()) == 0 {
t.Errorf("expect non-empty error message")
}
}
| 64 |
aws-sdk-go-v2 | aws | Go | //go:build integration
// +build integration
package pinpointemail
import (
"context"
"errors"
"testing"
"time"
"github.com/aws/aws-sdk-go-v2/aws"
"github.com/aws/aws-sdk-go-v2/service/internal/integrationtest"
"github.com/aws/aws-sdk-go-v2/service/pinpointemail"
"github.com/aws/smithy-go"
)
func TestInteg_00_ListConfigurationSets(t *testing.T) {
ctx, cancelFn := context.WithTimeout(context.Background(), 5*time.Second)
defer cancelFn()
cfg, err := integrationtest.LoadConfigWithDefaultRegion("us-west-2")
if err != nil {
t.Fatalf("failed to load config, %v", err)
}
client := pinpointemail.NewFromConfig(cfg)
params := &pinpointemail.ListConfigurationSetsInput{}
_, err = client.ListConfigurationSets(ctx, params)
if err != nil {
t.Errorf("expect no error, got %v", err)
}
}
func TestInteg_01_PutConfigurationSetTrackingOptions(t *testing.T) {
ctx, cancelFn := context.WithTimeout(context.Background(), 5*time.Second)
defer cancelFn()
cfg, err := integrationtest.LoadConfigWithDefaultRegion("us-west-2")
if err != nil {
t.Fatalf("failed to load config, %v", err)
}
client := pinpointemail.NewFromConfig(cfg)
params := &pinpointemail.PutConfigurationSetTrackingOptionsInput{
ConfigurationSetName: aws.String("config-set-name-not-exists"),
}
_, err = client.PutConfigurationSetTrackingOptions(ctx, params)
if err == nil {
t.Fatalf("expect request to fail")
}
var apiErr smithy.APIError
if !errors.As(err, &apiErr) {
t.Fatalf("expect error to be API error, was not, %v", err)
}
if len(apiErr.ErrorCode()) == 0 {
t.Errorf("expect non-empty error code")
}
if len(apiErr.ErrorMessage()) == 0 {
t.Errorf("expect non-empty error message")
}
}
| 64 |
aws-sdk-go-v2 | aws | Go | //go:build integration
// +build integration
package polly
import (
"context"
"testing"
"time"
"github.com/aws/aws-sdk-go-v2/service/internal/integrationtest"
"github.com/aws/aws-sdk-go-v2/service/polly"
)
func TestInteg_00_DescribeVoices(t *testing.T) {
ctx, cancelFn := context.WithTimeout(context.Background(), 5*time.Second)
defer cancelFn()
cfg, err := integrationtest.LoadConfigWithDefaultRegion("us-west-2")
if err != nil {
t.Fatalf("failed to load config, %v", err)
}
client := polly.NewFromConfig(cfg)
params := &polly.DescribeVoicesInput{}
_, err = client.DescribeVoices(ctx, params)
if err != nil {
t.Errorf("expect no error, got %v", err)
}
}
| 31 |
aws-sdk-go-v2 | aws | Go | //go:build integration
// +build integration
package rds
import (
"context"
"errors"
"testing"
"time"
"github.com/aws/aws-sdk-go-v2/aws"
"github.com/aws/aws-sdk-go-v2/service/internal/integrationtest"
"github.com/aws/aws-sdk-go-v2/service/rds"
"github.com/aws/smithy-go"
)
func TestInteg_00_DescribeDBEngineVersions(t *testing.T) {
ctx, cancelFn := context.WithTimeout(context.Background(), 5*time.Second)
defer cancelFn()
cfg, err := integrationtest.LoadConfigWithDefaultRegion("us-west-2")
if err != nil {
t.Fatalf("failed to load config, %v", err)
}
client := rds.NewFromConfig(cfg)
params := &rds.DescribeDBEngineVersionsInput{}
_, err = client.DescribeDBEngineVersions(ctx, params)
if err != nil {
t.Errorf("expect no error, got %v", err)
}
}
func TestInteg_01_DescribeDBInstances(t *testing.T) {
ctx, cancelFn := context.WithTimeout(context.Background(), 5*time.Second)
defer cancelFn()
cfg, err := integrationtest.LoadConfigWithDefaultRegion("us-west-2")
if err != nil {
t.Fatalf("failed to load config, %v", err)
}
client := rds.NewFromConfig(cfg)
params := &rds.DescribeDBInstancesInput{
DBInstanceIdentifier: aws.String("fake-id"),
}
_, err = client.DescribeDBInstances(ctx, params)
if err == nil {
t.Fatalf("expect request to fail")
}
var apiErr smithy.APIError
if !errors.As(err, &apiErr) {
t.Fatalf("expect error to be API error, was not, %v", err)
}
if len(apiErr.ErrorCode()) == 0 {
t.Errorf("expect non-empty error code")
}
if len(apiErr.ErrorMessage()) == 0 {
t.Errorf("expect non-empty error message")
}
}
| 64 |
aws-sdk-go-v2 | aws | Go | //go:build integration
// +build integration
package redshift
import (
"context"
"errors"
"testing"
"time"
"github.com/aws/aws-sdk-go-v2/aws"
"github.com/aws/aws-sdk-go-v2/service/internal/integrationtest"
"github.com/aws/aws-sdk-go-v2/service/redshift"
"github.com/aws/smithy-go"
)
func TestInteg_00_DescribeClusterVersions(t *testing.T) {
ctx, cancelFn := context.WithTimeout(context.Background(), 5*time.Second)
defer cancelFn()
cfg, err := integrationtest.LoadConfigWithDefaultRegion("us-west-2")
if err != nil {
t.Fatalf("failed to load config, %v", err)
}
client := redshift.NewFromConfig(cfg)
params := &redshift.DescribeClusterVersionsInput{}
_, err = client.DescribeClusterVersions(ctx, params)
if err != nil {
t.Errorf("expect no error, got %v", err)
}
}
func TestInteg_01_DescribeClusters(t *testing.T) {
ctx, cancelFn := context.WithTimeout(context.Background(), 5*time.Second)
defer cancelFn()
cfg, err := integrationtest.LoadConfigWithDefaultRegion("us-west-2")
if err != nil {
t.Fatalf("failed to load config, %v", err)
}
client := redshift.NewFromConfig(cfg)
params := &redshift.DescribeClustersInput{
ClusterIdentifier: aws.String("fake-cluster"),
}
_, err = client.DescribeClusters(ctx, params)
if err == nil {
t.Fatalf("expect request to fail")
}
var apiErr smithy.APIError
if !errors.As(err, &apiErr) {
t.Fatalf("expect error to be API error, was not, %v", err)
}
if len(apiErr.ErrorCode()) == 0 {
t.Errorf("expect non-empty error code")
}
if len(apiErr.ErrorMessage()) == 0 {
t.Errorf("expect non-empty error message")
}
}
| 64 |
aws-sdk-go-v2 | aws | Go | //go:build integration
// +build integration
package rekognition
import (
"context"
"testing"
"time"
"github.com/aws/aws-sdk-go-v2/service/internal/integrationtest"
"github.com/aws/aws-sdk-go-v2/service/rekognition"
)
func TestInteg_00_ListCollections(t *testing.T) {
ctx, cancelFn := context.WithTimeout(context.Background(), 5*time.Second)
defer cancelFn()
cfg, err := integrationtest.LoadConfigWithDefaultRegion("us-west-2")
if err != nil {
t.Fatalf("failed to load config, %v", err)
}
client := rekognition.NewFromConfig(cfg)
params := &rekognition.ListCollectionsInput{}
_, err = client.ListCollections(ctx, params)
if err != nil {
t.Errorf("expect no error, got %v", err)
}
}
| 31 |
aws-sdk-go-v2 | aws | Go | //go:build integration
// +build integration
package route53
import (
"context"
"errors"
"testing"
"time"
"github.com/aws/aws-sdk-go-v2/aws"
"github.com/aws/aws-sdk-go-v2/service/internal/integrationtest"
"github.com/aws/aws-sdk-go-v2/service/route53"
"github.com/aws/smithy-go"
)
func TestInteg_00_ListHostedZones(t *testing.T) {
ctx, cancelFn := context.WithTimeout(context.Background(), 5*time.Second)
defer cancelFn()
cfg, err := integrationtest.LoadConfigWithDefaultRegion("us-east-1")
if err != nil {
t.Fatalf("failed to load config, %v", err)
}
client := route53.NewFromConfig(cfg)
params := &route53.ListHostedZonesInput{}
_, err = client.ListHostedZones(ctx, params)
if err != nil {
t.Errorf("expect no error, got %v", err)
}
}
func TestInteg_01_GetHostedZone(t *testing.T) {
ctx, cancelFn := context.WithTimeout(context.Background(), 5*time.Second)
defer cancelFn()
cfg, err := integrationtest.LoadConfigWithDefaultRegion("us-east-1")
if err != nil {
t.Fatalf("failed to load config, %v", err)
}
client := route53.NewFromConfig(cfg)
params := &route53.GetHostedZoneInput{
Id: aws.String("fake-zone"),
}
_, err = client.GetHostedZone(ctx, params)
if err == nil {
t.Fatalf("expect request to fail")
}
var apiErr smithy.APIError
if !errors.As(err, &apiErr) {
t.Fatalf("expect error to be API error, was not, %v", err)
}
if len(apiErr.ErrorCode()) == 0 {
t.Errorf("expect non-empty error code")
}
if len(apiErr.ErrorMessage()) == 0 {
t.Errorf("expect non-empty error message")
}
}
| 64 |
aws-sdk-go-v2 | aws | Go | //go:build integration
// +build integration
package route53domains
import (
"context"
"errors"
"testing"
"time"
"github.com/aws/aws-sdk-go-v2/aws"
"github.com/aws/aws-sdk-go-v2/service/internal/integrationtest"
"github.com/aws/aws-sdk-go-v2/service/route53domains"
"github.com/aws/smithy-go"
)
func TestInteg_00_ListDomains(t *testing.T) {
ctx, cancelFn := context.WithTimeout(context.Background(), 5*time.Second)
defer cancelFn()
cfg, err := integrationtest.LoadConfigWithDefaultRegion("us-east-1")
if err != nil {
t.Fatalf("failed to load config, %v", err)
}
client := route53domains.NewFromConfig(cfg)
params := &route53domains.ListDomainsInput{}
_, err = client.ListDomains(ctx, params)
if err != nil {
t.Errorf("expect no error, got %v", err)
}
}
func TestInteg_01_GetDomainDetail(t *testing.T) {
ctx, cancelFn := context.WithTimeout(context.Background(), 5*time.Second)
defer cancelFn()
cfg, err := integrationtest.LoadConfigWithDefaultRegion("us-east-1")
if err != nil {
t.Fatalf("failed to load config, %v", err)
}
client := route53domains.NewFromConfig(cfg)
params := &route53domains.GetDomainDetailInput{
DomainName: aws.String("fake-domain-name"),
}
_, err = client.GetDomainDetail(ctx, params)
if err == nil {
t.Fatalf("expect request to fail")
}
var apiErr smithy.APIError
if !errors.As(err, &apiErr) {
t.Fatalf("expect error to be API error, was not, %v", err)
}
if len(apiErr.ErrorCode()) == 0 {
t.Errorf("expect non-empty error code")
}
if len(apiErr.ErrorMessage()) == 0 {
t.Errorf("expect non-empty error message")
}
}
| 64 |
aws-sdk-go-v2 | aws | Go | //go:build integration
// +build integration
package route53resolver
import (
"context"
"errors"
"testing"
"time"
"github.com/aws/aws-sdk-go-v2/aws"
"github.com/aws/aws-sdk-go-v2/service/internal/integrationtest"
"github.com/aws/aws-sdk-go-v2/service/route53resolver"
"github.com/aws/smithy-go"
)
func TestInteg_00_ListResolverEndpoints(t *testing.T) {
ctx, cancelFn := context.WithTimeout(context.Background(), 5*time.Second)
defer cancelFn()
cfg, err := integrationtest.LoadConfigWithDefaultRegion("us-west-2")
if err != nil {
t.Fatalf("failed to load config, %v", err)
}
client := route53resolver.NewFromConfig(cfg)
params := &route53resolver.ListResolverEndpointsInput{}
_, err = client.ListResolverEndpoints(ctx, params)
if err != nil {
t.Errorf("expect no error, got %v", err)
}
}
func TestInteg_01_GetResolverRule(t *testing.T) {
ctx, cancelFn := context.WithTimeout(context.Background(), 5*time.Second)
defer cancelFn()
cfg, err := integrationtest.LoadConfigWithDefaultRegion("us-west-2")
if err != nil {
t.Fatalf("failed to load config, %v", err)
}
client := route53resolver.NewFromConfig(cfg)
params := &route53resolver.GetResolverRuleInput{
ResolverRuleId: aws.String("fake-id"),
}
_, err = client.GetResolverRule(ctx, params)
if err == nil {
t.Fatalf("expect request to fail")
}
var apiErr smithy.APIError
if !errors.As(err, &apiErr) {
t.Fatalf("expect error to be API error, was not, %v", err)
}
if len(apiErr.ErrorCode()) == 0 {
t.Errorf("expect non-empty error code")
}
if len(apiErr.ErrorMessage()) == 0 {
t.Errorf("expect non-empty error message")
}
}
| 64 |
aws-sdk-go-v2 | aws | Go | //go:build integration
// +build integration
package s3
import (
"strings"
"testing"
)
func TestInteg_WriteToObject(t *testing.T) {
cases := map[string]writeToObjectTestData{
"seekable body": {Body: strings.NewReader("hello world"), ExpectBody: []byte("hello world")},
"empty string body": {Body: strings.NewReader(""), ExpectBody: []byte("")},
"nil body": {Body: nil, ExpectBody: []byte("")},
}
for name, c := range cases {
t.Run(name, func(t *testing.T) {
testWriteToObject(t, setupMetadata.Buckets.Source.Name, c)
})
}
}
func TestInteg_CopyObject(t *testing.T) {
testCopyObject(t, setupMetadata.Buckets.Source.Name, setupMetadata.Buckets.Target.Name, nil)
}
| 28 |
aws-sdk-go-v2 | aws | Go | //go:build integration
// +build integration
package s3
import (
"bytes"
"context"
"fmt"
"io/ioutil"
"strings"
"testing"
"github.com/aws/aws-sdk-go-v2/aws"
"github.com/aws/aws-sdk-go-v2/service/s3"
"github.com/aws/aws-sdk-go-v2/service/s3/types"
s3types "github.com/aws/aws-sdk-go-v2/service/s3/types"
"github.com/aws/smithy-go/logging"
"github.com/google/go-cmp/cmp"
)
func TestInteg_ObjectChecksums(t *testing.T) {
cases := map[string]map[string]struct {
disableHTTPS bool
params *s3.PutObjectInput
expectErr string
getObjectChecksumMode s3types.ChecksumMode
expectReadErr string
expectLogged string
expectChecksumAlgorithms s3types.ChecksumAlgorithm
expectPayload []byte
expectComputedChecksums *s3.ComputedInputChecksumsMetadata
expectAlgorithmsUsed *s3.ChecksumValidationMetadata
}{
"seekable": {
"no checksum": {
params: &s3.PutObjectInput{
Body: strings.NewReader("abc123"),
},
getObjectChecksumMode: s3types.ChecksumModeEnabled,
expectPayload: []byte("abc123"),
expectLogged: "Response has no supported checksum.",
},
"preset checksum": {
params: &s3.PutObjectInput{
Body: strings.NewReader("hello world"),
ChecksumAlgorithm: s3types.ChecksumAlgorithmCrc32c,
ChecksumCRC32C: aws.String("yZRlqg=="),
},
getObjectChecksumMode: s3types.ChecksumModeEnabled,
expectPayload: []byte("hello world"),
expectComputedChecksums: &s3.ComputedInputChecksumsMetadata{
ComputedChecksums: map[string]string{
"CRC32C": "yZRlqg==",
},
},
expectAlgorithmsUsed: &s3.ChecksumValidationMetadata{
AlgorithmsUsed: []string{"CRC32C"},
},
},
"wrong preset checksum": {
params: &s3.PutObjectInput{
Body: strings.NewReader("hello world"),
ChecksumAlgorithm: s3types.ChecksumAlgorithmCrc32c,
ChecksumCRC32C: aws.String("RZRlqg=="),
},
getObjectChecksumMode: s3types.ChecksumModeEnabled,
expectErr: "BadDigest",
},
"without TLS autofill header checksum": {
disableHTTPS: true,
params: &s3.PutObjectInput{
Body: strings.NewReader("hello world"),
ChecksumAlgorithm: s3types.ChecksumAlgorithmCrc32c,
},
getObjectChecksumMode: s3types.ChecksumModeEnabled,
expectPayload: []byte("hello world"),
expectComputedChecksums: &s3.ComputedInputChecksumsMetadata{
ComputedChecksums: map[string]string{
"CRC32C": "yZRlqg==",
},
},
expectAlgorithmsUsed: &s3.ChecksumValidationMetadata{
AlgorithmsUsed: []string{"CRC32C"},
},
},
"autofill trailing checksum": {
params: &s3.PutObjectInput{
Body: strings.NewReader("hello world"),
ChecksumAlgorithm: s3types.ChecksumAlgorithmCrc32c,
},
getObjectChecksumMode: s3types.ChecksumModeEnabled,
expectPayload: []byte("hello world"),
expectComputedChecksums: &s3.ComputedInputChecksumsMetadata{
ComputedChecksums: map[string]string{
"CRC32C": "yZRlqg==",
},
},
expectAlgorithmsUsed: &s3.ChecksumValidationMetadata{
AlgorithmsUsed: []string{"CRC32C"},
},
},
"content length preset": {
params: &s3.PutObjectInput{
Body: strings.NewReader("hello world"),
ContentLength: 11,
ChecksumAlgorithm: s3types.ChecksumAlgorithmCrc32c,
},
getObjectChecksumMode: s3types.ChecksumModeEnabled,
expectPayload: []byte("hello world"),
expectComputedChecksums: &s3.ComputedInputChecksumsMetadata{
ComputedChecksums: map[string]string{
"CRC32C": "yZRlqg==",
},
},
expectAlgorithmsUsed: &s3.ChecksumValidationMetadata{
AlgorithmsUsed: []string{"CRC32C"},
},
},
"with content encoding set": {
params: &s3.PutObjectInput{
Body: strings.NewReader("hello world"),
ChecksumAlgorithm: s3types.ChecksumAlgorithmCrc32c,
ContentEncoding: aws.String("gzip"),
},
getObjectChecksumMode: s3types.ChecksumModeEnabled,
expectPayload: []byte("hello world"),
expectComputedChecksums: &s3.ComputedInputChecksumsMetadata{
ComputedChecksums: map[string]string{
"CRC32C": "yZRlqg==",
},
},
expectAlgorithmsUsed: &s3.ChecksumValidationMetadata{
AlgorithmsUsed: []string{"CRC32C"},
},
},
},
"unseekable": {
"no checksum": {
params: &s3.PutObjectInput{
Body: bytes.NewBuffer([]byte("abc123")),
},
getObjectChecksumMode: s3types.ChecksumModeEnabled,
expectPayload: []byte("abc123"),
expectLogged: "Response has no supported checksum.",
},
"preset checksum": {
params: &s3.PutObjectInput{
Body: bytes.NewBuffer([]byte("hello world")),
ChecksumAlgorithm: s3types.ChecksumAlgorithmCrc32c,
ChecksumCRC32C: aws.String("yZRlqg=="),
},
getObjectChecksumMode: s3types.ChecksumModeEnabled,
expectPayload: []byte("hello world"),
expectComputedChecksums: &s3.ComputedInputChecksumsMetadata{
ComputedChecksums: map[string]string{
"CRC32C": "yZRlqg==",
},
},
expectAlgorithmsUsed: &s3.ChecksumValidationMetadata{
AlgorithmsUsed: []string{"CRC32C"},
},
},
"wrong preset checksum": {
params: &s3.PutObjectInput{
Body: bytes.NewBuffer([]byte("hello world")),
ChecksumAlgorithm: s3types.ChecksumAlgorithmCrc32c,
ChecksumCRC32C: aws.String("RZRlqg=="),
},
getObjectChecksumMode: s3types.ChecksumModeEnabled,
expectErr: "BadDigest",
},
"autofill trailing checksum": {
params: &s3.PutObjectInput{
Body: bytes.NewBuffer([]byte("hello world")),
ChecksumAlgorithm: s3types.ChecksumAlgorithmCrc32c,
},
getObjectChecksumMode: s3types.ChecksumModeEnabled,
expectPayload: []byte("hello world"),
expectComputedChecksums: &s3.ComputedInputChecksumsMetadata{
ComputedChecksums: map[string]string{
"CRC32C": "yZRlqg==",
},
},
expectAlgorithmsUsed: &s3.ChecksumValidationMetadata{
AlgorithmsUsed: []string{"CRC32C"},
},
},
"without TLS": {
disableHTTPS: true,
params: &s3.PutObjectInput{
Body: bytes.NewBuffer([]byte("hello world")),
ChecksumAlgorithm: s3types.ChecksumAlgorithmCrc32c,
},
expectErr: "unseekable stream is not supported without TLS",
},
"content length preset": {
params: &s3.PutObjectInput{
Body: ioutil.NopCloser(strings.NewReader("hello world")),
ContentLength: 11,
ChecksumAlgorithm: s3types.ChecksumAlgorithmCrc32c,
},
getObjectChecksumMode: s3types.ChecksumModeEnabled,
expectPayload: []byte("hello world"),
expectComputedChecksums: &s3.ComputedInputChecksumsMetadata{
ComputedChecksums: map[string]string{
"CRC32C": "yZRlqg==",
},
},
expectAlgorithmsUsed: &s3.ChecksumValidationMetadata{
AlgorithmsUsed: []string{"CRC32C"},
},
},
"unknown content length": {
params: &s3.PutObjectInput{
Body: ioutil.NopCloser(strings.NewReader("hello world")),
ChecksumAlgorithm: s3types.ChecksumAlgorithmCrc32c,
},
expectErr: "MissingContentLength",
},
},
"nil body": {
"no checksum": {
params: &s3.PutObjectInput{},
getObjectChecksumMode: s3types.ChecksumModeEnabled,
expectLogged: "Response has no supported checksum.",
},
"preset checksum": {
params: &s3.PutObjectInput{
ChecksumAlgorithm: s3types.ChecksumAlgorithmCrc32c,
ChecksumCRC32C: aws.String("AAAAAA=="),
},
getObjectChecksumMode: s3types.ChecksumModeEnabled,
expectComputedChecksums: &s3.ComputedInputChecksumsMetadata{
ComputedChecksums: map[string]string{
"CRC32C": "AAAAAA==",
},
},
expectAlgorithmsUsed: &s3.ChecksumValidationMetadata{
AlgorithmsUsed: []string{"CRC32C"},
},
},
"autofill checksum": {
params: &s3.PutObjectInput{
ChecksumAlgorithm: s3types.ChecksumAlgorithmCrc32c,
},
getObjectChecksumMode: s3types.ChecksumModeEnabled,
expectComputedChecksums: &s3.ComputedInputChecksumsMetadata{
ComputedChecksums: map[string]string{
"CRC32C": "AAAAAA==",
},
},
expectAlgorithmsUsed: &s3.ChecksumValidationMetadata{
AlgorithmsUsed: []string{"CRC32C"},
},
},
"without TLS autofill checksum": {
disableHTTPS: true,
params: &s3.PutObjectInput{
ChecksumAlgorithm: s3types.ChecksumAlgorithmCrc32c,
},
getObjectChecksumMode: s3types.ChecksumModeEnabled,
expectComputedChecksums: &s3.ComputedInputChecksumsMetadata{
ComputedChecksums: map[string]string{
"CRC32C": "AAAAAA==",
},
},
expectAlgorithmsUsed: &s3.ChecksumValidationMetadata{
AlgorithmsUsed: []string{"CRC32C"},
},
},
},
"empty body": {
"no checksum": {
params: &s3.PutObjectInput{
Body: bytes.NewBuffer([]byte{}),
},
getObjectChecksumMode: s3types.ChecksumModeEnabled,
expectLogged: "Response has no supported checksum.",
},
"preset checksum": {
params: &s3.PutObjectInput{
Body: bytes.NewBuffer([]byte{}),
ChecksumAlgorithm: s3types.ChecksumAlgorithmCrc32c,
ChecksumCRC32C: aws.String("AAAAAA=="),
},
getObjectChecksumMode: s3types.ChecksumModeEnabled,
expectComputedChecksums: &s3.ComputedInputChecksumsMetadata{
ComputedChecksums: map[string]string{
"CRC32C": "AAAAAA==",
},
},
expectAlgorithmsUsed: &s3.ChecksumValidationMetadata{
AlgorithmsUsed: []string{"CRC32C"},
},
},
"autofill checksum": {
params: &s3.PutObjectInput{
Body: bytes.NewBuffer([]byte{}),
ChecksumAlgorithm: s3types.ChecksumAlgorithmCrc32c,
},
getObjectChecksumMode: s3types.ChecksumModeEnabled,
expectComputedChecksums: &s3.ComputedInputChecksumsMetadata{
ComputedChecksums: map[string]string{
"CRC32C": "AAAAAA==",
},
},
expectAlgorithmsUsed: &s3.ChecksumValidationMetadata{
AlgorithmsUsed: []string{"CRC32C"},
},
},
"without TLS autofill checksum": {
disableHTTPS: true,
params: &s3.PutObjectInput{
Body: bytes.NewBuffer([]byte{}),
ChecksumAlgorithm: s3types.ChecksumAlgorithmCrc32c,
},
getObjectChecksumMode: s3types.ChecksumModeEnabled,
expectComputedChecksums: &s3.ComputedInputChecksumsMetadata{
ComputedChecksums: map[string]string{
"CRC32C": "AAAAAA==",
},
},
expectAlgorithmsUsed: &s3.ChecksumValidationMetadata{
AlgorithmsUsed: []string{"CRC32C"},
},
},
},
}
for groupName, cs := range cases {
t.Run(groupName, func(t *testing.T) {
for caseName, c := range cs {
t.Run(caseName, func(t *testing.T) {
c.params.Bucket = &setupMetadata.Buckets.Source.Name
c.params.Key = aws.String(t.Name())
ctx := context.Background()
logger, logged := bufferLogger(t)
s3Options := func(o *s3.Options) {
o.Logger = logger
o.EndpointOptions.DisableHTTPS = c.disableHTTPS
}
t.Logf("putting bucket: %q, object: %q", *c.params.Bucket, *c.params.Key)
putResult, err := s3client.PutObject(ctx, c.params, s3Options)
if err == nil && len(c.expectErr) != 0 {
t.Fatalf("expect error %v, got none", c.expectErr)
}
if err != nil && len(c.expectErr) == 0 {
t.Fatalf("expect no error, got %v", err)
}
if err != nil && !strings.Contains(err.Error(), c.expectErr) {
t.Fatalf("expect error to contain %v, got %v", c.expectErr, err)
}
if c.expectErr != "" {
return
}
// assert computed input checksums metadata
computedChecksums, ok := s3.GetComputedInputChecksumsMetadata(putResult.ResultMetadata)
if e, a := ok, (c.expectComputedChecksums != nil); e != a {
t.Fatalf("expect computed checksum metadata %t, got %t, %v", e, a, computedChecksums)
}
if c.expectComputedChecksums != nil {
if diff := cmp.Diff(*c.expectComputedChecksums, computedChecksums); diff != "" {
t.Errorf("expect computed checksum metadata match\n%s", diff)
}
}
getResult, err := s3client.GetObject(ctx, &s3.GetObjectInput{
Bucket: c.params.Bucket,
Key: c.params.Key,
ChecksumMode: c.getObjectChecksumMode,
}, s3Options)
if err != nil {
t.Fatalf("expect no error, got %v", err)
}
actualPayload, err := ioutil.ReadAll(getResult.Body)
if err == nil && len(c.expectReadErr) != 0 {
t.Fatalf("expected read error: %v, got none", c.expectReadErr)
}
if err != nil && len(c.expectReadErr) == 0 {
t.Fatalf("expect no read error, got %v", err)
}
if err != nil && !strings.Contains(err.Error(), c.expectReadErr) {
t.Fatalf("expected read error %v to contain %v", err, c.expectReadErr)
}
if c.expectReadErr != "" {
return
}
if diff := cmp.Diff(string(c.expectPayload), string(actualPayload)); diff != "" {
t.Errorf("expect payload match:\n%s", diff)
}
if err = getResult.Body.Close(); err != nil {
t.Errorf("expect no close error, got %v", err)
}
// Only compare string values, since S3 can respond with
// empty value Content-Encoding header.
if e, a := aws.ToString(c.params.ContentEncoding), aws.ToString(getResult.ContentEncoding); e != a {
t.Errorf("expect %v content encoding, got %v", e, a)
}
// assert checksum validation metadata
algorithmsUsed, ok := s3.GetChecksumValidationMetadata(getResult.ResultMetadata)
if e, a := ok, (c.expectAlgorithmsUsed != nil); e != a {
t.Fatalf("expect algorithms used metadata %t, got %t, %v", e, a, algorithmsUsed)
}
if c.expectAlgorithmsUsed != nil {
if diff := cmp.Diff(*c.expectAlgorithmsUsed, algorithmsUsed); diff != "" {
t.Errorf("expect algorithms used to match\n%s", diff)
}
}
if c.expectLogged != "" {
if e, a := c.expectLogged, logged.String(); !strings.Contains(a, e) {
t.Errorf("expected %q logged in:\n%s", e, a)
}
}
})
}
})
}
}
func TestInteg_RequireChecksum(t *testing.T) {
cases := map[string]struct {
checksumAlgorithm types.ChecksumAlgorithm
expectComputedChecksums []string
}{
"no algorithm": {
expectComputedChecksums: []string{"MD5"},
},
"with algorithm": {
checksumAlgorithm: types.ChecksumAlgorithmCrc32c,
expectComputedChecksums: []string{"CRC32C"},
},
}
for name, c := range cases {
t.Run(name, func(t *testing.T) {
result, err := s3client.DeleteObjects(context.Background(), &s3.DeleteObjectsInput{
Bucket: &setupMetadata.Buckets.Source.Name,
Delete: &s3types.Delete{
Objects: []s3types.ObjectIdentifier{
{Key: aws.String(t.Name())},
},
Quiet: true,
},
ChecksumAlgorithm: c.checksumAlgorithm,
})
if err != nil {
t.Fatalf("expect no error, got %v", err)
}
// assert computed input checksums metadata
computedChecksums, ok := s3.GetComputedInputChecksumsMetadata(result.ResultMetadata)
if e, a := ok, (c.expectComputedChecksums != nil); e != a {
t.Fatalf("expect computed checksum metadata %t, got %t, %v", e, a, computedChecksums)
}
if e, a := len(c.expectComputedChecksums), len(computedChecksums.ComputedChecksums); e != a {
t.Errorf("expect %v computed checksums, got %v, %v", e, a, computedChecksums)
}
for _, e := range c.expectComputedChecksums {
v, ok := computedChecksums.ComputedChecksums[e]
if !ok {
t.Errorf("expect %v algorithm to be computed", e)
}
if v == "" {
t.Errorf("expect %v algorithm to have non-empty computed checksum", e)
}
}
})
}
}
func bufferLogger(t *testing.T) (logging.Logger, *bytes.Buffer) {
var logged bytes.Buffer
logger := logging.LoggerFunc(
func(classification logging.Classification, format string, v ...interface{}) {
fmt.Fprintf(&logged, format, v...)
t.Logf(format, v...)
})
return logger, &logged
}
| 492 |
aws-sdk-go-v2 | aws | Go | //go:build integration
// +build integration
package s3
import (
"strings"
"testing"
)
func TestInteg_AccessPoint_WriteToObject(t *testing.T) {
cases := map[string]writeToObjectTestData{
"seekable body": {Body: strings.NewReader("hello world"), ExpectBody: []byte("hello world")},
}
for name, c := range cases {
t.Run(name, func(t *testing.T) {
testWriteToObject(t, setupMetadata.AccessPoints.Source.ARN, c)
})
}
}
| 21 |
aws-sdk-go-v2 | aws | Go | //go:build integration
// +build integration
package s3
import (
"context"
"github.com/aws/aws-sdk-go-v2/service/internal/integrationtest"
"testing"
"time"
"github.com/aws/aws-sdk-go-v2/service/s3"
)
func TestInteg_XSIType(t *testing.T) {
key := integrationtest.UniqueID()
ctx, cancelFn := context.WithTimeout(context.Background(), 5*time.Second)
defer cancelFn()
cfg, err := integrationtest.LoadConfigWithDefaultRegion("us-west-2")
if err != nil {
t.Fatalf("failed to load config, %v", err)
}
client := s3.NewFromConfig(cfg)
_, err = client.PutObject(ctx, &s3.PutObjectInput{
Bucket: &setupMetadata.Buckets.Source.Name,
Key: &key,
})
if err != nil {
t.Fatal(err)
}
resp, err := client.GetObjectAcl(ctx, &s3.GetObjectAclInput{
Bucket: &setupMetadata.Buckets.Source.Name,
Key: &key,
})
if err != nil {
t.Fatal(err)
}
if len(resp.Grants) == 0 {
t.Fatalf("expect Grants to not be empty")
}
if len(resp.Grants[0].Grantee.Type) == 0 {
t.Errorf("expect grantee type to not be empty")
}
}
| 52 |
aws-sdk-go-v2 | aws | Go | //go:build integration
// +build integration
package s3
import (
"bytes"
"context"
"fmt"
"io"
"io/ioutil"
"net/http"
"strconv"
"testing"
"time"
"github.com/aws/aws-sdk-go-v2/aws"
v4 "github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/internal/integrationtest"
"github.com/aws/aws-sdk-go-v2/service/s3"
s3types "github.com/aws/aws-sdk-go-v2/service/s3/types"
"github.com/google/go-cmp/cmp"
)
func TestInteg_PresignURL(t *testing.T) {
cases := map[string]struct {
params s3.PutObjectInput
expires time.Duration
sha256Header string
expectedSignedHeader http.Header
expectErr string
}{
"standard": {
params: s3.PutObjectInput{
Body: bytes.NewReader([]byte("Hello-world")),
},
expectedSignedHeader: http.Header{},
},
"special characters": {
params: s3.PutObjectInput{
Key: aws.String("some_value_(1).foo"),
},
},
"nil-body": {
expectedSignedHeader: http.Header{},
},
"empty-body": {
params: s3.PutObjectInput{
Body: bytes.NewReader([]byte("")),
},
expectedSignedHeader: http.Header{},
},
"preset checksum": {
params: s3.PutObjectInput{
Body: bytes.NewReader([]byte("hello world")),
ChecksumAlgorithm: s3types.ChecksumAlgorithmCrc32,
ChecksumCRC32: aws.String("DUoRhQ=="),
},
expectedSignedHeader: http.Header{},
},
}
for name, c := range cases {
t.Run(name, func(t *testing.T) {
ctx, cancelFn := context.WithTimeout(context.Background(), 5*time.Second)
defer cancelFn()
cfg, err := integrationtest.LoadConfigWithDefaultRegion("us-west-2")
if err != nil {
t.Fatalf("failed to load config, %v", err)
}
client := s3.NewFromConfig(cfg)
// construct a put object
presignerClient := s3.NewPresignClient(client, func(options *s3.PresignOptions) {
options.Expires = 600 * time.Second
})
params := c.params
if params.Key == nil {
params.Key = aws.String(integrationtest.UniqueID())
}
params.Bucket = &setupMetadata.Buckets.Source.Name
presignRequest, err := presignerClient.PresignPutObject(ctx, ¶ms)
if err != nil {
t.Fatalf("expect no error, got %v", err)
}
for k, v := range c.expectedSignedHeader {
value := presignRequest.SignedHeader[k]
if len(value) == 0 {
t.Fatalf("expected %v header to be present in presigned url, got %v", k, presignRequest.SignedHeader)
}
if diff := cmp.Diff(v, value); len(diff) != 0 {
t.Fatalf("expected %v header value to be %v got %v", k, v, value)
}
}
resp, err := sendHTTPRequest(presignRequest, params.Body)
if err != nil {
t.Errorf("expect no error while sending HTTP request using presigned url, got %v", err)
}
defer resp.Body.Close()
if resp.StatusCode != http.StatusOK {
t.Fatalf("failed to put S3 object, %d:%s", resp.StatusCode, resp.Status)
}
// construct a get object
getObjectInput := &s3.GetObjectInput{
Bucket: params.Bucket,
Key: params.Key,
}
presignRequest, err = presignerClient.PresignGetObject(ctx, getObjectInput)
if err != nil {
t.Errorf("expect no error, got %v", err)
}
resp, err = sendHTTPRequest(presignRequest, nil)
if err != nil {
t.Errorf("expect no error while sending HTTP request using presigned url, got %v", err)
}
defer resp.Body.Close()
if resp.StatusCode != http.StatusOK {
t.Fatalf("failed to get S3 object, %d:%s", resp.StatusCode, resp.Status)
}
})
}
}
func TestInteg_MultipartPresignURL(t *testing.T) {
t.Skip("CompleteMultipartUpload requires part number to be passed for successful testing.")
cases := map[string]struct {
key string
body io.Reader
expires time.Duration
sha256Header string
expectedSignedHeader http.Header
}{
"standard": {
body: bytes.NewReader([]byte("Hello-world")),
expectedSignedHeader: http.Header{},
},
"special characters": {
key: "some_value_(1).foo",
},
"nil-body": {
expectedSignedHeader: http.Header{},
},
"empty-body": {
body: bytes.NewReader([]byte("")),
expectedSignedHeader: http.Header{},
},
}
for name, c := range cases {
t.Run(name, func(t *testing.T) {
key := c.key
if len(key) == 0 {
key = integrationtest.UniqueID()
}
ctx, cancelFn := context.WithTimeout(context.Background(), 5*time.Second)
defer cancelFn()
cfg, err := integrationtest.LoadConfigWithDefaultRegion("us-west-2")
if err != nil {
t.Fatalf("failed to load config, %v", err)
}
client := s3.NewFromConfig(cfg)
multipartUpload, err := client.CreateMultipartUpload(ctx, &s3.CreateMultipartUploadInput{
Bucket: &setupMetadata.Buckets.Source.Name,
Key: &key,
})
if err != nil {
t.Fatalf("error creating multipart upload: %v", err)
}
// construct an upload part object
uploadPartInput := &s3.UploadPartInput{
Bucket: &setupMetadata.Buckets.Source.Name,
Key: &key,
PartNumber: 1,
UploadId: multipartUpload.UploadId,
Body: c.body,
}
presignerClient := s3.NewPresignClient(client, func(options *s3.PresignOptions) {
options.Expires = 600 * time.Second
})
presignRequest, err := presignerClient.PresignUploadPart(ctx, uploadPartInput)
if err != nil {
t.Fatalf("expect no error, got %v", err)
}
for k, v := range c.expectedSignedHeader {
value := presignRequest.SignedHeader[k]
if len(value) == 0 {
t.Fatalf("expected %v header to be present in presigned url, got %v", k, presignRequest.SignedHeader)
}
if diff := cmp.Diff(v, value); len(diff) != 0 {
t.Fatalf("expected %v header value to be %v got %v", k, v, value)
}
}
resp, err := sendHTTPRequest(presignRequest, uploadPartInput.Body)
if err != nil {
t.Errorf("expect no error while sending HTTP request using presigned url, got %v", err)
}
defer resp.Body.Close()
if resp.StatusCode != http.StatusOK {
t.Fatalf("failed to upload part, %d:%s", resp.StatusCode, resp.Status)
}
_, err = client.CompleteMultipartUpload(ctx, &s3.CompleteMultipartUploadInput{
Bucket: &setupMetadata.Buckets.Source.Name,
Key: &key,
UploadId: multipartUpload.UploadId,
})
if err != nil {
t.Fatalf("error completing multipart upload: %v", err)
}
// construct a get object
getObjectInput := &s3.GetObjectInput{
Bucket: &setupMetadata.Buckets.Source.Name,
Key: &key,
}
presignRequest, err = presignerClient.PresignGetObject(ctx, getObjectInput)
if err != nil {
t.Errorf("expect no error, got %v", err)
}
resp, err = sendHTTPRequest(presignRequest, nil)
if err != nil {
t.Errorf("expect no error while sending HTTP request using presigned url, got %v", err)
}
defer resp.Body.Close()
if resp.StatusCode != http.StatusOK {
t.Fatalf("failed to get S3 object, %d:%s", resp.StatusCode, resp.Status)
}
})
}
}
func sendHTTPRequest(presignRequest *v4.PresignedHTTPRequest, body io.Reader) (*http.Response, error) {
// create a http request
req, err := http.NewRequest(presignRequest.Method, presignRequest.URL, nil)
if err != nil {
return nil, fmt.Errorf("failed to build presigned request, %v", err)
}
// assign the signed headers onto the http request
for k, vs := range presignRequest.SignedHeader {
for _, v := range vs {
req.Header.Add(k, v)
}
}
// Need to ensure that the content length member is set of the HTTP Request
// or the request will NOT be transmitted correctly with a content length
// value across the wire.
if contLen := req.Header.Get("Content-Length"); len(contLen) > 0 {
req.ContentLength, _ = strconv.ParseInt(contLen, 10, 64)
}
// assign the request body if not nil
if body != nil {
req.Body = ioutil.NopCloser(body)
if req.ContentLength == 0 {
req.Body = nil
}
}
// Upload the object to S3.
resp, err := http.DefaultClient.Do(req)
return resp, err
}
| 299 |
aws-sdk-go-v2 | aws | Go | //go:build integration
// +build integration
package s3
import (
"bytes"
"context"
"crypto/tls"
"flag"
"fmt"
"io"
"io/ioutil"
"net/http"
"os"
"strings"
"testing"
"github.com/aws/aws-sdk-go-v2/aws"
"github.com/aws/aws-sdk-go-v2/aws/arn"
"github.com/aws/aws-sdk-go-v2/service/internal/integrationtest"
"github.com/aws/aws-sdk-go-v2/service/internal/integrationtest/s3shared"
"github.com/aws/aws-sdk-go-v2/service/s3"
"github.com/aws/aws-sdk-go-v2/service/s3control"
"github.com/aws/aws-sdk-go-v2/service/sts"
)
var setupMetadata = struct {
AccountID string
Region string
Buckets struct {
Source struct {
Name string
ARN string
}
Target struct {
Name string
ARN string
}
}
AccessPoints struct {
Source struct {
Name string
ARN string
}
Target struct {
Name string
ARN string
}
}
}{}
// s3 client to use for integ testing
var s3client *s3.Client
// s3-control client to use for integ testing
var s3ControlClient *s3control.Client
// sts client to use for integ testing
var stsClient *sts.Client
// http client setting to use for integ testing
var httpClient *http.Client
var region = "us-west-2"
// TestMain executes at start of package tests
func TestMain(m *testing.M) {
flag.Parse()
flag.CommandLine.Visit(func(f *flag.Flag) {
if !(f.Name == "run" || f.Name == "test.run") {
return
}
value := f.Value.String()
if value == `NONE` {
os.Exit(0)
}
})
var result int
defer func() {
if r := recover(); r != nil {
fmt.Fprintln(os.Stderr, "S3 integration tests panic,", r)
result = 1
}
os.Exit(result)
}()
var verifyTLS bool
var s3Endpoint, s3ControlEndpoint string
var s3EnableTLS, s3ControlEnableTLS bool
flag.StringVar(&s3Endpoint, "s3-endpoint", "", "integration endpoint for S3")
flag.BoolVar(&s3EnableTLS, "s3-tls", true, "enable TLS for S3 endpoint")
flag.StringVar(&s3ControlEndpoint, "s3-control-endpoint", "", "integration endpoint for S3")
flag.BoolVar(&s3ControlEnableTLS, "s3-control-tls", true, "enable TLS for S3 control endpoint")
flag.StringVar(&setupMetadata.AccountID, "account", "", "integration account id")
flag.BoolVar(&verifyTLS, "verify-tls", true, "verify server TLS certificate")
flag.Parse()
httpClient = &http.Client{
Transport: &http.Transport{
TLSClientConfig: &tls.Config{InsecureSkipVerify: verifyTLS},
},
}
cfg, err := integrationtest.LoadConfigWithDefaultRegion(region)
if err != nil {
fmt.Fprintf(os.Stderr, "Error occurred while loading config with region %v, %v", region, err)
result = 1
return
}
// assign the http client
cfg.HTTPClient = httpClient
// create a s3 client
s3cfg := cfg.Copy()
if len(s3Endpoint) != 0 {
s3cfg.EndpointResolver = aws.EndpointResolverFunc(func(service, region string) (aws.Endpoint, error) {
return aws.Endpoint{
URL: s3Endpoint,
PartitionID: "aws",
SigningName: "s3",
SigningRegion: region,
SigningMethod: "s3v4",
}, nil
})
}
// build s3 client from config
s3client = s3.NewFromConfig(s3cfg)
// create a s3-control client
s3ControlCfg := cfg.Copy()
if len(s3ControlEndpoint) != 0 {
s3ControlCfg.EndpointResolver = aws.EndpointResolverFunc(func(service, region string) (aws.Endpoint, error) {
return aws.Endpoint{
URL: s3ControlEndpoint,
PartitionID: "aws",
SigningName: "s3-control",
SigningRegion: region,
}, nil
})
}
// build s3-control client from config
s3ControlClient = s3control.NewFromConfig(s3ControlCfg)
// build sts client from config
stsClient = sts.NewFromConfig(cfg)
// context
ctx := context.Background()
setupMetadata.AccountID, err = getAccountID(ctx)
if err != nil {
fmt.Fprintf(os.Stderr, "failed to get integration aws account id: %v\n", err)
result = 1
return
}
bucketCleanup, err := setupBuckets(ctx)
defer bucketCleanup()
if err != nil {
fmt.Fprintf(os.Stderr, "failed to setup integration test buckets: %v\n", err)
result = 1
return
}
accessPointsCleanup, err := setupAccessPoints(ctx)
defer accessPointsCleanup()
if err != nil {
fmt.Fprintf(os.Stderr, "failed to setup integration test access points: %v\n", err)
result = 1
return
}
result = m.Run()
}
// getAccountID retrieves account id
func getAccountID(ctx context.Context) (string, error) {
if len(setupMetadata.AccountID) != 0 {
return setupMetadata.AccountID, nil
}
identity, err := stsClient.GetCallerIdentity(ctx, nil)
if err != nil {
return "", fmt.Errorf("error fetching caller identity, %w", err)
}
return *identity.Account, nil
}
func setupBuckets(ctx context.Context) (func(), error) {
var cleanups []func()
cleanup := func() {
for i := range cleanups {
cleanups[i]()
}
}
bucketCreates := []struct {
name *string
arn *string
}{
{name: &setupMetadata.Buckets.Source.Name, arn: &setupMetadata.Buckets.Source.ARN},
{name: &setupMetadata.Buckets.Target.Name, arn: &setupMetadata.Buckets.Target.ARN},
}
for _, bucket := range bucketCreates {
*bucket.name = s3shared.GenerateBucketName()
if err := s3shared.SetupBucket(ctx, s3client, *bucket.name); err != nil {
return cleanup, err
}
// Compute ARN
bARN := arn.ARN{
Partition: "aws",
Service: "s3",
Region: region,
AccountID: setupMetadata.AccountID,
Resource: fmt.Sprintf("bucket_name:%s", *bucket.name),
}.String()
*bucket.arn = bARN
bucketName := *bucket.name
cleanups = append(cleanups, func() {
if err := s3shared.CleanupBucket(ctx, s3client, bucketName); err != nil {
fmt.Fprintln(os.Stderr, err)
}
})
}
return cleanup, nil
}
func setupAccessPoints(ctx context.Context) (func(), error) {
var cleanups []func()
cleanup := func() {
for i := range cleanups {
cleanups[i]()
}
}
creates := []struct {
bucket string
name *string
arn *string
}{
{bucket: setupMetadata.Buckets.Source.Name, name: &setupMetadata.AccessPoints.Source.Name, arn: &setupMetadata.AccessPoints.Source.ARN},
{bucket: setupMetadata.Buckets.Target.Name, name: &setupMetadata.AccessPoints.Target.Name, arn: &setupMetadata.AccessPoints.Target.ARN},
}
for _, ap := range creates {
*ap.name = integrationtest.UniqueID()
err := s3shared.SetupAccessPoint(ctx, s3ControlClient, setupMetadata.AccountID, ap.bucket, *ap.name)
if err != nil {
return cleanup, err
}
// Compute ARN
apARN := arn.ARN{
Partition: "aws",
Service: "s3",
Region: region,
AccountID: setupMetadata.AccountID,
Resource: fmt.Sprintf("accesspoint/%s", *ap.name),
}.String()
*ap.arn = apARN
apName := *ap.name
cleanups = append(cleanups, func() {
err := s3shared.CleanupAccessPoint(ctx, s3ControlClient, setupMetadata.AccountID, apName)
if err != nil {
fmt.Fprintln(os.Stderr, err)
}
})
}
return cleanup, nil
}
func putTestContent(t *testing.T, reader io.ReadSeeker, key string, opts func(options *s3.Options)) {
t.Logf("uploading test file %s/%s", setupMetadata.Buckets.Source.Name, key)
_, err := s3client.PutObject(context.Background(),
&s3.PutObjectInput{
Bucket: &setupMetadata.Buckets.Source.Name,
Key: aws.String(key),
Body: reader,
}, opts)
if err != nil {
t.Errorf("expect no error, got %v", err)
}
}
type writeToObjectTestData struct {
Body io.Reader
ExpectBody []byte
ExpectError string
}
func testWriteToObject(t *testing.T, bucket string, testData writeToObjectTestData, opts ...func(options *s3.Options)) {
key := integrationtest.UniqueID()
// put object
_, err := s3client.PutObject(context.Background(),
&s3.PutObjectInput{
Bucket: &bucket,
Key: &key,
Body: testData.Body,
}, opts...)
if err != nil {
if len(testData.ExpectError) == 0 {
t.Fatalf("expect no error, got %v", err)
}
if e, a := testData.ExpectError, err.Error(); !strings.Contains(a, e) {
t.Fatalf("expect error to contain %v, got %v", e, a)
}
} else {
if len(testData.ExpectError) != 0 {
t.Fatalf("expected error: %v, got none", err)
}
}
// stop if expected error writing object
if len(testData.ExpectError) != 0 {
return
}
// get object
resp, err := s3client.GetObject(context.Background(),
&s3.GetObjectInput{
Bucket: &bucket,
Key: &key,
}, opts...)
if err != nil {
t.Fatalf("expect no error, got %v", err)
}
b, _ := ioutil.ReadAll(resp.Body)
if e, a := testData.ExpectBody, b; !bytes.EqualFold(e, a) {
t.Errorf("expect %s, got %s", e, a)
}
}
func testCopyObject(t *testing.T, sourceBucket, targetBucket string, opts func(options *s3.Options)) {
key := integrationtest.UniqueID()
if opts == nil {
opts = func(options *s3.Options) {
}
}
// put object
_, err := s3client.PutObject(context.Background(),
&s3.PutObjectInput{
Bucket: &sourceBucket,
Key: &key,
Body: bytes.NewReader([]byte(`hello world`)),
}, opts)
if err != nil {
t.Fatalf("expect no error, got %v", err)
}
// copy object
_, err = s3client.CopyObject(context.Background(),
&s3.CopyObjectInput{
Bucket: &targetBucket,
Key: &key,
CopySource: aws.String("/" + sourceBucket + "/" + key),
}, opts)
if err != nil {
t.Fatalf("expect no error, got %v", err)
}
// get object
resp, err := s3client.GetObject(context.Background(),
&s3.GetObjectInput{
Bucket: &targetBucket,
Key: &key,
}, opts)
if err != nil {
t.Fatalf("expect no error, got %v", err)
}
b, _ := ioutil.ReadAll(resp.Body)
if e, a := []byte("hello world"), b; !bytes.EqualFold(e, a) {
t.Errorf("expect %s, got %s", e, a)
}
}
| 403 |
aws-sdk-go-v2 | aws | Go | //go:build integration
// +build integration
package s3
import (
"context"
"testing"
"time"
"github.com/aws/aws-sdk-go-v2/service/internal/integrationtest"
"github.com/aws/aws-sdk-go-v2/service/s3"
)
func TestInteg_00_ListBuckets(t *testing.T) {
ctx, cancelFn := context.WithTimeout(context.Background(), 5*time.Second)
defer cancelFn()
cfg, err := integrationtest.LoadConfigWithDefaultRegion("us-west-2")
if err != nil {
t.Fatalf("failed to load config, %v", err)
}
client := s3.NewFromConfig(cfg)
params := &s3.ListBucketsInput{}
_, err = client.ListBuckets(ctx, params)
if err != nil {
t.Errorf("expect no error, got %v", err)
}
}
| 31 |
aws-sdk-go-v2 | aws | Go | //go:build integration
// +build integration
package s3control
import (
"context"
"errors"
"testing"
"github.com/aws/aws-sdk-go-v2/aws"
"github.com/aws/aws-sdk-go-v2/service/s3control"
"github.com/aws/aws-sdk-go-v2/service/s3control/types"
)
func TestInteg_PublicAccessBlock(t *testing.T) {
ctx := context.Background()
_, err := svc.GetPublicAccessBlock(ctx, &s3control.GetPublicAccessBlockInput{
AccountId: aws.String(accountID),
})
if err != nil {
// Ignore NoSuchPublicAccessBlockConfiguration, but fail on any other error.
var e *types.NoSuchPublicAccessBlockConfiguration
if !errors.As(err, &e) {
t.Fatalf("expect no error for GetPublicAccessBlock, got %v", err)
}
}
}
| 29 |
aws-sdk-go-v2 | aws | Go | //go:build integration
// +build integration
package s3control
import (
"context"
"crypto/tls"
"flag"
"fmt"
"net/http"
"os"
"testing"
"github.com/aws/aws-sdk-go-v2/aws"
"github.com/aws/aws-sdk-go-v2/service/internal/integrationtest"
"github.com/aws/aws-sdk-go-v2/service/s3control"
"github.com/aws/aws-sdk-go-v2/service/sts"
)
var (
svc *s3control.Client
s3ControlEndpoint, stsEndpoint string
accountID string
insecureTLS, useDualstack bool
)
var region = "us-west-2"
func TestMain(m *testing.M) {
flag.Parse()
flag.CommandLine.Visit(func(f *flag.Flag) {
if !(f.Name == "run" || f.Name == "test.run") {
return
}
value := f.Value.String()
if value == `NONE` {
os.Exit(0)
}
})
var result int
defer func() {
if r := recover(); r != nil {
fmt.Fprintln(os.Stderr, "S3 integration tests panic,", r)
result = 1
}
os.Exit(result)
}()
flag.StringVar(&stsEndpoint, "sts-endpoint", "",
"The optional `URL` endpoint for the STS service.",
)
flag.StringVar(&s3ControlEndpoint, "s3-control-endpoint", "",
"The optional `URL` endpoint for the S3 Control service.",
)
flag.BoolVar(&insecureTLS, "insecure-tls", false,
"Disables TLS validation on request endpoints.",
)
flag.BoolVar(&useDualstack, "dualstack", false,
"Enables usage of dualstack endpoints.",
)
flag.StringVar(&accountID, "account", "",
"The AWS account `ID`.",
)
// parse flag
flag.Parse()
tlsCfg := &tls.Config{}
if insecureTLS {
tlsCfg.InsecureSkipVerify = true
}
httpClient := &http.Client{
Transport: &http.Transport{
TLSClientConfig: tlsCfg,
},
}
cfg, err := integrationtest.LoadConfigWithDefaultRegion(region)
if err != nil {
fmt.Fprintf(os.Stderr, "Error occurred while loading config with region %v, %v", region, err)
result = 1
return
}
cfg.HTTPClient = httpClient
// initialize context
ctx := context.Background()
if len(accountID) == 0 {
var opts = func(options *sts.Options) {}
if len(stsEndpoint) != 0 {
opts = func(options *sts.Options) {
options.EndpointResolver = sts.EndpointResolverFunc(func(region string, options sts.EndpointResolverOptions) (aws.Endpoint, error) {
return aws.Endpoint{
URL: stsEndpoint,
PartitionID: "aws",
SigningName: "sts",
SigningRegion: region,
}, nil
})
}
}
// initialize a sts client
stsClient := sts.NewFromConfig(cfg, opts)
identity, err := stsClient.GetCallerIdentity(ctx, nil)
if err != nil {
panic(fmt.Sprintf("failed to get accountID, %v", err))
}
accountID = *(identity.Account)
}
var s3controlOpts = func(options *s3control.Options) {}
if len(s3ControlEndpoint) != 0 {
s3controlOpts = func(options *s3control.Options) {
options.EndpointResolver = s3control.EndpointResolverFunc(func(region string, options s3control.EndpointResolverOptions) (aws.Endpoint, error) {
return aws.Endpoint{
URL: s3ControlEndpoint,
PartitionID: "aws",
SigningName: "s3-control",
SigningRegion: region,
}, nil
})
}
}
// construct a s3-control client
svc = s3control.NewFromConfig(cfg, s3controlOpts)
result = m.Run()
}
| 134 |
aws-sdk-go-v2 | aws | Go | //go:build integration
// +build integration
package s3shared
import (
"context"
"fmt"
"github.com/aws/aws-sdk-go-v2/service/internal/integrationtest"
"github.com/aws/aws-sdk-go-v2/service/s3"
"github.com/aws/aws-sdk-go-v2/service/s3/types"
"github.com/aws/aws-sdk-go-v2/service/s3control"
)
// BucketPrefix is the root prefix of integration test buckets.
const BucketPrefix = "aws-sdk-go-v2-integration"
// GenerateBucketName returns a unique bucket name.
func GenerateBucketName() string {
return fmt.Sprintf("%s-%s",
BucketPrefix, integrationtest.UniqueID())
}
// SetupBucket returns a test bucket created for the integration tests.
func SetupBucket(ctx context.Context, svc *s3.Client, bucketName string) (err error) {
fmt.Println("Setup: Creating test bucket,", bucketName)
_, err = svc.CreateBucket(ctx, &s3.CreateBucketInput{
Bucket: &bucketName,
CreateBucketConfiguration: &types.CreateBucketConfiguration{
LocationConstraint: "us-west-2",
},
})
if err != nil {
return fmt.Errorf("failed to create bucket %s, %v", bucketName, err)
}
// TODO: change this to use waiter to wait until BucketExists instead of loop
// svc.WaitUntilBucketExists(HeadBucketInput)
// HeadBucket to determine if bucket exists
var attempt = 0
params := &s3.HeadBucketInput{
Bucket: &bucketName,
}
pt:
_, err = svc.HeadBucket(ctx, params)
// increment an attempt
attempt++
// retry till 10 attempt
if err != nil {
if attempt < 10 {
goto pt
}
// fail if not succeed after 10 attempts
return fmt.Errorf("failed to determine if a bucket %s exists and you have permission to access it", bucketName)
}
return nil
}
// CleanupBucket deletes the contents of a S3 bucket, before deleting the bucket
// it self.
// TODO: list and delete methods should use paginators
func CleanupBucket(ctx context.Context, svc *s3.Client, bucketName string) (err error) {
var errs = make([]error, 0)
fmt.Println("TearDown: Deleting objects from test bucket,", bucketName)
listObjectsResp, err := svc.ListObjects(ctx, &s3.ListObjectsInput{
Bucket: &bucketName,
})
if err != nil {
return fmt.Errorf("failed to list objects, %w", err)
}
for _, o := range listObjectsResp.Contents {
_, err := svc.DeleteObject(ctx, &s3.DeleteObjectInput{
Bucket: &bucketName,
Key: o.Key,
})
if err != nil {
errs = append(errs, err)
}
}
if len(errs) != 0 {
return fmt.Errorf("failed to delete objects, %s", errs)
}
fmt.Println("TearDown: Deleting partial uploads from test bucket,", bucketName)
multipartUploadResp, err := svc.ListMultipartUploads(ctx, &s3.ListMultipartUploadsInput{
Bucket: &bucketName,
})
if err != nil {
return fmt.Errorf("failed to list multipart objects, %w", err)
}
for _, u := range multipartUploadResp.Uploads {
_, err = svc.AbortMultipartUpload(ctx, &s3.AbortMultipartUploadInput{
Bucket: &bucketName,
Key: u.Key,
UploadId: u.UploadId,
})
if err != nil {
errs = append(errs, err)
}
}
if len(errs) != 0 {
return fmt.Errorf("failed to delete multipart upload objects, %s", errs)
}
fmt.Println("TearDown: Deleting test bucket,", bucketName)
_, err = svc.DeleteBucket(ctx, &s3.DeleteBucketInput{
Bucket: &bucketName,
})
if err != nil {
return fmt.Errorf("failed to delete bucket, %s", bucketName)
}
return nil
}
// SetupAccessPoint returns an access point for the given bucket for testing
func SetupAccessPoint(ctx context.Context, svc *s3control.Client, accountID, bucketName, accessPoint string) error {
fmt.Printf("Setup: creating access point %q for bucket %q\n", accessPoint, bucketName)
_, err := svc.CreateAccessPoint(ctx, &s3control.CreateAccessPointInput{
AccountId: &accountID,
Bucket: &bucketName,
Name: &accessPoint,
})
if err != nil {
return fmt.Errorf("failed to create access point : %w", err)
}
return nil
}
// CleanupAccessPoint deletes the given access point
func CleanupAccessPoint(ctx context.Context, svc *s3control.Client, accountID, accessPoint string) error {
fmt.Printf("TearDown: Deleting access point %q\n", accessPoint)
_, err := svc.DeleteAccessPoint(ctx, &s3control.DeleteAccessPointInput{
AccountId: &accountID,
Name: &accessPoint,
})
if err != nil {
return fmt.Errorf("failed to delete access point: %w", err)
}
return nil
}
| 149 |
aws-sdk-go-v2 | aws | Go | //go:build integration
// +build integration
package secretsmanager
import (
"context"
"errors"
"testing"
"time"
"github.com/aws/aws-sdk-go-v2/aws"
"github.com/aws/aws-sdk-go-v2/service/internal/integrationtest"
"github.com/aws/aws-sdk-go-v2/service/secretsmanager"
"github.com/aws/smithy-go"
)
func TestInteg_00_ListSecrets(t *testing.T) {
ctx, cancelFn := context.WithTimeout(context.Background(), 5*time.Second)
defer cancelFn()
cfg, err := integrationtest.LoadConfigWithDefaultRegion("us-west-2")
if err != nil {
t.Fatalf("failed to load config, %v", err)
}
client := secretsmanager.NewFromConfig(cfg)
params := &secretsmanager.ListSecretsInput{}
_, err = client.ListSecrets(ctx, params)
if err != nil {
t.Errorf("expect no error, got %v", err)
}
}
func TestInteg_01_DescribeSecret(t *testing.T) {
ctx, cancelFn := context.WithTimeout(context.Background(), 5*time.Second)
defer cancelFn()
cfg, err := integrationtest.LoadConfigWithDefaultRegion("us-west-2")
if err != nil {
t.Fatalf("failed to load config, %v", err)
}
client := secretsmanager.NewFromConfig(cfg)
params := &secretsmanager.DescribeSecretInput{
SecretId: aws.String("fake-secret-id"),
}
_, err = client.DescribeSecret(ctx, params)
if err == nil {
t.Fatalf("expect request to fail")
}
var apiErr smithy.APIError
if !errors.As(err, &apiErr) {
t.Fatalf("expect error to be API error, was not, %v", err)
}
if len(apiErr.ErrorCode()) == 0 {
t.Errorf("expect non-empty error code")
}
if len(apiErr.ErrorMessage()) == 0 {
t.Errorf("expect non-empty error message")
}
}
| 64 |
aws-sdk-go-v2 | aws | Go | //go:build integration
// +build integration
package servicecatalog
import (
"context"
"testing"
"time"
"github.com/aws/aws-sdk-go-v2/service/internal/integrationtest"
"github.com/aws/aws-sdk-go-v2/service/servicecatalog"
)
func TestInteg_00_ListAcceptedPortfolioShares(t *testing.T) {
ctx, cancelFn := context.WithTimeout(context.Background(), 5*time.Second)
defer cancelFn()
cfg, err := integrationtest.LoadConfigWithDefaultRegion("us-west-2")
if err != nil {
t.Fatalf("failed to load config, %v", err)
}
client := servicecatalog.NewFromConfig(cfg)
params := &servicecatalog.ListAcceptedPortfolioSharesInput{}
_, err = client.ListAcceptedPortfolioShares(ctx, params)
if err != nil {
t.Errorf("expect no error, got %v", err)
}
}
| 31 |
aws-sdk-go-v2 | aws | Go | //go:build integration
// +build integration
package ses
import (
"context"
"errors"
"testing"
"time"
"github.com/aws/aws-sdk-go-v2/aws"
"github.com/aws/aws-sdk-go-v2/service/internal/integrationtest"
"github.com/aws/aws-sdk-go-v2/service/ses"
"github.com/aws/smithy-go"
)
func TestInteg_00_ListIdentities(t *testing.T) {
ctx, cancelFn := context.WithTimeout(context.Background(), 5*time.Second)
defer cancelFn()
cfg, err := integrationtest.LoadConfigWithDefaultRegion("us-west-2")
if err != nil {
t.Fatalf("failed to load config, %v", err)
}
client := ses.NewFromConfig(cfg)
params := &ses.ListIdentitiesInput{}
_, err = client.ListIdentities(ctx, params)
if err != nil {
t.Errorf("expect no error, got %v", err)
}
}
func TestInteg_01_VerifyEmailIdentity(t *testing.T) {
ctx, cancelFn := context.WithTimeout(context.Background(), 5*time.Second)
defer cancelFn()
cfg, err := integrationtest.LoadConfigWithDefaultRegion("us-west-2")
if err != nil {
t.Fatalf("failed to load config, %v", err)
}
client := ses.NewFromConfig(cfg)
params := &ses.VerifyEmailIdentityInput{
EmailAddress: aws.String("fake_email"),
}
_, err = client.VerifyEmailIdentity(ctx, params)
if err == nil {
t.Fatalf("expect request to fail")
}
var apiErr smithy.APIError
if !errors.As(err, &apiErr) {
t.Fatalf("expect error to be API error, was not, %v", err)
}
if len(apiErr.ErrorCode()) == 0 {
t.Errorf("expect non-empty error code")
}
if len(apiErr.ErrorMessage()) == 0 {
t.Errorf("expect non-empty error message")
}
}
| 64 |
aws-sdk-go-v2 | aws | Go | //go:build integration
// +build integration
package sfn
import (
"context"
"testing"
"time"
"github.com/aws/aws-sdk-go-v2/service/internal/integrationtest"
"github.com/aws/aws-sdk-go-v2/service/sfn"
)
func TestInteg_00_ListActivities(t *testing.T) {
ctx, cancelFn := context.WithTimeout(context.Background(), 5*time.Second)
defer cancelFn()
cfg, err := integrationtest.LoadConfigWithDefaultRegion("us-west-2")
if err != nil {
t.Fatalf("failed to load config, %v", err)
}
client := sfn.NewFromConfig(cfg)
params := &sfn.ListActivitiesInput{}
_, err = client.ListActivities(ctx, params)
if err != nil {
t.Errorf("expect no error, got %v", err)
}
}
| 31 |
aws-sdk-go-v2 | aws | Go | //go:build integration
// +build integration
package shield
import (
"context"
"testing"
"time"
"github.com/aws/aws-sdk-go-v2/service/internal/integrationtest"
"github.com/aws/aws-sdk-go-v2/service/shield"
)
func TestInteg_00_ListAttacks(t *testing.T) {
ctx, cancelFn := context.WithTimeout(context.Background(), 5*time.Second)
defer cancelFn()
cfg, err := integrationtest.LoadConfigWithDefaultRegion("us-east-1")
if err != nil {
t.Fatalf("failed to load config, %v", err)
}
client := shield.NewFromConfig(cfg)
params := &shield.ListAttacksInput{}
_, err = client.ListAttacks(ctx, params)
if err != nil {
t.Errorf("expect no error, got %v", err)
}
}
| 31 |
aws-sdk-go-v2 | aws | Go | //go:build integration
// +build integration
package snowball
import (
"context"
"testing"
"time"
"github.com/aws/aws-sdk-go-v2/service/internal/integrationtest"
"github.com/aws/aws-sdk-go-v2/service/snowball"
)
func TestInteg_00_DescribeAddresses(t *testing.T) {
ctx, cancelFn := context.WithTimeout(context.Background(), 5*time.Second)
defer cancelFn()
cfg, err := integrationtest.LoadConfigWithDefaultRegion("us-west-2")
if err != nil {
t.Fatalf("failed to load config, %v", err)
}
client := snowball.NewFromConfig(cfg)
params := &snowball.DescribeAddressesInput{}
_, err = client.DescribeAddresses(ctx, params)
if err != nil {
t.Errorf("expect no error, got %v", err)
}
}
| 31 |
aws-sdk-go-v2 | aws | Go | //go:build integration
// +build integration
package sns
import (
"context"
"errors"
"testing"
"time"
"github.com/aws/aws-sdk-go-v2/aws"
"github.com/aws/aws-sdk-go-v2/service/sns"
"github.com/aws/smithy-go"
"github.com/aws/aws-sdk-go-v2/service/internal/integrationtest"
)
func TestInteg_00_ListTopics(t *testing.T) {
ctx, cancelFn := context.WithTimeout(context.Background(), 5*time.Second)
defer cancelFn()
cfg, err := integrationtest.LoadConfigWithDefaultRegion("us-west-2")
if err != nil {
t.Fatalf("failed to load config, %v", err)
}
client := sns.NewFromConfig(cfg)
params := &sns.ListTopicsInput{}
_, err = client.ListTopics(ctx, params)
if err != nil {
t.Errorf("expect no error, got %v", err)
}
}
func TestInteg_01_Publish(t *testing.T) {
ctx, cancelFn := context.WithTimeout(context.Background(), 5*time.Second)
defer cancelFn()
cfg, err := integrationtest.LoadConfigWithDefaultRegion("us-west-2")
if err != nil {
t.Fatalf("failed to load config, %v", err)
}
client := sns.NewFromConfig(cfg)
params := &sns.PublishInput{
Message: aws.String("hello"),
TopicArn: aws.String("fake_topic"),
}
_, err = client.Publish(ctx, params)
if err == nil {
t.Fatalf("expect request to fail")
}
var apiErr smithy.APIError
if !errors.As(err, &apiErr) {
t.Fatalf("expect error to be API error, was not, %v", err)
}
if len(apiErr.ErrorCode()) == 0 {
t.Errorf("expect non-empty error code")
}
if len(apiErr.ErrorMessage()) == 0 {
t.Errorf("expect non-empty error message")
}
}
| 66 |
aws-sdk-go-v2 | aws | Go | //go:build integration
// +build integration
package sqs
import (
"context"
"errors"
"testing"
"time"
"github.com/aws/aws-sdk-go-v2/aws"
"github.com/aws/aws-sdk-go-v2/service/internal/integrationtest"
"github.com/aws/aws-sdk-go-v2/service/sqs"
"github.com/aws/smithy-go"
)
func TestInteg_00_ListQueues(t *testing.T) {
ctx, cancelFn := context.WithTimeout(context.Background(), 5*time.Second)
defer cancelFn()
cfg, err := integrationtest.LoadConfigWithDefaultRegion("us-west-2")
if err != nil {
t.Fatalf("failed to load config, %v", err)
}
client := sqs.NewFromConfig(cfg)
params := &sqs.ListQueuesInput{}
_, err = client.ListQueues(ctx, params)
if err != nil {
t.Errorf("expect no error, got %v", err)
}
}
func TestInteg_01_GetQueueUrl(t *testing.T) {
ctx, cancelFn := context.WithTimeout(context.Background(), 5*time.Second)
defer cancelFn()
cfg, err := integrationtest.LoadConfigWithDefaultRegion("us-west-2")
if err != nil {
t.Fatalf("failed to load config, %v", err)
}
client := sqs.NewFromConfig(cfg)
params := &sqs.GetQueueUrlInput{
QueueName: aws.String("fake_queue"),
}
_, err = client.GetQueueUrl(ctx, params)
if err == nil {
t.Fatalf("expect request to fail")
}
var apiErr smithy.APIError
if !errors.As(err, &apiErr) {
t.Fatalf("expect error to be API error, was not, %v", err)
}
if len(apiErr.ErrorCode()) == 0 {
t.Errorf("expect non-empty error code")
}
if len(apiErr.ErrorMessage()) == 0 {
// TODO: GitHub-1369 SQS Modelling Issue
t.Log("expect non-empty error message")
}
}
| 65 |
aws-sdk-go-v2 | aws | Go | //go:build integration
// +build integration
package ssm
import (
"context"
"errors"
"testing"
"time"
"github.com/aws/aws-sdk-go-v2/aws"
"github.com/aws/aws-sdk-go-v2/service/ssm"
"github.com/aws/smithy-go"
"github.com/aws/aws-sdk-go-v2/service/internal/integrationtest"
)
func TestInteg_00_ListDocuments(t *testing.T) {
ctx, cancelFn := context.WithTimeout(context.Background(), 5*time.Second)
defer cancelFn()
cfg, err := integrationtest.LoadConfigWithDefaultRegion("us-west-2")
if err != nil {
t.Fatalf("failed to load config, %v", err)
}
client := ssm.NewFromConfig(cfg)
params := &ssm.ListDocumentsInput{}
_, err = client.ListDocuments(ctx, params)
if err != nil {
t.Errorf("expect no error, got %v", err)
}
}
func TestInteg_01_GetDocument(t *testing.T) {
ctx, cancelFn := context.WithTimeout(context.Background(), 5*time.Second)
defer cancelFn()
cfg, err := integrationtest.LoadConfigWithDefaultRegion("us-west-2")
if err != nil {
t.Fatalf("failed to load config, %v", err)
}
client := ssm.NewFromConfig(cfg)
params := &ssm.GetDocumentInput{
Name: aws.String("'fake-name'"),
}
_, err = client.GetDocument(ctx, params)
if err == nil {
t.Fatalf("expect request to fail")
}
var apiErr smithy.APIError
if !errors.As(err, &apiErr) {
t.Fatalf("expect error to be API error, was not, %v", err)
}
if len(apiErr.ErrorCode()) == 0 {
t.Errorf("expect non-empty error code")
}
if len(apiErr.ErrorMessage()) == 0 {
t.Errorf("expect non-empty error message")
}
}
| 65 |
aws-sdk-go-v2 | aws | Go | //go:build integration
// +build integration
package sts
import (
"context"
"errors"
"testing"
"time"
"github.com/aws/aws-sdk-go-v2/aws"
"github.com/aws/aws-sdk-go-v2/service/sts"
"github.com/aws/smithy-go"
"github.com/aws/aws-sdk-go-v2/service/internal/integrationtest"
)
func TestInteg_00_GetCallerIdentity(t *testing.T) {
ctx, cancelFn := context.WithTimeout(context.Background(), 5*time.Second)
defer cancelFn()
cfg, err := integrationtest.LoadConfigWithDefaultRegion("us-west-2")
if err != nil {
t.Fatalf("failed to load config, %v", err)
}
client := sts.NewFromConfig(cfg)
params := &sts.GetCallerIdentityInput{}
resp, err := client.GetCallerIdentity(ctx, params)
if err != nil {
t.Errorf("expect no error, got %v", err)
}
if len(aws.ToString(resp.Account)) == 0 {
t.Errorf("expect account to not be empty")
}
}
func TestInteg_01_GetFederationToken(t *testing.T) {
ctx, cancelFn := context.WithTimeout(context.Background(), 5*time.Second)
defer cancelFn()
cfg, err := integrationtest.LoadConfigWithDefaultRegion("us-west-2")
if err != nil {
t.Fatalf("failed to load config, %v", err)
}
client := sts.NewFromConfig(cfg)
params := &sts.GetFederationTokenInput{
Name: aws.String("temp"),
Policy: aws.String("{\\\"temp\\\":true}"),
}
_, err = client.GetFederationToken(ctx, params)
if err == nil {
t.Fatalf("expect request to fail")
}
var apiErr smithy.APIError
if !errors.As(err, &apiErr) {
t.Fatalf("expect error to be API error, was not, %v", err)
}
if len(apiErr.ErrorCode()) == 0 {
t.Errorf("expect non-empty error code")
}
if len(apiErr.ErrorMessage()) == 0 {
t.Errorf("expect non-empty error message")
}
}
| 70 |
aws-sdk-go-v2 | aws | Go | //go:build integration
// +build integration
package support
import (
"context"
"errors"
"testing"
"time"
"github.com/aws/aws-sdk-go-v2/aws"
"github.com/aws/aws-sdk-go-v2/service/support"
"github.com/aws/smithy-go"
"github.com/aws/aws-sdk-go-v2/service/internal/integrationtest"
)
func TestInteg_00_DescribeServices(t *testing.T) {
ctx, cancelFn := context.WithTimeout(context.Background(), 5*time.Second)
defer cancelFn()
cfg, err := integrationtest.LoadConfigWithDefaultRegion("us-east-1")
if err != nil {
t.Fatalf("failed to load config, %v", err)
}
client := support.NewFromConfig(cfg)
params := &support.DescribeServicesInput{}
_, err = client.DescribeServices(ctx, params)
if err != nil {
t.Errorf("expect no error, got %v", err)
}
}
func TestInteg_01_CreateCase(t *testing.T) {
ctx, cancelFn := context.WithTimeout(context.Background(), 5*time.Second)
defer cancelFn()
cfg, err := integrationtest.LoadConfigWithDefaultRegion("us-east-1")
if err != nil {
t.Fatalf("failed to load config, %v", err)
}
client := support.NewFromConfig(cfg)
params := &support.CreateCaseInput{
CategoryCode: aws.String("category"),
CommunicationBody: aws.String("communication"),
ServiceCode: aws.String("amazon-dynamodb"),
SeverityCode: aws.String("low"),
Subject: aws.String("subject"),
}
_, err = client.CreateCase(ctx, params)
if err == nil {
t.Fatalf("expect request to fail")
}
var apiErr smithy.APIError
if !errors.As(err, &apiErr) {
t.Fatalf("expect error to be API error, was not, %v", err)
}
if len(apiErr.ErrorCode()) == 0 {
t.Errorf("expect non-empty error code")
}
if len(apiErr.ErrorMessage()) == 0 {
t.Errorf("expect non-empty error message")
}
}
| 69 |
aws-sdk-go-v2 | aws | Go | //go:build integration
// +build integration
package timestreamwrite
import (
"context"
"github.com/aws/aws-sdk-go-v2/aws"
"github.com/aws/aws-sdk-go-v2/service/internal/integrationtest"
tw "github.com/aws/aws-sdk-go-v2/service/timestreamwrite"
"testing"
"time"
)
func TestInteg_00_ListDatabases(t *testing.T) {
ctx, cancelFn := context.WithTimeout(context.Background(), 10*time.Second)
defer cancelFn()
cfg, err := integrationtest.LoadConfigWithDefaultRegion("us-east-1")
if err != nil {
t.Fatalf("failed to load config, %v", err)
}
// Create an Amazon timestreamwrite service client
client := tw.NewFromConfig(cfg)
// ListDatabases
_, err = client.ListDatabases(ctx, &tw.ListDatabasesInput{
MaxResults: aws.Int32(1),
})
if err != nil {
t.Fatal(err)
}
}
| 35 |
aws-sdk-go-v2 | aws | Go | //go:build integration
// +build integration
package transcribestreaming
import (
"bytes"
"context"
"encoding/base64"
"flag"
"fmt"
"io"
"os"
"strings"
"sync"
"testing"
"time"
"github.com/aws/aws-sdk-go-v2/aws"
"github.com/aws/aws-sdk-go-v2/service/internal/integrationtest"
"github.com/aws/aws-sdk-go-v2/service/transcribestreaming"
"github.com/aws/aws-sdk-go-v2/service/transcribestreaming/types"
)
var (
audioFilename string
audioFormat string
audioLang string
audioSampleRate int
audioFrameSize int
withDebug bool
)
func init() {
flag.BoolVar(&withDebug, "debug", false, "Include debug logging with test.")
flag.StringVar(&audioFilename, "audio-file", "", "Audio file filename to perform test with.")
flag.StringVar(&audioLang, "audio-lang", string(types.LanguageCodeEnUs), "Language of audio speech.")
flag.StringVar(&audioFormat, "audio-format", string(types.MediaEncodingPcm), "Format of audio.")
flag.IntVar(&audioSampleRate, "audio-sample", 16000, "Sample rate of the audio.")
flag.IntVar(&audioFrameSize, "audio-frame", 15*1024, "Size of frames of audio uploaded.")
}
func TestInteg_StartStreamTranscription(t *testing.T) {
var audio io.Reader
if len(audioFilename) != 0 {
audioFile, err := os.Open(audioFilename)
if err != nil {
t.Fatalf("expect to open file, %v", err)
}
defer audioFile.Close()
audio = audioFile
} else {
b, err := base64.StdEncoding.DecodeString(
`UklGRjzxPQBXQVZFZm10IBAAAAABAAEAgD4AAAB9AAACABAAZGF0YVTwPQAAAAAAAAAAAAAAAAD//wIA/f8EAA==`,
)
if err != nil {
t.Fatalf("expect decode audio bytes, %v", err)
}
audio = bytes.NewReader(b)
}
cfg, _ := integrationtest.LoadConfigWithDefaultRegion("us-west-2")
ctx, cancelFn := context.WithTimeout(context.Background(), 10*time.Second)
defer cancelFn()
client := transcribestreaming.NewFromConfig(cfg)
resp, err := client.StartStreamTranscription(ctx, &transcribestreaming.StartStreamTranscriptionInput{
LanguageCode: types.LanguageCode(audioLang),
MediaEncoding: types.MediaEncoding(audioFormat),
MediaSampleRateHertz: aws.Int32(int32(audioSampleRate)),
})
if err != nil {
t.Fatalf("failed to start streaming, %v", err)
}
stream := resp.GetStream()
defer stream.Close()
go streamAudioFromReader(context.Background(), stream.Writer, audioFrameSize, audio)
for event := range stream.Events() {
switch e := event.(type) {
case *types.TranscriptResultStreamMemberTranscriptEvent:
t.Logf("got event, %v results", len(e.Value.Transcript.Results))
for _, res := range e.Value.Transcript.Results {
for _, alt := range res.Alternatives {
t.Logf("* %s", aws.ToString(alt.Transcript))
}
}
default:
t.Fatalf("unexpected event, %T", event)
}
}
if err := stream.Err(); err != nil {
t.Fatalf("expect no error from stream, got %v", err)
}
}
func TestInteg_StartStreamTranscription_contextClose(t *testing.T) {
b, err := base64.StdEncoding.DecodeString(
`UklGRjzxPQBXQVZFZm10IBAAAAABAAEAgD4AAAB9AAACABAAZGF0YVTwPQAAAAAAAAAAAAAAAAD//wIA/f8EAA==`,
)
if err != nil {
t.Fatalf("expect decode audio bytes, %v", err)
}
audio := bytes.NewReader(b)
cfg, _ := integrationtest.LoadConfigWithDefaultRegion("us-west-2")
client := transcribestreaming.NewFromConfig(cfg)
resp, err := client.StartStreamTranscription(context.Background(), &transcribestreaming.StartStreamTranscriptionInput{
LanguageCode: types.LanguageCodeEnUs,
MediaEncoding: types.MediaEncodingPcm,
MediaSampleRateHertz: aws.Int32(16000),
})
if err != nil {
t.Fatalf("failed to start streaming, %v", err)
}
stream := resp.GetStream()
defer stream.Close()
ctx, cancelFn := context.WithCancel(context.Background())
defer cancelFn()
var wg sync.WaitGroup
wg.Add(1)
go func() {
err := streamAudioFromReader(ctx, stream.Writer, audioFrameSize, audio)
if err == nil {
t.Errorf("expect error")
}
if e, a := "context canceled", err.Error(); !strings.Contains(a, e) {
t.Errorf("expect %q error in %q", e, a)
}
wg.Done()
}()
cancelFn()
Loop:
for {
select {
case <-ctx.Done():
break Loop
case event, ok := <-stream.Events():
if !ok {
break Loop
}
switch e := event.(type) {
case *types.TranscriptResultStreamMemberTranscriptEvent:
t.Logf("got event, %v results", len(e.Value.Transcript.Results))
for _, res := range e.Value.Transcript.Results {
for _, alt := range res.Alternatives {
t.Logf("* %s", aws.ToString(alt.Transcript))
}
}
default:
t.Fatalf("unexpected event, %T", event)
}
}
}
wg.Wait()
if err := stream.Err(); err != nil {
t.Fatalf("expect no error from stream, got %v", err)
}
}
func streamAudioFromReader(ctx context.Context, stream transcribestreaming.AudioStreamWriter, frameSize int, input io.Reader) (err error) {
defer func() {
if closeErr := stream.Close(); closeErr != nil && err == nil {
err = fmt.Errorf("failed to close stream, %v", closeErr)
}
}()
frame := make([]byte, frameSize)
for {
var n int
n, err = input.Read(frame)
if n > 0 {
err = stream.Send(ctx, &types.AudioStreamMemberAudioEvent{Value: types.AudioEvent{
AudioChunk: frame[:n],
}})
if err != nil {
return fmt.Errorf("failed to send audio event, %v", err)
}
}
if err == io.EOF {
return nil
}
if err != nil {
return fmt.Errorf("failed to read audio, %v", err)
}
}
}
| 200 |
aws-sdk-go-v2 | aws | Go | //go:build integration
// +build integration
package waf
import (
"context"
"testing"
"time"
"github.com/aws/aws-sdk-go-v2/service/internal/integrationtest"
"github.com/aws/aws-sdk-go-v2/service/waf"
)
func TestInteg_00_ListRules(t *testing.T) {
ctx, cancelFn := context.WithTimeout(context.Background(), 5*time.Second)
defer cancelFn()
cfg, err := integrationtest.LoadConfigWithDefaultRegion("us-west-2")
if err != nil {
t.Fatalf("failed to load config, %v", err)
}
client := waf.NewFromConfig(cfg)
params := &waf.ListRulesInput{
Limit: 20,
}
_, err = client.ListRules(ctx, params)
if err != nil {
t.Errorf("expect no error, got %v", err)
}
}
| 33 |
aws-sdk-go-v2 | aws | Go | //go:build integration
// +build integration
package wafregional
import (
"context"
"errors"
"testing"
"time"
"github.com/aws/aws-sdk-go-v2/aws"
"github.com/aws/aws-sdk-go-v2/service/internal/integrationtest"
"github.com/aws/aws-sdk-go-v2/service/wafregional"
"github.com/aws/smithy-go"
)
func TestInteg_00_ListRules(t *testing.T) {
ctx, cancelFn := context.WithTimeout(context.Background(), 5*time.Second)
defer cancelFn()
cfg, err := integrationtest.LoadConfigWithDefaultRegion("us-west-2")
if err != nil {
t.Fatalf("failed to load config, %v", err)
}
client := wafregional.NewFromConfig(cfg)
params := &wafregional.ListRulesInput{
Limit: 20,
}
_, err = client.ListRules(ctx, params)
if err != nil {
t.Errorf("expect no error, got %v", err)
}
}
func TestInteg_01_CreateSqlInjectionMatchSet(t *testing.T) {
t.Skip("disable waf CreateSqlInjectionMatchSet")
ctx, cancelFn := context.WithTimeout(context.Background(), 5*time.Second)
defer cancelFn()
cfg, err := integrationtest.LoadConfigWithDefaultRegion("us-west-2")
if err != nil {
t.Fatalf("failed to load config, %v", err)
}
client := wafregional.NewFromConfig(cfg)
params := &wafregional.CreateSqlInjectionMatchSetInput{
ChangeToken: aws.String("fake_token"),
Name: aws.String("fake_name"),
}
_, err = client.CreateSqlInjectionMatchSet(ctx, params)
if err == nil {
t.Fatalf("expect request to fail")
}
var apiErr smithy.APIError
if !errors.As(err, &apiErr) {
t.Fatalf("expect error to be API error, was not, %v", err)
}
if len(apiErr.ErrorCode()) == 0 {
t.Errorf("expect non-empty error code")
}
if len(apiErr.ErrorMessage()) == 0 {
t.Errorf("expect non-empty error message")
}
}
| 69 |
aws-sdk-go-v2 | aws | Go | //go:build integration
// +build integration
package wafv2
import (
"context"
"errors"
"testing"
"time"
"github.com/aws/aws-sdk-go-v2/aws"
"github.com/aws/aws-sdk-go-v2/service/wafv2"
"github.com/aws/aws-sdk-go-v2/service/wafv2/types"
"github.com/aws/smithy-go"
"github.com/aws/aws-sdk-go-v2/service/internal/integrationtest"
)
func TestInteg_00_ListWebACLs(t *testing.T) {
ctx, cancelFn := context.WithTimeout(context.Background(), 5*time.Second)
defer cancelFn()
cfg, _ := integrationtest.LoadConfigWithDefaultRegion("us-east-1")
svc := wafv2.NewFromConfig(cfg)
input := &wafv2.ListWebACLsInput{
Limit: aws.Int32(20),
Scope: types.ScopeRegional,
}
_, err := svc.ListWebACLs(ctx, input)
if err != nil {
t.Errorf("expect no error, got %v", err)
}
}
func TestInteg_01_CreateRegexPatternSet(t *testing.T) {
ctx, cancelFn := context.WithTimeout(context.Background(), 5*time.Second)
defer cancelFn()
cfg, _ := integrationtest.LoadConfigWithDefaultRegion("us-east-1")
svc := wafv2.NewFromConfig(cfg)
input := &wafv2.CreateRegexPatternSetInput{
Name: aws.String("fake_name"),
Scope: types.ScopeRegional,
}
_, err := svc.CreateRegexPatternSet(ctx, input)
if err == nil {
t.Fatalf("expect request to fail")
}
var apiErr smithy.APIError
if !errors.As(err, &apiErr) {
t.Fatalf("expect error to be API error, was not, %v", err)
}
if len(apiErr.ErrorCode()) == 0 {
t.Errorf("expect non-empty error code")
}
if len(apiErr.ErrorMessage()) == 0 {
t.Errorf("expect non-empty error message")
}
}
| 66 |
aws-sdk-go-v2 | aws | Go | //go:build integration
// +build integration
package workspaces
import (
"context"
"errors"
"testing"
"time"
"github.com/aws/aws-sdk-go-v2/aws"
"github.com/aws/aws-sdk-go-v2/service/internal/integrationtest"
"github.com/aws/aws-sdk-go-v2/service/workspaces"
"github.com/aws/smithy-go"
)
func TestInteg_00_DescribeWorkspaces(t *testing.T) {
ctx, cancelFn := context.WithTimeout(context.Background(), 5*time.Second)
defer cancelFn()
cfg, _ := integrationtest.LoadConfigWithDefaultRegion("us-west-2")
svc := workspaces.NewFromConfig(cfg)
input := &workspaces.DescribeWorkspacesInput{}
_, err := svc.DescribeWorkspaces(ctx, input)
if err != nil {
t.Errorf("expect no error, got %v", err)
}
}
func TestInteg_01_DescribeWorkspaces(t *testing.T) {
ctx, cancelFn := context.WithTimeout(context.Background(), 5*time.Second)
defer cancelFn()
cfg, _ := integrationtest.LoadConfigWithDefaultRegion("us-west-2")
svc := workspaces.NewFromConfig(cfg)
input := &workspaces.DescribeWorkspacesInput{
DirectoryId: aws.String("fake-id"),
}
_, err := svc.DescribeWorkspaces(ctx, input)
if err == nil {
t.Errorf("expect request to fail")
}
var apiErr smithy.APIError
if !errors.As(err, &apiErr) {
t.Fatalf("expect error to be API error, was not, %v", err)
}
if len(apiErr.ErrorCode()) == 0 {
t.Errorf("expect non-empty error code")
}
if len(apiErr.ErrorMessage()) == 0 {
t.Errorf("expect non-empty error message")
}
}
| 60 |
aws-sdk-go-v2 | aws | Go | package presignedurl
import (
"context"
"github.com/aws/smithy-go/middleware"
)
// WithIsPresigning adds the isPresigning sentinel value to a context to signal
// that the middleware stack is using the presign flow.
//
// Scoped to stack values. Use github.com/aws/smithy-go/middleware#ClearStackValues
// to clear all stack values.
func WithIsPresigning(ctx context.Context) context.Context {
return middleware.WithStackValue(ctx, isPresigningKey{}, true)
}
// GetIsPresigning returns if the context contains the isPresigning sentinel
// value for presigning flows.
//
// Scoped to stack values. Use github.com/aws/smithy-go/middleware#ClearStackValues
// to clear all stack values.
func GetIsPresigning(ctx context.Context) bool {
v, _ := middleware.GetStackValue(ctx, isPresigningKey{}).(bool)
return v
}
type isPresigningKey struct{}
// AddAsIsPresigingMiddleware adds a middleware to the head of the stack that
// will update the stack's context to be flagged as being invoked for the
// purpose of presigning.
func AddAsIsPresigingMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(asIsPresigningMiddleware{}, middleware.Before)
}
type asIsPresigningMiddleware struct{}
func (asIsPresigningMiddleware) ID() string { return "AsIsPresigningMiddleware" }
func (asIsPresigningMiddleware) HandleInitialize(
ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler,
) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
ctx = WithIsPresigning(ctx)
return next.HandleInitialize(ctx, in)
}
| 49 |
aws-sdk-go-v2 | aws | Go | // Package presignedurl provides the customizations for API clients to fill in
// presigned URLs into input parameters.
package presignedurl
| 4 |
aws-sdk-go-v2 | aws | Go | // Code generated by internal/repotools/cmd/updatemodulemeta DO NOT EDIT.
package presignedurl
// goModuleVersion is the tagged release for this module
const goModuleVersion = "1.9.28"
| 7 |
aws-sdk-go-v2 | aws | Go | package presignedurl
import (
"context"
"fmt"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
v4 "github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/smithy-go/middleware"
)
// URLPresigner provides the interface to presign the input parameters in to a
// presigned URL.
type URLPresigner interface {
// PresignURL presigns a URL.
PresignURL(ctx context.Context, srcRegion string, params interface{}) (*v4.PresignedHTTPRequest, error)
}
// ParameterAccessor provides an collection of accessor to for retrieving and
// setting the values needed to PresignedURL generation
type ParameterAccessor struct {
// GetPresignedURL accessor points to a function that retrieves a presigned url if present
GetPresignedURL func(interface{}) (string, bool, error)
// GetSourceRegion accessor points to a function that retrieves source region for presigned url
GetSourceRegion func(interface{}) (string, bool, error)
// CopyInput accessor points to a function that takes in an input, and returns a copy.
CopyInput func(interface{}) (interface{}, error)
// SetDestinationRegion accessor points to a function that sets destination region on api input struct
SetDestinationRegion func(interface{}, string) error
// SetPresignedURL accessor points to a function that sets presigned url on api input struct
SetPresignedURL func(interface{}, string) error
}
// Options provides the set of options needed by the presigned URL middleware.
type Options struct {
// Accessor are the parameter accessors used by this middleware
Accessor ParameterAccessor
// Presigner is the URLPresigner used by the middleware
Presigner URLPresigner
}
// AddMiddleware adds the Presign URL middleware to the middleware stack.
func AddMiddleware(stack *middleware.Stack, opts Options) error {
return stack.Initialize.Add(&presign{options: opts}, middleware.Before)
}
// RemoveMiddleware removes the Presign URL middleware from the stack.
func RemoveMiddleware(stack *middleware.Stack) error {
_, err := stack.Initialize.Remove((*presign)(nil).ID())
return err
}
type presign struct {
options Options
}
func (m *presign) ID() string { return "Presign" }
func (m *presign) HandleInitialize(
ctx context.Context, input middleware.InitializeInput, next middleware.InitializeHandler,
) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
// If PresignedURL is already set ignore middleware.
if _, ok, err := m.options.Accessor.GetPresignedURL(input.Parameters); err != nil {
return out, metadata, fmt.Errorf("presign middleware failed, %w", err)
} else if ok {
return next.HandleInitialize(ctx, input)
}
// If have source region is not set ignore middleware.
srcRegion, ok, err := m.options.Accessor.GetSourceRegion(input.Parameters)
if err != nil {
return out, metadata, fmt.Errorf("presign middleware failed, %w", err)
} else if !ok || len(srcRegion) == 0 {
return next.HandleInitialize(ctx, input)
}
// Create a copy of the original input so the destination region value can
// be added. This ensures that value does not leak into the original
// request parameters.
paramCpy, err := m.options.Accessor.CopyInput(input.Parameters)
if err != nil {
return out, metadata, fmt.Errorf("unable to create presigned URL, %w", err)
}
// Destination region is the API client's configured region.
dstRegion := awsmiddleware.GetRegion(ctx)
if err = m.options.Accessor.SetDestinationRegion(paramCpy, dstRegion); err != nil {
return out, metadata, fmt.Errorf("presign middleware failed, %w", err)
}
presignedReq, err := m.options.Presigner.PresignURL(ctx, srcRegion, paramCpy)
if err != nil {
return out, metadata, fmt.Errorf("unable to create presigned URL, %w", err)
}
// Update the original input with the presigned URL value.
if err = m.options.Accessor.SetPresignedURL(input.Parameters, presignedReq.URL); err != nil {
return out, metadata, fmt.Errorf("presign middleware failed, %w", err)
}
return next.HandleInitialize(ctx, input)
}
| 111 |
aws-sdk-go-v2 | aws | Go | package presignedurl
import (
"context"
"net/http"
"strings"
"testing"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
v4 "github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
"github.com/google/go-cmp/cmp"
)
func TestPresignMiddleware(t *testing.T) {
cases := map[string]struct {
Input *mockURLPresignInput
ExpectInput *mockURLPresignInput
ExpectErr string
}{
"no source": {
Input: &mockURLPresignInput{},
ExpectInput: &mockURLPresignInput{},
},
"with presigned URL": {
Input: &mockURLPresignInput{
SourceRegion: "source-region",
PresignedURL: "https://example.amazonaws.com/someURL",
},
ExpectInput: &mockURLPresignInput{
SourceRegion: "source-region",
PresignedURL: "https://example.amazonaws.com/someURL",
},
},
"with source": {
Input: &mockURLPresignInput{
SourceRegion: "source-region",
},
ExpectInput: &mockURLPresignInput{
SourceRegion: "source-region",
PresignedURL: "https://example.source-region.amazonaws.com/?DestinationRegion=mock-region",
},
},
"matching source destination region": {
Input: &mockURLPresignInput{
SourceRegion: "mock-region",
},
ExpectInput: &mockURLPresignInput{
SourceRegion: "mock-region",
PresignedURL: "https://example.mock-region.amazonaws.com/?DestinationRegion=mock-region",
},
},
}
for name, c := range cases {
t.Run(name, func(t *testing.T) {
stack := middleware.NewStack(name, smithyhttp.NewStackRequest)
stack.Initialize.Add(&awsmiddleware.RegisterServiceMetadata{
Region: "mock-region",
}, middleware.After)
stack.Initialize.Add(&presign{options: getURLPresignMiddlewareOptions()}, middleware.After)
stack.Initialize.Add(middleware.InitializeMiddlewareFunc(name+"_verifyParams",
func(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
input := in.Parameters.(*mockURLPresignInput)
if diff := cmp.Diff(c.ExpectInput, input); len(diff) != 0 {
t.Errorf("expect input to be updated\n%s", diff)
}
return next.HandleInitialize(ctx, in)
},
), middleware.After)
handler := middleware.DecorateHandler(smithyhttp.NewClientHandler(smithyhttp.NopClient{}), stack)
_, _, err := handler.Handle(context.Background(), c.Input)
if len(c.ExpectErr) != 0 {
if err == nil {
t.Fatalf("expect error, got none")
}
if e, a := c.ExpectErr, err.Error(); !strings.Contains(a, e) {
t.Fatalf("expect error to contain %v, got %v", e, a)
}
return
}
if err != nil {
t.Fatalf("expect no error, got %v", err)
}
})
}
}
func getURLPresignMiddlewareOptions() Options {
return Options{
Accessor: ParameterAccessor{
GetPresignedURL: func(c interface{}) (string, bool, error) {
presignURL := c.(*mockURLPresignInput).PresignedURL
if len(presignURL) != 0 {
return presignURL, true, nil
}
return "", false, nil
},
GetSourceRegion: func(c interface{}) (string, bool, error) {
srcRegion := c.(*mockURLPresignInput).SourceRegion
if len(srcRegion) != 0 {
return srcRegion, true, nil
}
return "", false, nil
},
CopyInput: func(c interface{}) (interface{}, error) {
input := *(c.(*mockURLPresignInput))
return &input, nil
},
SetDestinationRegion: func(c interface{}, v string) error {
c.(*mockURLPresignInput).DestinationRegion = v
return nil
},
SetPresignedURL: func(c interface{}, v string) error {
c.(*mockURLPresignInput).PresignedURL = v
return nil
},
},
Presigner: &mockURLPresigner{},
}
}
type mockURLPresignInput struct {
SourceRegion string
DestinationRegion string
PresignedURL string
}
type mockURLPresigner struct{}
func (*mockURLPresigner) PresignURL(ctx context.Context, srcRegion string, params interface{}) (
req *v4.PresignedHTTPRequest, err error,
) {
in := params.(*mockURLPresignInput)
return &v4.PresignedHTTPRequest{
URL: "https://example." + srcRegion + ".amazonaws.com/?DestinationRegion=" + in.DestinationRegion,
Method: "GET",
SignedHeader: http.Header{},
}, nil
}
| 152 |
aws-sdk-go-v2 | aws | Go | package s3shared
import (
"context"
"fmt"
"github.com/aws/smithy-go/middleware"
"github.com/aws/aws-sdk-go-v2/aws/arn"
)
// ARNLookup is the initial middleware that looks up if an arn is provided.
// This middleware is responsible for fetching ARN from a arnable field, and registering the ARN on
// middleware context. This middleware must be executed before input validation step or any other
// arn processing middleware.
type ARNLookup struct {
// GetARNValue takes in a input interface and returns a ptr to string and a bool
GetARNValue func(interface{}) (*string, bool)
}
// ID for the middleware
func (m *ARNLookup) ID() string {
return "S3Shared:ARNLookup"
}
// HandleInitialize handles the behavior of this initialize step
func (m *ARNLookup) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
// check if GetARNValue is supported
if m.GetARNValue == nil {
return next.HandleInitialize(ctx, in)
}
// check is input resource is an ARN; if not go to next
v, ok := m.GetARNValue(in.Parameters)
if !ok || v == nil || !arn.IsARN(*v) {
return next.HandleInitialize(ctx, in)
}
// if ARN process ResourceRequest and put it on ctx
av, err := arn.Parse(*v)
if err != nil {
return out, metadata, fmt.Errorf("error parsing arn: %w", err)
}
// set parsed arn on context
ctx = setARNResourceOnContext(ctx, av)
return next.HandleInitialize(ctx, in)
}
// arnResourceKey is the key set on context used to identify, retrive an ARN resource
// if present on the context.
type arnResourceKey struct{}
// SetARNResourceOnContext sets the S3 ARN on the context.
//
// Scoped to stack values. Use github.com/aws/smithy-go/middleware#ClearStackValues
// to clear all stack values.
func setARNResourceOnContext(ctx context.Context, value arn.ARN) context.Context {
return middleware.WithStackValue(ctx, arnResourceKey{}, value)
}
// GetARNResourceFromContext returns an ARN from context and a bool indicating
// presence of ARN on ctx.
//
// Scoped to stack values. Use github.com/aws/smithy-go/middleware#ClearStackValues
// to clear all stack values.
func GetARNResourceFromContext(ctx context.Context) (arn.ARN, bool) {
v, ok := middleware.GetStackValue(ctx, arnResourceKey{}).(arn.ARN)
return v, ok
}
| 74 |
aws-sdk-go-v2 | aws | Go | package s3shared
import (
"fmt"
"github.com/aws/aws-sdk-go-v2/service/internal/s3shared/arn"
)
// TODO: fix these error statements to be relevant to v2 sdk
const (
invalidARNErrorErrCode = "InvalidARNError"
configurationErrorErrCode = "ConfigurationError"
)
// InvalidARNError denotes the error for Invalid ARN
type InvalidARNError struct {
message string
resource arn.Resource
origErr error
}
// Error returns the InvalidARN error string
func (e InvalidARNError) Error() string {
var extra string
if e.resource != nil {
extra = "ARN: " + e.resource.String()
}
msg := invalidARNErrorErrCode + " : " + e.message
if extra != "" {
msg = msg + "\n\t" + extra
}
return msg
}
// OrigErr is the original error wrapped by Invalid ARN Error
func (e InvalidARNError) Unwrap() error {
return e.origErr
}
// NewInvalidARNError denotes invalid arn error
func NewInvalidARNError(resource arn.Resource, err error) InvalidARNError {
return InvalidARNError{
message: "invalid ARN",
origErr: err,
resource: resource,
}
}
// NewInvalidARNWithUnsupportedPartitionError ARN not supported for the target partition
func NewInvalidARNWithUnsupportedPartitionError(resource arn.Resource, err error) InvalidARNError {
return InvalidARNError{
message: "resource ARN not supported for the target ARN partition",
origErr: err,
resource: resource,
}
}
// NewInvalidARNWithFIPSError ARN not supported for FIPS region
//
// Deprecated: FIPS will not appear in the ARN region component.
func NewInvalidARNWithFIPSError(resource arn.Resource, err error) InvalidARNError {
return InvalidARNError{
message: "resource ARN not supported for FIPS region",
resource: resource,
origErr: err,
}
}
// ConfigurationError is used to denote a client configuration error
type ConfigurationError struct {
message string
resource arn.Resource
clientPartitionID string
clientRegion string
origErr error
}
// Error returns the Configuration error string
func (e ConfigurationError) Error() string {
extra := fmt.Sprintf("ARN: %s, client partition: %s, client region: %s",
e.resource, e.clientPartitionID, e.clientRegion)
msg := configurationErrorErrCode + " : " + e.message
if extra != "" {
msg = msg + "\n\t" + extra
}
return msg
}
// OrigErr is the original error wrapped by Configuration Error
func (e ConfigurationError) Unwrap() error {
return e.origErr
}
// NewClientPartitionMismatchError stub
func NewClientPartitionMismatchError(resource arn.Resource, clientPartitionID, clientRegion string, err error) ConfigurationError {
return ConfigurationError{
message: "client partition does not match provided ARN partition",
origErr: err,
resource: resource,
clientPartitionID: clientPartitionID,
clientRegion: clientRegion,
}
}
// NewClientRegionMismatchError denotes cross region access error
func NewClientRegionMismatchError(resource arn.Resource, clientPartitionID, clientRegion string, err error) ConfigurationError {
return ConfigurationError{
message: "client region does not match provided ARN region",
origErr: err,
resource: resource,
clientPartitionID: clientPartitionID,
clientRegion: clientRegion,
}
}
// NewFailedToResolveEndpointError denotes endpoint resolving error
func NewFailedToResolveEndpointError(resource arn.Resource, clientPartitionID, clientRegion string, err error) ConfigurationError {
return ConfigurationError{
message: "endpoint resolver failed to find an endpoint for the provided ARN region",
origErr: err,
resource: resource,
clientPartitionID: clientPartitionID,
clientRegion: clientRegion,
}
}
// NewClientConfiguredForFIPSError denotes client config error for unsupported cross region FIPS access
func NewClientConfiguredForFIPSError(resource arn.Resource, clientPartitionID, clientRegion string, err error) ConfigurationError {
return ConfigurationError{
message: "client configured for fips but cross-region resource ARN provided",
origErr: err,
resource: resource,
clientPartitionID: clientPartitionID,
clientRegion: clientRegion,
}
}
// NewFIPSConfigurationError denotes a configuration error when a client or request is configured for FIPS
func NewFIPSConfigurationError(resource arn.Resource, clientPartitionID, clientRegion string, err error) ConfigurationError {
return ConfigurationError{
message: "use of ARN is not supported when client or request is configured for FIPS",
origErr: err,
resource: resource,
clientPartitionID: clientPartitionID,
clientRegion: clientRegion,
}
}
// NewClientConfiguredForAccelerateError denotes client config error for unsupported S3 accelerate
func NewClientConfiguredForAccelerateError(resource arn.Resource, clientPartitionID, clientRegion string, err error) ConfigurationError {
return ConfigurationError{
message: "client configured for S3 Accelerate but is not supported with resource ARN",
origErr: err,
resource: resource,
clientPartitionID: clientPartitionID,
clientRegion: clientRegion,
}
}
// NewClientConfiguredForCrossRegionFIPSError denotes client config error for unsupported cross region FIPS request
func NewClientConfiguredForCrossRegionFIPSError(resource arn.Resource, clientPartitionID, clientRegion string, err error) ConfigurationError {
return ConfigurationError{
message: "client configured for FIPS with cross-region enabled but is supported with cross-region resource ARN",
origErr: err,
resource: resource,
clientPartitionID: clientPartitionID,
clientRegion: clientRegion,
}
}
// NewClientConfiguredForDualStackError denotes client config error for unsupported S3 Dual-stack
func NewClientConfiguredForDualStackError(resource arn.Resource, clientPartitionID, clientRegion string, err error) ConfigurationError {
return ConfigurationError{
message: "client configured for S3 Dual-stack but is not supported with resource ARN",
origErr: err,
resource: resource,
clientPartitionID: clientPartitionID,
clientRegion: clientRegion,
}
}
| 184 |
aws-sdk-go-v2 | aws | Go | // Code generated by internal/repotools/cmd/updatemodulemeta DO NOT EDIT.
package s3shared
// goModuleVersion is the tagged release for this module
const goModuleVersion = "1.14.3"
| 7 |
aws-sdk-go-v2 | aws | Go | package s3shared
import (
"github.com/aws/smithy-go/middleware"
)
// hostID is used to retrieve host id from response metadata
type hostID struct {
}
// SetHostIDMetadata sets the provided host id over middleware metadata
func SetHostIDMetadata(metadata *middleware.Metadata, id string) {
metadata.Set(hostID{}, id)
}
// GetHostIDMetadata retrieves the host id from middleware metadata
// returns host id as string along with a boolean indicating presence of
// hostId on middleware metadata.
func GetHostIDMetadata(metadata middleware.Metadata) (string, bool) {
if !metadata.Has(hostID{}) {
return "", false
}
v, ok := metadata.Get(hostID{}).(string)
if !ok {
return "", true
}
return v, true
}
| 30 |
aws-sdk-go-v2 | aws | Go | package s3shared
import (
"context"
"github.com/aws/smithy-go/middleware"
)
// clonedInputKey used to denote if request input was cloned.
type clonedInputKey struct{}
// SetClonedInputKey sets a key on context to denote input was cloned previously.
//
// Scoped to stack values. Use github.com/aws/smithy-go/middleware#ClearStackValues
// to clear all stack values.
func SetClonedInputKey(ctx context.Context, value bool) context.Context {
return middleware.WithStackValue(ctx, clonedInputKey{}, value)
}
// IsClonedInput retrieves if context key for cloned input was set.
// If set, we can infer that the reuqest input was cloned previously.
//
// Scoped to stack values. Use github.com/aws/smithy-go/middleware#ClearStackValues
// to clear all stack values.
func IsClonedInput(ctx context.Context) bool {
v, _ := middleware.GetStackValue(ctx, clonedInputKey{}).(bool)
return v
}
| 29 |
aws-sdk-go-v2 | aws | Go | package s3shared
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
const metadataRetrieverID = "S3MetadataRetriever"
// AddMetadataRetrieverMiddleware adds request id, host id retriever middleware
func AddMetadataRetrieverMiddleware(stack *middleware.Stack) error {
// add metadata retriever middleware before operation deserializers so that it can retrieve metadata such as
// host id, request id from response header returned by operation deserializers
return stack.Deserialize.Insert(&metadataRetriever{}, "OperationDeserializer", middleware.Before)
}
type metadataRetriever struct {
}
// ID returns the middleware identifier
func (m *metadataRetriever) ID() string {
return metadataRetrieverID
}
func (m *metadataRetriever) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
resp, ok := out.RawResponse.(*smithyhttp.Response)
if !ok {
// No raw response to wrap with.
return out, metadata, err
}
// check for header for Request id
if v := resp.Header.Get("X-Amz-Request-Id"); len(v) != 0 {
// set reqID on metadata for successful responses.
awsmiddleware.SetRequestIDMetadata(&metadata, v)
}
// look up host-id
if v := resp.Header.Get("X-Amz-Id-2"); len(v) != 0 {
// set reqID on metadata for successful responses.
SetHostIDMetadata(&metadata, v)
}
return out, metadata, err
}
| 53 |
aws-sdk-go-v2 | aws | Go | package s3shared
import (
"fmt"
"strings"
awsarn "github.com/aws/aws-sdk-go-v2/aws/arn"
"github.com/aws/aws-sdk-go-v2/service/internal/s3shared/arn"
)
// ResourceRequest represents an ARN resource and api request metadata
type ResourceRequest struct {
Resource arn.Resource
// RequestRegion is the region configured on the request config
RequestRegion string
// SigningRegion is the signing region resolved for the request
SigningRegion string
// PartitionID is the resolved partition id for the provided request region
PartitionID string
// UseARNRegion indicates if client should use the region provided in an ARN resource
UseARNRegion bool
// UseFIPS indicates if te client is configured for FIPS
UseFIPS bool
}
// ARN returns the resource ARN
func (r ResourceRequest) ARN() awsarn.ARN {
return r.Resource.GetARN()
}
// ResourceConfiguredForFIPS returns true if resource ARNs region is FIPS
//
// Deprecated: FIPS will not be present in the ARN region
func (r ResourceRequest) ResourceConfiguredForFIPS() bool {
return IsFIPS(r.ARN().Region)
}
// AllowCrossRegion returns a bool value to denote if S3UseARNRegion flag is set
func (r ResourceRequest) AllowCrossRegion() bool {
return r.UseARNRegion
}
// IsCrossPartition returns true if request is configured for region of another partition, than
// the partition that resource ARN region resolves to. IsCrossPartition will not return an error,
// if request is not configured with a specific partition id. This might happen if customer provides
// custom endpoint url, but does not associate a partition id with it.
func (r ResourceRequest) IsCrossPartition() (bool, error) {
rv := r.PartitionID
if len(rv) == 0 {
return false, nil
}
av := r.Resource.GetARN().Partition
if len(av) == 0 {
return false, fmt.Errorf("no partition id for provided ARN")
}
return !strings.EqualFold(rv, av), nil
}
// IsCrossRegion returns true if request signing region is not same as arn region
func (r ResourceRequest) IsCrossRegion() bool {
v := r.SigningRegion
return !strings.EqualFold(v, r.Resource.GetARN().Region)
}
// IsFIPS returns true if region is a fips pseudo-region
//
// Deprecated: FIPS should be specified via EndpointOptions.
func IsFIPS(region string) bool {
return strings.HasPrefix(region, "fips-") ||
strings.HasSuffix(region, "-fips")
}
| 78 |
aws-sdk-go-v2 | aws | Go | package s3shared
import (
"errors"
"fmt"
awshttp "github.com/aws/aws-sdk-go-v2/aws/transport/http"
)
// ResponseError provides the HTTP centric error type wrapping the underlying error
// with the HTTP response value and the deserialized RequestID.
type ResponseError struct {
*awshttp.ResponseError
// HostID associated with response error
HostID string
}
// ServiceHostID returns the host id associated with Response Error
func (e *ResponseError) ServiceHostID() string { return e.HostID }
// Error returns the formatted error
func (e *ResponseError) Error() string {
return fmt.Sprintf(
"https response error StatusCode: %d, RequestID: %s, HostID: %s, %v",
e.Response.StatusCode, e.RequestID, e.HostID, e.Err)
}
// As populates target and returns true if the type of target is a error type that
// the ResponseError embeds, (e.g.S3 HTTP ResponseError)
func (e *ResponseError) As(target interface{}) bool {
return errors.As(e.ResponseError, target)
}
| 34 |
aws-sdk-go-v2 | aws | Go | package s3shared
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
awshttp "github.com/aws/aws-sdk-go-v2/aws/transport/http"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// AddResponseErrorMiddleware adds response error wrapper middleware
func AddResponseErrorMiddleware(stack *middleware.Stack) error {
// add error wrapper middleware before request id retriever middleware so that it can wrap the error response
// returned by operation deserializers
return stack.Deserialize.Insert(&errorWrapper{}, metadataRetrieverID, middleware.Before)
}
type errorWrapper struct {
}
// ID returns the middleware identifier
func (m *errorWrapper) ID() string {
return "ResponseErrorWrapper"
}
func (m *errorWrapper) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
if err == nil {
// Nothing to do when there is no error.
return out, metadata, err
}
resp, ok := out.RawResponse.(*smithyhttp.Response)
if !ok {
// No raw response to wrap with.
return out, metadata, err
}
// look for request id in metadata
reqID, _ := awsmiddleware.GetRequestIDMetadata(metadata)
// look for host id in metadata
hostID, _ := GetHostIDMetadata(metadata)
// Wrap the returned smithy error with the request id retrieved from the metadata
err = &ResponseError{
ResponseError: &awshttp.ResponseError{
ResponseError: &smithyhttp.ResponseError{
Response: resp,
Err: err,
},
RequestID: reqID,
},
HostID: hostID,
}
return out, metadata, err
}
| 61 |
aws-sdk-go-v2 | aws | Go | package s3shared
import (
"context"
"fmt"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
const s3100ContinueID = "S3100Continue"
const default100ContinueThresholdBytes int64 = 1024 * 1024 * 2
// Add100Continue add middleware, which adds {Expect: 100-continue} header for s3 client HTTP PUT request larger than 2MB
// or with unknown size streaming bodies, during operation builder step
func Add100Continue(stack *middleware.Stack, continueHeaderThresholdBytes int64) error {
return stack.Build.Add(&s3100Continue{
continueHeaderThresholdBytes: continueHeaderThresholdBytes,
}, middleware.After)
}
type s3100Continue struct {
continueHeaderThresholdBytes int64
}
// ID returns the middleware identifier
func (m *s3100Continue) ID() string {
return s3100ContinueID
}
func (m *s3100Continue) HandleBuild(
ctx context.Context, in middleware.BuildInput, next middleware.BuildHandler,
) (
out middleware.BuildOutput, metadata middleware.Metadata, err error,
) {
sizeLimit := default100ContinueThresholdBytes
switch {
case m.continueHeaderThresholdBytes == -1:
return next.HandleBuild(ctx, in)
case m.continueHeaderThresholdBytes > 0:
sizeLimit = m.continueHeaderThresholdBytes
default:
}
req, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, fmt.Errorf("unknown request type %T", req)
}
if req.ContentLength == -1 || (req.ContentLength == 0 && req.Body != nil) || req.ContentLength >= sizeLimit {
req.Header.Set("Expect", "100-continue")
}
return next.HandleBuild(ctx, in)
}
| 55 |
aws-sdk-go-v2 | aws | Go | package s3shared
import (
"context"
"github.com/aws/aws-sdk-go-v2/internal/awstesting"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
"testing"
)
// unit test for service/internal/s3shared/s3100continue.go
func TestAdd100ContinueHttpHeader(t *testing.T) {
const HeaderKey = "Expect"
HeaderValue := "100-continue"
cases := map[string]struct {
ContentLength int64
Body *awstesting.ReadCloser
ExpectValueFound string
ContinueHeaderThresholdBytes int64
}{
"http request smaller than default 2MB": {
ContentLength: 1,
Body: &awstesting.ReadCloser{Size: 1},
ExpectValueFound: "",
},
"http request smaller than configured threshold": {
ContentLength: 1024 * 1024 * 2,
Body: &awstesting.ReadCloser{Size: 1024 * 1024 * 2},
ExpectValueFound: "",
ContinueHeaderThresholdBytes: 1024 * 1024 * 3,
},
"http request larger than default 2MB": {
ContentLength: 1024 * 1024 * 3,
Body: &awstesting.ReadCloser{Size: 1024 * 1024 * 3},
ExpectValueFound: HeaderValue,
},
"http request larger than configured threshold": {
ContentLength: 1024 * 1024 * 4,
Body: &awstesting.ReadCloser{Size: 1024 * 1024 * 4},
ExpectValueFound: HeaderValue,
ContinueHeaderThresholdBytes: 1024 * 1024 * 3,
},
"http put request with unknown -1 ContentLength": {
ContentLength: -1,
Body: &awstesting.ReadCloser{Size: 1024 * 1024 * 10},
ExpectValueFound: HeaderValue,
},
"http put request with 0 ContentLength but unknown non-nil body": {
ContentLength: 0,
Body: &awstesting.ReadCloser{Size: 1024 * 1024 * 3},
ExpectValueFound: HeaderValue,
},
"http put request with unknown -1 ContentLength and configured threshold": {
ContentLength: -1,
Body: &awstesting.ReadCloser{Size: 1024 * 1024 * 3},
ExpectValueFound: HeaderValue,
ContinueHeaderThresholdBytes: 1024 * 1024 * 10,
},
"http put request with continue header disabled": {
ContentLength: 1024 * 1024 * 3,
Body: &awstesting.ReadCloser{Size: 1024 * 1024 * 3},
ExpectValueFound: "",
ContinueHeaderThresholdBytes: -1,
},
}
for name, c := range cases {
t.Run(name, func(t *testing.T) {
var err error
req := smithyhttp.NewStackRequest().(*smithyhttp.Request)
req.ContentLength = c.ContentLength
req.Body = c.Body
var updatedRequest *smithyhttp.Request
m := s3100Continue{
continueHeaderThresholdBytes: c.ContinueHeaderThresholdBytes,
}
_, _, err = m.HandleBuild(context.Background(),
middleware.BuildInput{Request: req},
middleware.BuildHandlerFunc(func(ctx context.Context, input middleware.BuildInput) (
out middleware.BuildOutput, metadata middleware.Metadata, err error) {
updatedRequest = input.Request.(*smithyhttp.Request)
return out, metadata, nil
}),
)
if err != nil {
t.Fatalf("expect no error, got %v", err)
}
if e, a := c.ExpectValueFound, updatedRequest.Header.Get(HeaderKey); e != a {
t.Errorf("expect header value %v found, got %v", e, a)
}
})
}
}
| 97 |
aws-sdk-go-v2 | aws | Go | package s3shared
import (
"context"
"fmt"
"strings"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
awsmiddle "github.com/aws/aws-sdk-go-v2/aws/middleware"
)
// EnableDualstack represents middleware struct for enabling dualstack support
//
// Deprecated: See EndpointResolverOptions' UseDualStackEndpoint support
type EnableDualstack struct {
// UseDualstack indicates if dualstack endpoint resolving is to be enabled
UseDualstack bool
// DefaultServiceID is the service id prefix used in endpoint resolving
// by default service-id is 's3' and 's3-control' for service s3, s3control.
DefaultServiceID string
}
// ID returns the middleware ID.
func (*EnableDualstack) ID() string {
return "EnableDualstack"
}
// HandleSerialize handles serializer middleware behavior when middleware is executed
func (u *EnableDualstack) HandleSerialize(
ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler,
) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
// check for host name immutable property
if smithyhttp.GetHostnameImmutable(ctx) {
return next.HandleSerialize(ctx, in)
}
serviceID := awsmiddle.GetServiceID(ctx)
// s3-control may be represented as `S3 Control` as in model
if serviceID == "S3 Control" {
serviceID = "s3-control"
}
if len(serviceID) == 0 {
// default service id
serviceID = u.DefaultServiceID
}
req, ok := in.Request.(*smithyhttp.Request)
if !ok {
return out, metadata, fmt.Errorf("unknown request type %T", req)
}
if u.UseDualstack {
parts := strings.Split(req.URL.Host, ".")
if len(parts) < 3 {
return out, metadata, fmt.Errorf("unable to update endpoint host for dualstack, hostname invalid, %s", req.URL.Host)
}
for i := 0; i+1 < len(parts); i++ {
if strings.EqualFold(parts[i], serviceID) {
parts[i] = parts[i] + ".dualstack"
break
}
}
// construct the url host
req.URL.Host = strings.Join(parts, ".")
}
return next.HandleSerialize(ctx, in)
}
| 79 |
aws-sdk-go-v2 | aws | Go | package s3shared
import (
"encoding/xml"
"fmt"
"io"
"net/http"
"strings"
)
// ErrorComponents represents the error response fields
// that will be deserialized from an xml error response body
type ErrorComponents struct {
Code string `xml:"Code"`
Message string `xml:"Message"`
RequestID string `xml:"RequestId"`
HostID string `xml:"HostId"`
}
// GetUnwrappedErrorResponseComponents returns the error fields from an xml error response body
func GetUnwrappedErrorResponseComponents(r io.Reader) (ErrorComponents, error) {
var errComponents ErrorComponents
if err := xml.NewDecoder(r).Decode(&errComponents); err != nil && err != io.EOF {
return ErrorComponents{}, fmt.Errorf("error while deserializing xml error response : %w", err)
}
return errComponents, nil
}
// GetWrappedErrorResponseComponents returns the error fields from an xml error response body
// in which error code, and message are wrapped by a <Error> tag
func GetWrappedErrorResponseComponents(r io.Reader) (ErrorComponents, error) {
var errComponents struct {
Code string `xml:"Error>Code"`
Message string `xml:"Error>Message"`
RequestID string `xml:"RequestId"`
HostID string `xml:"HostId"`
}
if err := xml.NewDecoder(r).Decode(&errComponents); err != nil && err != io.EOF {
return ErrorComponents{}, fmt.Errorf("error while deserializing xml error response : %w", err)
}
return ErrorComponents{
Code: errComponents.Code,
Message: errComponents.Message,
RequestID: errComponents.RequestID,
HostID: errComponents.HostID,
}, nil
}
// GetErrorResponseComponents retrieves error components according to passed in options
func GetErrorResponseComponents(r io.Reader, options ErrorResponseDeserializerOptions) (ErrorComponents, error) {
var errComponents ErrorComponents
var err error
if options.IsWrappedWithErrorTag {
errComponents, err = GetWrappedErrorResponseComponents(r)
} else {
errComponents, err = GetUnwrappedErrorResponseComponents(r)
}
if err != nil {
return ErrorComponents{}, err
}
// If an error code or message is not retrieved, it is derived from the http status code
// eg, for S3 service, we derive err code and message, if none is found
if options.UseStatusCode && len(errComponents.Code) == 0 &&
len(errComponents.Message) == 0 {
// derive code and message from status code
statusText := http.StatusText(options.StatusCode)
errComponents.Code = strings.Replace(statusText, " ", "", -1)
errComponents.Message = statusText
}
return errComponents, nil
}
// ErrorResponseDeserializerOptions represents error response deserializer options for s3 and s3-control service
type ErrorResponseDeserializerOptions struct {
// UseStatusCode denotes if status code should be used to retrieve error code, msg
UseStatusCode bool
// StatusCode is status code of error response
StatusCode int
//IsWrappedWithErrorTag represents if error response's code, msg is wrapped within an
// additional <Error> tag
IsWrappedWithErrorTag bool
}
| 90 |
aws-sdk-go-v2 | aws | Go | package s3shared
import (
"strings"
"testing"
)
func TestGetResponseErrorCode(t *testing.T) {
const xmlErrorResponse = `<Error>
<Type>Sender</Type>
<Code>InvalidGreeting</Code>
<Message>Hi</Message>
<HostId>bar-id</HostId>
<RequestId>foo-id</RequestId>
</Error>`
const wrappedXMLErrorResponse = `<ErrorResponse><Error>
<Type>Sender</Type>
<Code>InvalidGreeting</Code>
<Message>Hi</Message>
</Error>
<HostId>bar-id</HostId>
<RequestId>foo-id</RequestId>
</ErrorResponse>`
cases := map[string]struct {
getErr func() (ErrorComponents, error)
expectedErrorCode string
expectedErrorMessage string
expectedErrorRequestID string
expectedErrorHostID string
}{
"standard xml error": {
getErr: func() (ErrorComponents, error) {
errResp := strings.NewReader(xmlErrorResponse)
return GetErrorResponseComponents(errResp, ErrorResponseDeserializerOptions{
UseStatusCode: false,
StatusCode: 0,
IsWrappedWithErrorTag: false,
})
},
expectedErrorCode: "InvalidGreeting",
expectedErrorMessage: "Hi",
expectedErrorRequestID: "foo-id",
expectedErrorHostID: "bar-id",
},
"s3 no response body": {
getErr: func() (ErrorComponents, error) {
errResp := strings.NewReader("")
return GetErrorResponseComponents(errResp, ErrorResponseDeserializerOptions{
UseStatusCode: true,
StatusCode: 400,
})
},
expectedErrorCode: "BadRequest",
expectedErrorMessage: "Bad Request",
},
"s3control no response body": {
getErr: func() (ErrorComponents, error) {
errResp := strings.NewReader("")
return GetErrorResponseComponents(errResp, ErrorResponseDeserializerOptions{
IsWrappedWithErrorTag: true,
})
},
},
"s3control standard response body": {
getErr: func() (ErrorComponents, error) {
errResp := strings.NewReader(wrappedXMLErrorResponse)
return GetErrorResponseComponents(errResp, ErrorResponseDeserializerOptions{
IsWrappedWithErrorTag: true,
})
},
expectedErrorCode: "InvalidGreeting",
expectedErrorMessage: "Hi",
expectedErrorRequestID: "foo-id",
expectedErrorHostID: "bar-id",
},
}
for name, c := range cases {
t.Run(name, func(t *testing.T) {
ec, err := c.getErr()
if err != nil {
t.Fatalf("expected no error, got %v", err)
}
if e, a := c.expectedErrorCode, ec.Code; !strings.EqualFold(e, a) {
t.Fatalf("expected %v, got %v", e, a)
}
if e, a := c.expectedErrorMessage, ec.Message; !strings.EqualFold(e, a) {
t.Fatalf("expected %v, got %v", e, a)
}
if e, a := c.expectedErrorRequestID, ec.RequestID; !strings.EqualFold(e, a) {
t.Fatalf("expected %v, got %v", e, a)
}
if e, a := c.expectedErrorHostID, ec.HostID; !strings.EqualFold(e, a) {
t.Fatalf("expected %v, got %v", e, a)
}
})
}
}
| 103 |
aws-sdk-go-v2 | aws | Go | package arn
import (
"strings"
"github.com/aws/aws-sdk-go-v2/aws/arn"
)
// AccessPointARN provides representation
type AccessPointARN struct {
arn.ARN
AccessPointName string
}
// GetARN returns the base ARN for the Access Point resource
func (a AccessPointARN) GetARN() arn.ARN {
return a.ARN
}
// ParseAccessPointResource attempts to parse the ARN's resource as an
// AccessPoint resource.
//
// Supported Access point resource format:
// - Access point format: arn:{partition}:s3:{region}:{accountId}:accesspoint/{accesspointName}
// - example: arn:aws:s3:us-west-2:012345678901:accesspoint/myaccesspoint
func ParseAccessPointResource(a arn.ARN, resParts []string) (AccessPointARN, error) {
if isFIPS(a.Region) {
return AccessPointARN{}, InvalidARNError{ARN: a, Reason: "FIPS region not allowed in ARN"}
}
if len(a.AccountID) == 0 {
return AccessPointARN{}, InvalidARNError{ARN: a, Reason: "account-id not set"}
}
if len(resParts) == 0 {
return AccessPointARN{}, InvalidARNError{ARN: a, Reason: "resource-id not set"}
}
if len(resParts) > 1 {
return AccessPointARN{}, InvalidARNError{ARN: a, Reason: "sub resource not supported"}
}
resID := resParts[0]
if len(strings.TrimSpace(resID)) == 0 {
return AccessPointARN{}, InvalidARNError{ARN: a, Reason: "resource-id not set"}
}
return AccessPointARN{
ARN: a,
AccessPointName: resID,
}, nil
}
func isFIPS(region string) bool {
return strings.HasPrefix(region, "fips-") || strings.HasSuffix(region, "-fips")
}
| 54 |
aws-sdk-go-v2 | aws | Go | package arn
import (
"reflect"
"strings"
"testing"
"github.com/aws/aws-sdk-go-v2/aws/arn"
)
func TestParseAccessPointResource(t *testing.T) {
cases := map[string]struct {
ARN arn.ARN
ExpectErr string
ExpectARN AccessPointARN
}{
"account-id not set": {
ARN: arn.ARN{
Partition: "aws",
Service: "s3",
Region: "us-west-2",
Resource: "accesspoint/myendpoint",
},
ExpectErr: "account-id not set",
},
"resource-id not set": {
ARN: arn.ARN{
Partition: "aws",
Service: "s3",
Region: "us-west-2",
AccountID: "012345678901",
Resource: "accesspoint",
},
ExpectErr: "resource-id not set",
},
"resource-id empty": {
ARN: arn.ARN{
Partition: "aws",
Service: "s3",
Region: "us-west-2",
AccountID: "012345678901",
Resource: "accesspoint:",
},
ExpectErr: "resource-id not set",
},
"resource not supported": {
ARN: arn.ARN{
Partition: "aws",
Service: "s3",
Region: "us-west-2",
AccountID: "012345678901",
Resource: "accesspoint/endpoint/object/key",
},
ExpectErr: "sub resource not supported",
},
"valid resource-id": {
ARN: arn.ARN{
Partition: "aws",
Service: "s3",
Region: "us-west-2",
AccountID: "012345678901",
Resource: "accesspoint/endpoint",
},
ExpectARN: AccessPointARN{
ARN: arn.ARN{
Partition: "aws",
Service: "s3",
Region: "us-west-2",
AccountID: "012345678901",
Resource: "accesspoint/endpoint",
},
AccessPointName: "endpoint",
},
},
"invalid FIPS pseudo region in ARN (prefix)": {
ARN: arn.ARN{
Partition: "aws",
Service: "s3",
Region: "fips-us-west-2",
AccountID: "012345678901",
Resource: "accesspoint/endpoint",
},
ExpectErr: "FIPS region not allowed in ARN",
},
"invalid FIPS pseudo region in ARN (suffix)": {
ARN: arn.ARN{
Partition: "aws",
Service: "s3",
Region: "us-west-2-fips",
AccountID: "012345678901",
Resource: "accesspoint/endpoint",
},
ExpectErr: "FIPS region not allowed in ARN",
},
}
for name, c := range cases {
t.Run(name, func(t *testing.T) {
resParts := SplitResource(c.ARN.Resource)
a, err := ParseAccessPointResource(c.ARN, resParts[1:])
if len(c.ExpectErr) == 0 && err != nil {
t.Fatalf("expect no error but got %v", err)
} else if len(c.ExpectErr) != 0 && err == nil {
t.Fatalf("expect error %q, but got nil", c.ExpectErr)
} else if len(c.ExpectErr) != 0 && err != nil {
if e, a := c.ExpectErr, err.Error(); !strings.Contains(a, e) {
t.Fatalf("expect error %q, got %q", e, a)
}
return
}
if e, a := c.ExpectARN, a; !reflect.DeepEqual(e, a) {
t.Errorf("expect %v, got %v", e, a)
}
})
}
}
| 119 |
aws-sdk-go-v2 | aws | Go | package arn
import (
"fmt"
"strings"
"github.com/aws/aws-sdk-go-v2/aws/arn"
)
var supportedServiceARN = []string{
"s3",
"s3-outposts",
"s3-object-lambda",
}
func isSupportedServiceARN(service string) bool {
for _, name := range supportedServiceARN {
if name == service {
return true
}
}
return false
}
// Resource provides the interfaces abstracting ARNs of specific resource
// types.
type Resource interface {
GetARN() arn.ARN
String() string
}
// ResourceParser provides the function for parsing an ARN's resource
// component into a typed resource.
type ResourceParser func(arn.ARN) (Resource, error)
// ParseResource parses an AWS ARN into a typed resource for the S3 API.
func ParseResource(a arn.ARN, resParser ResourceParser) (resARN Resource, err error) {
if len(a.Partition) == 0 {
return nil, InvalidARNError{ARN: a, Reason: "partition not set"}
}
if !isSupportedServiceARN(a.Service) {
return nil, InvalidARNError{ARN: a, Reason: "service is not supported"}
}
if len(a.Resource) == 0 {
return nil, InvalidARNError{ARN: a, Reason: "resource not set"}
}
return resParser(a)
}
// SplitResource splits the resource components by the ARN resource delimiters.
func SplitResource(v string) []string {
var parts []string
var offset int
for offset <= len(v) {
idx := strings.IndexAny(v[offset:], "/:")
if idx < 0 {
parts = append(parts, v[offset:])
break
}
parts = append(parts, v[offset:idx+offset])
offset += idx + 1
}
return parts
}
// IsARN returns whether the given string is an ARN
func IsARN(s string) bool {
return arn.IsARN(s)
}
// InvalidARNError provides the error for an invalid ARN error.
type InvalidARNError struct {
ARN arn.ARN
Reason string
}
// Error returns a string denoting the occurred InvalidARNError
func (e InvalidARNError) Error() string {
return fmt.Sprintf("invalid Amazon %s ARN, %s, %s", e.ARN.Service, e.Reason, e.ARN.String())
}
| 86 |
aws-sdk-go-v2 | aws | Go | package arn
import (
"reflect"
"strings"
"testing"
"github.com/aws/aws-sdk-go-v2/aws/arn"
)
func TestParseResource(t *testing.T) {
cases := map[string]struct {
Input string
MappedResources map[string]func(arn.ARN, []string) (Resource, error)
Expect Resource
ExpectErr string
}{
"Empty ARN": {
Input: "",
ExpectErr: "arn: invalid prefix",
},
"No Partition": {
Input: "arn::sqs:us-west-2:012345678901:accesspoint",
ExpectErr: "partition not set",
},
"Not S3 ARN": {
Input: "arn:aws:sqs:us-west-2:012345678901:accesspoint",
ExpectErr: "service is not supported",
},
"No Resource": {
Input: "arn:aws:s3:us-west-2:012345678901:",
ExpectErr: "resource not set",
},
"Unknown Resource Type": {
Input: "arn:aws:s3:us-west-2:012345678901:myresource",
ExpectErr: "unknown resource type",
},
"Unknown BucketARN Resource Type": {
Input: "arn:aws:s3:us-west-2:012345678901:bucket_name:mybucket",
ExpectErr: "unknown resource type",
},
"Unknown Resource Type with Resource and Sub-Resource": {
Input: "arn:aws:s3:us-west-2:012345678901:somethingnew:myresource/subresource",
ExpectErr: "unknown resource type",
},
"Access Point with sub resource": {
Input: "arn:aws:s3:us-west-2:012345678901:accesspoint:myresource/subresource",
MappedResources: map[string]func(arn.ARN, []string) (Resource, error){
"accesspoint": func(a arn.ARN, parts []string) (Resource, error) {
return ParseAccessPointResource(a, parts)
},
},
ExpectErr: "resource not supported",
},
"AccessPoint Resource Type": {
Input: "arn:aws:s3:us-west-2:012345678901:accesspoint:myendpoint",
MappedResources: map[string]func(arn.ARN, []string) (Resource, error){
"accesspoint": func(a arn.ARN, parts []string) (Resource, error) {
return ParseAccessPointResource(a, parts)
},
},
Expect: AccessPointARN{
ARN: arn.ARN{
Partition: "aws",
Service: "s3",
Region: "us-west-2",
AccountID: "012345678901",
Resource: "accesspoint:myendpoint",
},
AccessPointName: "myendpoint",
},
},
"AccessPoint Resource Type With Path Syntax": {
Input: "arn:aws:s3:us-west-2:012345678901:accesspoint/myendpoint",
MappedResources: map[string]func(arn.ARN, []string) (Resource, error){
"accesspoint": func(a arn.ARN, parts []string) (Resource, error) {
return ParseAccessPointResource(a, parts)
},
},
Expect: AccessPointARN{
ARN: arn.ARN{
Partition: "aws",
Service: "s3",
Region: "us-west-2",
AccountID: "012345678901",
Resource: "accesspoint/myendpoint",
},
AccessPointName: "myendpoint",
},
},
}
for name, c := range cases {
t.Run(name, func(t *testing.T) {
var parsed Resource
arn, err := arn.Parse(c.Input)
if err == nil {
parsed, err = ParseResource(arn, mappedResourceParser(c.MappedResources))
}
if len(c.ExpectErr) == 0 && err != nil {
t.Fatalf("expect no error but got %v", err)
} else if len(c.ExpectErr) != 0 && err == nil {
t.Fatalf("expect error but got nil")
} else if len(c.ExpectErr) != 0 && err != nil {
if e, a := c.ExpectErr, err.Error(); !strings.Contains(a, e) {
t.Fatalf("expect error %q, got %q", e, a)
}
return
}
if e, a := c.Expect, parsed; !reflect.DeepEqual(e, a) {
t.Errorf("Expect %v, got %v", e, a)
}
})
}
}
func mappedResourceParser(kinds map[string]func(arn.ARN, []string) (Resource, error)) ResourceParser {
return func(a arn.ARN) (Resource, error) {
parts := SplitResource(a.Resource)
fn, ok := kinds[parts[0]]
if !ok {
return nil, InvalidARNError{ARN: a, Reason: "unknown resource type"}
}
return fn(a, parts[1:])
}
}
func TestSplitResource(t *testing.T) {
cases := []struct {
Input string
Expect []string
}{
{
Input: "accesspoint:myendpoint",
Expect: []string{"accesspoint", "myendpoint"},
},
{
Input: "accesspoint/myendpoint",
Expect: []string{"accesspoint", "myendpoint"},
},
{
Input: "accesspoint",
Expect: []string{"accesspoint"},
},
{
Input: "accesspoint:",
Expect: []string{"accesspoint", ""},
},
{
Input: "accesspoint: ",
Expect: []string{"accesspoint", " "},
},
{
Input: "accesspoint:endpoint/object/key",
Expect: []string{"accesspoint", "endpoint", "object", "key"},
},
}
for _, c := range cases {
t.Run(c.Input, func(t *testing.T) {
parts := SplitResource(c.Input)
if e, a := c.Expect, parts; !reflect.DeepEqual(e, a) {
t.Errorf("expect %v, got %v", e, a)
}
})
}
}
| 171 |
aws-sdk-go-v2 | aws | Go | package arn
import (
"strings"
"github.com/aws/aws-sdk-go-v2/aws/arn"
)
// OutpostARN interface that should be satisfied by outpost ARNs
type OutpostARN interface {
Resource
GetOutpostID() string
}
// ParseOutpostARNResource will parse a provided ARNs resource using the appropriate ARN format
// and return a specific OutpostARN type
//
// Currently supported outpost ARN formats:
// * Outpost AccessPoint ARN format:
// - ARN format: arn:{partition}:s3-outposts:{region}:{accountId}:outpost/{outpostId}/accesspoint/{accesspointName}
// - example: arn:aws:s3-outposts:us-west-2:012345678901:outpost/op-1234567890123456/accesspoint/myaccesspoint
//
// * Outpost Bucket ARN format:
// - ARN format: arn:{partition}:s3-outposts:{region}:{accountId}:outpost/{outpostId}/bucket/{bucketName}
// - example: arn:aws:s3-outposts:us-west-2:012345678901:outpost/op-1234567890123456/bucket/mybucket
//
// Other outpost ARN formats may be supported and added in the future.
func ParseOutpostARNResource(a arn.ARN, resParts []string) (OutpostARN, error) {
if len(a.Region) == 0 {
return nil, InvalidARNError{ARN: a, Reason: "region not set"}
}
if isFIPS(a.Region) {
return nil, InvalidARNError{ARN: a, Reason: "FIPS region not allowed in ARN"}
}
if len(a.AccountID) == 0 {
return nil, InvalidARNError{ARN: a, Reason: "account-id not set"}
}
// verify if outpost id is present and valid
if len(resParts) == 0 || len(strings.TrimSpace(resParts[0])) == 0 {
return nil, InvalidARNError{ARN: a, Reason: "outpost resource-id not set"}
}
// verify possible resource type exists
if len(resParts) < 3 {
return nil, InvalidARNError{
ARN: a, Reason: "incomplete outpost resource type. Expected bucket or access-point resource to be present",
}
}
// Since we know this is a OutpostARN fetch outpostID
outpostID := strings.TrimSpace(resParts[0])
switch resParts[1] {
case "accesspoint":
accesspointARN, err := ParseAccessPointResource(a, resParts[2:])
if err != nil {
return OutpostAccessPointARN{}, err
}
return OutpostAccessPointARN{
AccessPointARN: accesspointARN,
OutpostID: outpostID,
}, nil
case "bucket":
bucketName, err := parseBucketResource(a, resParts[2:])
if err != nil {
return nil, err
}
return OutpostBucketARN{
ARN: a,
BucketName: bucketName,
OutpostID: outpostID,
}, nil
default:
return nil, InvalidARNError{ARN: a, Reason: "unknown resource set for outpost ARN"}
}
}
// OutpostAccessPointARN represents outpost access point ARN.
type OutpostAccessPointARN struct {
AccessPointARN
OutpostID string
}
// GetOutpostID returns the outpost id of outpost access point arn
func (o OutpostAccessPointARN) GetOutpostID() string {
return o.OutpostID
}
// OutpostBucketARN represents the outpost bucket ARN.
type OutpostBucketARN struct {
arn.ARN
BucketName string
OutpostID string
}
// GetOutpostID returns the outpost id of outpost bucket arn
func (o OutpostBucketARN) GetOutpostID() string {
return o.OutpostID
}
// GetARN retrives the base ARN from outpost bucket ARN resource
func (o OutpostBucketARN) GetARN() arn.ARN {
return o.ARN
}
// parseBucketResource attempts to parse the ARN's bucket resource and retrieve the
// bucket resource id.
//
// parseBucketResource only parses the bucket resource id.
func parseBucketResource(a arn.ARN, resParts []string) (bucketName string, err error) {
if len(resParts) == 0 {
return bucketName, InvalidARNError{ARN: a, Reason: "bucket resource-id not set"}
}
if len(resParts) > 1 {
return bucketName, InvalidARNError{ARN: a, Reason: "sub resource not supported"}
}
bucketName = strings.TrimSpace(resParts[0])
if len(bucketName) == 0 {
return bucketName, InvalidARNError{ARN: a, Reason: "bucket resource-id not set"}
}
return bucketName, err
}
| 129 |
aws-sdk-go-v2 | aws | Go | package arn
import (
"reflect"
"strings"
"testing"
"github.com/aws/aws-sdk-go-v2/aws/arn"
)
func TestParseOutpostAccessPointARNResource(t *testing.T) {
cases := map[string]struct {
ARN arn.ARN
ExpectErr string
ExpectARN OutpostAccessPointARN
}{
"region not set": {
ARN: arn.ARN{
Partition: "aws",
Service: "s3-outposts",
AccountID: "012345678901",
Resource: "outpost/myoutpost/accesspoint/myendpoint",
},
ExpectErr: "region not set",
},
"account-id not set": {
ARN: arn.ARN{
Partition: "aws",
Service: "s3-outposts",
Region: "us-west-2",
Resource: "outpost/myoutpost/accesspoint/myendpoint",
},
ExpectErr: "account-id not set",
},
"resource-id not set": {
ARN: arn.ARN{
Partition: "aws",
Service: "s3-outposts",
Region: "us-west-2",
AccountID: "012345678901",
Resource: "myoutpost",
},
ExpectErr: "resource-id not set",
},
"resource-id empty": {
ARN: arn.ARN{
Partition: "aws",
Service: "s3-outposts",
Region: "us-west-2",
AccountID: "012345678901",
Resource: "outpost:",
},
ExpectErr: "resource-id not set",
},
"resource not supported": {
ARN: arn.ARN{
Partition: "aws",
Service: "s3-outposts",
Region: "us-west-2",
AccountID: "012345678901",
Resource: "outpost/myoutpost/accesspoint/endpoint/object/key",
},
ExpectErr: "sub resource not supported",
},
"access-point not defined": {
ARN: arn.ARN{
Partition: "aws",
Service: "s3-outposts",
Region: "us-west-2",
AccountID: "012345678901",
Resource: "outpost/myoutpost/endpoint/object/key",
},
ExpectErr: "unknown resource set for outpost ARN",
},
"valid resource-id": {
ARN: arn.ARN{
Partition: "aws",
Service: "s3-outposts",
Region: "us-west-2",
AccountID: "012345678901",
Resource: "outpost/myoutpost/accesspoint/myaccesspoint",
},
ExpectARN: OutpostAccessPointARN{
AccessPointARN: AccessPointARN{
ARN: arn.ARN{
Partition: "aws",
Service: "s3-outposts",
Region: "us-west-2",
AccountID: "012345678901",
Resource: "outpost/myoutpost/accesspoint/myaccesspoint",
},
AccessPointName: "myaccesspoint",
},
OutpostID: "myoutpost",
},
},
"invalid FIPS pseudo region in ARN (prefix)": {
ARN: arn.ARN{
Partition: "aws",
Service: "s3-outposts",
Region: "fips-us-west-2",
AccountID: "012345678901",
Resource: "outpost/myoutpost/accesspoint/myendpoint",
},
ExpectErr: "FIPS region not allowed in ARN",
},
"invalid FIPS pseudo region in ARN (suffix)": {
ARN: arn.ARN{
Partition: "aws",
Service: "s3-outposts",
Region: "us-west-2-fips",
AccountID: "012345678901",
Resource: "outpost/myoutpost/accesspoint/myendpoint",
},
ExpectErr: "FIPS region not allowed in ARN",
},
}
for name, c := range cases {
t.Run(name, func(t *testing.T) {
resParts := SplitResource(c.ARN.Resource)
a, err := ParseOutpostARNResource(c.ARN, resParts[1:])
if len(c.ExpectErr) == 0 && err != nil {
t.Fatalf("expect no error but got %v", err)
} else if len(c.ExpectErr) != 0 && err == nil {
t.Fatalf("expect error %q, but got nil", c.ExpectErr)
} else if len(c.ExpectErr) != 0 && err != nil {
if e, a := c.ExpectErr, err.Error(); !strings.Contains(a, e) {
t.Fatalf("expect error %q, got %q", e, a)
}
return
}
if e, a := c.ExpectARN, a; !reflect.DeepEqual(e, a) {
t.Errorf("expect %v, got %v", e, a)
}
})
}
}
func TestParseOutpostBucketARNResource(t *testing.T) {
cases := map[string]struct {
ARN arn.ARN
ExpectErr string
ExpectARN OutpostBucketARN
}{
"region not set": {
ARN: arn.ARN{
Partition: "aws",
Service: "s3-outposts",
AccountID: "012345678901",
Resource: "outpost/myoutpost/bucket/mybucket",
},
ExpectErr: "region not set",
},
"resource-id empty": {
ARN: arn.ARN{
Partition: "aws",
Service: "s3-outposts",
Region: "us-west-2",
AccountID: "012345678901",
Resource: "outpost:",
},
ExpectErr: "resource-id not set",
},
"resource not supported": {
ARN: arn.ARN{
Partition: "aws",
Service: "s3-outposts",
Region: "us-west-2",
AccountID: "012345678901",
Resource: "outpost/myoutpost/bucket/mybucket/object/key",
},
ExpectErr: "sub resource not supported",
},
"bucket not defined": {
ARN: arn.ARN{
Partition: "aws",
Service: "s3-outposts",
Region: "us-west-2",
AccountID: "012345678901",
Resource: "outpost/myoutpost/endpoint/object/key",
},
ExpectErr: "unknown resource set for outpost ARN",
},
"valid resource-id": {
ARN: arn.ARN{
Partition: "aws",
Service: "s3-outposts",
Region: "us-west-2",
AccountID: "012345678901",
Resource: "outpost/myoutpost/bucket/mybucket",
},
ExpectARN: OutpostBucketARN{
ARN: arn.ARN{
Partition: "aws",
Service: "s3-outposts",
Region: "us-west-2",
AccountID: "012345678901",
Resource: "outpost/myoutpost/bucket/mybucket",
},
BucketName: "mybucket",
OutpostID: "myoutpost",
},
},
}
for name, c := range cases {
t.Run(name, func(t *testing.T) {
resParts := SplitResource(c.ARN.Resource)
a, err := ParseOutpostARNResource(c.ARN, resParts[1:])
if len(c.ExpectErr) == 0 && err != nil {
t.Fatalf("expect no error but got %v", err)
} else if len(c.ExpectErr) != 0 && err == nil {
t.Fatalf("expect error %q, but got nil", c.ExpectErr)
} else if len(c.ExpectErr) != 0 && err != nil {
if e, a := c.ExpectErr, err.Error(); !strings.Contains(a, e) {
t.Fatalf("expect error %q, got %q", e, a)
}
return
}
if e, a := c.ExpectARN, a; !reflect.DeepEqual(e, a) {
t.Errorf("expect %v, got %v", e, a)
}
})
}
}
func TestParseBucketResource(t *testing.T) {
cases := map[string]struct {
ARN arn.ARN
ExpectErr string
ExpectBucketName string
}{
"resource-id empty": {
ARN: arn.ARN{
Partition: "aws",
Service: "s3",
Region: "us-west-2",
AccountID: "012345678901",
Resource: "bucket:",
},
ExpectErr: "bucket resource-id not set",
},
"resource not supported": {
ARN: arn.ARN{
Partition: "aws",
Service: "s3",
Region: "us-west-2",
AccountID: "012345678901",
Resource: "bucket/mybucket/object/key",
},
ExpectErr: "sub resource not supported",
},
"valid resource-id": {
ARN: arn.ARN{
Partition: "aws",
Service: "s3",
Region: "us-west-2",
AccountID: "012345678901",
Resource: "bucket/mybucket",
},
ExpectBucketName: "mybucket",
},
}
for name, c := range cases {
t.Run(name, func(t *testing.T) {
resParts := SplitResource(c.ARN.Resource)
a, err := parseBucketResource(c.ARN, resParts[1:])
if len(c.ExpectErr) == 0 && err != nil {
t.Fatalf("expect no error but got %v", err)
} else if len(c.ExpectErr) != 0 && err == nil {
t.Fatalf("expect error %q, but got nil", c.ExpectErr)
} else if len(c.ExpectErr) != 0 && err != nil {
if e, a := c.ExpectErr, err.Error(); !strings.Contains(a, e) {
t.Fatalf("expect error %q, got %q", e, a)
}
return
}
if e, a := c.ExpectBucketName, a; !reflect.DeepEqual(e, a) {
t.Errorf("expect %v, got %v", e, a)
}
})
}
}
| 292 |
aws-sdk-go-v2 | aws | Go | package arn
// S3ObjectLambdaARN represents an ARN for the s3-object-lambda service
type S3ObjectLambdaARN interface {
Resource
isS3ObjectLambdasARN()
}
// S3ObjectLambdaAccessPointARN is an S3ObjectLambdaARN for the Access Point resource type
type S3ObjectLambdaAccessPointARN struct {
AccessPointARN
}
func (s S3ObjectLambdaAccessPointARN) isS3ObjectLambdasARN() {}
| 16 |
aws-sdk-go-v2 | aws | Go | package config
import "context"
// UseARNRegionProvider is an interface for retrieving external configuration value for UseARNRegion
type UseARNRegionProvider interface {
GetS3UseARNRegion(ctx context.Context) (value bool, found bool, err error)
}
// ResolveUseARNRegion extracts the first instance of a UseARNRegion from the config slice.
// Additionally returns a boolean to indicate if the value was found in provided configs, and error if one is encountered.
func ResolveUseARNRegion(ctx context.Context, configs []interface{}) (value bool, found bool, err error) {
for _, cfg := range configs {
if p, ok := cfg.(UseARNRegionProvider); ok {
value, found, err = p.GetS3UseARNRegion(ctx)
if err != nil || found {
break
}
}
}
return
}
| 23 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.