v0.29.3

src/proxy/tests/authority_tests.rs

@@ -307,3 +307,106 @@ fn upstream_uri_preserves_nested_url_query_without_rejecting_valid_separators()
     let uri = upstream_uri(backend, suffix).unwrap();
     assert_eq!(uri.path_and_query().unwrap().as_str(), suffix);
 }
+
+#[tokio::test]
+async fn error_fallback_replays_empty_unknown_length_h2_h3_get_and_head() {
+    use bytes::Bytes;
+
+    for version in [Version::HTTP_2, Version::HTTP_3] {
+        for method in [Method::GET, Method::HEAD] {
+            let stream = futures_util::stream::empty::<Result<Bytes, std::io::Error>>();
+            let mut request = Request::builder()
+                .version(version)
+                .method(method.clone())
+                .uri("https://www.example.test/missing?query=1")
+                .body(Body::from_stream(stream))
+                .unwrap();
+            assert_eq!(request.body().size_hint().exact(), None);
+            let result = match prepare_error_fallback_body(&mut request, true).await {
+                Ok(result) => result,
+                Err(response) => panic!("unexpected status {}", response.status()),
+            };
+            assert!(
+                matches!(result, ErrorFallbackBody::Replayable(ref bytes) if bytes.is_empty()),
+                "an empty {method:?} request over {version:?} should allow fallback"
+            );
+            assert!(request.body().is_end_stream());
+            assert_eq!(request.uri().path_and_query().unwrap().as_str(), "/missing?query=1");
+        }
+    }
+}
+
+#[tokio::test]
+async fn error_fallback_preserves_unknown_length_get_payload_without_replaying_it() {
+    use bytes::Bytes;
+
+    let stream = futures_util::stream::iter([Ok::<_, std::io::Error>(
+        Bytes::from_static(b"unexpected-payload"),
+    )]);
+    let mut request = Request::builder()
+        .method(Method::GET)
+        .version(Version::HTTP_3)
+        .uri("https://www.example.test/missing")
+        .body(Body::from_stream(stream))
+        .unwrap();
+    let result = match prepare_error_fallback_body(&mut request, true).await {
+        Ok(result) => result,
+        Err(response) => panic!("unexpected status {}", response.status()),
+    };
+    assert!(matches!(result, ErrorFallbackBody::Unavailable));
+    assert_eq!(
+        request.into_body().collect().await.unwrap().to_bytes(),
+        Bytes::from_static(b"unexpected-payload")
+    );
+}
+
+#[tokio::test]
+async fn error_fallback_does_not_poll_unknown_length_post_payload() {
+    use bytes::Bytes;
+
+    let stream = futures_util::stream::pending::<Result<Bytes, std::io::Error>>();
+    let mut request = Request::builder()
+        .method(Method::POST)
+        .version(Version::HTTP_2)
+        .uri("https://www.example.test/form")
+        .body(Body::from_stream(stream))
+        .unwrap();
+    let result = match prepare_error_fallback_body(&mut request, true).await {
+        Ok(result) => result,
+        Err(response) => panic!("unexpected status {}", response.status()),
+    };
+    assert!(matches!(result, ErrorFallbackBody::Unavailable));
+}
+
+#[tokio::test]
+async fn fallback_terminal_404_html_takes_precedence_over_builtin_error_page() {
+    use bytes::Bytes;
+
+    let mut response = Response::builder()
+        .status(StatusCode::NOT_FOUND)
+        .header("content-type", "text/html; charset=utf-8")
+        .body(Body::from("<html><title>ReactPHP 404</title></html>"))
+        .unwrap();
+    response.extensions_mut().insert(ErrorFallbackResponse);
+    let configured_page = crate::pages::Page {
+        kind: crate::pages::Kind::Builtin,
+        status: Some(404),
+        html: String::new(),
+    };
+    if should_replace_error_page(&response, false) {
+        crate::pages::replace_error(&mut response, &configured_page);
+    }
+    assert_eq!(response.status(), StatusCode::NOT_FOUND);
+    assert_eq!(
+        response.into_body().collect().await.unwrap().to_bytes(),
+        Bytes::from_static(b"<html><title>ReactPHP 404</title></html>")
+    );
+
+    // A normal response with no fallback is still eligible for the configured
+    // global/vhost error-page replacement.
+    let response = Response::builder()
+        .status(StatusCode::NOT_FOUND)
+        .body(Body::empty())
+        .unwrap();
+    assert!(should_replace_error_page(&response, false));
+}