From 511ad31ba0ec5877ed315e5aea89d62295a43d09 Mon Sep 17 00:00:00 2001 From: Zhengchao An Date: Tue, 7 Jul 2026 04:36:16 +0800 Subject: [PATCH] fix(s3): normalize root double-slash ListBuckets requests (#4336) test(s3): MinIO parity for double-slash ListBuckets, invalid copy-source date, region-aware CreateBucket - Add DoubleSlashListBucketsCompatLayer: rewrite `GET //` to `GET /` so it routes to ListBuckets, matching MinIO browser-client behavior (#601) - Add e2e regression coverage for invalid copy-source conditional date headers (#618) and region-aware MakeBucket(us-east-1) (#629) Refs rustfs/backlog#601 #618 #629 --- .../src/copy_source_invalid_date_test.rs | 142 ++++++++++++++++ .../e2e_test/src/create_bucket_region_test.rs | 82 ++++++++++ crates/e2e_test/src/lib.rs | 12 ++ .../src/list_buckets_double_slash_test.rs | 137 ++++++++++++++++ rustfs/src/server/http.rs | 9 +- rustfs/src/server/layer.rs | 151 ++++++++++++++++++ 6 files changed, 530 insertions(+), 3 deletions(-) create mode 100644 crates/e2e_test/src/copy_source_invalid_date_test.rs create mode 100644 crates/e2e_test/src/create_bucket_region_test.rs create mode 100644 crates/e2e_test/src/list_buckets_double_slash_test.rs diff --git a/crates/e2e_test/src/copy_source_invalid_date_test.rs b/crates/e2e_test/src/copy_source_invalid_date_test.rs new file mode 100644 index 000000000..1513dddce --- /dev/null +++ b/crates/e2e_test/src/copy_source_invalid_date_test.rs @@ -0,0 +1,142 @@ +// Copyright 2024 RustFS Team +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +//! Regression coverage for rustfs/backlog#618 item 8: `CopyObject` with an +//! unparsable `x-amz-copy-source-if-unmodified-since` value. +//! +//! `minio-js` `CopyConditions.setUnmodified(new Date(undefined))` serialises the +//! header value as the literal string `"Invalid Date"` (via `Date.toUTCString()`) +//! and signs it. MinIO parses this header from the raw request and *ignores* it +//! when it fails to parse (`amztime.ParseHeader` error is swallowed), so the copy +//! proceeds. +//! +//! RustFS routes S3 through the `s3s` crate, which models the copy-source +//! conditional-date headers as typed `Timestamp` fields and rejects an +//! unparsable value with `400 InvalidArgument` during request deserialization — +//! this happens *after* SigV4 verification but *before* the RustFS `CopyObject` +//! handler runs. Because the header is part of the client's `SignedHeaders`, the +//! value cannot be stripped or rewritten by a pre-`s3s` layer without breaking the +//! signature, and `s3s` exposes no hook between auth and typed deserialization. +//! Matching MinIO's tolerant behavior therefore requires a change in `s3s` +//! (lenient parsing of conditional-date headers). See the PR description for +//! details. +//! +//! This test pins the two ends of the current behavior: +//! * a *valid* HTTP-date copy-source conditional header is accepted and the copy +//! succeeds (the common, real-SDK path), and +//! * an *invalid* date value is rejected with `400 InvalidArgument` at the `s3s` +//! layer (the documented gap). When `s3s` gains lenient parsing, the second +//! assertion should be flipped to expect a successful copy. + +#[cfg(test)] +mod tests { + use crate::common::{RustFSTestEnvironment, init_logging, local_http_client}; + use aws_sdk_s3::primitives::ByteStream; + use http::header::HOST; + use rustfs_signer::constants::UNSIGNED_PAYLOAD; + use rustfs_signer::sign_v4; + use s3s::Body; + use serial_test::serial; + use std::error::Error; + + /// Signed raw `PUT` copy request with an explicit copy-source conditional + /// header. The header is included in the SigV4 signature (as real SDKs do). + async fn signed_copy( + base_url: &str, + dst_path: &str, + copy_source: &str, + if_unmodified_since: &str, + access_key: &str, + secret_key: &str, + ) -> Result<(reqwest::StatusCode, String), Box> { + let url = format!("{base_url}{dst_path}"); + let uri = url.parse::()?; + let authority = uri.authority().ok_or("missing authority")?.to_string(); + let request = http::Request::builder() + .method(http::Method::PUT) + .uri(uri) + .header(HOST, authority) + .header("x-amz-content-sha256", UNSIGNED_PAYLOAD) + .header("x-amz-copy-source", copy_source) + .header("x-amz-copy-source-if-unmodified-since", if_unmodified_since); + let signed = sign_v4(request.body(Body::empty())?, 0, access_key, secret_key, "", "us-east-1"); + + let client = local_http_client(); + let mut rb = client.request(reqwest::Method::PUT, url); + for (name, value) in signed.headers() { + rb = rb.header(name, value); + } + let resp = rb.send().await?; + let status = resp.status(); + let body = resp.text().await?; + Ok((status, body)) + } + + #[tokio::test] + #[serial] + async fn test_copy_source_if_unmodified_since_valid_and_invalid() -> Result<(), Box> { + init_logging(); + let mut env = RustFSTestEnvironment::new().await?; + env.start_rustfs_server(vec![]).await?; + + let client = env.create_s3_client(); + let bucket = "copy-cond-bucket"; + client.create_bucket().bucket(bucket).send().await?; + client + .put_object() + .bucket(bucket) + .key("src.txt") + .body(ByteStream::from_static(b"hello")) + .send() + .await?; + + let copy_source = format!("/{bucket}/src.txt"); + + // A valid future HTTP-date is accepted by s3s and the copy succeeds. + let (status, body) = signed_copy( + &env.url, + &format!("/{bucket}/dst-valid.txt"), + ©_source, + "Wed, 01 Jan 2031 00:00:00 GMT", + &env.access_key, + &env.secret_key, + ) + .await?; + assert_eq!(status, reqwest::StatusCode::OK, "valid copy-source date must succeed: {body}"); + assert!(body.contains("CopyObjectResult"), "expected CopyObjectResult XML: {body}"); + + // An unparsable date ("Invalid Date") is currently rejected by s3s at the + // deserialization layer with 400 InvalidArgument. This documents the s3s + // limitation described in backlog#618 item 8. When s3s parses these headers + // leniently (matching MinIO), this should become a successful copy. + let (status, body) = signed_copy( + &env.url, + &format!("/{bucket}/dst-invalid.txt"), + ©_source, + "Invalid Date", + &env.access_key, + &env.secret_key, + ) + .await?; + assert_eq!( + status, + reqwest::StatusCode::BAD_REQUEST, + "invalid copy-source date currently rejected by s3s (backlog#618): {body}" + ); + assert!(body.contains("InvalidArgument"), "expected InvalidArgument for invalid date: {body}"); + + env.stop_server(); + Ok(()) + } +} diff --git a/crates/e2e_test/src/create_bucket_region_test.rs b/crates/e2e_test/src/create_bucket_region_test.rs new file mode 100644 index 000000000..44f3ea13b --- /dev/null +++ b/crates/e2e_test/src/create_bucket_region_test.rs @@ -0,0 +1,82 @@ +// Copyright 2024 RustFS Team +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +//! Regression test for rustfs/backlog#629(b): region-aware `CreateBucket`. +//! +//! `minio-go`'s `MakeBucket(bucket, "us-east-1")` was reported to fail SigV4 +//! validation. The SigV4 signature is verified by `s3s` over the raw request +//! body bytes (compared against `x-amz-content-sha256`); a +//! `CreateBucketConfiguration`/`LocationConstraint` body therefore does not +//! change signature canonicalization. This test proves that both a +//! region-body `CreateBucket` and a plain `CreateBucket` succeed under SigV4. + +#[cfg(test)] +mod tests { + use crate::common::{RustFSTestEnvironment, init_logging}; + use aws_sdk_s3::types::{BucketLocationConstraint, CreateBucketConfiguration}; + use serial_test::serial; + use std::error::Error; + + /// `CreateBucket` with a `LocationConstraint` body must pass SigV4 validation + /// and create the bucket, mirroring `minio-go` `MakeBucket(bucket, "us-east-1")`. + #[tokio::test] + #[serial] + async fn test_create_bucket_with_us_east_1_location_constraint() -> Result<(), Box> { + init_logging(); + let mut env = RustFSTestEnvironment::new().await?; + env.start_rustfs_server(vec![]).await?; + let client = env.create_s3_client(); + + client + .create_bucket() + .bucket("region-aware-bucket") + .create_bucket_configuration( + CreateBucketConfiguration::builder() + .location_constraint(BucketLocationConstraint::from("us-east-1")) + .build(), + ) + .send() + .await + .expect("region-aware CreateBucket must pass SigV4 validation and succeed"); + + // The bucket exists and is listed. + let listed = client.list_buckets().send().await?; + let names: Vec<&str> = listed.buckets().iter().filter_map(|b| b.name()).collect(); + assert!(names.contains(&"region-aware-bucket"), "created bucket must be listed: {names:?}"); + + env.stop_server(); + Ok(()) + } + + /// A plain `CreateBucket` (no body) must also succeed; guards against a + /// regression where an empty body would be hashed incorrectly during SigV4. + #[tokio::test] + #[serial] + async fn test_create_bucket_without_location_constraint() -> Result<(), Box> { + init_logging(); + let mut env = RustFSTestEnvironment::new().await?; + env.start_rustfs_server(vec![]).await?; + let client = env.create_s3_client(); + + client + .create_bucket() + .bucket("plain-region-bucket") + .send() + .await + .expect("plain CreateBucket must succeed"); + + env.stop_server(); + Ok(()) + } +} diff --git a/crates/e2e_test/src/lib.rs b/crates/e2e_test/src/lib.rs index a126907dc..5107498bd 100644 --- a/crates/e2e_test/src/lib.rs +++ b/crates/e2e_test/src/lib.rs @@ -175,4 +175,16 @@ mod admin_timeout_regression_test; #[cfg(test)] mod overwrite_cleanup_regression_test; +// Regression test for backlog#601: `GET //` ListBuckets browser compatibility. +#[cfg(test)] +mod list_buckets_double_slash_test; + +// Regression test for backlog#629(b): region-aware CreateBucket SigV4. +#[cfg(test)] +mod create_bucket_region_test; + +// Regression coverage for backlog#618 item 8: copy-source invalid-date header. +#[cfg(test)] +mod copy_source_invalid_date_test; + pub mod tls_gen; diff --git a/crates/e2e_test/src/list_buckets_double_slash_test.rs b/crates/e2e_test/src/list_buckets_double_slash_test.rs new file mode 100644 index 000000000..ddbb68307 --- /dev/null +++ b/crates/e2e_test/src/list_buckets_double_slash_test.rs @@ -0,0 +1,137 @@ +// Copyright 2024 RustFS Team +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +//! Regression test for rustfs/backlog#601: `GET //` ListBuckets browser compat. +//! +//! The AWS S3 browser (SigV4) concatenates the endpoint with a leading slash and +//! emits `GET //` for `ListBuckets`. The `s3s` path parser rejects `//` with +//! `InvalidBucketName` (empty bucket) before routing. `DoubleSlashListBucketsCompatLayer` +//! rewrites `GET //` to `GET /` up front so it routes to `ListBuckets`, matching +//! MinIO's explicit `//` route. + +#[cfg(test)] +mod tests { + use crate::common::{RustFSTestEnvironment, init_logging, local_http_client}; + use http::header::HOST; + use rustfs_signer::constants::UNSIGNED_PAYLOAD; + use rustfs_signer::sign_v4; + use s3s::Body; + use serial_test::serial; + use std::error::Error; + + /// Sends a SigV4-signed `GET` where the signature is computed over `sign_path` + /// but the on-the-wire request target is `wire_path`. Returns (status, body). + async fn signed_get( + base_url: &str, + sign_path: &str, + wire_path: &str, + access_key: &str, + secret_key: &str, + ) -> Result<(reqwest::StatusCode, String), Box> { + let sign_url = format!("{base_url}{sign_path}"); + let uri = sign_url.parse::()?; + let authority = uri.authority().ok_or("missing authority")?.to_string(); + let request = http::Request::builder() + .method(http::Method::GET) + .uri(uri) + .header(HOST, authority) + .header("x-amz-content-sha256", UNSIGNED_PAYLOAD); + let signed = sign_v4(request.body(Body::empty())?, 0, access_key, secret_key, "", "us-east-1"); + + let client = local_http_client(); + let mut rb = client.request(reqwest::Method::GET, format!("{base_url}{wire_path}")); + for (name, value) in signed.headers() { + rb = rb.header(name, value); + } + let resp = rb.send().await?; + let status = resp.status(); + let body = resp.text().await?; + Ok((status, body)) + } + + fn assert_list_buckets_ok(status: reqwest::StatusCode, body: &str, label: &str) { + assert_eq!(status, reqwest::StatusCode::OK, "{label}: expected 200, body: {body}"); + assert!(body.contains("ListAllMyBucketsResult"), "{label}: expected ListBuckets XML, body: {body}"); + } + + /// `GET /` (path-style service call) returns `ListBuckets`. + #[tokio::test] + #[serial] + async fn test_list_buckets_single_slash() -> Result<(), Box> { + init_logging(); + let mut env = RustFSTestEnvironment::new().await?; + env.start_rustfs_server(vec![]).await?; + + let (status, body) = signed_get(&env.url, "/", "/", &env.access_key, &env.secret_key).await?; + assert_list_buckets_ok(status, &body, "GET /"); + + env.stop_server(); + Ok(()) + } + + /// `GET //` returns `ListBuckets` for the S3 browser SigV4 case: the client + /// concatenates the endpoint with a leading `/` so the request target becomes + /// `//`, while the signature was computed over the canonical `/` path. The + /// compat layer rewrites `//` to `/` before `s3s` parses/verifies the request, + /// so both routing and signature verification operate on `/`. + #[tokio::test] + #[serial] + async fn test_list_buckets_double_slash_browser_compat() -> Result<(), Box> { + init_logging(); + let mut env = RustFSTestEnvironment::new().await?; + env.start_rustfs_server(vec![]).await?; + + let (status, body) = signed_get(&env.url, "/", "//", &env.access_key, &env.secret_key).await?; + assert_list_buckets_ok(status, &body, "GET // (signature over /)"); + + env.stop_server(); + Ok(()) + } + + /// The rewrite is confined to a request target of exactly `//`. A normal + /// path-style bucket listing (`GET /bucket`) must keep working (no routing + /// regression), and a leading double slash before a bucket name + /// (`GET //bucket`) must be left untouched by the compat layer — it is not a + /// `ListBuckets` request and s3s continues to reject the empty bucket name. + #[tokio::test] + #[serial] + async fn test_double_slash_rewrite_is_narrowly_scoped() -> Result<(), Box> { + init_logging(); + let mut env = RustFSTestEnvironment::new().await?; + env.start_rustfs_server(vec![]).await?; + + let client = env.create_s3_client(); + client.create_bucket().bucket("compat-bucket").send().await?; + + // `GET /compat-bucket` still lists the bucket (routing unchanged). + let (status, body) = signed_get(&env.url, "/compat-bucket", "/compat-bucket", &env.access_key, &env.secret_key).await?; + assert_eq!(status, reqwest::StatusCode::OK, "GET /compat-bucket body: {body}"); + assert!( + body.contains("ListBucketResult") && !body.contains("ListAllMyBucketsResult"), + "GET /compat-bucket must be a bucket listing: {body}" + ); + + // `GET //compat-bucket` is not rewritten (path is not exactly `//`); s3s + // still rejects the empty leading bucket segment with InvalidBucketName. + let (status, body) = signed_get(&env.url, "//compat-bucket", "//compat-bucket", &env.access_key, &env.secret_key).await?; + assert_eq!(status, reqwest::StatusCode::BAD_REQUEST, "GET //compat-bucket body: {body}"); + assert!( + body.contains("InvalidBucketName"), + "GET //compat-bucket must remain InvalidBucketName (not rewritten): {body}" + ); + + env.stop_server(); + Ok(()) + } +} diff --git a/rustfs/src/server/http.rs b/rustfs/src/server/http.rs index 5edd5f372..f87e2eee9 100644 --- a/rustfs/src/server/http.rs +++ b/rustfs/src/server/http.rs @@ -22,9 +22,9 @@ use crate::server::{ compress::{HttpCompressionConfig, PathAwareHttpCompressionPredicate, PathCategoryInjectionLayer}, hybrid::hybrid, layer::{ - BodylessStatusFixLayer, ConditionalCorsLayer, EmptyBodyContentLengthCompatLayer, HeadRequestBodyFixLayer, - ObjectAttributesEtagFixLayer, PublicHealthEndpointLayer, RedirectLayer, RequestContextLayer, RequestLoggingLayer, - S3ErrorMessageCompatLayer, VirtualHostStyleHintLayer, redact_sensitive_uri_query, + BodylessStatusFixLayer, ConditionalCorsLayer, DoubleSlashListBucketsCompatLayer, EmptyBodyContentLengthCompatLayer, + HeadRequestBodyFixLayer, ObjectAttributesEtagFixLayer, PublicHealthEndpointLayer, RedirectLayer, RequestContextLayer, + RequestLoggingLayer, S3ErrorMessageCompatLayer, VirtualHostStyleHintLayer, redact_sensitive_uri_query, }, tls_material::{ TlsAcceptorHolder, TlsHandshakeFailureKind, build_acceptor_from_loaded, load_tls_material, spawn_reload_loop, @@ -1097,6 +1097,7 @@ fn process_connection( // 20. HeadRequestBodyFixLayer — strips actual body bytes from HEAD responses // 21. PublicHealthEndpointLayer — handles public health before s3s host parsing // 22. VirtualHostStyleHintLayer — actionable error for unroutable virtual-hosted-style (conditional) + // 23. DoubleSlashListBucketsCompatLayer — rewrites `GET //` to `GET /` for ListBuckets (MinIO browser compat) // ───────────────────────────────────────────────────────────── // Batch 1 intentionally keeps the external and internode stacks behaviorally // identical while giving each path family a named construction boundary. @@ -1265,6 +1266,7 @@ fn process_connection( .layer(HeadRequestBodyFixLayer) .layer(PublicHealthEndpointLayer) .option_layer((!server_domains_configured && !is_console).then_some(VirtualHostStyleHintLayer)) + .layer(DoubleSlashListBucketsCompatLayer) .service(service) }; let build_internode_stack = |service| { @@ -1414,6 +1416,7 @@ fn process_connection( .layer(HeadRequestBodyFixLayer) .layer(PublicHealthEndpointLayer) .option_layer((!server_domains_configured && !is_console).then_some(VirtualHostStyleHintLayer)) + .layer(DoubleSlashListBucketsCompatLayer) .service(service) }; let external_stack_service = build_external_stack(external_service); diff --git a/rustfs/src/server/layer.rs b/rustfs/src/server/layer.rs index 1c1c3a5d0..017a18e54 100644 --- a/rustfs/src/server/layer.rs +++ b/rustfs/src/server/layer.rs @@ -1544,6 +1544,79 @@ where } } +/// Rewrites the request-target of a root-level double-slash `GET //` to `GET /` +/// so it routes to `ListBuckets`, matching MinIO browser compatibility. +/// +/// The AWS S3 browser client (SigV4) concatenates the endpoint with a leading +/// slash and emits `GET //` for `ListBuckets`. The `s3s` path parser strips the +/// single leading slash and then treats the remaining `/` as an empty bucket +/// name, rejecting the request with `InvalidBucketName` before it is routed. +/// MinIO's `api-router.go` registers an explicit `//` route to `ListBuckets`; +/// this layer reproduces that behavior by collapsing the path to `/` up front. +/// +/// The rewrite is intentionally limited to a path that is exactly `//` (optionally +/// followed by a query string). It never touches bucket/object requests, so object +/// keys with embedded or leading slashes are unaffected (those are normalized by +/// `s3s` via `normalize_forward_slash_path`). +#[derive(Clone)] +pub struct DoubleSlashListBucketsCompatLayer; + +impl Layer for DoubleSlashListBucketsCompatLayer { + type Service = DoubleSlashListBucketsCompatService; + + fn layer(&self, inner: S) -> Self::Service { + DoubleSlashListBucketsCompatService { inner } + } +} + +#[derive(Clone)] +pub struct DoubleSlashListBucketsCompatService { + inner: S, +} + +impl Service> for DoubleSlashListBucketsCompatService +where + S: Service, Response = Response> + Clone + Send + 'static, + S::Future: Send + 'static, + ReqBody: Send + 'static, + ResBody: Send + 'static, +{ + type Response = Response; + type Error = S::Error; + type Future = S::Future; + + fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll> { + self.inner.poll_ready(cx) + } + + fn call(&mut self, mut req: HttpRequest) -> Self::Future { + if req.method() == Method::GET + && let Some(rewritten) = rewrite_double_slash_root(req.uri()) + { + *req.uri_mut() = rewritten; + } + self.inner.call(req) + } +} + +/// Returns the `/`-rooted URI when `uri` has a request-target path of exactly `//`. +/// +/// Returns `None` for every other path so the rewrite is confined to the +/// root-level double-slash case. +fn rewrite_double_slash_root(uri: &Uri) -> Option { + if uri.path() != "//" { + return None; + } + + let mut parts = uri.clone().into_parts(); + let path_and_query = match uri.query() { + Some(query) => format!("/?{query}"), + None => "/".to_string(), + }; + parts.path_and_query = Some(path_and_query.parse().ok()?); + Uri::from_parts(parts).ok() +} + #[cfg(test)] mod tests { use super::*; @@ -3347,4 +3420,82 @@ mod tests { assert!(output.contains("500"), "{output}"); assert!(output.contains("server_error"), "{output}"); } + + #[test] + fn rewrite_double_slash_root_only_matches_exact_double_slash() { + // Exactly `//` is rewritten to `/` (query preserved). + assert_eq!( + rewrite_double_slash_root(&Uri::from_static("//")).map(|u| u.to_string()), + Some("/".to_string()) + ); + assert_eq!( + rewrite_double_slash_root(&Uri::from_static("//?x-id=ListBuckets")).map(|u| u.to_string()), + Some("/?x-id=ListBuckets".to_string()) + ); + + // Everything else is left untouched. + assert_eq!(rewrite_double_slash_root(&Uri::from_static("/")), None); + assert_eq!(rewrite_double_slash_root(&Uri::from_static("//bucket")), None); + assert_eq!(rewrite_double_slash_root(&Uri::from_static("/bucket")), None); + assert_eq!(rewrite_double_slash_root(&Uri::from_static("/bucket//key")), None); + assert_eq!(rewrite_double_slash_root(&Uri::from_static("///")), None); + } + + /// Inner service that records the request-target path it received and + /// returns an empty response, so the layer's URI rewrite can be observed. + #[derive(Clone, Default)] + struct UriCaptureService { + path: Arc>>, + } + + impl Service> for UriCaptureService { + type Response = Response>; + type Error = Infallible; + type Future = Ready>; + + fn poll_ready(&mut self, _cx: &mut Context<'_>) -> Poll> { + Poll::Ready(Ok(())) + } + + fn call(&mut self, req: Request) -> Self::Future { + *self.path.lock().expect("path lock") = Some(req.uri().path().to_string()); + ready(Ok(Response::new(Full::from(Bytes::new())))) + } + } + + #[tokio::test] + async fn double_slash_compat_layer_rewrites_get_double_slash() { + let inner = UriCaptureService::default(); + let seen = inner.path.clone(); + let mut service = DoubleSlashListBucketsCompatLayer.layer(inner); + + let observe = |seen: &Arc>>| seen.lock().expect("path lock").clone(); + + // `GET //` becomes `GET /`. + let req = Request::builder() + .method(Method::GET) + .uri("//") + .body(Full::::from(Bytes::new())) + .expect("request"); + service.call(req).await.expect("response"); + assert_eq!(observe(&seen).as_deref(), Some("/")); + + // Non-GET `//` is not rewritten. + let req = Request::builder() + .method(Method::PUT) + .uri("//") + .body(Full::::from(Bytes::new())) + .expect("request"); + service.call(req).await.expect("response"); + assert_eq!(observe(&seen).as_deref(), Some("//")); + + // `GET //bucket` is not rewritten. + let req = Request::builder() + .method(Method::GET) + .uri("//bucket") + .body(Full::::from(Bytes::new())) + .expect("request"); + service.call(req).await.expect("response"); + assert_eq!(observe(&seen).as_deref(), Some("//bucket")); + } }