AWS SDK

#[allow(unreachable_code, unused_variables)]

#[cfg(test)]

mod get_reusable_delegation_set_test {

    /// This test validates that delegation set id is correctly trimmed

    /// Test ID: GetReusableDelegationSetTrimDelegationSetId

    #[::tokio::test]

    #[::tracing_test::traced_test]

    async fn get_reusable_delegation_set_trim_delegation_set_id_request() {

        let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");

        let config_builder = config_builder.region(::aws_types::region::Region::new("us-east-1"));

        let mut config_builder = config_builder;

        config_builder.set_region(Some(crate::config::Region::new("us-east-1")));

        let config = config_builder.http_client(http_client).build();

        let client = crate::Client::from_conf(config);

        let result = client

            .get_reusable_delegation_set()

            .set_id(::std::option::Option::Some("/delegationset/DELEGATIONSETID".to_owned()))

#[allow(unreachable_code, unused_variables)]

#[cfg(test)]

mod list_resource_record_sets_test {

    /// This test validates that hosted zone is correctly trimmed

    /// Test ID: ListResourceRecordSetsTrimHostedZone

    #[::tokio::test]

    #[::tracing_test::traced_test]

    async fn list_resource_record_sets_trim_hosted_zone_request() {

        let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");

        let config_builder = config_builder.region(::aws_types::region::Region::new("us-east-1"));

        let mut config_builder = config_builder;

        config_builder.set_region(Some(crate::config::Region::new("us-east-1")));

        let config = config_builder.http_client(http_client).build();

        let client = crate::Client::from_conf(config);

        let result = client

            .list_resource_record_sets()

            .set_hosted_zone_id(::std::option::Option::Some("/hostedzone/IDOFMYHOSTEDZONE".to_owned()))

repository = "https://github.com/awslabs/aws-sdk-rust"

rust-version = "1.81.0"

readme = "README.md"

[package.metadata.smithy]

codegen-version = "ci"

[package.metadata.docs.rs]

all-features = true

targets = ["x86_64-unknown-linux-gnu"]

[dependencies.aws-credential-types]

path = "../aws-credential-types"

[dependencies.aws-runtime]

path = "../aws-runtime"

features = ["event-stream", "http-02x"]

[dependencies.aws-sigv4]

path = "../aws-sigv4"

[dependencies.aws-smithy-async]

path = "../aws-smithy-async"

[dependencies.aws-smithy-checksums]

path = "../aws-smithy-checksums"

[dependencies.aws-smithy-eventstream]

path = "../aws-smithy-eventstream"

[dependencies.aws-smithy-http]

path = "../aws-smithy-http"

features = ["event-stream"]

[dependencies.aws-smithy-json]

path = "../aws-smithy-json"

[dependencies.aws-smithy-runtime]

path = "../aws-smithy-runtime"

features = ["client"]

[dependencies.aws-smithy-runtime-api]

path = "../aws-smithy-runtime-api"

features = ["client", "http-02x"]

[dependencies.aws-smithy-types]

path = "../aws-smithy-types"

[dependencies.aws-smithy-xml]

path = "../aws-smithy-xml"

version = "0.60.9"

[dependencies.aws-types]

path = "../aws-types"

[dependencies.bytes]

version = "1.4.0"

[dependencies.fastrand]

version = "2.0.0"

[dependencies.hex]

version = "0.4.3"

[dependencies.hmac]

version = "0.12"

[dependencies.http]

version = "0.2.9"

[dependencies.http-1x]

version = "1"

package = "http"

[dependencies.http-body]

version = "0.4.4"

[dependencies.http-body-1x]

version = "1"

optional = true

package = "http-body"

[dependencies.lru]

version = "0.12.2"

[dependencies.once_cell]

version = "1.16"

[dependencies.percent-encoding]

version = "2.0.0"

[dependencies.regex-lite]

version = "0.1.5"

[dependencies.sha2]

version = "0.10"

[dependencies.tracing]

version = "0.1"

[dependencies.url]

version = "2.3.1"

[dev-dependencies.async-std]

version = "1.12.0"

[dev-dependencies.aws-config]

path = "../aws-config"

features = ["behavior-version-latest"]

[dev-dependencies.aws-credential-types]

path = "../aws-credential-types"

features = ["test-util"]

[dev-dependencies.aws-runtime]

path = "../aws-runtime"

features = ["test-util"]

[dev-dependencies.aws-smithy-async]

path = "../aws-smithy-async"

features = ["test-util"]

[dev-dependencies.aws-smithy-eventstream]

path = "../aws-smithy-eventstream"

features = ["test-util"]

[dev-dependencies.aws-smithy-protocol-test]

path = "../aws-smithy-protocol-test"

[dev-dependencies.aws-smithy-runtime]

path = "../aws-smithy-runtime"

[dev-dependencies.aws-smithy-runtime-api]

path = "../aws-smithy-runtime-api"

features = ["test-util", "client", "http-02x"]

[dev-dependencies.aws-smithy-types]

path = "../aws-smithy-types"

features = ["test-util"]

[dev-dependencies.bytes-utils]

version = "0.1.0"

[dev-dependencies.futures-util]

version = "0.3.25"

features = ["alloc"]

default-features = false

[dev-dependencies.hdrhistogram]

version = "7.5.2"

[dev-dependencies.pretty_assertions]

version = "1.3.0"

[dev-dependencies.proptest]

version = "1"

[dev-dependencies.serde_json]

version = "1.0.0"

[dev-dependencies.smol]

version = "1.2.0"

[dev-dependencies.tempfile]

version = "3.2.0"

[dev-dependencies.tokio]

version = "1.23.1"

features = ["macros", "test-util", "rt-multi-thread"]

[dev-dependencies.tracing-appender]

version = "0.2.2"

[dev-dependencies.tracing-subscriber]

version = "0.3.16"

features = ["env-filter", "json"]

[dev-dependencies.tracing-test]

version = "0.2.5"

features = ["no-env-filter"]

[features]

sigv4a = ["aws-runtime/sigv4a"]

behavior-version-latest = []

rustls = ["aws-smithy-runtime/tls-rustls"]

test-util = ["aws-credential-types/test-util", "aws-smithy-runtime/test-util"]

rt-tokio = ["aws-smithy-async/rt-tokio", "aws-smithy-types/rt-tokio"]

gated-tests = []

#[allow(unreachable_code, unused_variables)]

#[cfg(test)]

mod create_multipart_upload_test {

    /// This test validates that the URI for CreateMultipartUpload is created correctly

    /// Test ID: CreateMultipartUploadUriConstruction

    #[::tokio::test]

    #[::tracing_test::traced_test]

    async fn create_multipart_upload_uri_construction_request() {

        let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");

        let config_builder = config_builder.region(::aws_types::region::Region::new("us-east-1"));

        let mut config_builder = config_builder;

        config_builder.set_region(Some(crate::config::Region::new("us-east-1")));

        let config = config_builder.http_client(http_client).build();

        let client = crate::Client::from_conf(config);

        let result = client

            .create_multipart_upload()

            .set_bucket(::std::option::Option::Some("test-bucket".to_owned()))

#[cfg(test)]

mod delete_object_tagging_test {

    /// S3 clients should escape special characters in Object Keys

    /// when the Object Key is used as a URI label binding.

    ///

    /// Test ID: S3EscapeObjectKeyInUriLabel

    #[::tokio::test]

    #[::tracing_test::traced_test]

    async fn s3_escape_object_key_in_uri_label_request() {

        let config_builder = crate::config::Config::builder()

            .with_test_defaults()

            .endpoint_url("https://s3.us-west-2.amazonaws.com");

        let mut config_builder = config_builder;

        config_builder.set_region(Some(crate::config::Region::new("us-east-1")));

        let config = config_builder.http_client(http_client).build();

        let client = crate::Client::from_conf(config);

        let result = client

            .delete_object_tagging()

            .set_bucket(::std::option::Option::Some("mybucket".to_owned()))

            .set_key(::std::option::Option::Some("my key.txt".to_owned()))

            .send()

            .await;

        let _ = dbg!(result);

        let http_request = request_receiver.expect_request();

        let expected_query_params = &["tagging"];

        ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_query_string(&http_request, expected_query_params));

        let body = http_request.body().bytes().expect("body should be strict");

        // No body.

        ::pretty_assertions::assert_eq!(&body, &bytes::Bytes::new());

        let uri: ::http::Uri = http_request.uri().parse().expect("invalid URI sent");

        ::pretty_assertions::assert_eq!(http_request.method(), "DELETE", "method was incorrect");

        ::pretty_assertions::assert_eq!(uri.path(), "/my%20key.txt", "path was incorrect");

        ::pretty_assertions::assert_eq!(uri.host().expect("host should be set"), "mybucket.s3.us-west-2.amazonaws.com");

    }

    /// S3 clients should preserve an Object Key representing a path

    /// when the Object Key is used as a URI label binding, but still

    /// escape special characters.

    ///

    /// Test ID: S3EscapePathObjectKeyInUriLabel

    #[::tokio::test]

    #[::tracing_test::traced_test]

    async fn s3_escape_path_object_key_in_uri_label_request() {

        let config_builder = crate::config::Config::builder()

            .with_test_defaults()

            .endpoint_url("https://s3.us-west-2.amazonaws.com");

        let mut config_builder = config_builder;

        config_builder.set_region(Some(crate::config::Region::new("us-east-1")));

        let config = config_builder.http_client(http_client).build();

        let client = crate::Client::from_conf(config);

        let result = client

#[allow(unreachable_code, unused_variables)]

#[cfg(test)]

mod get_object_test {

    /// https://github.com/awslabs/aws-sdk-rust/issues/818

    /// Test ID: GetObjectIfModifiedSince

    #[::tokio::test]

    #[::tracing_test::traced_test]

    async fn get_object_if_modified_since_request() {

        let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");

        let config_builder = config_builder.region(::aws_types::region::Region::new("us-east-1"));

        let mut config_builder = config_builder;

        config_builder.set_region(Some(crate::config::Region::new("us-east-1")));

        let config = config_builder.http_client(http_client).build();

        let client = crate::Client::from_conf(config);

        let result = client

            .get_object()

            .set_bucket(::std::option::Option::Some("test-bucket".to_owned()))

            .set_key(::std::option::Option::Some("object.txt".to_owned()))

            .set_if_modified_since(::std::option::Option::Some(::aws_smithy_types::DateTime::from_fractional_secs(

                1626452453, 0.123_f64,

            )))

            .send()

            .await;

        let _ = dbg!(result);

        let http_request = request_receiver.expect_request();

        let expected_headers = [("if-modified-since", "Fri, 16 Jul 2021 16:20:53 GMT")];

        ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));

        let uri: ::http::Uri = http_request.uri().parse().expect("invalid URI sent");

        ::pretty_assertions::assert_eq!(http_request.method(), "GET", "method was incorrect");

        ::pretty_assertions::assert_eq!(uri.path(), "/object.txt", "path was incorrect");

    }

    /// S3 clients should not remove dot segments from request paths.

    ///

    /// Test ID: S3PreservesLeadingDotSegmentInUriLabel

    #[::tokio::test]

    #[::tracing_test::traced_test]

    async fn s3_preserves_leading_dot_segment_in_uri_label_request() {

        let config_builder = crate::config::Config::builder()

            .with_test_defaults()

            .endpoint_url("https://s3.us-west-2.amazonaws.com");

        let mut config_builder = config_builder;

        config_builder.set_region(Some(crate::config::Region::new("us-east-1")));

        let config = config_builder.http_client(http_client).build();

        let client = crate::Client::from_conf(config);

        let result = client

            .get_object()

            .set_bucket(::std::option::Option::Some("mybucket".to_owned()))

            .set_key(::std::option::Option::Some("../key.txt".to_owned()))

            .send()

            .await;

        let _ = dbg!(result);

        let http_request = request_receiver.expect_request();

        let body = http_request.body().bytes().expect("body should be strict");

        // No body.

        ::pretty_assertions::assert_eq!(&body, &bytes::Bytes::new());

        let uri: ::http::Uri = http_request.uri().parse().expect("invalid URI sent");

        ::pretty_assertions::assert_eq!(http_request.method(), "GET", "method was incorrect");

        ::pretty_assertions::assert_eq!(uri.path(), "/../key.txt", "path was incorrect");

        ::pretty_assertions::assert_eq!(uri.host().expect("host should be set"), "mybucket.s3.us-west-2.amazonaws.com");

    }

    /// S3 clients should not remove dot segments from request paths.

    ///

    /// Test ID: S3PreservesEmbeddedDotSegmentInUriLabel

    #[::tokio::test]

    #[::tracing_test::traced_test]

    async fn s3_preserves_embedded_dot_segment_in_uri_label_request() {

        let config_builder = crate::config::Config::builder()

            .with_test_defaults()

            .endpoint_url("https://s3.us-west-2.amazonaws.com");

        let mut config_builder = config_builder;

        config_builder.set_region(Some(crate::config::Region::new("us-east-1")));

        let config = config_builder.http_client(http_client).build();

        let client = crate::Client::from_conf(config);

        let result = client

#[allow(unreachable_code, unused_variables)]

#[cfg(test)]

mod head_object_test {

    /// https://github.com/awslabs/aws-sdk-rust/issues/331

    /// Test ID: HeadObjectUriEncoding

    #[::tokio::test]

    #[::tracing_test::traced_test]

    async fn head_object_uri_encoding_request() {

        let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");

        let config_builder = config_builder.region(::aws_types::region::Region::new("us-east-1"));

        let mut config_builder = config_builder;

        config_builder.set_region(Some(crate::config::Region::new("us-east-1")));

        let config = config_builder.http_client(http_client).build();

        let client = crate::Client::from_conf(config);

        let result = client

            .head_object()

            .set_bucket(::std::option::Option::Some("test-bucket".to_owned()))

#[allow(unreachable_code, unused_variables)]

#[cfg(test)]

mod put_bucket_lifecycle_configuration_test {

    /// This test validates that the content md5 header is set correctly

    /// Test ID: PutBucketLifecycleConfiguration

    #[::tokio::test]

    #[::tracing_test::traced_test]

    async fn put_bucket_lifecycle_configuration_request() {

        let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");

        let config_builder = config_builder.region(::aws_types::region::Region::new("us-east-1"));

        let mut config_builder = config_builder;

        config_builder.set_region(Some(crate::config::Region::new("us-east-1")));

        let config = config_builder.http_client(http_client).build();

        let client = crate::Client::from_conf(config);

        let result = client

            .put_bucket_lifecycle_configuration()

            .set_bucket(::std::option::Option::Some("test-bucket".to_owned()))

#[allow(unreachable_code, unused_variables)]

#[cfg(test)]

mod put_object_test {

    /// This test validates that if a content-type is specified, that only one content-type header is sent

    /// Test ID: DontSendDuplicateContentType

    #[::tokio::test]

    #[::tracing_test::traced_test]

    async fn dont_send_duplicate_content_type_request() {

        let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");

        let config_builder = config_builder.region(::aws_types::region::Region::new("us-east-1"));

        let mut config_builder = config_builder;

        config_builder.set_region(Some(crate::config::Region::new("us-east-1")));

        let config = config_builder.http_client(http_client).build();

        let client = crate::Client::from_conf(config);

        let result = client

            .put_object()

            .set_bucket(::std::option::Option::Some("test-bucket".to_owned()))

            .set_key(::std::option::Option::Some("test-key".to_owned()))

            .set_content_type(::std::option::Option::Some("text/html".to_owned()))

            .send()

            .await;

        let _ = dbg!(result);

        let http_request = request_receiver.expect_request();

        let expected_headers = [("content-type", "text/html")];

        ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));

        let uri: ::http::Uri = http_request.uri().parse().expect("invalid URI sent");

        ::pretty_assertions::assert_eq!(http_request.method(), "PUT", "method was incorrect");

        ::pretty_assertions::assert_eq!(uri.path(), "/test-key", "path was incorrect");

    }

    /// This test validates that if a content-length is specified, that only one content-length header is sent

    /// Test ID: DontSendDuplicateContentLength

    #[::tokio::test]

    #[::tracing_test::traced_test]

    async fn dont_send_duplicate_content_length_request() {

        let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");

        let config_builder = config_builder.region(::aws_types::region::Region::new("us-east-1"));

        let mut config_builder = config_builder;

        config_builder.set_region(Some(crate::config::Region::new("us-east-1")));

        let config = config_builder.http_client(http_client).build();

        let client = crate::Client::from_conf(config);

        let result = client

            .put_object()

            .set_bucket(::std::option::Option::Some("test-bucket".to_owned()))

use aws_config::retry::RetryConfig;

use aws_credential_types::provider::SharedCredentialsProvider;

use aws_sdk_s3::config::{Credentials, Region, StalledStreamProtectionConfig};

use aws_sdk_s3::types::{

    CompressionType, CsvInput, CsvOutput, ExpressionType, FileHeaderInfo, InputSerialization,

    OutputSerialization,

};

use aws_sdk_s3::{Client, Config};

use aws_smithy_async::assert_elapsed;

use aws_smithy_async::rt::sleep::{AsyncSleep, SharedAsyncSleep, Sleep};

use aws_smithy_runtime::test_util::capture_test_logs::capture_test_logs;

use aws_smithy_runtime_api::client::result::SdkError;

use aws_smithy_types::error::display::DisplayErrorContext;

use aws_smithy_types::timeout::TimeoutConfig;

use std::fmt::Debug;

use std::time::{Duration, Instant};

#[derive(Debug)]

struct SmolSleep;

 */

//! Body wrappers must pass through size_hint

use aws_config::SdkConfig;

use aws_sdk_s3::{

    config::{Credentials, Region, SharedCredentialsProvider},

    primitives::{ByteStream, SdkBody},

    Client,

};

#[tokio::test]

async fn download_body_size_hint_check() {

    let test_body_content = b"hello";

    let test_body = || SdkBody::from(&test_body_content[..]);

    assert_eq!(

        Some(test_body_content.len() as u64),

        (test_body)().size_hint().exact(),

        "pre-condition check"

    );

    let http_client = infallible_client_fn(move |_| {

            .status(200)

            .body((test_body)())

            .unwrap()

    });

    let sdk_config = SdkConfig::builder()

        .credentials_provider(SharedCredentialsProvider::new(Credentials::for_tests()))

        .region(Region::new("us-east-1"))

        .http_client(http_client)

        .build();

    let client = Client::new(&sdk_config);

/*

 * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.

 * SPDX-License-Identifier: Apache-2.0

 */

use aws_config::SdkConfig;

use aws_credential_types::provider::SharedCredentialsProvider;

use aws_sdk_s3::config::{Credentials, Region, StalledStreamProtectionConfig};

use aws_sdk_s3::Client;

#[tokio::test]

async fn dont_dispatch_when_bucket_is_unset() {

    let (http_client, rcvr) = capture_request(None);

    let sdk_config = SdkConfig::builder()

        .credentials_provider(SharedCredentialsProvider::new(Credentials::for_tests()))

        .region(Region::new("us-east-1"))

        .stalled_stream_protection(StalledStreamProtectionConfig::disabled())

        .http_client(http_client.clone())

        .build();

use aws_config::Region;

use aws_runtime::{

    sdk_feature::AwsSdkFeature, user_agent::test_util::assert_ua_contains_metric_values,

};

use aws_sdk_s3::{

    config::{Intercept, IntoShared},

    primitives::ByteStream,

    Client, Config,

};

#[derive(Debug)]

struct TransferManagerFeatureInterceptor;

impl Intercept for TransferManagerFeatureInterceptor {

    fn name(&self) -> &'static str {

        "TransferManagerFeature"

    }

    fn read_before_execution(

/*

 * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.

 * SPDX-License-Identifier: Apache-2.0

 */

#![cfg(feature = "test-util")]

use aws_config::SdkConfig;

use aws_credential_types::provider::SharedCredentialsProvider;

use aws_sdk_s3::config::{Credentials, Region, StalledStreamProtectionConfig};

use aws_sdk_s3::types::ChecksumMode;

use aws_sdk_s3::{operation::get_object::GetObjectOutput, types::ChecksumAlgorithm};

use aws_sdk_s3::{Client, Config};

use aws_smithy_types::body::SdkBody;

use std::time::{Duration, UNIX_EPOCH};

use tracing_test::traced_test;

/// Test connection for the movies IT

/// headers are signed with actual creds, at some point we could replace them with verifiable test

/// credentials, but there are plenty of other tests that target signing

fn new_checksum_validated_response_test_connection(

    checksum_header_name: &'static str,

    checksum_header_value: &'static str,

) -> StaticReplayClient {

    StaticReplayClient::new(vec![ReplayEvent::new(

            .header("x-amz-checksum-mode", "ENABLED")

            .header(

                "user-agent",

                "aws-sdk-rust/0.123.test os/windows/XPSP3 lang/rust/1.50.0",

            )

            .header("x-amz-date", "20090213T233130Z")

            .header(

                "x-amz-content-sha256",

                "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",

            )

            .header(

                "x-amz-user-agent",

                "aws-sdk-rust/0.123.test api/test-service/0.123 os/windows/XPSP3 lang/rust/1.50.0",

            )

            .header("authorization", "not-relevant")

            .uri(Uri::from_static(

                "https://some-test-bucket.s3.us-east-1.amazonaws.com/test.txt?x-id=GetObject",

            ))

            .body(SdkBody::empty())

            .unwrap(),

            .header("x-amz-request-id", "4B4NGF0EAWN0GE63")

            .header("content-length", "11")

            .header("etag", "\"3e25960a79dbc69b674cd4ec67a72c62\"")

            .header(checksum_header_name, checksum_header_value)

            .header("content-type", "application/octet-stream")

            .header("server", "AmazonS3")

            .header("content-encoding", "")

            .header("last-modified", "Tue, 21 Jun 2022 16:29:14 GMT")

            .header("date", "Tue, 21 Jun 2022 16:29:23 GMT")

            .header(

                "x-amz-id-2",

                "kPl+IVVZAwsN8ePUyQJZ40WD9dzaqtr4eNESArqE68GSKtVvuvCTDe+SxhTT+JTUqXB1HL4OxNM=",

            )

            .header("accept-ranges", "bytes")

            .body(SdkBody::from(r#"Hello world"#))

            .unwrap(),

    )])

}

async fn test_checksum_on_streaming_response(

    checksum_header_name: &'static str,

    checksum_header_value: &'static str,

) -> GetObjectOutput {

    let http_client = new_checksum_validated_response_test_connection(

        b"Hello world",

        ChecksumAlgorithm::Sha256,

        "x-amz-checksum-sha256",

        "11",

        &expected_encoded_content_length,

        expected_aws_chunked_encoded_body,

    )

    .await

}

    use bytes::Buf;

    use bytes_utils::SegmentedBuf;

    use std::io::Read;

    let mut output = SegmentedBuf::new();

        output.push(buf.unwrap());

    }

    let mut output_text = String::new();

    output

        .reader()

        .read_to_string(&mut output_text)

        .expect("Doesn't cause IO errors");

    output_text

}

#[tokio::test]

#[traced_test]

async fn test_get_multipart_upload_part_checksum_validation() {

    let expected_checksum = "cpjwid==-12";

    let (http_client, rcvr) = capture_request(Some(