Compare commits

...

3 Commits

Author SHA1 Message Date
overtrue 9b6d60e934 test(object): own method-only put envelopes
Twelve header-free puts call the owned entry point, and each assertion stays
on the same output and error code.
2026-11-22 23:45:26 +08:00
overtrue bb94ec983b test(object): own the invalid-storage-class put envelope
The storage-class rejection carries no request headers, so it uses the owned
request and still rejects the class before any store call.
2026-11-22 23:41:23 +08:00
overtrue 6a1b92b783 test(object): own the SSE-C put envelope
The boundary put carries no request headers, so it uses the owned request
and still stores the customer-key object.
2026-11-22 23:05:30 +08:00
2 changed files with 54 additions and 19 deletions
+12 -2
View File
@@ -543,8 +543,18 @@ async fn ssec_wire_contract(usecase: &DefaultObjectUsecase, server: &crate::embe
.build()
.unwrap();
{
let (envelope, input) =
crate::app::object_usecase::PutObjectWriteInput::from_test_request(build_request(input, Method::PUT));
let envelope = crate::app::RequestEnvelope::from_parts(
crate::app::RequestHead {
method: Method::PUT,
uri: http::Uri::from_static("/"),
headers: http::HeaderMap::new(),
credentials: None,
region: None,
service: None,
},
http::Extensions::new(),
);
let input = crate::app::object_usecase::PutObjectWriteInput::from_legacy(input, None);
crate::app::test_seams::put_object(usecase, envelope, input)
}
.await
+42 -17
View File
@@ -2624,6 +2624,35 @@ mod tests {
.map_err(S3Error::from)
}
/// Method-only envelope. `build_request` leaves the URI as `/`, the headers empty, and the trailing headers absent.
fn method_only_put_envelope() -> crate::app::RequestEnvelope {
crate::app::RequestEnvelope::from_parts(
crate::app::RequestHead {
method: Method::PUT,
uri: http::Uri::from_static("/"),
headers: HeaderMap::new(),
credentials: None,
region: None,
service: None,
},
http::Extensions::new(),
)
}
async fn put_method_only(usecase: &DefaultObjectUsecase, input: PutObjectInput) -> S3Result<PutObjectWriteOutput> {
let input = PutObjectWriteInput::from_legacy(input, None);
Box::pin(usecase.execute_put_object_owned(method_only_put_envelope(), input))
.await
.map_err(S3Error::from)
}
async fn put_extract_method_only(usecase: &DefaultObjectUsecase, input: PutObjectInput) -> S3Result<PutObjectWriteOutput> {
let input = PutObjectWriteInput::from_legacy(input, None);
Box::pin(usecase.execute_put_object_extract_owned(method_only_put_envelope(), input))
.await
.map_err(S3Error::from)
}
#[tokio::test]
#[serial_test::serial]
async fn s3_put_uses_tail_drained_completion_before_acknowledgement() {
@@ -2647,7 +2676,7 @@ mod tests {
let usecase = DefaultObjectUsecase::with_context(Some(context));
let (response, observed) = PUT_STORAGE_TEST_COMPLETION
.scope(std::cell::Cell::new(None), async {
let response = Box::pin(put_owned(&usecase, build_request(input, Method::PUT))).await;
let response = Box::pin(put_method_only(&usecase, input)).await;
(response, PUT_STORAGE_TEST_COMPLETION.with(std::cell::Cell::get))
})
.await;
@@ -2746,7 +2775,7 @@ mod tests {
..Default::default()
};
let error = runtime
.block_on(Box::pin(put_extract_owned(&usecase, build_request(input, Method::PUT))))
.block_on(Box::pin(put_extract_method_only(&usecase, input)))
.expect_err("missing archive body");
assert_eq!(error.code(), &S3ErrorCode::IncompleteBody);
assert_eq!(
@@ -2795,7 +2824,7 @@ mod tests {
// The gateway's dispatch names the operation before the use case runs.
Box::pin(async {
rustfs_io_metrics::record_s3_op(S3Operation::PutObject);
put_owned(&usecase, build_request(input, Method::PUT)).await
put_method_only(&usecase, input).await
}),
));
runtime.block_on(std::future::poll_fn(|cx| {
@@ -3291,7 +3320,7 @@ mod tests {
.build()
.expect("PUT input must build");
let put_usecase = DefaultObjectUsecase::with_context(Some(context));
let put = tokio::spawn(async move { put_owned(&put_usecase, build_request(put_input, Method::PUT)).await });
let put = tokio::spawn(async move { put_method_only(&put_usecase, put_input).await });
tokio::time::timeout(Duration::from_secs(2), async {
while !object_traffic_health.snapshot().write_stalled {
tokio::task::yield_now().await;
@@ -3519,8 +3548,7 @@ mod tests {
.build()
.expect("zero-copy PUT input must build");
let zero_copy_usecase = DefaultObjectUsecase::with_context(Some(context));
let zero_copy_put =
tokio::spawn(async move { put_owned(&zero_copy_usecase, build_request(zero_copy_input, Method::PUT)).await });
let zero_copy_put = tokio::spawn(async move { put_method_only(&zero_copy_usecase, zero_copy_input).await });
tokio::time::timeout(Duration::from_secs(30), async {
while !object_traffic_health.snapshot().write_stalled {
@@ -4596,10 +4624,9 @@ mod tests {
.build()
.unwrap();
let req = build_request(input, Method::PUT);
let usecase = DefaultObjectUsecase::without_context();
let err = Box::pin(put_owned(&usecase, req)).await.unwrap_err();
let err = Box::pin(put_method_only(&usecase, input)).await.unwrap_err();
assert_eq!(err.code(), &S3ErrorCode::InvalidStorageClass);
}
@@ -4821,7 +4848,7 @@ mod tests {
.expect("SSE-C PUT input must build");
let usecase = DefaultObjectUsecase::from_global();
let response = put_owned(&usecase, build_request(input, Method::PUT))
let response = put_method_only(&usecase, input)
.await
.unwrap_or_else(|err| panic!("a {algorithm} default bucket must accept an SSE-C PUT: {err:?}"));
assert_eq!(response.server_side_encryption, None);
@@ -4990,7 +5017,7 @@ mod tests {
.build()
.expect("legacy quota PUT input should build");
let err = put_owned(&DefaultObjectUsecase::from_global(), build_request(input, Method::PUT))
let err = put_method_only(&DefaultObjectUsecase::from_global(), input)
.await
.expect_err("4 GiB used plus a 2 GiB PUT must exceed a 5 GiB legacy quota");
assert_eq!(err.code(), &S3ErrorCode::InvalidRequest);
@@ -5036,7 +5063,7 @@ mod tests {
.content_length(Some(i64::try_from(payload.len()).expect("test payload length must fit i64")))
.build()
.expect("PUT input should build");
put_owned(&DefaultObjectUsecase::from_global(), build_request(input, Method::PUT))
put_method_only(&DefaultObjectUsecase::from_global(), input)
.await
.expect("a ledger-admitted bucket must accept a write without scanner usage");
@@ -5048,7 +5075,7 @@ mod tests {
.content_length(Some(i64::try_from(too_large.len()).expect("test payload length must fit i64")))
.build()
.expect("PUT input should build");
let err = put_owned(&DefaultObjectUsecase::from_global(), build_request(input, Method::PUT))
let err = put_method_only(&DefaultObjectUsecase::from_global(), input)
.await
.expect_err("the ledger must still reject a write above the quota limit");
assert_eq!(err.code(), &S3ErrorCode::InvalidRequest);
@@ -5451,7 +5478,7 @@ mod tests {
.expect("PUT input must build");
let usecase = DefaultObjectUsecase::with_context(Some(Arc::clone(&context)));
let err = Box::pin(put_owned(&usecase, build_request(input, Method::PUT)))
let err = Box::pin(put_method_only(&usecase, input))
.await
.expect_err("an unreadable bucket encryption configuration must refuse the write");
@@ -5496,9 +5523,7 @@ mod tests {
metrics::with_local_recorder(&recorder, || {
request.in_scope(|| {
runtime.block_on(async {
Box::pin(put_owned(&usecase, build_request(input, Method::PUT)))
.await
.expect("S3 PUT must commit");
Box::pin(put_method_only(&usecase, input)).await.expect("S3 PUT must commit");
assert_eq!(current_s3_http_operation_name(), Some("s3:PutObject"));
assert_eq!(crate::app::storage_api::diagnostic::current_read_version_entry_source(), None);
})
@@ -5563,7 +5588,7 @@ mod tests {
.expect("PUT input must build");
let usecase = DefaultObjectUsecase::with_context(Some(Arc::clone(&context)));
Box::pin(put_owned(&usecase, build_request(input, Method::PUT)))
Box::pin(put_method_only(&usecase, input))
.await
.expect("a bucket without default encryption must still accept a plaintext write");