mirror of
https://github.com/rustfs/rustfs.git
synced 2026-11-21 23:44:22 +00:00
Compare commits
19 Commits
| Author | SHA1 | Date | |
|---|---|---|---|
| c2e50b3b10 | |||
| 6fde592da1 | |||
| 98259d7c46 | |||
| b5a35fc2c7 | |||
| 11a7572bba | |||
| 4c4dc84671 | |||
| 52986eefd5 | |||
| 7a5ffcfee7 | |||
| 334d615a67 | |||
| 0c813e1a9e | |||
| 0de0b85374 | |||
| 78f78ce5ee | |||
| 82ad3f0007 | |||
| 82f094f4d5 | |||
| e1df1d569b | |||
| 19487a6e34 | |||
| 6177fc280f | |||
| 14db51bba7 | |||
| 353de54fcc |
@@ -1320,23 +1320,22 @@ mod tests {
|
||||
};
|
||||
for (index, expected_key) in ["a&local", "z-local"].into_iter().enumerate() {
|
||||
let request_marker = input.marker.clone().unwrap_or_default();
|
||||
let list_req = S3Request {
|
||||
input: input.clone(),
|
||||
method: http::Method::GET,
|
||||
uri: http::Uri::from_static("/"),
|
||||
headers: HeaderMap::new(),
|
||||
extensions: http::Extensions::new(),
|
||||
credentials: None,
|
||||
region: None,
|
||||
service: None,
|
||||
trailing_headers: None,
|
||||
};
|
||||
let envelope = crate::app::RequestEnvelope::from_s3s(&list_req);
|
||||
let gateway_input =
|
||||
rustfs_gateway_types::compat::s3s_5761ddfe::generated::ops::list_objects::input_from_s3s(
|
||||
list_req.input,
|
||||
input.clone(),
|
||||
)
|
||||
.expect("convert ListObjectsInput");
|
||||
let envelope = crate::app::RequestEnvelope::from_parts(
|
||||
crate::app::RequestHead {
|
||||
method: http::Method::GET,
|
||||
uri: http::Uri::from_static("/"),
|
||||
headers: HeaderMap::new(),
|
||||
credentials: None,
|
||||
region: None,
|
||||
service: None,
|
||||
},
|
||||
http::Extensions::new(),
|
||||
);
|
||||
let gateway_output = tokio::time::timeout(
|
||||
Duration::from_secs(10),
|
||||
DefaultBucketUsecase::from_global().execute_list_objects(envelope, gateway_input),
|
||||
|
||||
@@ -366,7 +366,7 @@ impl DefaultBucketUsecase {
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
use crate::app::bucket_usecase::test_support::{build_request, build_request_with_req_info, s3_op_total};
|
||||
use crate::app::bucket_usecase::test_support::{build_request_with_req_info, owned_envelope, s3_op_total};
|
||||
use http::Method;
|
||||
|
||||
#[test]
|
||||
@@ -399,11 +399,10 @@ mod tests {
|
||||
|
||||
/// The envelope of a request whose access phase installed `req_info`, or none.
|
||||
fn envelope(req_info: Option<ReqInfo>) -> RequestEnvelope {
|
||||
let req = match req_info {
|
||||
Some(req_info) => build_request_with_req_info((), Method::PUT, req_info),
|
||||
None => build_request((), Method::PUT),
|
||||
};
|
||||
RequestEnvelope::from_s3s(&req)
|
||||
match req_info {
|
||||
Some(req_info) => RequestEnvelope::from_s3s(&build_request_with_req_info((), Method::PUT, req_info)),
|
||||
None => owned_envelope(Method::PUT),
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
|
||||
@@ -203,7 +203,7 @@ impl DefaultBucketUsecase {
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
use crate::app::bucket_usecase::test_support::build_request;
|
||||
use crate::app::bucket_usecase::test_support::owned_envelope;
|
||||
use crate::app::storage_api::s3::dto::{self, PutBucketEncryptionInput, ServerSideEncryption};
|
||||
use http::Method;
|
||||
use rustfs_gateway_types::persistence::{
|
||||
@@ -292,20 +292,19 @@ mod tests {
|
||||
.build()
|
||||
.unwrap();
|
||||
|
||||
let req = build_request(input, Method::PUT);
|
||||
let prepared = crate::storage::persisted_from_s3s(&req.input.server_side_encryption_configuration);
|
||||
let prepared = crate::storage::persisted_from_s3s(&input.server_side_encryption_configuration);
|
||||
let usecase = DefaultBucketUsecase::without_context();
|
||||
|
||||
let err = usecase
|
||||
.execute_put_bucket_encryption(RequestEnvelope::from_s3s(&req), &req.input.bucket, prepared.map_err(Into::into))
|
||||
.execute_put_bucket_encryption(owned_envelope(Method::PUT), &input.bucket, prepared.map_err(Into::into))
|
||||
.await
|
||||
.unwrap_err();
|
||||
assert_eq!(err.code(), &S3ErrorCode::InternalError);
|
||||
|
||||
let err = usecase
|
||||
.execute_put_bucket_encryption(
|
||||
RequestEnvelope::from_s3s(&req),
|
||||
&req.input.bucket,
|
||||
owned_envelope(Method::PUT),
|
||||
&input.bucket,
|
||||
Ok(PersistedBucketEncryptionConfiguration { rules: vec![] }),
|
||||
)
|
||||
.await
|
||||
|
||||
@@ -405,7 +405,7 @@ mod tests {
|
||||
// waiter again on the single-thread test runtime.
|
||||
assert_eq!(admission.available_permits(), 1);
|
||||
}
|
||||
use crate::app::bucket_usecase::test_support::build_request;
|
||||
use crate::app::bucket_usecase::test_support::{build_request, owned_envelope};
|
||||
use crate::app::gating_test_env::{run_large_stack_test, shared_gating_ambient};
|
||||
use crate::app::runtime_sources::ServerContextSlot;
|
||||
use crate::app::storage_api::bucket_usecase::helper::MutationCompletionProbe;
|
||||
@@ -775,13 +775,12 @@ mod tests {
|
||||
.build()
|
||||
.unwrap();
|
||||
|
||||
let req = build_request(input, Method::PUT);
|
||||
let usecase = DefaultBucketUsecase::without_context();
|
||||
|
||||
let err = usecase
|
||||
.execute_put_bucket_lifecycle_configuration(
|
||||
RequestEnvelope::from_s3s(&req),
|
||||
&req.input.bucket,
|
||||
owned_envelope(Method::PUT),
|
||||
&input.bucket,
|
||||
PreparedLifecycleConfiguration::Missing,
|
||||
)
|
||||
.await
|
||||
|
||||
@@ -56,7 +56,7 @@ impl DefaultBucketUsecase {
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
use crate::app::bucket_usecase::test_support::build_request;
|
||||
use crate::app::bucket_usecase::test_support::{build_request, owned_envelope};
|
||||
use crate::app::bucket_usecase::{BucketOperations, DeleteBucketOptions, MakeBucketOptions};
|
||||
use crate::app::gating_test_env::{run_large_stack_test, shared_gating_ambient};
|
||||
use crate::app::runtime_sources::ServerContextSlot;
|
||||
@@ -75,10 +75,8 @@ mod tests {
|
||||
let context = shared_gating_ambient().await;
|
||||
let bucket = format!("logging-missing-{}", uuid::Uuid::new_v4().simple());
|
||||
let usecase = DefaultBucketUsecase::with_context(Some(context));
|
||||
let request = build_request((), Method::PUT);
|
||||
let envelope = RequestEnvelope::from_s3s(&request);
|
||||
let error = usecase
|
||||
.execute_put_bucket_logging(envelope, &bucket, || {
|
||||
.execute_put_bucket_logging(owned_envelope(Method::PUT), &bucket, || {
|
||||
Err(rustfs_s3_types::s3_error!(MalformedXML, "invalid logging configuration"))
|
||||
})
|
||||
.await
|
||||
|
||||
@@ -81,7 +81,7 @@ impl DefaultBucketUsecase {
|
||||
mod tests {
|
||||
use super::super::{BUCKET_ACCELERATE_CONFIG, BUCKET_REQUEST_PAYMENT_CONFIG};
|
||||
use super::*;
|
||||
use crate::app::bucket_usecase::test_support::{build_request, build_request_with_req_info};
|
||||
use crate::app::bucket_usecase::test_support::{build_request, build_request_with_req_info, owned_envelope};
|
||||
use crate::app::gating_test_env::{run_large_stack_test, shared_gating_ambient};
|
||||
use crate::app::runtime_sources::ServerContextSlot;
|
||||
use crate::app::storage_api::object_usecase::helper::MutationCompletionProbe;
|
||||
@@ -190,22 +190,21 @@ mod tests {
|
||||
let ambient = shared_gating_ambient().await;
|
||||
let usecase = DefaultBucketUsecase::with_context(Some(ambient));
|
||||
let bucket = format!("core-config-missing-{}", uuid::Uuid::new_v4().simple());
|
||||
let request = build_request((), http::Method::PUT);
|
||||
let mut converted = [false; 3];
|
||||
let accelerate = usecase
|
||||
.execute_put_bucket_accelerate_configuration(RequestEnvelope::from_s3s(&request), &bucket, || {
|
||||
.execute_put_bucket_accelerate_configuration(owned_envelope(http::Method::PUT), &bucket, || {
|
||||
converted[0] = true;
|
||||
Err(rustfs_s3_types::s3_error!(MalformedXML, "invalid acceleration"))
|
||||
})
|
||||
.await;
|
||||
let payment = usecase
|
||||
.execute_put_bucket_request_payment(RequestEnvelope::from_s3s(&request), &bucket, || {
|
||||
.execute_put_bucket_request_payment(owned_envelope(http::Method::PUT), &bucket, || {
|
||||
converted[1] = true;
|
||||
Err(rustfs_s3_types::s3_error!(MalformedXML, "invalid request payment"))
|
||||
})
|
||||
.await;
|
||||
let website = usecase
|
||||
.execute_put_bucket_website(RequestEnvelope::from_s3s(&request), &bucket, || {
|
||||
.execute_put_bucket_website(owned_envelope(http::Method::PUT), &bucket, || {
|
||||
converted[2] = true;
|
||||
Err(rustfs_s3_types::s3_error!(MalformedXML, "invalid website"))
|
||||
})
|
||||
|
||||
@@ -52,8 +52,19 @@ async fn object_lock_handlers_schedule_replication() {
|
||||
.expect("Failed to create object-lock bucket");
|
||||
upload_test_object(&ecstore, bucket.as_str(), object, b"worm payload").await;
|
||||
|
||||
let req = build_request((), Method::PUT);
|
||||
let envelope = || RequestEnvelope::from_s3s(&req);
|
||||
let envelope = || {
|
||||
RequestEnvelope::from_parts(
|
||||
crate::app::RequestHead {
|
||||
method: Method::PUT,
|
||||
uri: Uri::from_static("/"),
|
||||
headers: HeaderMap::new(),
|
||||
credentials: None,
|
||||
region: None,
|
||||
service: None,
|
||||
},
|
||||
Extensions::new(),
|
||||
)
|
||||
};
|
||||
|
||||
// A bucket without a replication configuration can skip the decision.
|
||||
MUST_REPLICATE_OBJECT_CALLS.store(0, Ordering::SeqCst);
|
||||
|
||||
@@ -22,7 +22,17 @@ const RESTORE_SUSPENDED_WAIT_TIMEOUT: Duration = Duration::from_secs(15);
|
||||
async fn suspend_test_bucket(bucket: &str) {
|
||||
DefaultBucketUsecase::from_global()
|
||||
.execute_put_bucket_versioning(
|
||||
crate::app::RequestEnvelope::from_s3s(&build_request((), Method::PUT)),
|
||||
crate::app::RequestEnvelope::from_parts(
|
||||
crate::app::RequestHead {
|
||||
method: Method::PUT,
|
||||
uri: Uri::from_static("/"),
|
||||
headers: HeaderMap::new(),
|
||||
credentials: None,
|
||||
region: None,
|
||||
service: None,
|
||||
},
|
||||
Extensions::new(),
|
||||
),
|
||||
bucket,
|
||||
Ok(rustfs_gateway_types::persistence::PersistedVersioningConfiguration {
|
||||
status: Some("Suspended".to_owned()),
|
||||
|
||||
@@ -545,10 +545,17 @@ mod tests {
|
||||
.key(key.to_owned())
|
||||
.build()
|
||||
.expect("valid create request DTO");
|
||||
let error = make_usecase()
|
||||
.execute_create_multipart_upload_from_s3s(build_request(create, Method::POST))
|
||||
let error = match make_usecase()
|
||||
.execute_create_multipart_upload(
|
||||
owned_envelope(Method::POST),
|
||||
super::create_values::CreateMultipartUploadFields::from_legacy(create),
|
||||
None,
|
||||
)
|
||||
.await
|
||||
.expect_err("reserved key must be rejected before accessing storage");
|
||||
{
|
||||
Err(error) => crate::app::storage_api::s3::S3Error::from(error),
|
||||
Ok(_) => panic!("reserved key must be rejected before accessing storage"),
|
||||
};
|
||||
assert_eq!(error.code(), &crate::app::storage_api::s3::S3ErrorCode::InvalidArgument);
|
||||
|
||||
let complete = CompleteMultipartUploadInput::builder()
|
||||
@@ -558,9 +565,15 @@ mod tests {
|
||||
.multipart_upload(Some(CompletedMultipartUpload::default()))
|
||||
.build()
|
||||
.expect("valid complete request DTO");
|
||||
let error = Box::pin(make_usecase().complete_for_s3s_request(build_request(complete, Method::POST)))
|
||||
.await
|
||||
.expect_err("uploads created before the fix must not publish reserved keys");
|
||||
let error =
|
||||
match rustfs_gateway_types::compat::s3s_5761ddfe::generated::ops::complete_multipart_upload::input_from_s3s(
|
||||
complete,
|
||||
) {
|
||||
Err(error) => crate::app::dto_values::seam_error(error),
|
||||
Ok(input) => Box::pin(make_usecase().execute_complete_multipart_upload(owned_envelope(Method::POST), input))
|
||||
.await
|
||||
.expect_err("uploads created before the fix must not publish reserved keys"),
|
||||
};
|
||||
assert_eq!(error.code(), &rustfs_s3_types::S3ErrorCode::InvalidArgument);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1124,10 +1124,9 @@ mod tests {
|
||||
crate::app::gating_test_env::run_large_stack_test("ssec-completion-checksums", || async {
|
||||
let (_store, bucket) =
|
||||
crate::app::gating_test_env::durable_quota_test_bucket("ssec-completion-checksums", 16_384).await;
|
||||
let versioning_req = build_request((), Method::PUT);
|
||||
crate::app::bucket_usecase::DefaultBucketUsecase::from_global()
|
||||
.execute_put_bucket_versioning(
|
||||
RequestEnvelope::from_s3s(&versioning_req),
|
||||
super::super::test_support::owned_envelope(Method::PUT),
|
||||
&bucket,
|
||||
Ok(rustfs_gateway_types::persistence::PersistedVersioningConfiguration {
|
||||
status: Some("Enabled".to_owned()),
|
||||
@@ -1304,16 +1303,13 @@ mod tests {
|
||||
|
||||
let bucket_usecase = crate::app::bucket_usecase::DefaultBucketUsecase::from_global();
|
||||
// Listings carry neither the SSE-C key nor a per-object decryption request.
|
||||
let versions_req = build_request(
|
||||
ListObjectVersionsInput {
|
||||
bucket: bucket.to_string(),
|
||||
prefix: Some(key.to_string()),
|
||||
..Default::default()
|
||||
},
|
||||
Method::GET,
|
||||
);
|
||||
let versions_env = RequestEnvelope::from_s3s(&versions_req);
|
||||
let versions_in = list_object_versions::input_from_s3s(versions_req.input).expect("convert ListObjectVersionsInput");
|
||||
let versions_input = ListObjectVersionsInput {
|
||||
bucket: bucket.to_string(),
|
||||
prefix: Some(key.to_string()),
|
||||
..Default::default()
|
||||
};
|
||||
let versions_env = super::super::test_support::owned_envelope(Method::GET);
|
||||
let versions_in = list_object_versions::input_from_s3s(versions_input).expect("convert ListObjectVersionsInput");
|
||||
let versions = list_object_versions::output_to_s3s(
|
||||
bucket_usecase
|
||||
.execute_list_object_versions(versions_env, versions_in)
|
||||
@@ -1328,16 +1324,13 @@ mod tests {
|
||||
assert_eq!(entries[0].e_tag.as_ref(), Some(etag));
|
||||
assert_xml_etag(&versions, etag);
|
||||
|
||||
let v1_req = build_request(
|
||||
ListObjectsInput {
|
||||
bucket: bucket.to_string(),
|
||||
prefix: Some(key.to_string()),
|
||||
..Default::default()
|
||||
},
|
||||
Method::GET,
|
||||
);
|
||||
let v1_env = RequestEnvelope::from_s3s(&v1_req);
|
||||
let v1_in = list_objects::input_from_s3s(v1_req.input).expect("convert ListObjectsInput");
|
||||
let v1_input = ListObjectsInput {
|
||||
bucket: bucket.to_string(),
|
||||
prefix: Some(key.to_string()),
|
||||
..Default::default()
|
||||
};
|
||||
let v1_env = super::super::test_support::owned_envelope(Method::GET);
|
||||
let v1_in = list_objects::input_from_s3s(v1_input).expect("convert ListObjectsInput");
|
||||
let v1 = list_objects::output_to_s3s(
|
||||
bucket_usecase
|
||||
.execute_list_objects(v1_env, v1_in)
|
||||
@@ -1411,7 +1404,6 @@ mod tests {
|
||||
.await
|
||||
.expect("create versioned Object Lock bucket");
|
||||
let key = "kms-encrypted";
|
||||
let enc_req = build_request((), Method::PUT);
|
||||
let enc_cfg = crate::app::storage_api::s3::dto::ServerSideEncryptionConfiguration {
|
||||
rules: vec![crate::app::storage_api::s3::dto::ServerSideEncryptionRule {
|
||||
apply_server_side_encryption_by_default: Some(
|
||||
@@ -1425,7 +1417,7 @@ mod tests {
|
||||
};
|
||||
let prepared = crate::storage::persisted_from_s3s(&enc_cfg).map_err(Into::into);
|
||||
crate::app::bucket_usecase::DefaultBucketUsecase::from_global()
|
||||
.execute_put_bucket_encryption(RequestEnvelope::from_s3s(&enc_req), &bucket, prepared)
|
||||
.execute_put_bucket_encryption(super::super::test_support::owned_envelope(Method::PUT), &bucket, prepared)
|
||||
.await
|
||||
.expect("configure bucket-default SSE-KMS");
|
||||
let usecase = DefaultMultipartUsecase::from_global();
|
||||
|
||||
@@ -545,10 +545,17 @@ mod tests {
|
||||
.object_lock_retain_until_date(date.map(Timestamp::from))
|
||||
.build()
|
||||
.expect("direct fixture DTO");
|
||||
let error = make_usecase()
|
||||
.execute_create_multipart_upload_from_s3s(build_request(input, Method::POST))
|
||||
let error = match make_usecase()
|
||||
.execute_create_multipart_upload(
|
||||
owned_envelope(Method::POST),
|
||||
CreateMultipartUploadFields::from_legacy(input),
|
||||
None,
|
||||
)
|
||||
.await
|
||||
.expect_err("direct fixture does not create an upload");
|
||||
{
|
||||
Err(error) => crate::app::storage_api::s3::S3Error::from(error),
|
||||
Ok(_) => panic!("direct fixture does not create an upload"),
|
||||
};
|
||||
assert_eq!(
|
||||
(error.code().as_str(), error.message()),
|
||||
(expected.0, Some(expected.1)),
|
||||
|
||||
@@ -14,7 +14,7 @@
|
||||
|
||||
//! ListParts execution against real multipart metadata and the native claim exchange.
|
||||
|
||||
use super::super::test_support::{Method, build_request};
|
||||
use super::super::test_support::{Method, build_request, owned_envelope};
|
||||
use super::*;
|
||||
use crate::app::gating_test_env::{run_large_stack_test, shared_gating_ambient, shared_gating_ecstore_and_disk_paths};
|
||||
use crate::app::storage_api::multipart_usecase::access::{AuthorizationRequest, load_bucket_generation_from_store};
|
||||
@@ -81,7 +81,7 @@ fn list_parts_resolves_real_owners_and_retains_storage_errors() {
|
||||
let key = "fixture/one";
|
||||
let foreign_key = "fixture/two";
|
||||
let opts = ObjectOptions::default();
|
||||
let envelope = || RequestEnvelope::from_s3s(&build_request((), Method::GET));
|
||||
let envelope = || owned_envelope(Method::GET);
|
||||
for name in [&bucket, &foreign_bucket] {
|
||||
store
|
||||
.make_bucket(name, &MakeBucketOptions::default())
|
||||
|
||||
@@ -741,9 +741,13 @@ mod tests {
|
||||
.part_number(1)
|
||||
.build()
|
||||
.unwrap();
|
||||
let req = build_request(input, Method::PUT);
|
||||
|
||||
let err = make_usecase().execute_upload_part(req).await.unwrap_err();
|
||||
let err = match make_usecase()
|
||||
.execute_upload_part_with_audit(owned_envelope(Method::PUT), UploadPartWriteInput::from_legacy(input, None))
|
||||
.await
|
||||
{
|
||||
Err(error) => crate::app::storage_api::s3::S3Error::from(error),
|
||||
Ok(_) => panic!("missing body must be rejected"),
|
||||
};
|
||||
assert_eq!(err.code(), &LegacyErrorCode::IncompleteBody);
|
||||
}
|
||||
|
||||
@@ -765,9 +769,13 @@ mod tests {
|
||||
.content_length(Some(declared))
|
||||
.build()
|
||||
.unwrap();
|
||||
let req = build_request(input, Method::PUT);
|
||||
|
||||
let err = make_usecase().execute_upload_part(req).await.unwrap_err();
|
||||
let err = match make_usecase()
|
||||
.execute_upload_part_with_audit(owned_envelope(Method::PUT), UploadPartWriteInput::from_legacy(input, None))
|
||||
.await
|
||||
{
|
||||
Err(error) => crate::app::storage_api::s3::S3Error::from(error),
|
||||
Ok(_) => panic!("declared part must be rejected"),
|
||||
};
|
||||
if expect_too_large {
|
||||
assert_eq!(err.code(), &LegacyErrorCode::EntityTooLarge, "declared {declared}");
|
||||
assert_eq!(polls.load(std::sync::atomic::Ordering::SeqCst), 0, "body must not be polled");
|
||||
@@ -787,9 +795,13 @@ mod tests {
|
||||
.part_number(part_number)
|
||||
.build()
|
||||
.unwrap();
|
||||
let req = build_request(input, Method::PUT);
|
||||
|
||||
let err = make_usecase().execute_upload_part(req).await.unwrap_err();
|
||||
let err = match make_usecase()
|
||||
.execute_upload_part_with_audit(owned_envelope(Method::PUT), UploadPartWriteInput::from_legacy(input, None))
|
||||
.await
|
||||
{
|
||||
Err(error) => crate::app::storage_api::s3::S3Error::from(error),
|
||||
Ok(_) => panic!("invalid part number must be rejected"),
|
||||
};
|
||||
assert_eq!(err.code(), &LegacyErrorCode::InvalidArgument);
|
||||
assert_eq!(err.message(), Some("partNumber must be between 1 and 10000"));
|
||||
}
|
||||
|
||||
@@ -14,6 +14,7 @@
|
||||
|
||||
//! Upload target ownership and refusal order against real multipart state.
|
||||
|
||||
use super::super::super::test_support::owned_envelope;
|
||||
use super::*;
|
||||
use crate::app::storage_api::test::contract::bucket::{BucketOperations as _, MakeBucketOptions};
|
||||
use rustfs_gateway_types::{BucketName, ObjectKey, UploadIdClaim};
|
||||
@@ -101,7 +102,7 @@ async fn native_claim_checks_order_ownership_and_one_active_lookup() {
|
||||
Body::from(Bytes::from_static(b"abc"))
|
||||
}
|
||||
});
|
||||
let envelope = RequestEnvelope::from_s3s(&build_request((), Method::PUT));
|
||||
let envelope = owned_envelope(Method::PUT);
|
||||
LOOKUP
|
||||
.scope((Cell::new(0), mode), async {
|
||||
let result = usecase.execute_upload_part_with_audit(envelope, input).await;
|
||||
@@ -211,7 +212,7 @@ fn native_copy_part_rejects_unproved_owner_without_changing_parts() {
|
||||
copy_source_sse_customer_key: None,
|
||||
copy_source_sse_customer_key_md5: None,
|
||||
};
|
||||
let envelope = RequestEnvelope::from_s3s(&build_request((), Method::PUT));
|
||||
let envelope = owned_envelope(Method::PUT);
|
||||
LOOKUP
|
||||
.scope((Cell::new(0), mode), async {
|
||||
let result = Box::pin(usecase.execute_upload_part_copy_with_audit(envelope, input)).await;
|
||||
|
||||
@@ -258,8 +258,17 @@ mod tests {
|
||||
sse_customer_key: None,
|
||||
sse_customer_key_md5: None,
|
||||
};
|
||||
let request = build_request((), http::Method::GET);
|
||||
let envelope = RequestEnvelope::from_s3s(&request);
|
||||
let envelope = RequestEnvelope::from_parts(
|
||||
crate::app::RequestHead {
|
||||
method: http::Method::GET,
|
||||
uri: http::Uri::from_static("/"),
|
||||
headers: http::HeaderMap::new(),
|
||||
credentials: None,
|
||||
region: None,
|
||||
service: None,
|
||||
},
|
||||
http::Extensions::new(),
|
||||
);
|
||||
let error = DefaultObjectUsecase::without_context()
|
||||
.execute_get_object_attributes(envelope, fields)
|
||||
.await
|
||||
|
||||
Reference in New Issue
Block a user