From 0402b496189430bd02ce2dfaa4f172e57f967547 Mon Sep 17 00:00:00 2001 From: AWS SDK for Go v2 automation user Date: Wed, 5 Jun 2024 18:27:26 +0000 Subject: [PATCH] Regenerated Clients --- .../3e8f46bef0634ecca6d79ce47de3e1b1.json | 8 + .../8e1bf54ee9c54a05b900fcae96c40f9e.json | 8 + .../d3790cc1943e4cadb454d0a30bb36060.json | 8 + .../dynamodbstreams/attributevalue/decode.go | 47 +- .../attributevalue/decode_test.go | 95 +++ .../dynamodbstreams/attributevalue/encode.go | 48 +- .../attributevalue/encode_test.go | 89 +++ .../cloud9/internal/endpoints/endpoints.go | 88 +++ .../internal/endpoints/endpoints.go | 30 + .../api_op_UpdateAccelerator.go | 3 + .../api_op_UpdateCustomRoutingAccelerator.go | 3 + service/globalaccelerator/serializers.go | 14 + service/glue/api_op_CreateConnection.go | 6 + service/glue/api_op_CreateJob.go | 7 +- service/glue/api_op_StartJobRun.go | 6 +- service/glue/deserializers.go | 246 ++++++++ service/glue/serializers.go | 119 ++++ service/glue/types/enums.go | 77 +++ service/glue/types/types.go | 175 +++++- service/s3/api_op_CopyObject.go | 2 + service/s3/endpoints.go | 7 + service/s3/endpoints_test.go | 541 ++++++++++-------- 22 files changed, 1347 insertions(+), 280 deletions(-) create mode 100644 .changelog/3e8f46bef0634ecca6d79ce47de3e1b1.json create mode 100644 .changelog/8e1bf54ee9c54a05b900fcae96c40f9e.json create mode 100644 .changelog/d3790cc1943e4cadb454d0a30bb36060.json diff --git a/.changelog/3e8f46bef0634ecca6d79ce47de3e1b1.json b/.changelog/3e8f46bef0634ecca6d79ce47de3e1b1.json new file mode 100644 index 00000000000..6f39d14fb50 --- /dev/null +++ b/.changelog/3e8f46bef0634ecca6d79ce47de3e1b1.json @@ -0,0 +1,8 @@ +{ + "id": "3e8f46be-f063-4ecc-a6d7-9ce47de3e1b1", + "type": "feature", + "description": "Added new params copySource and key to copyObject API for supporting S3 Access Grants plugin. These changes will not change any of the existing S3 API functionality.", + "modules": [ + "service/s3" + ] +} \ No newline at end of file diff --git a/.changelog/8e1bf54ee9c54a05b900fcae96c40f9e.json b/.changelog/8e1bf54ee9c54a05b900fcae96c40f9e.json new file mode 100644 index 00000000000..580669f18e4 --- /dev/null +++ b/.changelog/8e1bf54ee9c54a05b900fcae96c40f9e.json @@ -0,0 +1,8 @@ +{ + "id": "8e1bf54e-e9c5-4a05-b900-fcae96c40f9e", + "type": "feature", + "description": "This release contains a new optional ip-addresses input field for the update accelerator and update custom routing accelerator apis. This input enables consumers to replace IPv4 addresses on existing accelerators with addresses provided in the input.", + "modules": [ + "service/globalaccelerator" + ] +} \ No newline at end of file diff --git a/.changelog/d3790cc1943e4cadb454d0a30bb36060.json b/.changelog/d3790cc1943e4cadb454d0a30bb36060.json new file mode 100644 index 00000000000..fcdb96f3015 --- /dev/null +++ b/.changelog/d3790cc1943e4cadb454d0a30bb36060.json @@ -0,0 +1,8 @@ +{ + "id": "d3790cc1-943e-4cad-b454-d0a30bb36060", + "type": "feature", + "description": "AWS Glue now supports native SaaS connectivity: Salesforce connector available now", + "modules": [ + "service/glue" + ] +} \ No newline at end of file diff --git a/feature/dynamodbstreams/attributevalue/decode.go b/feature/dynamodbstreams/attributevalue/decode.go index b722b3eec38..35021869967 100644 --- a/feature/dynamodbstreams/attributevalue/decode.go +++ b/feature/dynamodbstreams/attributevalue/decode.go @@ -231,6 +231,18 @@ type DecoderOptions struct { // Default string parsing format is time.RFC3339 // Default number parsing format is seconds since January 1, 1970 UTC DecodeTime DecodeTimeAttributes + + // When enabled, the decoder will use implementations of + // encoding.TextUnmarshaler and encoding.BinaryUnmarshaler when present on + // unmarshaling targets. + // + // If a target implements [Unmarshaler], encoding unmarshaler + // implementations are ignored. + // + // If the attributevalue is a string, its underlying value will be used to + // call UnmarshalText on the target. If the attributevalue is a binary, its + // value will be used to call UnmarshalBinary. + UseEncodingUnmarshalers bool } // A Decoder provides unmarshaling AttributeValues to Go value types. @@ -288,17 +300,30 @@ func (d *Decoder) decode(av types.AttributeValue, v reflect.Value, fieldTag tag) var u Unmarshaler _, isNull := av.(*types.AttributeValueMemberNULL) if av == nil || isNull { - u, v = indirect(v, indirectOptions{decodeNull: true}) + u, v = indirect[Unmarshaler](v, indirectOptions{decodeNull: true}) if u != nil { return u.UnmarshalDynamoDBStreamsAttributeValue(av) } return d.decodeNull(v) } - u, v = indirect(v, indirectOptions{}) + v0 := v + u, v = indirect[Unmarshaler](v, indirectOptions{}) if u != nil { return u.UnmarshalDynamoDBStreamsAttributeValue(av) } + if d.options.UseEncodingUnmarshalers { + if s, ok := av.(*types.AttributeValueMemberS); ok { + if u, _ := indirect[encoding.TextUnmarshaler](v0, indirectOptions{}); u != nil { + return u.UnmarshalText([]byte(s.Value)) + } + } + if b, ok := av.(*types.AttributeValueMemberB); ok { + if u, _ := indirect[encoding.BinaryUnmarshaler](v0, indirectOptions{}); u != nil { + return u.UnmarshalBinary(b.Value) + } + } + } switch tv := av.(type) { case *types.AttributeValueMemberB: @@ -420,7 +445,7 @@ func (d *Decoder) decodeBinarySet(bs [][]byte, v reflect.Value) error { if !isArray { v.SetLen(i + 1) } - u, elem := indirect(v.Index(i), indirectOptions{}) + u, elem := indirect[Unmarshaler](v.Index(i), indirectOptions{}) if u != nil { return u.UnmarshalDynamoDBStreamsAttributeValue(&types.AttributeValueMemberBS{Value: bs}) } @@ -555,7 +580,7 @@ func (d *Decoder) decodeNumberSet(ns []string, v reflect.Value) error { if !isArray { v.SetLen(i + 1) } - u, elem := indirect(v.Index(i), indirectOptions{}) + u, elem := indirect[Unmarshaler](v.Index(i), indirectOptions{}) if u != nil { return u.UnmarshalDynamoDBStreamsAttributeValue(&types.AttributeValueMemberNS{Value: ns}) } @@ -634,7 +659,7 @@ func (d *Decoder) decodeMap(avMap map[string]types.AttributeValue, v reflect.Val for k, av := range avMap { key := reflect.New(keyType).Elem() // handle pointer keys - _, indirectKey := indirect(key, indirectOptions{skipUnmarshaler: true}) + _, indirectKey := indirect[Unmarshaler](key, indirectOptions{skipUnmarshaler: true}) if err := decodeMapKey(k, indirectKey, tag{}); err != nil { return &UnmarshalTypeError{ Value: fmt.Sprintf("map key %q", k), @@ -777,7 +802,7 @@ func (d *Decoder) decodeStringSet(ss []string, v reflect.Value) error { if !isArray { v.SetLen(i + 1) } - u, elem := indirect(v.Index(i), indirectOptions{}) + u, elem := indirect[Unmarshaler](v.Index(i), indirectOptions{}) if u != nil { return u.UnmarshalDynamoDBStreamsAttributeValue(&types.AttributeValueMemberSS{Value: ss}) } @@ -825,7 +850,7 @@ type indirectOptions struct { // // Based on the enoding/json type reflect value type indirection in Go Stdlib // https://golang.org/src/encoding/json/decode.go indirect func. -func indirect(v reflect.Value, opts indirectOptions) (Unmarshaler, reflect.Value) { +func indirect[U any](v reflect.Value, opts indirectOptions) (U, reflect.Value) { // Issue #24153 indicates that it is generally not a guaranteed property // that you may round-trip a reflect.Value by calling Value.Addr().Elem() // and expect the value to still be settable for values derived from @@ -859,7 +884,8 @@ func indirect(v reflect.Value, opts indirectOptions) (Unmarshaler, reflect.Value continue } if e.Kind() != reflect.Ptr && e.IsValid() { - return nil, e + var u U + return u, e } } if v.Kind() != reflect.Ptr { @@ -880,7 +906,7 @@ func indirect(v reflect.Value, opts indirectOptions) (Unmarshaler, reflect.Value v.Set(reflect.New(v.Type().Elem())) } if !opts.skipUnmarshaler && v.Type().NumMethod() > 0 && v.CanInterface() { - if u, ok := v.Interface().(Unmarshaler); ok { + if u, ok := v.Interface().(U); ok { return u, reflect.Value{} } } @@ -893,7 +919,8 @@ func indirect(v reflect.Value, opts indirectOptions) (Unmarshaler, reflect.Value } } - return nil, v + var u U + return u, v } // A Number represents a Attributevalue number literal. diff --git a/feature/dynamodbstreams/attributevalue/decode_test.go b/feature/dynamodbstreams/attributevalue/decode_test.go index fb5ea599f48..1bccef17abb 100644 --- a/feature/dynamodbstreams/attributevalue/decode_test.go +++ b/feature/dynamodbstreams/attributevalue/decode_test.go @@ -4,6 +4,7 @@ import ( "fmt" "reflect" "strconv" + "strings" "testing" "time" @@ -1173,3 +1174,97 @@ func TestUnmarshalMap_keyPtrTypes(t *testing.T) { } } + +type textUnmarshalerString string + +func (v *textUnmarshalerString) UnmarshalText(text []byte) error { + *v = textUnmarshalerString("[[" + string(text) + "]]") + return nil +} + +func TestUnmarshalTextString(t *testing.T) { + in := &types.AttributeValueMemberS{Value: "foo"} + + var actual textUnmarshalerString + err := UnmarshalWithOptions(in, &actual, func(o *DecoderOptions) { + o.UseEncodingUnmarshalers = true + }) + if err != nil { + t.Fatalf("expect no error, got %v", err) + } + + if string(actual) != "[[foo]]" { + t.Errorf("expected [[foo]], got %s", actual) + } +} + +func TestUnmarshalTextStringDisabled(t *testing.T) { + in := &types.AttributeValueMemberS{Value: "foo"} + + var actual textUnmarshalerString + err := UnmarshalWithOptions(in, &actual, func(o *DecoderOptions) { + o.UseEncodingUnmarshalers = false + }) + if err != nil { + t.Fatalf("expect no error, got %v", err) + } + + if string(actual) != "foo" { + t.Errorf("expected foo, got %s", actual) + } +} + +type textUnmarshalerStruct struct { + I, J string +} + +func (v *textUnmarshalerStruct) UnmarshalText(text []byte) error { + parts := strings.Split(string(text), ";") + v.I = parts[0] + v.J = parts[1] + return nil +} + +func TestUnmarshalTextStruct(t *testing.T) { + in := &types.AttributeValueMemberS{Value: "foo;bar"} + + var actual textUnmarshalerStruct + err := UnmarshalWithOptions(in, &actual, func(o *DecoderOptions) { + o.UseEncodingUnmarshalers = true + }) + if err != nil { + t.Fatalf("expect no error, got %v", err) + } + + expected := textUnmarshalerStruct{"foo", "bar"} + if actual != expected { + t.Errorf("expected %v, got %v", expected, actual) + } +} + +type binaryUnmarshaler struct { + I, J byte +} + +func (v *binaryUnmarshaler) UnmarshalBinary(b []byte) error { + v.I = b[0] + v.J = b[1] + return nil +} + +func TestUnmarshalBinary(t *testing.T) { + in := &types.AttributeValueMemberB{Value: []byte{1, 2}} + + var actual binaryUnmarshaler + err := UnmarshalWithOptions(in, &actual, func(o *DecoderOptions) { + o.UseEncodingUnmarshalers = true + }) + if err != nil { + t.Fatalf("expect no error, got %v", err) + } + + expected := binaryUnmarshaler{1, 2} + if actual != expected { + t.Errorf("expected %v, got %v", expected, actual) + } +} diff --git a/feature/dynamodbstreams/attributevalue/encode.go b/feature/dynamodbstreams/attributevalue/encode.go index d696d43d2fb..4e9989a70a5 100644 --- a/feature/dynamodbstreams/attributevalue/encode.go +++ b/feature/dynamodbstreams/attributevalue/encode.go @@ -354,8 +354,7 @@ func MarshalListWithOptions(in interface{}, optFns ...func(*EncoderOptions)) ([] return asList.Value, nil } -// EncoderOptions is a collection of options shared between marshaling -// and unmarshaling +// EncoderOptions is a collection of options used by the marshaler. type EncoderOptions struct { // Support other custom struct tag keys, such as `yaml`, `json`, or `toml`. // Note that values provided with a custom TagKey must also be supported @@ -380,6 +379,19 @@ type EncoderOptions struct { // // Default encoding is time.RFC3339Nano in a DynamoDBStreams String (S) data type. EncodeTime func(time.Time) (types.AttributeValue, error) + + // When enabled, the encoder will use implementations of + // encoding.TextMarshaler and encoding.BinaryMarshaler when present on + // marshaled values. + // + // Implementations are checked in the following order: + // - [Marshaler] + // - encoding.TextMarshaler + // - encoding.BinaryMarshaler + // + // The results of a MarshalText call will convert to string (S), results + // from a MarshalBinary call will convert to binary (B). + UseEncodingMarshalers bool } // An Encoder provides marshaling Go value types to AttributeValues. @@ -438,7 +450,7 @@ func (e *Encoder) encode(v reflect.Value, fieldTag tag) (types.AttributeValue, e v = valueElem(v) if v.Kind() != reflect.Invalid { - if av, err := tryMarshaler(v); err != nil { + if av, err := e.tryMarshaler(v); err != nil { return nil, err } else if av != nil { return av, nil @@ -822,7 +834,7 @@ func isNullableZeroValue(v reflect.Value) bool { return false } -func tryMarshaler(v reflect.Value) (types.AttributeValue, error) { +func (e *Encoder) tryMarshaler(v reflect.Value) (types.AttributeValue, error) { if v.Kind() != reflect.Ptr && v.Type().Name() != "" && v.CanAddr() { v = v.Addr() } @@ -831,9 +843,35 @@ func tryMarshaler(v reflect.Value) (types.AttributeValue, error) { return nil, nil } - if m, ok := v.Interface().(Marshaler); ok { + i := v.Interface() + if m, ok := i.(Marshaler); ok { return m.MarshalDynamoDBStreamsAttributeValue() } + if e.options.UseEncodingMarshalers { + return e.tryEncodingMarshaler(i) + } + + return nil, nil +} + +func (e *Encoder) tryEncodingMarshaler(v any) (types.AttributeValue, error) { + if m, ok := v.(encoding.TextMarshaler); ok { + s, err := m.MarshalText() + if err != nil { + return nil, err + } + + return &types.AttributeValueMemberS{Value: string(s)}, nil + } + + if m, ok := v.(encoding.BinaryMarshaler); ok { + b, err := m.MarshalBinary() + if err != nil { + return nil, err + } + + return &types.AttributeValueMemberB{Value: b}, nil + } return nil, nil } diff --git a/feature/dynamodbstreams/attributevalue/encode_test.go b/feature/dynamodbstreams/attributevalue/encode_test.go index 9c0584160a6..56bc3be5186 100644 --- a/feature/dynamodbstreams/attributevalue/encode_test.go +++ b/feature/dynamodbstreams/attributevalue/encode_test.go @@ -94,6 +94,95 @@ func (m customBoolStringMarshaler) MarshalDynamoDBStreamsAttributeValue() (types return &types.AttributeValueMemberS{Value: string(m)}, nil } +type customTextMarshaler struct { + I, J int +} + +func (v customTextMarshaler) MarshalText() ([]byte, error) { + text := fmt.Sprintf("{I: %d, J: %d}", v.I, v.J) + return []byte(text), nil +} + +type customBinaryMarshaler struct { + I, J byte +} + +func (v customBinaryMarshaler) MarshalBinary() ([]byte, error) { + return []byte{v.I, v.J}, nil +} + +type customAVAndTextMarshaler struct { + I, J int +} + +func (v customAVAndTextMarshaler) MarshalDynamoDBStreamsAttributeValue() (types.AttributeValue, error) { + return &types.AttributeValueMemberNS{Value: []string{ + fmt.Sprintf("%d", v.I), + fmt.Sprintf("%d", v.J), + }}, nil +} + +func (v customAVAndTextMarshaler) MarshalText() ([]byte, error) { + return []byte("should never happen"), nil +} + +func TestEncodingMarshalers(t *testing.T) { + cases := []struct { + input any + expected types.AttributeValue + useMarshalers bool + }{ + { + input: customTextMarshaler{1, 2}, + expected: &types.AttributeValueMemberM{Value: map[string]types.AttributeValue{ + "I": &types.AttributeValueMemberN{Value: "1"}, + "J": &types.AttributeValueMemberN{Value: "2"}, + }}, + useMarshalers: false, + }, + { + input: customTextMarshaler{1, 2}, + expected: &types.AttributeValueMemberS{Value: "{I: 1, J: 2}"}, + useMarshalers: true, + }, + { + input: customBinaryMarshaler{1, 2}, + expected: &types.AttributeValueMemberM{Value: map[string]types.AttributeValue{ + "I": &types.AttributeValueMemberN{Value: "1"}, + "J": &types.AttributeValueMemberN{Value: "2"}, + }}, + useMarshalers: false, + }, + { + input: customBinaryMarshaler{1, 2}, + expected: &types.AttributeValueMemberB{Value: []byte{1, 2}}, + useMarshalers: true, + }, + { + input: customAVAndTextMarshaler{1, 2}, + expected: &types.AttributeValueMemberNS{Value: []string{"1", "2"}}, + useMarshalers: false, + }, + { + input: customAVAndTextMarshaler{1, 2}, + expected: &types.AttributeValueMemberNS{Value: []string{"1", "2"}}, + useMarshalers: true, + }, + } + + for _, testCase := range cases { + actual, err := MarshalWithOptions(testCase.input, func(o *EncoderOptions) { + o.UseEncodingMarshalers = testCase.useMarshalers + }) + if err != nil { + t.Errorf("got unexpected error %v for input %v", err, testCase.input) + } + if diff := cmpDiff(testCase.expected, actual); len(diff) != 0 { + t.Errorf("expected match but got: %s", diff) + } + } +} + func TestCustomStringMarshaler(t *testing.T) { cases := []struct { expected types.AttributeValue diff --git a/service/cloud9/internal/endpoints/endpoints.go b/service/cloud9/internal/endpoints/endpoints.go index c8e05a43683..09e19c0d8bd 100644 --- a/service/cloud9/internal/endpoints/endpoints.go +++ b/service/cloud9/internal/endpoints/endpoints.go @@ -142,69 +142,157 @@ var defaultPartitions = endpoints.Partitions{ endpoints.EndpointKey{ Region: "af-south-1", }: endpoints.Endpoint{}, + endpoints.EndpointKey{ + Region: "af-south-1", + Variant: endpoints.DualStackVariant, + }: {}, endpoints.EndpointKey{ Region: "ap-east-1", }: endpoints.Endpoint{}, + endpoints.EndpointKey{ + Region: "ap-east-1", + Variant: endpoints.DualStackVariant, + }: {}, endpoints.EndpointKey{ Region: "ap-northeast-1", }: endpoints.Endpoint{}, + endpoints.EndpointKey{ + Region: "ap-northeast-1", + Variant: endpoints.DualStackVariant, + }: {}, endpoints.EndpointKey{ Region: "ap-northeast-2", }: endpoints.Endpoint{}, + endpoints.EndpointKey{ + Region: "ap-northeast-2", + Variant: endpoints.DualStackVariant, + }: {}, endpoints.EndpointKey{ Region: "ap-northeast-3", }: endpoints.Endpoint{}, + endpoints.EndpointKey{ + Region: "ap-northeast-3", + Variant: endpoints.DualStackVariant, + }: {}, endpoints.EndpointKey{ Region: "ap-south-1", }: endpoints.Endpoint{}, + endpoints.EndpointKey{ + Region: "ap-south-1", + Variant: endpoints.DualStackVariant, + }: {}, endpoints.EndpointKey{ Region: "ap-southeast-1", }: endpoints.Endpoint{}, + endpoints.EndpointKey{ + Region: "ap-southeast-1", + Variant: endpoints.DualStackVariant, + }: {}, endpoints.EndpointKey{ Region: "ap-southeast-2", }: endpoints.Endpoint{}, + endpoints.EndpointKey{ + Region: "ap-southeast-2", + Variant: endpoints.DualStackVariant, + }: {}, endpoints.EndpointKey{ Region: "ca-central-1", }: endpoints.Endpoint{}, + endpoints.EndpointKey{ + Region: "ca-central-1", + Variant: endpoints.DualStackVariant, + }: {}, endpoints.EndpointKey{ Region: "eu-central-1", }: endpoints.Endpoint{}, + endpoints.EndpointKey{ + Region: "eu-central-1", + Variant: endpoints.DualStackVariant, + }: {}, endpoints.EndpointKey{ Region: "eu-north-1", }: endpoints.Endpoint{}, + endpoints.EndpointKey{ + Region: "eu-north-1", + Variant: endpoints.DualStackVariant, + }: {}, endpoints.EndpointKey{ Region: "eu-south-1", }: endpoints.Endpoint{}, + endpoints.EndpointKey{ + Region: "eu-south-1", + Variant: endpoints.DualStackVariant, + }: {}, endpoints.EndpointKey{ Region: "eu-west-1", }: endpoints.Endpoint{}, + endpoints.EndpointKey{ + Region: "eu-west-1", + Variant: endpoints.DualStackVariant, + }: {}, endpoints.EndpointKey{ Region: "eu-west-2", }: endpoints.Endpoint{}, + endpoints.EndpointKey{ + Region: "eu-west-2", + Variant: endpoints.DualStackVariant, + }: {}, endpoints.EndpointKey{ Region: "eu-west-3", }: endpoints.Endpoint{}, + endpoints.EndpointKey{ + Region: "eu-west-3", + Variant: endpoints.DualStackVariant, + }: {}, endpoints.EndpointKey{ Region: "il-central-1", }: endpoints.Endpoint{}, + endpoints.EndpointKey{ + Region: "il-central-1", + Variant: endpoints.DualStackVariant, + }: {}, endpoints.EndpointKey{ Region: "me-south-1", }: endpoints.Endpoint{}, + endpoints.EndpointKey{ + Region: "me-south-1", + Variant: endpoints.DualStackVariant, + }: {}, endpoints.EndpointKey{ Region: "sa-east-1", }: endpoints.Endpoint{}, + endpoints.EndpointKey{ + Region: "sa-east-1", + Variant: endpoints.DualStackVariant, + }: {}, endpoints.EndpointKey{ Region: "us-east-1", }: endpoints.Endpoint{}, + endpoints.EndpointKey{ + Region: "us-east-1", + Variant: endpoints.DualStackVariant, + }: {}, endpoints.EndpointKey{ Region: "us-east-2", }: endpoints.Endpoint{}, + endpoints.EndpointKey{ + Region: "us-east-2", + Variant: endpoints.DualStackVariant, + }: {}, endpoints.EndpointKey{ Region: "us-west-1", }: endpoints.Endpoint{}, + endpoints.EndpointKey{ + Region: "us-west-1", + Variant: endpoints.DualStackVariant, + }: {}, endpoints.EndpointKey{ Region: "us-west-2", }: endpoints.Endpoint{}, + endpoints.EndpointKey{ + Region: "us-west-2", + Variant: endpoints.DualStackVariant, + }: {}, }, }, { diff --git a/service/directconnect/internal/endpoints/endpoints.go b/service/directconnect/internal/endpoints/endpoints.go index 4a35d57e853..45ed398be05 100644 --- a/service/directconnect/internal/endpoints/endpoints.go +++ b/service/directconnect/internal/endpoints/endpoints.go @@ -175,9 +175,21 @@ var defaultPartitions = endpoints.Partitions{ endpoints.EndpointKey{ Region: "ca-central-1", }: endpoints.Endpoint{}, + endpoints.EndpointKey{ + Region: "ca-central-1", + Variant: endpoints.FIPSVariant, + }: { + Hostname: "directconnect-fips.ca-central-1.amazonaws.com", + }, endpoints.EndpointKey{ Region: "ca-west-1", }: endpoints.Endpoint{}, + endpoints.EndpointKey{ + Region: "ca-west-1", + Variant: endpoints.FIPSVariant, + }: { + Hostname: "directconnect-fips.ca-west-1.amazonaws.com", + }, endpoints.EndpointKey{ Region: "eu-central-1", }: endpoints.Endpoint{}, @@ -202,6 +214,24 @@ var defaultPartitions = endpoints.Partitions{ endpoints.EndpointKey{ Region: "eu-west-3", }: endpoints.Endpoint{}, + endpoints.EndpointKey{ + Region: "fips-ca-central-1", + }: endpoints.Endpoint{ + Hostname: "directconnect-fips.ca-central-1.amazonaws.com", + CredentialScope: endpoints.CredentialScope{ + Region: "ca-central-1", + }, + Deprecated: aws.TrueTernary, + }, + endpoints.EndpointKey{ + Region: "fips-ca-west-1", + }: endpoints.Endpoint{ + Hostname: "directconnect-fips.ca-west-1.amazonaws.com", + CredentialScope: endpoints.CredentialScope{ + Region: "ca-west-1", + }, + Deprecated: aws.TrueTernary, + }, endpoints.EndpointKey{ Region: "fips-us-east-1", }: endpoints.Endpoint{ diff --git a/service/globalaccelerator/api_op_UpdateAccelerator.go b/service/globalaccelerator/api_op_UpdateAccelerator.go index 6ceb4b5be06..5ea68adb401 100644 --- a/service/globalaccelerator/api_op_UpdateAccelerator.go +++ b/service/globalaccelerator/api_op_UpdateAccelerator.go @@ -66,6 +66,9 @@ type UpdateAcceleratorInput struct { // the value can be IPV4 or DUAL_STACK. IpAddressType types.IpAddressType + // The IP addresses for an accelerator. + IpAddresses []string + // The name of the accelerator. The name can have a maximum of 64 characters, must // contain only alphanumeric characters, periods (.), or hyphens (-), and must not // begin or end with a hyphen or period. diff --git a/service/globalaccelerator/api_op_UpdateCustomRoutingAccelerator.go b/service/globalaccelerator/api_op_UpdateCustomRoutingAccelerator.go index ae17f16e7f2..201138d6d58 100644 --- a/service/globalaccelerator/api_op_UpdateCustomRoutingAccelerator.go +++ b/service/globalaccelerator/api_op_UpdateCustomRoutingAccelerator.go @@ -45,6 +45,9 @@ type UpdateCustomRoutingAcceleratorInput struct { // accelerator, the value must be IPV4. IpAddressType types.IpAddressType + // The IP addresses for an accelerator. + IpAddresses []string + // The name of the accelerator. The name can have a maximum of 64 characters, must // contain only alphanumeric characters, periods (.), or hyphens (-), and must not // begin or end with a hyphen or period. diff --git a/service/globalaccelerator/serializers.go b/service/globalaccelerator/serializers.go index c1d8796cf86..9fda3e68b83 100644 --- a/service/globalaccelerator/serializers.go +++ b/service/globalaccelerator/serializers.go @@ -4455,6 +4455,13 @@ func awsAwsjson11_serializeOpDocumentUpdateAcceleratorInput(v *UpdateAccelerator ok.Boolean(*v.Enabled) } + if v.IpAddresses != nil { + ok := object.Key("IpAddresses") + if err := awsAwsjson11_serializeDocumentIpAddresses(v.IpAddresses, ok); err != nil { + return err + } + } + if len(v.IpAddressType) > 0 { ok := object.Key("IpAddressType") ok.String(string(v.IpAddressType)) @@ -4554,6 +4561,13 @@ func awsAwsjson11_serializeOpDocumentUpdateCustomRoutingAcceleratorInput(v *Upda ok.Boolean(*v.Enabled) } + if v.IpAddresses != nil { + ok := object.Key("IpAddresses") + if err := awsAwsjson11_serializeDocumentIpAddresses(v.IpAddresses, ok); err != nil { + return err + } + } + if len(v.IpAddressType) > 0 { ok := object.Key("IpAddressType") ok.String(string(v.IpAddressType)) diff --git a/service/glue/api_op_CreateConnection.go b/service/glue/api_op_CreateConnection.go index d3000e63be2..12d8dbb77ac 100644 --- a/service/glue/api_op_CreateConnection.go +++ b/service/glue/api_op_CreateConnection.go @@ -48,6 +48,12 @@ type CreateConnectionInput struct { } type CreateConnectionOutput struct { + + // The status of the connection creation request. The request can take some time + // for certain authentication types, for example when creating an OAuth connection + // with token exchange over VPC. + CreateConnectionStatus types.ConnectionStatus + // Metadata pertaining to the operation's result. ResultMetadata middleware.Metadata diff --git a/service/glue/api_op_CreateJob.go b/service/glue/api_op_CreateJob.go index 54dad036e63..a3ab282a905 100644 --- a/service/glue/api_op_CreateJob.go +++ b/service/glue/api_op_CreateJob.go @@ -199,7 +199,12 @@ type CreateJobInput struct { // The job timeout in minutes. This is the maximum time that a job run can consume // resources before it is terminated and enters TIMEOUT status. The default is - // 2,880 minutes (48 hours). + // 2,880 minutes (48 hours) for batch jobs. + // + // Streaming jobs must have timeout values less than 7 days or 10080 minutes. When + // the value is left blank, the job will be restarted after 7 days based if you + // have not setup a maintenance window. If you have setup maintenance window, it + // will be restarted during the maintenance window after 7 days. Timeout *int32 // The type of predefined worker that is allocated when a job runs. Accepts a diff --git a/service/glue/api_op_StartJobRun.go b/service/glue/api_op_StartJobRun.go index b65e96fe32c..acde62cbcac 100644 --- a/service/glue/api_op_StartJobRun.go +++ b/service/glue/api_op_StartJobRun.go @@ -124,8 +124,10 @@ type StartJobRunInput struct { // consume resources before it is terminated and enters TIMEOUT status. This value // overrides the timeout value set in the parent job. // - // Streaming jobs do not have a timeout. The default for non-streaming jobs is - // 2,880 minutes (48 hours). + // Streaming jobs must have timeout values less than 7 days or 10080 minutes. When + // the value is left blank, the job will be restarted after 7 days based if you + // have not setup a maintenance window. If you have setup maintenance window, it + // will be restarted during the maintenance window after 7 days. Timeout *int32 // The type of predefined worker that is allocated when a job runs. Accepts a diff --git a/service/glue/deserializers.go b/service/glue/deserializers.go index 12058a7f528..051c2bb2e2e 100644 --- a/service/glue/deserializers.go +++ b/service/glue/deserializers.go @@ -27214,6 +27214,60 @@ func awsAwsjson11_deserializeDocumentAthenaConnectorSource(v **types.AthenaConne return nil } +func awsAwsjson11_deserializeDocumentAuthenticationConfiguration(v **types.AuthenticationConfiguration, value interface{}) error { + if v == nil { + return fmt.Errorf("unexpected nil of type %T", v) + } + if value == nil { + return nil + } + + shape, ok := value.(map[string]interface{}) + if !ok { + return fmt.Errorf("unexpected JSON type %v", value) + } + + var sv *types.AuthenticationConfiguration + if *v == nil { + sv = &types.AuthenticationConfiguration{} + } else { + sv = *v + } + + for key, value := range shape { + switch key { + case "AuthenticationType": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected AuthenticationType to be of type string, got %T instead", value) + } + sv.AuthenticationType = types.AuthenticationType(jtv) + } + + case "OAuth2Properties": + if err := awsAwsjson11_deserializeDocumentOAuth2Properties(&sv.OAuth2Properties, value); err != nil { + return err + } + + case "SecretArn": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected SecretArn to be of type string, got %T instead", value) + } + sv.SecretArn = ptr.String(jtv) + } + + default: + _, _ = key, value + + } + } + *v = sv + return nil +} + func awsAwsjson11_deserializeDocumentBackfillError(v **types.BackfillError, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) @@ -31456,6 +31510,11 @@ func awsAwsjson11_deserializeDocumentConnection(v **types.Connection, value inte for key, value := range shape { switch key { + case "AuthenticationConfiguration": + if err := awsAwsjson11_deserializeDocumentAuthenticationConfiguration(&sv.AuthenticationConfiguration, value); err != nil { + return err + } + case "ConnectionProperties": if err := awsAwsjson11_deserializeDocumentConnectionProperties(&sv.ConnectionProperties, value); err != nil { return err @@ -31495,6 +31554,22 @@ func awsAwsjson11_deserializeDocumentConnection(v **types.Connection, value inte sv.Description = ptr.String(jtv) } + case "LastConnectionValidationTime": + if value != nil { + switch jtv := value.(type) { + case json.Number: + f64, err := jtv.Float64() + if err != nil { + return err + } + sv.LastConnectionValidationTime = ptr.Time(smithytime.ParseEpochSeconds(f64)) + + default: + return fmt.Errorf("expected Timestamp to be a JSON Number, got %T instead", value) + + } + } + case "LastUpdatedBy": if value != nil { jtv, ok := value.(string) @@ -31539,6 +31614,24 @@ func awsAwsjson11_deserializeDocumentConnection(v **types.Connection, value inte return err } + case "Status": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected ConnectionStatus to be of type string, got %T instead", value) + } + sv.Status = types.ConnectionStatus(jtv) + } + + case "StatusReason": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected LongValueString to be of type string, got %T instead", value) + } + sv.StatusReason = ptr.String(jtv) + } + default: _, _ = key, value @@ -44292,6 +44385,114 @@ func awsAwsjson11_deserializeDocumentNullValueFields(v *[]types.NullValueField, return nil } +func awsAwsjson11_deserializeDocumentOAuth2ClientApplication(v **types.OAuth2ClientApplication, value interface{}) error { + if v == nil { + return fmt.Errorf("unexpected nil of type %T", v) + } + if value == nil { + return nil + } + + shape, ok := value.(map[string]interface{}) + if !ok { + return fmt.Errorf("unexpected JSON type %v", value) + } + + var sv *types.OAuth2ClientApplication + if *v == nil { + sv = &types.OAuth2ClientApplication{} + } else { + sv = *v + } + + for key, value := range shape { + switch key { + case "AWSManagedClientApplicationReference": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected AWSManagedClientApplicationReference to be of type string, got %T instead", value) + } + sv.AWSManagedClientApplicationReference = ptr.String(jtv) + } + + case "UserManagedClientApplicationClientId": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected UserManagedClientApplicationClientId to be of type string, got %T instead", value) + } + sv.UserManagedClientApplicationClientId = ptr.String(jtv) + } + + default: + _, _ = key, value + + } + } + *v = sv + return nil +} + +func awsAwsjson11_deserializeDocumentOAuth2Properties(v **types.OAuth2Properties, value interface{}) error { + if v == nil { + return fmt.Errorf("unexpected nil of type %T", v) + } + if value == nil { + return nil + } + + shape, ok := value.(map[string]interface{}) + if !ok { + return fmt.Errorf("unexpected JSON type %v", value) + } + + var sv *types.OAuth2Properties + if *v == nil { + sv = &types.OAuth2Properties{} + } else { + sv = *v + } + + for key, value := range shape { + switch key { + case "OAuth2ClientApplication": + if err := awsAwsjson11_deserializeDocumentOAuth2ClientApplication(&sv.OAuth2ClientApplication, value); err != nil { + return err + } + + case "OAuth2GrantType": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected OAuth2GrantType to be of type string, got %T instead", value) + } + sv.OAuth2GrantType = types.OAuth2GrantType(jtv) + } + + case "TokenUrl": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected TokenUrl to be of type string, got %T instead", value) + } + sv.TokenUrl = ptr.String(jtv) + } + + case "TokenUrlParametersMap": + if err := awsAwsjson11_deserializeDocumentTokenUrlParametersMap(&sv.TokenUrlParametersMap, value); err != nil { + return err + } + + default: + _, _ = key, value + + } + } + *v = sv + return nil +} + func awsAwsjson11_deserializeDocumentOneInput(v *[]string, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) @@ -52417,6 +52618,42 @@ func awsAwsjson11_deserializeDocumentTaskRunProperties(v **types.TaskRunProperti return nil } +func awsAwsjson11_deserializeDocumentTokenUrlParametersMap(v *map[string]string, value interface{}) error { + if v == nil { + return fmt.Errorf("unexpected nil of type %T", v) + } + if value == nil { + return nil + } + + shape, ok := value.(map[string]interface{}) + if !ok { + return fmt.Errorf("unexpected JSON type %v", value) + } + + var mv map[string]string + if *v == nil { + mv = map[string]string{} + } else { + mv = *v + } + + for key, value := range shape { + var parsedVal string + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected TokenUrlParameterValue to be of type string, got %T instead", value) + } + parsedVal = jtv + } + mv[key] = parsedVal + + } + *v = mv + return nil +} + func awsAwsjson11_deserializeDocumentTransformConfigParameter(v **types.TransformConfigParameter, value interface{}) error { if v == nil { return fmt.Errorf("unexpected nil of type %T", v) @@ -55265,6 +55502,15 @@ func awsAwsjson11_deserializeOpDocumentCreateConnectionOutput(v **CreateConnecti for key, value := range shape { switch key { + case "CreateConnectionStatus": + if value != nil { + jtv, ok := value.(string) + if !ok { + return fmt.Errorf("expected ConnectionStatus to be of type string, got %T instead", value) + } + sv.CreateConnectionStatus = types.ConnectionStatus(jtv) + } + default: _, _ = key, value diff --git a/service/glue/serializers.go b/service/glue/serializers.go index 792cd6357ed..97549d20d3f 100644 --- a/service/glue/serializers.go +++ b/service/glue/serializers.go @@ -12218,6 +12218,47 @@ func awsAwsjson11_serializeDocumentAuditContext(v *types.AuditContext, value smi return nil } +func awsAwsjson11_serializeDocumentAuthenticationConfigurationInput(v *types.AuthenticationConfigurationInput, value smithyjson.Value) error { + object := value.Object() + defer object.Close() + + if len(v.AuthenticationType) > 0 { + ok := object.Key("AuthenticationType") + ok.String(string(v.AuthenticationType)) + } + + if v.OAuth2Properties != nil { + ok := object.Key("OAuth2Properties") + if err := awsAwsjson11_serializeDocumentOAuth2PropertiesInput(v.OAuth2Properties, ok); err != nil { + return err + } + } + + if v.SecretArn != nil { + ok := object.Key("SecretArn") + ok.String(*v.SecretArn) + } + + return nil +} + +func awsAwsjson11_serializeDocumentAuthorizationCodeProperties(v *types.AuthorizationCodeProperties, value smithyjson.Value) error { + object := value.Object() + defer object.Close() + + if v.AuthorizationCode != nil { + ok := object.Key("AuthorizationCode") + ok.String(*v.AuthorizationCode) + } + + if v.RedirectUri != nil { + ok := object.Key("RedirectUri") + ok.String(*v.RedirectUri) + } + + return nil +} + func awsAwsjson11_serializeDocumentBasicCatalogTarget(v *types.BasicCatalogTarget, value smithyjson.Value) error { object := value.Object() defer object.Close() @@ -13585,6 +13626,13 @@ func awsAwsjson11_serializeDocumentConnectionInput(v *types.ConnectionInput, val object := value.Object() defer object.Close() + if v.AuthenticationConfiguration != nil { + ok := object.Key("AuthenticationConfiguration") + if err := awsAwsjson11_serializeDocumentAuthenticationConfigurationInput(v.AuthenticationConfiguration, ok); err != nil { + return err + } + } + if v.ConnectionProperties != nil { ok := object.Key("ConnectionProperties") if err := awsAwsjson11_serializeDocumentConnectionProperties(v.ConnectionProperties, ok); err != nil { @@ -13621,6 +13669,11 @@ func awsAwsjson11_serializeDocumentConnectionInput(v *types.ConnectionInput, val } } + if v.ValidateCredentials { + ok := object.Key("ValidateCredentials") + ok.Boolean(v.ValidateCredentials) + } + return nil } @@ -17053,6 +17106,61 @@ func awsAwsjson11_serializeDocumentNullValueFields(v []types.NullValueField, val return nil } +func awsAwsjson11_serializeDocumentOAuth2ClientApplication(v *types.OAuth2ClientApplication, value smithyjson.Value) error { + object := value.Object() + defer object.Close() + + if v.AWSManagedClientApplicationReference != nil { + ok := object.Key("AWSManagedClientApplicationReference") + ok.String(*v.AWSManagedClientApplicationReference) + } + + if v.UserManagedClientApplicationClientId != nil { + ok := object.Key("UserManagedClientApplicationClientId") + ok.String(*v.UserManagedClientApplicationClientId) + } + + return nil +} + +func awsAwsjson11_serializeDocumentOAuth2PropertiesInput(v *types.OAuth2PropertiesInput, value smithyjson.Value) error { + object := value.Object() + defer object.Close() + + if v.AuthorizationCodeProperties != nil { + ok := object.Key("AuthorizationCodeProperties") + if err := awsAwsjson11_serializeDocumentAuthorizationCodeProperties(v.AuthorizationCodeProperties, ok); err != nil { + return err + } + } + + if v.OAuth2ClientApplication != nil { + ok := object.Key("OAuth2ClientApplication") + if err := awsAwsjson11_serializeDocumentOAuth2ClientApplication(v.OAuth2ClientApplication, ok); err != nil { + return err + } + } + + if len(v.OAuth2GrantType) > 0 { + ok := object.Key("OAuth2GrantType") + ok.String(string(v.OAuth2GrantType)) + } + + if v.TokenUrl != nil { + ok := object.Key("TokenUrl") + ok.String(*v.TokenUrl) + } + + if v.TokenUrlParametersMap != nil { + ok := object.Key("TokenUrlParametersMap") + if err := awsAwsjson11_serializeDocumentTokenUrlParametersMap(v.TokenUrlParametersMap, ok); err != nil { + return err + } + } + + return nil +} + func awsAwsjson11_serializeDocumentOneInput(v []string, value smithyjson.Value) error { array := value.Array() defer array.Close() @@ -19897,6 +20005,17 @@ func awsAwsjson11_serializeDocumentTaskRunSortCriteria(v *types.TaskRunSortCrite return nil } +func awsAwsjson11_serializeDocumentTokenUrlParametersMap(v map[string]string, value smithyjson.Value) error { + object := value.Object() + defer object.Close() + + for key := range v { + om := object.Key(key) + om.String(v[key]) + } + return nil +} + func awsAwsjson11_serializeDocumentTransformConfigParameter(v *types.TransformConfigParameter, value smithyjson.Value) error { object := value.Object() defer object.Close() diff --git a/service/glue/types/enums.go b/service/glue/types/enums.go index 8888eda0e0e..308f25d9128 100644 --- a/service/glue/types/enums.go +++ b/service/glue/types/enums.go @@ -66,6 +66,27 @@ func (AggFunction) Values() []AggFunction { } } +type AuthenticationType string + +// Enum values for AuthenticationType +const ( + AuthenticationTypeBasic AuthenticationType = "BASIC" + AuthenticationTypeOauth2 AuthenticationType = "OAUTH2" + AuthenticationTypeCustom AuthenticationType = "CUSTOM" +) + +// Values returns all known values for AuthenticationType. Note that this can be +// expanded in the future, and so it is only as up to date as the client. +// +// The ordering of this slice is not guaranteed to be stable across updates. +func (AuthenticationType) Values() []AuthenticationType { + return []AuthenticationType{ + "BASIC", + "OAUTH2", + "CUSTOM", + } +} + type BackfillErrorCode string // Enum values for BackfillErrorCode @@ -352,6 +373,7 @@ const ( ConnectionPropertyKeyKafkaSaslGssapiKrb5Conf ConnectionPropertyKey = "KAFKA_SASL_GSSAPI_KRB5_CONF" ConnectionPropertyKeyKafkaSaslGssapiService ConnectionPropertyKey = "KAFKA_SASL_GSSAPI_SERVICE" ConnectionPropertyKeyKafkaSaslGssapiPrincipal ConnectionPropertyKey = "KAFKA_SASL_GSSAPI_PRINCIPAL" + ConnectionPropertyKeyRoleArn ConnectionPropertyKey = "ROLE_ARN" ) // Values returns all known values for ConnectionPropertyKey. Note that this can @@ -402,6 +424,28 @@ func (ConnectionPropertyKey) Values() []ConnectionPropertyKey { "KAFKA_SASL_GSSAPI_KRB5_CONF", "KAFKA_SASL_GSSAPI_SERVICE", "KAFKA_SASL_GSSAPI_PRINCIPAL", + "ROLE_ARN", + } +} + +type ConnectionStatus string + +// Enum values for ConnectionStatus +const ( + ConnectionStatusReady ConnectionStatus = "READY" + ConnectionStatusInProgress ConnectionStatus = "IN_PROGRESS" + ConnectionStatusFailed ConnectionStatus = "FAILED" +) + +// Values returns all known values for ConnectionStatus. Note that this can be +// expanded in the future, and so it is only as up to date as the client. +// +// The ordering of this slice is not guaranteed to be stable across updates. +func (ConnectionStatus) Values() []ConnectionStatus { + return []ConnectionStatus{ + "READY", + "IN_PROGRESS", + "FAILED", } } @@ -416,6 +460,7 @@ const ( ConnectionTypeNetwork ConnectionType = "NETWORK" ConnectionTypeMarketplace ConnectionType = "MARKETPLACE" ConnectionTypeCustom ConnectionType = "CUSTOM" + ConnectionTypeSalesforce ConnectionType = "SALESFORCE" ) // Values returns all known values for ConnectionType. Note that this can be @@ -431,6 +476,7 @@ func (ConnectionType) Values() []ConnectionType { "NETWORK", "MARKETPLACE", "CUSTOM", + "SALESFORCE", } } @@ -749,10 +795,15 @@ type FederationSourceErrorCode string // Enum values for FederationSourceErrorCode const ( + FederationSourceErrorCodeAccessDeniedException FederationSourceErrorCode = "AccessDeniedException" + FederationSourceErrorCodeEntityNotFoundException FederationSourceErrorCode = "EntityNotFoundException" + FederationSourceErrorCodeInvalidCredentialsException FederationSourceErrorCode = "InvalidCredentialsException" + FederationSourceErrorCodeInvalidInputException FederationSourceErrorCode = "InvalidInputException" FederationSourceErrorCodeInvalidResponseException FederationSourceErrorCode = "InvalidResponseException" FederationSourceErrorCodeOperationTimeoutException FederationSourceErrorCode = "OperationTimeoutException" FederationSourceErrorCodeOperationNotSupportedException FederationSourceErrorCode = "OperationNotSupportedException" FederationSourceErrorCodeInternalServiceException FederationSourceErrorCode = "InternalServiceException" + FederationSourceErrorCodePartialFailureException FederationSourceErrorCode = "PartialFailureException" FederationSourceErrorCodeThrottlingException FederationSourceErrorCode = "ThrottlingException" ) @@ -762,10 +813,15 @@ const ( // The ordering of this slice is not guaranteed to be stable across updates. func (FederationSourceErrorCode) Values() []FederationSourceErrorCode { return []FederationSourceErrorCode{ + "AccessDeniedException", + "EntityNotFoundException", + "InvalidCredentialsException", + "InvalidInputException", "InvalidResponseException", "OperationTimeoutException", "OperationNotSupportedException", "InternalServiceException", + "PartialFailureException", "ThrottlingException", } } @@ -1320,6 +1376,27 @@ func (NodeType) Values() []NodeType { } } +type OAuth2GrantType string + +// Enum values for OAuth2GrantType +const ( + OAuth2GrantTypeAuthorizationCode OAuth2GrantType = "AUTHORIZATION_CODE" + OAuth2GrantTypeClientCredentials OAuth2GrantType = "CLIENT_CREDENTIALS" + OAuth2GrantTypeJwtBearer OAuth2GrantType = "JWT_BEARER" +) + +// Values returns all known values for OAuth2GrantType. Note that this can be +// expanded in the future, and so it is only as up to date as the client. +// +// The ordering of this slice is not guaranteed to be stable across updates. +func (OAuth2GrantType) Values() []OAuth2GrantType { + return []OAuth2GrantType{ + "AUTHORIZATION_CODE", + "CLIENT_CREDENTIALS", + "JWT_BEARER", + } +} + type ParamType string // Enum values for ParamType diff --git a/service/glue/types/types.go b/service/glue/types/types.go index 65271d720c2..4e59eb0dc2b 100644 --- a/service/glue/types/types.go +++ b/service/glue/types/types.go @@ -308,6 +308,56 @@ type AuditContext struct { noSmithyDocumentSerde } +// A structure containing the authentication configuration. +type AuthenticationConfiguration struct { + + // A structure containing the authentication configuration. + AuthenticationType AuthenticationType + + // The properties for OAuth2 authentication. + OAuth2Properties *OAuth2Properties + + // The secret manager ARN to store credentials. + SecretArn *string + + noSmithyDocumentSerde +} + +// A structure containing the authentication configuration in the CreateConnection +// request. +type AuthenticationConfigurationInput struct { + + // A structure containing the authentication configuration in the CreateConnection + // request. + AuthenticationType AuthenticationType + + // The properties for OAuth2 authentication in the CreateConnection request. + OAuth2Properties *OAuth2PropertiesInput + + // The secret manager ARN to store credentials in the CreateConnection request. + SecretArn *string + + noSmithyDocumentSerde +} + +// The set of properties required for the the OAuth2 AUTHORIZATION_CODE grant type +// workflow. +type AuthorizationCodeProperties struct { + + // An authorization code to be used in the third leg of the AUTHORIZATION_CODE + // grant workflow. This is a single-use code which becomes invalid once exchanged + // for an access token, thus it is acceptable to have this value as a request + // parameter. + AuthorizationCode *string + + // The redirect URI where the user gets redirected to by authorization server when + // issuing an authorization code. The URI is subsequently used when the + // authorization code is exchanged for an access token. + RedirectUri *string + + noSmithyDocumentSerde +} + // A list of errors that can occur when registering partition indexes for an // existing table. // @@ -1446,6 +1496,9 @@ type ConfusionMatrix struct { // Defines a connection to a data source. type Connection struct { + // The authentication properties of the connection. + AuthenticationConfiguration *AuthenticationConfiguration + // These key-value pairs define parameters for the connection: // // - HOST - The host URI: either the fully qualified domain name (FQDN) or the @@ -1593,16 +1646,19 @@ type Connection struct { // The type of the connection. Currently, SFTP is not supported. ConnectionType ConnectionType - // The time that this connection definition was created. + // The timestamp of the time that this connection definition was created. CreationTime *time.Time // The description of the connection. Description *string + // A timestamp of the time this connection was last validated. + LastConnectionValidationTime *time.Time + // The user, group, or role that last updated this connection definition. LastUpdatedBy *string - // The last time that this connection definition was updated. + // The timestamp of the last time the connection definition was updated. LastUpdatedTime *time.Time // A list of criteria that can be used in selecting this connection. @@ -1611,10 +1667,16 @@ type Connection struct { // The name of the connection definition. Name *string - // A map of physical connection requirements, such as virtual private cloud (VPC) - // and SecurityGroup , that are needed to make this connection successfully. + // The physical connection requirements, such as virtual private cloud (VPC) and + // SecurityGroup , that are needed to make this connection successfully. PhysicalConnectionRequirements *PhysicalConnectionRequirements + // The status of the connection. Can be one of: READY , IN_PROGRESS , or FAILED . + Status ConnectionStatus + + // The reason for the connection status. + StatusReason *string + noSmithyDocumentSerde } @@ -1675,6 +1737,10 @@ type ConnectionInput struct { // // - Required: All of ( USERNAME , PASSWORD ) or SECRET_ID . // + // - SALESFORCE - Designates a connection to Salesforce using OAuth authencation. + // + // - Requires the AuthenticationConfiguration member to be configured. + // // - NETWORK - Designates a network connection to a data source within an Amazon // Virtual Private Cloud environment (Amazon VPC). // @@ -1710,22 +1776,29 @@ type ConnectionInput struct { // This member is required. ConnectionType ConnectionType - // The name of the connection. Connection will not function as expected without a - // name. + // The name of the connection. // // This member is required. Name *string + // The authentication properties of the connection. Used for a Salesforce + // connection. + AuthenticationConfiguration *AuthenticationConfigurationInput + // The description of the connection. Description *string // A list of criteria that can be used in selecting this connection. MatchCriteria []string - // A map of physical connection requirements, such as virtual private cloud (VPC) - // and SecurityGroup , that are needed to successfully make this connection. + // The physical connection requirements, such as virtual private cloud (VPC) and + // SecurityGroup , that are needed to successfully make this connection. PhysicalConnectionRequirements *PhysicalConnectionRequirements + // A flag to validate the credentials during create connection. Used for a + // Salesforce connection. Default is true. + ValidateCredentials bool + noSmithyDocumentSerde } @@ -4361,7 +4434,12 @@ type Job struct { // The job timeout in minutes. This is the maximum time that a job run can consume // resources before it is terminated and enters TIMEOUT status. The default is - // 2,880 minutes (48 hours). + // 2,880 minutes (48 hours) for batch jobs. + // + // Streaming jobs must have timeout values less than 7 days or 10080 minutes. When + // the value is left blank, the job will be restarted after 7 days based if you + // have not setup a maintenance window. If you have setup maintenance window, it + // will be restarted during the maintenance window after 7 days. Timeout *int32 // The type of predefined worker that is allocated when a job runs. Accepts a @@ -4666,13 +4744,6 @@ type JobRun struct { // consume resources before it is terminated and enters TIMEOUT status. This value // overrides the timeout value set in the parent job. // - // The maximum value for timeout for batch jobs is 7 days or 10080 minutes. The - // default is 2880 minutes (48 hours) for batch jobs. - // - // Any existing Glue jobs that have a greater timeout value are defaulted to 7 - // days. For instance you have specified a timeout of 20 days for a batch job, it - // will be stopped on the 7th day. - // // Streaming jobs must have timeout values less than 7 days or 10080 minutes. When // the value is left blank, the job will be restarted after 7 days based if you // have not setup a maintenance window. If you have setup maintenance window, it @@ -4887,7 +4958,12 @@ type JobUpdate struct { // The job timeout in minutes. This is the maximum time that a job run can consume // resources before it is terminated and enters TIMEOUT status. The default is - // 2,880 minutes (48 hours). + // 2,880 minutes (48 hours) for batch jobs. + // + // Streaming jobs must have timeout values less than 7 days or 10080 minutes. When + // the value is left blank, the job will be restarted after 7 days based if you + // have not setup a maintenance window. If you have setup maintenance window, it + // will be restarted during the maintenance window after 7 days. Timeout *int32 // The type of predefined worker that is allocated when a job runs. Accepts a @@ -5827,6 +5903,62 @@ type NullValueField struct { noSmithyDocumentSerde } +// The OAuth2 client app used for the connection. +type OAuth2ClientApplication struct { + + // The reference to the SaaS-side client app that is Amazon Web Services managed. + AWSManagedClientApplicationReference *string + + // The client application clientID if the ClientAppType is USER_MANAGED . + UserManagedClientApplicationClientId *string + + noSmithyDocumentSerde +} + +// A structure containing properties for OAuth2 authentication. +type OAuth2Properties struct { + + // The client application type. For example, AWS_MANAGED or USER_MANAGED. + OAuth2ClientApplication *OAuth2ClientApplication + + // The OAuth2 grant type. For example, AUTHORIZATION_CODE , JWT_BEARER , or + // CLIENT_CREDENTIALS . + OAuth2GrantType OAuth2GrantType + + // The URL of the provider's authentication server, to exchange an authorization + // code for an access token. + TokenUrl *string + + // A map of parameters that are added to the token GET request. + TokenUrlParametersMap map[string]string + + noSmithyDocumentSerde +} + +// A structure containing properties for OAuth2 in the CreateConnection request. +type OAuth2PropertiesInput struct { + + // The set of properties required for the the OAuth2 AUTHORIZATION_CODE grant type. + AuthorizationCodeProperties *AuthorizationCodeProperties + + // The client application type in the CreateConnection request. For example, + // AWS_MANAGED or USER_MANAGED . + OAuth2ClientApplication *OAuth2ClientApplication + + // The OAuth2 grant type in the CreateConnection request. For example, + // AUTHORIZATION_CODE , JWT_BEARER , or CLIENT_CREDENTIALS . + OAuth2GrantType OAuth2GrantType + + // The URL of the provider's authentication server, to exchange an authorization + // code for an access token. + TokenUrl *string + + // A map of parameters that are added to the token GET request. + TokenUrlParametersMap map[string]string + + noSmithyDocumentSerde +} + // A structure representing an open format table. type OpenTableFormatInput struct { @@ -6066,12 +6198,10 @@ type PartitionValueList struct { noSmithyDocumentSerde } -// Specifies the physical requirements for a connection. +// The OAuth client app in GetConnection response. type PhysicalConnectionRequirements struct { - // The connection's Availability Zone. This field is redundant because the - // specified subnet implies the Availability Zone to be used. Currently the field - // must be populated, but it will be deprecated in the future. + // The connection's Availability Zone. AvailabilityZone *string // The security group ID list used by the connection. @@ -8880,7 +9010,8 @@ type ViewRepresentation struct { // query on a view. Engines may perform operations during view creation to // transform ViewOriginalText to ViewExpandedText . For example: // - // - Fully qualify identifiers: SELECT * from table1 → SELECT * from db1.table1 + // - Fully qualified identifiers: SELECT * from table1 -> SELECT * from + // db1.table1 ViewExpandedText *string // The SELECT query provided by the customer during CREATE VIEW DDL . This SQL is diff --git a/service/s3/api_op_CopyObject.go b/service/s3/api_op_CopyObject.go index bae0b7cb499..824a9c816bd 100644 --- a/service/s3/api_op_CopyObject.go +++ b/service/s3/api_op_CopyObject.go @@ -736,6 +736,8 @@ type CopyObjectInput struct { func (in *CopyObjectInput) bindEndpointParams(p *EndpointParameters) { p.Bucket = in.Bucket + p.CopySource = in.CopySource + p.Key = in.Key p.DisableS3ExpressSessionAuth = ptr.Bool(true) } diff --git a/service/s3/endpoints.go b/service/s3/endpoints.go index e6ae2e8729a..39f416bcf87 100644 --- a/service/s3/endpoints.go +++ b/service/s3/endpoints.go @@ -326,6 +326,13 @@ type EndpointParameters struct { // is required. Prefix *string + // The Copy Source used for Copy Object request. This is an optional parameter that + // will be set automatically for operations that are scoped to Copy + // Source. + // + // Parameter is required. + CopySource *string + // Internal parameter to disable Access Point Buckets // // Parameter is required. diff --git a/service/s3/endpoints_test.go b/service/s3/endpoints_test.go index a2011e0466a..feb96c3350c 100644 --- a/service/s3/endpoints_test.go +++ b/service/s3/endpoints_test.go @@ -2545,8 +2545,69 @@ func TestEndpointCase56(t *testing.T) { } } -// virtual addressing, aws-global region with fips uses the regional fips endpoint +// virtual addressing, aws-global region with Copy Source, and Key uses the global +// endpoint. Copy Source and Key parameters should not be used in endpoint +// evaluation. func TestEndpointCase57(t *testing.T) { + var params = EndpointParameters{ + Region: ptr.String("aws-global"), + Bucket: ptr.String("bucket-name"), + UseFIPS: ptr.Bool(false), + UseDualStack: ptr.Bool(false), + Accelerate: ptr.Bool(false), + CopySource: ptr.String("/copy/source"), + Key: ptr.String("key"), + } + + resolver := NewDefaultEndpointResolverV2() + result, err := resolver.ResolveEndpoint(context.Background(), params) + _, _ = result, err + + if err != nil { + t.Fatalf("expect no error, got %v", err) + } + + uri, _ := url.Parse("https://bucket-name.s3.amazonaws.com") + + expectEndpoint := smithyendpoints.Endpoint{ + URI: *uri, + Headers: http.Header{}, + Properties: func() smithy.Properties { + var out smithy.Properties + smithyauth.SetAuthOptions(&out, []*smithyauth.Option{ + { + SchemeID: "aws.auth#sigv4", + SignerProperties: func() smithy.Properties { + var sp smithy.Properties + smithyhttp.SetSigV4SigningName(&sp, "s3") + smithyhttp.SetSigV4ASigningName(&sp, "s3") + + smithyhttp.SetSigV4SigningRegion(&sp, "us-east-1") + + smithyhttp.SetDisableDoubleEncoding(&sp, true) + return sp + }(), + }, + }) + return out + }(), + } + + if e, a := expectEndpoint.URI, result.URI; e != a { + t.Errorf("expect %v URI, got %v", e, a) + } + + if !reflect.DeepEqual(expectEndpoint.Headers, result.Headers) { + t.Errorf("expect headers to match\n%v != %v", expectEndpoint.Headers, result.Headers) + } + + if !reflect.DeepEqual(expectEndpoint.Properties, result.Properties) { + t.Errorf("expect properties to match\n%v != %v", expectEndpoint.Properties, result.Properties) + } +} + +// virtual addressing, aws-global region with fips uses the regional fips endpoint +func TestEndpointCase58(t *testing.T) { var params = EndpointParameters{ Region: ptr.String("aws-global"), Bucket: ptr.String("bucket-name"), @@ -2604,7 +2665,7 @@ func TestEndpointCase57(t *testing.T) { // virtual addressing, aws-global region with dualstack uses the regional dualstack // endpoint -func TestEndpointCase58(t *testing.T) { +func TestEndpointCase59(t *testing.T) { var params = EndpointParameters{ Region: ptr.String("aws-global"), Bucket: ptr.String("bucket-name"), @@ -2662,7 +2723,7 @@ func TestEndpointCase58(t *testing.T) { // virtual addressing, aws-global region with fips/dualstack uses the regional // fips/dualstack endpoint -func TestEndpointCase59(t *testing.T) { +func TestEndpointCase60(t *testing.T) { var params = EndpointParameters{ Region: ptr.String("aws-global"), Bucket: ptr.String("bucket-name"), @@ -2720,7 +2781,7 @@ func TestEndpointCase59(t *testing.T) { // virtual addressing, aws-global region with accelerate uses the global accelerate // endpoint -func TestEndpointCase60(t *testing.T) { +func TestEndpointCase61(t *testing.T) { var params = EndpointParameters{ Region: ptr.String("aws-global"), Bucket: ptr.String("bucket-name"), @@ -2777,7 +2838,7 @@ func TestEndpointCase60(t *testing.T) { } // virtual addressing, aws-global region with custom endpoint -func TestEndpointCase61(t *testing.T) { +func TestEndpointCase62(t *testing.T) { var params = EndpointParameters{ Region: ptr.String("aws-global"), Endpoint: ptr.String("https://example.com"), @@ -2836,7 +2897,7 @@ func TestEndpointCase61(t *testing.T) { // virtual addressing, UseGlobalEndpoint and us-east-1 region uses the global // endpoint -func TestEndpointCase62(t *testing.T) { +func TestEndpointCase63(t *testing.T) { var params = EndpointParameters{ Region: ptr.String("us-east-1"), UseGlobalEndpoint: ptr.Bool(true), @@ -2895,7 +2956,7 @@ func TestEndpointCase62(t *testing.T) { // virtual addressing, UseGlobalEndpoint and us-west-2 region uses the regional // endpoint -func TestEndpointCase63(t *testing.T) { +func TestEndpointCase64(t *testing.T) { var params = EndpointParameters{ Region: ptr.String("us-west-2"), UseGlobalEndpoint: ptr.Bool(true), @@ -2954,7 +3015,7 @@ func TestEndpointCase63(t *testing.T) { // virtual addressing, UseGlobalEndpoint and us-east-1 region and fips uses the // regional fips endpoint -func TestEndpointCase64(t *testing.T) { +func TestEndpointCase65(t *testing.T) { var params = EndpointParameters{ Region: ptr.String("us-east-1"), UseGlobalEndpoint: ptr.Bool(true), @@ -3013,7 +3074,7 @@ func TestEndpointCase64(t *testing.T) { // virtual addressing, UseGlobalEndpoint and us-east-1 region and dualstack uses // the regional dualstack endpoint -func TestEndpointCase65(t *testing.T) { +func TestEndpointCase66(t *testing.T) { var params = EndpointParameters{ Region: ptr.String("us-east-1"), UseGlobalEndpoint: ptr.Bool(true), @@ -3072,7 +3133,7 @@ func TestEndpointCase65(t *testing.T) { // virtual addressing, UseGlobalEndpoint and us-east-1 region and accelerate uses // the global accelerate endpoint -func TestEndpointCase66(t *testing.T) { +func TestEndpointCase67(t *testing.T) { var params = EndpointParameters{ Region: ptr.String("us-east-1"), UseGlobalEndpoint: ptr.Bool(true), @@ -3130,7 +3191,7 @@ func TestEndpointCase66(t *testing.T) { } // virtual addressing, UseGlobalEndpoint and us-east-1 region with custom endpoint -func TestEndpointCase67(t *testing.T) { +func TestEndpointCase68(t *testing.T) { var params = EndpointParameters{ Region: ptr.String("us-east-1"), Endpoint: ptr.String("https://example.com"), @@ -3189,7 +3250,7 @@ func TestEndpointCase67(t *testing.T) { } // ForcePathStyle, aws-global region uses the global endpoint -func TestEndpointCase68(t *testing.T) { +func TestEndpointCase69(t *testing.T) { var params = EndpointParameters{ Region: ptr.String("aws-global"), Bucket: ptr.String("bucket-name"), @@ -3247,7 +3308,7 @@ func TestEndpointCase68(t *testing.T) { } // ForcePathStyle, aws-global region with fips is invalid -func TestEndpointCase69(t *testing.T) { +func TestEndpointCase70(t *testing.T) { var params = EndpointParameters{ Region: ptr.String("aws-global"), Bucket: ptr.String("bucket-name"), @@ -3306,7 +3367,7 @@ func TestEndpointCase69(t *testing.T) { // ForcePathStyle, aws-global region with dualstack uses regional dualstack // endpoint -func TestEndpointCase70(t *testing.T) { +func TestEndpointCase71(t *testing.T) { var params = EndpointParameters{ Region: ptr.String("aws-global"), Bucket: ptr.String("bucket-name"), @@ -3364,7 +3425,7 @@ func TestEndpointCase70(t *testing.T) { } // ForcePathStyle, aws-global region custom endpoint uses the custom endpoint -func TestEndpointCase71(t *testing.T) { +func TestEndpointCase72(t *testing.T) { var params = EndpointParameters{ Region: ptr.String("aws-global"), Endpoint: ptr.String("https://example.com"), @@ -3423,7 +3484,7 @@ func TestEndpointCase71(t *testing.T) { } // ForcePathStyle, UseGlobalEndpoint us-east-1 region uses the global endpoint -func TestEndpointCase72(t *testing.T) { +func TestEndpointCase73(t *testing.T) { var params = EndpointParameters{ Region: ptr.String("us-east-1"), Bucket: ptr.String("bucket-name"), @@ -3482,7 +3543,7 @@ func TestEndpointCase72(t *testing.T) { } // ForcePathStyle, UseGlobalEndpoint us-west-2 region uses the regional endpoint -func TestEndpointCase73(t *testing.T) { +func TestEndpointCase74(t *testing.T) { var params = EndpointParameters{ Region: ptr.String("us-west-2"), Bucket: ptr.String("bucket-name"), @@ -3542,7 +3603,7 @@ func TestEndpointCase73(t *testing.T) { // ForcePathStyle, UseGlobalEndpoint us-east-1 region, dualstack uses the regional // dualstack endpoint -func TestEndpointCase74(t *testing.T) { +func TestEndpointCase75(t *testing.T) { var params = EndpointParameters{ Region: ptr.String("us-east-1"), Bucket: ptr.String("bucket-name"), @@ -3602,7 +3663,7 @@ func TestEndpointCase74(t *testing.T) { // ForcePathStyle, UseGlobalEndpoint us-east-1 region custom endpoint uses the // custom endpoint -func TestEndpointCase75(t *testing.T) { +func TestEndpointCase76(t *testing.T) { var params = EndpointParameters{ Region: ptr.String("us-east-1"), Bucket: ptr.String("bucket-name"), @@ -3662,7 +3723,7 @@ func TestEndpointCase75(t *testing.T) { } // ARN with aws-global region and UseArnRegion uses the regional endpoint -func TestEndpointCase76(t *testing.T) { +func TestEndpointCase77(t *testing.T) { var params = EndpointParameters{ Region: ptr.String("aws-global"), UseArnRegion: ptr.Bool(true), @@ -3733,7 +3794,7 @@ func TestEndpointCase76(t *testing.T) { } // cross partition MRAP ARN is an error -func TestEndpointCase77(t *testing.T) { +func TestEndpointCase78(t *testing.T) { var params = EndpointParameters{ Bucket: ptr.String("arn:aws-cn:s3::123456789012:accesspoint:mfzwi23gnjvgw.mrap"), Region: ptr.String("us-west-1"), @@ -3752,7 +3813,7 @@ func TestEndpointCase77(t *testing.T) { } // Endpoint override, accesspoint with HTTP, port -func TestEndpointCase78(t *testing.T) { +func TestEndpointCase79(t *testing.T) { var params = EndpointParameters{ Endpoint: ptr.String("http://beta.example.com:1234"), Region: ptr.String("us-west-2"), @@ -3807,7 +3868,7 @@ func TestEndpointCase78(t *testing.T) { } // Endpoint override, accesspoint with http, path, query, and port -func TestEndpointCase79(t *testing.T) { +func TestEndpointCase80(t *testing.T) { var params = EndpointParameters{ Region: ptr.String("us-west-2"), Bucket: ptr.String("arn:aws:s3:us-west-2:123456789012:accesspoint:myendpoint"), @@ -3865,7 +3926,7 @@ func TestEndpointCase79(t *testing.T) { } // non-bucket endpoint override with FIPS = error -func TestEndpointCase80(t *testing.T) { +func TestEndpointCase81(t *testing.T) { var params = EndpointParameters{ Region: ptr.String("us-west-2"), Endpoint: ptr.String("http://beta.example.com:1234/path"), @@ -3886,7 +3947,7 @@ func TestEndpointCase80(t *testing.T) { } // FIPS + dualstack + custom endpoint -func TestEndpointCase81(t *testing.T) { +func TestEndpointCase82(t *testing.T) { var params = EndpointParameters{ Region: ptr.String("us-west-2"), Endpoint: ptr.String("http://beta.example.com:1234/path"), @@ -3907,7 +3968,7 @@ func TestEndpointCase81(t *testing.T) { } // dualstack + custom endpoint -func TestEndpointCase82(t *testing.T) { +func TestEndpointCase83(t *testing.T) { var params = EndpointParameters{ Region: ptr.String("us-west-2"), Endpoint: ptr.String("http://beta.example.com:1234/path"), @@ -3928,7 +3989,7 @@ func TestEndpointCase82(t *testing.T) { } // custom endpoint without FIPS/dualstack -func TestEndpointCase83(t *testing.T) { +func TestEndpointCase84(t *testing.T) { var params = EndpointParameters{ Region: ptr.String("us-west-2"), Endpoint: ptr.String("http://beta.example.com:1234/path"), @@ -3984,7 +4045,7 @@ func TestEndpointCase83(t *testing.T) { } // s3 object lambda with access points disabled -func TestEndpointCase84(t *testing.T) { +func TestEndpointCase85(t *testing.T) { var params = EndpointParameters{ Region: ptr.String("us-west-2"), Bucket: ptr.String("arn:aws:s3-object-lambda:us-west-2:123456789012:accesspoint:myendpoint"), @@ -4004,7 +4065,7 @@ func TestEndpointCase84(t *testing.T) { } // non bucket + FIPS -func TestEndpointCase85(t *testing.T) { +func TestEndpointCase86(t *testing.T) { var params = EndpointParameters{ Region: ptr.String("us-west-2"), UseFIPS: ptr.Bool(true), @@ -4059,7 +4120,7 @@ func TestEndpointCase85(t *testing.T) { } // standard non bucket endpoint -func TestEndpointCase86(t *testing.T) { +func TestEndpointCase87(t *testing.T) { var params = EndpointParameters{ Region: ptr.String("us-west-2"), UseFIPS: ptr.Bool(false), @@ -4114,7 +4175,7 @@ func TestEndpointCase86(t *testing.T) { } // non bucket endpoint with FIPS + Dualstack -func TestEndpointCase87(t *testing.T) { +func TestEndpointCase88(t *testing.T) { var params = EndpointParameters{ Region: ptr.String("us-west-2"), UseFIPS: ptr.Bool(true), @@ -4169,7 +4230,7 @@ func TestEndpointCase87(t *testing.T) { } // non bucket endpoint with dualstack -func TestEndpointCase88(t *testing.T) { +func TestEndpointCase89(t *testing.T) { var params = EndpointParameters{ Region: ptr.String("us-west-2"), UseFIPS: ptr.Bool(false), @@ -4224,7 +4285,7 @@ func TestEndpointCase88(t *testing.T) { } // use global endpoint + IP address endpoint override -func TestEndpointCase89(t *testing.T) { +func TestEndpointCase90(t *testing.T) { var params = EndpointParameters{ Region: ptr.String("us-east-1"), Bucket: ptr.String("bucket"), @@ -4282,7 +4343,7 @@ func TestEndpointCase89(t *testing.T) { } // non-dns endpoint + global endpoint -func TestEndpointCase90(t *testing.T) { +func TestEndpointCase91(t *testing.T) { var params = EndpointParameters{ Region: ptr.String("us-east-1"), Bucket: ptr.String("bucket!"), @@ -4339,7 +4400,7 @@ func TestEndpointCase90(t *testing.T) { } // endpoint override + use global endpoint -func TestEndpointCase91(t *testing.T) { +func TestEndpointCase92(t *testing.T) { var params = EndpointParameters{ Region: ptr.String("us-east-1"), Bucket: ptr.String("bucket!"), @@ -4397,7 +4458,7 @@ func TestEndpointCase91(t *testing.T) { } // FIPS + dualstack + non-bucket endpoint -func TestEndpointCase92(t *testing.T) { +func TestEndpointCase93(t *testing.T) { var params = EndpointParameters{ Region: ptr.String("us-east-1"), Bucket: ptr.String("bucket!"), @@ -4453,7 +4514,7 @@ func TestEndpointCase92(t *testing.T) { } // FIPS + dualstack + non-DNS endpoint -func TestEndpointCase93(t *testing.T) { +func TestEndpointCase94(t *testing.T) { var params = EndpointParameters{ Region: ptr.String("us-east-1"), Bucket: ptr.String("bucket!"), @@ -4510,7 +4571,7 @@ func TestEndpointCase93(t *testing.T) { } // endpoint override + FIPS + dualstack (BUG) -func TestEndpointCase94(t *testing.T) { +func TestEndpointCase95(t *testing.T) { var params = EndpointParameters{ Region: ptr.String("us-east-1"), Bucket: ptr.String("bucket!"), @@ -4533,7 +4594,7 @@ func TestEndpointCase94(t *testing.T) { } // endpoint override + non-dns bucket + FIPS (BUG) -func TestEndpointCase95(t *testing.T) { +func TestEndpointCase96(t *testing.T) { var params = EndpointParameters{ Region: ptr.String("us-east-1"), Bucket: ptr.String("bucket!"), @@ -4555,7 +4616,7 @@ func TestEndpointCase95(t *testing.T) { } // FIPS + bucket endpoint + force path style -func TestEndpointCase96(t *testing.T) { +func TestEndpointCase97(t *testing.T) { var params = EndpointParameters{ Region: ptr.String("us-east-1"), Bucket: ptr.String("bucket!"), @@ -4613,7 +4674,7 @@ func TestEndpointCase96(t *testing.T) { } // bucket + FIPS + force path style -func TestEndpointCase97(t *testing.T) { +func TestEndpointCase98(t *testing.T) { var params = EndpointParameters{ Region: ptr.String("us-east-1"), Bucket: ptr.String("bucket"), @@ -4671,7 +4732,7 @@ func TestEndpointCase97(t *testing.T) { } // FIPS + dualstack + use global endpoint -func TestEndpointCase98(t *testing.T) { +func TestEndpointCase99(t *testing.T) { var params = EndpointParameters{ Region: ptr.String("us-east-1"), Bucket: ptr.String("bucket"), @@ -4728,7 +4789,7 @@ func TestEndpointCase98(t *testing.T) { } // URI encoded bucket + use global endpoint -func TestEndpointCase99(t *testing.T) { +func TestEndpointCase100(t *testing.T) { var params = EndpointParameters{ Region: ptr.String("us-east-1"), Bucket: ptr.String("bucket!"), @@ -4751,7 +4812,7 @@ func TestEndpointCase99(t *testing.T) { } // FIPS + path based endpoint -func TestEndpointCase100(t *testing.T) { +func TestEndpointCase101(t *testing.T) { var params = EndpointParameters{ Region: ptr.String("us-east-1"), Bucket: ptr.String("bucket!"), @@ -4809,7 +4870,7 @@ func TestEndpointCase100(t *testing.T) { } // accelerate + dualstack + global endpoint -func TestEndpointCase101(t *testing.T) { +func TestEndpointCase102(t *testing.T) { var params = EndpointParameters{ Region: ptr.String("us-east-1"), Bucket: ptr.String("bucket"), @@ -4867,7 +4928,7 @@ func TestEndpointCase101(t *testing.T) { } // dualstack + global endpoint + non URI safe bucket -func TestEndpointCase102(t *testing.T) { +func TestEndpointCase103(t *testing.T) { var params = EndpointParameters{ Region: ptr.String("us-east-1"), Bucket: ptr.String("bucket!"), @@ -4925,7 +4986,7 @@ func TestEndpointCase102(t *testing.T) { } // FIPS + uri encoded bucket -func TestEndpointCase103(t *testing.T) { +func TestEndpointCase104(t *testing.T) { var params = EndpointParameters{ Region: ptr.String("us-east-1"), Bucket: ptr.String("bucket!"), @@ -4984,7 +5045,7 @@ func TestEndpointCase103(t *testing.T) { } // endpoint override + non-uri safe endpoint + force path style -func TestEndpointCase104(t *testing.T) { +func TestEndpointCase105(t *testing.T) { var params = EndpointParameters{ Region: ptr.String("us-east-1"), Bucket: ptr.String("bucket!"), @@ -5009,7 +5070,7 @@ func TestEndpointCase104(t *testing.T) { } // FIPS + Dualstack + global endpoint + non-dns bucket -func TestEndpointCase105(t *testing.T) { +func TestEndpointCase106(t *testing.T) { var params = EndpointParameters{ Region: ptr.String("us-east-1"), Bucket: ptr.String("bucket!"), @@ -5067,7 +5128,7 @@ func TestEndpointCase105(t *testing.T) { } // endpoint override + FIPS + dualstack -func TestEndpointCase106(t *testing.T) { +func TestEndpointCase107(t *testing.T) { var params = EndpointParameters{ Region: ptr.String("us-east-1"), UseDualStack: ptr.Bool(true), @@ -5089,7 +5150,7 @@ func TestEndpointCase106(t *testing.T) { } // non-bucket endpoint override + dualstack + global endpoint -func TestEndpointCase107(t *testing.T) { +func TestEndpointCase108(t *testing.T) { var params = EndpointParameters{ Region: ptr.String("us-east-1"), UseFIPS: ptr.Bool(false), @@ -5111,7 +5172,7 @@ func TestEndpointCase107(t *testing.T) { } // Endpoint override + UseGlobalEndpoint + us-east-1 -func TestEndpointCase108(t *testing.T) { +func TestEndpointCase109(t *testing.T) { var params = EndpointParameters{ Region: ptr.String("us-east-1"), UseFIPS: ptr.Bool(true), @@ -5133,7 +5194,7 @@ func TestEndpointCase108(t *testing.T) { } // non-FIPS partition with FIPS set + custom endpoint -func TestEndpointCase109(t *testing.T) { +func TestEndpointCase110(t *testing.T) { var params = EndpointParameters{ Region: ptr.String("cn-north-1"), UseFIPS: ptr.Bool(true), @@ -5154,7 +5215,7 @@ func TestEndpointCase109(t *testing.T) { } // aws-global signs as us-east-1 -func TestEndpointCase110(t *testing.T) { +func TestEndpointCase111(t *testing.T) { var params = EndpointParameters{ Region: ptr.String("aws-global"), Bucket: ptr.String("bucket!"), @@ -5211,7 +5272,7 @@ func TestEndpointCase110(t *testing.T) { } // aws-global signs as us-east-1 -func TestEndpointCase111(t *testing.T) { +func TestEndpointCase112(t *testing.T) { var params = EndpointParameters{ Region: ptr.String("aws-global"), Bucket: ptr.String("bucket"), @@ -5269,7 +5330,7 @@ func TestEndpointCase111(t *testing.T) { } // aws-global + dualstack + path-only bucket -func TestEndpointCase112(t *testing.T) { +func TestEndpointCase113(t *testing.T) { var params = EndpointParameters{ Region: ptr.String("aws-global"), Bucket: ptr.String("bucket!"), @@ -5326,7 +5387,7 @@ func TestEndpointCase112(t *testing.T) { } // aws-global + path-only bucket -func TestEndpointCase113(t *testing.T) { +func TestEndpointCase114(t *testing.T) { var params = EndpointParameters{ Region: ptr.String("aws-global"), Bucket: ptr.String("bucket!"), @@ -5380,7 +5441,7 @@ func TestEndpointCase113(t *testing.T) { } // aws-global + fips + custom endpoint -func TestEndpointCase114(t *testing.T) { +func TestEndpointCase115(t *testing.T) { var params = EndpointParameters{ Region: ptr.String("aws-global"), Bucket: ptr.String("bucket!"), @@ -5403,7 +5464,7 @@ func TestEndpointCase114(t *testing.T) { } // aws-global, endpoint override & path only-bucket -func TestEndpointCase115(t *testing.T) { +func TestEndpointCase116(t *testing.T) { var params = EndpointParameters{ Region: ptr.String("aws-global"), Bucket: ptr.String("bucket!"), @@ -5461,7 +5522,7 @@ func TestEndpointCase115(t *testing.T) { } // aws-global + dualstack + custom endpoint -func TestEndpointCase116(t *testing.T) { +func TestEndpointCase117(t *testing.T) { var params = EndpointParameters{ Region: ptr.String("aws-global"), UseDualStack: ptr.Bool(true), @@ -5483,7 +5544,7 @@ func TestEndpointCase116(t *testing.T) { } // accelerate, dualstack + aws-global -func TestEndpointCase117(t *testing.T) { +func TestEndpointCase118(t *testing.T) { var params = EndpointParameters{ Region: ptr.String("aws-global"), Bucket: ptr.String("bucket"), @@ -5541,7 +5602,7 @@ func TestEndpointCase117(t *testing.T) { // FIPS + aws-global + path only bucket. This is not supported by S3 but we allow // garbage in garbage out -func TestEndpointCase118(t *testing.T) { +func TestEndpointCase119(t *testing.T) { var params = EndpointParameters{ Region: ptr.String("aws-global"), Bucket: ptr.String("bucket!"), @@ -5599,7 +5660,7 @@ func TestEndpointCase118(t *testing.T) { } // aws-global + FIPS + endpoint override. -func TestEndpointCase119(t *testing.T) { +func TestEndpointCase120(t *testing.T) { var params = EndpointParameters{ Region: ptr.String("aws-global"), UseFIPS: ptr.Bool(true), @@ -5619,7 +5680,7 @@ func TestEndpointCase119(t *testing.T) { } // force path style, FIPS, aws-global & endpoint override -func TestEndpointCase120(t *testing.T) { +func TestEndpointCase121(t *testing.T) { var params = EndpointParameters{ Region: ptr.String("aws-global"), Bucket: ptr.String("bucket!"), @@ -5641,7 +5702,7 @@ func TestEndpointCase120(t *testing.T) { } // ip address causes path style to be forced -func TestEndpointCase121(t *testing.T) { +func TestEndpointCase122(t *testing.T) { var params = EndpointParameters{ Region: ptr.String("aws-global"), Bucket: ptr.String("bucket"), @@ -5696,7 +5757,7 @@ func TestEndpointCase121(t *testing.T) { } // endpoint override with aws-global region -func TestEndpointCase122(t *testing.T) { +func TestEndpointCase123(t *testing.T) { var params = EndpointParameters{ Region: ptr.String("aws-global"), UseFIPS: ptr.Bool(true), @@ -5717,7 +5778,7 @@ func TestEndpointCase122(t *testing.T) { } // FIPS + path-only (TODO: consider making this an error) -func TestEndpointCase123(t *testing.T) { +func TestEndpointCase124(t *testing.T) { var params = EndpointParameters{ Region: ptr.String("aws-global"), Bucket: ptr.String("bucket!"), @@ -5772,7 +5833,7 @@ func TestEndpointCase123(t *testing.T) { } // empty arn type -func TestEndpointCase124(t *testing.T) { +func TestEndpointCase125(t *testing.T) { var params = EndpointParameters{ Region: ptr.String("us-east-2"), Bucket: ptr.String("arn:aws:not-s3:us-west-2:123456789012::myendpoint"), @@ -5791,7 +5852,7 @@ func TestEndpointCase124(t *testing.T) { } // path style can't be used with accelerate -func TestEndpointCase125(t *testing.T) { +func TestEndpointCase126(t *testing.T) { var params = EndpointParameters{ Region: ptr.String("us-east-2"), Bucket: ptr.String("bucket!"), @@ -5811,7 +5872,7 @@ func TestEndpointCase125(t *testing.T) { } // invalid region -func TestEndpointCase126(t *testing.T) { +func TestEndpointCase127(t *testing.T) { var params = EndpointParameters{ Region: ptr.String("us-east-2!"), Bucket: ptr.String("bucket.subdomain"), @@ -5831,7 +5892,7 @@ func TestEndpointCase126(t *testing.T) { } // invalid region -func TestEndpointCase127(t *testing.T) { +func TestEndpointCase128(t *testing.T) { var params = EndpointParameters{ Region: ptr.String("us-east-2!"), Bucket: ptr.String("bucket"), @@ -5851,7 +5912,7 @@ func TestEndpointCase127(t *testing.T) { } // empty arn type -func TestEndpointCase128(t *testing.T) { +func TestEndpointCase129(t *testing.T) { var params = EndpointParameters{ Region: ptr.String("us-east-2"), Bucket: ptr.String("arn:aws:s3::123456789012:accesspoint:my_endpoint"), @@ -5870,7 +5931,7 @@ func TestEndpointCase128(t *testing.T) { } // empty arn type -func TestEndpointCase129(t *testing.T) { +func TestEndpointCase130(t *testing.T) { var params = EndpointParameters{ Region: ptr.String("us-east-2"), Bucket: ptr.String("arn:aws:s3:cn-north-1:123456789012:accesspoint:my-endpoint"), @@ -5890,7 +5951,7 @@ func TestEndpointCase129(t *testing.T) { } // invalid arn region -func TestEndpointCase130(t *testing.T) { +func TestEndpointCase131(t *testing.T) { var params = EndpointParameters{ Region: ptr.String("us-east-2"), Bucket: ptr.String("arn:aws:s3-object-lambda:us-east_2:123456789012:accesspoint:my-endpoint"), @@ -5910,7 +5971,7 @@ func TestEndpointCase130(t *testing.T) { } // invalid ARN outpost -func TestEndpointCase131(t *testing.T) { +func TestEndpointCase132(t *testing.T) { var params = EndpointParameters{ Region: ptr.String("us-east-2"), Bucket: ptr.String("arn:aws:s3-outposts:us-east-1:123456789012:outpost/op_01234567890123456/accesspoint/reports"), @@ -5930,7 +5991,7 @@ func TestEndpointCase131(t *testing.T) { } // invalid ARN -func TestEndpointCase132(t *testing.T) { +func TestEndpointCase133(t *testing.T) { var params = EndpointParameters{ Region: ptr.String("us-east-2"), Bucket: ptr.String("arn:aws:s3-outposts:us-east-1:123456789012:outpost/op-01234567890123456/reports"), @@ -5949,7 +6010,7 @@ func TestEndpointCase132(t *testing.T) { } // invalid ARN -func TestEndpointCase133(t *testing.T) { +func TestEndpointCase134(t *testing.T) { var params = EndpointParameters{ Region: ptr.String("us-east-2"), Bucket: ptr.String("arn:aws:s3-outposts:us-east-1:123456789012:outpost/op-01234567890123456"), @@ -5968,7 +6029,7 @@ func TestEndpointCase133(t *testing.T) { } // invalid outpost type -func TestEndpointCase134(t *testing.T) { +func TestEndpointCase135(t *testing.T) { var params = EndpointParameters{ Region: ptr.String("us-east-2"), Bucket: ptr.String("arn:aws:s3-outposts:us-east-1:123456789012:outpost/op-01234567890123456/not-accesspoint/reports"), @@ -5987,7 +6048,7 @@ func TestEndpointCase134(t *testing.T) { } // invalid outpost type -func TestEndpointCase135(t *testing.T) { +func TestEndpointCase136(t *testing.T) { var params = EndpointParameters{ Region: ptr.String("us-east-2"), Bucket: ptr.String("arn:aws:s3-outposts:us-east_1:123456789012:outpost/op-01234567890123456/not-accesspoint/reports"), @@ -6006,7 +6067,7 @@ func TestEndpointCase135(t *testing.T) { } // invalid outpost type -func TestEndpointCase136(t *testing.T) { +func TestEndpointCase137(t *testing.T) { var params = EndpointParameters{ Region: ptr.String("us-east-2"), Bucket: ptr.String("arn:aws:s3-outposts:us-east-1:12345_789012:outpost/op-01234567890123456/not-accesspoint/reports"), @@ -6025,7 +6086,7 @@ func TestEndpointCase136(t *testing.T) { } // invalid outpost type -func TestEndpointCase137(t *testing.T) { +func TestEndpointCase138(t *testing.T) { var params = EndpointParameters{ Region: ptr.String("us-east-2"), Bucket: ptr.String("arn:aws:s3-outposts:us-east-1:12345789012:outpost"), @@ -6044,7 +6105,7 @@ func TestEndpointCase137(t *testing.T) { } // use global endpoint virtual addressing -func TestEndpointCase138(t *testing.T) { +func TestEndpointCase139(t *testing.T) { var params = EndpointParameters{ Region: ptr.String("us-east-2"), Bucket: ptr.String("bucket"), @@ -6100,7 +6161,7 @@ func TestEndpointCase138(t *testing.T) { } // global endpoint + ip address -func TestEndpointCase139(t *testing.T) { +func TestEndpointCase140(t *testing.T) { var params = EndpointParameters{ Region: ptr.String("us-east-2"), Bucket: ptr.String("bucket"), @@ -6156,7 +6217,7 @@ func TestEndpointCase139(t *testing.T) { } // invalid outpost type -func TestEndpointCase140(t *testing.T) { +func TestEndpointCase141(t *testing.T) { var params = EndpointParameters{ Region: ptr.String("us-east-2"), Bucket: ptr.String("bucket!"), @@ -6211,7 +6272,7 @@ func TestEndpointCase140(t *testing.T) { } // invalid outpost type -func TestEndpointCase141(t *testing.T) { +func TestEndpointCase142(t *testing.T) { var params = EndpointParameters{ Region: ptr.String("us-east-2"), Bucket: ptr.String("bucket"), @@ -6267,7 +6328,7 @@ func TestEndpointCase141(t *testing.T) { } // use global endpoint + custom endpoint -func TestEndpointCase142(t *testing.T) { +func TestEndpointCase143(t *testing.T) { var params = EndpointParameters{ Region: ptr.String("us-east-2"), Bucket: ptr.String("bucket!"), @@ -6323,7 +6384,7 @@ func TestEndpointCase142(t *testing.T) { } // use global endpoint, not us-east-1, force path style -func TestEndpointCase143(t *testing.T) { +func TestEndpointCase144(t *testing.T) { var params = EndpointParameters{ Region: ptr.String("us-east-2"), Bucket: ptr.String("bucket!"), @@ -6380,7 +6441,7 @@ func TestEndpointCase143(t *testing.T) { } // vanilla virtual addressing@us-west-2 -func TestEndpointCase144(t *testing.T) { +func TestEndpointCase145(t *testing.T) { var params = EndpointParameters{ Accelerate: ptr.Bool(false), Bucket: ptr.String("bucket-name"), @@ -6438,7 +6499,7 @@ func TestEndpointCase144(t *testing.T) { } // virtual addressing + dualstack@us-west-2 -func TestEndpointCase145(t *testing.T) { +func TestEndpointCase146(t *testing.T) { var params = EndpointParameters{ Accelerate: ptr.Bool(false), Bucket: ptr.String("bucket-name"), @@ -6496,7 +6557,7 @@ func TestEndpointCase145(t *testing.T) { } // accelerate + dualstack@us-west-2 -func TestEndpointCase146(t *testing.T) { +func TestEndpointCase147(t *testing.T) { var params = EndpointParameters{ Accelerate: ptr.Bool(true), Bucket: ptr.String("bucket-name"), @@ -6554,7 +6615,7 @@ func TestEndpointCase146(t *testing.T) { } // accelerate (dualstack=false)@us-west-2 -func TestEndpointCase147(t *testing.T) { +func TestEndpointCase148(t *testing.T) { var params = EndpointParameters{ Accelerate: ptr.Bool(true), Bucket: ptr.String("bucket-name"), @@ -6612,7 +6673,7 @@ func TestEndpointCase147(t *testing.T) { } // virtual addressing + fips@us-west-2 -func TestEndpointCase148(t *testing.T) { +func TestEndpointCase149(t *testing.T) { var params = EndpointParameters{ Accelerate: ptr.Bool(false), Bucket: ptr.String("bucket-name"), @@ -6670,7 +6731,7 @@ func TestEndpointCase148(t *testing.T) { } // virtual addressing + dualstack + fips@us-west-2 -func TestEndpointCase149(t *testing.T) { +func TestEndpointCase150(t *testing.T) { var params = EndpointParameters{ Accelerate: ptr.Bool(false), Bucket: ptr.String("bucket-name"), @@ -6728,7 +6789,7 @@ func TestEndpointCase149(t *testing.T) { } // accelerate + fips = error@us-west-2 -func TestEndpointCase150(t *testing.T) { +func TestEndpointCase151(t *testing.T) { var params = EndpointParameters{ Accelerate: ptr.Bool(true), Bucket: ptr.String("bucket-name"), @@ -6751,7 +6812,7 @@ func TestEndpointCase150(t *testing.T) { } // vanilla virtual addressing@cn-north-1 -func TestEndpointCase151(t *testing.T) { +func TestEndpointCase152(t *testing.T) { var params = EndpointParameters{ Accelerate: ptr.Bool(false), Bucket: ptr.String("bucket-name"), @@ -6809,7 +6870,7 @@ func TestEndpointCase151(t *testing.T) { } // virtual addressing + dualstack@cn-north-1 -func TestEndpointCase152(t *testing.T) { +func TestEndpointCase153(t *testing.T) { var params = EndpointParameters{ Accelerate: ptr.Bool(false), Bucket: ptr.String("bucket-name"), @@ -6867,7 +6928,7 @@ func TestEndpointCase152(t *testing.T) { } // accelerate (dualstack=false)@cn-north-1 -func TestEndpointCase153(t *testing.T) { +func TestEndpointCase154(t *testing.T) { var params = EndpointParameters{ Accelerate: ptr.Bool(true), Bucket: ptr.String("bucket-name"), @@ -6890,7 +6951,7 @@ func TestEndpointCase153(t *testing.T) { } // virtual addressing + fips@cn-north-1 -func TestEndpointCase154(t *testing.T) { +func TestEndpointCase155(t *testing.T) { var params = EndpointParameters{ Accelerate: ptr.Bool(false), Bucket: ptr.String("bucket-name"), @@ -6913,7 +6974,7 @@ func TestEndpointCase154(t *testing.T) { } // vanilla virtual addressing@af-south-1 -func TestEndpointCase155(t *testing.T) { +func TestEndpointCase156(t *testing.T) { var params = EndpointParameters{ Accelerate: ptr.Bool(false), Bucket: ptr.String("bucket-name"), @@ -6971,7 +7032,7 @@ func TestEndpointCase155(t *testing.T) { } // virtual addressing + dualstack@af-south-1 -func TestEndpointCase156(t *testing.T) { +func TestEndpointCase157(t *testing.T) { var params = EndpointParameters{ Accelerate: ptr.Bool(false), Bucket: ptr.String("bucket-name"), @@ -7029,7 +7090,7 @@ func TestEndpointCase156(t *testing.T) { } // accelerate + dualstack@af-south-1 -func TestEndpointCase157(t *testing.T) { +func TestEndpointCase158(t *testing.T) { var params = EndpointParameters{ Accelerate: ptr.Bool(true), Bucket: ptr.String("bucket-name"), @@ -7087,7 +7148,7 @@ func TestEndpointCase157(t *testing.T) { } // accelerate (dualstack=false)@af-south-1 -func TestEndpointCase158(t *testing.T) { +func TestEndpointCase159(t *testing.T) { var params = EndpointParameters{ Accelerate: ptr.Bool(true), Bucket: ptr.String("bucket-name"), @@ -7145,7 +7206,7 @@ func TestEndpointCase158(t *testing.T) { } // virtual addressing + fips@af-south-1 -func TestEndpointCase159(t *testing.T) { +func TestEndpointCase160(t *testing.T) { var params = EndpointParameters{ Accelerate: ptr.Bool(false), Bucket: ptr.String("bucket-name"), @@ -7203,7 +7264,7 @@ func TestEndpointCase159(t *testing.T) { } // virtual addressing + dualstack + fips@af-south-1 -func TestEndpointCase160(t *testing.T) { +func TestEndpointCase161(t *testing.T) { var params = EndpointParameters{ Accelerate: ptr.Bool(false), Bucket: ptr.String("bucket-name"), @@ -7261,7 +7322,7 @@ func TestEndpointCase160(t *testing.T) { } // accelerate + fips = error@af-south-1 -func TestEndpointCase161(t *testing.T) { +func TestEndpointCase162(t *testing.T) { var params = EndpointParameters{ Accelerate: ptr.Bool(true), Bucket: ptr.String("bucket-name"), @@ -7284,7 +7345,7 @@ func TestEndpointCase161(t *testing.T) { } // vanilla path style@us-west-2 -func TestEndpointCase162(t *testing.T) { +func TestEndpointCase163(t *testing.T) { var params = EndpointParameters{ Accelerate: ptr.Bool(false), Bucket: ptr.String("bucket-name"), @@ -7342,7 +7403,7 @@ func TestEndpointCase162(t *testing.T) { } // fips@us-gov-west-2, bucket is not S3-dns-compatible (subdomains) -func TestEndpointCase163(t *testing.T) { +func TestEndpointCase164(t *testing.T) { var params = EndpointParameters{ Accelerate: ptr.Bool(false), Bucket: ptr.String("bucket.with.dots"), @@ -7399,7 +7460,7 @@ func TestEndpointCase163(t *testing.T) { } // path style + accelerate = error@us-west-2 -func TestEndpointCase164(t *testing.T) { +func TestEndpointCase165(t *testing.T) { var params = EndpointParameters{ Accelerate: ptr.Bool(true), Bucket: ptr.String("bucket-name"), @@ -7422,7 +7483,7 @@ func TestEndpointCase164(t *testing.T) { } // path style + dualstack@us-west-2 -func TestEndpointCase165(t *testing.T) { +func TestEndpointCase166(t *testing.T) { var params = EndpointParameters{ Accelerate: ptr.Bool(false), Bucket: ptr.String("bucket-name"), @@ -7480,7 +7541,7 @@ func TestEndpointCase165(t *testing.T) { } // path style + arn is error@us-west-2 -func TestEndpointCase166(t *testing.T) { +func TestEndpointCase167(t *testing.T) { var params = EndpointParameters{ Accelerate: ptr.Bool(false), Bucket: ptr.String("arn:PARTITION:s3-outposts:REGION:123456789012:outpost:op-01234567890123456:bucket:mybucket"), @@ -7503,7 +7564,7 @@ func TestEndpointCase166(t *testing.T) { } // path style + invalid DNS name@us-west-2 -func TestEndpointCase167(t *testing.T) { +func TestEndpointCase168(t *testing.T) { var params = EndpointParameters{ Accelerate: ptr.Bool(false), Bucket: ptr.String("99a_b"), @@ -7561,7 +7622,7 @@ func TestEndpointCase167(t *testing.T) { } // no path style + invalid DNS name@us-west-2 -func TestEndpointCase168(t *testing.T) { +func TestEndpointCase169(t *testing.T) { var params = EndpointParameters{ Accelerate: ptr.Bool(false), Bucket: ptr.String("99a_b"), @@ -7618,7 +7679,7 @@ func TestEndpointCase168(t *testing.T) { } // vanilla path style@cn-north-1 -func TestEndpointCase169(t *testing.T) { +func TestEndpointCase170(t *testing.T) { var params = EndpointParameters{ Accelerate: ptr.Bool(false), Bucket: ptr.String("bucket-name"), @@ -7676,7 +7737,7 @@ func TestEndpointCase169(t *testing.T) { } // path style + fips@cn-north-1 -func TestEndpointCase170(t *testing.T) { +func TestEndpointCase171(t *testing.T) { var params = EndpointParameters{ Accelerate: ptr.Bool(false), Bucket: ptr.String("bucket-name"), @@ -7699,7 +7760,7 @@ func TestEndpointCase170(t *testing.T) { } // path style + accelerate = error@cn-north-1 -func TestEndpointCase171(t *testing.T) { +func TestEndpointCase172(t *testing.T) { var params = EndpointParameters{ Accelerate: ptr.Bool(true), Bucket: ptr.String("bucket-name"), @@ -7722,7 +7783,7 @@ func TestEndpointCase171(t *testing.T) { } // path style + dualstack@cn-north-1 -func TestEndpointCase172(t *testing.T) { +func TestEndpointCase173(t *testing.T) { var params = EndpointParameters{ Accelerate: ptr.Bool(false), Bucket: ptr.String("bucket-name"), @@ -7780,7 +7841,7 @@ func TestEndpointCase172(t *testing.T) { } // path style + arn is error@cn-north-1 -func TestEndpointCase173(t *testing.T) { +func TestEndpointCase174(t *testing.T) { var params = EndpointParameters{ Accelerate: ptr.Bool(false), Bucket: ptr.String("arn:PARTITION:s3-outposts:REGION:123456789012:outpost:op-01234567890123456:bucket:mybucket"), @@ -7803,7 +7864,7 @@ func TestEndpointCase173(t *testing.T) { } // path style + invalid DNS name@cn-north-1 -func TestEndpointCase174(t *testing.T) { +func TestEndpointCase175(t *testing.T) { var params = EndpointParameters{ Accelerate: ptr.Bool(false), Bucket: ptr.String("99a_b"), @@ -7861,7 +7922,7 @@ func TestEndpointCase174(t *testing.T) { } // no path style + invalid DNS name@cn-north-1 -func TestEndpointCase175(t *testing.T) { +func TestEndpointCase176(t *testing.T) { var params = EndpointParameters{ Accelerate: ptr.Bool(false), Bucket: ptr.String("99a_b"), @@ -7918,7 +7979,7 @@ func TestEndpointCase175(t *testing.T) { } // vanilla path style@af-south-1 -func TestEndpointCase176(t *testing.T) { +func TestEndpointCase177(t *testing.T) { var params = EndpointParameters{ Accelerate: ptr.Bool(false), Bucket: ptr.String("bucket-name"), @@ -7976,7 +8037,7 @@ func TestEndpointCase176(t *testing.T) { } // path style + fips@af-south-1 -func TestEndpointCase177(t *testing.T) { +func TestEndpointCase178(t *testing.T) { var params = EndpointParameters{ Accelerate: ptr.Bool(false), Bucket: ptr.String("bucket-name"), @@ -8034,7 +8095,7 @@ func TestEndpointCase177(t *testing.T) { } // path style + accelerate = error@af-south-1 -func TestEndpointCase178(t *testing.T) { +func TestEndpointCase179(t *testing.T) { var params = EndpointParameters{ Accelerate: ptr.Bool(true), Bucket: ptr.String("bucket-name"), @@ -8057,7 +8118,7 @@ func TestEndpointCase178(t *testing.T) { } // path style + dualstack@af-south-1 -func TestEndpointCase179(t *testing.T) { +func TestEndpointCase180(t *testing.T) { var params = EndpointParameters{ Accelerate: ptr.Bool(false), Bucket: ptr.String("bucket-name"), @@ -8115,7 +8176,7 @@ func TestEndpointCase179(t *testing.T) { } // path style + arn is error@af-south-1 -func TestEndpointCase180(t *testing.T) { +func TestEndpointCase181(t *testing.T) { var params = EndpointParameters{ Accelerate: ptr.Bool(false), Bucket: ptr.String("arn:PARTITION:s3-outposts:REGION:123456789012:outpost:op-01234567890123456:bucket:mybucket"), @@ -8138,7 +8199,7 @@ func TestEndpointCase180(t *testing.T) { } // path style + invalid DNS name@af-south-1 -func TestEndpointCase181(t *testing.T) { +func TestEndpointCase182(t *testing.T) { var params = EndpointParameters{ Accelerate: ptr.Bool(false), Bucket: ptr.String("99a_b"), @@ -8196,7 +8257,7 @@ func TestEndpointCase181(t *testing.T) { } // no path style + invalid DNS name@af-south-1 -func TestEndpointCase182(t *testing.T) { +func TestEndpointCase183(t *testing.T) { var params = EndpointParameters{ Accelerate: ptr.Bool(false), Bucket: ptr.String("99a_b"), @@ -8253,7 +8314,7 @@ func TestEndpointCase182(t *testing.T) { } // virtual addressing + private link@us-west-2 -func TestEndpointCase183(t *testing.T) { +func TestEndpointCase184(t *testing.T) { var params = EndpointParameters{ Accelerate: ptr.Bool(false), Bucket: ptr.String("bucket-name"), @@ -8312,7 +8373,7 @@ func TestEndpointCase183(t *testing.T) { } // path style + private link@us-west-2 -func TestEndpointCase184(t *testing.T) { +func TestEndpointCase185(t *testing.T) { var params = EndpointParameters{ Accelerate: ptr.Bool(false), Bucket: ptr.String("bucket-name"), @@ -8371,7 +8432,7 @@ func TestEndpointCase184(t *testing.T) { } // SDK::Host + FIPS@us-west-2 -func TestEndpointCase185(t *testing.T) { +func TestEndpointCase186(t *testing.T) { var params = EndpointParameters{ Accelerate: ptr.Bool(false), Bucket: ptr.String("bucket-name"), @@ -8395,7 +8456,7 @@ func TestEndpointCase185(t *testing.T) { } // SDK::Host + DualStack@us-west-2 -func TestEndpointCase186(t *testing.T) { +func TestEndpointCase187(t *testing.T) { var params = EndpointParameters{ Accelerate: ptr.Bool(false), Bucket: ptr.String("bucket-name"), @@ -8419,7 +8480,7 @@ func TestEndpointCase186(t *testing.T) { } // SDK::HOST + accelerate@us-west-2 -func TestEndpointCase187(t *testing.T) { +func TestEndpointCase188(t *testing.T) { var params = EndpointParameters{ Accelerate: ptr.Bool(true), Bucket: ptr.String("bucket-name"), @@ -8443,7 +8504,7 @@ func TestEndpointCase187(t *testing.T) { } // SDK::Host + access point ARN@us-west-2 -func TestEndpointCase188(t *testing.T) { +func TestEndpointCase189(t *testing.T) { var params = EndpointParameters{ Accelerate: ptr.Bool(false), Bucket: ptr.String("arn:aws:s3:us-west-2:123456789012:accesspoint:myendpoint"), @@ -8502,7 +8563,7 @@ func TestEndpointCase188(t *testing.T) { } // virtual addressing + private link@cn-north-1 -func TestEndpointCase189(t *testing.T) { +func TestEndpointCase190(t *testing.T) { var params = EndpointParameters{ Accelerate: ptr.Bool(false), Bucket: ptr.String("bucket-name"), @@ -8561,7 +8622,7 @@ func TestEndpointCase189(t *testing.T) { } // path style + private link@cn-north-1 -func TestEndpointCase190(t *testing.T) { +func TestEndpointCase191(t *testing.T) { var params = EndpointParameters{ Accelerate: ptr.Bool(false), Bucket: ptr.String("bucket-name"), @@ -8620,7 +8681,7 @@ func TestEndpointCase190(t *testing.T) { } // FIPS@cn-north-1 -func TestEndpointCase191(t *testing.T) { +func TestEndpointCase192(t *testing.T) { var params = EndpointParameters{ Accelerate: ptr.Bool(false), Bucket: ptr.String("bucket-name"), @@ -8643,7 +8704,7 @@ func TestEndpointCase191(t *testing.T) { } // SDK::Host + DualStack@cn-north-1 -func TestEndpointCase192(t *testing.T) { +func TestEndpointCase193(t *testing.T) { var params = EndpointParameters{ Accelerate: ptr.Bool(false), Bucket: ptr.String("bucket-name"), @@ -8667,7 +8728,7 @@ func TestEndpointCase192(t *testing.T) { } // SDK::HOST + accelerate@cn-north-1 -func TestEndpointCase193(t *testing.T) { +func TestEndpointCase194(t *testing.T) { var params = EndpointParameters{ Accelerate: ptr.Bool(true), Bucket: ptr.String("bucket-name"), @@ -8691,7 +8752,7 @@ func TestEndpointCase193(t *testing.T) { } // SDK::Host + access point ARN@cn-north-1 -func TestEndpointCase194(t *testing.T) { +func TestEndpointCase195(t *testing.T) { var params = EndpointParameters{ Accelerate: ptr.Bool(false), Bucket: ptr.String("arn:aws-cn:s3:cn-north-1:123456789012:accesspoint:myendpoint"), @@ -8750,7 +8811,7 @@ func TestEndpointCase194(t *testing.T) { } // virtual addressing + private link@af-south-1 -func TestEndpointCase195(t *testing.T) { +func TestEndpointCase196(t *testing.T) { var params = EndpointParameters{ Accelerate: ptr.Bool(false), Bucket: ptr.String("bucket-name"), @@ -8809,7 +8870,7 @@ func TestEndpointCase195(t *testing.T) { } // path style + private link@af-south-1 -func TestEndpointCase196(t *testing.T) { +func TestEndpointCase197(t *testing.T) { var params = EndpointParameters{ Accelerate: ptr.Bool(false), Bucket: ptr.String("bucket-name"), @@ -8868,7 +8929,7 @@ func TestEndpointCase196(t *testing.T) { } // SDK::Host + FIPS@af-south-1 -func TestEndpointCase197(t *testing.T) { +func TestEndpointCase198(t *testing.T) { var params = EndpointParameters{ Accelerate: ptr.Bool(false), Bucket: ptr.String("bucket-name"), @@ -8892,7 +8953,7 @@ func TestEndpointCase197(t *testing.T) { } // SDK::Host + DualStack@af-south-1 -func TestEndpointCase198(t *testing.T) { +func TestEndpointCase199(t *testing.T) { var params = EndpointParameters{ Accelerate: ptr.Bool(false), Bucket: ptr.String("bucket-name"), @@ -8916,7 +8977,7 @@ func TestEndpointCase198(t *testing.T) { } // SDK::HOST + accelerate@af-south-1 -func TestEndpointCase199(t *testing.T) { +func TestEndpointCase200(t *testing.T) { var params = EndpointParameters{ Accelerate: ptr.Bool(true), Bucket: ptr.String("bucket-name"), @@ -8940,7 +9001,7 @@ func TestEndpointCase199(t *testing.T) { } // SDK::Host + access point ARN@af-south-1 -func TestEndpointCase200(t *testing.T) { +func TestEndpointCase201(t *testing.T) { var params = EndpointParameters{ Accelerate: ptr.Bool(false), Bucket: ptr.String("arn:aws:s3:af-south-1:123456789012:accesspoint:myendpoint"), @@ -8999,7 +9060,7 @@ func TestEndpointCase200(t *testing.T) { } // vanilla access point arn@us-west-2 -func TestEndpointCase201(t *testing.T) { +func TestEndpointCase202(t *testing.T) { var params = EndpointParameters{ Accelerate: ptr.Bool(false), Bucket: ptr.String("arn:aws:s3:us-west-2:123456789012:accesspoint:myendpoint"), @@ -9057,7 +9118,7 @@ func TestEndpointCase201(t *testing.T) { } // access point arn + FIPS@us-west-2 -func TestEndpointCase202(t *testing.T) { +func TestEndpointCase203(t *testing.T) { var params = EndpointParameters{ Accelerate: ptr.Bool(false), Bucket: ptr.String("arn:aws:s3:us-west-2:123456789012:accesspoint:myendpoint"), @@ -9115,7 +9176,7 @@ func TestEndpointCase202(t *testing.T) { } // access point arn + accelerate = error@us-west-2 -func TestEndpointCase203(t *testing.T) { +func TestEndpointCase204(t *testing.T) { var params = EndpointParameters{ Accelerate: ptr.Bool(true), Bucket: ptr.String("arn:aws:s3:us-west-2:123456789012:accesspoint:myendpoint"), @@ -9138,7 +9199,7 @@ func TestEndpointCase203(t *testing.T) { } // access point arn + FIPS + DualStack@us-west-2 -func TestEndpointCase204(t *testing.T) { +func TestEndpointCase205(t *testing.T) { var params = EndpointParameters{ Accelerate: ptr.Bool(false), Bucket: ptr.String("arn:aws:s3:us-west-2:123456789012:accesspoint:myendpoint"), @@ -9196,7 +9257,7 @@ func TestEndpointCase204(t *testing.T) { } // vanilla access point arn@cn-north-1 -func TestEndpointCase205(t *testing.T) { +func TestEndpointCase206(t *testing.T) { var params = EndpointParameters{ Accelerate: ptr.Bool(false), Bucket: ptr.String("arn:aws-cn:s3:cn-north-1:123456789012:accesspoint:myendpoint"), @@ -9254,7 +9315,7 @@ func TestEndpointCase205(t *testing.T) { } // access point arn + FIPS@cn-north-1 -func TestEndpointCase206(t *testing.T) { +func TestEndpointCase207(t *testing.T) { var params = EndpointParameters{ Accelerate: ptr.Bool(false), Bucket: ptr.String("arn:aws-cn:s3:cn-north-1:123456789012:accesspoint:myendpoint"), @@ -9277,7 +9338,7 @@ func TestEndpointCase206(t *testing.T) { } // access point arn + accelerate = error@cn-north-1 -func TestEndpointCase207(t *testing.T) { +func TestEndpointCase208(t *testing.T) { var params = EndpointParameters{ Accelerate: ptr.Bool(true), Bucket: ptr.String("arn:aws-cn:s3:cn-north-1:123456789012:accesspoint:myendpoint"), @@ -9300,7 +9361,7 @@ func TestEndpointCase207(t *testing.T) { } // access point arn + FIPS + DualStack@cn-north-1 -func TestEndpointCase208(t *testing.T) { +func TestEndpointCase209(t *testing.T) { var params = EndpointParameters{ Accelerate: ptr.Bool(false), Bucket: ptr.String("arn:aws-cn:s3:cn-north-1:123456789012:accesspoint:myendpoint"), @@ -9323,7 +9384,7 @@ func TestEndpointCase208(t *testing.T) { } // vanilla access point arn@af-south-1 -func TestEndpointCase209(t *testing.T) { +func TestEndpointCase210(t *testing.T) { var params = EndpointParameters{ Accelerate: ptr.Bool(false), Bucket: ptr.String("arn:aws:s3:af-south-1:123456789012:accesspoint:myendpoint"), @@ -9381,7 +9442,7 @@ func TestEndpointCase209(t *testing.T) { } // access point arn + FIPS@af-south-1 -func TestEndpointCase210(t *testing.T) { +func TestEndpointCase211(t *testing.T) { var params = EndpointParameters{ Accelerate: ptr.Bool(false), Bucket: ptr.String("arn:aws:s3:af-south-1:123456789012:accesspoint:myendpoint"), @@ -9439,7 +9500,7 @@ func TestEndpointCase210(t *testing.T) { } // access point arn + accelerate = error@af-south-1 -func TestEndpointCase211(t *testing.T) { +func TestEndpointCase212(t *testing.T) { var params = EndpointParameters{ Accelerate: ptr.Bool(true), Bucket: ptr.String("arn:aws:s3:af-south-1:123456789012:accesspoint:myendpoint"), @@ -9462,7 +9523,7 @@ func TestEndpointCase211(t *testing.T) { } // access point arn + FIPS + DualStack@af-south-1 -func TestEndpointCase212(t *testing.T) { +func TestEndpointCase213(t *testing.T) { var params = EndpointParameters{ Accelerate: ptr.Bool(false), Bucket: ptr.String("arn:aws:s3:af-south-1:123456789012:accesspoint:myendpoint"), @@ -9520,7 +9581,7 @@ func TestEndpointCase212(t *testing.T) { } // S3 outposts vanilla test -func TestEndpointCase213(t *testing.T) { +func TestEndpointCase214(t *testing.T) { var params = EndpointParameters{ Region: ptr.String("us-west-2"), UseFIPS: ptr.Bool(false), @@ -9590,7 +9651,7 @@ func TestEndpointCase213(t *testing.T) { } // S3 outposts custom endpoint -func TestEndpointCase214(t *testing.T) { +func TestEndpointCase215(t *testing.T) { var params = EndpointParameters{ Region: ptr.String("us-west-2"), UseFIPS: ptr.Bool(false), @@ -9661,7 +9722,7 @@ func TestEndpointCase214(t *testing.T) { } // outposts arn with region mismatch and UseArnRegion=false -func TestEndpointCase215(t *testing.T) { +func TestEndpointCase216(t *testing.T) { var params = EndpointParameters{ Accelerate: ptr.Bool(false), Bucket: ptr.String("arn:aws:s3-outposts:us-east-1:123456789012:outpost:op-01234567890123456:accesspoint:myaccesspoint"), @@ -9685,7 +9746,7 @@ func TestEndpointCase215(t *testing.T) { } // outposts arn with region mismatch, custom region and UseArnRegion=false -func TestEndpointCase216(t *testing.T) { +func TestEndpointCase217(t *testing.T) { var params = EndpointParameters{ Accelerate: ptr.Bool(false), Bucket: ptr.String("arn:aws:s3-outposts:us-east-1:123456789012:outpost:op-01234567890123456:accesspoint:myaccesspoint"), @@ -9710,7 +9771,7 @@ func TestEndpointCase216(t *testing.T) { } // outposts arn with region mismatch and UseArnRegion=true -func TestEndpointCase217(t *testing.T) { +func TestEndpointCase218(t *testing.T) { var params = EndpointParameters{ Accelerate: ptr.Bool(false), Bucket: ptr.String("arn:aws:s3-outposts:us-east-1:123456789012:outpost:op-01234567890123456:accesspoint:myaccesspoint"), @@ -9782,7 +9843,7 @@ func TestEndpointCase217(t *testing.T) { } // outposts arn with region mismatch and UseArnRegion unset -func TestEndpointCase218(t *testing.T) { +func TestEndpointCase219(t *testing.T) { var params = EndpointParameters{ Accelerate: ptr.Bool(false), Bucket: ptr.String("arn:aws:s3-outposts:us-east-1:123456789012:outpost:op-01234567890123456:accesspoint:myaccesspoint"), @@ -9853,7 +9914,7 @@ func TestEndpointCase218(t *testing.T) { } // outposts arn with partition mismatch and UseArnRegion=true -func TestEndpointCase219(t *testing.T) { +func TestEndpointCase220(t *testing.T) { var params = EndpointParameters{ Accelerate: ptr.Bool(false), Bucket: ptr.String("arn:aws:s3-outposts:cn-north-1:123456789012:outpost:op-01234567890123456:accesspoint:myaccesspoint"), @@ -9877,7 +9938,7 @@ func TestEndpointCase219(t *testing.T) { } // ARN with UseGlobalEndpoint and use-east-1 region uses the regional endpoint -func TestEndpointCase220(t *testing.T) { +func TestEndpointCase221(t *testing.T) { var params = EndpointParameters{ Region: ptr.String("us-east-1"), UseGlobalEndpoint: ptr.Bool(true), @@ -9948,7 +10009,7 @@ func TestEndpointCase220(t *testing.T) { } // S3 outposts does not support dualstack -func TestEndpointCase221(t *testing.T) { +func TestEndpointCase222(t *testing.T) { var params = EndpointParameters{ Region: ptr.String("us-east-1"), UseFIPS: ptr.Bool(false), @@ -9970,7 +10031,7 @@ func TestEndpointCase221(t *testing.T) { } // S3 outposts does not support fips -func TestEndpointCase222(t *testing.T) { +func TestEndpointCase223(t *testing.T) { var params = EndpointParameters{ Region: ptr.String("us-east-1"), UseFIPS: ptr.Bool(true), @@ -9992,7 +10053,7 @@ func TestEndpointCase222(t *testing.T) { } // S3 outposts does not support accelerate -func TestEndpointCase223(t *testing.T) { +func TestEndpointCase224(t *testing.T) { var params = EndpointParameters{ Region: ptr.String("us-east-1"), UseFIPS: ptr.Bool(false), @@ -10014,7 +10075,7 @@ func TestEndpointCase223(t *testing.T) { } // validates against subresource -func TestEndpointCase224(t *testing.T) { +func TestEndpointCase225(t *testing.T) { var params = EndpointParameters{ Region: ptr.String("us-west-2"), UseFIPS: ptr.Bool(false), @@ -10036,7 +10097,7 @@ func TestEndpointCase224(t *testing.T) { } // object lambda @us-east-1 -func TestEndpointCase225(t *testing.T) { +func TestEndpointCase226(t *testing.T) { var params = EndpointParameters{ Region: ptr.String("us-east-1"), UseFIPS: ptr.Bool(false), @@ -10094,7 +10155,7 @@ func TestEndpointCase225(t *testing.T) { } // object lambda @us-west-2 -func TestEndpointCase226(t *testing.T) { +func TestEndpointCase227(t *testing.T) { var params = EndpointParameters{ Region: ptr.String("us-west-2"), UseFIPS: ptr.Bool(false), @@ -10152,7 +10213,7 @@ func TestEndpointCase226(t *testing.T) { } // object lambda, colon resource deliminator @us-west-2 -func TestEndpointCase227(t *testing.T) { +func TestEndpointCase228(t *testing.T) { var params = EndpointParameters{ Region: ptr.String("us-west-2"), UseFIPS: ptr.Bool(false), @@ -10210,7 +10271,7 @@ func TestEndpointCase227(t *testing.T) { } // object lambda @us-east-1, client region us-west-2, useArnRegion=true -func TestEndpointCase228(t *testing.T) { +func TestEndpointCase229(t *testing.T) { var params = EndpointParameters{ Region: ptr.String("us-west-2"), UseFIPS: ptr.Bool(false), @@ -10268,7 +10329,7 @@ func TestEndpointCase228(t *testing.T) { } // object lambda @us-east-1, client region s3-external-1, useArnRegion=true -func TestEndpointCase229(t *testing.T) { +func TestEndpointCase230(t *testing.T) { var params = EndpointParameters{ Region: ptr.String("s3-external-1"), UseFIPS: ptr.Bool(false), @@ -10326,7 +10387,7 @@ func TestEndpointCase229(t *testing.T) { } // object lambda @us-east-1, client region s3-external-1, useArnRegion=false -func TestEndpointCase230(t *testing.T) { +func TestEndpointCase231(t *testing.T) { var params = EndpointParameters{ Region: ptr.String("s3-external-1"), UseFIPS: ptr.Bool(false), @@ -10349,7 +10410,7 @@ func TestEndpointCase230(t *testing.T) { } // object lambda @us-east-1, client region aws-global, useArnRegion=true -func TestEndpointCase231(t *testing.T) { +func TestEndpointCase232(t *testing.T) { var params = EndpointParameters{ Region: ptr.String("aws-global"), UseFIPS: ptr.Bool(false), @@ -10407,7 +10468,7 @@ func TestEndpointCase231(t *testing.T) { } // object lambda @us-east-1, client region aws-global, useArnRegion=false -func TestEndpointCase232(t *testing.T) { +func TestEndpointCase233(t *testing.T) { var params = EndpointParameters{ Region: ptr.String("aws-global"), UseFIPS: ptr.Bool(false), @@ -10431,7 +10492,7 @@ func TestEndpointCase232(t *testing.T) { // object lambda @cn-north-1, client region us-west-2 (cross partition), // useArnRegion=true -func TestEndpointCase233(t *testing.T) { +func TestEndpointCase234(t *testing.T) { var params = EndpointParameters{ Region: ptr.String("aws-global"), UseFIPS: ptr.Bool(false), @@ -10454,7 +10515,7 @@ func TestEndpointCase233(t *testing.T) { } // object lambda with dualstack -func TestEndpointCase234(t *testing.T) { +func TestEndpointCase235(t *testing.T) { var params = EndpointParameters{ Region: ptr.String("us-west-2"), UseFIPS: ptr.Bool(false), @@ -10477,7 +10538,7 @@ func TestEndpointCase234(t *testing.T) { } // object lambda @us-gov-east-1 -func TestEndpointCase235(t *testing.T) { +func TestEndpointCase236(t *testing.T) { var params = EndpointParameters{ Region: ptr.String("us-gov-east-1"), UseFIPS: ptr.Bool(false), @@ -10535,7 +10596,7 @@ func TestEndpointCase235(t *testing.T) { } // object lambda @us-gov-east-1, with fips -func TestEndpointCase236(t *testing.T) { +func TestEndpointCase237(t *testing.T) { var params = EndpointParameters{ Region: ptr.String("us-gov-east-1"), UseFIPS: ptr.Bool(true), @@ -10593,7 +10654,7 @@ func TestEndpointCase236(t *testing.T) { } // object lambda @cn-north-1, with fips -func TestEndpointCase237(t *testing.T) { +func TestEndpointCase238(t *testing.T) { var params = EndpointParameters{ Region: ptr.String("cn-north-1"), UseFIPS: ptr.Bool(true), @@ -10616,7 +10677,7 @@ func TestEndpointCase237(t *testing.T) { } // object lambda with accelerate -func TestEndpointCase238(t *testing.T) { +func TestEndpointCase239(t *testing.T) { var params = EndpointParameters{ Region: ptr.String("us-west-2"), UseFIPS: ptr.Bool(false), @@ -10639,7 +10700,7 @@ func TestEndpointCase238(t *testing.T) { } // object lambda with invalid arn - bad service and someresource -func TestEndpointCase239(t *testing.T) { +func TestEndpointCase240(t *testing.T) { var params = EndpointParameters{ Region: ptr.String("us-west-2"), UseFIPS: ptr.Bool(false), @@ -10662,7 +10723,7 @@ func TestEndpointCase239(t *testing.T) { } // object lambda with invalid arn - invalid resource -func TestEndpointCase240(t *testing.T) { +func TestEndpointCase241(t *testing.T) { var params = EndpointParameters{ Region: ptr.String("us-west-2"), UseFIPS: ptr.Bool(false), @@ -10685,7 +10746,7 @@ func TestEndpointCase240(t *testing.T) { } // object lambda with invalid arn - missing region -func TestEndpointCase241(t *testing.T) { +func TestEndpointCase242(t *testing.T) { var params = EndpointParameters{ Region: ptr.String("us-west-2"), UseFIPS: ptr.Bool(false), @@ -10708,7 +10769,7 @@ func TestEndpointCase241(t *testing.T) { } // object lambda with invalid arn - missing account-id -func TestEndpointCase242(t *testing.T) { +func TestEndpointCase243(t *testing.T) { var params = EndpointParameters{ Region: ptr.String("us-west-2"), UseFIPS: ptr.Bool(false), @@ -10731,7 +10792,7 @@ func TestEndpointCase242(t *testing.T) { } // object lambda with invalid arn - account id contains invalid characters -func TestEndpointCase243(t *testing.T) { +func TestEndpointCase244(t *testing.T) { var params = EndpointParameters{ Region: ptr.String("us-west-2"), UseFIPS: ptr.Bool(false), @@ -10754,7 +10815,7 @@ func TestEndpointCase243(t *testing.T) { } // object lambda with invalid arn - missing access point name -func TestEndpointCase244(t *testing.T) { +func TestEndpointCase245(t *testing.T) { var params = EndpointParameters{ Region: ptr.String("us-west-2"), UseFIPS: ptr.Bool(false), @@ -10777,7 +10838,7 @@ func TestEndpointCase244(t *testing.T) { } // object lambda with invalid arn - access point name contains invalid character: * -func TestEndpointCase245(t *testing.T) { +func TestEndpointCase246(t *testing.T) { var params = EndpointParameters{ Region: ptr.String("us-west-2"), UseFIPS: ptr.Bool(false), @@ -10800,7 +10861,7 @@ func TestEndpointCase245(t *testing.T) { } // object lambda with invalid arn - access point name contains invalid character: . -func TestEndpointCase246(t *testing.T) { +func TestEndpointCase247(t *testing.T) { var params = EndpointParameters{ Region: ptr.String("us-west-2"), UseFIPS: ptr.Bool(false), @@ -10823,7 +10884,7 @@ func TestEndpointCase246(t *testing.T) { } // object lambda with invalid arn - access point name contains sub resources -func TestEndpointCase247(t *testing.T) { +func TestEndpointCase248(t *testing.T) { var params = EndpointParameters{ Region: ptr.String("us-west-2"), UseFIPS: ptr.Bool(false), @@ -10846,7 +10907,7 @@ func TestEndpointCase247(t *testing.T) { } // object lambda with custom endpoint -func TestEndpointCase248(t *testing.T) { +func TestEndpointCase249(t *testing.T) { var params = EndpointParameters{ Region: ptr.String("us-west-2"), UseFIPS: ptr.Bool(false), @@ -10905,7 +10966,7 @@ func TestEndpointCase248(t *testing.T) { } // object lambda arn with region mismatch and UseArnRegion=false -func TestEndpointCase249(t *testing.T) { +func TestEndpointCase250(t *testing.T) { var params = EndpointParameters{ Accelerate: ptr.Bool(false), Bucket: ptr.String("arn:aws:s3-object-lambda:us-east-1:123456789012:accesspoint/mybanner"), @@ -10929,7 +10990,7 @@ func TestEndpointCase249(t *testing.T) { } // WriteGetObjectResponse @ us-west-2 -func TestEndpointCase250(t *testing.T) { +func TestEndpointCase251(t *testing.T) { var params = EndpointParameters{ Accelerate: ptr.Bool(false), UseObjectLambdaEndpoint: ptr.Bool(true), @@ -10986,7 +11047,7 @@ func TestEndpointCase250(t *testing.T) { } // WriteGetObjectResponse with custom endpoint -func TestEndpointCase251(t *testing.T) { +func TestEndpointCase252(t *testing.T) { var params = EndpointParameters{ Accelerate: ptr.Bool(false), UseObjectLambdaEndpoint: ptr.Bool(true), @@ -11044,7 +11105,7 @@ func TestEndpointCase251(t *testing.T) { } // WriteGetObjectResponse @ us-east-1 -func TestEndpointCase252(t *testing.T) { +func TestEndpointCase253(t *testing.T) { var params = EndpointParameters{ Accelerate: ptr.Bool(false), UseObjectLambdaEndpoint: ptr.Bool(true), @@ -11101,7 +11162,7 @@ func TestEndpointCase252(t *testing.T) { } // WriteGetObjectResponse with fips -func TestEndpointCase253(t *testing.T) { +func TestEndpointCase254(t *testing.T) { var params = EndpointParameters{ Accelerate: ptr.Bool(false), UseObjectLambdaEndpoint: ptr.Bool(true), @@ -11158,7 +11219,7 @@ func TestEndpointCase253(t *testing.T) { } // WriteGetObjectResponse with dualstack -func TestEndpointCase254(t *testing.T) { +func TestEndpointCase255(t *testing.T) { var params = EndpointParameters{ Accelerate: ptr.Bool(false), UseObjectLambdaEndpoint: ptr.Bool(true), @@ -11180,7 +11241,7 @@ func TestEndpointCase254(t *testing.T) { } // WriteGetObjectResponse with accelerate -func TestEndpointCase255(t *testing.T) { +func TestEndpointCase256(t *testing.T) { var params = EndpointParameters{ Accelerate: ptr.Bool(true), UseObjectLambdaEndpoint: ptr.Bool(true), @@ -11202,7 +11263,7 @@ func TestEndpointCase255(t *testing.T) { } // WriteGetObjectResponse with fips in CN -func TestEndpointCase256(t *testing.T) { +func TestEndpointCase257(t *testing.T) { var params = EndpointParameters{ Accelerate: ptr.Bool(false), Region: ptr.String("cn-north-1"), @@ -11224,7 +11285,7 @@ func TestEndpointCase256(t *testing.T) { } // WriteGetObjectResponse with invalid partition -func TestEndpointCase257(t *testing.T) { +func TestEndpointCase258(t *testing.T) { var params = EndpointParameters{ Accelerate: ptr.Bool(false), UseObjectLambdaEndpoint: ptr.Bool(true), @@ -11246,7 +11307,7 @@ func TestEndpointCase257(t *testing.T) { } // WriteGetObjectResponse with an unknown partition -func TestEndpointCase258(t *testing.T) { +func TestEndpointCase259(t *testing.T) { var params = EndpointParameters{ Accelerate: ptr.Bool(false), UseObjectLambdaEndpoint: ptr.Bool(true), @@ -11303,7 +11364,7 @@ func TestEndpointCase258(t *testing.T) { } // S3 Outposts bucketAlias Real Outpost Prod us-west-1 -func TestEndpointCase259(t *testing.T) { +func TestEndpointCase260(t *testing.T) { var params = EndpointParameters{ Region: ptr.String("us-west-1"), Bucket: ptr.String("test-accessp-o0b1d075431d83bebde8xz5w8ijx1qzlbp3i3kuse10--op-s3"), @@ -11373,7 +11434,7 @@ func TestEndpointCase259(t *testing.T) { } // S3 Outposts bucketAlias Real Outpost Prod ap-east-1 -func TestEndpointCase260(t *testing.T) { +func TestEndpointCase261(t *testing.T) { var params = EndpointParameters{ Region: ptr.String("ap-east-1"), Bucket: ptr.String("test-accessp-o0b1d075431d83bebde8xz5w8ijx1qzlbp3i3kuse10--op-s3"), @@ -11443,7 +11504,7 @@ func TestEndpointCase260(t *testing.T) { } // S3 Outposts bucketAlias Ec2 Outpost Prod us-east-1 -func TestEndpointCase261(t *testing.T) { +func TestEndpointCase262(t *testing.T) { var params = EndpointParameters{ Region: ptr.String("us-east-1"), Bucket: ptr.String("test-accessp-e0000075431d83bebde8xz5w8ijx1qzlbp3i3kuse10--op-s3"), @@ -11513,7 +11574,7 @@ func TestEndpointCase261(t *testing.T) { } // S3 Outposts bucketAlias Ec2 Outpost Prod me-south-1 -func TestEndpointCase262(t *testing.T) { +func TestEndpointCase263(t *testing.T) { var params = EndpointParameters{ Region: ptr.String("me-south-1"), Bucket: ptr.String("test-accessp-e0000075431d83bebde8xz5w8ijx1qzlbp3i3kuse10--op-s3"), @@ -11583,7 +11644,7 @@ func TestEndpointCase262(t *testing.T) { } // S3 Outposts bucketAlias Real Outpost Beta -func TestEndpointCase263(t *testing.T) { +func TestEndpointCase264(t *testing.T) { var params = EndpointParameters{ Region: ptr.String("us-east-1"), Bucket: ptr.String("test-accessp-o0b1d075431d83bebde8xz5w8ijx1qzlbp3i3kbeta0--op-s3"), @@ -11654,7 +11715,7 @@ func TestEndpointCase263(t *testing.T) { } // S3 Outposts bucketAlias Ec2 Outpost Beta -func TestEndpointCase264(t *testing.T) { +func TestEndpointCase265(t *testing.T) { var params = EndpointParameters{ Region: ptr.String("us-east-1"), Bucket: ptr.String("161743052723-e00000136899934034jeahy1t8gpzpbwjj8kb7beta0--op-s3"), @@ -11725,7 +11786,7 @@ func TestEndpointCase264(t *testing.T) { } // S3 Outposts bucketAlias - No endpoint set for beta -func TestEndpointCase265(t *testing.T) { +func TestEndpointCase266(t *testing.T) { var params = EndpointParameters{ Region: ptr.String("us-east-1"), Bucket: ptr.String("test-accessp-o0b1d075431d83bebde8xz5w8ijx1qzlbp3i3kbeta0--op-s3"), @@ -11747,7 +11808,7 @@ func TestEndpointCase265(t *testing.T) { } // S3 Outposts bucketAlias Invalid hardware type -func TestEndpointCase266(t *testing.T) { +func TestEndpointCase267(t *testing.T) { var params = EndpointParameters{ Region: ptr.String("us-east-1"), Bucket: ptr.String("test-accessp-h0000075431d83bebde8xz5w8ijx1qzlbp3i3kuse10--op-s3"), @@ -11769,7 +11830,7 @@ func TestEndpointCase266(t *testing.T) { } // S3 Outposts bucketAlias Special character in Outpost Arn -func TestEndpointCase267(t *testing.T) { +func TestEndpointCase268(t *testing.T) { var params = EndpointParameters{ Region: ptr.String("us-east-1"), Bucket: ptr.String("test-accessp-o00000754%1d83bebde8xz5w8ijx1qzlbp3i3kuse10--op-s3"), @@ -11791,7 +11852,7 @@ func TestEndpointCase267(t *testing.T) { } // S3 Outposts bucketAlias - No endpoint set for beta -func TestEndpointCase268(t *testing.T) { +func TestEndpointCase269(t *testing.T) { var params = EndpointParameters{ Region: ptr.String("us-east-1"), Bucket: ptr.String("test-accessp-e0b1d075431d83bebde8xz5w8ijx1qzlbp3i3ebeta0--op-s3"), @@ -11813,7 +11874,7 @@ func TestEndpointCase268(t *testing.T) { } // S3 Snow with bucket -func TestEndpointCase269(t *testing.T) { +func TestEndpointCase270(t *testing.T) { var params = EndpointParameters{ Region: ptr.String("snow"), Bucket: ptr.String("bucketName"), @@ -11871,7 +11932,7 @@ func TestEndpointCase269(t *testing.T) { } // S3 Snow without bucket -func TestEndpointCase270(t *testing.T) { +func TestEndpointCase271(t *testing.T) { var params = EndpointParameters{ Region: ptr.String("snow"), Endpoint: ptr.String("https://10.0.1.12:433"), @@ -11928,7 +11989,7 @@ func TestEndpointCase270(t *testing.T) { } // S3 Snow no port -func TestEndpointCase271(t *testing.T) { +func TestEndpointCase272(t *testing.T) { var params = EndpointParameters{ Region: ptr.String("snow"), Bucket: ptr.String("bucketName"), @@ -11986,7 +12047,7 @@ func TestEndpointCase271(t *testing.T) { } // S3 Snow dns endpoint -func TestEndpointCase272(t *testing.T) { +func TestEndpointCase273(t *testing.T) { var params = EndpointParameters{ Region: ptr.String("snow"), Bucket: ptr.String("bucketName"), @@ -12044,7 +12105,7 @@ func TestEndpointCase272(t *testing.T) { } // Data Plane with short AZ -func TestEndpointCase273(t *testing.T) { +func TestEndpointCase274(t *testing.T) { var params = EndpointParameters{ Region: ptr.String("us-east-1"), Bucket: ptr.String("mybucket--use1-az1--x-s3"), @@ -12103,7 +12164,7 @@ func TestEndpointCase273(t *testing.T) { } // Data Plane with short AZ fips -func TestEndpointCase274(t *testing.T) { +func TestEndpointCase275(t *testing.T) { var params = EndpointParameters{ Region: ptr.String("us-east-1"), Bucket: ptr.String("mybucket--use1-az1--x-s3"), @@ -12162,7 +12223,7 @@ func TestEndpointCase274(t *testing.T) { } // Data Plane with long AZ -func TestEndpointCase275(t *testing.T) { +func TestEndpointCase276(t *testing.T) { var params = EndpointParameters{ Region: ptr.String("ap-northeast-1"), Bucket: ptr.String("mybucket--apne1-az1--x-s3"), @@ -12221,7 +12282,7 @@ func TestEndpointCase275(t *testing.T) { } // Data Plane with long AZ fips -func TestEndpointCase276(t *testing.T) { +func TestEndpointCase277(t *testing.T) { var params = EndpointParameters{ Region: ptr.String("ap-northeast-1"), Bucket: ptr.String("mybucket--apne1-az1--x-s3"), @@ -12280,7 +12341,7 @@ func TestEndpointCase276(t *testing.T) { } // Control plane with short AZ bucket -func TestEndpointCase277(t *testing.T) { +func TestEndpointCase278(t *testing.T) { var params = EndpointParameters{ Region: ptr.String("us-east-1"), Bucket: ptr.String("mybucket--use1-az1--x-s3"), @@ -12340,7 +12401,7 @@ func TestEndpointCase277(t *testing.T) { } // Control plane with short AZ bucket and fips -func TestEndpointCase278(t *testing.T) { +func TestEndpointCase279(t *testing.T) { var params = EndpointParameters{ Region: ptr.String("us-east-1"), Bucket: ptr.String("mybucket--use1-az1--x-s3"), @@ -12400,7 +12461,7 @@ func TestEndpointCase278(t *testing.T) { } // Control plane without bucket -func TestEndpointCase279(t *testing.T) { +func TestEndpointCase280(t *testing.T) { var params = EndpointParameters{ Region: ptr.String("us-east-1"), UseFIPS: ptr.Bool(false), @@ -12459,7 +12520,7 @@ func TestEndpointCase279(t *testing.T) { } // Control plane without bucket and fips -func TestEndpointCase280(t *testing.T) { +func TestEndpointCase281(t *testing.T) { var params = EndpointParameters{ Region: ptr.String("us-east-1"), UseFIPS: ptr.Bool(true), @@ -12518,7 +12579,7 @@ func TestEndpointCase280(t *testing.T) { } // Data Plane sigv4 auth with short AZ -func TestEndpointCase281(t *testing.T) { +func TestEndpointCase282(t *testing.T) { var params = EndpointParameters{ Region: ptr.String("us-west-2"), Bucket: ptr.String("mybucket--usw2-az1--x-s3"), @@ -12577,7 +12638,7 @@ func TestEndpointCase281(t *testing.T) { } // Data Plane sigv4 auth with short AZ fips -func TestEndpointCase282(t *testing.T) { +func TestEndpointCase283(t *testing.T) { var params = EndpointParameters{ Region: ptr.String("us-west-2"), Bucket: ptr.String("mybucket--usw2-az1--x-s3"), @@ -12636,7 +12697,7 @@ func TestEndpointCase282(t *testing.T) { } // Data Plane sigv4 auth with long AZ -func TestEndpointCase283(t *testing.T) { +func TestEndpointCase284(t *testing.T) { var params = EndpointParameters{ Region: ptr.String("ap-northeast-1"), Bucket: ptr.String("mybucket--apne1-az1--x-s3"), @@ -12696,7 +12757,7 @@ func TestEndpointCase283(t *testing.T) { } // Data Plane sigv4 auth with long AZ fips -func TestEndpointCase284(t *testing.T) { +func TestEndpointCase285(t *testing.T) { var params = EndpointParameters{ Region: ptr.String("ap-northeast-1"), Bucket: ptr.String("mybucket--apne1-az1--x-s3"), @@ -12756,7 +12817,7 @@ func TestEndpointCase284(t *testing.T) { } // Control Plane host override -func TestEndpointCase285(t *testing.T) { +func TestEndpointCase286(t *testing.T) { var params = EndpointParameters{ Region: ptr.String("us-west-2"), Bucket: ptr.String("mybucket--usw2-az1--x-s3"), @@ -12817,7 +12878,7 @@ func TestEndpointCase285(t *testing.T) { } // Control Plane host override no bucket -func TestEndpointCase286(t *testing.T) { +func TestEndpointCase287(t *testing.T) { var params = EndpointParameters{ Region: ptr.String("us-west-2"), UseFIPS: ptr.Bool(false), @@ -12877,7 +12938,7 @@ func TestEndpointCase286(t *testing.T) { } // Data plane host override non virtual session auth -func TestEndpointCase287(t *testing.T) { +func TestEndpointCase288(t *testing.T) { var params = EndpointParameters{ Region: ptr.String("us-west-2"), Bucket: ptr.String("mybucket--usw2-az1--x-s3"), @@ -12936,7 +12997,7 @@ func TestEndpointCase287(t *testing.T) { } // Control Plane host override ip -func TestEndpointCase288(t *testing.T) { +func TestEndpointCase289(t *testing.T) { var params = EndpointParameters{ Region: ptr.String("us-west-2"), Bucket: ptr.String("mybucket--usw2-az1--x-s3"), @@ -12997,7 +13058,7 @@ func TestEndpointCase288(t *testing.T) { } // Data plane host override -func TestEndpointCase289(t *testing.T) { +func TestEndpointCase290(t *testing.T) { var params = EndpointParameters{ Region: ptr.String("us-west-2"), Bucket: ptr.String("mybucket--usw2-az1--x-s3"), @@ -13056,7 +13117,7 @@ func TestEndpointCase289(t *testing.T) { } // bad format error -func TestEndpointCase290(t *testing.T) { +func TestEndpointCase291(t *testing.T) { var params = EndpointParameters{ Region: ptr.String("us-east-1"), Bucket: ptr.String("mybucket--usaz1--x-s3"), @@ -13079,7 +13140,7 @@ func TestEndpointCase290(t *testing.T) { } // bad format error no session auth -func TestEndpointCase291(t *testing.T) { +func TestEndpointCase292(t *testing.T) { var params = EndpointParameters{ Region: ptr.String("us-east-1"), Bucket: ptr.String("mybucket--usaz1--x-s3"), @@ -13103,7 +13164,7 @@ func TestEndpointCase291(t *testing.T) { } // dual-stack error -func TestEndpointCase292(t *testing.T) { +func TestEndpointCase293(t *testing.T) { var params = EndpointParameters{ Region: ptr.String("us-east-1"), Bucket: ptr.String("mybucket--use1-az1--x-s3"), @@ -13126,7 +13187,7 @@ func TestEndpointCase292(t *testing.T) { } // accelerate error -func TestEndpointCase293(t *testing.T) { +func TestEndpointCase294(t *testing.T) { var params = EndpointParameters{ Region: ptr.String("us-east-1"), Bucket: ptr.String("mybucket--use1-az1--x-s3"), @@ -13149,7 +13210,7 @@ func TestEndpointCase293(t *testing.T) { } // Data plane bucket format error -func TestEndpointCase294(t *testing.T) { +func TestEndpointCase295(t *testing.T) { var params = EndpointParameters{ Region: ptr.String("us-east-1"), Bucket: ptr.String("my.bucket--use1-az1--x-s3"), @@ -13172,7 +13233,7 @@ func TestEndpointCase294(t *testing.T) { } // host override data plane bucket error session auth -func TestEndpointCase295(t *testing.T) { +func TestEndpointCase296(t *testing.T) { var params = EndpointParameters{ Region: ptr.String("us-west-2"), Bucket: ptr.String("my.bucket--usw2-az1--x-s3"), @@ -13195,7 +13256,7 @@ func TestEndpointCase295(t *testing.T) { } // host override data plane bucket error -func TestEndpointCase296(t *testing.T) { +func TestEndpointCase297(t *testing.T) { var params = EndpointParameters{ Region: ptr.String("us-west-2"), Bucket: ptr.String("my.bucket--usw2-az1--x-s3"),