diff --git a/s3api/middlewares/url-decoder.go b/s3api/middlewares/url-decoder.go new file mode 100644 index 0000000..ac61852 --- /dev/null +++ b/s3api/middlewares/url-decoder.go @@ -0,0 +1,32 @@ +// Copyright 2023 Versity Software +// This file is licensed under the Apache License, Version 2.0 +// (the "License"); you may not use this file except in compliance +// with the License. You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +package middlewares + +import ( + "net/url" + + "github.com/gofiber/fiber/v3" +) + +// DecodeURL url path unescapes the request url for the gateway +// to handle some special characters +func DecodeURL(ctx fiber.Ctx) error { + unescp, err := url.PathUnescape(string(ctx.Request().URI().PathOriginal())) + if err != nil { + return err + } + ctx.Path(unescp) + return nil +} diff --git a/tests/integration/general.go b/tests/integration/general.go new file mode 100644 index 0000000..50ff019 --- /dev/null +++ b/tests/integration/general.go @@ -0,0 +1,578 @@ +// Copyright 2023 Versity Software +// This file is licensed under the Apache License, Version 2.0 +// (the "License"); you may not use this file except in compliance +// with the License. You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +package integration + +import ( + "context" + "fmt" + "net/http" + "strings" + "time" + + "github.com/aws/aws-sdk-go-v2/service/s3" + "github.com/aws/aws-sdk-go-v2/service/s3/types" + "github.com/versity/versitygw/s3err" +) + +var ( + shortTimeout = 30 * time.Second + longTimeout = 60 * time.Second + iso8601Format = "20060102T150405Z" + timefmt = "Mon, 02 Jan 2006 15:04:05 GMT" + nullVersionId = "null" +) + +// router tests +func RouterPutPartNumberWithoutUploadId(s *S3Conf) error { + testName := "RouterPutPartNumberWithoutUploadId" + return actionHandlerNoSetup(s, testName, func(s3client *s3.Client, bucket string) error { + req, err := http.NewRequest(http.MethodPut, s.endpoint+"/bucket/object", nil) + if err != nil { + return err + } + + query := req.URL.Query() + query.Add("partNumber", "1") + req.URL.RawQuery = query.Encode() + + resp, err := s.httpClient.Do(req) + if err != nil { + return err + } + + if err := checkHTTPResponseApiErr(resp, s3err.GetInvalidArgumentErr(s3err.InvalidArgMissingUploadId, "partNumber")); err != nil { + return err + } + + return nil + }) +} + +func RouterPostRoot(s *S3Conf) error { + testName := "RouterPostRoot" + return actionHandlerNoSetup(s, testName, func(s3client *s3.Client, bucket string) error { + req, err := http.NewRequest(http.MethodPost, s.endpoint+"/", nil) + if err != nil { + return err + } + + resp, err := s.httpClient.Do(req) + if err != nil { + return err + } + + if err := checkHTTPResponseApiErr(resp, s3err.GetMethodNotAllowedErr(http.MethodPost, s3err.ResourceTypeService, nil)); err != nil { + return err + } + + return nil + }) +} + +func RouterPostObjectWithoutQuery(s *S3Conf) error { + testName := "RouterPostObjectWithoutQuery" + return actionHandler(s, testName, func(s3client *s3.Client, bucket string) error { + req, err := http.NewRequest(http.MethodPost, s.endpoint+"/bucket/object", nil) + if err != nil { + return err + } + + resp, err := s.httpClient.Do(req) + if err != nil { + return err + } + + if err := checkHTTPResponseApiErr(resp, s3err.GetMethodNotAllowedErr(http.MethodPost, s3err.ResourceTypeService, nil)); err != nil { + return err + } + + return nil + }) +} + +func RouterPUTObjectOnlyUploadId(s *S3Conf) error { + testName := "RouterPUTObjectOnlyUploadId" + return actionHandler(s, testName, func(s3client *s3.Client, bucket string) error { + req, err := http.NewRequest(http.MethodPut, s.endpoint+"/bucket/object", nil) + if err != nil { + return err + } + + query := req.URL.Query() + query.Add("uploadId", "my-upload-id") + req.URL.RawQuery = query.Encode() + + resp, err := s.httpClient.Do(req) + if err != nil { + return err + } + + if err := checkHTTPResponseApiErr(resp, s3err.GetMethodNotAllowedErr( + http.MethodPut, + s3err.ResourceTypeUpload, + []string{http.MethodDelete, http.MethodPost, http.MethodGet}, + )); err != nil { + return err + } + + return nil + }) +} + +func RouterGetUploadsWithKey(s *S3Conf) error { + testName := "RouterGetUploadsWithKey" + return actionHandlerNoSetup(s, testName, func(s3client *s3.Client, bucket string) error { + req, err := http.NewRequest(http.MethodGet, s.endpoint+"/bucket/object?uploads", nil) + if err != nil { + return err + } + + resp, err := s.httpClient.Do(req) + if err != nil { + return err + } + + return checkHTTPResponseApiErr(resp, s3err.GetAPIError(s3err.ErrGetUploadsWithKey)) + }) +} + +func RouterCopySourceNotAllowed(s *S3Conf) error { + testName := "RouterCopySourceNotAllowed" + return actionHandlerNoSetup(s, testName, func(s3client *s3.Client, bucket string) error { + for _, method := range []string{ + http.MethodPost, + http.MethodDelete, + http.MethodGet, + http.MethodHead, + } { + for _, path := range []string{ + "/bucket", + "/bucket/object", + } { + if method == http.MethodPost { + // the error for POST request occurs only when uploadId is there + path += "?uploadId=something" + } + + req, err := http.NewRequest(method, s.endpoint+path, nil) + if err != nil { + return fmt.Errorf("failed to make %s request to %s", method, path) + } + + req.Header.Add("x-amz-copy-source", "bucket/object") + + resp, err := s.httpClient.Do(req) + if err != nil { + return fmt.Errorf("failed to send %s request to %s", method, path) + } + + if method == http.MethodHead { + // for head requests only check the status code + if resp.StatusCode != http.StatusBadRequest { + return fmt.Errorf("expected 400 status code for HEAD %s request, instead got %v", path, resp.StatusCode) + } + } else { + if err := checkHTTPResponseApiErr(resp, s3err.GetInvalidArgumentErr(s3err.InvalidArgCopySource, "bucket/object")); err != nil { + return fmt.Errorf("%s %s: %w", method, path, err) + } + } + } + } + + return nil + }) +} + +func RouterListVersionsWithKey(s *S3Conf) error { + testName := "RouterListVersionsWithKey" + return actionHandlerNoSetup(s, testName, func(s3client *s3.Client, bucket string) error { + req, err := http.NewRequest(http.MethodGet, s.endpoint+"/bucket/object?versions", nil) + if err != nil { + return err + } + + resp, err := s.httpClient.Do(req) + if err != nil { + return err + } + + return checkHTTPResponseApiErr(resp, s3err.GetAPIError(s3err.ErrVersionsWithKey)) + }) +} + +func RouterObjectAnnotationNotImplemented(s *S3Conf) error { + testName := "RouterObjectAnnotationNotImplemented" + return actionHandler(s, testName, func(s3client *s3.Client, bucket string) error { + obj, name := "my-obj", "label" + _, err := putObjectWithData(10, &s3.PutObjectInput{ + Bucket: &bucket, + Key: &obj, + }, s3client) + if err != nil { + return err + } + + ctx, cancel := context.WithTimeout(context.Background(), shortTimeout) + _, err = s3client.PutObjectAnnotation(ctx, &s3.PutObjectAnnotationInput{ + Bucket: &bucket, + Key: &obj, + AnnotationName: &name, + AnnotationPayload: strings.NewReader(`{"label":"x"}`), + }) + cancel() + if err := checkApiErr(err, s3err.GetAPIError(s3err.ErrNotImplemented)); err != nil { + return fmt.Errorf("PutObjectAnnotation: %w", err) + } + + ctx, cancel = context.WithTimeout(context.Background(), shortTimeout) + _, err = s3client.GetObjectAnnotation(ctx, &s3.GetObjectAnnotationInput{ + Bucket: &bucket, + Key: &obj, + AnnotationName: &name, + }) + cancel() + if err := checkApiErr(err, s3err.GetAPIError(s3err.ErrNotImplemented)); err != nil { + return fmt.Errorf("GetObjectAnnotation: %w", err) + } + + ctx, cancel = context.WithTimeout(context.Background(), shortTimeout) + _, err = s3client.ListObjectAnnotations(ctx, &s3.ListObjectAnnotationsInput{ + Bucket: &bucket, + Key: &obj, + }) + cancel() + if err := checkApiErr(err, s3err.GetAPIError(s3err.ErrNotImplemented)); err != nil { + return fmt.Errorf("ListObjectAnnotations: %w", err) + } + + ctx, cancel = context.WithTimeout(context.Background(), shortTimeout) + _, err = s3client.DeleteObjectAnnotation(ctx, &s3.DeleteObjectAnnotationInput{ + Bucket: &bucket, + Key: &obj, + AnnotationName: &name, + }) + cancel() + if err := checkApiErr(err, s3err.GetAPIError(s3err.ErrNotImplemented)); err != nil { + return fmt.Errorf("DeleteObjectAnnotation: %w", err) + } + + return nil + }) +} + +func RouterRenameObjectNotImplemented(s *S3Conf) error { + testName := "RouterRenameObjectNotImplemented" + return actionHandler(s, testName, func(s3client *s3.Client, bucket string) error { + src, dst := "src-obj", "dst-obj" + _, err := putObjectWithData(10, &s3.PutObjectInput{ + Bucket: &bucket, + Key: &src, + }, s3client) + if err != nil { + return err + } + + ctx, cancel := context.WithTimeout(context.Background(), shortTimeout) + _, err = s3client.RenameObject(ctx, &s3.RenameObjectInput{ + Bucket: &bucket, + Key: &dst, + RenameSource: &src, + }) + cancel() + + return checkApiErr(err, s3err.GetAPIError(s3err.ErrNotImplemented)) + }) +} + +func RouterObjectTorrentMethodNotAllowed(s *S3Conf) error { + testName := "RouterObjectTorrentMethodNotAllowed" + return actionHandlerNoSetup(s, testName, func(s3client *s3.Client, bucket string) error { + for _, method := range []string{ + http.MethodGet, + http.MethodHead, + http.MethodPut, + http.MethodDelete, + http.MethodPost, + } { + req, err := http.NewRequest(method, s.endpoint+"/bucket/object?torrent", nil) + if err != nil { + return fmt.Errorf("failed to make %s request: %w", method, err) + } + + resp, err := s.httpClient.Do(req) + if err != nil { + return fmt.Errorf("failed to send %s request: %w", method, err) + } + + var allowed []string + if method != http.MethodGet { + allowed = []string{http.MethodGet} + } + expected := s3err.GetMethodNotAllowedErr(method, s3err.ResourceTypeTorrent, allowed) + if got, want := resp.Header.Get("Allow"), expected.AllowedMethodsString(); got != want { + return fmt.Errorf("%s: expected Allow header %q, instead got %q", method, want, got) + } + + if method == http.MethodHead { + // for head requests only check the status code + if resp.StatusCode != http.StatusMethodNotAllowed { + return fmt.Errorf("expected 405 status code for HEAD request, instead got %v", resp.StatusCode) + } + continue + } + + if err := checkHTTPResponseApiErr(resp, expected); err != nil { + return fmt.Errorf("%s: %w", method, err) + } + } + + return nil + }) +} + +// CORS middleware tests +func CORSMiddleware_invalid_method(s *S3Conf) error { + testName := "CORSMiddleware_invalid_method" + return actionHandler(s, testName, func(s3client *s3.Client, bucket string) error { + err := putBucketCors(s3client, &s3.PutBucketCorsInput{ + Bucket: &bucket, + CORSConfiguration: &types.CORSConfiguration{ + CORSRules: []types.CORSRule{ + { + AllowedOrigins: []string{"http://www.example.com"}, + AllowedMethods: []string{http.MethodPut}, + }, + }, + }, + }) + if err != nil { + return err + } + + // create a PutObject signed request + req, err := createSignedReq(http.MethodPut, s.endpoint, bucket+"/my-obj", s.awsID, s.awsSecret, "s3", s.awsRegion, "", nil, time.Now(), map[string]string{ + "Origin": "http://www.example.com", + "Access-Control-Request-Method": "invalid_method", + }) + if err != nil { + return err + } + + resp, err := s.httpClient.Do(req) + if err != nil { + return err + } + + result, err := extractCORSHeaders(resp) + if err != nil { + return err + } + + return checkApiErr(result.err, s3err.GetInvalidCORSMethodErr("invalid_method")) + }) +} + +func CORSMiddleware_invalid_headers(s *S3Conf) error { + testName := "CORSMiddleware_invalid_headers" + return actionHandler(s, testName, func(s3client *s3.Client, bucket string) error { + err := putBucketCors(s3client, &s3.PutBucketCorsInput{ + Bucket: &bucket, + CORSConfiguration: &types.CORSConfiguration{ + CORSRules: []types.CORSRule{ + { + AllowedOrigins: []string{"http://www.example.com"}, + AllowedMethods: []string{http.MethodPut}, + }, + }, + }, + }) + if err != nil { + return err + } + + // create a PutObject signed request + req, err := createSignedReq(http.MethodPut, s.endpoint, bucket+"/my-obj", s.awsID, s.awsSecret, "s3", s.awsRegion, "", nil, time.Now(), map[string]string{ + "Origin": "http://www.example.com", + "Access-Control-Request-Headers": "invalid header", + }) + if err != nil { + return err + } + + resp, err := s.httpClient.Do(req) + if err != nil { + return err + } + + result, err := extractCORSHeaders(resp) + if err != nil { + return err + } + + return checkApiErr(result.err, s3err.GetInvalidCORSRequestHeaderErr("invalid header")) + }) +} + +func CORSMiddleware_access_forbidden(s *S3Conf) error { + testName := "CORSMiddleware_access_forbidden" + return actionHandler(s, testName, func(s3client *s3.Client, bucket string) error { + err := putBucketCors(s3client, &s3.PutBucketCorsInput{ + Bucket: &bucket, + CORSConfiguration: &types.CORSConfiguration{ + CORSRules: []types.CORSRule{ + { + AllowedOrigins: []string{"http://example.com", "https://example.com"}, + AllowedMethods: []string{http.MethodGet}, + AllowedHeaders: []string{"X-Amz-Date", "X-Amz-Content-Sha256"}, + }, + { + AllowedOrigins: []string{"*"}, + AllowedMethods: []string{http.MethodHead}, + }, + }, + }, + }) + if err != nil { + return err + } + + for _, test := range []struct { + origin string + method string + headers string + }{ + // origin deson't match + {"http://non-matching-origin.net", http.MethodGet, "X-Amz-Date"}, + // method doesn't match + {"http://example.com", http.MethodPut, "X-Amz-Content-Sha256"}, + // header doesn't match + {"http://example.com", http.MethodGet, "X-Amz-Expected-Bucket-Owner"}, + // extra header + {"http://example.com", http.MethodGet, "X-Amz-Date,X-Amz-Content-Sha256,Extra-Header"}, + // extra header (2nd rule) + {"https://any-origin.com", http.MethodHead, "X-Amz-Extra-Header"}, + // origin match, method not (2nd rule) + {"https://any-origin.com", http.MethodPost, ""}, + } { + req, err := createSignedReq(http.MethodPut, s.endpoint, bucket+"/my-obj", s.awsID, s.awsSecret, "s3", s.awsRegion, "", nil, time.Now(), map[string]string{ + "Origin": test.origin, + "Access-Control-Request-Headers": test.headers, + "Access-Control-Request-Method": test.method, + }) + if err != nil { + return err + } + + resp, err := s.httpClient.Do(req) + if err != nil { + return err + } + + res, err := extractCORSHeaders(resp) + if err != nil { + return err + } + + // no error expected, all the headers should be empty + if err := comparePreflightResult(&PreflightResult{}, res); err != nil { + return err + } + } + + return nil + }) +} + +func CORSMiddleware_access_granted(s *S3Conf) error { + testName := "CORSMiddleware_access_granted" + return actionHandler(s, testName, func(s3client *s3.Client, bucket string) error { + err := putBucketCors(s3client, &s3.PutBucketCorsInput{ + Bucket: &bucket, + CORSConfiguration: &types.CORSConfiguration{ + CORSRules: []types.CORSRule{ + { + AllowedOrigins: []string{"http://example.com", "https://example.com"}, + AllowedMethods: []string{http.MethodGet, http.MethodHead}, + AllowedHeaders: []string{"X-Amz-Date", "X-Amz-Content-Sha256"}, + ExposeHeaders: []string{"Content-Type", "Content-Length"}, + MaxAgeSeconds: getPtr(int32(100)), + }, + { + AllowedOrigins: []string{"*"}, + AllowedMethods: []string{http.MethodHead}, + AllowedHeaders: []string{"X-Amz-Meta-Something"}, + }, + { + AllowedOrigins: []string{"something.net"}, + AllowedMethods: []string{http.MethodPost, http.MethodPut}, + AllowedHeaders: []string{"Authorization"}, + ExposeHeaders: []string{"Content-Disposition", "Content-Encoding"}, + MaxAgeSeconds: getPtr(int32(3000)), + ID: getPtr("unique_id"), + }, + }, + }, + }) + if err != nil { + return err + } + + varyHdr := "Origin, Access-Control-Request-Headers, Access-Control-Request-Method" + + for _, test := range []struct { + origin string + method string + headers string + result PreflightResult + }{ + // first rule matches + {"http://example.com", http.MethodGet, "X-Amz-Date", PreflightResult{"http://example.com", "GET, HEAD", "x-amz-date, x-amz-content-sha256", "Content-Type, Content-Length", "100", "true", varyHdr, nil}}, + {"http://example.com", http.MethodGet, "X-Amz-Content-Sha256", PreflightResult{"http://example.com", "GET, HEAD", "x-amz-date, x-amz-content-sha256", "Content-Type, Content-Length", "100", "true", varyHdr, nil}}, + {"http://example.com", http.MethodHead, "", PreflightResult{"http://example.com", "GET, HEAD", "", "Content-Type, Content-Length", "100", "true", varyHdr, nil}}, + {"https://example.com", http.MethodGet, "X-Amz-Date,X-Amz-Content-Sha256", PreflightResult{"https://example.com", "GET, HEAD", "x-amz-date, x-amz-content-sha256", "Content-Type, Content-Length", "100", "true", varyHdr, nil}}, + // second rule matches + {"http://anything.com", http.MethodHead, "X-Amz-Meta-Something", PreflightResult{"*", "HEAD", "x-amz-meta-something", "", "", "false", varyHdr, nil}}, + {"hello.com", http.MethodHead, "", PreflightResult{"*", "HEAD", "", "", "", "false", varyHdr, nil}}, + // third rule matches + {"something.net", http.MethodPut, "Authorization", PreflightResult{"something.net", "POST, PUT", "authorization", "Content-Disposition, Content-Encoding", "3000", "true", varyHdr, nil}}, + {"something.net", http.MethodPost, "", PreflightResult{"something.net", "POST, PUT", "", "Content-Disposition, Content-Encoding", "3000", "true", varyHdr, nil}}, + } { + req, err := createSignedReq(http.MethodPut, s.endpoint, bucket+"/my-obj", s.awsID, s.awsSecret, "s3", s.awsRegion, "", nil, time.Now(), map[string]string{ + "Origin": test.origin, + "Access-Control-Request-Headers": test.headers, + "Access-Control-Request-Method": test.method, + }) + if err != nil { + return err + } + + resp, err := s.httpClient.Do(req) + if err != nil { + return err + } + + res, err := extractCORSHeaders(resp) + if err != nil { + return err + } + + if err := comparePreflightResult(&test.result, res); err != nil { + return err + } + } + + return nil + }) +} diff --git a/tests/integration/group-tests.go b/tests/integration/group-tests.go new file mode 100644 index 0000000..0b5eb90 --- /dev/null +++ b/tests/integration/group-tests.go @@ -0,0 +1,3823 @@ +// Copyright 2023 Versity Software +// This file is licensed under the Apache License, Version 2.0 +// (the "License"); you may not use this file except in compliance +// with the License. You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +package integration + +func TestAuthentication(ts *TestState) { + ts.Run(Authentication_invalid_auth_header) + ts.Run(Authentication_unsupported_signature_version) + ts.Run(Authentication_missing_components) + ts.Run(Authentication_malformed_component) + ts.Run(Authentication_missing_credentials) + ts.Run(Authentication_missing_signedheaders) + ts.Run(Authentication_missing_signature) + ts.Run(Authentication_malformed_credential) + ts.Run(Authentication_credentials_invalid_terminal) + ts.Run(Authentication_credentials_incorrect_service) + ts.Run(Authentication_credentials_incorrect_region) + ts.Run(Authentication_credentials_incorrect_region_head) + ts.Run(Authentication_credentials_invalid_date) + ts.Run(Authentication_credentials_future_date) + ts.Run(Authentication_credentials_past_date) + ts.Run(Authentication_credentials_non_existing_access_key) + //TODO: handle the case with signed headers + ts.Run(Authentication_missing_date_header) + ts.Run(Authentication_invalid_date_header) + ts.Run(Authentication_date_mismatch) + ts.Run(Authentication_incorrect_payload_hash) + ts.Run(Authentication_invalid_sha256_payload_hash) + ts.Run(Authentication_unsigned_required_header) + ts.Run(Authentication_unsigned_non_required_header) + ts.Run(Authentication_signature_error_incorrect_secret_key) + ts.Run(Authentication_sigv2_not_supported) + ts.Run(Authentication_with_expect_header) +} + +func TestPresignedAuthentication(ts *TestState) { + ts.Run(PresignedAuth_security_token_with_permanent_credentials) + ts.Run(PresignedAuth_unsupported_algorithm) + ts.Run(PresignedAuth_ECDSA_not_supported) + ts.Run(PresignedAuth_missing_signature_query_param) + ts.Run(PresignedAuth_missing_credentials_query_param) + ts.Run(PresignedAuth_malformed_creds_invalid_parts) + ts.Run(PresignedAuth_creds_invalid_terminal) + ts.Run(PresignedAuth_creds_incorrect_service) + ts.Run(PresignedAuth_creds_incorrect_region) + ts.Run(PresignedAuth_creds_invalid_date) + ts.Run(PresignedAuth_missing_date_query) + ts.Run(PresignedAuth_dates_mismatch) + ts.Run(PresignedAuth_non_existing_access_key_id) + ts.Run(PresignedAuth_missing_signed_headers_query_param) + ts.Run(PresignedAuth_unsigned_required_header) + ts.Run(PresignedAuth_unsigned_non_required_header) + ts.Run(PresignedAuth_missing_expiration_query_param) + ts.Run(PresignedAuth_invalid_expiration_query_param) + ts.Run(PresignedAuth_negative_expiration_query_param) + ts.Run(PresignedAuth_exceeding_expiration_query_param) + ts.Run(PresignedAuth_expired_request) + ts.Run(PresignedAuth_incorrect_secret_key) + ts.Run(PresignedAuth_sigv2_not_supported) + ts.Run(PresignedAuth_PutObject_success) + ts.Run(PresignedAuth_PutObject_strips_aws_chunked_content_encoding) + ts.Run(PresignedAuth_CopyObject_strips_aws_chunked_content_encoding) + ts.Run(PresignedAuth_CreateMultipartUpload_strips_aws_chunked_content_encoding) + ts.Run(PresignedAuth_Put_GetObject_with_data) + if !ts.conf.azureTests { + ts.Run(PresignedAuth_Put_GetObject_with_UTF8_chars) + } + ts.Run(PresignedAuth_UploadPart) +} + +func TestCreateBucket(ts *TestState) { + ts.Run(CreateBucket_invalid_bucket_name) + ts.Run(CreateBucket_existing_bucket) + ts.Run(CreateBucket_owned_by_you) + ts.Run(CreateBucket_invalid_ownership) + ts.Run(CreateBucket_ownership_with_acl) + ts.Run(CreateBucket_as_user) + ts.Run(CreateBucket_default_acl) + ts.Run(CreateBucket_non_default_acl) + ts.Run(CreateBucket_private_canned_acl) + ts.Run(CreateBucket_private_canned_acl_bucket_owner_enforced_ownership) + ts.Run(CreateBucket_success) + ts.Run(CreateBucket_default_object_lock) + ts.Run(CreateBucket_invalid_location_constraint) + ts.Run(CreateBucket_long_tags) + ts.Run(CreateBucket_invalid_tags) + ts.Run(CreateBucket_duplicate_keys) + ts.Run(CreateBucket_tag_count_limit) + ts.Run(CreateBucket_invalid_canned_acl) +} + +func TestHeadBucket(ts *TestState) { + ts.Run(HeadBucket_non_existing_bucket) + ts.Run(HeadBucket_success) +} + +func TestListBuckets(ts *TestState) { + ts.Sync(ListBuckets_as_user) + ts.Sync(ListBuckets_as_admin) + ts.Sync(ListBuckets_with_prefix) + ts.Sync(ListBuckets_invalid_max_buckets) + ts.Sync(ListBuckets_truncated) + ts.Sync(ListBuckets_success) + ts.Sync(ListBuckets_empty_success) +} + +func TestDeleteBucket(ts *TestState) { + ts.Run(DeleteBucket_non_existing_bucket) + ts.Run(DeleteBucket_non_empty_bucket) + ts.Run(DeleteBucket_success_status_code) + ts.Run(DeleteBucket_incorrect_expected_bucket_owner) +} + +func TestPutBucketOwnershipControls(ts *TestState) { + ts.Run(PutBucketOwnershipControls_non_existing_bucket) + ts.Run(PutBucketOwnershipControls_multiple_rules) + ts.Run(PutBucketOwnershipControls_invalid_ownership) + ts.Run(PutBucketOwnershipControls_empty_rules) + ts.Run(PutBucketOwnershipControls_success) +} + +func TestGetBucketOwnershipControls(ts *TestState) { + ts.Run(GetBucketOwnershipControls_non_existing_bucket) + ts.Run(GetBucketOwnershipControls_default_ownership) + ts.Run(GetBucketOwnershipControls_success) +} + +func TestDeleteBucketOwnershipControls(ts *TestState) { + ts.Run(DeleteBucketOwnershipControls_non_existing_bucket) + ts.Run(DeleteBucketOwnershipControls_success) +} + +func TestPutBucketTagging(ts *TestState) { + ts.Run(PutBucketTagging_non_existing_bucket) + ts.Run(PutBucketTagging_long_tags) + ts.Run(PutBucketTagging_invalid_tags) + ts.Run(PutBucketTagging_duplicate_keys) + ts.Run(PutBucketTagging_tag_count_limit) + ts.Run(PutBucketTagging_success) + ts.Run(PutBucketTagging_success_status) +} + +func TestGetBucketTagging(ts *TestState) { + ts.Run(GetBucketTagging_non_existing_bucket) + ts.Run(GetBucketTagging_unset_tags) + ts.Run(GetBucketTagging_success) +} + +func TestDeleteBucketTagging(ts *TestState) { + ts.Run(DeleteBucketTagging_non_existing_object) + ts.Run(DeleteBucketTagging_success_status) + ts.Run(DeleteBucketTagging_success) +} + +func TestGetBucketLocation(ts *TestState) { + ts.Run(GetBucketLocation_success) + ts.Run(GetBucketLocation_non_exist) + ts.Run(GetBucketLocation_no_access) +} + +func TestPutObject(ts *TestState) { + ts.Run(PutObject_non_existing_bucket) + ts.Run(PutObject_special_chars) + ts.Run(PutObject_aborted_plain_body) + ts.Run(PutObject_plain_body_with_decoded_length) + ts.Run(PutObject_plain_stores_aws_chunked_content_encoding) + ts.Run(PutObject_unsigned_payload_with_aws_chunked_content_encoding) + ts.Run(PutObject_tagging) + ts.Run(PutObject_missing_object_lock_retention_config) + ts.Run(PutObject_with_object_lock) + ts.Run(PutObject_missing_bucket_lock) + ts.Run(PutObject_invalid_legal_hold) + ts.Run(PutObject_invalid_object_lock_mode) + ts.Run(PutObject_object_lock_checksum_required) + ts.Run(PutObject_default_retention_checksum_required) + ts.Run(PutObject_past_retain_until_date) + ts.Run(PutObject_invalid_retain_until_date) + ts.Run(PutObject_conditional_writes) + ts.Run(PutObject_should_combine_metadata) + ts.Run(PutObject_md5) + //TODO: remove the condition after implementing checksums in azure + if !ts.conf.azureTests { + ts.Run(PutObject_checksum_algorithm_and_header_mismatch) + ts.Run(PutObject_multiple_checksum_headers) + ts.Run(PutObject_invalid_checksum_header) + ts.Run(PutObject_incorrect_checksums) + ts.Run(PutObject_default_checksum) + ts.Run(PutObject_dir_object_default_checksum) + ts.Run(PutObject_checksums_success) + ts.Run(PutObject_dir_object_checksums_success) + // azure applies some encoding mechanisms. + ts.Run(PutObject_false_negative_object_names) + // azure doesn't support these metadata characters + ts.Run(PutObject_with_metadata) + } + ts.Run(PutObject_success) + ts.Run(PutObject_default_content_type) + ts.Run(PutObject_overwrite_resets_attributes) + ts.Run(PutObject_overwrite_multipart_object) + ts.Run(PutObject_dir_object_overwrite_resets_attributes) + if !ts.conf.versioningEnabled && !ts.conf.windowsTests { + ts.Run(PutObject_racey_success) + } + ts.Run(PutObject_invalid_credentials) + ts.Run(PutObject_invalid_object_names) + ts.Run(PutObject_object_acl_not_supported) + ts.Run(PutObject_long_metadata) + ts.Run(PutObject_invalid_website_redirect_location) +} + +func TestHeadObject(ts *TestState) { + ts.Run(HeadObject_non_existing_object) + ts.Run(HeadObject_invalid_part_number) + ts.Run(HeadObject_directory_object_noslash) + ts.Run(HeadObject_non_existing_dir_object) + ts.Run(HeadObject_incidental_dir_object) + ts.Run(HeadObject_invalid_parent_dir) + ts.Run(HeadObject_with_range) + ts.Run(HeadObject_by_range_resp_status) + ts.Run(HeadObject_zero_len_with_range) + ts.Run(HeadObject_dir_with_range) + ts.Run(HeadObject_conditional_reads) + //TODO: remove the condition after implementing checksums in azure + if !ts.conf.azureTests { + ts.Run(HeadObject_not_enabled_checksum_mode) + ts.Run(HeadObject_checksums) + ts.Run(HeadObject_ranged_with_checksum_mode) + } + ts.Run(HeadObject_success) + ts.Run(HeadObject_overrides_success) + ts.Run(HeadObject_overrides_presign_success) + ts.Run(HeadObject_overrides_fail_public) + ts.Run(HeadObject_range_and_part_number) + ts.Run(HeadObject_mp_part_number_exceeds_parts_count) + ts.Run(HeadObject_mp_part_number_success) + ts.Run(HeadObject_mp_part_number_resp_status) + ts.Run(HeadObject_non_mp_part_number_1_success) + ts.Run(HeadObject_empty_object_part_number_1) + ts.Run(HeadObject_empty_version_id) +} + +func TestGetObjectAttributes(ts *TestState) { + ts.Run(GetObjectAttributes_non_existing_bucket) + ts.Run(GetObjectAttributes_non_existing_object) + ts.Run(GetObjectAttributes_invalid_attrs) + ts.Run(GetObjectAttributes_invalid_parent) + ts.Run(GetObjectAttributes_invalid_single_attribute) + ts.Run(GetObjectAttributes_empty_attrs) + ts.Run(GetObjectAttributes_existing_object) + //TODO: remove the condition after implementing checksums in azure + if !ts.conf.azureTests { + ts.Run(GetObjectAttributes_checksums) + } + ts.Run(GetObjectAttributes_empty_version_id) +} + +func TestGetObject(ts *TestState) { + ts.Run(GetObject_non_existing_key) + ts.Run(GetObject_directory_object_noslash) + ts.Run(GetObject_with_range) + ts.Run(GetObject_zero_len_with_range) + ts.Run(GetObject_dir_with_range) + ts.Run(GetObject_invalid_parent) + ts.Sync(GetObject_large_object) + ts.Run(GetObject_conditional_reads) + //TODO: remove the condition after implementing checksums in azure + if !ts.conf.azureTests { + ts.Run(GetObject_not_enabled_checksum_mode) + ts.Run(GetObject_checksums) + ts.Run(GetObject_dir_object_checksum) + ts.Run(GetObject_ranged_with_checksum_mode) + } + ts.Run(GetObject_success) + ts.Run(GetObject_directory_success) + ts.Run(GetObject_by_range_resp_status) + ts.Run(GetObject_non_existing_dir_object) + ts.Run(GetObject_incidental_dir_object) + ts.Run(GetObject_overrides_success) + ts.Run(GetObject_overrides_presign_success) + ts.Run(GetObject_overrides_fail_public) + ts.Run(GetObject_invalid_part_number) + ts.Run(GetObject_range_and_part_number) + ts.Run(GetObject_mp_part_number_exceeds_parts_count) + ts.Run(GetObject_mp_part_number_success) + ts.Run(GetObject_mp_part_number_resp_status) + ts.Run(GetObject_non_mp_part_number_1_success) + ts.Run(GetObject_empty_object_part_number_1) + ts.Run(GetObject_empty_version_id) +} + +func TestListObjects(ts *TestState) { + ts.Run(ListObjects_non_existing_bucket) + ts.Run(ListObjects_with_prefix) + ts.Run(ListObjects_truncated) + ts.Run(ListObjects_paginated) + ts.Run(ListObjects_invalid_max_keys) + ts.Run(ListObjects_max_keys_0) + ts.Run(ListObjects_exceeding_max_keys) + ts.Run(ListObjects_delimiter) + ts.Run(ListObjects_max_keys_none) + ts.Run(ListObjects_marker_not_from_obj_list) + ts.Run(ListObjects_list_all_objs) + ts.Run(ListObjects_nested_dir_file_objs) + ts.Run(ListObjects_check_owner) + ts.Run(ListObjects_non_truncated_common_prefixes) + ts.Run(ListObjects_should_not_list_pending_mps) + ts.Run(ListObjects_mp_masking_with_marker) + ts.Run(ListObjects_mp_masking_truncation) + ts.Run(ListObjects_mp_masking_delimiter) + //TODO: remove the condition after implementing checksums in azure + if !ts.conf.azureTests { + ts.Run(ListObjects_with_checksum) + } +} + +func TestListObjectsV2(ts *TestState) { + ts.Run(ListObjectsV2_start_after) + ts.Run(ListObjectsV2_both_start_after_and_continuation_token) + ts.Run(ListObjectsV2_start_after_not_in_list) + ts.Run(ListObjectsV2_start_after_empty_result) + ts.Run(ListObjectsV2_both_delimiter_and_prefix) + ts.Run(ListObjectsV2_single_dir_object_with_delim_and_prefix) + ts.Run(ListObjectsV2_truncated_common_prefixes) + ts.Run(ListObjectsV2_all_objs_max_keys) + ts.Run(ListObjectsV2_exceeding_max_keys) + ts.Run(ListObjectsV2_list_all_objs) + ts.Run(ListObjectsV2_full_pagination) + ts.Run(ListObjectsV2_pagination_with_delimiter) + ts.Run(ListObjectsV2_with_owner) + ts.Run(ListObjectsV2_non_truncated_common_prefixes) + //TODO: remove the condition after implementing checksums in azure + if !ts.conf.azureTests { + ts.Run(ListObjectsV2_with_checksum) + } + ts.Run(ListObjectsV2_invalid_parent_prefix) + ts.Run(ListObjectsV2_should_not_list_pending_mps) + ts.Run(ListObjectsV2_mp_masking_start_after) + ts.Run(ListObjectsV2_mp_masking_truncation) + ts.Run(ListObjectsV2_mp_masking_delimiter) +} + +// VD stands for Versioning Disabled +func TestListObjectVersions_VD(ts *TestState) { + ts.Run(ListObjectVersions_VD_success) +} + +func TestDeleteObject(ts *TestState) { + ts.Run(DeleteObject_non_existing_object) + ts.Run(DeleteObject_directory_object_noslash) + ts.Run(DeleteObject_non_existing_dir_object) + ts.Run(DeleteObject_directory_object) + ts.Run(DeleteObject_non_empty_dir_obj) + ts.Run(DeleteObject_conditional_writes) + ts.Run(DeleteObject_success) + ts.Run(DeleteObject_success_status_code) + ts.Run(DeleteObject_incorrect_expected_bucket_owner) + ts.Run(DeleteObject_expected_bucket_owner) + ts.Run(DeleteObject_empty_version_id) +} + +func TestDeleteObjects(ts *TestState) { + ts.Run(DeleteObjects_non_existing_bucket) + ts.Run(DeleteObjects_empty_input) + ts.Run(DeleteObjects_non_existing_objects) + ts.Run(DeleteObjects_success) + ts.Run(DeleteObjects_quiet_mode) + ts.Run(DeleteObjects_key_limit) + ts.Run(DeleteObjects_invalid_object_keys) +} + +func TestCopyObject(ts *TestState) { + ts.Run(CopyObject_non_existing_dst_bucket) + ts.Run(CopyObject_not_owned_source_bucket) + ts.Run(CopyObject_copy_to_itself) + ts.Run(CopyObject_copy_to_itself_invalid_directive) + ts.Run(CopyObject_should_replace_tagging) + ts.Run(CopyObject_should_copy_tagging) + ts.Run(CopyObject_invalid_tagging_directive) + ts.Run(CopyObject_to_itself_with_new_metadata) + ts.Run(CopyObject_long_metadata) + ts.Run(CopyObject_copy_source_starting_with_slash) + ts.Run(CopyObject_invalid_copy_source) + ts.Run(CopyObject_non_existing_dir_object) + ts.Run(CopyObject_should_copy_meta_props) + ts.Run(CopyObject_should_not_copy_website_redirect_without_user_metadata) + ts.Run(CopyObject_should_replace_meta_props) + ts.Run(CopyObject_overwrite_resets_attributes) + ts.Run(CopyObject_invalid_website_redirect_location) + ts.Run(CopyObject_default_content_type_with_replace_metadata) + ts.Run(CopyObject_missing_bucket_lock) + ts.Run(CopyObject_invalid_legal_hold) + ts.Run(CopyObject_invalid_object_lock_mode) + ts.Run(CopyObject_with_legal_hold) + ts.Run(CopyObject_with_retention_lock) + ts.Run(CopyObject_conditional_reads) + ts.Run(CopyObject_object_acl_not_supported) + //TODO: remove the condition after implementing checksums in azure + if !ts.conf.azureTests { + ts.Run(CopyObject_invalid_checksum_algorithm) + ts.Run(CopyObject_create_checksum_on_copy) + ts.Run(CopyObject_should_copy_the_existing_checksum) + ts.Run(CopyObject_should_replace_the_existing_checksum) + ts.Run(CopyObject_to_itself_by_replacing_the_checksum) + // azure doesn't support these metadata characters + ts.Run(CopyObject_with_metadata) + } + ts.Run(CopyObject_with_special_characters) + ts.Run(CopyObject_success) + ts.Run(CopyObject_cross_bucket_server_side_copy) + ts.Run(CopyObject_incorrect_source_bucket_expected_owner) +} + +func TestPutObjectTagging(ts *TestState) { + ts.Run(PutObjectTagging_non_existing_object) + ts.Run(PutObjectTagging_long_tags) + ts.Run(PutObjectTagging_duplicate_keys) + ts.Run(PutObjectTagging_tag_count_limit) + ts.Run(PutObjectTagging_invalid_tags) + ts.Run(PutObjectTagging_success) + ts.Run(PutObjectTagging_empty_version_id) +} + +func TestGetObjectTagging(ts *TestState) { + ts.Run(GetObjectTagging_non_existing_object) + ts.Run(GetObjectTagging_unset_tags) + ts.Run(GetObjectTagging_invalid_parent) + ts.Run(GetObjectTagging_success) + ts.Run(GetObjectTagging_empty_version_id) +} + +func TestDeleteObjectTagging(ts *TestState) { + ts.Run(DeleteObjectTagging_non_existing_object) + ts.Run(DeleteObjectTagging_success_status) + ts.Run(DeleteObjectTagging_success) + ts.Run(DeleteObjectTagging_expected_bucket_owner) + ts.Run(DeleteObjectTagging_empty_version_id) +} + +func TestCreateMultipartUpload(ts *TestState) { + ts.Run(CreateMultipartUpload_non_existing_bucket) + ts.Run(CreateMultipartUpload_long_metadata) + ts.Run(CreateMultipartUpload_with_metadata) + ts.Run(CreateMultipartUpload_invalid_website_redirect_location) + ts.Run(CreateMultipartUpload_with_tagging) + ts.Run(CreateMultipartUpload_with_object_lock) + ts.Run(CreateMultipartUpload_with_object_lock_not_enabled) + ts.Run(CreateMultipartUpload_with_object_lock_invalid_retention) + ts.Run(CreateMultipartUpload_past_retain_until_date) + ts.Run(CreateMultipartUpload_invalid_legal_hold) + ts.Run(CreateMultipartUpload_invalid_object_lock_mode) + ts.Run(CreateMultipartUpload_object_acl_not_supported) + //TODO: remove the condition after implementing checksums in azure + if !ts.conf.azureTests { + ts.Run(CreateMultipartUpload_invalid_checksum_algorithm) + ts.Run(CreateMultipartUpload_empty_checksum_algorithm_with_checksum_type) + ts.Run(CreateMultipartUpload_type_algo_mismatch) + ts.Run(CreateMultipartUpload_invalid_checksum_type) + ts.Run(CreateMultipartUpload_valid_algo_type) + } + ts.Run(CreateMultipartUpload_success) +} + +func TestUploadPart(ts *TestState) { + ts.Run(UploadPart_non_existing_bucket) + ts.Run(UploadPart_invalid_part_number) + ts.Run(UploadPart_non_existing_key) + ts.Run(UploadPart_non_existing_mp_upload) + ts.Run(UploadPart_upload_id_path_traversal) + //TODO: remove the condition after implementing checksums in azure + if !ts.conf.azureTests { + ts.Run(UploadPart_multiple_checksum_headers) + ts.Run(UploadPart_invalid_checksum_header) + ts.Run(UploadPart_checksum_header_and_algo_mismatch) + ts.Run(UploadPart_checksum_algorithm_mistmatch_on_initialization) + ts.Run(UploadPart_checksum_algorithm_mistmatch_on_initialization_with_value) + ts.Run(UploadPart_incorrect_checksums) + ts.Run(UploadPart_no_checksum_with_full_object_checksum_type) + ts.Run(UploadPart_no_checksum_with_composite_checksum_type) + ts.Run(UploadPart_with_checksums_success) + } + ts.Run(UploadPart_success) + ts.Run(UploadPart_plain_body_with_decoded_length) + ts.Run(UploadPart_etag_quoting_consistency) + ts.Run(UploadPart_object_lock_checksum_required) + ts.Run(UploadPart_default_retention_checksum_required) +} + +func TestUploadPartCopy(ts *TestState) { + ts.Run(UploadPartCopy_non_existing_bucket) + ts.Run(UploadPartCopy_incorrect_uploadId) + ts.Run(UploadPartCopy_upload_id_path_traversal) + ts.Run(UploadPartCopy_incorrect_object_key) + ts.Run(UploadPartCopy_invalid_part_number) + ts.Run(UploadPartCopy_invalid_copy_source) + ts.Run(UploadPartCopy_non_existing_source_bucket) + ts.Run(UploadPartCopy_non_existing_source_object_key) + ts.Run(UploadPartCopy_success) + ts.Run(UploadPartCopy_by_range_invalid_ranges) + ts.Run(UploadPartCopy_exceeding_copy_source_range) + ts.Run(UploadPartCopy_greater_range_than_obj_size) + ts.Run(UploadPartCopy_by_range_success) + //TODO: remove the condition after implementing checksums in azure + if !ts.conf.azureTests { + ts.Run(UploadPartCopy_should_copy_the_checksum) + ts.Run(UploadPartCopy_should_not_copy_the_checksum) + ts.Run(UploadPartCopy_should_calculate_the_checksum) + ts.Run(UploadPartCopy_conditional_reads) + } + ts.Run(UploadPartCopy_incorrect_source_bucket_expected_owner) +} + +func TestListParts(ts *TestState) { + ts.Run(ListParts_incorrect_uploadId) + ts.Run(ListParts_upload_id_path_traversal) + ts.Run(ListParts_incorrect_object_key) + ts.Run(ListParts_invalid_max_parts) + ts.Run(ListParts_invalid_part_number_marker) + ts.Run(ListParts_default_max_parts) + ts.Run(ListParts_exceeding_max_parts) + ts.Run(ListParts_truncated) + //TODO: remove the condition after implementing checksums in azure + if !ts.conf.azureTests { + ts.Run(ListParts_with_checksums) + ts.Run(ListParts_null_checksums) + } + ts.Run(ListParts_success) +} + +func TestListMultipartUploads(ts *TestState) { + ts.Run(ListMultipartUploads_non_existing_bucket) + ts.Run(ListMultipartUploads_empty_result) + ts.Run(ListMultipartUploads_invalid_max_uploads) + ts.Run(ListMultipartUploads_max_uploads) + ts.Run(ListMultipartUploads_exceeding_max_uploads) + ts.Run(ListMultipartUploads_ignore_upload_id_marker) + ts.Run(ListMultipartUploads_invalid_uploadId_marker) + ts.Run(ListMultipartUploads_keyMarker_not_from_list) + ts.Run(ListMultipartUploads_delimiter_truncated) + ts.Run(ListMultipartUploads_prefix) + ts.Run(ListMultipartUploads_both_delimiter_and_prefix) + ts.Run(ListMultipartUploads_delimiter_no_matches) + //TODO: remove the condition after implementing checksums in azure + if !ts.conf.azureTests { + ts.Run(ListMultipartUploads_with_checksums) + } +} + +func TestAbortMultipartUpload(ts *TestState) { + ts.Run(AbortMultipartUpload_non_existing_bucket) + ts.Run(AbortMultipartUpload_incorrect_uploadId) + ts.Run(AbortMultipartUpload_upload_id_path_traversal) + ts.Run(AbortMultipartUpload_incorrect_object_key) + ts.Run(AbortMultipartUpload_success) + ts.Run(AbortMultipartUpload_success_status_code) + ts.Run(AbortMultipartUpload_if_match_initiated_time) +} + +func TestCompleteMultipartUpload(ts *TestState) { + ts.Run(CompletedMultipartUpload_non_existing_bucket) + ts.Run(CompleteMultipartUpload_upload_id_path_traversal) + ts.Run(CompleteMultipartUpload_incorrect_part_number) + ts.Run(CompleteMultipartUpload_invalid_part_number) + ts.Run(CompleteMultipartUpload_default_content_type) + ts.Run(CompleteMultipartUpload_overwrite_resets_attributes) + ts.Run(CompleteMultipartUpload_invalid_ETag) + ts.Run(CompleteMultipartUpload_small_upload_size) + ts.Run(CompleteMultipartUpload_empty_parts) + ts.Run(CompleteMultipartUpload_missing_part_fields) + ts.Run(CompleteMultipartUpload_incorrect_parts_order) + ts.Run(CompleteMultipartUpload_mpu_object_size) + ts.Run(CompleteMultipartUpload_conditional_writes) + //TODO: remove the condition after implementing checksums in azure + if !ts.conf.azureTests { + ts.Run(CompleteMultipartUpload_invalid_checksum_type) + ts.Run(CompleteMultipartUpload_invalid_checksum_part) + ts.Run(CompleteMultipartUpload_multiple_checksum_part) + ts.Run(CompleteMultipartUpload_incorrect_checksum_part) + ts.Run(CompleteMultipartUpload_different_checksum_part) + ts.Run(CompleteMultipartUpload_missing_part_checksum) + ts.Run(CompleteMultipartUpload_multiple_final_checksums) + ts.Run(CompleteMultipartUpload_invalid_final_checksums) + ts.Run(CompleteMultipartUpload_incorrect_final_checksums) + ts.Run(CompleteMultipartUpload_should_calculate_the_final_checksum_full_object) + ts.Run(CompleteMultipartUpload_should_verify_the_final_checksum) + ts.Run(CompleteMultipartUpload_should_verify_final_composite_checksum) + ts.Run(CompleteMultipartUpload_invalid_final_composite_checksum) + ts.Run(CompleteMultipartUpload_checksum_type_mismatch) + ts.Run(CompleteMultipartUpload_should_ignore_the_final_checksum) + ts.Run(CompleteMultipartUpload_should_succeed_without_final_checksum_type) + // azure doesn't support these metadata characters + ts.Run(CompleteMultipartUpload_with_metadata) + } + ts.Run(CompleteMultipartUpload_success) + ts.Run(CompleteMultipartUpload_already_completed) + if !(ts.conf.azureTests || ts.conf.sidecarTests) { + ts.Run(CompleteMultipartUpload_racey_success) + ts.Run(CompleteMultipartUpload_racey_data_integrity) + } +} + +func TestPutBucketAcl(ts *TestState) { + ts.Run(PutBucketAcl_non_existing_bucket) + ts.Run(PutBucketAcl_disabled) + ts.Run(PutBucketAcl_none_of_the_options_specified) + ts.Run(PutBucketAcl_invalid_canned_acl) + ts.Run(PutBucketAcl_invalid_acl_canned_and_acp) + ts.Run(PutBucketAcl_invalid_acl_canned_and_grants) + ts.Run(PutBucketAcl_invalid_acl_acp_and_grants) + ts.Run(PutBucketAcl_invalid_owner) + ts.Run(PutBucketAcl_invalid_owner_not_in_body) + ts.Run(PutBucketAcl_invalid_empty_owner_id_in_body) + ts.Run(PutBucketAcl_invalid_permission_in_body) + ts.Run(PutBucketAcl_invalid_grantee_type_in_body) + ts.Run(PutBucketAcl_empty_grantee_ID_in_body) + ts.Run(PutBucketAcl_success_access_denied) + ts.Run(PutBucketAcl_success_grants) + ts.Run(PutBucketAcl_success_canned_acl) + ts.Run(PutBucketAcl_success_acp) +} + +func TestGetBucketAcl(ts *TestState) { + ts.Run(GetBucketAcl_non_existing_bucket) + ts.Run(GetBucketAcl_translation_canned_public_read) + ts.Run(GetBucketAcl_translation_canned_public_read_write) + ts.Run(GetBucketAcl_translation_canned_private) + ts.Run(GetBucketAcl_access_denied) + ts.Run(GetBucketAcl_success) +} + +func TestPutBucketPolicy(ts *TestState) { + ts.Run(PutBucketPolicy_non_existing_bucket) + ts.Run(PutBucketPolicy_invalid_json) + ts.Run(PutBucketPolicy_statement_not_provided) + ts.Run(PutBucketPolicy_empty_statement) + ts.Run(PutBucketPolicy_invalid_effect) + ts.Run(PutBucketPolicy_invalid_action) + ts.Run(PutBucketPolicy_empty_principals_string) + ts.Run(PutBucketPolicy_empty_principals_array) + ts.Run(PutBucketPolicy_principals_aws_struct_empty_string) + ts.Run(PutBucketPolicy_principals_aws_struct_empty_string_slice) + ts.Run(PutBucketPolicy_principals_incorrect_wildcard_usage) + ts.Run(PutBucketPolicy_non_existing_principals) + ts.Run(PutBucketPolicy_empty_resources_string) + ts.Run(PutBucketPolicy_empty_resources_array) + ts.Run(PutBucketPolicy_invalid_resource_prefix) + ts.Run(PutBucketPolicy_invalid_resource_with_starting_slash) + ts.Run(PutBucketPolicy_duplicate_resource) + ts.Run(PutBucketPolicy_incorrect_bucket_name) + ts.Run(PutBucketPolicy_action_resource_mismatch) + ts.Run(PutBucketPolicy_explicit_deny) + ts.Run(PutBucketPolicy_multi_wildcard_resource) + ts.Run(PutBucketPolicy_any_char_match) + ts.Run(PutBucketPolicy_version) + ts.Run(PutBucketPolicy_success) + ts.Run(PutBucketPolicy_status) + ts.Run(PutBucketPolicy_condition_invalid_operator) + ts.Run(PutBucketPolicy_condition_invalid_key) + ts.Run(PutBucketPolicy_condition_action_mismatch) + ts.Run(PutBucketPolicy_condition_conditional_write_keys) + ts.Run(PutBucketPolicy_condition_invalid_ip) +} + +func TestGetBucketPolicy(ts *TestState) { + ts.Run(GetBucketPolicy_non_existing_bucket) + ts.Run(GetBucketPolicy_not_set) + ts.Run(GetBucketPolicy_success) +} + +func TestGetBucketPolicyStatus(ts *TestState) { + ts.Run(GetBucketPolicyStatus_non_existing_bucket) + ts.Run(GetBucketPolicyStatus_no_such_bucket_policy) + ts.Run(GetBucketPolicyStatus_success) +} + +func TestDeleteBucketPolicy(ts *TestState) { + ts.Run(DeleteBucketPolicy_non_existing_bucket) + ts.Run(DeleteBucketPolicy_remove_before_setting) + ts.Run(DeleteBucketPolicy_success) +} + +func TestPutBucketCors(ts *TestState) { + ts.Run(PutBucketCors_non_existing_bucket) + ts.Run(PutBucketCors_empty_cors_rules) + ts.Run(PutBucketCors_invalid_allowed_origins) + ts.Run(PutBucketCors_invalid_method) + ts.Run(PutBucketCors_invalid_header) + ts.Run(PutBucketCors_md5) + ts.Run(PutBucketCors_success) +} + +func TestGetBucketCors(ts *TestState) { + ts.Run(GetBucketCors_non_existing_bucket) + ts.Run(GetBucketCors_no_such_bucket_cors) + ts.Run(GetBucketCors_success) +} + +func TestDeleteBucketCors(ts *TestState) { + ts.Run(DeleteBucketCors_non_existing_bucket) + ts.Run(DeleteBucketCors_success) +} + +func TestPutBucketWebsite(ts *TestState) { + ts.Run(PutBucketWebsite_non_existing_bucket) + ts.Run(PutBucketWebsite_empty_suffix) + ts.Run(PutBucketWebsite_empty_configuration) + ts.Run(PutBucketWebsite_suffix_with_slash) + ts.Run(PutBucketWebsite_invalid_redirect_protocol) + ts.Run(PutBucketWebsite_redirectAll_index_error_routingRules) + ts.Run(PutBucketWebsite_invalid_routing_rule_protocol) + ts.Run(PutBucketWebsite_empty_routing_rule_condition) + ts.Run(PutBucketWebsite_empty_routing_rule_redirect) + ts.Run(PutBucketWebsite_empty_error_document_key) + ts.Run(PutBucketWebsite_too_many_routing_rules) + ts.Run(PutBucketWebsite_routing_rule_replace_key_and_prefix) + ts.Run(PutBucketWebsite_invalid_http_redirect_code) + ts.Run(PutBucketWebsite_invalid_http_error_code) + ts.Run(PutBucketWebsite_request_too_large) + ts.Run(PutBucketWebsite_success) + ts.Run(PutBucketWebsite_success_redirect_all) +} + +func TestGetBucketWebsite(ts *TestState) { + ts.Run(GetBucketWebsite_non_existing_bucket) + ts.Run(GetBucketWebsite_no_such_website_config) + ts.Run(GetBucketWebsite_success) + ts.Run(GetBucketWebsite_success_redirect_all) +} + +func TestDeleteBucketWebsite(ts *TestState) { + ts.Run(DeleteBucketWebsite_non_existing_bucket) + ts.Run(DeleteBucketWebsite_success) +} + +func TestWebsiteHosting(ts *TestState) { + ts.Run(WebsiteHosting_error_document_served) + ts.Run(WebsiteHosting_error_document_not_found) + ts.Run(WebsiteHosting_no_error_document) + ts.Run(WebsiteHosting_no_bucket_in_request_location) + ts.Run(WebsiteHosting_private_object_and_error_document) + ts.Run(WebsiteHosting_routing_rule_post_request_redirect) + ts.Run(WebsiteHosting_routing_rule_pre_request_redirect) + ts.Run(WebsiteHosting_routing_rule_prefix_and_error_redirect) + ts.Run(WebsiteHosting_routing_rule_no_match_serves_error_document) + ts.Run(WebsiteHosting_redirect_all_requests) + ts.Run(WebsiteHosting_object_redirect_location) + ts.Run(WebsiteHosting_index_document) + ts.Run(WebsiteHosting_index_error_document_and_routing_rules) + ts.Run(WebsiteHosting_get_cors_headers) + ts.Run(WebsiteHosting_head_cors_headers) + ts.Run(WebsiteHosting_options_preflight_access_granted) + ts.Run(WebsiteHosting_options_preflight_access_forbidden) + ts.Run(WebsiteHosting_options_preflight_missing_origin) + ts.Run(WebsiteHosting_url_encoded_object_key) +} + +func TestPreflightOPTIONSEndpoint(ts *TestState) { + ts.Run(PreflightOPTIONS_non_existing_bucket) + ts.Run(PreflightOPTIONS_missing_origin) + ts.Run(PreflightOPTIONS_invalid_request_method) + ts.Run(PreflightOPTIONS_invalid_request_headers) + ts.Run(PreflightOPTIONS_unset_bucket_cors) + ts.Run(PreflightOPTIONS_access_forbidden) + ts.Run(PreflightOPTIONS_access_granted) +} + +func TestCORSMiddleware(ts *TestState) { + ts.Run(CORSMiddleware_invalid_method) + ts.Run(CORSMiddleware_invalid_headers) + ts.Run(CORSMiddleware_access_forbidden) + ts.Run(CORSMiddleware_access_granted) +} + +func TestPutObjectLockConfiguration(ts *TestState) { + ts.Run(PutObjectLockConfiguration_non_existing_bucket) + ts.Run(PutObjectLockConfiguration_empty_request_body) + ts.Run(PutObjectLockConfiguration_malformed_body) + if !ts.conf.versioningEnabled { + ts.Run(PutObjectLockConfiguration_not_enabled_on_bucket_creation) + } + ts.Run(PutObjectLockConfiguration_invalid_status) + ts.Run(PutObjectLockConfiguration_invalid_mode) + ts.Run(PutObjectLockConfiguration_both_years_and_days) + ts.Run(PutObjectLockConfiguration_invalid_years_days) + ts.Run(PutObjectLockConfiguration_success) +} + +func TestGetObjectLockConfiguration(ts *TestState) { + ts.Run(GetObjectLockConfiguration_non_existing_bucket) + ts.Run(GetObjectLockConfiguration_unset_config) + ts.Run(GetObjectLockConfiguration_no_default_retention) + ts.Run(GetObjectLockConfiguration_success) +} + +func TestPutObjectRetention(ts *TestState) { + ts.Run(PutObjectRetention_non_existing_bucket) + ts.Run(PutObjectRetention_non_existing_object) + ts.Run(PutObjectRetention_unset_bucket_object_lock_config) + ts.Run(PutObjectRetention_expired_retain_until_date) + ts.Run(PutObjectRetention_invalid_mode) + ts.Run(PutObjectRetention_overwrite_compliance_mode) + ts.Run(PutObjectRetention_overwrite_compliance_with_compliance) + ts.Run(PutObjectRetention_overwrite_governance_with_governance) + ts.Run(PutObjectRetention_overwrite_governance_without_bypass_specified) + ts.Run(PutObjectRetention_overwrite_governance_with_permission) + ts.Run(PutObjectRetention_shorten_governance_without_bypass) + ts.Run(PutObjectRetention_shorten_governance_with_bypass) + ts.Run(PutObjectRetention_shorten_compliance_denied) + ts.Run(PutObjectRetention_rewrite_same_date) + ts.Run(PutObjectRetention_success) + ts.Run(PutObjectRetention_empty_version_id) +} + +func TestGetObjectRetention(ts *TestState) { + ts.Run(GetObjectRetention_non_existing_bucket) + ts.Run(GetObjectRetention_non_existing_object) + ts.Run(GetObjectRetention_disabled_lock) + ts.Run(GetObjectRetention_unset_config) + ts.Run(GetObjectRetention_success) + ts.Run(GetObjectRetention_empty_version_id) +} + +func TestPutObjectLegalHold(ts *TestState) { + ts.Run(PutObjectLegalHold_non_existing_bucket) + ts.Run(PutObjectLegalHold_non_existing_object) + ts.Run(PutObjectLegalHold_invalid_body) + ts.Run(PutObjectLegalHold_invalid_status) + ts.Run(PutObjectLegalHold_unset_bucket_object_lock_config) + ts.Run(PutObjectLegalHold_success) + ts.Run(PutObjectLegalHold_empty_version_id) +} + +func TestGetObjectLegalHold(ts *TestState) { + ts.Run(GetObjectLegalHold_non_existing_bucket) + ts.Run(GetObjectLegalHold_non_existing_object) + ts.Run(GetObjectLegalHold_disabled_lock) + ts.Run(GetObjectLegalHold_unset_config) + ts.Run(GetObjectLegalHold_success) + ts.Run(GetObjectLegalHold_empty_version_id) +} + +func TestNotImplementedActions(ts *TestState) { + // bucket analytics actions + ts.Run(PutBucketAnalyticsConfiguration_not_implemented) + ts.Run(GetBucketAnalyticsConfiguration_not_implemented) + ts.Run(ListBucketAnalyticsConfiguration_not_implemented) + ts.Run(DeleteBucketAnalyticsConfiguration_not_implemented) + // bucket encryption actions + ts.Run(PutBucketEncryption_not_implemented) + ts.Run(GetBucketEncryption_not_implemented) + ts.Run(DeleteBucketEncryption_not_implemented) + // bucket intelligent tierieng actions + ts.Run(PutBucketIntelligentTieringConfiguration_not_implemented) + ts.Run(GetBucketIntelligentTieringConfiguration_not_implemented) + ts.Run(ListBucketIntelligentTieringConfiguration_not_implemented) + ts.Run(DeleteBucketIntelligentTieringConfiguration_not_implemented) + // bucket inventory configuration actions + ts.Run(PutBucketInventoryConfiguration_not_implemented) + ts.Run(GetBucketInventoryConfiguration_not_implemented) + ts.Run(ListBucketInventoryConfiguration_not_implemented) + ts.Run(DeleteBucketInventoryConfiguration_not_implemented) + // bucket lifecycle configuration actions + ts.Run(PutBucketLifecycleConfiguration_not_implemented) + ts.Run(GetBucketLifecycleConfiguration_not_implemented) + ts.Run(DeleteBucketLifecycle_not_implemented) + // bucket logging actions + ts.Run(PutBucketLogging_not_implemented) + ts.Run(GetBucketLogging_not_implemented) + // bucket request payment actions + ts.Run(PutBucketRequestPayment_not_implemented) + ts.Run(GetBucketRequestPayment_not_implemented) + // bucket metrics configuration actions + ts.Run(PutBucketMetricsConfiguration_not_implemented) + ts.Run(GetBucketMetricsConfiguration_not_implemented) + ts.Run(ListBucketMetricsConfigurations_not_implemented) + ts.Run(DeleteBucketMetricsConfiguration_not_implemented) + // bucket replication actions + ts.Run(PutBucketReplication_not_implemented) + ts.Run(GetBucketReplication_not_implemented) + ts.Run(DeleteBucketReplication_not_implemented) + // bucket public access block actions + ts.Run(PutPublicAccessBlock_not_implemented) + ts.Run(GetPublicAccessBlock_not_implemented) + ts.Run(DeletePublicAccessBlock_not_implemented) + // bucket notification actions + ts.Run(PutBucketNotificationConfiguratio_not_implemented) + ts.Run(GetBucketNotificationConfiguratio_not_implemented) + // bucket acceleration actions + ts.Run(PutBucketAccelerateConfiguration_not_implemented) + ts.Run(GetBucketAccelerateConfiguration_not_implemented) + // object acl actions + ts.Run(PutObjectAcl_not_implemented) + ts.Run(GetObjectAcl_not_implemented) +} + +func TestWORMProtection(ts *TestState) { + ts.Run(WORMProtection_bucket_object_lock_configuration_compliance_mode) + ts.Run(WORMProtection_bucket_object_lock_configuration_governance_mode) + ts.Run(WORMProtection_bucket_object_lock_governance_bypass_delete) + ts.Run(WORMProtection_bucket_object_lock_governance_bypass_delete_multiple) + ts.Run(WORMProtection_delete_objects_locked_object_partial_success) + ts.Run(WORMProtection_object_lock_retention_compliance_locked) + ts.Run(WORMProtection_object_lock_retention_governance_locked) + ts.Run(WORMProtection_object_lock_retention_governance_bypass_overwrite_put) + ts.Run(WORMProtection_object_lock_retention_governance_bypass_overwrite_copy) + ts.Run(WORMProtection_object_lock_retention_governance_bypass_overwrite_mp) + ts.Run(WORMProtection_object_lock_retention_governance_bypass_overwrite_post) + ts.Run(WORMProtection_unable_to_overwrite_locked_object_put) + ts.Run(WORMProtection_unable_to_overwrite_locked_object_copy) + ts.Run(WORMProtection_unable_to_overwrite_locked_object_mp) + ts.Run(WORMProtection_unable_to_overwrite_locked_object_post) + ts.Run(WORMProtection_object_lock_retention_governance_bypass_delete) + ts.Run(WORMProtection_object_lock_retention_governance_bypass_delete_mul) + ts.Run(WORMProtection_object_lock_legal_hold_locked) + ts.Run(WORMProtection_root_bypass_governance_retention_delete_object) +} + +func TestFullFlow(ts *TestState) { + TestAuthentication(ts) + TestPresignedAuthentication(ts) + TestCreateBucket(ts) + TestHeadBucket(ts) + TestListBuckets(ts) + TestDeleteBucket(ts) + TestPutBucketOwnershipControls(ts) + TestGetBucketOwnershipControls(ts) + TestDeleteBucketOwnershipControls(ts) + TestPutBucketTagging(ts) + TestGetBucketTagging(ts) + TestDeleteBucketTagging(ts) + TestGetBucketLocation(ts) + TestPutObject(ts) + TestHeadObject(ts) + TestGetObjectAttributes(ts) + TestGetObject(ts) + TestListObjects(ts) + TestListObjectsV2(ts) + if !ts.conf.versioningEnabled && !ts.conf.azureTests { + TestListObjectVersions_VD(ts) + } + TestDeleteObject(ts) + TestDeleteObjects(ts) + TestCopyObject(ts) + TestPutObjectTagging(ts) + TestGetObjectTagging(ts) + TestDeleteObjectTagging(ts) + TestCreateMultipartUpload(ts) + TestUploadPart(ts) + // UploadPartCopy maps to Azure StageBlockFromURL, which Azurite does not + // implement (returns HTTP 500 InternalError), so the group is skipped in + // Azure full-flow. The backend now returns a populated, quoted CopyPartResult + // ETag (consistent with UploadPart/ListParts); that path is exercised against + // real Azure rather than Azurite. + if !ts.conf.azureTests { + TestUploadPartCopy(ts) + } + TestListParts(ts) + TestListMultipartUploads(ts) + TestAbortMultipartUpload(ts) + TestCompleteMultipartUpload(ts) + TestPutBucketAcl(ts) + TestGetBucketAcl(ts) + TestPutBucketPolicy(ts) + TestGetBucketPolicy(ts) + TestDeleteBucketPolicy(ts) + TestPutBucketCors(ts) + TestGetBucketCors(ts) + TestDeleteBucketCors(ts) + TestPutBucketWebsite(ts) + TestGetBucketWebsite(ts) + TestDeleteBucketWebsite(ts) + TestPreflightOPTIONSEndpoint(ts) + TestPutObjectLockConfiguration(ts) + TestGetObjectLockConfiguration(ts) + TestPutObjectRetention(ts) + TestGetObjectRetention(ts) + TestPutObjectLegalHold(ts) + TestGetObjectLegalHold(ts) + if !ts.conf.versioningEnabled { + TestWORMProtection(ts) + } + TestAccessControl(ts) + TestRouter(ts) + TestPostObject(ts) + TestUnsignedStreaminPayloadTrailer(ts) + TestSignedStreaminPayload(ts) + TestSignedStreaminPayloadTrailer(ts) + // FIXME: The tests should pass for azure as well + // but this issue should be fixed with https://github.com/versity/versitygw/issues/1336 + if !ts.conf.azureTests { + TestPublicBuckets(ts) + } + if ts.conf.versioningEnabled { + TestVersioning(ts) + } + TestGatewayIAM(ts) + TestServer(ts) +} + +func TestPosix(ts *TestState) { + ts.Run(PutObject_overwrite_dir_obj) + ts.Run(PutObject_overwrite_file_obj) + ts.Run(PutObject_overwrite_file_obj_with_nested_obj) + ts.Run(PutObject_dir_obj_with_data) + ts.Run(PutObject_with_slashes) + ts.Run(CreateMultipartUpload_dir_obj) + ts.Run(PutObject_name_too_long) + ts.Run(HeadObject_name_too_long) + ts.Run(DeleteObject_name_too_long) + ts.Run(CopyObject_overwrite_same_dir_object) + ts.Run(CopyObject_overwrite_same_file_object) + ts.Run(CompleteMultipartUpload_overwrite_dir_obj) + if ts.conf.versioningEnabled { + ts.Run(CompleteMultipartUpload_overwrite_dir_obj_delete_marker) + } + ts.Run(ObjectTagging_trailing_slash_counterpart) + ts.Run(ObjectLock_trailing_slash_counterpart) + ts.Run(DeleteObject_directory_not_empty) + if !ts.conf.windowsTests { + ts.Run(PutObject_race_with_delete) + } + // posix specific versioning tests + if !ts.conf.versioningEnabled { + TestVersioningDisabled(ts) + } +} + +func TestScoutfs(ts *TestState) { + TestAuthentication(ts) + TestPresignedAuthentication(ts) + TestCreateBucket(ts) + TestHeadBucket(ts) + TestListBuckets(ts) + TestDeleteBucket(ts) + TestPutBucketOwnershipControls(ts) + TestGetBucketOwnershipControls(ts) + TestDeleteBucketOwnershipControls(ts) + TestPutBucketTagging(ts) + TestGetBucketTagging(ts) + TestDeleteBucketTagging(ts) + TestGetBucketLocation(ts) + TestPutObject(ts) + TestHeadObject(ts) + TestGetObjectAttributes(ts) + TestGetObject(ts) + TestListObjects(ts) + TestListObjectsV2(ts) + TestListObjectVersions_VD(ts) + TestDeleteObject(ts) + TestDeleteObjects(ts) + TestCopyObject(ts) + TestPutObjectTagging(ts) + TestDeleteObjectTagging(ts) + TestUploadPart(ts) + TestUploadPartCopy(ts) + TestListParts(ts) + TestListMultipartUploads(ts) + TestAbortMultipartUpload(ts) + TestPutBucketAcl(ts) + TestGetBucketAcl(ts) + TestPutBucketPolicy(ts) + TestGetBucketPolicy(ts) + TestDeleteBucketPolicy(ts) + TestPutObjectLockConfiguration(ts) + TestGetObjectLockConfiguration(ts) + TestPutObjectRetention(ts) + TestGetObjectRetention(ts) + TestPutObjectLegalHold(ts) + TestGetObjectLegalHold(ts) + TestWORMProtection(ts) + TestAccessControl(ts) + + ts.Run(CreateMultipartUpload_non_existing_bucket) + ts.Run(CreateMultipartUpload_with_tagging) + ts.Run(CreateMultipartUpload_with_object_lock) + ts.Run(CreateMultipartUpload_with_object_lock_not_enabled) + ts.Run(CreateMultipartUpload_with_object_lock_invalid_retention) + ts.Run(CreateMultipartUpload_past_retain_until_date) + ts.Run(CreateMultipartUpload_invalid_legal_hold) + ts.Run(CreateMultipartUpload_invalid_object_lock_mode) + ts.Run(CreateMultipartUpload_invalid_checksum_algorithm) + ts.Run(CreateMultipartUpload_empty_checksum_algorithm_with_checksum_type) + ts.Run(CreateMultipartUpload_invalid_checksum_type) + ts.Run(CreateMultipartUpload_valid_algo_type) + ts.Run(CreateMultipartUpload_success) + + ts.Run(CompletedMultipartUpload_non_existing_bucket) + ts.Run(CompleteMultipartUpload_upload_id_path_traversal) + ts.Run(CompleteMultipartUpload_incorrect_part_number) + ts.Run(CompleteMultipartUpload_invalid_part_number) + ts.Run(CompleteMultipartUpload_invalid_ETag) + ts.Run(CompleteMultipartUpload_small_upload_size) + ts.Run(CompleteMultipartUpload_empty_parts) + ts.Run(CompleteMultipartUpload_missing_part_fields) + ts.Run(CompleteMultipartUpload_incorrect_parts_order) + ts.Run(CompleteMultipartUpload_mpu_object_size) + ts.Run(CompleteMultipartUpload_invalid_checksum_type) + ts.Run(CompleteMultipartUpload_invalid_checksum_part) + ts.Run(CompleteMultipartUpload_multiple_checksum_part) + ts.Run(CompleteMultipartUpload_incorrect_checksum_part) + ts.Run(CompleteMultipartUpload_different_checksum_part) + ts.Run(CompleteMultipartUpload_missing_part_checksum) + ts.Run(CompleteMultipartUpload_multiple_final_checksums) + ts.Run(CompleteMultipartUpload_invalid_final_checksums) + ts.Run(CompleteMultipartUpload_checksum_type_mismatch) + ts.Run(CompleteMultipartUpload_should_ignore_the_final_checksum) + ts.Run(CompleteMultipartUpload_success) + ts.Run(CompleteMultipartUpload_racey_success) + ts.Run(CompleteMultipartUpload_racey_data_integrity) + + // posix/scoutfs specific tests + ts.Run(PutObject_overwrite_dir_obj) + ts.Run(PutObject_overwrite_file_obj) + ts.Run(PutObject_overwrite_file_obj_with_nested_obj) + ts.Run(PutObject_dir_obj_with_data) + ts.Run(PutObject_with_slashes) + ts.Run(CreateMultipartUpload_dir_obj) + ts.Run(PutObject_name_too_long) + ts.Run(HeadObject_name_too_long) + ts.Run(DeleteObject_name_too_long) + ts.Run(CopyObject_overwrite_same_dir_object) + ts.Run(CopyObject_overwrite_same_file_object) + ts.Run(CompleteMultipartUpload_overwrite_dir_obj) + ts.Run(ObjectTagging_trailing_slash_counterpart) + ts.Run(ObjectLock_trailing_slash_counterpart) + ts.Run(DeleteObject_directory_not_empty) +} + +func TestGatewayIAM(ts *TestState) { + ts.Run(IAM_user_access_denied) + ts.Run(IAM_userplus_access_denied) + ts.Run(IAM_userplus_CreateBucket) + ts.Run(IAM_admin_ChangeBucketOwner) + ts.Run(IAM_ChangeBucketOwner_back_to_root) + ts.Sync(IAM_ListBuckets) + ts.Run(IAM_CreateBucket_empty_owner_header) + ts.Run(IAM_CreateBucket_non_existing_user) + ts.Run(IAM_CreateBucket_success) +} + +func TestIAMAuth(ts *TestState) { + ts.Run(IAMAuth_invalid_auth_header) + ts.Run(IAMAuth_unsupported_signature_version) + ts.Run(IAMAuth_malformed_component) + ts.Run(IAMAuth_missing_authorization_component) + ts.Run(IAMAuth_malformed_credential) + ts.Run(IAMAuth_credentials_invalid_terminal) + ts.Run(IAMAuth_credentials_incorrect_service) + ts.Run(IAMAuth_credentials_incorrect_region) + ts.Run(IAMAuth_credentials_invalid_date) + ts.Run(IAMAuth_credentials_future_date) + ts.Run(IAMAuth_credentials_past_date) + ts.Run(IAMAuth_credentials_non_existing_access_key) + ts.Run(IAMAuth_missing_date_header) + ts.Run(IAMAuth_invalid_date_header) + ts.Run(IAMAuth_date_mismatch) + ts.Run(IAMAuth_invalid_sha256_payload_hash_ignored) + ts.Run(IAMAuth_unsigned_required_header) + ts.Run(IAMAuth_unsigned_non_required_header) + ts.Run(IAMAuth_signature_error_incorrect_secret_key) + ts.Run(IAMAuth_sigv2_not_supported) + ts.Run(IAMAuth_with_expect_header) +} + +func TestIAMQueryAuth(ts *TestState) { + ts.Run(IAMQueryAuth_success) + ts.Run(IAMQueryAuth_security_token_not_supported) + ts.Run(IAMQueryAuth_unsupported_algorithm) + ts.Run(IAMQueryAuth_ECDSA_not_supported) + ts.Run(IAMQueryAuth_missing_query_parameters) + ts.Run(IAMQueryAuth_malformed_credential) + ts.Run(IAMQueryAuth_credentials_invalid_terminal) + ts.Run(IAMQueryAuth_credentials_incorrect_service) + ts.Run(IAMQueryAuth_credentials_incorrect_region) + ts.Run(IAMQueryAuth_credentials_invalid_date) + ts.Run(IAMQueryAuth_non_existing_access_key) + ts.Run(IAMQueryAuth_invalid_date) + ts.Run(IAMQueryAuth_date_mismatch) + ts.Run(IAMQueryAuth_unsigned_query_parameter) + ts.Run(IAMQueryAuth_incorrect_secret_key) + ts.Run(IAMQueryAuth_invalid_sha256_payload_hash_ignored) + ts.Run(IAMQueryAuth_with_expect_header) +} + +func TestIAMCreateUser(ts *TestState) { + ts.Run(IAMCreateUser_user_already_exists) + ts.Run(IAMCreateUser_already_exists_case_insensitive) + ts.Run(IAMCreateUser_invalid_user_name) + ts.Run(IAMCreateUser_long_user_name) + ts.Run(IAMCreateUser_missing_user_name) + ts.Run(IAMCreateUser_invalid_tag_key) + ts.Run(IAMCreateUser_invalid_tag_value) + ts.Run(IAMCreateUser_long_tag_key) + ts.Run(IAMCreateUser_long_tag_value) + ts.Run(IAMCreateUser_duplicate_tag_keys) + ts.Run(IAMCreateUser_success) + ts.Run(IAMCreateUser_default_path) + ts.Run(IAMCreateUser_invalid_path) + ts.Run(IAMCreateUser_long_path) +} + +func TestIAMGetUser(ts *TestState) { + ts.Run(IAMGetUser_long_user_name) + ts.Run(IAMGetUser_invalid_user_name) + ts.Run(IAMGetUser_non_existing_user) + ts.Run(IAMGetUser_success) + ts.Run(IAMGetUser_root_user) +} + +func TestIAMListUsers(ts *TestState) { + ts.Run(IAMListUsers_invalid_path_prefix) + ts.Run(IAMListUsers_long_path_prefix) + ts.Run(IAMListUsers_invalid_max_items) + ts.Run(IAMListUsers_invalid_max_items_format) + ts.Run(IAMListUsers_empty_result) + ts.Run(IAMListUsers_success) + ts.Run(IAMListUsers_path_prefix) + ts.Run(IAMListUsers_pagination) + ts.Run(IAMListUsers_path_prefix_pagination) +} + +func TestIAMDeleteUser(ts *TestState) { + ts.Run(IAMDeleteUser_invalid_user_name) + ts.Run(IAMDeleteUser_long_user_name) + ts.Run(IAMDeleteUser_non_existing_user) + ts.Run(IAMDeleteUser_has_access_keys) + ts.Run(IAMDeleteUser_success) +} + +func TestIAMUpdateUser(ts *TestState) { + ts.Run(IAMUpdateUser_invalid_user_name) + ts.Run(IAMUpdateUser_long_user_name) + ts.Run(IAMUpdateUser_invalid_new_user_name) + ts.Run(IAMUpdateUser_long_new_user_name) + ts.Run(IAMUpdateUser_non_existing_user) + ts.Run(IAMUpdateUser_invalid_new_path) + ts.Run(IAMUpdateUser_long_new_path) + ts.Run(IAMUpdateUser_new_user_name_already_exists) + ts.Run(IAMUpdateUser_success) +} + +func TestIAMTagUser(ts *TestState) { + ts.Run(IAMTagUser_missing_user_name) + ts.Run(IAMTagUser_invalid_user_name) + ts.Run(IAMTagUser_user_name_too_long) + ts.Run(IAMTagUser_missing_tags) + ts.Run(IAMTagUser_missing_tag_key) + ts.Run(IAMTagUser_missing_tag_value) + ts.Run(IAMTagUser_empty_tag_key) + ts.Run(IAMTagUser_tag_key_too_long) + ts.Run(IAMTagUser_invalid_tag_key) + ts.Run(IAMTagUser_tag_value_too_long) + ts.Run(IAMTagUser_invalid_tag_value) + ts.Run(IAMTagUser_duplicate_tag_keys) + ts.Run(IAMTagUser_too_many_tags) + ts.Run(IAMTagUser_non_existing_user) + ts.Run(IAMTagUser_tag_limit_exceeded) + ts.Run(IAMTagUser_success) + ts.Run(IAMTagUser_overwrites_existing_tag) +} + +func TestIAMUntagUser(ts *TestState) { + ts.Run(IAMUntagUser_missing_user_name) + ts.Run(IAMUntagUser_invalid_user_name) + ts.Run(IAMUntagUser_user_name_too_long) + ts.Run(IAMUntagUser_missing_tag_keys) + ts.Run(IAMUntagUser_invalid_tag_key) + ts.Run(IAMUntagUser_too_many_tag_keys) + ts.Run(IAMUntagUser_non_existing_user) + ts.Run(IAMUntagUser_success) + ts.Run(IAMUntagUser_removal_is_idempotent) + ts.Run(IAMUntagUser_case_insensitive_key) +} + +func TestIAMListUserTags(ts *TestState) { + ts.Run(IAMListUserTags_missing_user_name) + ts.Run(IAMListUserTags_invalid_user_name) + ts.Run(IAMListUserTags_user_name_too_long) + ts.Run(IAMListUserTags_invalid_max_items) + ts.Run(IAMListUserTags_invalid_max_items_format) + ts.Run(IAMListUserTags_non_existing_user) + ts.Run(IAMListUserTags_empty_result) + ts.Run(IAMListUserTags_success) + ts.Run(IAMListUserTags_pagination) +} + +func TestIAMCreateAccessKey(ts *TestState) { + ts.Run(IAMCreateAccessKey_missing_user_name) + ts.Run(IAMCreateAccessKey_empty_user_name) + ts.Run(IAMCreateAccessKey_infers_caller_user_name) + ts.Run(IAMCreateAccessKey_invalid_user_name) + ts.Run(IAMCreateAccessKey_long_user_name) + ts.Run(IAMCreateAccessKey_non_existing_user) + ts.Run(IAMCreateAccessKey_limit_exceeded) + ts.Run(IAMCreateAccessKey_success) +} + +func TestIAMUpdateAccessKey(ts *TestState) { + ts.Run(IAMUpdateAccessKey_missing_user_name) + ts.Run(IAMUpdateAccessKey_infers_caller_user_name) + ts.Run(IAMUpdateAccessKey_inferred_user_name_scoped_to_caller) + ts.Run(IAMUpdateAccessKey_invalid_user_name) + ts.Run(IAMUpdateAccessKey_long_user_name) + ts.Run(IAMUpdateAccessKey_missing_access_key_id) + ts.Run(IAMUpdateAccessKey_access_key_id_too_short) + ts.Run(IAMUpdateAccessKey_access_key_id_too_long) + ts.Run(IAMUpdateAccessKey_invalid_access_key_id_chars) + ts.Run(IAMUpdateAccessKey_missing_status) + ts.Run(IAMUpdateAccessKey_invalid_status) + ts.Run(IAMUpdateAccessKey_non_existing_user) + ts.Run(IAMUpdateAccessKey_non_existing_access_key) + ts.Run(IAMUpdateAccessKey_success) +} + +func TestIAMDeleteAccessKey(ts *TestState) { + ts.Run(IAMDeleteAccessKey_missing_user_name) + ts.Run(IAMDeleteAccessKey_infers_caller_user_name) + ts.Run(IAMDeleteAccessKey_inferred_user_name_scoped_to_caller) + ts.Run(IAMDeleteAccessKey_invalid_user_name) + ts.Run(IAMDeleteAccessKey_long_user_name) + ts.Run(IAMDeleteAccessKey_missing_access_key_id) + ts.Run(IAMDeleteAccessKey_access_key_id_too_short) + ts.Run(IAMDeleteAccessKey_access_key_id_too_long) + ts.Run(IAMDeleteAccessKey_invalid_access_key_id_chars) + ts.Run(IAMDeleteAccessKey_non_existing_user) + ts.Run(IAMDeleteAccessKey_non_existing_access_key) + ts.Run(IAMDeleteAccessKey_success) +} + +func TestIAMGetAccessKeyLastUsed(ts *TestState) { + ts.Run(IAMGetAccessKeyLastUsed_missing_access_key_id) + ts.Run(IAMGetAccessKeyLastUsed_access_key_id_too_short) + ts.Run(IAMGetAccessKeyLastUsed_access_key_id_too_long) + ts.Run(IAMGetAccessKeyLastUsed_invalid_access_key_id_chars) + ts.Run(IAMGetAccessKeyLastUsed_non_existing_access_key) + ts.Run(IAMGetAccessKeyLastUsed_success) +} + +func TestIAMListAccessKeys(ts *TestState) { + ts.Run(IAMListAccessKeys_missing_user_name) + ts.Run(IAMListAccessKeys_infers_caller_user_name) + ts.Run(IAMListAccessKeys_invalid_user_name) + ts.Run(IAMListAccessKeys_long_user_name) + ts.Run(IAMListAccessKeys_invalid_max_items) + ts.Run(IAMListAccessKeys_invalid_max_items_format) + ts.Run(IAMListAccessKeys_non_existing_user) + ts.Run(IAMListAccessKeys_empty_result) + ts.Run(IAMListAccessKeys_success) + ts.Run(IAMListAccessKeys_pagination) +} + +func TestIAMPutUserPolicy(ts *TestState) { + ts.Run(IAMPutUserPolicy_missing_user_name) + ts.Run(IAMPutUserPolicy_missing_policy_name) + ts.Run(IAMPutUserPolicy_missing_policy_document) + ts.Run(IAMPutUserPolicy_invalid_policy_name) + ts.Run(IAMPutUserPolicy_long_policy_name) + ts.Run(IAMPutUserPolicy_non_ascii_policy_document) + ts.Run(IAMPutUserPolicy_non_existing_user) + ts.Run(IAMPutUserPolicy_malformed_policy_document) + ts.Run(IAMPutUserPolicy_principal_not_allowed) + ts.Run(IAMPutUserPolicy_limit_exceeded) + ts.Run(IAMPutUserPolicy_success) + ts.Run(IAMPutUserPolicy_overwrite_updates_existing) +} + +func TestIAMGetUserPolicy(ts *TestState) { + ts.Run(IAMGetUserPolicy_missing_user_name) + ts.Run(IAMGetUserPolicy_missing_policy_name) + ts.Run(IAMGetUserPolicy_non_existing_user) + ts.Run(IAMGetUserPolicy_non_existing_policy) + ts.Run(IAMGetUserPolicy_success) +} + +func TestIAMDeleteUserPolicy(ts *TestState) { + ts.Run(IAMDeleteUserPolicy_missing_user_name) + ts.Run(IAMDeleteUserPolicy_missing_policy_name) + ts.Run(IAMDeleteUserPolicy_non_existing_user) + ts.Run(IAMDeleteUserPolicy_non_existing_policy) + ts.Run(IAMDeleteUserPolicy_success) + ts.Run(IAMDeleteUserPolicy_blocks_user_deletion) +} + +func TestIAMListUserPolicies(ts *TestState) { + ts.Run(IAMListUserPolicies_missing_user_name) + ts.Run(IAMListUserPolicies_non_existing_user) + ts.Run(IAMListUserPolicies_invalid_max_items) + ts.Run(IAMListUserPolicies_empty_result) + ts.Run(IAMListUserPolicies_success) + ts.Run(IAMListUserPolicies_pagination) +} + +func TestIAMCreateRole(ts *TestState) { + ts.Run(IAMCreateRole_missing_role_name) + ts.Run(IAMCreateRole_invalid_role_name) + ts.Run(IAMCreateRole_long_role_name) + ts.Run(IAMCreateRole_already_exists) + ts.Run(IAMCreateRole_already_exists_case_insensitive) + ts.Run(IAMCreateRole_invalid_path) + ts.Run(IAMCreateRole_long_path) + ts.Run(IAMCreateRole_missing_assume_role_policy_document) + ts.Run(IAMCreateRole_non_ascii_assume_role_policy_document) + ts.Run(IAMCreateRole_trust_policy_size_limit_exceeded) + ts.Run(IAMCreateRole_description_invalid_charset) + ts.Run(IAMCreateRole_description_too_long) + ts.Run(IAMCreateRole_max_session_duration_invalid_format) + ts.Run(IAMCreateRole_max_session_duration_too_low) + ts.Run(IAMCreateRole_max_session_duration_too_high) + ts.Run(IAMCreateRole_duplicate_tag_keys) + ts.Run(IAMCreateRole_success) + ts.Run(IAMCreateRole_defaults) + ts.Run(IAMCreateRole_trust_policy_document_grammar) +} + +func TestIAMGetRole(ts *TestState) { + ts.Run(IAMGetRole_missing_role_name) + ts.Run(IAMGetRole_invalid_role_name) + ts.Run(IAMGetRole_long_role_name) + ts.Run(IAMGetRole_non_existing_role) + ts.Run(IAMGetRole_success) + ts.Run(IAMGetRole_role_last_used_never_used) +} + +func TestIAMListRoles(ts *TestState) { + ts.Run(IAMListRoles_invalid_path_prefix) + ts.Run(IAMListRoles_long_path_prefix) + ts.Run(IAMListRoles_invalid_max_items) + ts.Run(IAMListRoles_invalid_max_items_format) + ts.Run(IAMListRoles_empty_result) + ts.Run(IAMListRoles_success) + ts.Run(IAMListRoles_path_prefix) + ts.Run(IAMListRoles_pagination) + ts.Run(IAMListRoles_path_prefix_pagination) +} + +func TestIAMDeleteRole(ts *TestState) { + ts.Run(IAMDeleteRole_missing_role_name) + ts.Run(IAMDeleteRole_invalid_role_name) + ts.Run(IAMDeleteRole_long_role_name) + ts.Run(IAMDeleteRole_non_existing_role) + ts.Run(IAMDeleteRole_has_policies) + ts.Run(IAMDeleteRole_success) +} + +func TestIAMUpdateAssumeRolePolicy(ts *TestState) { + ts.Run(IAMUpdateAssumeRolePolicy_missing_role_name) + ts.Run(IAMUpdateAssumeRolePolicy_missing_policy_document) + ts.Run(IAMUpdateAssumeRolePolicy_invalid_role_name) + ts.Run(IAMUpdateAssumeRolePolicy_long_role_name) + ts.Run(IAMUpdateAssumeRolePolicy_non_existing_role) + ts.Run(IAMUpdateAssumeRolePolicy_non_ascii_policy_document) + ts.Run(IAMUpdateAssumeRolePolicy_trust_policy_size_limit_exceeded) + ts.Run(IAMUpdateAssumeRolePolicy_success) + ts.Run(IAMUpdateAssumeRolePolicy_trust_policy_document_grammar) +} + +func TestIAMTagRole(ts *TestState) { + ts.Run(IAMTagRole_missing_role_name) + ts.Run(IAMTagRole_invalid_role_name) + ts.Run(IAMTagRole_role_name_too_long) + ts.Run(IAMTagRole_missing_tags) + ts.Run(IAMTagRole_missing_tag_key) + ts.Run(IAMTagRole_missing_tag_value) + ts.Run(IAMTagRole_empty_tag_key) + ts.Run(IAMTagRole_tag_key_too_long) + ts.Run(IAMTagRole_invalid_tag_key) + ts.Run(IAMTagRole_tag_value_too_long) + ts.Run(IAMTagRole_invalid_tag_value) + ts.Run(IAMTagRole_duplicate_tag_keys) + ts.Run(IAMTagRole_too_many_tags) + ts.Run(IAMTagRole_non_existing_role) + ts.Run(IAMTagRole_tag_limit_exceeded) + ts.Run(IAMTagRole_success) + ts.Run(IAMTagRole_overwrites_existing_tag) + ts.Run(IAMTagRole_isolated_from_same_named_user) +} + +func TestIAMUntagRole(ts *TestState) { + ts.Run(IAMUntagRole_missing_role_name) + ts.Run(IAMUntagRole_invalid_role_name) + ts.Run(IAMUntagRole_role_name_too_long) + ts.Run(IAMUntagRole_missing_tag_keys) + ts.Run(IAMUntagRole_invalid_tag_key) + ts.Run(IAMUntagRole_too_many_tag_keys) + ts.Run(IAMUntagRole_non_existing_role) + ts.Run(IAMUntagRole_success) + ts.Run(IAMUntagRole_removal_is_idempotent) + ts.Run(IAMUntagRole_case_insensitive_key) + ts.Run(IAMUntagRole_removes_only_named_keys) +} + +func TestIAMListRoleTags(ts *TestState) { + ts.Run(IAMListRoleTags_missing_role_name) + ts.Run(IAMListRoleTags_invalid_role_name) + ts.Run(IAMListRoleTags_role_name_too_long) + ts.Run(IAMListRoleTags_invalid_max_items) + ts.Run(IAMListRoleTags_invalid_max_items_format) + ts.Run(IAMListRoleTags_non_existing_role) + ts.Run(IAMListRoleTags_empty_result) + ts.Run(IAMListRoleTags_success) + ts.Run(IAMListRoleTags_pagination) +} + +func TestIAMPutRolePolicy(ts *TestState) { + ts.Run(IAMPutRolePolicy_missing_role_name) + ts.Run(IAMPutRolePolicy_missing_policy_name) + ts.Run(IAMPutRolePolicy_missing_policy_document) + ts.Run(IAMPutRolePolicy_invalid_policy_name) + ts.Run(IAMPutRolePolicy_long_policy_name) + ts.Run(IAMPutRolePolicy_non_ascii_policy_document) + ts.Run(IAMPutRolePolicy_non_existing_role) + ts.Run(IAMPutRolePolicy_malformed_policy_document) + ts.Run(IAMPutRolePolicy_principal_not_allowed) + ts.Run(IAMPutRolePolicy_limit_exceeded) + ts.Run(IAMPutRolePolicy_success) + ts.Run(IAMPutRolePolicy_overwrite_updates_existing) +} + +func TestIAMGetRolePolicy(ts *TestState) { + ts.Run(IAMGetRolePolicy_missing_role_name) + ts.Run(IAMGetRolePolicy_missing_policy_name) + ts.Run(IAMGetRolePolicy_non_existing_role) + ts.Run(IAMGetRolePolicy_non_existing_policy) + ts.Run(IAMGetRolePolicy_success) +} + +func TestIAMDeleteRolePolicy(ts *TestState) { + ts.Run(IAMDeleteRolePolicy_missing_role_name) + ts.Run(IAMDeleteRolePolicy_missing_policy_name) + ts.Run(IAMDeleteRolePolicy_non_existing_role) + ts.Run(IAMDeleteRolePolicy_non_existing_policy) + ts.Run(IAMDeleteRolePolicy_success) + ts.Run(IAMDeleteRolePolicy_blocks_role_deletion) +} + +func TestIAMListRolePolicies(ts *TestState) { + ts.Run(IAMListRolePolicies_missing_role_name) + ts.Run(IAMListRolePolicies_non_existing_role) + ts.Run(IAMListRolePolicies_invalid_max_items) + ts.Run(IAMListRolePolicies_empty_result) + ts.Run(IAMListRolePolicies_success) + ts.Run(IAMListRolePolicies_pagination) +} + +func TestIAMCreateOpenIDConnectProvider(ts *TestState) { + ts.Run(IAMCreateOpenIDConnectProvider_missing_url) + ts.Run(IAMCreateOpenIDConnectProvider_invalid_url) + ts.Run(IAMCreateOpenIDConnectProvider_client_id_too_long) + ts.Run(IAMCreateOpenIDConnectProvider_too_many_client_ids) + ts.Run(IAMCreateOpenIDConnectProvider_invalid_thumbprint) + ts.Run(IAMCreateOpenIDConnectProvider_duplicate_tag_keys) + ts.Run(IAMCreateOpenIDConnectProvider_already_exists) + ts.Run(IAMCreateOpenIDConnectProvider_thumbprint_autofetch_communication_error) + ts.Run(IAMCreateOpenIDConnectProvider_quota_exceeded) + ts.Run(IAMCreateOpenIDConnectProvider_success) + ts.Run(IAMCreateOpenIDConnectProvider_defaults) + ts.Run(IAMCreateOpenIDConnectProvider_ip_literal_host) + ts.Run(IAMCreateOpenIDConnectProvider_thumbprint_edge_cases) + ts.Run(IAMCreateOpenIDConnectProvider_trailing_slash_distinct_identity) +} + +func TestIAMGetOpenIDConnectProvider(ts *TestState) { + ts.Run(IAMGetOpenIDConnectProvider_missing_arn) + ts.Run(IAMGetOpenIDConnectProvider_invalid_arn) + ts.Run(IAMGetOpenIDConnectProvider_non_existing) + ts.Run(IAMGetOpenIDConnectProvider_success) +} + +func TestIAMListOpenIDConnectProviders(ts *TestState) { + ts.Run(IAMListOpenIDConnectProviders_success) +} + +func TestIAMDeleteOpenIDConnectProvider(ts *TestState) { + ts.Run(IAMDeleteOpenIDConnectProvider_missing_arn) + ts.Run(IAMDeleteOpenIDConnectProvider_non_existing) + ts.Run(IAMDeleteOpenIDConnectProvider_success) + ts.Run(IAMDeleteOpenIDConnectProvider_not_idempotent) +} + +func TestIAMAddClientIDToOpenIDConnectProvider(ts *TestState) { + ts.Run(IAMAddClientIDToOpenIDConnectProvider_missing_arn) + ts.Run(IAMAddClientIDToOpenIDConnectProvider_missing_client_id) + ts.Run(IAMAddClientIDToOpenIDConnectProvider_client_id_too_long) + ts.Run(IAMAddClientIDToOpenIDConnectProvider_non_existing_provider) + ts.Run(IAMAddClientIDToOpenIDConnectProvider_limit_exceeded) + ts.Run(IAMAddClientIDToOpenIDConnectProvider_success) + ts.Run(IAMAddClientIDToOpenIDConnectProvider_idempotent_duplicate) +} + +func TestIAMRemoveClientIDFromOpenIDConnectProvider(ts *TestState) { + ts.Run(IAMRemoveClientIDFromOpenIDConnectProvider_missing_arn) + ts.Run(IAMRemoveClientIDFromOpenIDConnectProvider_missing_client_id) + ts.Run(IAMRemoveClientIDFromOpenIDConnectProvider_client_id_too_long) + ts.Run(IAMRemoveClientIDFromOpenIDConnectProvider_non_existing_provider) + ts.Run(IAMRemoveClientIDFromOpenIDConnectProvider_success) + ts.Run(IAMRemoveClientIDFromOpenIDConnectProvider_idempotent_absent) +} + +func TestIAMUpdateOpenIDConnectProviderThumbprint(ts *TestState) { + ts.Run(IAMUpdateOpenIDConnectProviderThumbprint_missing_arn) + ts.Run(IAMUpdateOpenIDConnectProviderThumbprint_missing_thumbprint_list) + ts.Run(IAMUpdateOpenIDConnectProviderThumbprint_too_many_thumbprints) + ts.Run(IAMUpdateOpenIDConnectProviderThumbprint_wrong_length_thumbprint) + ts.Run(IAMUpdateOpenIDConnectProviderThumbprint_non_existing_provider) + ts.Run(IAMUpdateOpenIDConnectProviderThumbprint_success) + ts.Run(IAMUpdateOpenIDConnectProviderThumbprint_boundary_max_thumbprints) +} + +func TestIAMTagOpenIDConnectProvider(ts *TestState) { + ts.Run(IAMTagOpenIDConnectProvider_missing_arn) + ts.Run(IAMTagOpenIDConnectProvider_invalid_arn) + ts.Run(IAMTagOpenIDConnectProvider_missing_tags) + ts.Run(IAMTagOpenIDConnectProvider_missing_tag_key) + ts.Run(IAMTagOpenIDConnectProvider_missing_tag_value) + ts.Run(IAMTagOpenIDConnectProvider_invalid_tags) + ts.Run(IAMTagOpenIDConnectProvider_duplicate_tag_keys) + ts.Run(IAMTagOpenIDConnectProvider_too_many_tags) + ts.Run(IAMTagOpenIDConnectProvider_non_existing_provider) + ts.Run(IAMTagOpenIDConnectProvider_invalid_tags_precede_lookup) + ts.Run(IAMTagOpenIDConnectProvider_tag_limit_exceeded) + ts.Run(IAMTagOpenIDConnectProvider_success) + ts.Run(IAMTagOpenIDConnectProvider_overwrites_existing_tag) + ts.Run(IAMTagOpenIDConnectProvider_isolated_per_provider) +} + +func TestIAMUntagOpenIDConnectProvider(ts *TestState) { + ts.Run(IAMUntagOpenIDConnectProvider_missing_arn) + ts.Run(IAMUntagOpenIDConnectProvider_invalid_arn) + ts.Run(IAMUntagOpenIDConnectProvider_missing_tag_keys) + ts.Run(IAMUntagOpenIDConnectProvider_invalid_tag_key) + ts.Run(IAMUntagOpenIDConnectProvider_too_many_tag_keys) + ts.Run(IAMUntagOpenIDConnectProvider_non_existing_provider) + ts.Run(IAMUntagOpenIDConnectProvider_success) + ts.Run(IAMUntagOpenIDConnectProvider_removal_is_idempotent) + ts.Run(IAMUntagOpenIDConnectProvider_case_sensitive_key) + ts.Run(IAMUntagOpenIDConnectProvider_removes_only_named_keys) +} + +func TestIAMListOpenIDConnectProviderTags(ts *TestState) { + ts.Run(IAMListOpenIDConnectProviderTags_missing_arn) + ts.Run(IAMListOpenIDConnectProviderTags_invalid_arn) + ts.Run(IAMListOpenIDConnectProviderTags_invalid_max_items) + ts.Run(IAMListOpenIDConnectProviderTags_invalid_max_items_format) + ts.Run(IAMListOpenIDConnectProviderTags_non_existing_provider) + ts.Run(IAMListOpenIDConnectProviderTags_empty_result) + ts.Run(IAMListOpenIDConnectProviderTags_success) + ts.Run(IAMListOpenIDConnectProviderTags_pagination) +} + +func TestIAMAssumeRoleWithWebIdentity(ts *TestState) { + ts.Run(IAMAssumeRoleWithWebIdentity_missing_role_arn) + ts.Run(IAMAssumeRoleWithWebIdentity_role_arn_too_short) + ts.Run(IAMAssumeRoleWithWebIdentity_malformed_duration) + ts.Run(IAMAssumeRoleWithWebIdentity_wrong_version_is_invalid_action) + ts.Run(IAMAssumeRoleWithWebIdentity_malformed_token) + ts.Run(IAMAssumeRoleWithWebIdentity_duration_exceeds_role_max) + ts.Run(IAMAssumeRoleWithWebIdentity_nonexistent_role) + ts.Run(IAMAssumeRoleWithWebIdentity_no_matching_principal) + ts.Run(IAMAssumeRoleWithWebIdentity_no_issuer_match) + ts.Run(IAMAssumeRoleWithWebIdentity_condition_failed) + ts.Run(IAMAssumeRoleWithWebIdentity_explicit_deny) + ts.Run(IAMAssumeRoleWithWebIdentity_audience_not_in_client_id_list) + ts.Run(IAMAssumeRoleWithWebIdentity_empty_client_id_list) + ts.Run(IAMAssumeRoleWithWebIdentity_idp_communication_error) + ts.Run(IAMAssumeRoleWithWebIdentity_role_arn_path_mismatch) + ts.Run(IAMAssumeRoleWithWebIdentity_policy_arns_rejected) + ts.Run(IAMAssumeRoleWithWebIdentity_provider_id_rejected) + ts.Run(IAMAssumeRoleWithWebIdentity_session_policy_too_large) + ts.Run(IAMAssumeRoleWithWebIdentity_session_policy_invalid) + ts.Run(IAMAssumeRoleWithWebIdentity_oaud_condition_matches) + ts.Run(IAMAssumeRoleWithWebIdentity_oaud_condition_mismatch) + ts.Run(IAMAssumeRoleWithWebIdentity_issuer_trailing_slash_mismatch) + ts.Run(IAMAssumeRoleWithWebIdentity_issuer_scheme_mismatch) +} + +func TestIAMGetCallerIdentity(ts *TestState) { + ts.Run(IAMGetCallerIdentity_root_success) + ts.Run(IAMGetCallerIdentity_user_success) + ts.Run(IAMGetCallerIdentity_unknown_access_key) + ts.Run(IAMGetCallerIdentity_no_auth) + ts.Run(IAMGetCallerIdentity_wrong_version_is_invalid_action) + ts.Run(IAMGetCallerIdentity_incorrect_service_scope) +} + +func TestIAMAccessControl(ts *TestState) { + ts.Run(IAMAccessControl_ImplicitDenyNoMatchingPolicy) + ts.Run(IAMAccessControl_AllowGrantsMatchingRequest) + ts.Run(IAMAccessControl_NonMatchingStatementDoesNotGrant) + ts.Run(IAMAccessControl_ExplicitDenyOverridesAllow) + ts.Run(IAMAccessControl_MultipleStatementsEvaluatedIndependently) + ts.Run(IAMAccessControl_MultipleInlinePoliciesCombinedAllow) + ts.Run(IAMAccessControl_MultipleInlinePoliciesExplicitDenyWins) + ts.Run(IAMAccessControl_EffectNonMatchingAllowStillImplicitlyDenies) + ts.Run(IAMAccessControl_EffectNonMatchingDenyDoesNotBlockUnrelatedAllow) + ts.Run(IAMAccessControl_ActionMatchingVariants) + ts.Run(IAMAccessControl_ActionAllowOneDenyAnotherByOmission) + ts.Run(IAMAccessControl_ActionExplicitDenySubsetOfWildcardAllow) + ts.Run(IAMAccessControl_NotActionAllowGrantsEverythingExceptExcluded) + ts.Run(IAMAccessControl_NotActionDenyBlocksEverythingExceptExcluded) + ts.Run(IAMAccessControl_ResourceMatchingVariants) + ts.Run(IAMAccessControl_ResourceOneAllowedOneDeniedSameAction) + ts.Run(IAMAccessControl_ResourceWildcardRequiredForListAction) + ts.Run(IAMAccessControl_ResourceExplicitDenyOverridesBroaderAllow) + ts.Run(IAMAccessControl_NotResourceExcludesTarget) + ts.Run(IAMAccessControl_NotResourceMultipleExcludedResources) + ts.Run(IAMAccessControl_NotResourceWildcardExclusion) + ts.Run(IAMAccessControl_ConditionStringOperators) + ts.Run(IAMAccessControl_ConditionStringMultipleExpectedValuesOR) + ts.Run(IAMAccessControl_ConditionArnOperators) + ts.Run(IAMAccessControl_ConditionIpAddressRealSourceIp) + ts.Run(IAMAccessControl_ConditionIpAddressExplicitDenyOverridesBroaderAllow) + ts.Run(IAMAccessControl_ConditionMultipleContextKeysANDed) + ts.Run(IAMAccessControl_ConditionAllowMatchesDenyConditionDoesNotApply) + ts.Run(IAMAccessControl_ConditionAllowAndDenyBothMatchDenyWins) + ts.Run(IAMAccessControl_ConditionOneFailedConditionVoidsStatement) + ts.Run(IAMAccessControl_ConditionNullPrincipalTag) + ts.Run(IAMAccessControl_ConditionIfExistsPrincipalTag) + ts.Run(IAMAccessControl_ConditionResourceTagOnTarget) + ts.Run(IAMAccessControl_ConditionRequestTagOnCreateUser) + ts.Run(IAMAccessControl_ConditionCurrentTimeBroadWindow) + ts.Run(IAMAccessControl_ConditionNumericOperators) + ts.Run(IAMAccessControl_ConditionDateOperators) + ts.Run(IAMAccessControl_ConditionBoolOperator) + ts.Run(IAMAccessControl_ConditionNullOperatorClaim) + ts.Run(IAMAccessControl_ConditionBinaryEqualsOperator) + ts.Run(IAMAccessControl_ConditionForAnyValueOperator) + ts.Run(IAMAccessControl_ConditionForAllValuesOperator) + ts.Run(IAMAccessControl_ConditionIfExistsTrustClaim) + ts.Run(IAMAccessControl_ConditionMultipleOperatorBlocksANDedTrust) + ts.Run(IAMAccessControl_TrustPolicyFederatedExactMatchAllowed) + ts.Run(IAMAccessControl_TrustPolicyFederatedWrongProviderDenied) + ts.Run(IAMAccessControl_TrustPolicyFederatedArrayMatchesAny) + ts.Run(IAMAccessControl_TrustPolicyNonFederatedPrincipalsIgnored) + ts.Run(IAMAccessControl_TrustPolicyStringEqualsSubjectExactAllowed) + ts.Run(IAMAccessControl_TrustPolicyStringEqualsSubjectMismatchDenied) + ts.Run(IAMAccessControl_TrustPolicyStringLikeBranchWildcardAllowed) + ts.Run(IAMAccessControl_TrustPolicyStringLikeTagSubjectDenied) + ts.Run(IAMAccessControl_TrustPolicyAudienceCorrectAllowed) + ts.Run(IAMAccessControl_TrustPolicyAudienceIncorrectDenied) + ts.Run(IAMAccessControl_TrustPolicyMultipleAudiencesArrayAllowed) + ts.Run(IAMAccessControl_TrustPolicyAudienceAndSubjectBothMustMatch) + ts.Run(IAMAccessControl_TrustPolicyExplicitDenyStatement) + ts.Run(IAMAccessControl_TrustPolicyMultipleStatementsSecondGrants) + ts.Run(IAMAccessControl_TrustPolicyMissingRequiredClaimDenied) + ts.Run(IAMAccessControl_UserInlinePolicyWorkflow) + ts.Run(IAMAccessControl_UserPathScopedResourceGrantsOnlyMatchingPath) + ts.Run(IAMAccessControl_RolePermissionPolicyDoesNotAffectAssumptionDecision) + ts.Run(IAMAccessControl_RoleTrustDenialIndependentOfPermissionPolicy) + ts.Run(IAMAccessControl_CrossIdentity_UnrelatedRoleCannotBeAssumedViaWrongIssuer) + ts.Run(IAMAccessControl_CrossIdentity_AssumeRoleWithWebIdentityHasNoCallerIdentityCheck) +} + +func TestS3IAMAccessControl(ts *TestState) { + ts.Run(S3IAMAccessControl_no_policy_denies) + ts.Run(S3IAMAccessControl_root_bypasses_policies) + ts.Run(S3IAMAccessControl_identity_policy_allows_without_bucket_policy) + ts.Run(S3IAMAccessControl_identity_policy_action_wildcards) + ts.Run(S3IAMAccessControl_identity_policy_resource_scoping) + ts.Run(S3IAMAccessControl_identity_policy_bucket_vs_object_arn) + ts.Run(S3IAMAccessControl_post_object_identity_policy_resource_scoping) + ts.Run(S3IAMAccessControl_post_object_tagging_identity_policy) + ts.Run(S3IAMAccessControl_identity_policy_not_action_and_not_resource) + ts.Run(S3IAMAccessControl_identity_policy_explicit_deny_wins) + ts.Run(S3IAMAccessControl_multiple_inline_policies_combine) + ts.Run(S3IAMAccessControl_bucket_policy_allows_without_identity_policy) + ts.Run(S3IAMAccessControl_bucket_policy_explicit_deny) + ts.Run(S3IAMAccessControl_policy_combinations) + ts.Run(S3IAMAccessControl_copy_object_requires_both_sides) + ts.Run(S3IAMAccessControl_put_object_tagging_split_sources) + ts.Run(S3IAMAccessControl_copy_object_tagging_split_sources) + ts.Run(S3IAMAccessControl_create_multipart_upload_tagging_split_sources) + ts.Run(S3IAMAccessControl_post_object_tagging_split_sources) + ts.Run(S3IAMAccessControl_put_object_lock_split_sources) + ts.Run(S3IAMAccessControl_create_bucket) + ts.Run(S3IAMAccessControl_list_buckets) + ts.Run(S3IAMAccessControl_governance_bypass_sources) + ts.Run(S3IAMAccessControl_governance_without_bypass_header) + ts.Run(S3IAMAccessControl_compliance_mode_not_bypassable) + ts.Run(S3IAMAccessControl_delete_objects_authorizes_each_key) + ts.Run(S3IAMAccessControl_delete_objects_version_needs_separate_permission) + ts.Run(S3IAMAccessControl_delete_objects_bucket_policy_deny_per_key) + ts.Run(S3IAMAccessControl_delete_objects_deny_across_versioned_split) + ts.Run(S3IAMAccessControl_governance_bypass_delete_objects) + ts.Run(DeleteObjects_iam_mixed_denials_and_success) + ts.Run(DeleteObjects_iam_all_access_denied) + ts.Run(DeleteObjects_iam_all_locked) + ts.Run(S3IAMAccessControl_retention_extension_needs_no_bypass) + ts.Run(S3IAMAccessControl_governance_bypass_put_object_retention) + ts.Run(S3IAMAccessControl_retention_shortening_needs_bypass) + ts.Run(S3IAMAccessControl_condition_source_ip) + ts.Run(S3IAMAccessControl_condition_negated_operator_needs_context) + ts.Run(S3IAMAccessControl_condition_request_keys) + ts.Run(S3IAMAccessControl_condition_identity_keys) + ts.Run(S3IAMAccessControl_condition_principal_tag) + ts.Run(S3IAMAccessControl_condition_on_deny_statement) + ts.Run(S3IAMAccessControl_condition_multiple_keys_anded) + ts.Run(S3IAMAccessControl_condition_if_none_match_required) + ts.Run(S3IAMAccessControl_condition_conditional_write_values) + ts.Run(S3IAMAccessControl_condition_if_match_delete_object) + ts.Run(S3IAMAccessControl_condition_if_match_versioned_delete) + ts.Run(S3IAMAccessControl_condition_conditional_write_keys_ignore_reads) + ts.Run(S3IAMAccessControl_condition_conditional_write_keys_ignore_copies) + ts.Run(S3IAMAccessControl_condition_if_match_bucket_level_write) + ts.Run(S3IAMAccessControl_condition_if_match_ignores_delete_objects) + ts.Run(S3IAMAccessControl_inactive_and_deleted_credentials) + ts.Run(S3IAMAccessControl_access_key_last_used_records_s3) + ts.Run(S3IAMPrincipal_accepted_forms) + ts.Run(S3IAMPrincipal_rejected_forms) + ts.Run(S3IAMPrincipal_empty_forms) + ts.Run(S3IAMPrincipal_user_arn_names_only_that_user) + ts.Run(S3IAMPrincipal_pathed_user_arn) + ts.Run(S3IAMPrincipal_account_delegates_but_does_not_grant) + ts.Run(S3IAMPrincipal_role_arn_does_not_match_a_user) + ts.Run(S3IAMPrincipal_deleted_user_arn_rejected) + ts.Run(S3IAMPrincipal_wildcard_grants_everyone) +} + +// TestS3IAMSessionAccessControl is the one group the OIDC workflow runs, so +// it carries every test that needs a real, signed ID token — including the +// IAM/STS-endpoint ones below, which are not S3 access-control tests but +// have the same GitHub-OIDC prerequisite. Every test here skips itself +// outside a job that can mint a token. +func TestS3IAMSessionAccessControl(ts *TestState) { + ts.Run(S3IAMSession_role_policy_allows) + ts.Run(S3IAMSession_role_without_policy_denied) + ts.Run(S3IAMSession_role_policy_explicit_deny_wins) + ts.Run(S3IAMSession_role_policy_resource_scoped) + ts.Run(S3IAMSession_session_policy_narrows_role) + ts.Run(S3IAMSession_session_policy_cannot_widen_role) + ts.Run(S3IAMSession_session_policy_explicit_deny_overrides_role) + ts.Run(S3IAMSession_role_policy_deny_overrides_session_allow) + ts.Run(S3IAMSession_session_policy_without_role_policy_denied) + ts.Run(S3IAMSession_bucket_policy_allows_without_role_policy) + ts.Run(S3IAMSession_bucket_policy_role_arn_covers_every_session) + ts.Run(S3IAMSession_bucket_policy_names_one_session) + ts.Run(S3IAMSession_bucket_policy_account_delegates) + ts.Run(S3IAMSession_bucket_policy_session_principal_forms) + ts.Run(S3IAMSession_session_policy_filters_bucket_policy_grant) + ts.Run(S3IAMSession_bucket_policy_deny_overrides_role_allow) + ts.Run(S3IAMSession_missing_and_wrong_security_token) + ts.Run(S3IAMSession_presigned_url_with_session_credentials) + ts.Run(S3IAMSession_deleted_role_denies) + ts.Run(S3IAMSession_create_bucket_via_role_policy) + ts.Run(S3IAMSession_governance_bypass_via_role_policy) + ts.Run(S3IAMSession_delete_objects_authorizes_each_key) + ts.Run(S3IAMSession_condition_identity_keys) + ts.Run(S3IAMSession_get_caller_identity_matches_s3_principal) + ts.Run(S3IAMSession_AssumeRoleWithWebIdentity_github_oidc_live) + ts.Run(S3IAMSession_GetRole_role_last_used_recorded) + ts.Run(S3IAMSession_role_last_used_records_s3) +} + +func TestIAM(ts *TestState) { + TestIAMAuth(ts) + TestIAMQueryAuth(ts) + TestIAMCreateUser(ts) + TestIAMGetUser(ts) + TestIAMListUsers(ts) + TestIAMDeleteUser(ts) + TestIAMUpdateUser(ts) + TestIAMTagUser(ts) + TestIAMUntagUser(ts) + TestIAMListUserTags(ts) + TestIAMCreateAccessKey(ts) + TestIAMUpdateAccessKey(ts) + TestIAMDeleteAccessKey(ts) + TestIAMGetAccessKeyLastUsed(ts) + TestIAMListAccessKeys(ts) + TestIAMPutUserPolicy(ts) + TestIAMGetUserPolicy(ts) + TestIAMDeleteUserPolicy(ts) + TestIAMListUserPolicies(ts) + TestIAMCreateRole(ts) + TestIAMGetRole(ts) + TestIAMListRoles(ts) + TestIAMDeleteRole(ts) + TestIAMUpdateAssumeRolePolicy(ts) + TestIAMTagRole(ts) + TestIAMUntagRole(ts) + TestIAMListRoleTags(ts) + TestIAMPutRolePolicy(ts) + TestIAMGetRolePolicy(ts) + TestIAMDeleteRolePolicy(ts) + TestIAMListRolePolicies(ts) + TestIAMCreateOpenIDConnectProvider(ts) + TestIAMGetOpenIDConnectProvider(ts) + TestIAMListOpenIDConnectProviders(ts) + TestIAMDeleteOpenIDConnectProvider(ts) + TestIAMAddClientIDToOpenIDConnectProvider(ts) + TestIAMRemoveClientIDFromOpenIDConnectProvider(ts) + TestIAMUpdateOpenIDConnectProviderThumbprint(ts) + TestIAMTagOpenIDConnectProvider(ts) + TestIAMUntagOpenIDConnectProvider(ts) + TestIAMListOpenIDConnectProviderTags(ts) + TestIAMAssumeRoleWithWebIdentity(ts) + TestIAMGetCallerIdentity(ts) + TestIAMAccessControl(ts) +} + +func TestAccessControl(ts *TestState) { + ts.Run(AccessControl_default_ACL_user_access_denied) + ts.Run(AccessControl_default_ACL_userplus_access_denied) + ts.Run(AccessControl_default_ACL_admin_successful_access) + ts.Run(AccessControl_bucket_resource_single_action) + ts.Run(AccessControl_bucket_resource_all_action) + ts.Run(AccessControl_single_object_resource_actions) + ts.Run(AccessControl_multi_statement_policy) + ts.Run(AccessControl_bucket_ownership_to_user) + ts.Run(AccessControl_root_PutBucketAcl) + ts.Run(AccessControl_user_PutBucketAcl_with_policy_access) + ts.Run(AccessControl_copy_object_with_starting_slash_for_user) + ts.Run(AccessControl_PutObject_with_tagging_policy) + ts.Run(AccessControl_PutObject_with_legal_hold_policy) + ts.Run(AccessControl_PutObject_with_retention_policy) + ts.Run(AccessControl_CreateMultipartUpload_with_tagging_policy) + ts.Run(AccessControl_CreateMultipartUpload_with_legal_hold_policy) + ts.Run(AccessControl_CreateMultipartUpload_with_retention_policy) + ts.Run(AccessControl_CopyObject_with_tagging_policy) + ts.Run(AccessControl_CopyObject_with_legal_hold_policy) + ts.Run(AccessControl_CopyObject_with_retention_policy) + if !ts.conf.azureTests { + ts.Run(AccessControl_policy_normalizes_object_key_for_get_put_delete) + } + ts.Run(AccessControl_bucket_policy_condition_ip_allow) + ts.Run(AccessControl_bucket_policy_condition_ip_deny_no_match) + ts.Run(AccessControl_bucket_policy_condition_not_ip_address_allow) + ts.Run(AccessControl_bucket_policy_condition_not_ip_address_deny) + ts.Run(AccessControl_bucket_policy_condition_explicit_deny_overrides_allow) + ts.Run(AccessControl_bucket_policy_condition_s3_prefix) + ts.Run(AccessControl_bucket_policy_condition_string_operators) + ts.Run(AccessControl_bucket_policy_condition_numeric_operators) + ts.Run(AccessControl_bucket_policy_condition_date_operators) + ts.Run(AccessControl_bucket_policy_condition_bool_operator) + ts.Run(AccessControl_bucket_policy_condition_binary_operator) + ts.Run(AccessControl_bucket_policy_condition_null_operator) + ts.Run(AccessControl_bucket_policy_condition_if_none_match_required) + ts.Run(AccessControl_bucket_policy_condition_if_none_match_value) + ts.Run(AccessControl_bucket_policy_condition_if_match_value) + ts.Run(AccessControl_bucket_policy_condition_if_match_delete_object) + ts.Run(AccessControl_bucket_policy_condition_if_match_versioned_delete) +} + +func TestPublicBuckets(ts *TestState) { + ts.Run(PublicBucket_default_private_bucket) + ts.Run(PublicBucket_public_bucket_policy) + if !ts.conf.versioningEnabled { + // This test targets gateway actions when bucket grants + // public access to object operations: no specific + // bucket versioning operations. As object version cleanup + // is hard to perform, run the test only on the versioning-disabled + // gateway instance + ts.Run(PublicBucket_public_object_policy) + } + ts.Run(PublicBucket_public_acl) + ts.Run(PublicBucket_policy_deny_overrides_public_acl) + ts.Run(PublicBucket_post_object_policy) + ts.Run(PublicBucket_post_object_policy_deny_overrides_public_acl) + ts.Run(PublicBucket_signed_streaming_payload) + ts.Run(PublicBucket_incorrect_sha256_hash) + ts.Run(PublicBucket_put_object_tagging) + ts.Run(PublicBucket_put_object_tagging_public_acl) + ts.Run(PublicBucket_put_object_lock) + ts.Run(PublicBucket_put_object_lock_missing_bucket_lock) + ts.Run(PublicBucket_put_object_default_retention) + ts.Run(PublicBucket_upload_part_object_lock) + ts.Run(PublicBucket_post_object_tagging) + if ts.conf.versioningEnabled { + ts.Run(PublicBucket_object_version_actions) + ts.Run(PublicBucket_object_version_actions_public_acl) + } +} + +func TestVersioning(ts *TestState) { + // PutBucketVersioning action + ts.Run(PutBucketVersioning_non_existing_bucket) + ts.Run(PutBucketVersioning_invalid_status) + ts.Run(PutBucketVersioning_success_enabled) + ts.Run(PutBucketVersioning_success_suspended) + // GetBucketVersioning action + ts.Run(GetBucketVersioning_non_existing_bucket) + ts.Run(GetBucketVersioning_empty_response) + ts.Run(GetBucketVersioning_success) + ts.Run(GetBucketVersioning_non_owner_access_denied) + ts.Run(GetBucketVersioning_with_policy_access) + ts.Run(GetBucketVersioning_with_acl_access) + // DeleteBucket action + ts.Run(Versioning_DeleteBucket_not_empty) + // PutObject action + ts.Run(Versioning_PutObject_suspended_null_versionId_obj) + ts.Run(Versioning_PutObject_null_versionId_obj) + ts.Run(Versioning_PutObject_overwrite_null_versionId_obj) + ts.Run(Versioning_PutObject_success) + ts.Run(Versioning_PutObject_dir_object_new_version_resets_attributes) + ts.Run(Versioning_PutObject_new_version_resets_attributes) + ts.Run(Versioning_PutObject_over_delete_marker_resets_attributes) + ts.Run(Versioning_PutObject_suspended_null_version_resets_attributes) + // CopyObject action + ts.Run(Versioning_CopyObject_invalid_versionId) + ts.Run(Versioning_CopyObject_encoded_versionid_separator_invalid_versionId) + ts.Run(Versioning_CopyObject_success) + ts.Run(Versioning_CopyObject_non_existing_version_id) + ts.Run(Versioning_CopyObject_from_an_object_version) + ts.Run(Versioning_CopyObject_from_a_delete_marker) + ts.Run(Versioning_CopyObject_to_itself) + ts.Run(Versioning_CopyObject_to_itself_from_the_current_version) + if !ts.conf.windowsTests { + ts.Run(Versioning_CopyObject_special_chars) + } + // HeadObject action + ts.Run(Versioning_HeadObject_invalid_versionId) + if !ts.conf.windowsTests { + ts.Run(Versioning_HeadObject_non_existing_object_version) + } + ts.Run(Versioning_HeadObject_invalid_parent) + ts.Run(Versioning_HeadObject_success) + ts.Run(Versioning_HeadObject_dir_object_versions) + ts.Run(Versioning_HeadObject_without_versionId) + ts.Run(Versioning_HeadObject_null_version_without_versionId) + ts.Run(Versioning_HeadObject_null_versionId_obj) + ts.Run(Versioning_HeadObject_delete_marker) + // GetObject action + ts.Run(Versioning_GetObject_invalid_versionId) + ts.Run(Versioning_GetObject_non_existing_object_version) + ts.Run(Versioning_GetObject_success) + ts.Run(Versioning_GetObject_delete_marker_without_versionId) + ts.Run(Versioning_GetObject_delete_marker) + ts.Run(Versioning_GetObject_null_versionId_obj) + ts.Run(Versioning_GetObject_null_version_without_versionId) + ts.Run(Versioning_unversioned_bucket_omits_versionId) + // object tagging actions + ts.Run(Versioning_PutObjectTagging_invalid_versionId) + ts.Run(Versioning_PutObjectTagging_non_existing_object_version) + ts.Run(Versioning_PutGetDeleteObjectTagging_delete_marker) + ts.Run(Versioning_GetObjectTagging_invalid_versionId) + ts.Run(Versioning_GetObjectTagging_non_existing_object_version) + ts.Run(Versioning_DeleteObjectTagging_invalid_versionId) + ts.Run(Versioning_DeleteObjectTagging_non_existing_object_version) + ts.Run(Versioning_PutGetDeleteObjectTagging_success) + ts.Run(Versioning_ObjectTagging_trailing_slash_counterpart) + // GetObjectAttributes action + ts.Run(Versioning_GetObjectAttributes_invalid_versionId) + ts.Run(Versioning_GetObjectAttributes_object_version) + ts.Run(Versioning_GetObjectAttributes_delete_marker) + // DeleteObject actions + ts.Run(Versioning_DeleteObject_invalid_versionId) + ts.Run(Versioning_DeleteObject_delete_object_version) + ts.Run(Versioning_DeleteObject_dir_object_latest_version) + ts.Run(Versioning_DeleteObject_latest_version_with_null_version) + ts.Run(Versioning_DeleteObject_latest_version_null_version_order) + ts.Run(Versioning_DeleteObject_promoted_version_attributes) + ts.Run(Versioning_DeleteObject_promoted_version_last_modified) + ts.Run(Versioning_DeleteObject_delete_marker_last_modified) + ts.Run(Versioning_DeleteObject_non_existing_object) + ts.Run(Versioning_DeleteObject_implicit_dir) + ts.Run(Versioning_DeleteObject_trailing_slash_counterpart) + if !ts.conf.windowsTests { + ts.Run(Versioning_DeleteObject_delete_a_delete_marker) + ts.Run(Versioning_DeleteObject_dir_object_with_children) + } + ts.Run(Versioning_Delete_null_versionId_object) + ts.Run(Versioning_DeleteObject_nested_dir_object) + ts.Run(Versioning_DeleteObject_non_existing_objects) + ts.Run(Versioning_DeleteObject_suspended) + ts.Run(Versioning_DeleteObject_never_versioned_bucket) + ts.Run(Versioning_DeleteObjects_success) + ts.Run(Versioning_DeleteObjects_delete_deleteMarkers) + ts.Run(Versioning_DeleteObjects_never_versioned_bucket) + // ListObjectVersions + ts.Run(ListObjectVersions_non_existing_bucket) + ts.Run(ListObjectVersions_negative_max_keys) + ts.Run(ListObjectVersions_list_single_object_versions) + ts.Run(ListObjectVersions_list_multiple_object_versions) + ts.Run(ListObjectVersions_dir_object_with_children) + ts.Run(ListObjectVersions_multiple_object_versions_truncated) + ts.Run(ListObjectVersions_with_delete_markers) + ts.Run(ListObjectVersions_containing_null_versionId_obj) + ts.Run(ListObjectVersions_paginate_null_version) + ts.Run(ListObjectVersions_single_null_versionId_object) + ts.Run(ListObjectVersions_checksum) + // Multipart upload + ts.Run(Versioning_Multipart_Upload_success) + ts.Run(Versioning_Multipart_Upload_overwrite_an_object) + ts.Run(Versioning_Multipart_Upload_suspended_overwrite_versioned_object) + ts.Run(Versioning_Multipart_Upload_overwrite_keeps_previous_version_metadata) + ts.Run(Versioning_UploadPartCopy_invalid_versionId) + ts.Run(Versioning_UploadPartCopy_encoded_versionid_separator_invalid_versionId) + ts.Run(Versioning_UploadPartCopy_non_existing_versionId) + ts.Run(Versioning_UploadPartCopy_from_an_object_version) + ts.Run(Versioning_UploadPartCopy_from_a_delete_marker) + // Object lock configuration + ts.Run(Versioning_object_lock_not_enabled_on_bucket_creation) + ts.Run(Versioning_Enable_object_lock) + ts.Run(Versioning_status_switch_to_suspended_with_object_lock) + // Object-Lock Retention + ts.Run(Versioning_PutObjectRetention_invalid_versionId) + ts.Run(Versioning_PutObjectRetention_non_existing_object_version) + ts.Run(Versioning_GetObjectRetention_invalid_versionId) + ts.Run(Versioning_GetObjectRetention_non_existing_object_version) + ts.Run(Versioning_Put_GetObjectRetention_delete_marker) + ts.Run(Versioning_Put_GetObjectRetention_success) + // Object-Lock Legal hold + ts.Run(Versioning_PutObjectLegalHold_invalid_versionId) + ts.Run(Versioning_PutObjectLegalHold_non_existing_object_version) + ts.Run(Versioning_GetObjectLegalHold_invalid_versionId) + ts.Run(Versioning_GetObjectLegalHold_non_existing_object_version) + ts.Run(Versioning_PutGetObjectLegalHold_delete_marker) + ts.Run(Versioning_Put_GetObjectLegalHold_success) + // WORM protection + ts.Run(Versioning_WORM_obj_version_locked_with_legal_hold) + ts.Run(Versioning_WORM_dir_object_lock_headers) + ts.Run(Versioning_WORM_obj_version_locked_with_governance_retention) + ts.Run(Versioning_WORM_obj_version_locked_with_compliance_retention) + ts.Run(Versioning_WORM_delete_marker_locked_object_legal_hold) + ts.Run(Versioning_WORM_delete_marker_locked_object_governance_retention) + ts.Run(Versioning_WORM_delete_marker_locked_object_compliance_retention) + ts.Run(Versioning_WORM_PutObject_overwrite_locked_object) + ts.Run(Versioning_WORM_CopyObject_overwrite_locked_object) + ts.Run(Versioning_WORM_CopyObject_to_itself_locked_object) + ts.Run(Versioning_WORM_CompleteMultipartUpload_overwrite_locked_object) + if !ts.conf.windowsTests { + ts.Run(Versioning_WORM_remove_delete_marker_under_bucket_default_retention) + } + ts.Run(Versioning_WORM_trailing_slash_counterpart) + ts.Run(Versioning_WORM_null_version_locked_with_legal_hold) + ts.Run(Versioning_WORM_PutObject_new_version_lock_settings) + ts.Run(Versioning_WORM_DeleteObject_promoted_version_lock_settings) + // Concurrent requests + // Versioninig_concurrent_upload_object + ts.Run(Versioning_AccessControl_GetObjectVersion) + ts.Run(Versioning_AccessControl_HeadObjectVersion) + ts.Run(Versioning_AccessControl_object_tagging_policy) + if !ts.conf.windowsTests { + ts.Run(Versioning_AccessControl_DeleteObject_policy) + } + ts.Run(Versioning_AccessControl_GetObjectAttributes_policy) +} + +func TestVersioningDisabled(ts *TestState) { + ts.Run(VersioningDisabled_GetBucketVersioning_not_configured) + ts.Run(VersioningDisabled_GetBucketVersioning_no_such_bucket) + ts.Run(VersioningDisabled_PutBucketVersioning_not_configured) +} + +func TestRouter(ts *TestState) { + ts.Run(RouterPutPartNumberWithoutUploadId) + ts.Run(RouterPostRoot) + ts.Run(RouterPostObjectWithoutQuery) + ts.Run(RouterPUTObjectOnlyUploadId) + ts.Run(RouterGetUploadsWithKey) + ts.Run(RouterCopySourceNotAllowed) + ts.Run(RouterListVersionsWithKey) + ts.Run(RouterObjectAnnotationNotImplemented) + ts.Run(RouterRenameObjectNotImplemented) + ts.Run(RouterObjectTorrentMethodNotAllowed) +} + +func TestPostObject(ts *TestState) { + ts.Run(PostObject_invalid_content_type) + ts.Run(PostObject_missing_boundary) + ts.Run(PostObject_partial_auth_fields) + ts.Run(PostObject_invalid_algorithm) + ts.Run(PostObject_invalid_date) + ts.Run(PostObject_invalid_credential_format) + ts.Run(PostObject_incorrect_region) + ts.Run(PostObject_non_existing_access_key) + ts.Run(PostObject_signature_mismatch) + ts.Run(PostObject_expired_due_to_date) + ts.Run(PostObject_access_denied) + ts.Run(PostObject_bucket_policy_object_resource) + ts.Run(PostObject_bucket_policy_explicit_deny) + ts.Run(PostObject_tagging_requires_put_object_tagging) + ts.Run(PostObject_tagging_bucket_policy_explicit_deny) + ts.Run(PostObject_empty_tag_set_requires_only_put_object) + ts.Run(PostObject_invalid_object_names) + ts.Run(PostObject_policy_access_control) + ts.Run(PostObject_policy_expired) + ts.Run(PostObject_invalid_policy_document) + ts.Run(PostObject_policy_condition_key_mismatch) + ts.Run(PostObject_policy_extra_field) + ts.Run(PostObject_policy_missing_bucket_condition) + ts.Run(PostObject_policy_content_length_too_large) + ts.Run(PostObject_policy_content_length_too_small) + ts.Run(PostObject_success) + ts.Run(PostObject_success_status_200) + ts.Run(PostObject_success_status_201) + ts.Run(PostObject_should_ignore_anything_after_file) + ts.Run(PostObject_success_with_meta_properties) + ts.Run(PostObject_default_content_type) + ts.Run(PostObject_invalid_website_redirect_location) + ts.Run(PostObject_invalid_tagging) + ts.Run(PostObject_success_with_tagging) + ts.Run(PostObject_success_double_dash_boundary) + if !ts.conf.azureTests { + ts.Run(PostObject_invalid_checksum_value) + ts.Run(PostObject_invalid_checksum_algorithm) + ts.Run(PostObject_multiple_checksum_headers) + ts.Run(PostObject_checksums_success) + } +} + +func TestServer(ts *TestState) { + // TestServer tests s3 api server specific behaviors + ts.Run(Server_large_http_header) +} + +func TestUnsignedStreaminPayloadTrailer(ts *TestState) { + // azure doesn't support checksums + if !ts.conf.azureTests { + ts.Run(UnsignedStreaminPayloadTrailer_malformed_trailer) + ts.Run(UnsignedStreamingPayloadTrailer_missing_invalid_dec_content_length) + ts.Run(UnsignedStreamingPayloadTrailer_invalid_trailing_checksum) + ts.Run(UnsignedStreamingPayloadTrailer_incorrect_trailing_checksum) + ts.Run(UnsignedStreamingPayloadTrailer_multiple_checksum_headers) + ts.Run(UnsignedStreamingPayloadTrailer_sdk_algo_and_trailer_mismatch) + ts.Run(UnsignedStreamingPayloadTrailer_incomplete_body) + ts.Run(UnsignedStreamingPayloadTrailer_aborted_connection) + ts.Run(UnsignedStreamingPayloadTrailer_invalid_chunk_size) + ts.Run(UnsignedStreamingPayloadTrailer_content_length_payload_size_mismatch) + ts.Run(UnsignedStreamingPayloadTrailer_no_trailer_should_calculate_crc64nvme) + ts.Run(UnsignedStreamingPayloadTrailer_no_payload_trailer_only_headers) + ts.Run(UnsignedStreamingPayloadTrailer_success_both_sdk_algo_and_trailer) + ts.Run(UnsignedStreamingPayloadTrailer_strips_aws_chunked_content_encoding) + ts.Run(UnsignedStreamingPayloadTrailer_UploadPart_no_trailer_composite_checksum) + ts.Run(UnsignedStreamingPayloadTrailer_UploadPart_no_trailer_full_object) + ts.Run(UnsignedStreamingPayloadTrailer_UploadPart_trailer_and_mp_algo_mismatch) + ts.Run(UnsignedStreamingPayloadTrailer_UploadPart_success_with_trailer) + ts.Run(UnsignedStreamingPayloadTrailer_not_allowed) + } +} + +func TestSignedStreaminPayload(ts *TestState) { + if !ts.conf.azureTests { + ts.Run(SignedStreamingPayload_invalid_encoding) + ts.Run(SignedStreamingPayload_invalid_chunk_size) + ts.Run(SignedStreamingPayload_decoded_content_length_mismatch) + } +} + +func TestSignedStreaminPayloadTrailer(ts *TestState) { + if !ts.conf.azureTests { + ts.Run(SignedStreamingPayloadTrailer_malformed_trailer) + ts.Run(SignedStreamingPayloadTrailer_incomplete_body) + ts.Run(SignedStreamingPayloadTrailer_missing_x_amz_trailer_header) + ts.Run(SignedStreamingPayloadTrailer_invalid_checksum) + ts.Run(SignedStreamingPayloadTrailer_bad_digest) + ts.Run(SignedStreamingPayloadTrailer_success) + } +} + +func TestNoAclMode(ts *TestState) { + ts.Run(NoAclMode_CreateBucket_with_acl) + ts.Run(NoAclMode_PutBucketAcl) +} + +func TestDataIntegrityETag(ts *TestState) { + ts.Run(PutObject_data_integrity_etag) + ts.Run(PutObject_dir_object_data_integrity_etag) + ts.Run(UploadPart_data_integrity_etag) + ts.Run(UploadPartCopy_data_integrity_etag) + ts.Run(CompleteMultipartUpload_data_integrity_etag) +} + +type IntTest func(s3 *S3Conf) error + +type IntTests map[string]IntTest + +func GetIntTests() IntTests { + return IntTests{ + "S3IAMAccessControl_retention_shortening_needs_bypass": S3IAMAccessControl_retention_shortening_needs_bypass, + "S3IAMSession_get_caller_identity_matches_s3_principal": S3IAMSession_get_caller_identity_matches_s3_principal, + "S3IAMSession_condition_identity_keys": S3IAMSession_condition_identity_keys, + "S3IAMSession_delete_objects_authorizes_each_key": S3IAMSession_delete_objects_authorizes_each_key, + "S3IAMSession_governance_bypass_via_role_policy": S3IAMSession_governance_bypass_via_role_policy, + "S3IAMSession_create_bucket_via_role_policy": S3IAMSession_create_bucket_via_role_policy, + "S3IAMSession_deleted_role_denies": S3IAMSession_deleted_role_denies, + "S3IAMSession_presigned_url_with_session_credentials": S3IAMSession_presigned_url_with_session_credentials, + "S3IAMSession_missing_and_wrong_security_token": S3IAMSession_missing_and_wrong_security_token, + "S3IAMSession_bucket_policy_deny_overrides_role_allow": S3IAMSession_bucket_policy_deny_overrides_role_allow, + "S3IAMSession_session_policy_filters_bucket_policy_grant": S3IAMSession_session_policy_filters_bucket_policy_grant, + "S3IAMSession_bucket_policy_allows_without_role_policy": S3IAMSession_bucket_policy_allows_without_role_policy, + "S3IAMSession_session_policy_without_role_policy_denied": S3IAMSession_session_policy_without_role_policy_denied, + "S3IAMSession_role_policy_deny_overrides_session_allow": S3IAMSession_role_policy_deny_overrides_session_allow, + "S3IAMSession_session_policy_explicit_deny_overrides_role": S3IAMSession_session_policy_explicit_deny_overrides_role, + "S3IAMSession_session_policy_cannot_widen_role": S3IAMSession_session_policy_cannot_widen_role, + "S3IAMSession_session_policy_narrows_role": S3IAMSession_session_policy_narrows_role, + "S3IAMSession_role_policy_resource_scoped": S3IAMSession_role_policy_resource_scoped, + "S3IAMSession_role_policy_explicit_deny_wins": S3IAMSession_role_policy_explicit_deny_wins, + "S3IAMSession_role_without_policy_denied": S3IAMSession_role_without_policy_denied, + "S3IAMSession_role_policy_allows": S3IAMSession_role_policy_allows, + "S3IAMSession_AssumeRoleWithWebIdentity_github_oidc_live": S3IAMSession_AssumeRoleWithWebIdentity_github_oidc_live, + "S3IAMSession_GetRole_role_last_used_recorded": S3IAMSession_GetRole_role_last_used_recorded, + "S3IAMSession_role_last_used_records_s3": S3IAMSession_role_last_used_records_s3, + "S3IAMAccessControl_retention_extension_needs_no_bypass": S3IAMAccessControl_retention_extension_needs_no_bypass, + "S3IAMAccessControl_delete_objects_authorizes_each_key": S3IAMAccessControl_delete_objects_authorizes_each_key, + "S3IAMAccessControl_delete_objects_version_needs_separate_permission": S3IAMAccessControl_delete_objects_version_needs_separate_permission, + "S3IAMAccessControl_delete_objects_bucket_policy_deny_per_key": S3IAMAccessControl_delete_objects_bucket_policy_deny_per_key, + "S3IAMAccessControl_delete_objects_deny_across_versioned_split": S3IAMAccessControl_delete_objects_deny_across_versioned_split, + "S3IAMAccessControl_no_policy_denies": S3IAMAccessControl_no_policy_denies, + "S3IAMAccessControl_root_bypasses_policies": S3IAMAccessControl_root_bypasses_policies, + "S3IAMAccessControl_identity_policy_allows_without_bucket_policy": S3IAMAccessControl_identity_policy_allows_without_bucket_policy, + "S3IAMAccessControl_identity_policy_action_wildcards": S3IAMAccessControl_identity_policy_action_wildcards, + "S3IAMAccessControl_identity_policy_resource_scoping": S3IAMAccessControl_identity_policy_resource_scoping, + "S3IAMAccessControl_identity_policy_bucket_vs_object_arn": S3IAMAccessControl_identity_policy_bucket_vs_object_arn, + "S3IAMAccessControl_post_object_identity_policy_resource_scoping": S3IAMAccessControl_post_object_identity_policy_resource_scoping, + "S3IAMAccessControl_post_object_tagging_identity_policy": S3IAMAccessControl_post_object_tagging_identity_policy, + "S3IAMAccessControl_identity_policy_not_action_and_not_resource": S3IAMAccessControl_identity_policy_not_action_and_not_resource, + "S3IAMAccessControl_identity_policy_explicit_deny_wins": S3IAMAccessControl_identity_policy_explicit_deny_wins, + "S3IAMAccessControl_multiple_inline_policies_combine": S3IAMAccessControl_multiple_inline_policies_combine, + "S3IAMAccessControl_bucket_policy_allows_without_identity_policy": S3IAMAccessControl_bucket_policy_allows_without_identity_policy, + "S3IAMAccessControl_bucket_policy_explicit_deny": S3IAMAccessControl_bucket_policy_explicit_deny, + "S3IAMAccessControl_policy_combinations": S3IAMAccessControl_policy_combinations, + "S3IAMAccessControl_copy_object_requires_both_sides": S3IAMAccessControl_copy_object_requires_both_sides, + "S3IAMAccessControl_put_object_tagging_split_sources": S3IAMAccessControl_put_object_tagging_split_sources, + "S3IAMAccessControl_copy_object_tagging_split_sources": S3IAMAccessControl_copy_object_tagging_split_sources, + "S3IAMAccessControl_create_multipart_upload_tagging_split_sources": S3IAMAccessControl_create_multipart_upload_tagging_split_sources, + "S3IAMAccessControl_post_object_tagging_split_sources": S3IAMAccessControl_post_object_tagging_split_sources, + "S3IAMAccessControl_put_object_lock_split_sources": S3IAMAccessControl_put_object_lock_split_sources, + "S3IAMAccessControl_create_bucket": S3IAMAccessControl_create_bucket, + "S3IAMAccessControl_list_buckets": S3IAMAccessControl_list_buckets, + "S3IAMAccessControl_governance_bypass_sources": S3IAMAccessControl_governance_bypass_sources, + "S3IAMAccessControl_governance_without_bypass_header": S3IAMAccessControl_governance_without_bypass_header, + "S3IAMAccessControl_compliance_mode_not_bypassable": S3IAMAccessControl_compliance_mode_not_bypassable, + "S3IAMAccessControl_governance_bypass_delete_objects": S3IAMAccessControl_governance_bypass_delete_objects, + "S3IAMAccessControl_governance_bypass_put_object_retention": S3IAMAccessControl_governance_bypass_put_object_retention, + "S3IAMAccessControl_condition_source_ip": S3IAMAccessControl_condition_source_ip, + "S3IAMAccessControl_condition_negated_operator_needs_context": S3IAMAccessControl_condition_negated_operator_needs_context, + "S3IAMAccessControl_condition_request_keys": S3IAMAccessControl_condition_request_keys, + "S3IAMAccessControl_condition_identity_keys": S3IAMAccessControl_condition_identity_keys, + "S3IAMAccessControl_condition_principal_tag": S3IAMAccessControl_condition_principal_tag, + "S3IAMAccessControl_condition_on_deny_statement": S3IAMAccessControl_condition_on_deny_statement, + "S3IAMAccessControl_condition_multiple_keys_anded": S3IAMAccessControl_condition_multiple_keys_anded, + "S3IAMAccessControl_condition_if_none_match_required": S3IAMAccessControl_condition_if_none_match_required, + "S3IAMAccessControl_condition_conditional_write_values": S3IAMAccessControl_condition_conditional_write_values, + "S3IAMAccessControl_condition_if_match_delete_object": S3IAMAccessControl_condition_if_match_delete_object, + "S3IAMAccessControl_condition_if_match_versioned_delete": S3IAMAccessControl_condition_if_match_versioned_delete, + "S3IAMAccessControl_condition_conditional_write_keys_ignore_reads": S3IAMAccessControl_condition_conditional_write_keys_ignore_reads, + "S3IAMAccessControl_condition_conditional_write_keys_ignore_copies": S3IAMAccessControl_condition_conditional_write_keys_ignore_copies, + "S3IAMAccessControl_condition_if_match_bucket_level_write": S3IAMAccessControl_condition_if_match_bucket_level_write, + "S3IAMAccessControl_condition_if_match_ignores_delete_objects": S3IAMAccessControl_condition_if_match_ignores_delete_objects, + "S3IAMAccessControl_inactive_and_deleted_credentials": S3IAMAccessControl_inactive_and_deleted_credentials, + "S3IAMSession_bucket_policy_role_arn_covers_every_session": S3IAMSession_bucket_policy_role_arn_covers_every_session, + "S3IAMSession_bucket_policy_names_one_session": S3IAMSession_bucket_policy_names_one_session, + "S3IAMSession_bucket_policy_account_delegates": S3IAMSession_bucket_policy_account_delegates, + "S3IAMSession_bucket_policy_session_principal_forms": S3IAMSession_bucket_policy_session_principal_forms, + "S3IAMPrincipal_accepted_forms": S3IAMPrincipal_accepted_forms, + "S3IAMPrincipal_rejected_forms": S3IAMPrincipal_rejected_forms, + "S3IAMPrincipal_empty_forms": S3IAMPrincipal_empty_forms, + "S3IAMPrincipal_user_arn_names_only_that_user": S3IAMPrincipal_user_arn_names_only_that_user, + "S3IAMPrincipal_pathed_user_arn": S3IAMPrincipal_pathed_user_arn, + "S3IAMPrincipal_account_delegates_but_does_not_grant": S3IAMPrincipal_account_delegates_but_does_not_grant, + "S3IAMPrincipal_role_arn_does_not_match_a_user": S3IAMPrincipal_role_arn_does_not_match_a_user, + "S3IAMPrincipal_deleted_user_arn_rejected": S3IAMPrincipal_deleted_user_arn_rejected, + "S3IAMPrincipal_wildcard_grants_everyone": S3IAMPrincipal_wildcard_grants_everyone, + "S3IAMAccessControl_access_key_last_used_records_s3": S3IAMAccessControl_access_key_last_used_records_s3, + "Authentication_invalid_auth_header": Authentication_invalid_auth_header, + "Authentication_unsupported_signature_version": Authentication_unsupported_signature_version, + "Authentication_missing_components": Authentication_missing_components, + "Authentication_malformed_component": Authentication_malformed_component, + "Authentication_missing_credentials": Authentication_missing_credentials, + "Authentication_missing_signedheaders": Authentication_missing_signedheaders, + "Authentication_missing_signature": Authentication_missing_signature, + "Authentication_malformed_credential": Authentication_malformed_credential, + "Authentication_credentials_invalid_terminal": Authentication_credentials_invalid_terminal, + "Authentication_credentials_incorrect_service": Authentication_credentials_incorrect_service, + "Authentication_credentials_incorrect_region": Authentication_credentials_incorrect_region, + "Authentication_credentials_incorrect_region_head": Authentication_credentials_incorrect_region_head, + "Authentication_credentials_invalid_date": Authentication_credentials_invalid_date, + "Authentication_credentials_future_date": Authentication_credentials_future_date, + "Authentication_credentials_past_date": Authentication_credentials_past_date, + "Authentication_credentials_non_existing_access_key": Authentication_credentials_non_existing_access_key, + "Authentication_missing_date_header": Authentication_missing_date_header, + "Authentication_invalid_date_header": Authentication_invalid_date_header, + "Authentication_date_mismatch": Authentication_date_mismatch, + "Authentication_incorrect_payload_hash": Authentication_incorrect_payload_hash, + "Authentication_invalid_sha256_payload_hash": Authentication_invalid_sha256_payload_hash, + "Authentication_unsigned_required_header": Authentication_unsigned_required_header, + "Authentication_unsigned_non_required_header": Authentication_unsigned_non_required_header, + "Authentication_signature_error_incorrect_secret_key": Authentication_signature_error_incorrect_secret_key, + "Authentication_sigv2_not_supported": Authentication_sigv2_not_supported, + "Authentication_with_expect_header": Authentication_with_expect_header, + "IAMAuth_invalid_auth_header": IAMAuth_invalid_auth_header, + "IAMAuth_unsupported_signature_version": IAMAuth_unsupported_signature_version, + "IAMAuth_malformed_component": IAMAuth_malformed_component, + "IAMAuth_missing_authorization_component": IAMAuth_missing_authorization_component, + "IAMAuth_malformed_credential": IAMAuth_malformed_credential, + "IAMAuth_credentials_invalid_terminal": IAMAuth_credentials_invalid_terminal, + "IAMAuth_credentials_incorrect_service": IAMAuth_credentials_incorrect_service, + "IAMAuth_credentials_incorrect_region": IAMAuth_credentials_incorrect_region, + "IAMAuth_credentials_invalid_date": IAMAuth_credentials_invalid_date, + "IAMAuth_credentials_future_date": IAMAuth_credentials_future_date, + "IAMAuth_credentials_past_date": IAMAuth_credentials_past_date, + "IAMAuth_credentials_non_existing_access_key": IAMAuth_credentials_non_existing_access_key, + "IAMAuth_missing_date_header": IAMAuth_missing_date_header, + "IAMAuth_invalid_date_header": IAMAuth_invalid_date_header, + "IAMAuth_date_mismatch": IAMAuth_date_mismatch, + "IAMAuth_invalid_sha256_payload_hash_ignored": IAMAuth_invalid_sha256_payload_hash_ignored, + "IAMAuth_unsigned_required_header": IAMAuth_unsigned_required_header, + "IAMAuth_unsigned_non_required_header": IAMAuth_unsigned_non_required_header, + "IAMAuth_signature_error_incorrect_secret_key": IAMAuth_signature_error_incorrect_secret_key, + "IAMAuth_sigv2_not_supported": IAMAuth_sigv2_not_supported, + "IAMAuth_with_expect_header": IAMAuth_with_expect_header, + "IAMQueryAuth_success": IAMQueryAuth_success, + "IAMQueryAuth_security_token_not_supported": IAMQueryAuth_security_token_not_supported, + "IAMQueryAuth_unsupported_algorithm": IAMQueryAuth_unsupported_algorithm, + "IAMQueryAuth_ECDSA_not_supported": IAMQueryAuth_ECDSA_not_supported, + "IAMQueryAuth_missing_query_parameters": IAMQueryAuth_missing_query_parameters, + "IAMQueryAuth_malformed_credential": IAMQueryAuth_malformed_credential, + "IAMQueryAuth_credentials_invalid_terminal": IAMQueryAuth_credentials_invalid_terminal, + "IAMQueryAuth_credentials_incorrect_service": IAMQueryAuth_credentials_incorrect_service, + "IAMQueryAuth_credentials_incorrect_region": IAMQueryAuth_credentials_incorrect_region, + "IAMQueryAuth_credentials_invalid_date": IAMQueryAuth_credentials_invalid_date, + "IAMQueryAuth_non_existing_access_key": IAMQueryAuth_non_existing_access_key, + "IAMQueryAuth_invalid_date": IAMQueryAuth_invalid_date, + "IAMQueryAuth_date_mismatch": IAMQueryAuth_date_mismatch, + "IAMQueryAuth_unsigned_query_parameter": IAMQueryAuth_unsigned_query_parameter, + "IAMQueryAuth_incorrect_secret_key": IAMQueryAuth_incorrect_secret_key, + "IAMQueryAuth_invalid_sha256_payload_hash_ignored": IAMQueryAuth_invalid_sha256_payload_hash_ignored, + "IAMQueryAuth_with_expect_header": IAMQueryAuth_with_expect_header, + "IAMCreateUser_user_already_exists": IAMCreateUser_user_already_exists, + "IAMCreateUser_already_exists_case_insensitive": IAMCreateUser_already_exists_case_insensitive, + "IAMCreateUser_invalid_user_name": IAMCreateUser_invalid_user_name, + "IAMCreateUser_long_user_name": IAMCreateUser_long_user_name, + "IAMCreateUser_missing_user_name": IAMCreateUser_missing_user_name, + "IAMCreateUser_invalid_tag_key": IAMCreateUser_invalid_tag_key, + "IAMCreateUser_invalid_tag_value": IAMCreateUser_invalid_tag_value, + "IAMCreateUser_long_tag_key": IAMCreateUser_long_tag_key, + "IAMCreateUser_long_tag_value": IAMCreateUser_long_tag_value, + "IAMCreateUser_duplicate_tag_keys": IAMCreateUser_duplicate_tag_keys, + "IAMCreateUser_success": IAMCreateUser_success, + "IAMCreateUser_default_path": IAMCreateUser_default_path, + "IAMCreateUser_invalid_path": IAMCreateUser_invalid_path, + "IAMCreateUser_long_path": IAMCreateUser_long_path, + "IAMGetUser_long_user_name": IAMGetUser_long_user_name, + "IAMGetUser_invalid_user_name": IAMGetUser_invalid_user_name, + "IAMGetUser_non_existing_user": IAMGetUser_non_existing_user, + "IAMGetUser_success": IAMGetUser_success, + "IAMGetUser_root_user": IAMGetUser_root_user, + "IAMListUsers_invalid_path_prefix": IAMListUsers_invalid_path_prefix, + "IAMListUsers_long_path_prefix": IAMListUsers_long_path_prefix, + "IAMListUsers_invalid_max_items": IAMListUsers_invalid_max_items, + "IAMListUsers_invalid_max_items_format": IAMListUsers_invalid_max_items_format, + "IAMListUsers_empty_result": IAMListUsers_empty_result, + "IAMListUsers_success": IAMListUsers_success, + "IAMListUsers_path_prefix": IAMListUsers_path_prefix, + "IAMListUsers_pagination": IAMListUsers_pagination, + "IAMListUsers_path_prefix_pagination": IAMListUsers_path_prefix_pagination, + "IAMDeleteUser_invalid_user_name": IAMDeleteUser_invalid_user_name, + "IAMDeleteUser_long_user_name": IAMDeleteUser_long_user_name, + "IAMDeleteUser_non_existing_user": IAMDeleteUser_non_existing_user, + "IAMDeleteUser_has_access_keys": IAMDeleteUser_has_access_keys, + "IAMDeleteUser_success": IAMDeleteUser_success, + "IAMUpdateUser_invalid_user_name": IAMUpdateUser_invalid_user_name, + "IAMUpdateUser_long_user_name": IAMUpdateUser_long_user_name, + "IAMUpdateUser_invalid_new_user_name": IAMUpdateUser_invalid_new_user_name, + "IAMUpdateUser_long_new_user_name": IAMUpdateUser_long_new_user_name, + "IAMUpdateUser_non_existing_user": IAMUpdateUser_non_existing_user, + "IAMUpdateUser_invalid_new_path": IAMUpdateUser_invalid_new_path, + "IAMUpdateUser_long_new_path": IAMUpdateUser_long_new_path, + "IAMUpdateUser_new_user_name_already_exists": IAMUpdateUser_new_user_name_already_exists, + "IAMUpdateUser_success": IAMUpdateUser_success, + "IAMTagUser_missing_user_name": IAMTagUser_missing_user_name, + "IAMTagUser_invalid_user_name": IAMTagUser_invalid_user_name, + "IAMTagUser_user_name_too_long": IAMTagUser_user_name_too_long, + "IAMTagUser_missing_tags": IAMTagUser_missing_tags, + "IAMTagUser_missing_tag_key": IAMTagUser_missing_tag_key, + "IAMTagUser_missing_tag_value": IAMTagUser_missing_tag_value, + "IAMTagUser_empty_tag_key": IAMTagUser_empty_tag_key, + "IAMTagUser_tag_key_too_long": IAMTagUser_tag_key_too_long, + "IAMTagUser_invalid_tag_key": IAMTagUser_invalid_tag_key, + "IAMTagUser_tag_value_too_long": IAMTagUser_tag_value_too_long, + "IAMTagUser_invalid_tag_value": IAMTagUser_invalid_tag_value, + "IAMTagUser_duplicate_tag_keys": IAMTagUser_duplicate_tag_keys, + "IAMTagUser_too_many_tags": IAMTagUser_too_many_tags, + "IAMTagUser_non_existing_user": IAMTagUser_non_existing_user, + "IAMTagUser_tag_limit_exceeded": IAMTagUser_tag_limit_exceeded, + "IAMTagUser_success": IAMTagUser_success, + "IAMTagUser_overwrites_existing_tag": IAMTagUser_overwrites_existing_tag, + "IAMUntagUser_missing_user_name": IAMUntagUser_missing_user_name, + "IAMUntagUser_invalid_user_name": IAMUntagUser_invalid_user_name, + "IAMUntagUser_user_name_too_long": IAMUntagUser_user_name_too_long, + "IAMUntagUser_missing_tag_keys": IAMUntagUser_missing_tag_keys, + "IAMUntagUser_invalid_tag_key": IAMUntagUser_invalid_tag_key, + "IAMUntagUser_too_many_tag_keys": IAMUntagUser_too_many_tag_keys, + "IAMUntagUser_non_existing_user": IAMUntagUser_non_existing_user, + "IAMUntagUser_success": IAMUntagUser_success, + "IAMUntagUser_removal_is_idempotent": IAMUntagUser_removal_is_idempotent, + "IAMUntagUser_case_insensitive_key": IAMUntagUser_case_insensitive_key, + "IAMListUserTags_missing_user_name": IAMListUserTags_missing_user_name, + "IAMListUserTags_invalid_user_name": IAMListUserTags_invalid_user_name, + "IAMListUserTags_user_name_too_long": IAMListUserTags_user_name_too_long, + "IAMListUserTags_invalid_max_items": IAMListUserTags_invalid_max_items, + "IAMListUserTags_invalid_max_items_format": IAMListUserTags_invalid_max_items_format, + "IAMListUserTags_non_existing_user": IAMListUserTags_non_existing_user, + "IAMListUserTags_empty_result": IAMListUserTags_empty_result, + "IAMListUserTags_success": IAMListUserTags_success, + "IAMListUserTags_pagination": IAMListUserTags_pagination, + "IAMCreateAccessKey_missing_user_name": IAMCreateAccessKey_missing_user_name, + "IAMCreateAccessKey_empty_user_name": IAMCreateAccessKey_empty_user_name, + "IAMCreateAccessKey_infers_caller_user_name": IAMCreateAccessKey_infers_caller_user_name, + "IAMCreateAccessKey_invalid_user_name": IAMCreateAccessKey_invalid_user_name, + "IAMCreateAccessKey_long_user_name": IAMCreateAccessKey_long_user_name, + "IAMCreateAccessKey_non_existing_user": IAMCreateAccessKey_non_existing_user, + "IAMCreateAccessKey_limit_exceeded": IAMCreateAccessKey_limit_exceeded, + "IAMCreateAccessKey_success": IAMCreateAccessKey_success, + "IAMUpdateAccessKey_missing_user_name": IAMUpdateAccessKey_missing_user_name, + "IAMUpdateAccessKey_infers_caller_user_name": IAMUpdateAccessKey_infers_caller_user_name, + "IAMUpdateAccessKey_inferred_user_name_scoped_to_caller": IAMUpdateAccessKey_inferred_user_name_scoped_to_caller, + "IAMUpdateAccessKey_invalid_user_name": IAMUpdateAccessKey_invalid_user_name, + "IAMUpdateAccessKey_long_user_name": IAMUpdateAccessKey_long_user_name, + "IAMUpdateAccessKey_missing_access_key_id": IAMUpdateAccessKey_missing_access_key_id, + "IAMUpdateAccessKey_access_key_id_too_short": IAMUpdateAccessKey_access_key_id_too_short, + "IAMUpdateAccessKey_access_key_id_too_long": IAMUpdateAccessKey_access_key_id_too_long, + "IAMUpdateAccessKey_invalid_access_key_id_chars": IAMUpdateAccessKey_invalid_access_key_id_chars, + "IAMUpdateAccessKey_missing_status": IAMUpdateAccessKey_missing_status, + "IAMUpdateAccessKey_invalid_status": IAMUpdateAccessKey_invalid_status, + "IAMUpdateAccessKey_non_existing_user": IAMUpdateAccessKey_non_existing_user, + "IAMUpdateAccessKey_non_existing_access_key": IAMUpdateAccessKey_non_existing_access_key, + "IAMUpdateAccessKey_success": IAMUpdateAccessKey_success, + "IAMDeleteAccessKey_missing_user_name": IAMDeleteAccessKey_missing_user_name, + "IAMDeleteAccessKey_infers_caller_user_name": IAMDeleteAccessKey_infers_caller_user_name, + "IAMDeleteAccessKey_inferred_user_name_scoped_to_caller": IAMDeleteAccessKey_inferred_user_name_scoped_to_caller, + "IAMDeleteAccessKey_invalid_user_name": IAMDeleteAccessKey_invalid_user_name, + "IAMDeleteAccessKey_long_user_name": IAMDeleteAccessKey_long_user_name, + "IAMDeleteAccessKey_missing_access_key_id": IAMDeleteAccessKey_missing_access_key_id, + "IAMDeleteAccessKey_access_key_id_too_short": IAMDeleteAccessKey_access_key_id_too_short, + "IAMDeleteAccessKey_access_key_id_too_long": IAMDeleteAccessKey_access_key_id_too_long, + "IAMDeleteAccessKey_invalid_access_key_id_chars": IAMDeleteAccessKey_invalid_access_key_id_chars, + "IAMDeleteAccessKey_non_existing_user": IAMDeleteAccessKey_non_existing_user, + "IAMDeleteAccessKey_non_existing_access_key": IAMDeleteAccessKey_non_existing_access_key, + "IAMDeleteAccessKey_success": IAMDeleteAccessKey_success, + "IAMGetAccessKeyLastUsed_missing_access_key_id": IAMGetAccessKeyLastUsed_missing_access_key_id, + "IAMGetAccessKeyLastUsed_access_key_id_too_short": IAMGetAccessKeyLastUsed_access_key_id_too_short, + "IAMGetAccessKeyLastUsed_access_key_id_too_long": IAMGetAccessKeyLastUsed_access_key_id_too_long, + "IAMGetAccessKeyLastUsed_invalid_access_key_id_chars": IAMGetAccessKeyLastUsed_invalid_access_key_id_chars, + "IAMGetAccessKeyLastUsed_non_existing_access_key": IAMGetAccessKeyLastUsed_non_existing_access_key, + "IAMGetAccessKeyLastUsed_success": IAMGetAccessKeyLastUsed_success, + "IAMListAccessKeys_missing_user_name": IAMListAccessKeys_missing_user_name, + "IAMListAccessKeys_infers_caller_user_name": IAMListAccessKeys_infers_caller_user_name, + "IAMListAccessKeys_invalid_user_name": IAMListAccessKeys_invalid_user_name, + "IAMListAccessKeys_long_user_name": IAMListAccessKeys_long_user_name, + "IAMListAccessKeys_invalid_max_items": IAMListAccessKeys_invalid_max_items, + "IAMListAccessKeys_invalid_max_items_format": IAMListAccessKeys_invalid_max_items_format, + "IAMListAccessKeys_non_existing_user": IAMListAccessKeys_non_existing_user, + "IAMListAccessKeys_empty_result": IAMListAccessKeys_empty_result, + "IAMListAccessKeys_success": IAMListAccessKeys_success, + "IAMListAccessKeys_pagination": IAMListAccessKeys_pagination, + "IAMPutUserPolicy_missing_user_name": IAMPutUserPolicy_missing_user_name, + "IAMPutUserPolicy_missing_policy_name": IAMPutUserPolicy_missing_policy_name, + "IAMPutUserPolicy_missing_policy_document": IAMPutUserPolicy_missing_policy_document, + "IAMPutUserPolicy_invalid_policy_name": IAMPutUserPolicy_invalid_policy_name, + "IAMPutUserPolicy_long_policy_name": IAMPutUserPolicy_long_policy_name, + "IAMPutUserPolicy_non_ascii_policy_document": IAMPutUserPolicy_non_ascii_policy_document, + "IAMPutUserPolicy_non_existing_user": IAMPutUserPolicy_non_existing_user, + "IAMPutUserPolicy_malformed_policy_document": IAMPutUserPolicy_malformed_policy_document, + "IAMPutUserPolicy_principal_not_allowed": IAMPutUserPolicy_principal_not_allowed, + "IAMPutUserPolicy_limit_exceeded": IAMPutUserPolicy_limit_exceeded, + "IAMPutUserPolicy_success": IAMPutUserPolicy_success, + "IAMPutUserPolicy_overwrite_updates_existing": IAMPutUserPolicy_overwrite_updates_existing, + "IAMGetUserPolicy_missing_user_name": IAMGetUserPolicy_missing_user_name, + "IAMGetUserPolicy_missing_policy_name": IAMGetUserPolicy_missing_policy_name, + "IAMGetUserPolicy_non_existing_user": IAMGetUserPolicy_non_existing_user, + "IAMGetUserPolicy_non_existing_policy": IAMGetUserPolicy_non_existing_policy, + "IAMGetUserPolicy_success": IAMGetUserPolicy_success, + "IAMDeleteUserPolicy_missing_user_name": IAMDeleteUserPolicy_missing_user_name, + "IAMDeleteUserPolicy_missing_policy_name": IAMDeleteUserPolicy_missing_policy_name, + "IAMDeleteUserPolicy_non_existing_user": IAMDeleteUserPolicy_non_existing_user, + "IAMDeleteUserPolicy_non_existing_policy": IAMDeleteUserPolicy_non_existing_policy, + "IAMDeleteUserPolicy_success": IAMDeleteUserPolicy_success, + "IAMDeleteUserPolicy_blocks_user_deletion": IAMDeleteUserPolicy_blocks_user_deletion, + "IAMListUserPolicies_missing_user_name": IAMListUserPolicies_missing_user_name, + "IAMListUserPolicies_non_existing_user": IAMListUserPolicies_non_existing_user, + "IAMListUserPolicies_invalid_max_items": IAMListUserPolicies_invalid_max_items, + "IAMListUserPolicies_empty_result": IAMListUserPolicies_empty_result, + "IAMListUserPolicies_success": IAMListUserPolicies_success, + "IAMListUserPolicies_pagination": IAMListUserPolicies_pagination, + "IAMCreateRole_missing_role_name": IAMCreateRole_missing_role_name, + "IAMCreateRole_invalid_role_name": IAMCreateRole_invalid_role_name, + "IAMCreateRole_long_role_name": IAMCreateRole_long_role_name, + "IAMCreateRole_already_exists": IAMCreateRole_already_exists, + "IAMCreateRole_already_exists_case_insensitive": IAMCreateRole_already_exists_case_insensitive, + "IAMCreateRole_invalid_path": IAMCreateRole_invalid_path, + "IAMCreateRole_long_path": IAMCreateRole_long_path, + "IAMCreateRole_missing_assume_role_policy_document": IAMCreateRole_missing_assume_role_policy_document, + "IAMCreateRole_non_ascii_assume_role_policy_document": IAMCreateRole_non_ascii_assume_role_policy_document, + "IAMCreateRole_trust_policy_size_limit_exceeded": IAMCreateRole_trust_policy_size_limit_exceeded, + "IAMCreateRole_description_invalid_charset": IAMCreateRole_description_invalid_charset, + "IAMCreateRole_description_too_long": IAMCreateRole_description_too_long, + "IAMCreateRole_max_session_duration_invalid_format": IAMCreateRole_max_session_duration_invalid_format, + "IAMCreateRole_max_session_duration_too_low": IAMCreateRole_max_session_duration_too_low, + "IAMCreateRole_max_session_duration_too_high": IAMCreateRole_max_session_duration_too_high, + "IAMCreateRole_duplicate_tag_keys": IAMCreateRole_duplicate_tag_keys, + "IAMCreateRole_success": IAMCreateRole_success, + "IAMCreateRole_defaults": IAMCreateRole_defaults, + "IAMCreateRole_trust_policy_document_grammar": IAMCreateRole_trust_policy_document_grammar, + "IAMGetRole_missing_role_name": IAMGetRole_missing_role_name, + "IAMGetRole_invalid_role_name": IAMGetRole_invalid_role_name, + "IAMGetRole_long_role_name": IAMGetRole_long_role_name, + "IAMGetRole_non_existing_role": IAMGetRole_non_existing_role, + "IAMGetRole_success": IAMGetRole_success, + "IAMGetRole_role_last_used_never_used": IAMGetRole_role_last_used_never_used, + "IAMListRoles_invalid_path_prefix": IAMListRoles_invalid_path_prefix, + "IAMListRoles_long_path_prefix": IAMListRoles_long_path_prefix, + "IAMListRoles_invalid_max_items": IAMListRoles_invalid_max_items, + "IAMListRoles_invalid_max_items_format": IAMListRoles_invalid_max_items_format, + "IAMListRoles_empty_result": IAMListRoles_empty_result, + "IAMListRoles_success": IAMListRoles_success, + "IAMListRoles_path_prefix": IAMListRoles_path_prefix, + "IAMListRoles_pagination": IAMListRoles_pagination, + "IAMListRoles_path_prefix_pagination": IAMListRoles_path_prefix_pagination, + "IAMDeleteRole_missing_role_name": IAMDeleteRole_missing_role_name, + "IAMDeleteRole_invalid_role_name": IAMDeleteRole_invalid_role_name, + "IAMDeleteRole_long_role_name": IAMDeleteRole_long_role_name, + "IAMDeleteRole_non_existing_role": IAMDeleteRole_non_existing_role, + "IAMDeleteRole_has_policies": IAMDeleteRole_has_policies, + "IAMDeleteRole_success": IAMDeleteRole_success, + "IAMUpdateAssumeRolePolicy_missing_role_name": IAMUpdateAssumeRolePolicy_missing_role_name, + "IAMUpdateAssumeRolePolicy_missing_policy_document": IAMUpdateAssumeRolePolicy_missing_policy_document, + "IAMUpdateAssumeRolePolicy_invalid_role_name": IAMUpdateAssumeRolePolicy_invalid_role_name, + "IAMUpdateAssumeRolePolicy_long_role_name": IAMUpdateAssumeRolePolicy_long_role_name, + "IAMUpdateAssumeRolePolicy_non_existing_role": IAMUpdateAssumeRolePolicy_non_existing_role, + "IAMUpdateAssumeRolePolicy_non_ascii_policy_document": IAMUpdateAssumeRolePolicy_non_ascii_policy_document, + "IAMUpdateAssumeRolePolicy_trust_policy_size_limit_exceeded": IAMUpdateAssumeRolePolicy_trust_policy_size_limit_exceeded, + "IAMUpdateAssumeRolePolicy_success": IAMUpdateAssumeRolePolicy_success, + "IAMUpdateAssumeRolePolicy_trust_policy_document_grammar": IAMUpdateAssumeRolePolicy_trust_policy_document_grammar, + "IAMTagRole_missing_role_name": IAMTagRole_missing_role_name, + "IAMTagRole_invalid_role_name": IAMTagRole_invalid_role_name, + "IAMTagRole_role_name_too_long": IAMTagRole_role_name_too_long, + "IAMTagRole_missing_tags": IAMTagRole_missing_tags, + "IAMTagRole_missing_tag_key": IAMTagRole_missing_tag_key, + "IAMTagRole_missing_tag_value": IAMTagRole_missing_tag_value, + "IAMTagRole_empty_tag_key": IAMTagRole_empty_tag_key, + "IAMTagRole_tag_key_too_long": IAMTagRole_tag_key_too_long, + "IAMTagRole_invalid_tag_key": IAMTagRole_invalid_tag_key, + "IAMTagRole_tag_value_too_long": IAMTagRole_tag_value_too_long, + "IAMTagRole_invalid_tag_value": IAMTagRole_invalid_tag_value, + "IAMTagRole_duplicate_tag_keys": IAMTagRole_duplicate_tag_keys, + "IAMTagRole_too_many_tags": IAMTagRole_too_many_tags, + "IAMTagRole_non_existing_role": IAMTagRole_non_existing_role, + "IAMTagRole_tag_limit_exceeded": IAMTagRole_tag_limit_exceeded, + "IAMTagRole_success": IAMTagRole_success, + "IAMTagRole_overwrites_existing_tag": IAMTagRole_overwrites_existing_tag, + "IAMTagRole_isolated_from_same_named_user": IAMTagRole_isolated_from_same_named_user, + "IAMUntagRole_missing_role_name": IAMUntagRole_missing_role_name, + "IAMUntagRole_invalid_role_name": IAMUntagRole_invalid_role_name, + "IAMUntagRole_role_name_too_long": IAMUntagRole_role_name_too_long, + "IAMUntagRole_missing_tag_keys": IAMUntagRole_missing_tag_keys, + "IAMUntagRole_invalid_tag_key": IAMUntagRole_invalid_tag_key, + "IAMUntagRole_too_many_tag_keys": IAMUntagRole_too_many_tag_keys, + "IAMUntagRole_non_existing_role": IAMUntagRole_non_existing_role, + "IAMUntagRole_success": IAMUntagRole_success, + "IAMUntagRole_removal_is_idempotent": IAMUntagRole_removal_is_idempotent, + "IAMUntagRole_case_insensitive_key": IAMUntagRole_case_insensitive_key, + "IAMUntagRole_removes_only_named_keys": IAMUntagRole_removes_only_named_keys, + "IAMListRoleTags_missing_role_name": IAMListRoleTags_missing_role_name, + "IAMListRoleTags_invalid_role_name": IAMListRoleTags_invalid_role_name, + "IAMListRoleTags_role_name_too_long": IAMListRoleTags_role_name_too_long, + "IAMListRoleTags_invalid_max_items": IAMListRoleTags_invalid_max_items, + "IAMListRoleTags_invalid_max_items_format": IAMListRoleTags_invalid_max_items_format, + "IAMListRoleTags_non_existing_role": IAMListRoleTags_non_existing_role, + "IAMListRoleTags_empty_result": IAMListRoleTags_empty_result, + "IAMListRoleTags_success": IAMListRoleTags_success, + "IAMListRoleTags_pagination": IAMListRoleTags_pagination, + "IAMPutRolePolicy_missing_role_name": IAMPutRolePolicy_missing_role_name, + "IAMPutRolePolicy_missing_policy_name": IAMPutRolePolicy_missing_policy_name, + "IAMPutRolePolicy_missing_policy_document": IAMPutRolePolicy_missing_policy_document, + "IAMPutRolePolicy_invalid_policy_name": IAMPutRolePolicy_invalid_policy_name, + "IAMPutRolePolicy_long_policy_name": IAMPutRolePolicy_long_policy_name, + "IAMPutRolePolicy_non_ascii_policy_document": IAMPutRolePolicy_non_ascii_policy_document, + "IAMPutRolePolicy_non_existing_role": IAMPutRolePolicy_non_existing_role, + "IAMPutRolePolicy_malformed_policy_document": IAMPutRolePolicy_malformed_policy_document, + "IAMPutRolePolicy_principal_not_allowed": IAMPutRolePolicy_principal_not_allowed, + "IAMPutRolePolicy_limit_exceeded": IAMPutRolePolicy_limit_exceeded, + "IAMPutRolePolicy_success": IAMPutRolePolicy_success, + "IAMPutRolePolicy_overwrite_updates_existing": IAMPutRolePolicy_overwrite_updates_existing, + "IAMGetRolePolicy_missing_role_name": IAMGetRolePolicy_missing_role_name, + "IAMGetRolePolicy_missing_policy_name": IAMGetRolePolicy_missing_policy_name, + "IAMGetRolePolicy_non_existing_role": IAMGetRolePolicy_non_existing_role, + "IAMGetRolePolicy_non_existing_policy": IAMGetRolePolicy_non_existing_policy, + "IAMGetRolePolicy_success": IAMGetRolePolicy_success, + "IAMDeleteRolePolicy_missing_role_name": IAMDeleteRolePolicy_missing_role_name, + "IAMDeleteRolePolicy_missing_policy_name": IAMDeleteRolePolicy_missing_policy_name, + "IAMDeleteRolePolicy_non_existing_role": IAMDeleteRolePolicy_non_existing_role, + "IAMDeleteRolePolicy_non_existing_policy": IAMDeleteRolePolicy_non_existing_policy, + "IAMDeleteRolePolicy_success": IAMDeleteRolePolicy_success, + "IAMDeleteRolePolicy_blocks_role_deletion": IAMDeleteRolePolicy_blocks_role_deletion, + "IAMListRolePolicies_missing_role_name": IAMListRolePolicies_missing_role_name, + "IAMListRolePolicies_non_existing_role": IAMListRolePolicies_non_existing_role, + "IAMListRolePolicies_invalid_max_items": IAMListRolePolicies_invalid_max_items, + "IAMListRolePolicies_empty_result": IAMListRolePolicies_empty_result, + "IAMListRolePolicies_success": IAMListRolePolicies_success, + "IAMListRolePolicies_pagination": IAMListRolePolicies_pagination, + "IAMCreateOpenIDConnectProvider_missing_url": IAMCreateOpenIDConnectProvider_missing_url, + "IAMCreateOpenIDConnectProvider_invalid_url": IAMCreateOpenIDConnectProvider_invalid_url, + "IAMCreateOpenIDConnectProvider_client_id_too_long": IAMCreateOpenIDConnectProvider_client_id_too_long, + "IAMCreateOpenIDConnectProvider_too_many_client_ids": IAMCreateOpenIDConnectProvider_too_many_client_ids, + "IAMCreateOpenIDConnectProvider_invalid_thumbprint": IAMCreateOpenIDConnectProvider_invalid_thumbprint, + "IAMCreateOpenIDConnectProvider_duplicate_tag_keys": IAMCreateOpenIDConnectProvider_duplicate_tag_keys, + "IAMCreateOpenIDConnectProvider_already_exists": IAMCreateOpenIDConnectProvider_already_exists, + "IAMCreateOpenIDConnectProvider_thumbprint_autofetch_communication_error": IAMCreateOpenIDConnectProvider_thumbprint_autofetch_communication_error, + "IAMCreateOpenIDConnectProvider_quota_exceeded": IAMCreateOpenIDConnectProvider_quota_exceeded, + "IAMCreateOpenIDConnectProvider_success": IAMCreateOpenIDConnectProvider_success, + "IAMCreateOpenIDConnectProvider_defaults": IAMCreateOpenIDConnectProvider_defaults, + "IAMCreateOpenIDConnectProvider_ip_literal_host": IAMCreateOpenIDConnectProvider_ip_literal_host, + "IAMCreateOpenIDConnectProvider_thumbprint_edge_cases": IAMCreateOpenIDConnectProvider_thumbprint_edge_cases, + "IAMCreateOpenIDConnectProvider_trailing_slash_distinct_identity": IAMCreateOpenIDConnectProvider_trailing_slash_distinct_identity, + "IAMGetOpenIDConnectProvider_missing_arn": IAMGetOpenIDConnectProvider_missing_arn, + "IAMGetOpenIDConnectProvider_invalid_arn": IAMGetOpenIDConnectProvider_invalid_arn, + "IAMGetOpenIDConnectProvider_non_existing": IAMGetOpenIDConnectProvider_non_existing, + "IAMGetOpenIDConnectProvider_success": IAMGetOpenIDConnectProvider_success, + "IAMListOpenIDConnectProviders_success": IAMListOpenIDConnectProviders_success, + "IAMDeleteOpenIDConnectProvider_missing_arn": IAMDeleteOpenIDConnectProvider_missing_arn, + "IAMDeleteOpenIDConnectProvider_non_existing": IAMDeleteOpenIDConnectProvider_non_existing, + "IAMDeleteOpenIDConnectProvider_success": IAMDeleteOpenIDConnectProvider_success, + "IAMDeleteOpenIDConnectProvider_not_idempotent": IAMDeleteOpenIDConnectProvider_not_idempotent, + "IAMAddClientIDToOpenIDConnectProvider_missing_arn": IAMAddClientIDToOpenIDConnectProvider_missing_arn, + "IAMAddClientIDToOpenIDConnectProvider_missing_client_id": IAMAddClientIDToOpenIDConnectProvider_missing_client_id, + "IAMAddClientIDToOpenIDConnectProvider_client_id_too_long": IAMAddClientIDToOpenIDConnectProvider_client_id_too_long, + "IAMAddClientIDToOpenIDConnectProvider_non_existing_provider": IAMAddClientIDToOpenIDConnectProvider_non_existing_provider, + "IAMAddClientIDToOpenIDConnectProvider_limit_exceeded": IAMAddClientIDToOpenIDConnectProvider_limit_exceeded, + "IAMAddClientIDToOpenIDConnectProvider_success": IAMAddClientIDToOpenIDConnectProvider_success, + "IAMAddClientIDToOpenIDConnectProvider_idempotent_duplicate": IAMAddClientIDToOpenIDConnectProvider_idempotent_duplicate, + "IAMRemoveClientIDFromOpenIDConnectProvider_missing_arn": IAMRemoveClientIDFromOpenIDConnectProvider_missing_arn, + "IAMRemoveClientIDFromOpenIDConnectProvider_missing_client_id": IAMRemoveClientIDFromOpenIDConnectProvider_missing_client_id, + "IAMRemoveClientIDFromOpenIDConnectProvider_client_id_too_long": IAMRemoveClientIDFromOpenIDConnectProvider_client_id_too_long, + "IAMRemoveClientIDFromOpenIDConnectProvider_non_existing_provider": IAMRemoveClientIDFromOpenIDConnectProvider_non_existing_provider, + "IAMRemoveClientIDFromOpenIDConnectProvider_success": IAMRemoveClientIDFromOpenIDConnectProvider_success, + "IAMRemoveClientIDFromOpenIDConnectProvider_idempotent_absent": IAMRemoveClientIDFromOpenIDConnectProvider_idempotent_absent, + "IAMUpdateOpenIDConnectProviderThumbprint_missing_arn": IAMUpdateOpenIDConnectProviderThumbprint_missing_arn, + "IAMUpdateOpenIDConnectProviderThumbprint_missing_thumbprint_list": IAMUpdateOpenIDConnectProviderThumbprint_missing_thumbprint_list, + "IAMUpdateOpenIDConnectProviderThumbprint_too_many_thumbprints": IAMUpdateOpenIDConnectProviderThumbprint_too_many_thumbprints, + "IAMUpdateOpenIDConnectProviderThumbprint_wrong_length_thumbprint": IAMUpdateOpenIDConnectProviderThumbprint_wrong_length_thumbprint, + "IAMUpdateOpenIDConnectProviderThumbprint_non_existing_provider": IAMUpdateOpenIDConnectProviderThumbprint_non_existing_provider, + "IAMUpdateOpenIDConnectProviderThumbprint_success": IAMUpdateOpenIDConnectProviderThumbprint_success, + "IAMUpdateOpenIDConnectProviderThumbprint_boundary_max_thumbprints": IAMUpdateOpenIDConnectProviderThumbprint_boundary_max_thumbprints, + "IAMTagOpenIDConnectProvider_missing_arn": IAMTagOpenIDConnectProvider_missing_arn, + "IAMTagOpenIDConnectProvider_invalid_arn": IAMTagOpenIDConnectProvider_invalid_arn, + "IAMTagOpenIDConnectProvider_missing_tags": IAMTagOpenIDConnectProvider_missing_tags, + "IAMTagOpenIDConnectProvider_missing_tag_key": IAMTagOpenIDConnectProvider_missing_tag_key, + "IAMTagOpenIDConnectProvider_missing_tag_value": IAMTagOpenIDConnectProvider_missing_tag_value, + "IAMTagOpenIDConnectProvider_invalid_tags": IAMTagOpenIDConnectProvider_invalid_tags, + "IAMTagOpenIDConnectProvider_duplicate_tag_keys": IAMTagOpenIDConnectProvider_duplicate_tag_keys, + "IAMTagOpenIDConnectProvider_too_many_tags": IAMTagOpenIDConnectProvider_too_many_tags, + "IAMTagOpenIDConnectProvider_non_existing_provider": IAMTagOpenIDConnectProvider_non_existing_provider, + "IAMTagOpenIDConnectProvider_invalid_tags_precede_lookup": IAMTagOpenIDConnectProvider_invalid_tags_precede_lookup, + "IAMTagOpenIDConnectProvider_tag_limit_exceeded": IAMTagOpenIDConnectProvider_tag_limit_exceeded, + "IAMTagOpenIDConnectProvider_success": IAMTagOpenIDConnectProvider_success, + "IAMTagOpenIDConnectProvider_overwrites_existing_tag": IAMTagOpenIDConnectProvider_overwrites_existing_tag, + "IAMTagOpenIDConnectProvider_isolated_per_provider": IAMTagOpenIDConnectProvider_isolated_per_provider, + "IAMUntagOpenIDConnectProvider_missing_arn": IAMUntagOpenIDConnectProvider_missing_arn, + "IAMUntagOpenIDConnectProvider_invalid_arn": IAMUntagOpenIDConnectProvider_invalid_arn, + "IAMUntagOpenIDConnectProvider_missing_tag_keys": IAMUntagOpenIDConnectProvider_missing_tag_keys, + "IAMUntagOpenIDConnectProvider_invalid_tag_key": IAMUntagOpenIDConnectProvider_invalid_tag_key, + "IAMUntagOpenIDConnectProvider_too_many_tag_keys": IAMUntagOpenIDConnectProvider_too_many_tag_keys, + "IAMUntagOpenIDConnectProvider_non_existing_provider": IAMUntagOpenIDConnectProvider_non_existing_provider, + "IAMUntagOpenIDConnectProvider_success": IAMUntagOpenIDConnectProvider_success, + "IAMUntagOpenIDConnectProvider_removal_is_idempotent": IAMUntagOpenIDConnectProvider_removal_is_idempotent, + "IAMUntagOpenIDConnectProvider_case_sensitive_key": IAMUntagOpenIDConnectProvider_case_sensitive_key, + "IAMUntagOpenIDConnectProvider_removes_only_named_keys": IAMUntagOpenIDConnectProvider_removes_only_named_keys, + "IAMListOpenIDConnectProviderTags_missing_arn": IAMListOpenIDConnectProviderTags_missing_arn, + "IAMListOpenIDConnectProviderTags_invalid_arn": IAMListOpenIDConnectProviderTags_invalid_arn, + "IAMListOpenIDConnectProviderTags_invalid_max_items": IAMListOpenIDConnectProviderTags_invalid_max_items, + "IAMListOpenIDConnectProviderTags_invalid_max_items_format": IAMListOpenIDConnectProviderTags_invalid_max_items_format, + "IAMListOpenIDConnectProviderTags_non_existing_provider": IAMListOpenIDConnectProviderTags_non_existing_provider, + "IAMListOpenIDConnectProviderTags_empty_result": IAMListOpenIDConnectProviderTags_empty_result, + "IAMListOpenIDConnectProviderTags_success": IAMListOpenIDConnectProviderTags_success, + "IAMListOpenIDConnectProviderTags_pagination": IAMListOpenIDConnectProviderTags_pagination, + "IAMAssumeRoleWithWebIdentity_missing_role_arn": IAMAssumeRoleWithWebIdentity_missing_role_arn, + "IAMAssumeRoleWithWebIdentity_role_arn_too_short": IAMAssumeRoleWithWebIdentity_role_arn_too_short, + "IAMAssumeRoleWithWebIdentity_malformed_duration": IAMAssumeRoleWithWebIdentity_malformed_duration, + "IAMAssumeRoleWithWebIdentity_wrong_version_is_invalid_action": IAMAssumeRoleWithWebIdentity_wrong_version_is_invalid_action, + "IAMAssumeRoleWithWebIdentity_malformed_token": IAMAssumeRoleWithWebIdentity_malformed_token, + "IAMAssumeRoleWithWebIdentity_duration_exceeds_role_max": IAMAssumeRoleWithWebIdentity_duration_exceeds_role_max, + "IAMAssumeRoleWithWebIdentity_nonexistent_role": IAMAssumeRoleWithWebIdentity_nonexistent_role, + "IAMAssumeRoleWithWebIdentity_no_matching_principal": IAMAssumeRoleWithWebIdentity_no_matching_principal, + "IAMAssumeRoleWithWebIdentity_no_issuer_match": IAMAssumeRoleWithWebIdentity_no_issuer_match, + "IAMAssumeRoleWithWebIdentity_condition_failed": IAMAssumeRoleWithWebIdentity_condition_failed, + "IAMAssumeRoleWithWebIdentity_explicit_deny": IAMAssumeRoleWithWebIdentity_explicit_deny, + "IAMAssumeRoleWithWebIdentity_audience_not_in_client_id_list": IAMAssumeRoleWithWebIdentity_audience_not_in_client_id_list, + "IAMAssumeRoleWithWebIdentity_empty_client_id_list": IAMAssumeRoleWithWebIdentity_empty_client_id_list, + "IAMAssumeRoleWithWebIdentity_idp_communication_error": IAMAssumeRoleWithWebIdentity_idp_communication_error, + "IAMAssumeRoleWithWebIdentity_role_arn_path_mismatch": IAMAssumeRoleWithWebIdentity_role_arn_path_mismatch, + "IAMAssumeRoleWithWebIdentity_policy_arns_rejected": IAMAssumeRoleWithWebIdentity_policy_arns_rejected, + "IAMAssumeRoleWithWebIdentity_provider_id_rejected": IAMAssumeRoleWithWebIdentity_provider_id_rejected, + "IAMAssumeRoleWithWebIdentity_session_policy_too_large": IAMAssumeRoleWithWebIdentity_session_policy_too_large, + "IAMAssumeRoleWithWebIdentity_session_policy_invalid": IAMAssumeRoleWithWebIdentity_session_policy_invalid, + "IAMAssumeRoleWithWebIdentity_oaud_condition_matches": IAMAssumeRoleWithWebIdentity_oaud_condition_matches, + "IAMAssumeRoleWithWebIdentity_oaud_condition_mismatch": IAMAssumeRoleWithWebIdentity_oaud_condition_mismatch, + "IAMAssumeRoleWithWebIdentity_issuer_trailing_slash_mismatch": IAMAssumeRoleWithWebIdentity_issuer_trailing_slash_mismatch, + "IAMAssumeRoleWithWebIdentity_issuer_scheme_mismatch": IAMAssumeRoleWithWebIdentity_issuer_scheme_mismatch, + "IAMGetCallerIdentity_root_success": IAMGetCallerIdentity_root_success, + "IAMGetCallerIdentity_user_success": IAMGetCallerIdentity_user_success, + "IAMGetCallerIdentity_unknown_access_key": IAMGetCallerIdentity_unknown_access_key, + "IAMGetCallerIdentity_no_auth": IAMGetCallerIdentity_no_auth, + "IAMGetCallerIdentity_wrong_version_is_invalid_action": IAMGetCallerIdentity_wrong_version_is_invalid_action, + "IAMGetCallerIdentity_incorrect_service_scope": IAMGetCallerIdentity_incorrect_service_scope, + "IAMAccessControl_ImplicitDenyNoMatchingPolicy": IAMAccessControl_ImplicitDenyNoMatchingPolicy, + "IAMAccessControl_AllowGrantsMatchingRequest": IAMAccessControl_AllowGrantsMatchingRequest, + "IAMAccessControl_NonMatchingStatementDoesNotGrant": IAMAccessControl_NonMatchingStatementDoesNotGrant, + "IAMAccessControl_ExplicitDenyOverridesAllow": IAMAccessControl_ExplicitDenyOverridesAllow, + "IAMAccessControl_MultipleStatementsEvaluatedIndependently": IAMAccessControl_MultipleStatementsEvaluatedIndependently, + "IAMAccessControl_MultipleInlinePoliciesCombinedAllow": IAMAccessControl_MultipleInlinePoliciesCombinedAllow, + "IAMAccessControl_MultipleInlinePoliciesExplicitDenyWins": IAMAccessControl_MultipleInlinePoliciesExplicitDenyWins, + "IAMAccessControl_EffectNonMatchingAllowStillImplicitlyDenies": IAMAccessControl_EffectNonMatchingAllowStillImplicitlyDenies, + "IAMAccessControl_EffectNonMatchingDenyDoesNotBlockUnrelatedAllow": IAMAccessControl_EffectNonMatchingDenyDoesNotBlockUnrelatedAllow, + "IAMAccessControl_ActionMatchingVariants": IAMAccessControl_ActionMatchingVariants, + "IAMAccessControl_ActionAllowOneDenyAnotherByOmission": IAMAccessControl_ActionAllowOneDenyAnotherByOmission, + "IAMAccessControl_ActionExplicitDenySubsetOfWildcardAllow": IAMAccessControl_ActionExplicitDenySubsetOfWildcardAllow, + "IAMAccessControl_NotActionAllowGrantsEverythingExceptExcluded": IAMAccessControl_NotActionAllowGrantsEverythingExceptExcluded, + "IAMAccessControl_NotActionDenyBlocksEverythingExceptExcluded": IAMAccessControl_NotActionDenyBlocksEverythingExceptExcluded, + "IAMAccessControl_ResourceMatchingVariants": IAMAccessControl_ResourceMatchingVariants, + "IAMAccessControl_ResourceOneAllowedOneDeniedSameAction": IAMAccessControl_ResourceOneAllowedOneDeniedSameAction, + "IAMAccessControl_ResourceWildcardRequiredForListAction": IAMAccessControl_ResourceWildcardRequiredForListAction, + "IAMAccessControl_ResourceExplicitDenyOverridesBroaderAllow": IAMAccessControl_ResourceExplicitDenyOverridesBroaderAllow, + "IAMAccessControl_NotResourceExcludesTarget": IAMAccessControl_NotResourceExcludesTarget, + "IAMAccessControl_NotResourceMultipleExcludedResources": IAMAccessControl_NotResourceMultipleExcludedResources, + "IAMAccessControl_NotResourceWildcardExclusion": IAMAccessControl_NotResourceWildcardExclusion, + "IAMAccessControl_ConditionStringOperators": IAMAccessControl_ConditionStringOperators, + "IAMAccessControl_ConditionStringMultipleExpectedValuesOR": IAMAccessControl_ConditionStringMultipleExpectedValuesOR, + "IAMAccessControl_ConditionArnOperators": IAMAccessControl_ConditionArnOperators, + "IAMAccessControl_ConditionIpAddressRealSourceIp": IAMAccessControl_ConditionIpAddressRealSourceIp, + "IAMAccessControl_ConditionIpAddressExplicitDenyOverridesBroaderAllow": IAMAccessControl_ConditionIpAddressExplicitDenyOverridesBroaderAllow, + "IAMAccessControl_ConditionMultipleContextKeysANDed": IAMAccessControl_ConditionMultipleContextKeysANDed, + "IAMAccessControl_ConditionAllowMatchesDenyConditionDoesNotApply": IAMAccessControl_ConditionAllowMatchesDenyConditionDoesNotApply, + "IAMAccessControl_ConditionAllowAndDenyBothMatchDenyWins": IAMAccessControl_ConditionAllowAndDenyBothMatchDenyWins, + "IAMAccessControl_ConditionOneFailedConditionVoidsStatement": IAMAccessControl_ConditionOneFailedConditionVoidsStatement, + "IAMAccessControl_ConditionNullPrincipalTag": IAMAccessControl_ConditionNullPrincipalTag, + "IAMAccessControl_ConditionIfExistsPrincipalTag": IAMAccessControl_ConditionIfExistsPrincipalTag, + "IAMAccessControl_ConditionResourceTagOnTarget": IAMAccessControl_ConditionResourceTagOnTarget, + "IAMAccessControl_ConditionRequestTagOnCreateUser": IAMAccessControl_ConditionRequestTagOnCreateUser, + "IAMAccessControl_ConditionCurrentTimeBroadWindow": IAMAccessControl_ConditionCurrentTimeBroadWindow, + "IAMAccessControl_ConditionNumericOperators": IAMAccessControl_ConditionNumericOperators, + "IAMAccessControl_ConditionDateOperators": IAMAccessControl_ConditionDateOperators, + "IAMAccessControl_ConditionBoolOperator": IAMAccessControl_ConditionBoolOperator, + "IAMAccessControl_ConditionNullOperatorClaim": IAMAccessControl_ConditionNullOperatorClaim, + "IAMAccessControl_ConditionBinaryEqualsOperator": IAMAccessControl_ConditionBinaryEqualsOperator, + "IAMAccessControl_ConditionForAnyValueOperator": IAMAccessControl_ConditionForAnyValueOperator, + "IAMAccessControl_ConditionForAllValuesOperator": IAMAccessControl_ConditionForAllValuesOperator, + "IAMAccessControl_ConditionIfExistsTrustClaim": IAMAccessControl_ConditionIfExistsTrustClaim, + "IAMAccessControl_ConditionMultipleOperatorBlocksANDedTrust": IAMAccessControl_ConditionMultipleOperatorBlocksANDedTrust, + "IAMAccessControl_TrustPolicyFederatedExactMatchAllowed": IAMAccessControl_TrustPolicyFederatedExactMatchAllowed, + "IAMAccessControl_TrustPolicyFederatedWrongProviderDenied": IAMAccessControl_TrustPolicyFederatedWrongProviderDenied, + "IAMAccessControl_TrustPolicyFederatedArrayMatchesAny": IAMAccessControl_TrustPolicyFederatedArrayMatchesAny, + "IAMAccessControl_TrustPolicyNonFederatedPrincipalsIgnored": IAMAccessControl_TrustPolicyNonFederatedPrincipalsIgnored, + "IAMAccessControl_TrustPolicyStringEqualsSubjectExactAllowed": IAMAccessControl_TrustPolicyStringEqualsSubjectExactAllowed, + "IAMAccessControl_TrustPolicyStringEqualsSubjectMismatchDenied": IAMAccessControl_TrustPolicyStringEqualsSubjectMismatchDenied, + "IAMAccessControl_TrustPolicyStringLikeBranchWildcardAllowed": IAMAccessControl_TrustPolicyStringLikeBranchWildcardAllowed, + "IAMAccessControl_TrustPolicyStringLikeTagSubjectDenied": IAMAccessControl_TrustPolicyStringLikeTagSubjectDenied, + "IAMAccessControl_TrustPolicyAudienceCorrectAllowed": IAMAccessControl_TrustPolicyAudienceCorrectAllowed, + "IAMAccessControl_TrustPolicyAudienceIncorrectDenied": IAMAccessControl_TrustPolicyAudienceIncorrectDenied, + "IAMAccessControl_TrustPolicyMultipleAudiencesArrayAllowed": IAMAccessControl_TrustPolicyMultipleAudiencesArrayAllowed, + "IAMAccessControl_TrustPolicyAudienceAndSubjectBothMustMatch": IAMAccessControl_TrustPolicyAudienceAndSubjectBothMustMatch, + "IAMAccessControl_TrustPolicyExplicitDenyStatement": IAMAccessControl_TrustPolicyExplicitDenyStatement, + "IAMAccessControl_TrustPolicyMultipleStatementsSecondGrants": IAMAccessControl_TrustPolicyMultipleStatementsSecondGrants, + "IAMAccessControl_TrustPolicyMissingRequiredClaimDenied": IAMAccessControl_TrustPolicyMissingRequiredClaimDenied, + "IAMAccessControl_UserInlinePolicyWorkflow": IAMAccessControl_UserInlinePolicyWorkflow, + "IAMAccessControl_UserPathScopedResourceGrantsOnlyMatchingPath": IAMAccessControl_UserPathScopedResourceGrantsOnlyMatchingPath, + "IAMAccessControl_RolePermissionPolicyDoesNotAffectAssumptionDecision": IAMAccessControl_RolePermissionPolicyDoesNotAffectAssumptionDecision, + "IAMAccessControl_RoleTrustDenialIndependentOfPermissionPolicy": IAMAccessControl_RoleTrustDenialIndependentOfPermissionPolicy, + "IAMAccessControl_CrossIdentity_UnrelatedRoleCannotBeAssumedViaWrongIssuer": IAMAccessControl_CrossIdentity_UnrelatedRoleCannotBeAssumedViaWrongIssuer, + "IAMAccessControl_CrossIdentity_AssumeRoleWithWebIdentityHasNoCallerIdentityCheck": IAMAccessControl_CrossIdentity_AssumeRoleWithWebIdentityHasNoCallerIdentityCheck, + "PresignedAuth_security_token_with_permanent_credentials": PresignedAuth_security_token_with_permanent_credentials, + "PresignedAuth_unsupported_algorithm": PresignedAuth_unsupported_algorithm, + "PresignedAuth_ECDSA_not_supported": PresignedAuth_ECDSA_not_supported, + "PresignedAuth_missing_signature_query_param": PresignedAuth_missing_signature_query_param, + "PresignedAuth_missing_credentials_query_param": PresignedAuth_missing_credentials_query_param, + "PresignedAuth_malformed_creds_invalid_parts": PresignedAuth_malformed_creds_invalid_parts, + "PresignedAuth_creds_invalid_terminal": PresignedAuth_creds_invalid_terminal, + "PresignedAuth_creds_incorrect_service": PresignedAuth_creds_incorrect_service, + "PresignedAuth_creds_incorrect_region": PresignedAuth_creds_incorrect_region, + "PresignedAuth_creds_invalid_date": PresignedAuth_creds_invalid_date, + "PresignedAuth_missing_date_query": PresignedAuth_missing_date_query, + "PresignedAuth_dates_mismatch": PresignedAuth_dates_mismatch, + "PresignedAuth_non_existing_access_key_id": PresignedAuth_non_existing_access_key_id, + "PresignedAuth_missing_signed_headers_query_param": PresignedAuth_missing_signed_headers_query_param, + "PresignedAuth_unsigned_required_header": PresignedAuth_unsigned_required_header, + "PresignedAuth_unsigned_non_required_header": PresignedAuth_unsigned_non_required_header, + "PresignedAuth_missing_expiration_query_param": PresignedAuth_missing_expiration_query_param, + "PresignedAuth_invalid_expiration_query_param": PresignedAuth_invalid_expiration_query_param, + "PresignedAuth_negative_expiration_query_param": PresignedAuth_negative_expiration_query_param, + "PresignedAuth_exceeding_expiration_query_param": PresignedAuth_exceeding_expiration_query_param, + "PresignedAuth_expired_request": PresignedAuth_expired_request, + "PresignedAuth_incorrect_secret_key": PresignedAuth_incorrect_secret_key, + "PresignedAuth_sigv2_not_supported": PresignedAuth_sigv2_not_supported, + "PresignedAuth_PutObject_success": PresignedAuth_PutObject_success, + "PresignedAuth_PutObject_strips_aws_chunked_content_encoding": PresignedAuth_PutObject_strips_aws_chunked_content_encoding, + "PresignedAuth_CopyObject_strips_aws_chunked_content_encoding": PresignedAuth_CopyObject_strips_aws_chunked_content_encoding, + "PresignedAuth_CreateMultipartUpload_strips_aws_chunked_content_encoding": PresignedAuth_CreateMultipartUpload_strips_aws_chunked_content_encoding, + "PutObject_missing_object_lock_retention_config": PutObject_missing_object_lock_retention_config, + "PutObject_name_too_long": PutObject_name_too_long, + "PutObject_with_object_lock": PutObject_with_object_lock, + "PutObject_missing_bucket_lock": PutObject_missing_bucket_lock, + "PutObject_invalid_legal_hold": PutObject_invalid_legal_hold, + "PutObject_invalid_object_lock_mode": PutObject_invalid_object_lock_mode, + "PutObject_object_lock_checksum_required": PutObject_object_lock_checksum_required, + "PutObject_default_retention_checksum_required": PutObject_default_retention_checksum_required, + "PutObject_past_retain_until_date": PutObject_past_retain_until_date, + "PutObject_invalid_retain_until_date": PutObject_invalid_retain_until_date, + "PutObject_conditional_writes": PutObject_conditional_writes, + "PutObject_should_combine_metadata": PutObject_should_combine_metadata, + "PutObject_md5": PutObject_md5, + "PutObject_long_metadata": PutObject_long_metadata, + "PutObject_with_metadata": PutObject_with_metadata, + "PutObject_invalid_website_redirect_location": PutObject_invalid_website_redirect_location, + "PutObject_invalid_credentials": PutObject_invalid_credentials, + "PutObject_checksum_algorithm_and_header_mismatch": PutObject_checksum_algorithm_and_header_mismatch, + "PutObject_multiple_checksum_headers": PutObject_multiple_checksum_headers, + "PutObject_invalid_checksum_header": PutObject_invalid_checksum_header, + "PutObject_incorrect_checksums": PutObject_incorrect_checksums, + "PutObject_default_checksum": PutObject_default_checksum, + "PutObject_data_integrity_etag": PutObject_data_integrity_etag, + "PutObject_dir_object_data_integrity_etag": PutObject_dir_object_data_integrity_etag, + "PutObject_dir_object_default_checksum": PutObject_dir_object_default_checksum, + "PutObject_checksums_success": PutObject_checksums_success, + "PutObject_dir_object_checksums_success": PutObject_dir_object_checksums_success, + "PresignedAuth_Put_GetObject_with_data": PresignedAuth_Put_GetObject_with_data, + "PresignedAuth_Put_GetObject_with_UTF8_chars": PresignedAuth_Put_GetObject_with_UTF8_chars, + "PresignedAuth_UploadPart": PresignedAuth_UploadPart, + "CreateBucket_invalid_bucket_name": CreateBucket_invalid_bucket_name, + "CreateBucket_existing_bucket": CreateBucket_existing_bucket, + "CreateBucket_owned_by_you": CreateBucket_owned_by_you, + "CreateBucket_invalid_ownership": CreateBucket_invalid_ownership, + "CreateBucket_ownership_with_acl": CreateBucket_ownership_with_acl, + "CreateBucket_as_user": CreateBucket_as_user, + "CreateBucket_success": CreateBucket_success, + "CreateBucket_default_acl": CreateBucket_default_acl, + "CreateBucket_non_default_acl": CreateBucket_non_default_acl, + "CreateBucket_private_canned_acl": CreateBucket_private_canned_acl, + "CreateBucket_private_canned_acl_bucket_owner_enforced_ownership": CreateBucket_private_canned_acl_bucket_owner_enforced_ownership, + "CreateBucket_default_object_lock": CreateBucket_default_object_lock, + "CreateBucket_invalid_location_constraint": CreateBucket_invalid_location_constraint, + "CreateBucket_long_tags": CreateBucket_long_tags, + "CreateBucket_invalid_tags": CreateBucket_invalid_tags, + "CreateBucket_duplicate_keys": CreateBucket_duplicate_keys, + "CreateBucket_tag_count_limit": CreateBucket_tag_count_limit, + "CreateBucket_invalid_canned_acl": CreateBucket_invalid_canned_acl, + "HeadBucket_non_existing_bucket": HeadBucket_non_existing_bucket, + "HeadBucket_success": HeadBucket_success, + "ListBuckets_as_user": ListBuckets_as_user, + "ListBuckets_as_admin": ListBuckets_as_admin, + "ListBuckets_with_prefix": ListBuckets_with_prefix, + "ListBuckets_invalid_max_buckets": ListBuckets_invalid_max_buckets, + "ListBuckets_truncated": ListBuckets_truncated, + "ListBuckets_success": ListBuckets_success, + "ListBuckets_empty_success": ListBuckets_empty_success, + "DeleteBucket_non_existing_bucket": DeleteBucket_non_existing_bucket, + "DeleteBucket_non_empty_bucket": DeleteBucket_non_empty_bucket, + "DeleteBucket_incorrect_expected_bucket_owner": DeleteBucket_incorrect_expected_bucket_owner, + "DeleteBucket_success_status_code": DeleteBucket_success_status_code, + "PutBucketOwnershipControls_non_existing_bucket": PutBucketOwnershipControls_non_existing_bucket, + "PutBucketOwnershipControls_multiple_rules": PutBucketOwnershipControls_multiple_rules, + "PutBucketOwnershipControls_invalid_ownership": PutBucketOwnershipControls_invalid_ownership, + "PutBucketOwnershipControls_empty_rules": PutBucketOwnershipControls_empty_rules, + "PutBucketOwnershipControls_success": PutBucketOwnershipControls_success, + "GetBucketOwnershipControls_non_existing_bucket": GetBucketOwnershipControls_non_existing_bucket, + "GetBucketOwnershipControls_default_ownership": GetBucketOwnershipControls_default_ownership, + "GetBucketOwnershipControls_success": GetBucketOwnershipControls_success, + "DeleteBucketOwnershipControls_non_existing_bucket": DeleteBucketOwnershipControls_non_existing_bucket, + "DeleteBucketOwnershipControls_success": DeleteBucketOwnershipControls_success, + "PutBucketTagging_non_existing_bucket": PutBucketTagging_non_existing_bucket, + "PutBucketTagging_long_tags": PutBucketTagging_long_tags, + "PutBucketTagging_invalid_tags": PutBucketTagging_invalid_tags, + "PutBucketTagging_duplicate_keys": PutBucketTagging_duplicate_keys, + "PutBucketTagging_tag_count_limit": PutBucketTagging_tag_count_limit, + "PutBucketTagging_success": PutBucketTagging_success, + "PutBucketTagging_success_status": PutBucketTagging_success_status, + "GetBucketTagging_non_existing_bucket": GetBucketTagging_non_existing_bucket, + "GetBucketTagging_unset_tags": GetBucketTagging_unset_tags, + "GetBucketTagging_success": GetBucketTagging_success, + "DeleteBucketTagging_non_existing_object": DeleteBucketTagging_non_existing_object, + "DeleteBucketTagging_success_status": DeleteBucketTagging_success_status, + "DeleteBucketTagging_success": DeleteBucketTagging_success, + "GetBucketLocation_success": GetBucketLocation_success, + "GetBucketLocation_non_exist": GetBucketLocation_non_exist, + "GetBucketLocation_no_access": GetBucketLocation_no_access, + "PutObject_non_existing_bucket": PutObject_non_existing_bucket, + "PutObject_special_chars": PutObject_special_chars, + "PutObject_aborted_plain_body": PutObject_aborted_plain_body, + "PutObject_plain_body_with_decoded_length": PutObject_plain_body_with_decoded_length, + "UploadPart_plain_body_with_decoded_length": UploadPart_plain_body_with_decoded_length, + "PutObject_plain_stores_aws_chunked_content_encoding": PutObject_plain_stores_aws_chunked_content_encoding, + "PutObject_unsigned_payload_with_aws_chunked_content_encoding": PutObject_unsigned_payload_with_aws_chunked_content_encoding, + "PutObject_tagging": PutObject_tagging, + "PutObject_success": PutObject_success, + "PutObject_default_content_type": PutObject_default_content_type, + "PutObject_overwrite_resets_attributes": PutObject_overwrite_resets_attributes, + "PutObject_overwrite_multipart_object": PutObject_overwrite_multipart_object, + "PutObject_dir_object_overwrite_resets_attributes": PutObject_dir_object_overwrite_resets_attributes, + "PutObject_invalid_object_names": PutObject_invalid_object_names, + "PutObject_object_acl_not_supported": PutObject_object_acl_not_supported, + "PutObject_false_negative_object_names": PutObject_false_negative_object_names, + "PutObject_racey_success": PutObject_racey_success, + "HeadObject_non_existing_object": HeadObject_non_existing_object, + "HeadObject_invalid_part_number": HeadObject_invalid_part_number, + "HeadObject_directory_object_noslash": HeadObject_directory_object_noslash, + "HeadObject_non_existing_dir_object": HeadObject_non_existing_dir_object, + "HeadObject_incidental_dir_object": HeadObject_incidental_dir_object, + "HeadObject_name_too_long": HeadObject_name_too_long, + "HeadObject_invalid_parent_dir": HeadObject_invalid_parent_dir, + "HeadObject_with_range": HeadObject_with_range, + "HeadObject_by_range_resp_status": HeadObject_by_range_resp_status, + "HeadObject_zero_len_with_range": HeadObject_zero_len_with_range, + "HeadObject_dir_with_range": HeadObject_dir_with_range, + "HeadObject_conditional_reads": HeadObject_conditional_reads, + "HeadObject_not_enabled_checksum_mode": HeadObject_not_enabled_checksum_mode, + "HeadObject_checksums": HeadObject_checksums, + "HeadObject_ranged_with_checksum_mode": HeadObject_ranged_with_checksum_mode, + "HeadObject_success": HeadObject_success, + "HeadObject_overrides_success": HeadObject_overrides_success, + "HeadObject_overrides_presign_success": HeadObject_overrides_presign_success, + "HeadObject_overrides_fail_public": HeadObject_overrides_fail_public, + "HeadObject_range_and_part_number": HeadObject_range_and_part_number, + "HeadObject_mp_part_number_exceeds_parts_count": HeadObject_mp_part_number_exceeds_parts_count, + "HeadObject_mp_part_number_success": HeadObject_mp_part_number_success, + "HeadObject_mp_part_number_resp_status": HeadObject_mp_part_number_resp_status, + "HeadObject_empty_version_id": HeadObject_empty_version_id, + "HeadObject_non_mp_part_number_1_success": HeadObject_non_mp_part_number_1_success, + "HeadObject_empty_object_part_number_1": HeadObject_empty_object_part_number_1, + "GetObjectAttributes_non_existing_bucket": GetObjectAttributes_non_existing_bucket, + "GetObjectAttributes_non_existing_object": GetObjectAttributes_non_existing_object, + "GetObjectAttributes_invalid_attrs": GetObjectAttributes_invalid_attrs, + "GetObjectAttributes_invalid_parent": GetObjectAttributes_invalid_parent, + "GetObjectAttributes_invalid_single_attribute": GetObjectAttributes_invalid_single_attribute, + "GetObjectAttributes_empty_attrs": GetObjectAttributes_empty_attrs, + "GetObjectAttributes_existing_object": GetObjectAttributes_existing_object, + "GetObjectAttributes_checksums": GetObjectAttributes_checksums, + "GetObjectAttributes_empty_version_id": GetObjectAttributes_empty_version_id, + "GetObject_non_existing_key": GetObject_non_existing_key, + "GetObject_directory_object_noslash": GetObject_directory_object_noslash, + "GetObject_with_range": GetObject_with_range, + "GetObject_zero_len_with_range": GetObject_zero_len_with_range, + "GetObject_dir_with_range": GetObject_dir_with_range, + "GetObject_invalid_parent": GetObject_invalid_parent, + "GetObject_large_object": GetObject_large_object, + "GetObject_conditional_reads": GetObject_conditional_reads, + "GetObject_not_enabled_checksum_mode": GetObject_not_enabled_checksum_mode, + "GetObject_checksums": GetObject_checksums, + "GetObject_dir_object_checksum": GetObject_dir_object_checksum, + "GetObject_ranged_with_checksum_mode": GetObject_ranged_with_checksum_mode, + "GetObject_success": GetObject_success, + "GetObject_directory_success": GetObject_directory_success, + "GetObject_by_range_resp_status": GetObject_by_range_resp_status, + "GetObject_non_existing_dir_object": GetObject_non_existing_dir_object, + "GetObject_incidental_dir_object": GetObject_incidental_dir_object, + "GetObject_overrides_success": GetObject_overrides_success, + "GetObject_overrides_presign_success": GetObject_overrides_presign_success, + "GetObject_overrides_fail_public": GetObject_overrides_fail_public, + "GetObject_invalid_part_number": GetObject_invalid_part_number, + "GetObject_range_and_part_number": GetObject_range_and_part_number, + "GetObject_mp_part_number_exceeds_parts_count": GetObject_mp_part_number_exceeds_parts_count, + "GetObject_mp_part_number_success": GetObject_mp_part_number_success, + "GetObject_mp_part_number_resp_status": GetObject_mp_part_number_resp_status, + "GetObject_non_mp_part_number_1_success": GetObject_non_mp_part_number_1_success, + "GetObject_empty_object_part_number_1": GetObject_empty_object_part_number_1, + "GetObject_empty_version_id": GetObject_empty_version_id, + "ListObjects_non_existing_bucket": ListObjects_non_existing_bucket, + "ListObjects_with_prefix": ListObjects_with_prefix, + "ListObjects_truncated": ListObjects_truncated, + "ListObjects_paginated": ListObjects_paginated, + "ListObjects_invalid_max_keys": ListObjects_invalid_max_keys, + "ListObjects_max_keys_0": ListObjects_max_keys_0, + "ListObjects_delimiter": ListObjects_delimiter, + "ListObjects_max_keys_none": ListObjects_max_keys_none, + "ListObjects_marker_not_from_obj_list": ListObjects_marker_not_from_obj_list, + "ListObjects_list_all_objs": ListObjects_list_all_objs, + "ListObjects_nested_dir_file_objs": ListObjects_nested_dir_file_objs, + "ListObjects_check_owner": ListObjects_check_owner, + "ListObjects_non_truncated_common_prefixes": ListObjects_non_truncated_common_prefixes, + "ListObjects_should_not_list_pending_mps": ListObjects_should_not_list_pending_mps, + "ListObjects_mp_masking_with_marker": ListObjects_mp_masking_with_marker, + "ListObjects_mp_masking_truncation": ListObjects_mp_masking_truncation, + "ListObjects_mp_masking_delimiter": ListObjects_mp_masking_delimiter, + "ListObjectsV2_non_truncated_common_prefixes": ListObjectsV2_non_truncated_common_prefixes, + "ListObjectsV2_invalid_parent_prefix": ListObjectsV2_invalid_parent_prefix, + "ListObjectsV2_should_not_list_pending_mps": ListObjectsV2_should_not_list_pending_mps, + "ListObjectsV2_mp_masking_start_after": ListObjectsV2_mp_masking_start_after, + "ListObjectsV2_mp_masking_truncation": ListObjectsV2_mp_masking_truncation, + "ListObjectsV2_mp_masking_delimiter": ListObjectsV2_mp_masking_delimiter, + "ListObjects_with_checksum": ListObjects_with_checksum, + "ListObjectsV2_start_after": ListObjectsV2_start_after, + "ListObjectsV2_both_start_after_and_continuation_token": ListObjectsV2_both_start_after_and_continuation_token, + "ListObjectsV2_start_after_not_in_list": ListObjectsV2_start_after_not_in_list, + "ListObjectsV2_start_after_empty_result": ListObjectsV2_start_after_empty_result, + "ListObjectsV2_both_delimiter_and_prefix": ListObjectsV2_both_delimiter_and_prefix, + "ListObjectsV2_single_dir_object_with_delim_and_prefix": ListObjectsV2_single_dir_object_with_delim_and_prefix, + "ListObjectsV2_truncated_common_prefixes": ListObjectsV2_truncated_common_prefixes, + "ListObjectsV2_all_objs_max_keys": ListObjectsV2_all_objs_max_keys, + "ListObjectsV2_list_all_objs": ListObjectsV2_list_all_objs, + "ListObjectsV2_full_pagination": ListObjectsV2_full_pagination, + "ListObjectsV2_pagination_with_delimiter": ListObjectsV2_pagination_with_delimiter, + "ListObjectsV2_with_owner": ListObjectsV2_with_owner, + "ListObjectsV2_with_checksum": ListObjectsV2_with_checksum, + "ListObjectVersions_VD_success": ListObjectVersions_VD_success, + "DeleteObject_non_existing_object": DeleteObject_non_existing_object, + "DeleteObject_directory_object_noslash": DeleteObject_directory_object_noslash, + "DeleteObject_non_empty_dir_obj": DeleteObject_non_empty_dir_obj, + "DeleteObject_conditional_writes": DeleteObject_conditional_writes, + "DeleteObject_name_too_long": DeleteObject_name_too_long, + "CopyObject_overwrite_same_dir_object": CopyObject_overwrite_same_dir_object, + "CopyObject_overwrite_same_file_object": CopyObject_overwrite_same_file_object, + "CompleteMultipartUpload_overwrite_dir_obj": CompleteMultipartUpload_overwrite_dir_obj, + "CompleteMultipartUpload_overwrite_dir_obj_delete_marker": CompleteMultipartUpload_overwrite_dir_obj_delete_marker, + "ObjectTagging_trailing_slash_counterpart": ObjectTagging_trailing_slash_counterpart, + "ObjectLock_trailing_slash_counterpart": ObjectLock_trailing_slash_counterpart, + "DeleteObject_non_existing_dir_object": DeleteObject_non_existing_dir_object, + "DeleteObject_directory_object": DeleteObject_directory_object, + "DeleteObject_success": DeleteObject_success, + "DeleteObject_success_status_code": DeleteObject_success_status_code, + "DeleteObject_empty_version_id": DeleteObject_empty_version_id, + "DeleteObject_incorrect_expected_bucket_owner": DeleteObject_incorrect_expected_bucket_owner, + "DeleteObject_expected_bucket_owner": DeleteObject_expected_bucket_owner, + "DeleteObjects_non_existing_bucket": DeleteObjects_non_existing_bucket, + "DeleteObjects_empty_input": DeleteObjects_empty_input, + "DeleteObjects_non_existing_objects": DeleteObjects_non_existing_objects, + "DeleteObjects_success": DeleteObjects_success, + "DeleteObjects_quiet_mode": DeleteObjects_quiet_mode, + "DeleteObjects_key_limit": DeleteObjects_key_limit, + "DeleteObjects_invalid_object_keys": DeleteObjects_invalid_object_keys, + "DeleteObjects_iam_mixed_denials_and_success": DeleteObjects_iam_mixed_denials_and_success, + "DeleteObjects_iam_all_access_denied": DeleteObjects_iam_all_access_denied, + "DeleteObjects_iam_all_locked": DeleteObjects_iam_all_locked, + "CopyObject_non_existing_dst_bucket": CopyObject_non_existing_dst_bucket, + "CopyObject_not_owned_source_bucket": CopyObject_not_owned_source_bucket, + "CopyObject_copy_to_itself": CopyObject_copy_to_itself, + "CopyObject_copy_to_itself_invalid_directive": CopyObject_copy_to_itself_invalid_directive, + "CopyObject_should_replace_tagging": CopyObject_should_replace_tagging, + "CopyObject_should_copy_tagging": CopyObject_should_copy_tagging, + "CopyObject_invalid_tagging_directive": CopyObject_invalid_tagging_directive, + "CopyObject_long_metadata": CopyObject_long_metadata, + "CopyObject_to_itself_with_new_metadata": CopyObject_to_itself_with_new_metadata, + "CopyObject_copy_source_starting_with_slash": CopyObject_copy_source_starting_with_slash, + "CopyObject_invalid_copy_source": CopyObject_invalid_copy_source, + "CopyObject_non_existing_dir_object": CopyObject_non_existing_dir_object, + "CopyObject_should_copy_meta_props": CopyObject_should_copy_meta_props, + "CopyObject_should_not_copy_website_redirect_without_user_metadata": CopyObject_should_not_copy_website_redirect_without_user_metadata, + "CopyObject_should_replace_meta_props": CopyObject_should_replace_meta_props, + "CopyObject_overwrite_resets_attributes": CopyObject_overwrite_resets_attributes, + "CopyObject_invalid_website_redirect_location": CopyObject_invalid_website_redirect_location, + "CopyObject_default_content_type_with_replace_metadata": CopyObject_default_content_type_with_replace_metadata, + "CopyObject_missing_bucket_lock": CopyObject_missing_bucket_lock, + "CopyObject_invalid_legal_hold": CopyObject_invalid_legal_hold, + "CopyObject_invalid_object_lock_mode": CopyObject_invalid_object_lock_mode, + "CopyObject_with_legal_hold": CopyObject_with_legal_hold, + "CopyObject_with_retention_lock": CopyObject_with_retention_lock, + "CopyObject_conditional_reads": CopyObject_conditional_reads, + "CopyObject_object_acl_not_supported": CopyObject_object_acl_not_supported, + "CopyObject_with_metadata": CopyObject_with_metadata, + "CopyObject_invalid_checksum_algorithm": CopyObject_invalid_checksum_algorithm, + "CopyObject_create_checksum_on_copy": CopyObject_create_checksum_on_copy, + "CopyObject_should_copy_the_existing_checksum": CopyObject_should_copy_the_existing_checksum, + "CopyObject_should_replace_the_existing_checksum": CopyObject_should_replace_the_existing_checksum, + "CopyObject_to_itself_by_replacing_the_checksum": CopyObject_to_itself_by_replacing_the_checksum, + "CopyObject_with_special_characters": CopyObject_with_special_characters, + "CopyObject_success": CopyObject_success, + "CopyObject_cross_bucket_server_side_copy": CopyObject_cross_bucket_server_side_copy, + "CopyObject_incorrect_source_bucket_expected_owner": CopyObject_incorrect_source_bucket_expected_owner, + "PutObjectTagging_non_existing_object": PutObjectTagging_non_existing_object, + "PutObjectTagging_long_tags": PutObjectTagging_long_tags, + "PutObjectTagging_duplicate_keys": PutObjectTagging_duplicate_keys, + "PutObjectTagging_tag_count_limit": PutObjectTagging_tag_count_limit, + "PutObjectTagging_invalid_tags": PutObjectTagging_invalid_tags, + "PutObjectTagging_success": PutObjectTagging_success, + "PutObjectTagging_empty_version_id": PutObjectTagging_empty_version_id, + "GetObjectTagging_non_existing_object": GetObjectTagging_non_existing_object, + "GetObjectTagging_unset_tags": GetObjectTagging_unset_tags, + "GetObjectTagging_invalid_parent": GetObjectTagging_invalid_parent, + "GetObjectTagging_success": GetObjectTagging_success, + "GetObjectTagging_empty_version_id": GetObjectTagging_empty_version_id, + "DeleteObjectTagging_non_existing_object": DeleteObjectTagging_non_existing_object, + "DeleteObjectTagging_success_status": DeleteObjectTagging_success_status, + "DeleteObjectTagging_success": DeleteObjectTagging_success, + "DeleteObjectTagging_empty_version_id": DeleteObjectTagging_empty_version_id, + "DeleteObjectTagging_expected_bucket_owner": DeleteObjectTagging_expected_bucket_owner, + "CreateMultipartUpload_non_existing_bucket": CreateMultipartUpload_non_existing_bucket, + "CreateMultipartUpload_long_metadata": CreateMultipartUpload_long_metadata, + "CreateMultipartUpload_with_metadata": CreateMultipartUpload_with_metadata, + "CreateMultipartUpload_invalid_website_redirect_location": CreateMultipartUpload_invalid_website_redirect_location, + "CreateMultipartUpload_with_tagging": CreateMultipartUpload_with_tagging, + "CreateMultipartUpload_with_object_lock": CreateMultipartUpload_with_object_lock, + "CreateMultipartUpload_with_object_lock_not_enabled": CreateMultipartUpload_with_object_lock_not_enabled, + "CreateMultipartUpload_with_object_lock_invalid_retention": CreateMultipartUpload_with_object_lock_invalid_retention, + "CreateMultipartUpload_past_retain_until_date": CreateMultipartUpload_past_retain_until_date, + "CreateMultipartUpload_invalid_legal_hold": CreateMultipartUpload_invalid_legal_hold, + "CreateMultipartUpload_invalid_object_lock_mode": CreateMultipartUpload_invalid_object_lock_mode, + "CreateMultipartUpload_object_acl_not_supported": CreateMultipartUpload_object_acl_not_supported, + "CreateMultipartUpload_invalid_checksum_algorithm": CreateMultipartUpload_invalid_checksum_algorithm, + "CreateMultipartUpload_empty_checksum_algorithm_with_checksum_type": CreateMultipartUpload_empty_checksum_algorithm_with_checksum_type, + "CreateMultipartUpload_type_algo_mismatch": CreateMultipartUpload_type_algo_mismatch, + "CreateMultipartUpload_invalid_checksum_type": CreateMultipartUpload_invalid_checksum_type, + "CreateMultipartUpload_valid_algo_type": CreateMultipartUpload_valid_algo_type, + "CreateMultipartUpload_success": CreateMultipartUpload_success, + "UploadPart_non_existing_bucket": UploadPart_non_existing_bucket, + "UploadPart_invalid_part_number": UploadPart_invalid_part_number, + "UploadPart_non_existing_key": UploadPart_non_existing_key, + "UploadPart_non_existing_mp_upload": UploadPart_non_existing_mp_upload, + "UploadPart_upload_id_path_traversal": UploadPart_upload_id_path_traversal, + "UploadPart_multiple_checksum_headers": UploadPart_multiple_checksum_headers, + "UploadPart_invalid_checksum_header": UploadPart_invalid_checksum_header, + "UploadPart_checksum_header_and_algo_mismatch": UploadPart_checksum_header_and_algo_mismatch, + "UploadPart_checksum_algorithm_mistmatch_on_initialization": UploadPart_checksum_algorithm_mistmatch_on_initialization, + "UploadPart_checksum_algorithm_mistmatch_on_initialization_with_value": UploadPart_checksum_algorithm_mistmatch_on_initialization_with_value, + "UploadPart_incorrect_checksums": UploadPart_incorrect_checksums, + "UploadPart_no_checksum_with_full_object_checksum_type": UploadPart_no_checksum_with_full_object_checksum_type, + "UploadPart_no_checksum_with_composite_checksum_type": UploadPart_no_checksum_with_composite_checksum_type, + "UploadPart_with_checksums_success": UploadPart_with_checksums_success, + "UploadPart_success": UploadPart_success, + "UploadPart_etag_quoting_consistency": UploadPart_etag_quoting_consistency, + "UploadPart_object_lock_checksum_required": UploadPart_object_lock_checksum_required, + "UploadPart_default_retention_checksum_required": UploadPart_default_retention_checksum_required, + "UploadPart_data_integrity_etag": UploadPart_data_integrity_etag, + "UploadPartCopy_non_existing_bucket": UploadPartCopy_non_existing_bucket, + "UploadPartCopy_incorrect_uploadId": UploadPartCopy_incorrect_uploadId, + "UploadPartCopy_upload_id_path_traversal": UploadPartCopy_upload_id_path_traversal, + "UploadPartCopy_incorrect_object_key": UploadPartCopy_incorrect_object_key, + "UploadPartCopy_invalid_part_number": UploadPartCopy_invalid_part_number, + "UploadPartCopy_invalid_copy_source": UploadPartCopy_invalid_copy_source, + "UploadPartCopy_non_existing_source_bucket": UploadPartCopy_non_existing_source_bucket, + "UploadPartCopy_non_existing_source_object_key": UploadPartCopy_non_existing_source_object_key, + "UploadPartCopy_success": UploadPartCopy_success, + "UploadPartCopy_by_range_invalid_ranges": UploadPartCopy_by_range_invalid_ranges, + "UploadPartCopy_exceeding_copy_source_range": UploadPartCopy_exceeding_copy_source_range, + "UploadPartCopy_greater_range_than_obj_size": UploadPartCopy_greater_range_than_obj_size, + "UploadPartCopy_by_range_success": UploadPartCopy_by_range_success, + "UploadPartCopy_conditional_reads": UploadPartCopy_conditional_reads, + "UploadPartCopy_incorrect_source_bucket_expected_owner": UploadPartCopy_incorrect_source_bucket_expected_owner, + "UploadPartCopy_should_copy_the_checksum": UploadPartCopy_should_copy_the_checksum, + "UploadPartCopy_should_not_copy_the_checksum": UploadPartCopy_should_not_copy_the_checksum, + "UploadPartCopy_should_calculate_the_checksum": UploadPartCopy_should_calculate_the_checksum, + "UploadPartCopy_data_integrity_etag": UploadPartCopy_data_integrity_etag, + "ListParts_incorrect_uploadId": ListParts_incorrect_uploadId, + "ListParts_upload_id_path_traversal": ListParts_upload_id_path_traversal, + "ListParts_incorrect_object_key": ListParts_incorrect_object_key, + "ListParts_invalid_max_parts": ListParts_invalid_max_parts, + "ListParts_invalid_part_number_marker": ListParts_invalid_part_number_marker, + "ListParts_default_max_parts": ListParts_default_max_parts, + "ListParts_truncated": ListParts_truncated, + "ListParts_with_checksums": ListParts_with_checksums, + "ListParts_null_checksums": ListParts_null_checksums, + "ListParts_success": ListParts_success, + "ListMultipartUploads_non_existing_bucket": ListMultipartUploads_non_existing_bucket, + "ListMultipartUploads_empty_result": ListMultipartUploads_empty_result, + "ListMultipartUploads_invalid_max_uploads": ListMultipartUploads_invalid_max_uploads, + "ListMultipartUploads_max_uploads": ListMultipartUploads_max_uploads, + "ListMultipartUploads_exceeding_max_uploads": ListMultipartUploads_exceeding_max_uploads, + "ListMultipartUploads_ignore_upload_id_marker": ListMultipartUploads_ignore_upload_id_marker, + "ListMultipartUploads_invalid_uploadId_marker": ListMultipartUploads_invalid_uploadId_marker, + "ListMultipartUploads_keyMarker_not_from_list": ListMultipartUploads_keyMarker_not_from_list, + "ListMultipartUploads_delimiter_truncated": ListMultipartUploads_delimiter_truncated, + "ListMultipartUploads_prefix": ListMultipartUploads_prefix, + "ListMultipartUploads_both_delimiter_and_prefix": ListMultipartUploads_both_delimiter_and_prefix, + "ListMultipartUploads_with_checksums": ListMultipartUploads_with_checksums, + "AbortMultipartUpload_non_existing_bucket": AbortMultipartUpload_non_existing_bucket, + "AbortMultipartUpload_incorrect_uploadId": AbortMultipartUpload_incorrect_uploadId, + "AbortMultipartUpload_upload_id_path_traversal": AbortMultipartUpload_upload_id_path_traversal, + "AbortMultipartUpload_incorrect_object_key": AbortMultipartUpload_incorrect_object_key, + "AbortMultipartUpload_success": AbortMultipartUpload_success, + "AbortMultipartUpload_success_status_code": AbortMultipartUpload_success_status_code, + "AbortMultipartUpload_if_match_initiated_time": AbortMultipartUpload_if_match_initiated_time, + "CompletedMultipartUpload_non_existing_bucket": CompletedMultipartUpload_non_existing_bucket, + "CompleteMultipartUpload_upload_id_path_traversal": CompleteMultipartUpload_upload_id_path_traversal, + "CompleteMultipartUpload_invalid_part_number": CompleteMultipartUpload_invalid_part_number, + "CompleteMultipartUpload_default_content_type": CompleteMultipartUpload_default_content_type, + "CompleteMultipartUpload_overwrite_resets_attributes": CompleteMultipartUpload_overwrite_resets_attributes, + "CompleteMultipartUpload_invalid_ETag": CompleteMultipartUpload_invalid_ETag, + "CompleteMultipartUpload_small_upload_size": CompleteMultipartUpload_small_upload_size, + "CompleteMultipartUpload_empty_parts": CompleteMultipartUpload_empty_parts, + "CompleteMultipartUpload_missing_part_fields": CompleteMultipartUpload_missing_part_fields, + "CompleteMultipartUpload_incorrect_part_number": CompleteMultipartUpload_incorrect_part_number, + "CompleteMultipartUpload_incorrect_parts_order": CompleteMultipartUpload_incorrect_parts_order, + "CompleteMultipartUpload_mpu_object_size": CompleteMultipartUpload_mpu_object_size, + "CompleteMultipartUpload_conditional_writes": CompleteMultipartUpload_conditional_writes, + "CompleteMultipartUpload_with_metadata": CompleteMultipartUpload_with_metadata, + "CompleteMultipartUpload_invalid_checksum_type": CompleteMultipartUpload_invalid_checksum_type, + "CompleteMultipartUpload_invalid_checksum_part": CompleteMultipartUpload_invalid_checksum_part, + "CompleteMultipartUpload_multiple_checksum_part": CompleteMultipartUpload_multiple_checksum_part, + "CompleteMultipartUpload_incorrect_checksum_part": CompleteMultipartUpload_incorrect_checksum_part, + "CompleteMultipartUpload_different_checksum_part": CompleteMultipartUpload_different_checksum_part, + "CompleteMultipartUpload_missing_part_checksum": CompleteMultipartUpload_missing_part_checksum, + "CompleteMultipartUpload_multiple_final_checksums": CompleteMultipartUpload_multiple_final_checksums, + "CompleteMultipartUpload_invalid_final_checksums": CompleteMultipartUpload_invalid_final_checksums, + "CompleteMultipartUpload_incorrect_final_checksums": CompleteMultipartUpload_incorrect_final_checksums, + "CompleteMultipartUpload_should_calculate_the_final_checksum_full_object": CompleteMultipartUpload_should_calculate_the_final_checksum_full_object, + "CompleteMultipartUpload_should_verify_the_final_checksum": CompleteMultipartUpload_should_verify_the_final_checksum, + "CompleteMultipartUpload_should_verify_final_composite_checksum": CompleteMultipartUpload_should_verify_final_composite_checksum, + "CompleteMultipartUpload_invalid_final_composite_checksum": CompleteMultipartUpload_invalid_final_composite_checksum, + "CompleteMultipartUpload_checksum_type_mismatch": CompleteMultipartUpload_checksum_type_mismatch, + "CompleteMultipartUpload_should_ignore_the_final_checksum": CompleteMultipartUpload_should_ignore_the_final_checksum, + "CompleteMultipartUpload_should_succeed_without_final_checksum_type": CompleteMultipartUpload_should_succeed_without_final_checksum_type, + "CompleteMultipartUpload_success": CompleteMultipartUpload_success, + "CompleteMultipartUpload_data_integrity_etag": CompleteMultipartUpload_data_integrity_etag, + "CompleteMultipartUpload_already_completed": CompleteMultipartUpload_already_completed, + "CompleteMultipartUpload_racey_success": CompleteMultipartUpload_racey_success, + "CompleteMultipartUpload_racey_data_integrity": CompleteMultipartUpload_racey_data_integrity, + "PutBucketAcl_non_existing_bucket": PutBucketAcl_non_existing_bucket, + "PutBucketAcl_disabled": PutBucketAcl_disabled, + "PutBucketAcl_none_of_the_options_specified": PutBucketAcl_none_of_the_options_specified, + "PutBucketAcl_invalid_canned_acl": PutBucketAcl_invalid_canned_acl, + "PutBucketAcl_invalid_acl_canned_and_acp": PutBucketAcl_invalid_acl_canned_and_acp, + "PutBucketAcl_invalid_acl_canned_and_grants": PutBucketAcl_invalid_acl_canned_and_grants, + "PutBucketAcl_invalid_acl_acp_and_grants": PutBucketAcl_invalid_acl_acp_and_grants, + "PutBucketAcl_invalid_owner": PutBucketAcl_invalid_owner, + "PutBucketAcl_invalid_owner_not_in_body": PutBucketAcl_invalid_owner_not_in_body, + "PutBucketAcl_invalid_empty_owner_id_in_body": PutBucketAcl_invalid_empty_owner_id_in_body, + "PutBucketAcl_invalid_permission_in_body": PutBucketAcl_invalid_permission_in_body, + "PutBucketAcl_invalid_grantee_type_in_body": PutBucketAcl_invalid_grantee_type_in_body, + "PutBucketAcl_empty_grantee_ID_in_body": PutBucketAcl_empty_grantee_ID_in_body, + "PutBucketAcl_success_access_denied": PutBucketAcl_success_access_denied, + "PutBucketAcl_success_grants": PutBucketAcl_success_grants, + "PutBucketAcl_success_canned_acl": PutBucketAcl_success_canned_acl, + "PutBucketAcl_success_acp": PutBucketAcl_success_acp, + "GetBucketAcl_non_existing_bucket": GetBucketAcl_non_existing_bucket, + "GetBucketAcl_translation_canned_public_read": GetBucketAcl_translation_canned_public_read, + "GetBucketAcl_translation_canned_public_read_write": GetBucketAcl_translation_canned_public_read_write, + "GetBucketAcl_translation_canned_private": GetBucketAcl_translation_canned_private, + "GetBucketAcl_access_denied": GetBucketAcl_access_denied, + "GetBucketAcl_success": GetBucketAcl_success, + "PutBucketPolicy_non_existing_bucket": PutBucketPolicy_non_existing_bucket, + "PutBucketPolicy_invalid_json": PutBucketPolicy_invalid_json, + "PutBucketPolicy_statement_not_provided": PutBucketPolicy_statement_not_provided, + "PutBucketPolicy_empty_statement": PutBucketPolicy_empty_statement, + "PutBucketPolicy_invalid_effect": PutBucketPolicy_invalid_effect, + "PutBucketPolicy_invalid_action": PutBucketPolicy_invalid_action, + "PutBucketPolicy_empty_principals_string": PutBucketPolicy_empty_principals_string, + "PutBucketPolicy_empty_principals_array": PutBucketPolicy_empty_principals_array, + "PutBucketPolicy_principals_aws_struct_empty_string": PutBucketPolicy_principals_aws_struct_empty_string, + "PutBucketPolicy_principals_aws_struct_empty_string_slice": PutBucketPolicy_principals_aws_struct_empty_string_slice, + "PutBucketPolicy_principals_incorrect_wildcard_usage": PutBucketPolicy_principals_incorrect_wildcard_usage, + "PutBucketPolicy_non_existing_principals": PutBucketPolicy_non_existing_principals, + "PutBucketPolicy_empty_resources_string": PutBucketPolicy_empty_resources_string, + "PutBucketPolicy_empty_resources_array": PutBucketPolicy_empty_resources_array, + "PutBucketPolicy_invalid_resource_prefix": PutBucketPolicy_invalid_resource_prefix, + "PutBucketPolicy_invalid_resource_with_starting_slash": PutBucketPolicy_invalid_resource_with_starting_slash, + "PutBucketPolicy_duplicate_resource": PutBucketPolicy_duplicate_resource, + "PutBucketPolicy_incorrect_bucket_name": PutBucketPolicy_incorrect_bucket_name, + "PutBucketPolicy_action_resource_mismatch": PutBucketPolicy_action_resource_mismatch, + "PutBucketPolicy_explicit_deny": PutBucketPolicy_explicit_deny, + "PutBucketPolicy_multi_wildcard_resource": PutBucketPolicy_multi_wildcard_resource, + "PutBucketPolicy_any_char_match": PutBucketPolicy_any_char_match, + "PutBucketPolicy_version": PutBucketPolicy_version, + "PutBucketPolicy_success": PutBucketPolicy_success, + "PutBucketPolicy_status": PutBucketPolicy_status, + "PutBucketPolicy_condition_invalid_operator": PutBucketPolicy_condition_invalid_operator, + "PutBucketPolicy_condition_invalid_key": PutBucketPolicy_condition_invalid_key, + "PutBucketPolicy_condition_action_mismatch": PutBucketPolicy_condition_action_mismatch, + "PutBucketPolicy_condition_conditional_write_keys": PutBucketPolicy_condition_conditional_write_keys, + "PutBucketPolicy_condition_invalid_ip": PutBucketPolicy_condition_invalid_ip, + "GetBucketPolicy_non_existing_bucket": GetBucketPolicy_non_existing_bucket, + "GetBucketPolicy_not_set": GetBucketPolicy_not_set, + "GetBucketPolicy_success": GetBucketPolicy_success, + "GetBucketPolicyStatus_non_existing_bucket": GetBucketPolicyStatus_non_existing_bucket, + "GetBucketPolicyStatus_no_such_bucket_policy": GetBucketPolicyStatus_no_such_bucket_policy, + "GetBucketPolicyStatus_success": GetBucketPolicyStatus_success, + "DeleteBucketPolicy_non_existing_bucket": DeleteBucketPolicy_non_existing_bucket, + "DeleteBucketPolicy_remove_before_setting": DeleteBucketPolicy_remove_before_setting, + "DeleteBucketPolicy_success": DeleteBucketPolicy_success, + "PutBucketCors_non_existing_bucket": PutBucketCors_non_existing_bucket, + "PutBucketCors_empty_cors_rules": PutBucketCors_empty_cors_rules, + "PutBucketCors_invalid_allowed_origins": PutBucketCors_invalid_allowed_origins, + "PutBucketCors_invalid_method": PutBucketCors_invalid_method, + "PutBucketCors_invalid_header": PutBucketCors_invalid_header, + "PutBucketCors_md5": PutBucketCors_md5, + "GetBucketCors_non_existing_bucket": GetBucketCors_non_existing_bucket, + "GetBucketCors_no_such_bucket_cors": GetBucketCors_no_such_bucket_cors, + "GetBucketCors_success": GetBucketCors_success, + "DeleteBucketCors_non_existing_bucket": DeleteBucketCors_non_existing_bucket, + "DeleteBucketCors_success": DeleteBucketCors_success, + "PutBucketCors_success": PutBucketCors_success, + "PutBucketWebsite_non_existing_bucket": PutBucketWebsite_non_existing_bucket, + "PutBucketWebsite_empty_suffix": PutBucketWebsite_empty_suffix, + "PutBucketWebsite_empty_configuration": PutBucketWebsite_empty_configuration, + "PutBucketWebsite_suffix_with_slash": PutBucketWebsite_suffix_with_slash, + "PutBucketWebsite_invalid_redirect_protocol": PutBucketWebsite_invalid_redirect_protocol, + "PutBucketWebsite_redirectAll_index_error_routingRules": PutBucketWebsite_redirectAll_index_error_routingRules, + "PutBucketWebsite_invalid_routing_rule_protocol": PutBucketWebsite_invalid_routing_rule_protocol, + "PutBucketWebsite_empty_routing_rule_condition": PutBucketWebsite_empty_routing_rule_condition, + "PutBucketWebsite_empty_routing_rule_redirect": PutBucketWebsite_empty_routing_rule_redirect, + "PutBucketWebsite_empty_error_document_key": PutBucketWebsite_empty_error_document_key, + "PutBucketWebsite_too_many_routing_rules": PutBucketWebsite_too_many_routing_rules, + "PutBucketWebsite_routing_rule_replace_key_and_prefix": PutBucketWebsite_routing_rule_replace_key_and_prefix, + "PutBucketWebsite_invalid_http_redirect_code": PutBucketWebsite_invalid_http_redirect_code, + "PutBucketWebsite_invalid_http_error_code": PutBucketWebsite_invalid_http_error_code, + "PutBucketWebsite_request_too_large": PutBucketWebsite_request_too_large, + "PutBucketWebsite_success": PutBucketWebsite_success, + "PutBucketWebsite_success_redirect_all": PutBucketWebsite_success_redirect_all, + "GetBucketWebsite_non_existing_bucket": GetBucketWebsite_non_existing_bucket, + "GetBucketWebsite_no_such_website_config": GetBucketWebsite_no_such_website_config, + "GetBucketWebsite_success": GetBucketWebsite_success, + "GetBucketWebsite_success_redirect_all": GetBucketWebsite_success_redirect_all, + "DeleteBucketWebsite_non_existing_bucket": DeleteBucketWebsite_non_existing_bucket, + "DeleteBucketWebsite_success": DeleteBucketWebsite_success, + "WebsiteHosting_error_document_served": WebsiteHosting_error_document_served, + "WebsiteHosting_error_document_not_found": WebsiteHosting_error_document_not_found, + "WebsiteHosting_no_error_document": WebsiteHosting_no_error_document, + "WebsiteHosting_no_bucket_in_request_location": WebsiteHosting_no_bucket_in_request_location, + "WebsiteHosting_private_object_and_error_document": WebsiteHosting_private_object_and_error_document, + "WebsiteHosting_routing_rule_post_request_redirect": WebsiteHosting_routing_rule_post_request_redirect, + "WebsiteHosting_routing_rule_pre_request_redirect": WebsiteHosting_routing_rule_pre_request_redirect, + "WebsiteHosting_routing_rule_prefix_and_error_redirect": WebsiteHosting_routing_rule_prefix_and_error_redirect, + "WebsiteHosting_routing_rule_no_match_serves_error_document": WebsiteHosting_routing_rule_no_match_serves_error_document, + "WebsiteHosting_redirect_all_requests": WebsiteHosting_redirect_all_requests, + "WebsiteHosting_object_redirect_location": WebsiteHosting_object_redirect_location, + "WebsiteHosting_index_document": WebsiteHosting_index_document, + "WebsiteHosting_index_error_document_and_routing_rules": WebsiteHosting_index_error_document_and_routing_rules, + "WebsiteHosting_get_cors_headers": WebsiteHosting_get_cors_headers, + "WebsiteHosting_head_cors_headers": WebsiteHosting_head_cors_headers, + "WebsiteHosting_options_preflight_access_granted": WebsiteHosting_options_preflight_access_granted, + "WebsiteHosting_options_preflight_access_forbidden": WebsiteHosting_options_preflight_access_forbidden, + "WebsiteHosting_options_preflight_missing_origin": WebsiteHosting_options_preflight_missing_origin, + "WebsiteHosting_url_encoded_object_key": WebsiteHosting_url_encoded_object_key, + "PreflightOPTIONS_non_existing_bucket": PreflightOPTIONS_non_existing_bucket, + "PreflightOPTIONS_missing_origin": PreflightOPTIONS_missing_origin, + "PreflightOPTIONS_invalid_request_method": PreflightOPTIONS_invalid_request_method, + "PreflightOPTIONS_invalid_request_headers": PreflightOPTIONS_invalid_request_headers, + "PreflightOPTIONS_unset_bucket_cors": PreflightOPTIONS_unset_bucket_cors, + "PreflightOPTIONS_access_forbidden": PreflightOPTIONS_access_forbidden, + "PreflightOPTIONS_access_granted": PreflightOPTIONS_access_granted, + "CORSMiddleware_invalid_method": CORSMiddleware_invalid_method, + "CORSMiddleware_invalid_headers": CORSMiddleware_invalid_headers, + "CORSMiddleware_access_forbidden": CORSMiddleware_access_forbidden, + "CORSMiddleware_access_granted": CORSMiddleware_access_granted, + "PutObjectLockConfiguration_non_existing_bucket": PutObjectLockConfiguration_non_existing_bucket, + "PutObjectLockConfiguration_empty_request_body": PutObjectLockConfiguration_empty_request_body, + "PutObjectLockConfiguration_malformed_body": PutObjectLockConfiguration_malformed_body, + "PutObjectLockConfiguration_not_enabled_on_bucket_creation": PutObjectLockConfiguration_not_enabled_on_bucket_creation, + "PutObjectLockConfiguration_invalid_status": PutObjectLockConfiguration_invalid_status, + "PutObjectLockConfiguration_invalid_mode": PutObjectLockConfiguration_invalid_mode, + "PutObjectLockConfiguration_both_years_and_days": PutObjectLockConfiguration_both_years_and_days, + "PutObjectLockConfiguration_invalid_years_days": PutObjectLockConfiguration_invalid_years_days, + "PutObjectLockConfiguration_success": PutObjectLockConfiguration_success, + "GetObjectLockConfiguration_non_existing_bucket": GetObjectLockConfiguration_non_existing_bucket, + "GetObjectLockConfiguration_unset_config": GetObjectLockConfiguration_unset_config, + "GetObjectLockConfiguration_no_default_retention": GetObjectLockConfiguration_no_default_retention, + "GetObjectLockConfiguration_success": GetObjectLockConfiguration_success, + "PutObjectRetention_non_existing_bucket": PutObjectRetention_non_existing_bucket, + "PutObjectRetention_non_existing_object": PutObjectRetention_non_existing_object, + "PutObjectRetention_unset_bucket_object_lock_config": PutObjectRetention_unset_bucket_object_lock_config, + "PutObjectRetention_expired_retain_until_date": PutObjectRetention_expired_retain_until_date, + "PutObjectRetention_invalid_mode": PutObjectRetention_invalid_mode, + "PutObjectRetention_overwrite_compliance_mode": PutObjectRetention_overwrite_compliance_mode, + "PutObjectRetention_overwrite_compliance_with_compliance": PutObjectRetention_overwrite_compliance_with_compliance, + "PutObjectRetention_overwrite_governance_with_governance": PutObjectRetention_overwrite_governance_with_governance, + "PutObjectRetention_overwrite_governance_without_bypass_specified": PutObjectRetention_overwrite_governance_without_bypass_specified, + "PutObjectRetention_overwrite_governance_with_permission": PutObjectRetention_overwrite_governance_with_permission, + "PutObjectRetention_shorten_governance_without_bypass": PutObjectRetention_shorten_governance_without_bypass, + "PutObjectRetention_shorten_governance_with_bypass": PutObjectRetention_shorten_governance_with_bypass, + "PutObjectRetention_shorten_compliance_denied": PutObjectRetention_shorten_compliance_denied, + "PutObjectRetention_rewrite_same_date": PutObjectRetention_rewrite_same_date, + "PutObjectRetention_success": PutObjectRetention_success, + "PutObjectRetention_empty_version_id": PutObjectRetention_empty_version_id, + "GetObjectRetention_non_existing_bucket": GetObjectRetention_non_existing_bucket, + "GetObjectRetention_non_existing_object": GetObjectRetention_non_existing_object, + "GetObjectRetention_disabled_lock": GetObjectRetention_disabled_lock, + "GetObjectRetention_unset_config": GetObjectRetention_unset_config, + "GetObjectRetention_success": GetObjectRetention_success, + "GetObjectRetention_empty_version_id": GetObjectRetention_empty_version_id, + "PutObjectLegalHold_non_existing_bucket": PutObjectLegalHold_non_existing_bucket, + "PutObjectLegalHold_non_existing_object": PutObjectLegalHold_non_existing_object, + "PutObjectLegalHold_invalid_body": PutObjectLegalHold_invalid_body, + "PutObjectLegalHold_invalid_status": PutObjectLegalHold_invalid_status, + "PutObjectLegalHold_unset_bucket_object_lock_config": PutObjectLegalHold_unset_bucket_object_lock_config, + "PutObjectLegalHold_success": PutObjectLegalHold_success, + "PutObjectLegalHold_empty_version_id": PutObjectLegalHold_empty_version_id, + "GetObjectLegalHold_non_existing_bucket": GetObjectLegalHold_non_existing_bucket, + "GetObjectLegalHold_non_existing_object": GetObjectLegalHold_non_existing_object, + "GetObjectLegalHold_disabled_lock": GetObjectLegalHold_disabled_lock, + "GetObjectLegalHold_unset_config": GetObjectLegalHold_unset_config, + "GetObjectLegalHold_success": GetObjectLegalHold_success, + "GetObjectLegalHold_empty_version_id": GetObjectLegalHold_empty_version_id, + "PutBucketAnalyticsConfiguration_not_implemented": PutBucketAnalyticsConfiguration_not_implemented, + "GetBucketAnalyticsConfiguration_not_implemented": GetBucketAnalyticsConfiguration_not_implemented, + "ListBucketAnalyticsConfiguration_not_implemented": ListBucketAnalyticsConfiguration_not_implemented, + "DeleteBucketAnalyticsConfiguration_not_implemented": DeleteBucketAnalyticsConfiguration_not_implemented, + "PutBucketEncryption_not_implemented": PutBucketEncryption_not_implemented, + "GetBucketEncryption_not_implemented": GetBucketEncryption_not_implemented, + "DeleteBucketEncryption_not_implemented": DeleteBucketEncryption_not_implemented, + "PutBucketIntelligentTieringConfiguration_not_implemented": PutBucketIntelligentTieringConfiguration_not_implemented, + "GetBucketIntelligentTieringConfiguration_not_implemented": GetBucketIntelligentTieringConfiguration_not_implemented, + "ListBucketIntelligentTieringConfiguration_not_implemented": ListBucketIntelligentTieringConfiguration_not_implemented, + "DeleteBucketIntelligentTieringConfiguration_not_implemented": DeleteBucketIntelligentTieringConfiguration_not_implemented, + "PutBucketInventoryConfiguration_not_implemented": PutBucketInventoryConfiguration_not_implemented, + "GetBucketInventoryConfiguration_not_implemented": GetBucketInventoryConfiguration_not_implemented, + "ListBucketInventoryConfiguration_not_implemented": ListBucketInventoryConfiguration_not_implemented, + "DeleteBucketInventoryConfiguration_not_implemented": DeleteBucketInventoryConfiguration_not_implemented, + "PutBucketLifecycleConfiguration_not_implemented": PutBucketLifecycleConfiguration_not_implemented, + "GetBucketLifecycleConfiguration_not_implemented": GetBucketLifecycleConfiguration_not_implemented, + "DeleteBucketLifecycle_not_implemented": DeleteBucketLifecycle_not_implemented, + "PutBucketLogging_not_implemented": PutBucketLogging_not_implemented, + "GetBucketLogging_not_implemented": GetBucketLogging_not_implemented, + "PutBucketRequestPayment_not_implemented": PutBucketRequestPayment_not_implemented, + "GetBucketRequestPayment_not_implemented": GetBucketRequestPayment_not_implemented, + "PutBucketMetricsConfiguration_not_implemented": PutBucketMetricsConfiguration_not_implemented, + "GetBucketMetricsConfiguration_not_implemented": GetBucketMetricsConfiguration_not_implemented, + "ListBucketMetricsConfigurations_not_implemented": ListBucketMetricsConfigurations_not_implemented, + "DeleteBucketMetricsConfiguration_not_implemented": DeleteBucketMetricsConfiguration_not_implemented, + "PutBucketReplication_not_implemented": PutBucketReplication_not_implemented, + "GetBucketReplication_not_implemented": GetBucketReplication_not_implemented, + "DeleteBucketReplication_not_implemented": DeleteBucketReplication_not_implemented, + "PutPublicAccessBlock_not_implemented": PutPublicAccessBlock_not_implemented, + "GetPublicAccessBlock_not_implemented": GetPublicAccessBlock_not_implemented, + "DeletePublicAccessBlock_not_implemented": DeletePublicAccessBlock_not_implemented, + "PutBucketNotificationConfiguratio_not_implemented": PutBucketNotificationConfiguratio_not_implemented, + "GetBucketNotificationConfiguratio_not_implemented": GetBucketNotificationConfiguratio_not_implemented, + "PutBucketAccelerateConfiguration_not_implemented": PutBucketAccelerateConfiguration_not_implemented, + "GetBucketAccelerateConfiguration_not_implemented": GetBucketAccelerateConfiguration_not_implemented, + "PutObjectAcl_not_implemented": PutObjectAcl_not_implemented, + "GetObjectAcl_not_implemented": GetObjectAcl_not_implemented, + "WORMProtection_bucket_object_lock_configuration_compliance_mode": WORMProtection_bucket_object_lock_configuration_compliance_mode, + "WORMProtection_bucket_object_lock_configuration_governance_mode": WORMProtection_bucket_object_lock_configuration_governance_mode, + "WORMProtection_bucket_object_lock_governance_bypass_delete": WORMProtection_bucket_object_lock_governance_bypass_delete, + "WORMProtection_bucket_object_lock_governance_bypass_delete_multiple": WORMProtection_bucket_object_lock_governance_bypass_delete_multiple, + "WORMProtection_delete_objects_locked_object_partial_success": WORMProtection_delete_objects_locked_object_partial_success, + "WORMProtection_object_lock_retention_compliance_locked": WORMProtection_object_lock_retention_compliance_locked, + "WORMProtection_object_lock_retention_governance_locked": WORMProtection_object_lock_retention_governance_locked, + "WORMProtection_object_lock_retention_governance_bypass_overwrite_put": WORMProtection_object_lock_retention_governance_bypass_overwrite_put, + "WORMProtection_object_lock_retention_governance_bypass_overwrite_copy": WORMProtection_object_lock_retention_governance_bypass_overwrite_copy, + "WORMProtection_object_lock_retention_governance_bypass_overwrite_mp": WORMProtection_object_lock_retention_governance_bypass_overwrite_mp, + "WORMProtection_object_lock_retention_governance_bypass_overwrite_post": WORMProtection_object_lock_retention_governance_bypass_overwrite_post, + "WORMProtection_unable_to_overwrite_locked_object_put": WORMProtection_unable_to_overwrite_locked_object_put, + "WORMProtection_unable_to_overwrite_locked_object_copy": WORMProtection_unable_to_overwrite_locked_object_copy, + "WORMProtection_unable_to_overwrite_locked_object_mp": WORMProtection_unable_to_overwrite_locked_object_mp, + "WORMProtection_unable_to_overwrite_locked_object_post": WORMProtection_unable_to_overwrite_locked_object_post, + "WORMProtection_object_lock_retention_governance_bypass_delete": WORMProtection_object_lock_retention_governance_bypass_delete, + "WORMProtection_object_lock_retention_governance_bypass_delete_mul": WORMProtection_object_lock_retention_governance_bypass_delete_mul, + "WORMProtection_object_lock_legal_hold_locked": WORMProtection_object_lock_legal_hold_locked, + "WORMProtection_root_bypass_governance_retention_delete_object": WORMProtection_root_bypass_governance_retention_delete_object, + "PutObject_overwrite_dir_obj": PutObject_overwrite_dir_obj, + "PutObject_overwrite_file_obj": PutObject_overwrite_file_obj, + "PutObject_overwrite_file_obj_with_nested_obj": PutObject_overwrite_file_obj_with_nested_obj, + "PutObject_dir_obj_with_data": PutObject_dir_obj_with_data, + "PutObject_with_slashes": PutObject_with_slashes, + "PutObject_race_with_delete": PutObject_race_with_delete, + "CreateMultipartUpload_dir_obj": CreateMultipartUpload_dir_obj, + "IAM_user_access_denied": IAM_user_access_denied, + "IAM_userplus_access_denied": IAM_userplus_access_denied, + "IAM_userplus_CreateBucket": IAM_userplus_CreateBucket, + "IAM_admin_ChangeBucketOwner": IAM_admin_ChangeBucketOwner, + "IAM_ChangeBucketOwner_back_to_root": IAM_ChangeBucketOwner_back_to_root, + "IAM_ListBuckets": IAM_ListBuckets, + "IAM_CreateBucket_empty_owner_header": IAM_CreateBucket_empty_owner_header, + "IAM_CreateBucket_non_existing_user": IAM_CreateBucket_non_existing_user, + "IAM_CreateBucket_success": IAM_CreateBucket_success, + "AccessControl_default_ACL_user_access_denied": AccessControl_default_ACL_user_access_denied, + "AccessControl_default_ACL_userplus_access_denied": AccessControl_default_ACL_userplus_access_denied, + "AccessControl_default_ACL_admin_successful_access": AccessControl_default_ACL_admin_successful_access, + "AccessControl_bucket_resource_single_action": AccessControl_bucket_resource_single_action, + "AccessControl_bucket_resource_all_action": AccessControl_bucket_resource_all_action, + "AccessControl_single_object_resource_actions": AccessControl_single_object_resource_actions, + "AccessControl_multi_statement_policy": AccessControl_multi_statement_policy, + "AccessControl_bucket_ownership_to_user": AccessControl_bucket_ownership_to_user, + "AccessControl_root_PutBucketAcl": AccessControl_root_PutBucketAcl, + "AccessControl_user_PutBucketAcl_with_policy_access": AccessControl_user_PutBucketAcl_with_policy_access, + "AccessControl_copy_object_with_starting_slash_for_user": AccessControl_copy_object_with_starting_slash_for_user, + "AccessControl_PutObject_with_tagging_policy": AccessControl_PutObject_with_tagging_policy, + "AccessControl_PutObject_with_legal_hold_policy": AccessControl_PutObject_with_legal_hold_policy, + "AccessControl_PutObject_with_retention_policy": AccessControl_PutObject_with_retention_policy, + "AccessControl_CreateMultipartUpload_with_tagging_policy": AccessControl_CreateMultipartUpload_with_tagging_policy, + "AccessControl_CreateMultipartUpload_with_legal_hold_policy": AccessControl_CreateMultipartUpload_with_legal_hold_policy, + "AccessControl_CreateMultipartUpload_with_retention_policy": AccessControl_CreateMultipartUpload_with_retention_policy, + "AccessControl_CopyObject_with_tagging_policy": AccessControl_CopyObject_with_tagging_policy, + "AccessControl_CopyObject_with_legal_hold_policy": AccessControl_CopyObject_with_legal_hold_policy, + "AccessControl_CopyObject_with_retention_policy": AccessControl_CopyObject_with_retention_policy, + "AccessControl_policy_normalizes_object_key_for_get_put_delete": AccessControl_policy_normalizes_object_key_for_get_put_delete, + "AccessControl_bucket_policy_condition_ip_allow": AccessControl_bucket_policy_condition_ip_allow, + "AccessControl_bucket_policy_condition_ip_deny_no_match": AccessControl_bucket_policy_condition_ip_deny_no_match, + "AccessControl_bucket_policy_condition_not_ip_address_allow": AccessControl_bucket_policy_condition_not_ip_address_allow, + "AccessControl_bucket_policy_condition_not_ip_address_deny": AccessControl_bucket_policy_condition_not_ip_address_deny, + "AccessControl_bucket_policy_condition_explicit_deny_overrides_allow": AccessControl_bucket_policy_condition_explicit_deny_overrides_allow, + "AccessControl_bucket_policy_condition_s3_prefix": AccessControl_bucket_policy_condition_s3_prefix, + "AccessControl_bucket_policy_condition_string_operators": AccessControl_bucket_policy_condition_string_operators, + "AccessControl_bucket_policy_condition_numeric_operators": AccessControl_bucket_policy_condition_numeric_operators, + "AccessControl_bucket_policy_condition_date_operators": AccessControl_bucket_policy_condition_date_operators, + "AccessControl_bucket_policy_condition_bool_operator": AccessControl_bucket_policy_condition_bool_operator, + "AccessControl_bucket_policy_condition_binary_operator": AccessControl_bucket_policy_condition_binary_operator, + "AccessControl_bucket_policy_condition_null_operator": AccessControl_bucket_policy_condition_null_operator, + "AccessControl_bucket_policy_condition_if_none_match_required": AccessControl_bucket_policy_condition_if_none_match_required, + "AccessControl_bucket_policy_condition_if_none_match_value": AccessControl_bucket_policy_condition_if_none_match_value, + "AccessControl_bucket_policy_condition_if_match_value": AccessControl_bucket_policy_condition_if_match_value, + "AccessControl_bucket_policy_condition_if_match_delete_object": AccessControl_bucket_policy_condition_if_match_delete_object, + "AccessControl_bucket_policy_condition_if_match_versioned_delete": AccessControl_bucket_policy_condition_if_match_versioned_delete, + "PublicBucket_default_private_bucket": PublicBucket_default_private_bucket, + "PublicBucket_public_bucket_policy": PublicBucket_public_bucket_policy, + "PublicBucket_public_object_policy": PublicBucket_public_object_policy, + "PublicBucket_public_acl": PublicBucket_public_acl, + "PublicBucket_policy_deny_overrides_public_acl": PublicBucket_policy_deny_overrides_public_acl, + "PublicBucket_post_object_policy": PublicBucket_post_object_policy, + "PublicBucket_post_object_policy_deny_overrides_public_acl": PublicBucket_post_object_policy_deny_overrides_public_acl, + "PublicBucket_signed_streaming_payload": PublicBucket_signed_streaming_payload, + "PublicBucket_incorrect_sha256_hash": PublicBucket_incorrect_sha256_hash, + "PublicBucket_put_object_tagging": PublicBucket_put_object_tagging, + "PublicBucket_put_object_tagging_public_acl": PublicBucket_put_object_tagging_public_acl, + "PublicBucket_put_object_lock": PublicBucket_put_object_lock, + "PublicBucket_put_object_lock_missing_bucket_lock": PublicBucket_put_object_lock_missing_bucket_lock, + "PublicBucket_put_object_default_retention": PublicBucket_put_object_default_retention, + "PublicBucket_upload_part_object_lock": PublicBucket_upload_part_object_lock, + "PublicBucket_post_object_tagging": PublicBucket_post_object_tagging, + "PublicBucket_object_version_actions": PublicBucket_object_version_actions, + "PublicBucket_object_version_actions_public_acl": PublicBucket_object_version_actions_public_acl, + "PutBucketVersioning_non_existing_bucket": PutBucketVersioning_non_existing_bucket, + "PutBucketVersioning_invalid_status": PutBucketVersioning_invalid_status, + "PutBucketVersioning_success_enabled": PutBucketVersioning_success_enabled, + "PutBucketVersioning_success_suspended": PutBucketVersioning_success_suspended, + "GetBucketVersioning_non_existing_bucket": GetBucketVersioning_non_existing_bucket, + "GetBucketVersioning_empty_response": GetBucketVersioning_empty_response, + "GetBucketVersioning_success": GetBucketVersioning_success, + "GetBucketVersioning_non_owner_access_denied": GetBucketVersioning_non_owner_access_denied, + "GetBucketVersioning_with_policy_access": GetBucketVersioning_with_policy_access, + "GetBucketVersioning_with_acl_access": GetBucketVersioning_with_acl_access, + "Versioning_DeleteBucket_not_empty": Versioning_DeleteBucket_not_empty, + "Versioning_PutObject_suspended_null_versionId_obj": Versioning_PutObject_suspended_null_versionId_obj, + "Versioning_PutObject_null_versionId_obj": Versioning_PutObject_null_versionId_obj, + "Versioning_PutObject_overwrite_null_versionId_obj": Versioning_PutObject_overwrite_null_versionId_obj, + "Versioning_PutObject_success": Versioning_PutObject_success, + "Versioning_PutObject_dir_object_new_version_resets_attributes": Versioning_PutObject_dir_object_new_version_resets_attributes, + "Versioning_PutObject_new_version_resets_attributes": Versioning_PutObject_new_version_resets_attributes, + "Versioning_PutObject_over_delete_marker_resets_attributes": Versioning_PutObject_over_delete_marker_resets_attributes, + "Versioning_PutObject_suspended_null_version_resets_attributes": Versioning_PutObject_suspended_null_version_resets_attributes, + "Versioning_CopyObject_invalid_versionId": Versioning_CopyObject_invalid_versionId, + "Versioning_CopyObject_encoded_versionid_separator_invalid_versionId": Versioning_CopyObject_encoded_versionid_separator_invalid_versionId, + "Versioning_CopyObject_success": Versioning_CopyObject_success, + "Versioning_CopyObject_non_existing_version_id": Versioning_CopyObject_non_existing_version_id, + "Versioning_CopyObject_from_an_object_version": Versioning_CopyObject_from_an_object_version, + "Versioning_CopyObject_from_a_delete_marker": Versioning_CopyObject_from_a_delete_marker, + "Versioning_CopyObject_to_itself": Versioning_CopyObject_to_itself, + "Versioning_CopyObject_to_itself_from_the_current_version": Versioning_CopyObject_to_itself_from_the_current_version, + "Versioning_CopyObject_special_chars": Versioning_CopyObject_special_chars, + "Versioning_HeadObject_invalid_versionId": Versioning_HeadObject_invalid_versionId, + "Versioning_HeadObject_non_existing_object_version": Versioning_HeadObject_non_existing_object_version, + "Versioning_HeadObject_invalid_parent": Versioning_HeadObject_invalid_parent, + "Versioning_HeadObject_success": Versioning_HeadObject_success, + "Versioning_HeadObject_dir_object_versions": Versioning_HeadObject_dir_object_versions, + "Versioning_HeadObject_without_versionId": Versioning_HeadObject_without_versionId, + "Versioning_HeadObject_null_versionId_obj": Versioning_HeadObject_null_versionId_obj, + "Versioning_HeadObject_null_version_without_versionId": Versioning_HeadObject_null_version_without_versionId, + "Versioning_HeadObject_delete_marker": Versioning_HeadObject_delete_marker, + "Versioning_GetObject_invalid_versionId": Versioning_GetObject_invalid_versionId, + "Versioning_GetObject_non_existing_object_version": Versioning_GetObject_non_existing_object_version, + "Versioning_GetObject_success": Versioning_GetObject_success, + "Versioning_GetObject_delete_marker_without_versionId": Versioning_GetObject_delete_marker_without_versionId, + "Versioning_GetObject_delete_marker": Versioning_GetObject_delete_marker, + "Versioning_unversioned_bucket_omits_versionId": Versioning_unversioned_bucket_omits_versionId, + "Versioning_GetObject_null_version_without_versionId": Versioning_GetObject_null_version_without_versionId, + "Versioning_GetObject_null_versionId_obj": Versioning_GetObject_null_versionId_obj, + "Versioning_PutObjectTagging_invalid_versionId": Versioning_PutObjectTagging_invalid_versionId, + "Versioning_PutObjectTagging_non_existing_object_version": Versioning_PutObjectTagging_non_existing_object_version, + "Versioning_PutGetDeleteObjectTagging_delete_marker": Versioning_PutGetDeleteObjectTagging_delete_marker, + "Versioning_GetObjectTagging_invalid_versionId": Versioning_GetObjectTagging_invalid_versionId, + "Versioning_GetObjectTagging_non_existing_object_version": Versioning_GetObjectTagging_non_existing_object_version, + "Versioning_DeleteObjectTagging_invalid_versionId": Versioning_DeleteObjectTagging_invalid_versionId, + "Versioning_DeleteObjectTagging_non_existing_object_version": Versioning_DeleteObjectTagging_non_existing_object_version, + "Versioning_PutGetDeleteObjectTagging_success": Versioning_PutGetDeleteObjectTagging_success, + "Versioning_ObjectTagging_trailing_slash_counterpart": Versioning_ObjectTagging_trailing_slash_counterpart, + "Versioning_GetObjectAttributes_invalid_versionId": Versioning_GetObjectAttributes_invalid_versionId, + "Versioning_GetObjectAttributes_object_version": Versioning_GetObjectAttributes_object_version, + "Versioning_GetObjectAttributes_delete_marker": Versioning_GetObjectAttributes_delete_marker, + "Versioning_DeleteObject_invalid_versionId": Versioning_DeleteObject_invalid_versionId, + "Versioning_DeleteObject_delete_object_version": Versioning_DeleteObject_delete_object_version, + "Versioning_DeleteObject_latest_version_with_null_version": Versioning_DeleteObject_latest_version_with_null_version, + "Versioning_DeleteObject_latest_version_null_version_order": Versioning_DeleteObject_latest_version_null_version_order, + "Versioning_DeleteObject_promoted_version_attributes": Versioning_DeleteObject_promoted_version_attributes, + "Versioning_DeleteObject_promoted_version_last_modified": Versioning_DeleteObject_promoted_version_last_modified, + "Versioning_DeleteObject_delete_marker_last_modified": Versioning_DeleteObject_delete_marker_last_modified, + "Versioning_DeleteObject_dir_object_latest_version": Versioning_DeleteObject_dir_object_latest_version, + "Versioning_DeleteObject_non_existing_object": Versioning_DeleteObject_non_existing_object, + "Versioning_DeleteObject_implicit_dir": Versioning_DeleteObject_implicit_dir, + "Versioning_DeleteObject_trailing_slash_counterpart": Versioning_DeleteObject_trailing_slash_counterpart, + "Versioning_DeleteObject_delete_a_delete_marker": Versioning_DeleteObject_delete_a_delete_marker, + "Versioning_DeleteObject_dir_object_with_children": Versioning_DeleteObject_dir_object_with_children, + "Versioning_Delete_null_versionId_object": Versioning_Delete_null_versionId_object, + "Versioning_DeleteObject_nested_dir_object": Versioning_DeleteObject_nested_dir_object, + "Versioning_DeleteObject_non_existing_objects": Versioning_DeleteObject_non_existing_objects, + "Versioning_DeleteObject_suspended": Versioning_DeleteObject_suspended, + "Versioning_DeleteObject_never_versioned_bucket": Versioning_DeleteObject_never_versioned_bucket, + "Versioning_DeleteObjects_success": Versioning_DeleteObjects_success, + "Versioning_DeleteObjects_delete_deleteMarkers": Versioning_DeleteObjects_delete_deleteMarkers, + "Versioning_DeleteObjects_never_versioned_bucket": Versioning_DeleteObjects_never_versioned_bucket, + "ListObjectVersions_non_existing_bucket": ListObjectVersions_non_existing_bucket, + "ListObjectVersions_negative_max_keys": ListObjectVersions_negative_max_keys, + "ListObjectVersions_list_single_object_versions": ListObjectVersions_list_single_object_versions, + "ListObjectVersions_list_multiple_object_versions": ListObjectVersions_list_multiple_object_versions, + "ListObjectVersions_dir_object_with_children": ListObjectVersions_dir_object_with_children, + "ListObjectVersions_multiple_object_versions_truncated": ListObjectVersions_multiple_object_versions_truncated, + "ListObjectVersions_with_delete_markers": ListObjectVersions_with_delete_markers, + "ListObjectVersions_containing_null_versionId_obj": ListObjectVersions_containing_null_versionId_obj, + "ListObjectVersions_paginate_null_version": ListObjectVersions_paginate_null_version, + "ListObjectVersions_single_null_versionId_object": ListObjectVersions_single_null_versionId_object, + "ListObjectVersions_checksum": ListObjectVersions_checksum, + "Versioning_Multipart_Upload_success": Versioning_Multipart_Upload_success, + "Versioning_Multipart_Upload_overwrite_an_object": Versioning_Multipart_Upload_overwrite_an_object, + "Versioning_Multipart_Upload_suspended_overwrite_versioned_object": Versioning_Multipart_Upload_suspended_overwrite_versioned_object, + "Versioning_Multipart_Upload_overwrite_keeps_previous_version_metadata": Versioning_Multipart_Upload_overwrite_keeps_previous_version_metadata, + "Versioning_UploadPartCopy_invalid_versionId": Versioning_UploadPartCopy_invalid_versionId, + "Versioning_UploadPartCopy_encoded_versionid_separator_invalid_versionId": Versioning_UploadPartCopy_encoded_versionid_separator_invalid_versionId, + "Versioning_UploadPartCopy_non_existing_versionId": Versioning_UploadPartCopy_non_existing_versionId, + "Versioning_UploadPartCopy_from_an_object_version": Versioning_UploadPartCopy_from_an_object_version, + "Versioning_UploadPartCopy_from_a_delete_marker": Versioning_UploadPartCopy_from_a_delete_marker, + "Versioning_object_lock_not_enabled_on_bucket_creation": Versioning_object_lock_not_enabled_on_bucket_creation, + "Versioning_Enable_object_lock": Versioning_Enable_object_lock, + "Versioning_status_switch_to_suspended_with_object_lock": Versioning_status_switch_to_suspended_with_object_lock, + "Versioning_PutObjectRetention_invalid_versionId": Versioning_PutObjectRetention_invalid_versionId, + "Versioning_PutObjectRetention_non_existing_object_version": Versioning_PutObjectRetention_non_existing_object_version, + "Versioning_GetObjectRetention_invalid_versionId": Versioning_GetObjectRetention_invalid_versionId, + "Versioning_GetObjectRetention_non_existing_object_version": Versioning_GetObjectRetention_non_existing_object_version, + "Versioning_Put_GetObjectRetention_delete_marker": Versioning_Put_GetObjectRetention_delete_marker, + "Versioning_Put_GetObjectRetention_success": Versioning_Put_GetObjectRetention_success, + "Versioning_PutObjectLegalHold_invalid_versionId": Versioning_PutObjectLegalHold_invalid_versionId, + "Versioning_PutObjectLegalHold_non_existing_object_version": Versioning_PutObjectLegalHold_non_existing_object_version, + "Versioning_GetObjectLegalHold_invalid_versionId": Versioning_GetObjectLegalHold_invalid_versionId, + "Versioning_GetObjectLegalHold_non_existing_object_version": Versioning_GetObjectLegalHold_non_existing_object_version, + "Versioning_PutGetObjectLegalHold_delete_marker": Versioning_PutGetObjectLegalHold_delete_marker, + "Versioning_Put_GetObjectLegalHold_success": Versioning_Put_GetObjectLegalHold_success, + "Versioning_WORM_obj_version_locked_with_legal_hold": Versioning_WORM_obj_version_locked_with_legal_hold, + "Versioning_WORM_dir_object_lock_headers": Versioning_WORM_dir_object_lock_headers, + "Versioning_WORM_obj_version_locked_with_governance_retention": Versioning_WORM_obj_version_locked_with_governance_retention, + "Versioning_WORM_obj_version_locked_with_compliance_retention": Versioning_WORM_obj_version_locked_with_compliance_retention, + "Versioning_WORM_delete_marker_locked_object_legal_hold": Versioning_WORM_delete_marker_locked_object_legal_hold, + "Versioning_WORM_delete_marker_locked_object_governance_retention": Versioning_WORM_delete_marker_locked_object_governance_retention, + "Versioning_WORM_delete_marker_locked_object_compliance_retention": Versioning_WORM_delete_marker_locked_object_compliance_retention, + "Versioning_WORM_PutObject_overwrite_locked_object": Versioning_WORM_PutObject_overwrite_locked_object, + "Versioning_WORM_CopyObject_overwrite_locked_object": Versioning_WORM_CopyObject_overwrite_locked_object, + "Versioning_WORM_CopyObject_to_itself_locked_object": Versioning_WORM_CopyObject_to_itself_locked_object, + "Versioning_WORM_CompleteMultipartUpload_overwrite_locked_object": Versioning_WORM_CompleteMultipartUpload_overwrite_locked_object, + "Versioning_WORM_remove_delete_marker_under_bucket_default_retention": Versioning_WORM_remove_delete_marker_under_bucket_default_retention, + "Versioning_WORM_trailing_slash_counterpart": Versioning_WORM_trailing_slash_counterpart, + "Versioning_WORM_null_version_locked_with_legal_hold": Versioning_WORM_null_version_locked_with_legal_hold, + "Versioning_WORM_PutObject_new_version_lock_settings": Versioning_WORM_PutObject_new_version_lock_settings, + "Versioning_WORM_DeleteObject_promoted_version_lock_settings": Versioning_WORM_DeleteObject_promoted_version_lock_settings, + "Versioning_AccessControl_GetObjectVersion": Versioning_AccessControl_GetObjectVersion, + "Versioning_AccessControl_HeadObjectVersion": Versioning_AccessControl_HeadObjectVersion, + "Versioning_AccessControl_object_tagging_policy": Versioning_AccessControl_object_tagging_policy, + "Versioning_AccessControl_DeleteObject_policy": Versioning_AccessControl_DeleteObject_policy, + "Versioning_AccessControl_GetObjectAttributes_policy": Versioning_AccessControl_GetObjectAttributes_policy, + "Versioning_concurrent_upload_object": Versioning_concurrent_upload_object, + "RouterPutPartNumberWithoutUploadId": RouterPutPartNumberWithoutUploadId, + "RouterPostRoot": RouterPostRoot, + "RouterPostObjectWithoutQuery": RouterPostObjectWithoutQuery, + "RouterPUTObjectOnlyUploadId": RouterPUTObjectOnlyUploadId, + "RouterGetUploadsWithKey": RouterGetUploadsWithKey, + "RouterCopySourceNotAllowed": RouterCopySourceNotAllowed, + "RouterListVersionsWithKey": RouterListVersionsWithKey, + "RouterObjectAnnotationNotImplemented": RouterObjectAnnotationNotImplemented, + "RouterRenameObjectNotImplemented": RouterRenameObjectNotImplemented, + "RouterObjectTorrentMethodNotAllowed": RouterObjectTorrentMethodNotAllowed, + "UnsignedStreaminPayloadTrailer_malformed_trailer": UnsignedStreaminPayloadTrailer_malformed_trailer, + "UnsignedStreamingPayloadTrailer_aborted_connection": UnsignedStreamingPayloadTrailer_aborted_connection, + "UnsignedStreamingPayloadTrailer_missing_invalid_dec_content_length": UnsignedStreamingPayloadTrailer_missing_invalid_dec_content_length, + "UnsignedStreamingPayloadTrailer_invalid_trailing_checksum": UnsignedStreamingPayloadTrailer_invalid_trailing_checksum, + "UnsignedStreamingPayloadTrailer_incorrect_trailing_checksum": UnsignedStreamingPayloadTrailer_incorrect_trailing_checksum, + "UnsignedStreamingPayloadTrailer_multiple_checksum_headers": UnsignedStreamingPayloadTrailer_multiple_checksum_headers, + "UnsignedStreamingPayloadTrailer_sdk_algo_and_trailer_mismatch": UnsignedStreamingPayloadTrailer_sdk_algo_and_trailer_mismatch, + "UnsignedStreamingPayloadTrailer_incomplete_body": UnsignedStreamingPayloadTrailer_incomplete_body, + "UnsignedStreamingPayloadTrailer_invalid_chunk_size": UnsignedStreamingPayloadTrailer_invalid_chunk_size, + "UnsignedStreamingPayloadTrailer_content_length_payload_size_mismatch": UnsignedStreamingPayloadTrailer_content_length_payload_size_mismatch, + "UnsignedStreamingPayloadTrailer_no_trailer_should_calculate_crc64nvme": UnsignedStreamingPayloadTrailer_no_trailer_should_calculate_crc64nvme, + "UnsignedStreamingPayloadTrailer_no_payload_trailer_only_headers": UnsignedStreamingPayloadTrailer_no_payload_trailer_only_headers, + "UnsignedStreamingPayloadTrailer_success_both_sdk_algo_and_trailer": UnsignedStreamingPayloadTrailer_success_both_sdk_algo_and_trailer, + "UnsignedStreamingPayloadTrailer_strips_aws_chunked_content_encoding": UnsignedStreamingPayloadTrailer_strips_aws_chunked_content_encoding, + "UnsignedStreamingPayloadTrailer_UploadPart_no_trailer_composite_checksum": UnsignedStreamingPayloadTrailer_UploadPart_no_trailer_composite_checksum, + "UnsignedStreamingPayloadTrailer_UploadPart_no_trailer_full_object": UnsignedStreamingPayloadTrailer_UploadPart_no_trailer_full_object, + "UnsignedStreamingPayloadTrailer_UploadPart_trailer_and_mp_algo_mismatch": UnsignedStreamingPayloadTrailer_UploadPart_trailer_and_mp_algo_mismatch, + "UnsignedStreamingPayloadTrailer_UploadPart_success_with_trailer": UnsignedStreamingPayloadTrailer_UploadPart_success_with_trailer, + "UnsignedStreamingPayloadTrailer_not_allowed": UnsignedStreamingPayloadTrailer_not_allowed, + "SignedStreamingPayload_invalid_encoding": SignedStreamingPayload_invalid_encoding, + "SignedStreamingPayload_invalid_chunk_size": SignedStreamingPayload_invalid_chunk_size, + "SignedStreamingPayload_decoded_content_length_mismatch": SignedStreamingPayload_decoded_content_length_mismatch, + "SignedStreamingPayloadTrailer_malformed_trailer": SignedStreamingPayloadTrailer_malformed_trailer, + "SignedStreamingPayloadTrailer_incomplete_body": SignedStreamingPayloadTrailer_incomplete_body, + "SignedStreamingPayloadTrailer_missing_x_amz_trailer_header": SignedStreamingPayloadTrailer_missing_x_amz_trailer_header, + "SignedStreamingPayloadTrailer_invalid_checksum": SignedStreamingPayloadTrailer_invalid_checksum, + "SignedStreamingPayloadTrailer_bad_digest": SignedStreamingPayloadTrailer_bad_digest, + "SignedStreamingPayloadTrailer_success": SignedStreamingPayloadTrailer_success, + "NoAclMode_CreateBucket_with_acl": NoAclMode_CreateBucket_with_acl, + "NoAclMode_PutBucketAcl": NoAclMode_PutBucketAcl, + "Server_large_http_header": Server_large_http_header, + "PostObject_invalid_content_type": PostObject_invalid_content_type, + "PostObject_missing_boundary": PostObject_missing_boundary, + "PostObject_partial_auth_fields": PostObject_partial_auth_fields, + "PostObject_invalid_algorithm": PostObject_invalid_algorithm, + "PostObject_invalid_date": PostObject_invalid_date, + "PostObject_invalid_credential_format": PostObject_invalid_credential_format, + "PostObject_incorrect_region": PostObject_incorrect_region, + "PostObject_non_existing_access_key": PostObject_non_existing_access_key, + "PostObject_signature_mismatch": PostObject_signature_mismatch, + "PostObject_expired_due_to_date": PostObject_expired_due_to_date, + "PostObject_access_denied": PostObject_access_denied, + "PostObject_bucket_policy_object_resource": PostObject_bucket_policy_object_resource, + "PostObject_bucket_policy_explicit_deny": PostObject_bucket_policy_explicit_deny, + "PostObject_tagging_requires_put_object_tagging": PostObject_tagging_requires_put_object_tagging, + "PostObject_tagging_bucket_policy_explicit_deny": PostObject_tagging_bucket_policy_explicit_deny, + "PostObject_empty_tag_set_requires_only_put_object": PostObject_empty_tag_set_requires_only_put_object, + "PostObject_invalid_object_names": PostObject_invalid_object_names, + "PostObject_policy_access_control": PostObject_policy_access_control, + "PostObject_policy_expired": PostObject_policy_expired, + "PostObject_invalid_policy_document": PostObject_invalid_policy_document, + "PostObject_policy_condition_key_mismatch": PostObject_policy_condition_key_mismatch, + "PostObject_policy_extra_field": PostObject_policy_extra_field, + "PostObject_policy_missing_bucket_condition": PostObject_policy_missing_bucket_condition, + "PostObject_policy_content_length_too_large": PostObject_policy_content_length_too_large, + "PostObject_policy_content_length_too_small": PostObject_policy_content_length_too_small, + "PostObject_success": PostObject_success, + "PostObject_success_status_200": PostObject_success_status_200, + "PostObject_success_status_201": PostObject_success_status_201, + "PostObject_should_ignore_anything_after_file": PostObject_should_ignore_anything_after_file, + "PostObject_success_with_meta_properties": PostObject_success_with_meta_properties, + "PostObject_default_content_type": PostObject_default_content_type, + "PostObject_invalid_website_redirect_location": PostObject_invalid_website_redirect_location, + "PostObject_invalid_tagging": PostObject_invalid_tagging, + "PostObject_success_with_tagging": PostObject_success_with_tagging, + "PostObject_invalid_checksum_value": PostObject_invalid_checksum_value, + "PostObject_invalid_checksum_algorithm": PostObject_invalid_checksum_algorithm, + "PostObject_multiple_checksum_headers": PostObject_multiple_checksum_headers, + "PostObject_checksums_success": PostObject_checksums_success, + "PostObject_success_double_dash_boundary": PostObject_success_double_dash_boundary, + } +} diff --git a/website/handler.go b/website/handler.go new file mode 100644 index 0000000..b7e48a0 --- /dev/null +++ b/website/handler.go @@ -0,0 +1,595 @@ +// Copyright 2026 Versity Software +// This file is licensed under the Apache License, Version 2.0 +// (the "License"); you may not use this file except in compliance +// with the License. You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +package website + +import ( + "errors" + "fmt" + "io" + "net/http" + "net/url" + "strconv" + "strings" + + "github.com/aws/aws-sdk-go-v2/service/s3" + "github.com/gofiber/fiber/v3" + "github.com/versity/versitygw/auth" + "github.com/versity/versitygw/backend" + "github.com/versity/versitygw/debuglogger" + "github.com/versity/versitygw/s3api/middlewares" + "github.com/versity/versitygw/s3api/utils" + "github.com/versity/versitygw/s3err" + "github.com/versity/versitygw/s3response" +) + +var websiteAllowedMethods = []string{fiber.MethodGet, fiber.MethodHead, fiber.MethodOptions} + +type websiteController struct { + be backend.Backend + domain string + domainSuffix string + applyCORS fiber.Handler +} + +// newWebsiteController returns a controller that serves static website content. +// It resolves the bucket name from the Host header using the configured domain, +// fetches the website configuration, and serves objects accordingly. +// +// Virtual-host routing with --website-domain example.com: +// - Host "blog.example.com" -> bucket "blog" +// - Host "example.com" -> bucket "example.com" (apex) +// +// Catch-all mode (--website-domain omitted or empty): +// - Host "blog.example.com" -> bucket "blog.example.com" +// - Host "mysite.org" -> bucket "mysite.org" +func newWebsiteController(be backend.Backend, domain string) *websiteController { + controller := &websiteController{ + be: be, + domain: domain, + domainSuffix: "." + domain, + } + controller.applyCORS = middlewares.ApplyBucketCORS(be, controller.resolveBucket, "") + return controller +} + +func (c *websiteController) Get(ctx fiber.Ctx) error { + return c.serve(ctx, c.getObject) +} + +func (c *websiteController) Head(ctx fiber.Ctx) error { + return c.serve(ctx, c.headObject) +} + +func (c *websiteController) Options(ctx fiber.Ctx) error { + bucket, err := c.resolveBucket(ctx) + if err != nil { + return sendError(ctx, err) + } + + origin := ctx.Get("Origin") + method := auth.CORSHTTPMethod(ctx.Get("Access-Control-Request-Method")) + headers := ctx.Get("Access-Control-Request-Headers") + + if origin == "" { + debuglogger.Logf("origin is missing: %v", origin) + return sendError(ctx, s3err.GetAPIError(s3err.ErrMissingCORSOrigin)) + } + + if !method.IsValid() { + debuglogger.Logf("invalid cors method: %s", method) + return sendError(ctx, s3err.GetInvalidCORSMethodErr(method.String())) + } + + parsedHeaders, err := auth.ParseCORSHeaders(headers) + if err != nil { + return sendError(ctx, err) + } + + cors, err := c.be.GetBucketCors(ctx.RequestCtx(), bucket) + if err != nil { + debuglogger.Logf("failed to get bucket cors: %v", err) + if errors.Is(err, s3err.GetAPIError(s3err.ErrNoSuchCORSConfiguration)) { + err = s3err.GetAccessForbiddenErr(s3err.ErrCORSIsNotEnabled, http.MethodOptions, s3err.ResourceTypeBucket) + debuglogger.Logf("bucket cors is not set: %v", err) + } + return sendError(ctx, err) + } + + corsConfig, err := auth.ParseCORSOutput(cors) + if err != nil { + return sendError(ctx, err) + } + + allowConfig, err := corsConfig.IsAllowed(origin, method, parsedHeaders, s3err.ResourceTypeObject) + if err != nil { + debuglogger.Logf("cors access forbidden: %v", err) + return sendError(ctx, err) + } + + setCORSPreflightHeaders(ctx, allowConfig) + ctx.Status(http.StatusOK) + return nil +} + +func registerWebsiteRoutes(app *fiber.App, be backend.Backend, domain string) { + controller := newWebsiteController(be, domain) + + // percent-decode the request path, so object keys containing special + // characters resolve to the actual key. The s3 api and admin servers + // mount the same middleware. + app.Use("*", decodeURL) + + app.Head("*", controller.Head) + app.Get("*", controller.Get) + app.Options("*", controller.Options) + app.All("*", controller.MethodNotAllowed) +} + +// decodeURL wraps the shared DecodeURL middleware to continue the chain and to +// report malformed percent-encoding as an html error page. +func decodeURL(ctx fiber.Ctx) error { + if err := middlewares.DecodeURL(ctx); err != nil { + debuglogger.Logf("failed to unescape the request path: %v", err) + return sendError(ctx, s3err.GetAPIError(s3err.ErrInvalidURI)) + } + + return ctx.Next() +} + +func setCORSPreflightHeaders(ctx fiber.Ctx, allowConfig *auth.CORSAllowanceConfig) { + ctx.Set("Access-Control-Allow-Origin", allowConfig.Origin) + ctx.Set("Access-Control-Allow-Methods", allowConfig.Methods) + ctx.Set("Access-Control-Expose-Headers", allowConfig.ExposedHeaders) + ctx.Set("Access-Control-Allow-Credentials", allowConfig.AllowCredentials) + ctx.Set("Access-Control-Allow-Headers", allowConfig.AllowHeaders) + ctx.Set("Vary", middlewares.VaryHdr) + if allowConfig.MaxAge != nil { + ctx.Set("Access-Control-Max-Age", strconv.Itoa(int(*allowConfig.MaxAge))) + } +} + +func (c *websiteController) MethodNotAllowed(ctx fiber.Ctx) error { + return sendError(ctx, s3err.GetMethodNotAllowedErr(ctx.Method(), s3err.ResourceTypeObject, websiteAllowedMethods)) +} + +type websiteRequestInfo struct { + bucket string + config *s3response.WebsiteConfiguration + key string +} + +type websiteObjectReader func(ctx fiber.Ctx, bucket, key string) websiteResult + +func (c *websiteController) serve(ctx fiber.Ctx, readObject websiteObjectReader) error { + req, err := c.resolveRequest(ctx) + if err != nil { + return sendError(ctx, err) + } + + if err := c.applyCORS(ctx); err != nil { + return sendError(ctx, err) + } + + if req.config.RedirectAllRequestsTo != nil { + return handleRedirectAll(ctx, req.config.RedirectAllRequestsTo, req.key) + } + + if rule := req.config.MatchPrefetchRoutingRule(req.key); rule != nil { + return applyRedirect(ctx, rule.Redirect, rule.Condition, req.key) + } + + resolvedKey := resolveIndexKey(req.key, req.config) + result := readObject(ctx, req.bucket, resolvedKey) + if result.Err == nil { + return serveWebsiteResult(ctx, req.bucket, req.config, result, readObject) + } + if result.StatusCode >= http.StatusInternalServerError { + return sendError(ctx, result.Err) + } + + if rule := req.config.MatchPostErrorRoutingRule(req.key, result.StatusCode); rule != nil { + return applyRedirect(ctx, rule.Redirect, rule.Condition, req.key) + } + + return serveWebsiteResult(ctx, req.bucket, req.config, result, readObject) +} + +func (c *websiteController) resolveRequest(ctx fiber.Ctx) (*websiteRequestInfo, error) { + bucket, err := c.resolveBucket(ctx) + if err != nil { + return nil, err + } + + key := strings.TrimPrefix(ctx.Path(), "/") + if err := validateWebsiteNames(bucket, key); err != nil { + return nil, err + } + + data, err := c.be.GetBucketWebsite(ctx.RequestCtx(), bucket) + if err != nil { + return nil, err + } + + config, err := s3response.ParseWebsiteConfigOutput(data) + if err != nil { + return nil, err + } + + return &websiteRequestInfo{ + bucket: bucket, + config: config, + key: key, + }, nil +} + +func validateWebsiteNames(bucket, key string) error { + if !utils.IsValidBucketName(bucket) { + return s3err.GetBucketErr(s3err.ErrInvalidBucketName, bucket) + } + if key != "" && !utils.IsObjectNameValid(key) { + return s3err.GetAPIError(s3err.ErrBadRequest) + } + + return nil +} + +// resolveBucket extracts the bucket name from the request host header. +// +// It strips the port when present before applying website endpoint routing. +// +// When domain is set: +// - If host equals the domain exactly, the bucket IS the domain (apex). +// - If host ends with ".", the bucket is the subdomain part. +// - Otherwise, no bucket can be resolved. +// +// When domain is empty (catch-all mode): +// - The full hostname is used as the bucket name. +func (c *websiteController) resolveBucket(ctx fiber.Ctx) (string, error) { + host := ctx.Host() + if host == "" { + ctx.Set("Location", c.noBucketLocation(ctx, host)) + return "", s3err.GetAPIError(s3err.ErrNoBucketInRequest) + } + + // Strip port from host if present. Be careful with IPv6: only strip if the + // last colon is not inside brackets. + host = stripHostPort(host) + + if c.domain == "" { + return host, nil + } + + if strings.EqualFold(host, c.domain) { + return c.domain, nil + } + + lowerHost := strings.ToLower(host) + lowerDomainSuffix := strings.ToLower(c.domainSuffix) + if strings.HasSuffix(lowerHost, lowerDomainSuffix) { + bucket := host[:len(host)-len(c.domainSuffix)] + if bucket != "" && !strings.Contains(bucket, ".") { + return bucket, nil + } + } + + ctx.Set("Location", c.noBucketLocation(ctx, ctx.Host())) + return "", s3err.GetAPIError(s3err.ErrNoBucketInRequest) +} + +func (c *websiteController) noBucketLocation(ctx fiber.Ctx, host string) string { + locationHost := c.domain + if locationHost == "" { + locationHost = stripHostPort(host) + } + if locationHost == "" { + return "/" + } + if c.domain != "" { + if port := hostPort(host); port != "" { + locationHost += ":" + port + } + } + + return fmt.Sprintf("%s://%s/", ctx.Scheme(), locationHost) +} + +func stripHostPort(host string) string { + if idx := strings.LastIndex(host, ":"); idx != -1 && !strings.Contains(host[idx:], "]") { + return host[:idx] + } + + return host +} + +func hostPort(host string) string { + if idx := strings.LastIndex(host, ":"); idx != -1 && !strings.Contains(host[idx:], "]") { + return host[idx+1:] + } + + return "" +} + +type websiteResult struct { + Key string + StatusCode int + Object websiteObject + Err error +} + +type websiteObject struct { + Body io.ReadCloser + Headers map[string]*string + Metadata map[string]string + WebsiteRedirectLocation *string +} + +func resolveIndexKey(key string, config *s3response.WebsiteConfiguration) string { + if config.IndexDocument != nil && config.IndexDocument.Suffix != "" { + if key == "" || strings.HasSuffix(key, "/") { + return key + config.IndexDocument.Suffix + } + } + + return key +} + +func (c *websiteController) getObject(ctx fiber.Ctx, bucket, key string) websiteResult { + if err := auth.VerifyPublicAccess(ctx, c.be, []auth.Action{auth.GetObjectAction}, auth.PermissionRead, bucket, key); err != nil { + return websiteResult{ + Key: key, + StatusCode: statusCodeFromError(err), + Err: err, + } + } + + result, err := c.be.GetObject(ctx.RequestCtx(), &s3.GetObjectInput{ + Bucket: &bucket, + Key: &key, + }) + if err != nil { + return websiteResult{ + Key: key, + StatusCode: statusCodeFromError(err), + Err: err, + } + } + + return websiteResult{ + Key: key, + StatusCode: http.StatusOK, + Object: websiteObject{ + Body: result.Body, + Headers: getObjectHeaders(result), + Metadata: result.Metadata, + WebsiteRedirectLocation: result.WebsiteRedirectLocation, + }, + } +} + +func (c *websiteController) headObject(ctx fiber.Ctx, bucket, key string) websiteResult { + if err := auth.VerifyPublicAccess(ctx, c.be, []auth.Action{auth.GetObjectAction}, auth.PermissionRead, bucket, key); err != nil { + return websiteResult{ + Key: key, + StatusCode: statusCodeFromError(err), + Err: err, + } + } + + result, err := c.be.HeadObject(ctx.RequestCtx(), &s3.HeadObjectInput{ + Bucket: &bucket, + Key: &key, + }) + if err != nil { + return websiteResult{ + Key: key, + StatusCode: statusCodeFromError(err), + Err: err, + } + } + + return websiteResult{ + Key: key, + StatusCode: http.StatusOK, + Object: websiteObject{ + Headers: headObjectHeaders(result), + Metadata: result.Metadata, + WebsiteRedirectLocation: result.WebsiteRedirectLocation, + }, + } +} + +func statusCodeFromError(err error) int { + var serr s3err.S3Error + if errors.As(err, &serr) { + return serr.StatusCode() + } + + return http.StatusInternalServerError +} + +// handleRedirectAll sends a 301 redirect for RedirectAllRequestsTo configuration. +func handleRedirectAll(ctx fiber.Ctx, redirect *s3response.RedirectAllRequestsTo, key string) error { + protocol := redirect.Protocol + if protocol == "" { + protocol = ctx.Scheme() + } + + location := websiteLocation(protocol, redirect.HostName, key, + string(ctx.Request().URI().QueryString())) + return sendRedirect(ctx, http.StatusMovedPermanently, location) +} + +// applyRedirect constructs and sends a redirect response from a routing rule. +func applyRedirect(ctx fiber.Ctx, redirect *s3response.Redirect, condition *s3response.RoutingRuleCondition, originalKey string) error { + protocol := redirect.Protocol + if protocol == "" { + protocol = ctx.Scheme() + } + + host := redirect.HostName + if host == "" { + host = ctx.Host() + } + + key := originalKey + if redirect.ReplaceKeyWith != "" { + key = redirect.ReplaceKeyWith + } else if redirect.ReplaceKeyPrefixWith != "" && condition != nil && condition.KeyPrefixEquals != "" { + key = redirect.ReplaceKeyPrefixWith + strings.TrimPrefix(originalKey, condition.KeyPrefixEquals) + } + + httpCode := http.StatusMovedPermanently + if redirect.HttpRedirectCode != "" { + if code, err := strconv.Atoi(redirect.HttpRedirectCode); err == nil { + httpCode = code + } + } + + location := websiteLocation(protocol, host, key, + string(ctx.Request().URI().QueryString())) + return sendRedirect(ctx, httpCode, location) +} + +// websiteLocation builds a redirect target url. The object key is +// percent-encoded, as the keys reaching this point are decoded. +func websiteLocation(protocol, host, key, query string) string { + location := url.URL{ + Scheme: protocol, + Host: host, + Path: "/" + key, + RawQuery: query, + } + + return location.String() +} + +func sendRedirect(ctx fiber.Ctx, statusCode int, location string) error { + ctx.Set("Location", location) + _, _ = utils.EnsureRequestIDs(ctx) + ctx.Status(statusCode) + return nil +} + +func getObjectHeaders(result *s3.GetObjectOutput) map[string]*string { + return map[string]*string{ + "ETag": result.ETag, + "accept-ranges": result.AcceptRanges, + "Cache-Control": result.CacheControl, + "Content-Disposition": result.ContentDisposition, + "Content-Encoding": result.ContentEncoding, + "Content-Language": result.ContentLanguage, + "Content-Length": utils.ConvertPtrToStringPtr(result.ContentLength), + "Content-Range": result.ContentRange, + "Content-Type": result.ContentType, + "Expires": result.ExpiresString, + "Last-Modified": utils.FormatDatePtrToString(result.LastModified, http.TimeFormat), + "x-amz-restore": result.Restore, + "x-amz-version-id": result.VersionId, + } +} + +func headObjectHeaders(result *s3.HeadObjectOutput) map[string]*string { + return map[string]*string{ + "ETag": result.ETag, + "accept-ranges": result.AcceptRanges, + "Cache-Control": result.CacheControl, + "Content-Disposition": result.ContentDisposition, + "Content-Encoding": result.ContentEncoding, + "Content-Language": result.ContentLanguage, + "Content-Length": utils.ConvertPtrToStringPtr(result.ContentLength), + "Content-Range": result.ContentRange, + "Content-Type": result.ContentType, + "Expires": result.ExpiresString, + "Last-Modified": utils.FormatDatePtrToString(result.LastModified, http.TimeFormat), + "x-amz-restore": result.Restore, + "x-amz-version-id": result.VersionId, + } +} + +func serveWebsiteResult(ctx fiber.Ctx, bucket string, config *s3response.WebsiteConfiguration, result websiteResult, readObject websiteObjectReader) error { + if result.Err == nil { + // Precedence: RedirectAllRequestsTo, pre-fetch routing rules, object + // redirect metadata, then post-error routing/error documents. + if location := backend.GetStringFromPtr(result.Object.WebsiteRedirectLocation); location != "" { + if result.Object.Body != nil { + _ = result.Object.Body.Close() + } + return sendRedirect(ctx, http.StatusMovedPermanently, location) + } + return serveObject(ctx, result.Object, http.StatusOK) + } + + if config.ErrorDocument != nil && config.ErrorDocument.Key != "" { + return serveErrorDocument(ctx, readObject, bucket, config.ErrorDocument.Key, result.StatusCode) + } + + return sendError(ctx, result.Err) +} + +func serveObject(ctx fiber.Ctx, object websiteObject, statusCode int) error { + ctx.Status(statusCode) + setWebsiteObjectHeaders(ctx, object) + + if object.Body == nil { + return nil + } + defer object.Body.Close() + + _, err := io.Copy(ctx.Response().BodyWriter(), object.Body) + if err != nil { + return sendError(ctx, err) + } + + return nil +} + +func setWebsiteObjectHeaders(ctx fiber.Ctx, object websiteObject) { + utils.SetMetaHeaders(ctx, object.Metadata) + for key, value := range object.Headers { + if value != nil && *value != "" { + ctx.Set(key, *value) + } + } +} + +// serveErrorDocument fetches and serves the configured error document. +func serveErrorDocument(ctx fiber.Ctx, readObject websiteObjectReader, bucket, errorDocKey string, statusCode int) error { + result := readObject(ctx, bucket, errorDocKey) + if result.Err != nil { + return sendError(ctx, result.Err) + } + + return serveObject(ctx, result.Object, statusCode) +} + +// sendError sends a simple HTML error page. +func sendError(ctx fiber.Ctx, err error) error { + requestId, hostId := utils.EnsureRequestIDs(ctx) + serr, ok := err.(s3err.S3Error) + if !ok { + debuglogger.InternalError(err) + serr = s3err.GetAPIError(s3err.ErrInternalError) + } + + ctx.Response().Header.Set("x-amz-error-code", serr.BaseError().Code) + ctx.Response().Header.Set("x-amz-error-message", serr.BaseError().Description) + if methodErr, ok := serr.(s3err.MethodNotAllowedError); ok && len(methodErr.AllowedMethods) != 0 { + ctx.Response().Header.Set("Allow", methodErr.AllowedMethodsString()) + } + utils.SetRegionMismatchHeader(ctx, serr) + + ctx.Response().Header.SetContentType(fiber.MIMETextHTMLCharsetUTF8) + return ctx.Status(serr.StatusCode()).Send(serr.HTMLBody(requestId, hostId)) +}