AWS SDK

/*

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

 * SPDX-License-Identifier: Apache-2.0

 */

use aws_sdk_s3::operation::get_object::GetObjectError;

use aws_sdk_s3::operation::{RequestId, RequestIdExt};

use aws_sdk_s3::{config::Credentials, config::Region, Client, Config};

use aws_smithy_types::body::SdkBody;

#[tokio::test]

async fn get_request_id_from_modeled_error() {

    let (http_client, request) = capture_request(Some(

            .header("x-amz-request-id", "correct-request-id")

            .header("x-amz-id-2", "correct-extended-request-id")

            .status(404)

            .body(SdkBody::from(

                r#"<?xml version="1.0" encoding="UTF-8"?>

                <Error>

                  <Code>NoSuchKey</Code>

                  <Message>The resource you requested does not exist</Message>

                  <Resource>/mybucket/myfoto.jpg</Resource>

                  <RequestId>incorrect-request-id</RequestId>

                </Error>"#,

            ))

            .unwrap(),

    ));

    let config = Config::builder()

        .http_client(http_client)

        .credentials_provider(Credentials::for_tests())

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

        .build();

    let client = Client::from_conf(config);

    let err = client

        .get_object()

        .key("dontcare")

        .bucket("dontcare")

        .send()

        .await

        .expect_err("status was 404, this is an error")

        .into_service_error();

    request.expect_request();

    assert!(

        matches!(err, GetObjectError::NoSuchKey(_)),

        "expected NoSuchKey, got {err:?}",

    );

    assert_eq!(Some("correct-request-id"), err.request_id());

    assert_eq!(Some("correct-request-id"), err.meta().request_id());

    assert_eq!(

        Some("correct-extended-request-id"),

        err.extended_request_id()

    );

    assert_eq!(

        Some("correct-extended-request-id"),

        err.meta().extended_request_id()

    );

}

#[tokio::test]

#[allow(deprecated)]

async fn get_request_id_from_unmodeled_error() {

    let (http_client, request) = capture_request(Some(

            .header("x-amz-request-id", "correct-request-id")

            .header("x-amz-id-2", "correct-extended-request-id")

            .status(500)

            .body(SdkBody::from(

                r#"<?xml version="1.0" encoding="UTF-8"?>

                <Error>

                  <Code>SomeUnmodeledError</Code>

                  <Message>Something bad happened</Message>

                  <Resource>/mybucket/myfoto.jpg</Resource>

                  <RequestId>incorrect-request-id</RequestId>

                </Error>"#,

            ))

            .unwrap(),

    ));

    let config = Config::builder()

        .http_client(http_client)

        .credentials_provider(Credentials::for_tests())

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

        .build();

    let client = Client::from_conf(config);

    let err = client

        .get_object()

        .bucket("dontcare")

        .key("dontcare")

        .send()

        .await

        .expect_err("status 500")

        .into_service_error();

    request.expect_request();

    assert!(matches!(err, GetObjectError::Unhandled(_)));

    assert_eq!(Some("correct-request-id"), err.request_id());

    assert_eq!(Some("correct-request-id"), err.meta().request_id());

    assert_eq!(

        Some("correct-extended-request-id"),

        err.extended_request_id()

    );

    assert_eq!(

        Some("correct-extended-request-id"),

        err.meta().extended_request_id()

    );

}

#[tokio::test]

async fn get_request_id_from_successful_nonstreaming_response() {

    let (http_client, request) = capture_request(Some(

            .header("x-amz-request-id", "correct-request-id")

            .header("x-amz-id-2", "correct-extended-request-id")

            .status(200)

            .body(SdkBody::from(

                r#"<?xml version="1.0" encoding="UTF-8"?>

                <ListAllMyBucketsResult xmlns="http://s3.amazonaws.com/doc/2006-03-01/">

                  <Owner><ID>some-id</ID><DisplayName>some-display-name</DisplayName></Owner>

                  <Buckets></Buckets>

                </ListAllMyBucketsResult>"#,

            ))

            .unwrap(),

    ));

    let config = Config::builder()

        .http_client(http_client)

        .credentials_provider(Credentials::for_tests())

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

        .build();

    let client = Client::from_conf(config);

    let output = client

        .list_buckets()

        .send()

        .await

        .expect("valid successful response");

    request.expect_request();

    assert_eq!(Some("correct-request-id"), output.request_id());

    assert_eq!(

        Some("correct-extended-request-id"),

        output.extended_request_id()

    );

}

#[tokio::test]

async fn get_request_id_from_successful_streaming_response() {

    let (http_client, request) = capture_request(Some(

            .header("x-amz-request-id", "correct-request-id")

            .header("x-amz-id-2", "correct-extended-request-id")

            .status(200)

            .body(SdkBody::from("some streaming file data"))

            .unwrap(),

    ));

    let config = Config::builder()

        .http_client(http_client)

        .credentials_provider(Credentials::for_tests())

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

        .build();

    let client = Client::from_conf(config);

    let output = client

        .get_object()

        .key("dontcare")

        .bucket("dontcare")

        .send()

        .await

        .expect("valid successful response");

    request.expect_request();

    assert_eq!(Some("correct-request-id"), output.request_id());

    assert_eq!(

        Some("correct-extended-request-id"),

        output.extended_request_id()

    );

}

// Verify that the conversion from operation error to the top-level service error maintains the request ID

#[tokio::test]

async fn conversion_to_service_error_maintains_request_id() {

    let (http_client, request) = capture_request(Some(

            .header("x-amz-request-id", "correct-request-id")

            .header("x-amz-id-2", "correct-extended-request-id")

            .status(404)

            .body(SdkBody::from(

                r#"<?xml version="1.0" encoding="UTF-8"?>

                <Error>

                  <Code>NoSuchKey</Code>

                  <Message>The resource you requested does not exist</Message>

                  <Resource>/mybucket/myfoto.jpg</Resource>

                  <RequestId>incorrect-request-id</RequestId>

use aws_sdk_s3::config::interceptors::BeforeSerializationInterceptorContextMut;

use aws_sdk_s3::config::interceptors::FinalizerInterceptorContextRef;

use aws_sdk_s3::config::retry::RetryConfig;

use aws_sdk_s3::config::timeout::TimeoutConfig;

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

use aws_sdk_s3::config::{Intercept, SharedAsyncSleep};

use aws_sdk_s3::Client;

use aws_smithy_async::test_util::InstantSleep;

use aws_smithy_async::test_util::ManualTimeSource;

use aws_smithy_async::time::SharedTimeSource;

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

use aws_smithy_runtime_api::box_error::BoxError;

use aws_smithy_runtime_api::client::runtime_components::RuntimeComponents;

use aws_smithy_types::config_bag::{ConfigBag, Layer};

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

// # One SDK operation invocation.

// # Client retries 3 times, successful response on 3rd attempt.

// # Fast network, latency + server time is less than one second.

// # No clock skew

/*

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

 * SPDX-License-Identifier: Apache-2.0

 */

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

use aws_sdk_s3::error::DisplayErrorContext;

use aws_sdk_s3::Client;

use aws_smithy_types::error::operation::BuildError;

#[tokio::test]

async fn test_error_when_required_query_param_is_unset() {

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

    let config = aws_sdk_s3::Config::builder()

        .http_client(http_client)

        .credentials_provider(Credentials::for_tests())

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

        .build();

/*

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

 * SPDX-License-Identifier: Apache-2.0

 */

use aws_sdk_s3::config::interceptors::InterceptorContext;

use aws_sdk_s3::config::retry::{ClassifyRetry, RetryAction, RetryConfig};

use aws_sdk_s3::config::SharedAsyncSleep;

use aws_smithy_async::rt::sleep::TokioSleep;

use aws_smithy_runtime_api::client::retries::classifiers::RetryClassifierPriority;

use aws_smithy_types::body::SdkBody;

use std::sync::{Arc, Mutex};

#[derive(Debug, Clone)]

struct CustomizationTestClassifier {

    counter: Arc<Mutex<u8>>,

}

impl CustomizationTestClassifier {

    pub fn new() -> Self {

        Self {

            counter: Arc::new(Mutex::new(0u8)),

        }

    }

    pub fn counter(&self) -> u8 {

        *self.counter.lock().unwrap()

    }

}

impl ClassifyRetry for CustomizationTestClassifier {

    fn classify_retry(&self, ctx: &InterceptorContext) -> RetryAction {

        *self.counter.lock().unwrap() += 1;

        // Interceptors may call this classifier before a response is received. If a response was received,

        // ensure that it has the expected status code.

        if let Some(res) = ctx.response() {

            assert_eq!(

                500,

                res.status().as_u16(),

                "expected a 500 response from test connection"

            );

        }

        RetryAction::RetryForbidden

    }

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

        "Custom Retry Classifier"

    }

}

        .body(SdkBody::from("request body"))

        .unwrap()

}

        .status(200)

        .body(SdkBody::from("Hello!"))

        .unwrap()

}

        .status(500)

        .body(SdkBody::from("This was an error"))

        .unwrap()

}

#[tokio::test]

async fn test_retry_classifier_customization_for_service() {

    let http_client = StaticReplayClient::new(vec![

        ReplayEvent::new(req(), err()),

        ReplayEvent::new(req(), ok()),

 */

use aws_config::SdkConfig;

use aws_credential_types::provider::SharedCredentialsProvider;

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

use aws_sdk_s3::types::{

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

    OutputSerialization, SelectObjectContentEventStream,

};

use aws_sdk_s3::Client;

use aws_smithy_protocol_test::{assert_ok, validate_body, MediaType};

use std::error::Error;

#[tokio::test]

async fn test_success() {

    let events: Vec<Event> =

        serde_json::from_str(include_str!("select-object-content.json")).unwrap();

    let replayer = ReplayingClient::new(events);

    let sdk_config = SdkConfig::builder()

        .region(Region::from_static("us-east-2"))

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

/*

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

 * SPDX-License-Identifier: Apache-2.0

 */

use aws_credential_types::provider::SharedCredentialsProvider;

use aws_credential_types::Credentials;

use aws_smithy_async::assert_elapsed;

use aws_smithy_async::rt::sleep::{SharedAsyncSleep, TokioSleep};

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

use aws_smithy_runtime_api::client::behavior_version::BehaviorVersion;

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

use aws_smithy_types::retry::RetryConfig;

use aws_smithy_types::timeout::TimeoutConfig;

use aws_types::region::Region;

use aws_types::SdkConfig;

use std::time::Duration;

use tokio::time::Instant;

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

 * SPDX-License-Identifier: Apache-2.0

 */

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

use aws_credential_types::provider::SharedCredentialsProvider;

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

use aws_sdk_s3::primitives::ByteStream;

use aws_sdk_s3::{Client, Config};

use aws_smithy_types::body::SdkBody;

#[tokio::test]

async fn test_signer() {

    let http_client = StaticReplayClient::new(vec![ReplayEvent::new(

            .header("authorization", "AWS4-HMAC-SHA256 Credential=ANOTREAL/20090213/us-east-1/s3/aws4_request, SignedHeaders=host;x-amz-content-sha256;x-amz-date;x-amz-user-agent, Signature=27e3f59ec3cffaa10e4f1c92112e8fb62d468a04cd32be39e68215f830404dbb")

            .uri("https://test-bucket.s3.us-east-1.amazonaws.com/?list-type=2&prefix=prefix~")

            .body(SdkBody::empty())

            .unwrap(),

    )]);

    let config = Config::builder()

        .credentials_provider(SharedCredentialsProvider::new(

            Credentials::for_tests_with_session_token(),

        ))

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

        .http_client(http_client.clone())

        .with_test_defaults()

        .build();

    let client = Client::from_conf(config);

use aws_credential_types::Credentials;

use aws_sdk_s3::{

    config::{Region, StalledStreamProtectionConfig},

    error::BoxError,

};

use aws_sdk_s3::{error::DisplayErrorContext, primitives::ByteStream};

use aws_sdk_s3::{Client, Config};

use aws_smithy_runtime::{assert_str_contains, test_util::capture_test_logs::capture_test_logs};

use aws_smithy_types::body::SdkBody;

use bytes::{Bytes, BytesMut};

use std::error::Error;

use std::time::Duration;

use std::{future::Future, task::Poll};

use std::{net::SocketAddr, pin::Pin, task::Context};

use tokio::{

    net::{TcpListener, TcpStream},

    time::sleep,

};

use tracing::debug;

enum SlowBodyState {

    Wait(Pin<Box<dyn std::future::Future<Output = ()> + Send + Sync + 'static>>),

    Send,

    Taken,

}

struct SlowBody {

    state: SlowBodyState,

}

impl SlowBody {

    fn new() -> Self {

        Self {

            state: SlowBodyState::Send,

        }

    }

}

impl Body for SlowBody {

    type Data = Bytes;

    type Error = BoxError;

        mut self: Pin<&mut Self>,

        cx: &mut Context<'_>,

        loop {

            let mut state = SlowBodyState::Taken;

            std::mem::swap(&mut state, &mut self.state);

            match state {

                SlowBodyState::Wait(mut fut) => match fut.as_mut().poll(cx) {

                    Poll::Ready(_) => self.state = SlowBodyState::Send,

                    Poll::Pending => {

                        self.state = SlowBodyState::Wait(fut);

                        return Poll::Pending;

                    }

                },

                SlowBodyState::Send => {

                    self.state = SlowBodyState::Wait(Box::pin(sleep(Duration::from_micros(100))));

                        b"data_data_data_data_data_data_data_data_data_data_data_data_\

                          data_data_data_data_data_data_data_data_data_data_data_data_\

                          data_data_data_data_data_data_data_data_data_data_data_data_\

                          data_data_data_data_data_data_data_data_data_data_data_data_",

                }

                SlowBodyState::Taken => unreachable!(),

            }

        }

    }

}

#[tokio::test]

async fn test_stalled_stream_protection_defaults_for_upload() {

    let _logs = capture_test_logs();

    // We spawn a faulty server that will stop all request processing after reading half of the request body.

    let (server, server_addr) = start_faulty_upload_server().await;

    let _ = tokio::spawn(server);

    let conf = Config::builder()

        // Stalled stream protection MUST BE enabled by default. Do not configure it explicitly.

        .credentials_provider(Credentials::for_tests())

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

        .endpoint_url(format!("http://{server_addr}"))

        // The Body used here is odd and fails the body.size_hint().exact() check in the streaming branch of

        // the `RequestChecksumInterceptor`

        .request_checksum_calculation(aws_sdk_s3::config::RequestChecksumCalculation::WhenRequired)

        .build();

    let client = Client::from_conf(conf);

    let err = client

        .put_object()

        .bucket("a-test-bucket")

        .key("stalled-stream-test.txt")

        .send()

        .await

        .expect_err("upload stream stalled out");

    let err_msg = DisplayErrorContext(&err).to_string();

    assert_str_contains!(

        err_msg,

        "minimum throughput was specified at 1 B/s, but throughput of 0 B/s was observed"

    );

}

/*

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

 * SPDX-License-Identifier: Apache-2.0

 */

use aws_config::retry::{RetryConfigBuilder, RetryMode};

use aws_credential_types::provider::SharedCredentialsProvider;

use aws_credential_types::Credentials;

use aws_sdk_s3::Client;

use aws_smithy_runtime::assert_str_contains;

use aws_smithy_types::body::SdkBody;

use aws_smithy_types::error::metadata::ProvideErrorMetadata;

use aws_types::region::Region;

use aws_types::SdkConfig;

const ERROR_RESPONSE: &str = r#"<?xml version="1.0" encoding="UTF-8"?>

        <Error>

            <Code>SlowDown</Code>

            <Message>Please reduce your request rate.</Message>

            <RequestId>K2H6N7ZGQT6WHCEG</RequestId>

            <HostId>WWoZlnK4pTjKCYn6eNV7GgOurabfqLkjbSyqTvDMGBaI9uwzyNhSaDhOCPs8paFGye7S6b/AB3A=</HostId>

        </Error>

"#;

#[tokio::test]

async fn status_200_errors() {

    let http_client =

    let sdk_config = SdkConfig::builder()

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

        .region(Region::new("us-west-4"))

        .http_client(http_client)

        .build();

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

    let error = client

        .delete_objects()

        .bucket("bucket")

        .send()

        .await

        .expect_err("should fail");

    assert_eq!(error.as_service_error().unwrap().code(), Some("SlowDown"));

    assert_str_contains!(format!("{:?}", error), "Please reduce your request rate");

}

#[tracing_test::traced_test]

#[tokio::test]

async fn retry_200_internal_error() {

    let http_client = infallible_client_fn(|_req| {

            r#"<?xml version="1.0" encoding="UTF-8"?>

            <Error>

                <Type>Server</Type>

                <Code>InternalError</Code>

                <Message>>We encountered an internal error. Please try again.</Message>

                <RequestId>DOESNOTMATTER</RequestId>

            </Error>

        "#,

        ))

    });

/*

 * 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};

use aws_sdk_s3::error::DisplayErrorContext;

use aws_sdk_s3::Client;

use aws_smithy_runtime::assert_str_contains;

use aws_smithy_types::body::SdkBody;

use bytes::BytesMut;

use std::future::Future;

use std::net::SocketAddr;

use std::time::Duration;

use tracing::debug;

#[tokio::test]

async fn test_too_short_body_causes_an_error() {

    // this is almost impossible to reproduce with Hyper—you need to do stuff like run each request

    // in its own async runtime. But there's no reason a customer couldn't run their _own_ HttpClient

    // that was more poorly behaved, so we'll do that here.

    let http_client = infallible_client_fn(|_req| {

            .header(CONTENT_LENGTH, 5000)

            .body(SdkBody::from("definitely not 5000 characters"))

            .unwrap()

    });

    let client = aws_sdk_s3::Client::from_conf(

        aws_sdk_s3::Config::builder()

            .with_test_defaults()

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

            .http_client(http_client)

use aws_sdk_s3::config::{timeout::TimeoutConfig, Region};

use aws_sdk_s3::error::DisplayErrorContext;

use aws_sdk_s3::primitives::ByteStream;

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 std::future::Future;

use std::net::SocketAddr;

use std::time::Duration;

use tokio::net::TcpListener;

use tokio::time::timeout;

#[tokio::test(start_paused = true)]

async fn test_event_stream_request_times_out_if_server_is_unresponsive() {

    let config = Config::builder()

        .with_test_defaults()

        Duration::from_millis(1000),

        client.get_object().bucket("test").key("test").send(),

    )

    .await

    {

        match result {

            Ok(_) => panic!("should not have succeeded"),

            Err(err) => {

                let message = format!("{}", DisplayErrorContext(&err));

                let expected =

                assert!(

                    message.contains(expected),

                    "expected '{message}' to contain '{expected}'"

                );

            }

        }

    } else {

        panic!("the client didn't timeout");

    }

}

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"

[dependencies.aws-smithy-async]

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

[dependencies.aws-smithy-http]

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

[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.fastrand]

version = "2.0.0"

[dependencies.http]

version = "0.2.9"

[dependencies.md-5]

version = "0.10.0"

[dependencies.once_cell]

version = "1.16"

[dependencies.regex-lite]

version = "0.1.5"

[dependencies.tracing]

version = "0.1"

[dependencies.url]

version = "2.3.1"

[dev-dependencies.aws-config]

path = "../aws-config"

[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-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"]

[dev-dependencies.aws-smithy-types]

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

features = ["test-util"]

[dev-dependencies.futures-util]

version = "0.3.25"

features = ["alloc"]

default-features = false

[dev-dependencies.proptest]

version = "1"

[dev-dependencies.serde_json]

version = "1.0.0"

[dev-dependencies.tokio]

version = "1.23.1"

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

[dev-dependencies.tracing-subscriber]

version = "0.3.16"

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

[features]

behavior-version-latest = []

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

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

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

gated-tests = []

// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.

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

#[::tokio::test]

async fn operation_input_test_get_access_point_1() {

    /* documentation: Vanilla outposts without ARN region + access point ARN@us-west-2 */

    /* builtIns: {

        "AWS::Region": "us-west-2"

    } */

    /* clientParams: {} */

    let conf = {

        #[allow(unused_mut)]

        let mut builder = aws_sdk_s3control::Config::builder().with_test_defaults().http_client(http_client);

        let builder = builder.region(::aws_types::region::Region::new("us-west-2"));

        builder.build()

    };

    let client = aws_sdk_s3control::Client::from_conf(conf);

    let _result = dbg!(

        client

            .get_access_point()

            .set_name(::std::option::Option::Some(

                "arn:aws:s3-outposts:us-west-2:123456789012:outpost:op-01234567890123456:accesspoint:myaccesspoint".to_owned()

            ))

            .set_account_id(::std::option::Option::Some("123456789012".to_owned()))

            .send()

            .await

    );

    let req = rcvr.expect_request();

    let uri = req.uri().to_string();

    assert!(

        uri.starts_with("https://s3-outposts.us-west-2.amazonaws.com"),

        "expected URI to start with `https://s3-outposts.us-west-2.amazonaws.com` but it was `{}`",

        uri

    );

}

#[::tokio::test]

async fn operation_input_test_delete_access_point_2() {

    /* documentation: Vanilla outposts without ARN region + access point ARN@us-west-2 */

    /* builtIns: {

        "AWS::Region": "us-west-2"

    } */

    /* clientParams: {} */

    let conf = {

        #[allow(unused_mut)]

        let mut builder = aws_sdk_s3control::Config::builder().with_test_defaults().http_client(http_client);

        let builder = builder.region(::aws_types::region::Region::new("us-west-2"));

        builder.build()

    };

    let client = aws_sdk_s3control::Client::from_conf(conf);

    let _result = dbg!(

        client

            .delete_access_point()

            .set_name(::std::option::Option::Some(

                "arn:aws:s3-outposts:us-west-2:123456789012:outpost:op-01234567890123456:accesspoint:myaccesspoint".to_owned()

            ))

            .set_account_id(::std::option::Option::Some("123456789012".to_owned()))

            .send()

            .await

    );

    let req = rcvr.expect_request();

    let uri = req.uri().to_string();

    assert!(

        uri.starts_with("https://s3-outposts.us-west-2.amazonaws.com"),

        "expected URI to start with `https://s3-outposts.us-west-2.amazonaws.com` but it was `{}`",

        uri

    );

}

#[::tokio::test]

async fn operation_input_test_get_access_point_3() {

    /* documentation: Vanilla outposts with ARN region + access point ARN@us-west-2 */

    /* builtIns: {

        "AWS::Region": "us-west-2"

    } */

    /* clientParams: {} */

    let conf = {

        #[allow(unused_mut)]

        let mut builder = aws_sdk_s3control::Config::builder().with_test_defaults().http_client(http_client);

        let builder = builder.region(::aws_types::region::Region::new("us-west-2"));

        builder.build()

    };

    let client = aws_sdk_s3control::Client::from_conf(conf);

    let _result = dbg!(

        client

            .get_access_point()

            .set_name(::std::option::Option::Some(

                "arn:aws:s3-outposts:us-east-1:123456789012:outpost:op-01234567890123456:accesspoint:myaccesspoint".to_owned()

            ))

            .set_account_id(::std::option::Option::Some("123456789012".to_owned()))

            .send()

            .await

    );

    let req = rcvr.expect_request();

    let uri = req.uri().to_string();

    assert!(

        uri.starts_with("https://s3-outposts.us-east-1.amazonaws.com"),

        "expected URI to start with `https://s3-outposts.us-east-1.amazonaws.com` but it was `{}`",

        uri

    );

}

#[::tokio::test]

async fn operation_input_test_delete_access_point_4() {

    /* documentation: Vanilla outposts with ARN region + access point ARN@us-west-2 */

    /* builtIns: {

        "AWS::Region": "us-west-2"

    } */

    /* clientParams: {} */

    let conf = {

        #[allow(unused_mut)]

        let mut builder = aws_sdk_s3control::Config::builder().with_test_defaults().http_client(http_client);

        let builder = builder.region(::aws_types::region::Region::new("us-west-2"));

        builder.build()

    };

    let client = aws_sdk_s3control::Client::from_conf(conf);

    let _result = dbg!(

        client

            .delete_access_point()

            .set_name(::std::option::Option::Some(

                "arn:aws:s3-outposts:us-east-1:123456789012:outpost:op-01234567890123456:accesspoint:myaccesspoint".to_owned()

            ))

            .set_account_id(::std::option::Option::Some("123456789012".to_owned()))

            .send()

            .await

    );

    let req = rcvr.expect_request();

    let uri = req.uri().to_string();

    assert!(

        uri.starts_with("https://s3-outposts.us-east-1.amazonaws.com"),

        "expected URI to start with `https://s3-outposts.us-east-1.amazonaws.com` but it was `{}`",