#![cfg(target_family = "unix")]
use aws_s3_transfer::config::PartSize;
use aws_s3_transfer::types::ByteSize;
use aws_s3_transfer::{error::ErrorKind, io::walk::FsWalker, types::FailedTransferPolicy};
use aws_sdk_s3::{
config::http::HttpResponse,
error::DisplayErrorContext,
operation::{
complete_multipart_upload::CompleteMultipartUploadOutput,
create_multipart_upload::CreateMultipartUploadOutput, put_object::PutObjectOutput,
upload_part::UploadPartOutput,
},
Client,
};
use aws_smithy_mocks::{mock, mock_client, RuleMode};
use aws_smithy_runtime_api::http::StatusCode;
use aws_smithy_types::body::SdkBody;
use std::time::Duration;
use test_common::create_test_dir;
use tokio::{fs::symlink, sync::watch, time::timeout};
const TEST_TIMEOUT: Duration = Duration::from_secs(30);
async fn wait_for_finished_elapsed(
metrics: impl Fn() -> aws_s3_transfer::metrics::TransferMetrics,
) -> Duration {
loop {
let first = metrics().elapsed;
tokio::time::sleep(Duration::from_millis(10)).await;
if metrics().elapsed == first {
return first;
}
}
}
fn mock_s3_client_for_put_object(bucket_name: String) -> Client {
let put_object = mock!(aws_sdk_s3::Client::put_object)
.match_requests(move |input| input.bucket() == Some(&bucket_name))
.then_output(|| PutObjectOutput::builder().build());
mock_client!(aws_sdk_s3, RuleMode::MatchAny, &[put_object])
}
fn mock_s3_client_for_multipart_upload(bucket_name: String) -> Client {
let upload_id = "test-upload-id".to_owned();
let create_mpu = mock!(aws_sdk_s3::Client::create_multipart_upload).then_output({
let upload_id = upload_id.clone();
move || {
CreateMultipartUploadOutput::builder()
.upload_id(upload_id.clone())
.build()
}
});
let upload_part = mock!(aws_sdk_s3::Client::upload_part)
.match_requests({
let upload_id = upload_id.clone();
move |input| {
input.upload_id.as_ref() == Some(&upload_id) && input.bucket() == Some(&bucket_name)
}
})
.then_output(|| UploadPartOutput::builder().e_tag("test-etag").build());
let complete_mpu = mock!(aws_sdk_s3::Client::complete_multipart_upload)
.match_requests({
let upload_id = upload_id.clone();
move |r| r.upload_id.as_ref() == Some(&upload_id)
})
.then_output(|| CompleteMultipartUploadOutput::builder().build());
mock_client!(
aws_sdk_s3,
RuleMode::MatchAny,
&[create_mpu, upload_part, complete_mpu]
)
}
#[tokio::test]
async fn test_successful_multiple_objects_upload_via_put_object() {
timeout(TEST_TIMEOUT, async {
let recursion_root = "test";
let files = vec![
("sample.jpg", 1),
("photos/2022/January/sample.jpg", 1),
("photos/2022/February/sample1.jpg", 1),
("photos/2022/February/sample2.jpg", 1),
("photos/2022/February/sample3.jpg", 1),
];
let test_dir = create_test_dir(Some(recursion_root), files.clone(), &[]);
let bucket_name = "test-bucket";
let config = aws_s3_transfer::Config::builder()
.s3_config(test_common::s3_config_with_test_http(
mock_s3_client_for_put_object(bucket_name.to_owned())
.config()
.to_builder(),
))
.build()
.expect("valid config");
let sut = aws_s3_transfer::Client::new(config);
let handle = sut
.upload_objects()
.bucket(bucket_name)
.source(test_dir.path())
.walker(FsWalker::builder().recursive(true).build())
.initiate()
.unwrap();
let output = handle.join().await.unwrap();
assert_eq!(5, output.objects_uploaded());
assert!(output.failed_transfers().is_empty());
assert_eq!(5, output.metrics.network_tx);
})
.await
.expect("test_successful_multiple_objects_upload_via_put_object timed out");
}
#[tokio::test]
async fn test_successful_multiple_objects_upload_via_multipart_upload() {
timeout(TEST_TIMEOUT, async {
let recursion_root = "test";
const MIN_MULTIPART_PART_SIZE_BYTES: u64 = ByteSize::mib(5).as_u64();
let files = vec![
("sample.jpg", MIN_MULTIPART_PART_SIZE_BYTES as usize),
(
"photos/2022/January/sample.jpg",
MIN_MULTIPART_PART_SIZE_BYTES as usize,
),
];
let test_dir = create_test_dir(Some(recursion_root), files.clone(), &[]);
let bucket_name = "test-bucket";
let config = aws_s3_transfer::Config::builder()
.s3_config(test_common::s3_config_with_test_http(
mock_s3_client_for_multipart_upload(bucket_name.to_owned())
.config()
.to_builder(),
))
.multipart_threshold(PartSize::Target(ByteSize::new(5)))
.build()
.expect("valid config");
let sut = aws_s3_transfer::Client::new(config);
let handle = sut
.upload_objects()
.bucket(bucket_name)
.source(test_dir.path())
.walker(FsWalker::builder().recursive(true).build())
.initiate()
.unwrap();
let output = handle.join().await.unwrap();
assert_eq!(2, output.objects_uploaded());
assert!(output.failed_transfers().is_empty());
assert_eq!(2 * MIN_MULTIPART_PART_SIZE_BYTES, output.metrics.network_tx);
})
.await
.expect("test_successful_multiple_objects_upload_via_multipart_upload timed out");
}
#[tokio::test]
async fn test_successful_multiple_objects_upload_with_symlinks() {
timeout(TEST_TIMEOUT, async {
let temp_dir1 = create_test_dir(Some("temp1"), vec![("sample.jpg", 1)], &[]);
let temp_dir2 = create_test_dir(
Some("temp2"),
vec![
("sample.txt", 1),
("docs/2022/January/sample.txt", 1),
("docs/2022/February/sample1.txt", 1),
("docs/2022/February/sample2.txt", 1),
("docs/2022/February/sample3.txt", 1),
],
&[],
);
let temp_dir3 = create_test_dir(Some("temp3"), vec![("sample3.png", 1)], &[]);
symlink(&temp_dir2, temp_dir1.path().join("symlink"))
.await
.unwrap();
symlink(
temp_dir3.path().join("sample3.png"),
temp_dir1.path().join("symlink2"),
)
.await
.unwrap();
let bucket_name = "test-bucket";
let config = aws_s3_transfer::Config::builder()
.s3_config(test_common::s3_config_with_test_http(
mock_s3_client_for_put_object(bucket_name.to_owned())
.config()
.to_builder(),
))
.build()
.expect("valid config");
let sut = aws_s3_transfer::Client::new(config);
{
let handle = sut
.upload_objects()
.bucket(bucket_name)
.source(temp_dir1.path())
.walker(
FsWalker::builder()
.recursive(true)
.follow_symlinks(true)
.build(),
)
.initiate()
.unwrap();
let output = handle.join().await.unwrap();
assert_eq!(7, output.objects_uploaded());
assert!(output.failed_transfers().is_empty());
assert_eq!(7, output.metrics.network_tx);
}
{
let handle = sut
.upload_objects()
.bucket(bucket_name)
.source(temp_dir1.path())
.initiate()
.unwrap();
let output = handle.join().await.unwrap();
assert_eq!(1, output.objects_uploaded()); assert!(output.failed_transfers().is_empty());
assert_eq!(1, output.metrics.network_tx);
}
})
.await
.expect("test_successful_multiple_objects_upload_with_symlinks timed out");
}
#[tokio::test]
async fn test_source_dir_is_symlink() {
timeout(TEST_TIMEOUT, async {
let temp_dir1 = create_test_dir(Some("temp1"), vec![], &[]);
let temp_dir2 = create_test_dir(Some("temp2"), vec![("sample.txt", 1)], &[]);
let symlink_path = temp_dir1.path().join("symlink");
symlink(&temp_dir2, &symlink_path).await.unwrap();
let bucket_name = "test-bucket";
let config = aws_s3_transfer::Config::builder()
.s3_config(test_common::s3_config_with_test_http(
mock_s3_client_for_put_object(bucket_name.to_owned())
.config()
.to_builder(),
))
.build()
.expect("valid config");
let sut = aws_s3_transfer::Client::new(config);
{
let handle = sut
.upload_objects()
.bucket(bucket_name)
.source(&symlink_path)
.initiate()
.unwrap();
let err = handle.join().await.unwrap_err();
assert_eq!(&ErrorKind::InputInvalid, err.kind());
}
{
let handle = sut
.upload_objects()
.bucket(bucket_name)
.source(symlink_path)
.walker(FsWalker::builder().follow_symlinks(true).build())
.initiate()
.unwrap();
let output = handle.join().await.unwrap();
assert_eq!(1, output.objects_uploaded());
assert!(output.failed_transfers().is_empty());
assert_eq!(1, output.metrics.network_tx);
}
})
.await
.expect("test_source_dir_is_symlink timed out");
}
#[tokio::test]
async fn test_failed_upload_policy_continue() {
timeout(TEST_TIMEOUT, async {
let recursion_root = "test";
let files = vec![
("sample.jpg", 1),
("photos/2022/January/sample.jpg", 1),
("photos/2022/February/sample1.jpg", 1),
("photos/2022/February/sample2.jpg", 1),
("photos/2022/February/sample3.jpg", 1),
];
let inaccessible_dir_relative_path = "photos/2022/February";
let test_dir = create_test_dir(
Some(recursion_root),
files.clone(),
&[inaccessible_dir_relative_path],
);
let bucket_name = "test-bucket";
let config = aws_s3_transfer::Config::builder()
.s3_config(test_common::s3_config_with_test_http(
mock_s3_client_for_put_object(bucket_name.to_owned())
.config()
.to_builder(),
))
.build()
.expect("valid config");
let sut = aws_s3_transfer::Client::new(config);
let handle = sut
.upload_objects()
.bucket(bucket_name)
.source(test_dir.path())
.walker(FsWalker::builder().recursive(true).build())
.failure_policy(FailedTransferPolicy::Continue)
.initiate()
.unwrap();
let output = handle.join().await.unwrap();
assert_eq!(2, output.objects_uploaded());
assert_eq!(1, output.failed_transfers().len());
assert!(output.failed_transfers()[0].input().is_none());
assert_eq!(2, output.metrics.network_tx);
})
.await
.expect("test_failed_upload_policy_continue timed out");
}
#[tokio::test]
async fn test_server_error_should_be_recorded_as_such_in_failed_transfers() {
timeout(TEST_TIMEOUT, async {
let test_dir = create_test_dir(Some("test"), vec![("sample.jpg", 1)], &[]);
let bucket_name = "test-bucket";
let put_object = mock!(aws_sdk_s3::Client::put_object)
.match_requests(move |input| input.bucket() == Some(bucket_name))
.then_http_response(|| {
HttpResponse::new(StatusCode::try_from(500).unwrap(), SdkBody::empty())
});
let s3_client = mock_client!(aws_sdk_s3, RuleMode::MatchAny, &[put_object]);
let config = aws_s3_transfer::Config::builder()
.s3_config(test_common::s3_config_with_test_http(
s3_client.config().to_builder(),
))
.build()
.expect("valid config");
let sut = aws_s3_transfer::Client::new(config);
let handle = sut
.upload_objects()
.bucket(bucket_name)
.source(test_dir.path())
.failure_policy(FailedTransferPolicy::Continue)
.initiate()
.unwrap();
let output = handle.join().await.unwrap();
assert_eq!(0, output.objects_uploaded());
assert_eq!(1, output.failed_transfers().len());
assert!(output.failed_transfers()[0].source_path().is_some());
assert_eq!(0, output.metrics.network_tx);
})
.await
.expect("test_server_error_should_be_recorded_as_such_in_failed_transfers timed out");
}
#[tokio::test]
async fn test_source_dir_not_valid() {
timeout(TEST_TIMEOUT, async {
let source = tempfile::NamedTempFile::new().unwrap();
let bucket_name = "test-bucket";
let config = aws_s3_transfer::Config::builder()
.s3_config(test_common::s3_config_with_test_http(
mock_s3_client_for_put_object(bucket_name.to_owned())
.config()
.to_builder(),
))
.build()
.expect("valid config");
let sut = aws_s3_transfer::Client::new(config);
let handle = sut
.upload_objects()
.bucket(bucket_name)
.source(source.path())
.initiate()
.unwrap();
let err = handle.join().await.unwrap_err();
assert_eq!(&ErrorKind::InputInvalid, err.kind());
})
.await
.expect("test_source_dir_not_valid timed out");
}
#[tokio::test]
async fn test_error_when_custom_delimiter_appears_in_filename() {
timeout(TEST_TIMEOUT, async {
let recursion_root = "test";
let files = vec![
("sample.jpg", 1),
("photos/2022-January/sample.jpg", 1),
("photos/2022-February/sample1.jpg", 1),
("photos/2022-February/sample2.jpg", 1),
("photos/2022-February/sample3.jpg", 1),
];
let test_dir = create_test_dir(Some(recursion_root), files.clone(), &[]);
let bucket_name = "test-bucket";
let config = aws_s3_transfer::Config::builder()
.s3_config(test_common::s3_config_with_test_http(
mock_s3_client_for_put_object(bucket_name.to_owned())
.config()
.to_builder(),
))
.build()
.expect("valid config");
let sut = aws_s3_transfer::Client::new(config);
let handle = sut
.upload_objects()
.bucket(bucket_name)
.source(test_dir.path())
.walker(FsWalker::builder().recursive(true).build())
.delimiter("-")
.initiate()
.unwrap();
let err = handle.join().await.unwrap_err();
assert_eq!(&ErrorKind::ChildOperationFailed, err.kind());
let child = std::error::Error::source(&err)
.and_then(|s| s.downcast_ref::<aws_s3_transfer::error::Error>())
.expect("the source is the failed child's error");
assert_eq!(&ErrorKind::InputInvalid, child.kind());
let cause = std::error::Error::source(child).expect("the child keeps its cause");
assert!(
cause
.to_string()
.contains("a custom delimiter `-` should not appear in"),
"the child's cause is the key derivation error, got: {cause}"
);
})
.await
.expect("test_error_when_custom_delimiter_appears_in_filename timed out");
}
#[tokio::test]
async fn test_abort_on_handle_should_terminate_tasks_gracefully() {
timeout(TEST_TIMEOUT, async {
let recursion_root = "test";
let files = vec![
("sample.jpg", 1),
("photos/2022-January/sample.jpg", 1),
("photos/2022-February/sample1.jpg", 1),
("photos/2022-February/sample2.jpg", 1),
("photos/2022-February/sample3.jpg", 1),
];
let test_dir = create_test_dir(Some(recursion_root), files.clone(), &[]);
let (watch_tx, watch_rx) = watch::channel(());
let bucket_name = "test-bucket";
let put_object = mock!(aws_sdk_s3::Client::put_object)
.match_requests(move |input| input.bucket() == Some(bucket_name))
.then_output({
let rx = watch_rx.clone();
move || {
while !rx.has_changed().unwrap() {}
PutObjectOutput::builder().build()
}
});
let s3_client = mock_client!(aws_sdk_s3, RuleMode::MatchAny, &[put_object]);
let config = aws_s3_transfer::Config::builder()
.s3_config(test_common::s3_config_with_test_http(
s3_client.config().to_builder(),
))
.build()
.expect("valid config");
let sut = aws_s3_transfer::Client::new(config);
let handle = sut
.upload_objects()
.bucket(bucket_name)
.source(test_dir.path())
.walker(FsWalker::builder().recursive(true).build())
.initiate()
.unwrap();
watch_tx.send(()).unwrap();
handle.abort().await;
})
.await
.expect("test_abort_on_handle_should_terminate_tasks_gracefully timed out");
}
#[tokio::test]
async fn test_failed_child_operation_should_cause_ongoing_requests_to_be_cancelled() {
timeout(TEST_TIMEOUT, async {
let recursion_root = "test";
let files = vec![
("sample.jpg", 1),
("photos/2022-January/sample.jpg", 1),
("photos/2022-February/sample1.jpg", 1),
("photos/2022-February/sample2.jpg", 1),
("photos/2022-February/sample3.jpg", 1),
];
let test_dir = create_test_dir(Some(recursion_root), files.clone(), &[]);
let bucket_name = "test-bucket";
let put_object = mock!(aws_sdk_s3::Client::put_object)
.match_requests(move |input| input.bucket() == Some(bucket_name))
.then_http_response(|| {
HttpResponse::new(StatusCode::try_from(500).unwrap(), SdkBody::empty())
});
let s3_client = mock_client!(aws_sdk_s3, RuleMode::MatchAny, &[put_object]);
let config = aws_s3_transfer::Config::builder()
.s3_config(test_common::s3_config_with_test_http(
s3_client.config().to_builder(),
))
.build()
.expect("valid config");
let sut = aws_s3_transfer::Client::new(config);
let handle = sut
.upload_objects()
.bucket(bucket_name)
.source(test_dir.path())
.walker(FsWalker::builder().recursive(true).build())
.initiate()
.unwrap();
let err = handle.join().await.unwrap_err();
assert_eq!(&ErrorKind::ChildOperationFailed, err.kind());
})
.await
.expect("test_failed_child_operation_should_cause_ongoing_requests_to_be_cancelled timed out");
}
#[tokio::test]
async fn test_aborted_upload_objects_error_source_is_failed_child_error() {
use aws_s3_transfer::error::Error;
timeout(TEST_TIMEOUT, async {
let test_dir = create_test_dir(
Some("test"),
vec![("a.txt", 1), ("denied.txt", 1), ("b.txt", 1)],
&[],
);
let denied = mock!(aws_sdk_s3::Client::put_object)
.match_requests(|input| input.key() == Some("denied.txt"))
.then_http_response(|| {
HttpResponse::new(
StatusCode::try_from(403).unwrap(),
SdkBody::from("<Error><Code>AccessDenied</Code></Error>"),
)
});
let put_object = mock!(aws_sdk_s3::Client::put_object)
.then_output(|| PutObjectOutput::builder().build());
let s3_client = mock_client!(aws_sdk_s3, RuleMode::MatchAny, &[denied, put_object]);
let config = aws_s3_transfer::Config::builder()
.s3_config(test_common::s3_config_with_test_http(
s3_client.config().to_builder(),
))
.build()
.expect("valid config");
let sut = aws_s3_transfer::Client::new(config);
let err = sut
.upload_objects()
.bucket("test-bucket")
.source(test_dir.path())
.failure_policy(FailedTransferPolicy::Abort)
.initiate()
.unwrap()
.join()
.await
.unwrap_err();
assert_eq!(&ErrorKind::ChildOperationFailed, err.kind());
let first = err
.failed_uploads()
.and_then(|f| f.first())
.expect("the aggregate carries the failed uploads");
assert_eq!(
Some("denied.txt"),
first
.source_path()
.and_then(|p| p.file_name())
.and_then(|n| n.to_str())
);
let source = std::error::Error::source(&err)
.and_then(|s| s.downcast_ref::<Error>())
.expect("the source is the failed child's error");
assert!(
std::ptr::eq(source, first.error()),
"the source is the first failed upload's error"
);
assert_eq!(Some("PutObject"), source.operation_name());
assert_eq!(Some("AccessDenied"), source.code());
let context = format!("{}", DisplayErrorContext(&err));
assert!(
context.contains("PutObject") && context.contains("AccessDenied"),
"the error context names the child's operation and code, got: {context}"
);
})
.await
.expect("test_aborted_upload_objects_error_source_is_failed_child_error timed out");
}
#[tokio::test]
async fn test_drop_upload_objects_handle() {
timeout(TEST_TIMEOUT, async {
let test_dir = create_test_dir(
Some("test"),
vec![
("sample.jpg", 1),
("photos/2022-January/sample.jpg", 1),
("photos/2022-February/sample1.jpg", 1),
("photos/2022-February/sample2.jpg", 1),
("photos/2022-February/sample3.jpg", 1),
],
&[],
);
let (watch_tx, watch_rx) = watch::channel(());
let bucket_name = "test-bucket";
let put_object = mock!(aws_sdk_s3::Client::put_object)
.match_requests(move |input| input.bucket() == Some(bucket_name))
.then_output({
move || {
let _ = watch_tx.send(());
PutObjectOutput::builder().build()
}
});
let s3_client = mock_client!(aws_sdk_s3, RuleMode::MatchAny, &[put_object]);
let config = aws_s3_transfer::Config::builder()
.s3_config(test_common::s3_config_with_test_http(
s3_client.config().to_builder(),
))
.build()
.expect("valid config");
let sut = aws_s3_transfer::Client::new(config);
let handle = sut
.upload_objects()
.bucket(bucket_name)
.source(test_dir.path())
.walker(FsWalker::builder().recursive(true).build())
.initiate()
.unwrap();
let rx = watch_rx.clone();
while !rx.has_changed().unwrap() {
tokio::time::sleep(Duration::from_millis(50)).await;
}
tokio::time::sleep(Duration::from_millis(100)).await;
drop(handle);
})
.await
.expect("test_drop_upload_objects_handle timed out");
}
#[tokio::test]
async fn test_metrics_correctness_on_success() {
timeout(TEST_TIMEOUT, async {
let files = vec![
("a.bin", 7),
("b.bin", 13),
("nested/c.bin", 19),
("nested/deep/d.bin", 23),
];
let total_bytes: u64 = files.iter().map(|(_, s)| *s as u64).sum();
let test_dir = create_test_dir(Some("test"), files.clone(), &[]);
let bucket_name = "test-bucket";
let config = aws_s3_transfer::Config::builder()
.s3_config(test_common::s3_config_with_test_http(
mock_s3_client_for_put_object(bucket_name.to_owned())
.config()
.to_builder(),
))
.build()
.expect("valid config");
let sut = aws_s3_transfer::Client::new(config);
let handle = sut
.upload_objects()
.bucket(bucket_name)
.source(test_dir.path())
.walker(FsWalker::builder().recursive(true).build())
.initiate()
.unwrap();
let elapsed = wait_for_finished_elapsed(|| handle.metrics()).await;
let output = handle.join().await.unwrap();
assert_eq!(4, output.objects_uploaded());
assert!(output.failed_transfers().is_empty());
assert_eq!(
total_bytes, output.metrics.network_tx,
"network_tx should equal sum of source file sizes"
);
assert_eq!(
total_bytes, output.metrics.disk_read,
"disk_read should equal sum of source file sizes"
);
assert_eq!(output.metrics.elapsed, elapsed);
})
.await
.expect("test_metrics_correctness_on_success timed out");
}
#[tokio::test]
async fn test_max_concurrent_uploads_one_serial_execution() {
timeout(TEST_TIMEOUT, async {
let files: Vec<(String, usize)> = (0..10).map(|i| (format!("f{i}.bin"), 3)).collect();
let files_ref: Vec<(&str, usize)> = files.iter().map(|(p, s)| (p.as_str(), *s)).collect();
let test_dir = create_test_dir(Some("test"), files_ref, &[]);
let bucket_name = "test-bucket";
let config = aws_s3_transfer::Config::builder()
.s3_config(test_common::s3_config_with_test_http(
mock_s3_client_for_put_object(bucket_name.to_owned())
.config()
.to_builder(),
))
.build()
.expect("valid config");
let sut = aws_s3_transfer::Client::new(config);
let handle = sut
.upload_objects()
.bucket(bucket_name)
.source(test_dir.path())
.walker(FsWalker::builder().recursive(true).build())
.max_concurrent_uploads(1)
.initiate()
.unwrap();
let output = handle.join().await.unwrap();
assert_eq!(10, output.objects_uploaded());
assert!(output.failed_transfers().is_empty());
assert_eq!(30, output.metrics.network_tx);
assert_eq!(30, output.metrics.disk_read);
})
.await
.expect("test_max_concurrent_uploads_one_serial_execution timed out");
}
#[tokio::test]
async fn test_deep_tree_subtree_claiming() {
timeout(TEST_TIMEOUT, async {
let files: Vec<(String, usize)> = (0..20)
.map(|i| (format!("sub_{i:02}/file.bin"), 5))
.collect();
let files_ref: Vec<(&str, usize)> = files.iter().map(|(p, s)| (p.as_str(), *s)).collect();
let test_dir = create_test_dir(Some("test"), files_ref, &[]);
let bucket_name = "test-bucket";
let config = aws_s3_transfer::Config::builder()
.s3_config(test_common::s3_config_with_test_http(
mock_s3_client_for_put_object(bucket_name.to_owned())
.config()
.to_builder(),
))
.build()
.expect("valid config");
let sut = aws_s3_transfer::Client::new(config);
let handle = sut
.upload_objects()
.bucket(bucket_name)
.source(test_dir.path())
.walker(FsWalker::builder().recursive(true).build())
.initiate()
.unwrap();
let output = handle.join().await.unwrap();
assert_eq!(
20,
output.objects_uploaded(),
"all 20 files in sibling subdirs must upload"
);
assert!(output.failed_transfers().is_empty());
assert_eq!(100, output.metrics.network_tx);
})
.await
.expect("test_deep_tree_subtree_claiming timed out");
}
#[tokio::test]
async fn test_walker_filter_restricts_uploads() {
timeout(TEST_TIMEOUT, async {
let files = vec![
("keep.txt", 4),
("skip.log", 4),
("nested/keep.txt", 4),
("nested/skip.log", 4),
];
let test_dir = create_test_dir(Some("test"), files.clone(), &[]);
let bucket_name = "test-bucket";
let config = aws_s3_transfer::Config::builder()
.s3_config(test_common::s3_config_with_test_http(
mock_s3_client_for_put_object(bucket_name.to_owned())
.config()
.to_builder(),
))
.build()
.expect("valid config");
let sut = aws_s3_transfer::Client::new(config);
let handle = sut
.upload_objects()
.bucket(bucket_name)
.source(test_dir.path())
.walker(
FsWalker::builder()
.recursive(true)
.filter(|entry| entry.path().extension().is_some_and(|ext| ext == "txt"))
.build(),
)
.initiate()
.unwrap();
let output = handle.join().await.unwrap();
assert_eq!(
2,
output.objects_uploaded(),
"only .txt files should upload"
);
assert!(output.failed_transfers().is_empty());
assert_eq!(8, output.metrics.network_tx);
})
.await
.expect("test_walker_filter_restricts_uploads timed out");
}
#[tokio::test]
async fn test_empty_source_directory() {
timeout(TEST_TIMEOUT, async {
let test_dir = create_test_dir(Some("test"), vec![], &[]);
let bucket_name = "test-bucket";
let config = aws_s3_transfer::Config::builder()
.s3_config(test_common::s3_config_with_test_http(
mock_s3_client_for_put_object(bucket_name.to_owned())
.config()
.to_builder(),
))
.build()
.expect("valid config");
let sut = aws_s3_transfer::Client::new(config);
let handle = sut
.upload_objects()
.bucket(bucket_name)
.source(test_dir.path())
.walker(FsWalker::builder().recursive(true).build())
.initiate()
.unwrap();
let elapsed = wait_for_finished_elapsed(|| handle.metrics()).await;
let output = handle.join().await.unwrap();
assert_eq!(0, output.objects_uploaded());
assert!(output.failed_transfers().is_empty());
assert_eq!(0, output.metrics.network_tx);
assert_eq!(0, output.metrics.disk_read);
assert_eq!(
output.metrics.elapsed, elapsed,
"a zero-work transfer must record its finish"
);
})
.await
.expect("test_empty_source_directory timed out");
}
#[tokio::test]
async fn test_interleaved_success_failure_continue() {
timeout(TEST_TIMEOUT, async {
let files = vec![
("a.bin", 4),
("b.bin", 4),
("doomed.bin", 4),
("c.bin", 4),
("d.bin", 4),
];
let test_dir = create_test_dir(Some("test"), files.clone(), &[]);
let bucket_name = "test-bucket";
let fail_match = mock!(aws_sdk_s3::Client::put_object)
.match_requests(move |input| {
input.bucket() == Some(bucket_name)
&& input.key().is_some_and(|k| k.ends_with("doomed.bin"))
})
.then_http_response(|| {
HttpResponse::new(StatusCode::try_from(500).unwrap(), SdkBody::empty())
});
let succeed_match = mock!(aws_sdk_s3::Client::put_object)
.match_requests(move |input| input.bucket() == Some(bucket_name))
.then_output(|| PutObjectOutput::builder().build());
let s3_client = mock_client!(aws_sdk_s3, RuleMode::MatchAny, &[fail_match, succeed_match]);
let config = aws_s3_transfer::Config::builder()
.s3_config(test_common::s3_config_with_test_http(
s3_client.config().to_builder(),
))
.build()
.expect("valid config");
let sut = aws_s3_transfer::Client::new(config);
let handle = sut
.upload_objects()
.bucket(bucket_name)
.source(test_dir.path())
.walker(FsWalker::builder().recursive(true).build())
.failure_policy(FailedTransferPolicy::Continue)
.initiate()
.unwrap();
let output = handle.join().await.unwrap();
assert_eq!(4, output.objects_uploaded());
assert_eq!(1, output.failed_transfers().len());
let failed = &output.failed_transfers()[0];
assert!(
failed.source_path().is_some(),
"failed upload must carry source_path"
);
assert!(
failed
.source_path()
.unwrap()
.to_string_lossy()
.ends_with("doomed.bin"),
"failed source_path should point at the failing file"
);
})
.await
.expect("test_interleaved_success_failure_continue timed out");
}
#[tokio::test]
async fn test_drop_during_walk_in_progress() {
timeout(TEST_TIMEOUT, async {
let files: Vec<(String, usize)> =
(0..50).map(|i| (format!("dir_{i:02}/f.bin"), 2)).collect();
let files_ref: Vec<(&str, usize)> = files.iter().map(|(p, s)| (p.as_str(), *s)).collect();
let test_dir = create_test_dir(Some("test"), files_ref, &[]);
let bucket_name = "test-bucket";
let config = aws_s3_transfer::Config::builder()
.s3_config(test_common::s3_config_with_test_http(
mock_s3_client_for_put_object(bucket_name.to_owned())
.config()
.to_builder(),
))
.build()
.expect("valid config");
let sut = aws_s3_transfer::Client::new(config);
let handle = sut
.upload_objects()
.bucket(bucket_name)
.source(test_dir.path())
.walker(FsWalker::builder().recursive(true).build())
.initiate()
.unwrap();
drop(handle);
tokio::time::sleep(Duration::from_millis(50)).await;
})
.await
.expect("test_drop_during_walk_in_progress timed out");
}
#[tokio::test]
async fn test_multipart_metrics_aggregate_across_children() {
timeout(TEST_TIMEOUT, async {
const MIN_MULTIPART: u64 = ByteSize::mib(5).as_u64();
let files = vec![
("a.bin", MIN_MULTIPART as usize),
("b.bin", MIN_MULTIPART as usize),
("nested/c.bin", MIN_MULTIPART as usize),
];
let expected_total: u64 = MIN_MULTIPART * 3;
let test_dir = create_test_dir(Some("test"), files.clone(), &[]);
let bucket_name = "test-bucket";
let config = aws_s3_transfer::Config::builder()
.s3_config(test_common::s3_config_with_test_http(
mock_s3_client_for_multipart_upload(bucket_name.to_owned())
.config()
.to_builder(),
))
.multipart_threshold(PartSize::Target(ByteSize::new(5)))
.build()
.expect("valid config");
let sut = aws_s3_transfer::Client::new(config);
let handle = sut
.upload_objects()
.bucket(bucket_name)
.source(test_dir.path())
.walker(FsWalker::builder().recursive(true).build())
.initiate()
.unwrap();
let output = handle.join().await.unwrap();
assert_eq!(3, output.objects_uploaded());
assert!(output.failed_transfers().is_empty());
assert_eq!(
expected_total, output.metrics.network_tx,
"network_tx should sum across all multipart children"
);
assert_eq!(
expected_total, output.metrics.disk_read,
"disk_read should sum across all multipart children (part_reader instruments it)"
);
})
.await
.expect("test_multipart_metrics_aggregate_across_children timed out");
}
#[tokio::test]
async fn test_status_transitions_to_terminal() {
timeout(TEST_TIMEOUT, async {
let test_dir = create_test_dir(Some("test"), vec![("a.bin", 1)], &[]);
let bucket_name = "test-bucket";
let config = aws_s3_transfer::Config::builder()
.s3_config(test_common::s3_config_with_test_http(
mock_s3_client_for_put_object(bucket_name.to_owned())
.config()
.to_builder(),
))
.build()
.expect("valid config");
let sut = aws_s3_transfer::Client::new(config);
let handle = sut
.upload_objects()
.bucket(bucket_name)
.source(test_dir.path())
.walker(FsWalker::builder().recursive(true).build())
.initiate()
.unwrap();
let output = handle.join().await.unwrap();
assert_eq!(1, output.objects_uploaded());
})
.await
.expect("test_status_transitions_to_terminal timed out");
}
#[tokio::test]
async fn test_hidden_files_uploaded_by_default() {
timeout(TEST_TIMEOUT, async {
let files = vec![
(".hidden.txt", 3),
("visible.txt", 3),
(".dotdir/inner.txt", 3),
];
let test_dir = create_test_dir(Some("test"), files.clone(), &[]);
let bucket_name = "test-bucket";
let config = aws_s3_transfer::Config::builder()
.s3_config(test_common::s3_config_with_test_http(
mock_s3_client_for_put_object(bucket_name.to_owned())
.config()
.to_builder(),
))
.build()
.expect("valid config");
let sut = aws_s3_transfer::Client::new(config);
let handle = sut
.upload_objects()
.bucket(bucket_name)
.source(test_dir.path())
.walker(FsWalker::builder().recursive(true).build())
.initiate()
.unwrap();
let output = handle.join().await.unwrap();
assert_eq!(
3,
output.objects_uploaded(),
"all files including dotfiles and files in dotdirs should upload"
);
assert!(output.failed_transfers().is_empty());
})
.await
.expect("test_hidden_files_uploaded_by_default timed out");
}
#[tokio::test(flavor = "multi_thread", worker_threads = 4)]
async fn test_multiple_iterations_on_same_client_do_not_hang() {
timeout(Duration::from_secs(60), async {
const FILE_COUNT: usize = 2000;
const ITERATIONS: usize = 3;
let files: Vec<(String, usize)> = (0..FILE_COUNT)
.map(|i| (format!("f/{i:04}.bin"), 32))
.collect();
let test_dir = create_test_dir(
Some("test"),
files.iter().map(|(k, s)| (k.as_str(), *s)).collect(),
&[],
);
let bucket_name = "test-bucket";
let config = aws_s3_transfer::Config::builder()
.s3_config(test_common::s3_config_with_test_http(
mock_s3_client_for_put_object(bucket_name.to_owned())
.config()
.to_builder(),
))
.build()
.expect("valid config");
let sut = aws_s3_transfer::Client::new(config);
for iter in 0..ITERATIONS {
let handle = sut
.upload_objects()
.bucket(bucket_name)
.source(test_dir.path())
.walker(FsWalker::builder().recursive(true).build())
.key_prefix(format!("iter{iter}/"))
.initiate()
.unwrap();
let output = handle.join().await.unwrap();
assert_eq!(
FILE_COUNT as u64,
output.objects_uploaded(),
"iteration {iter}: all files should upload"
);
assert!(
output.failed_transfers().is_empty(),
"iteration {iter}: no failures expected"
);
}
})
.await
.expect("test_multiple_iterations_on_same_client_do_not_hang timed out");
}
#[tokio::test(flavor = "multi_thread", worker_threads = 4)]
async fn test_concurrent_child_completion_terminates_cleanly() {
timeout(Duration::from_secs(30), async {
const FILE_COUNT: usize = 300;
let files: Vec<(String, usize)> = (0..FILE_COUNT)
.map(|i| (format!("f/{i:04}.bin"), 32))
.collect();
let test_dir = create_test_dir(
Some("test"),
files.iter().map(|(k, s)| (k.as_str(), *s)).collect(),
&[],
);
let bucket_name = "test-bucket";
let config = aws_s3_transfer::Config::builder()
.s3_config(test_common::s3_config_with_test_http(
mock_s3_client_for_put_object(bucket_name.to_owned())
.config()
.to_builder(),
))
.build()
.expect("valid config");
let sut = aws_s3_transfer::Client::new(config);
let handle = sut
.upload_objects()
.bucket(bucket_name)
.source(test_dir.path())
.walker(FsWalker::builder().recursive(true).build())
.initiate()
.unwrap();
let output = handle.join().await.unwrap();
assert_eq!(FILE_COUNT as u64, output.objects_uploaded());
assert!(output.failed_transfers().is_empty());
})
.await
.expect("test_concurrent_child_completion_terminates_cleanly timed out");
}
#[tokio::test(flavor = "multi_thread", worker_threads = 4)]
async fn test_continue_policy_records_all_failures_under_concurrent_orchestration() {
timeout(Duration::from_secs(30), async {
const FILE_COUNT: usize = 200;
let files: Vec<(String, usize)> = (0..FILE_COUNT)
.map(|i| (format!("f/{i:04}.bin"), 32))
.collect();
let test_dir = create_test_dir(
Some("test"),
files.iter().map(|(k, s)| (k.as_str(), *s)).collect(),
&[],
);
let bucket_name = "test-bucket";
let put_object = mock!(aws_sdk_s3::Client::put_object)
.match_requests(move |input| input.bucket() == Some(bucket_name))
.then_http_response(|| {
HttpResponse::new(StatusCode::try_from(503).unwrap(), SdkBody::from(""))
});
let s3 = mock_client!(aws_sdk_s3, RuleMode::MatchAny, &[&put_object]);
let config = aws_s3_transfer::Config::builder()
.s3_config(test_common::s3_config_with_test_http(
s3.config().to_builder(),
))
.build()
.expect("valid config");
let sut = aws_s3_transfer::Client::new(config);
let handle = sut
.upload_objects()
.bucket(bucket_name)
.source(test_dir.path())
.walker(FsWalker::builder().recursive(true).build())
.failure_policy(FailedTransferPolicy::Continue)
.initiate()
.unwrap();
let output = handle.join().await.unwrap();
assert_eq!(0, output.objects_uploaded());
assert_eq!(FILE_COUNT, output.failed_transfers().len());
})
.await
.expect("test_continue_policy_records_all_failures_under_concurrent_orchestration timed out");
}
#[tokio::test(flavor = "multi_thread", worker_threads = 4)]
async fn test_max_concurrent_uploads_respected_during_concurrent_orchestration() {
use std::sync::atomic::{AtomicUsize, Ordering};
use std::sync::Arc;
timeout(Duration::from_secs(30), async {
const FILE_COUNT: usize = 100;
const MAX_CONCURRENT: usize = 8;
let files: Vec<(String, usize)> = (0..FILE_COUNT)
.map(|i| (format!("{i:04}.bin"), 16))
.collect();
let test_dir = create_test_dir(
Some("test"),
files.iter().map(|(k, s)| (k.as_str(), *s)).collect(),
&[],
);
let in_flight = Arc::new(AtomicUsize::new(0));
let max_observed = Arc::new(AtomicUsize::new(0));
let in_flight_cb = Arc::clone(&in_flight);
let max_observed_cb = Arc::clone(&max_observed);
let bucket_name = "test-bucket";
let put_object = mock!(aws_sdk_s3::Client::put_object)
.match_requests(move |input| input.bucket() == Some(bucket_name))
.then_output(move || {
let current = in_flight_cb.fetch_add(1, Ordering::AcqRel) + 1;
max_observed_cb.fetch_max(current, Ordering::AcqRel);
std::thread::sleep(Duration::from_millis(2));
in_flight_cb.fetch_sub(1, Ordering::AcqRel);
PutObjectOutput::builder().build()
});
let s3 = mock_client!(aws_sdk_s3, RuleMode::MatchAny, &[&put_object]);
let config = aws_s3_transfer::Config::builder()
.s3_config(test_common::s3_config_with_test_http(s3.config().to_builder()))
.build()
.expect("valid config");
let sut = aws_s3_transfer::Client::new(config);
let handle = sut
.upload_objects()
.bucket(bucket_name)
.source(test_dir.path())
.walker(FsWalker::builder().recursive(true).build())
.max_concurrent_uploads(MAX_CONCURRENT)
.initiate()
.unwrap();
let output = handle.join().await.unwrap();
assert_eq!(FILE_COUNT as u64, output.objects_uploaded());
let observed = max_observed.load(Ordering::Acquire);
assert!(
observed <= MAX_CONCURRENT,
"max concurrent PutObjects ({observed}) exceeded max_concurrent_uploads ({MAX_CONCURRENT}); \
children_reserved must prevent over-spawning during lock-released orchestration"
);
})
.await
.expect("test_max_concurrent_uploads_respected_during_concurrent_orchestration timed out");
}
#[tokio::test(flavor = "multi_thread", worker_threads = 4)]
async fn test_abort_policy_terminates_cleanly_during_concurrent_orchestration() {
timeout(Duration::from_secs(30), async {
const FILE_COUNT: usize = 100;
const SUCCESS_COUNT: usize = 30;
const LATENCY: Duration = Duration::from_millis(15);
let files: Vec<(String, usize)> = (0..FILE_COUNT)
.map(|i| (format!("f/{i:04}.bin"), 32))
.collect();
let test_dir = create_test_dir(
Some("test"),
files.iter().map(|(k, s)| (k.as_str(), *s)).collect(),
&[],
);
let bucket_name = "test-bucket";
let config = aws_s3_transfer::Config::builder()
.s3_config(test_common::s3_config_with_test_http(
mock_s3_client_for_put_object_succeeds_then_fails(
bucket_name.to_owned(),
SUCCESS_COUNT,
LATENCY,
)
.config()
.to_builder(),
))
.build()
.expect("valid config");
let sut = aws_s3_transfer::Client::new(config);
let handle = sut
.upload_objects()
.bucket(bucket_name)
.source(test_dir.path())
.walker(FsWalker::builder().recursive(true).build())
.failure_policy(FailedTransferPolicy::Abort)
.initiate()
.unwrap();
let result = handle.join().await;
let err = result.expect_err("Abort policy must surface an error");
assert!(
matches!(
err.kind(),
aws_s3_transfer::error::ErrorKind::ChildOperationFailed
),
"expected ChildOperationFailed, got: {:?}",
err.kind(),
);
let source = std::error::Error::source(&err)
.and_then(|s| s.downcast_ref::<aws_s3_transfer::error::Error>())
.expect("the error's source is the failed child upload's error");
assert_eq!(
Some("PutObject"),
source.operation_name(),
"expected the failed PutObject as the abort cause, got: {source:?}",
);
})
.await
.expect("test_abort_policy_terminates_cleanly_during_concurrent_orchestration timed out");
}
#[tokio::test(flavor = "multi_thread", worker_threads = 4)]
async fn test_drop_during_active_uploads_cancels_without_hang() {
timeout(Duration::from_secs(30), async {
const FILE_COUNT: usize = 200;
const LATENCY: Duration = Duration::from_millis(20);
let files: Vec<(String, usize)> = (0..FILE_COUNT)
.map(|i| (format!("f/{i:04}.bin"), 32))
.collect();
let test_dir = create_test_dir(
Some("test"),
files.iter().map(|(k, s)| (k.as_str(), *s)).collect(),
&[],
);
let bucket_name = "test-bucket";
let config = aws_s3_transfer::Config::builder()
.s3_config(test_common::s3_config_with_test_http(
mock_s3_client_for_put_object_with_latency(bucket_name.to_owned(), LATENCY)
.config()
.to_builder(),
))
.build()
.expect("valid config");
let sut = aws_s3_transfer::Client::new(config);
let handle = sut
.upload_objects()
.bucket(bucket_name)
.source(test_dir.path())
.walker(FsWalker::builder().recursive(true).build())
.initiate()
.unwrap();
tokio::time::sleep(Duration::from_millis(50)).await;
let drop_start = std::time::Instant::now();
drop(handle);
let drop_elapsed = drop_start.elapsed();
assert!(
drop_elapsed < Duration::from_millis(50),
"drop took {drop_elapsed:?}; expected < 50ms, indicates a deadlock"
);
tokio::time::sleep(Duration::from_secs(2)).await;
})
.await
.expect("test_drop_during_active_uploads_cancels_without_hang timed out");
}
#[ignore = "stress repro, run with --ignored"]
#[tokio::test(flavor = "multi_thread", worker_threads = 8)]
async fn test_stress_multi_iter_reproduce_ec2_hang() {
timeout(Duration::from_secs(240), async {
const FILE_COUNT: usize = 10_000;
const ITERATIONS: usize = 3;
let files: Vec<(String, usize)> = (0..FILE_COUNT)
.map(|i| (format!("d{:03}/{i:05}.bin", i / 100), 32))
.collect();
let test_dir = create_test_dir(
Some("test"),
files.iter().map(|(k, s)| (k.as_str(), *s)).collect(),
&[],
);
let bucket_name = "test-bucket";
let config = aws_s3_transfer::Config::builder()
.s3_config(test_common::s3_config_with_test_http(
mock_s3_client_for_put_object(bucket_name.to_owned())
.config()
.to_builder(),
))
.build()
.expect("valid config");
let sut = aws_s3_transfer::Client::new(config);
for iter in 0..ITERATIONS {
let start = std::time::Instant::now();
let handle = sut
.upload_objects()
.bucket(bucket_name)
.source(test_dir.path())
.walker(FsWalker::builder().recursive(true).build())
.key_prefix(format!("iter{iter}/"))
.initiate()
.unwrap();
let output = handle.join().await.unwrap();
let elapsed = start.elapsed();
eprintln!(
"iter {iter} done in {elapsed:?}: uploaded={} failed={}",
output.objects_uploaded(),
output.failed_transfers().len()
);
assert_eq!(
FILE_COUNT as u64,
output.objects_uploaded(),
"iteration {iter}: all files should upload"
);
assert!(
output.failed_transfers().is_empty(),
"iteration {iter}: no failures expected"
);
}
})
.await
.expect("test_stress_multi_iter_reproduce_ec2_hang timed out");
}
fn mock_s3_client_for_put_object_with_latency(bucket_name: String, latency: Duration) -> Client {
let put_object = mock!(aws_sdk_s3::Client::put_object)
.match_requests(move |input| input.bucket() == Some(&bucket_name))
.then_compute_output(move |_input| {
std::thread::sleep(latency);
PutObjectOutput::builder().build()
});
mock_client!(aws_sdk_s3, RuleMode::MatchAny, &[put_object])
}
fn mock_s3_client_for_put_object_succeeds_then_fails(
bucket_name: String,
success_count: usize,
latency: Duration,
) -> Client {
use std::sync::atomic::{AtomicUsize, Ordering};
use std::sync::Arc;
let counter = Arc::new(AtomicUsize::new(0));
let put_object = mock!(aws_sdk_s3::Client::put_object)
.match_requests(move |input| input.bucket() == Some(&bucket_name))
.then_http_response(move || {
std::thread::sleep(latency);
let n = counter.fetch_add(1, Ordering::AcqRel);
if n < success_count {
let mut resp =
HttpResponse::new(StatusCode::try_from(200).unwrap(), SdkBody::from(""));
resp.headers_mut()
.insert("etag", "\"d41d8cd98f00b204e9800998ecf8427e\"");
resp
} else {
HttpResponse::new(StatusCode::try_from(503).unwrap(), SdkBody::from(""))
}
});
mock_client!(aws_sdk_s3, RuleMode::MatchAny, &[put_object])
}
#[ignore = "stress repro (~2 min), run with --ignored"]
#[tokio::test(flavor = "multi_thread", worker_threads = 8)]
async fn test_stress_parent_lock_contention() {
timeout(Duration::from_secs(180), async {
const FILE_COUNT: usize = 10_000;
const PUT_LATENCY: Duration = Duration::from_millis(10);
let files: Vec<(String, usize)> = (0..FILE_COUNT)
.map(|i| (format!("d{:03}/{i:05}.bin", i / 100), 32))
.collect();
let test_dir = create_test_dir(
Some("test"),
files.iter().map(|(k, s)| (k.as_str(), *s)).collect(),
&[],
);
let bucket_name = "test-bucket";
let config = aws_s3_transfer::Config::builder()
.s3_config(test_common::s3_config_with_test_http(mock_s3_client_for_put_object_with_latency(
bucket_name.to_owned(),
PUT_LATENCY,
).config().to_builder()))
.build()
.expect("valid config");
let sut = aws_s3_transfer::Client::new(config);
let start = std::time::Instant::now();
let handle = sut
.upload_objects()
.bucket(bucket_name)
.source(test_dir.path())
.walker(FsWalker::builder().recursive(true).build())
.initiate()
.unwrap();
let output = handle.join().await.unwrap();
let elapsed = start.elapsed();
eprintln!(
"upload done in {elapsed:?}: uploaded={} failed={}",
output.objects_uploaded(),
output.failed_transfers().len()
);
assert_eq!(
FILE_COUNT as u64,
output.objects_uploaded(),
"all files should upload — a stall here indicates the scheduler is not draining in-flight work, which usually means single-poll exclusivity has broken",
);
assert!(
output.failed_transfers().is_empty(),
"no failures expected under happy-path mock",
);
})
.await
.expect("test_stress_parent_lock_contention timed out — single-poll exclusivity on the composite descriptor is likely broken");
}
#[tokio::test]
async fn test_upload_objects_children_send_mpu_object_size() {
timeout(TEST_TIMEOUT, async {
let one_mib = ByteSize::mib(1).as_u64();
let files = vec![
("a.bin", (5 * one_mib) as usize),
("b.bin", (6 * one_mib) as usize),
("nested/c.bin", (7 * one_mib) as usize),
];
let test_dir = create_test_dir(Some("test"), files.clone(), &[]);
let bucket_name = "test-bucket";
let upload_id = "test-upload-id".to_owned();
let create_mpu = mock!(aws_sdk_s3::Client::create_multipart_upload).then_output({
let upload_id = upload_id.clone();
move || {
CreateMultipartUploadOutput::builder()
.upload_id(upload_id.clone())
.build()
}
});
let upload_part = mock!(aws_sdk_s3::Client::upload_part)
.then_output(|| UploadPartOutput::builder().e_tag("test-etag").build());
let expected_sizes: Vec<i64> = files
.iter()
.map(|(_, size)| *size as i64)
.collect();
let complete_mpu = mock!(aws_sdk_s3::Client::complete_multipart_upload)
.match_requests(move |req| {
req.mpu_object_size()
.is_some_and(|n| expected_sizes.contains(&n))
})
.then_output(|| CompleteMultipartUploadOutput::builder().build());
let client = mock_client!(
aws_sdk_s3,
RuleMode::MatchAny,
&[create_mpu, upload_part, complete_mpu]
);
let config = aws_s3_transfer::Config::builder()
.s3_config(test_common::s3_config_with_test_http(client.config().to_builder()))
.multipart_threshold(PartSize::Target(ByteSize::new(5)))
.build()
.expect("valid config");
let sut = aws_s3_transfer::Client::new(config);
let handle = sut
.upload_objects()
.bucket(bucket_name)
.source(test_dir.path())
.walker(FsWalker::builder().recursive(true).build())
.initiate()
.unwrap();
let output = handle.join().await.unwrap();
assert_eq!(
3,
output.objects_uploaded(),
"every child must send MpuObjectSize = its content length; a child whose CompleteMPU request omits the field will not match the mock and will fail",
);
assert!(
output.failed_transfers().is_empty(),
"no child should fail: {:?}",
output.failed_transfers(),
);
})
.await
.expect("test_upload_objects_children_send_mpu_object_size timed out");
}