use aws_s3_transfer::config::ReadAhead;
use aws_s3_transfer::{
io::InputStream,
types::{
builders::{DownloadInputBuilder, UploadInputBuilder},
ChecksumAlgorithm, ChecksumStrategy, ChunkMetadata, DownloadInput,
FailedMultipartUploadPolicy, Object, ObjectMetadata, Owner, RestoreStatus, UploadInput,
},
};
use aws_smithy_types::DateTime;
#[test]
fn modeled_inputs_use_real_tm_runtime_types_and_validate_required_fields() {
let _: DownloadInputBuilder = DownloadInput::builder();
let _: UploadInputBuilder = UploadInput::builder();
assert!(DownloadInput::builder().build().is_err());
assert!(UploadInput::builder().bucket("bucket").build().is_err());
let missing_body = UploadInput::builder()
.bucket("bucket")
.key("key")
.build()
.expect_err("a body is required");
assert!(
missing_body.to_string().contains("body"),
"error should name the missing field: {missing_body}"
);
let download = DownloadInput::builder()
.bucket("bucket")
.key("key")
.read_ahead(ReadAhead::Parts(2))
.build()
.unwrap();
assert_eq!(download.read_ahead(), Some(&ReadAhead::Parts(2)));
let upload = UploadInput::builder()
.bucket("bucket")
.key("key")
.body(InputStream::from_static(b"payload"))
.checksum_strategy(ChecksumStrategy::default())
.failed_multipart_upload_policy(FailedMultipartUploadPolicy::Retain)
.build()
.unwrap();
assert_eq!(upload.body().size_hint().upper(), Some(7));
assert!(upload.checksum_strategy().is_some());
assert!(matches!(
upload.failed_multipart_upload_policy(),
Some(FailedMultipartUploadPolicy::Retain)
));
}
#[test]
fn expiration_types_preserve_upload_timestamps_and_raw_response_strings() {
let time = DateTime::from_secs(123);
let builder = UploadInput::builder().expires(time);
assert_eq!(builder.get_expires(), &Some(time));
let upload = builder
.bucket("bucket")
.key("key")
.body(InputStream::from_static(b""))
.build()
.unwrap();
let expires: Option<&DateTime> = upload.expires();
assert_eq!(expires, Some(&time));
let download = DownloadInput::builder()
.bucket("bucket")
.key("key")
.response_expires(time)
.build()
.unwrap();
assert_eq!(download.response_expires(), Some(&time));
assert_eq!(
ObjectMetadata::builder()
.expires_string("invalid date")
.build()
.expires_string(),
Some("invalid date")
);
assert_eq!(
ChunkMetadata::builder()
.expires_string("also invalid")
.build()
.expires_string(),
Some("also invalid")
);
}
#[test]
fn nested_values_preserve_absence_false_zero_and_unknown_strings() {
assert_eq!(Object::builder().build().size(), None);
assert_eq!(Object::builder().size(0).build().size(), Some(0));
assert_eq!(
Object::builder().size(i64::MAX).build().size(),
Some(i64::MAX)
);
assert_eq!(
RestoreStatus::builder().build().is_restore_in_progress(),
None
);
assert_eq!(
RestoreStatus::builder()
.is_restore_in_progress(false)
.build()
.is_restore_in_progress(),
Some(false)
);
let future = ChecksumAlgorithm::from("FUTURE_ALGORITHM");
let object = Object::builder()
.owner(Owner::builder().id("owner").build())
.checksum_algorithm(future)
.build();
assert_eq!(object.owner().unwrap().id(), Some("owner"));
assert_eq!(object.checksum_algorithm()[0].as_str(), "FUTURE_ALGORITHM");
}
#[test]
fn metadata_identifiers_are_accessible_without_sdk_traits() {
let object = ObjectMetadata::builder().build();
let chunk = ChunkMetadata::builder().build();
assert_eq!(object.request_id(), None);
assert_eq!(object.extended_request_id(), None);
assert_eq!(chunk.request_id(), None);
assert_eq!(chunk.extended_request_id(), None);
}
#[test]
fn sensitive_input_and_builder_debug_redacts_real_modeled_members() {
let builder = UploadInput::builder().sse_kms_key_id("secret");
assert!(!format!("{builder:?}").contains("secret"));
let input = builder
.bucket("bucket")
.key("key")
.body(InputStream::from_static(b""))
.build()
.unwrap();
assert!(!format!("{input:?}").contains("secret"));
let input = DownloadInput::builder()
.bucket("bucket")
.key("key")
.sse_customer_key("secret")
.build()
.unwrap();
assert!(!format!("{input:?}").contains("secret"));
}
#[test]
fn existing_operation_input_paths_remain_available() {
let _: aws_s3_transfer::operation::download::DownloadInput =
aws_s3_transfer::operation::download::DownloadInput::builder()
.bucket("bucket")
.key("key")
.build()
.unwrap();
let _: aws_s3_transfer::operation::upload::UploadInput =
aws_s3_transfer::operation::upload::UploadInput::builder()
.bucket("bucket")
.key("key")
.body(InputStream::from_static(b""))
.build()
.unwrap();
}