Merge branch 'main' into feat/res2

Author: abhinavs1920

core/runtime/src/fetch/headers.rs

@@ -74,6 +74,12 @@ impl JsHeaders {
     pub fn as_header_map(&self) -> Rc<RefCell<HttpHeaderMap>> {
         self.headers.clone()
     }
+
+    pub(crate) fn deep_clone(&self) -> Self {
+        Self {
+            headers: Rc::new(RefCell::new((*self.headers.borrow()).clone())),
+        }
+    }
 }
 
 #[boa_class(rename = "Headers")]

core/runtime/src/fetch/request.rs

@@ -178,4 +178,11 @@ impl JsRequest {
         };
         JsRequest::create_from_js(input, options)
     }
+
+    #[boa(rename = "clone")]
+    fn clone_request(&self) -> Self {
+        Self {
+            inner: self.inner.clone(),
+        }
+    }
 }

core/runtime/src/fetch/response.rs

@@ -13,6 +13,7 @@ use boa_engine::{
     js_string,
 };
 use boa_gc::{Finalize, Trace};
+use http::{HeaderName, HeaderValue, StatusCode};
 use std::rc::Rc;
 
 /// The type read-only property of the Response interface contains the type of the
@@ -295,6 +296,37 @@ impl JsResponse {
         Self::error()
     }
 
+    /// `Response.redirect(url, status)` per Fetch spec §7.4.
+    #[boa(static)]
+    fn redirect(url: JsValue, status: Option<u16>, context: &mut Context) -> JsResult<Self> {
+        let status = status.unwrap_or(302);
+        if !matches!(status, 301 | 302 | 303 | 307 | 308) {
+            return Err(js_error!(RangeError: "Invalid redirect status: {}", status));
+        }
+        let url_str = url.to_string(context)?.to_std_string_escaped();
+        http::Uri::try_from(url_str.as_str())
+            .map_err(|_| js_error!(TypeError: "Invalid URL: {}", url_str))?;
+
+        let status_code = StatusCode::from_u16(status)
+            .map_err(|_| js_error!(RangeError: "Invalid status code: {}", status))?;
+
+        let mut headers = http::header::HeaderMap::new();
+        headers.insert(
+            HeaderName::from_static("location"),
+            HeaderValue::try_from(url_str)
+                .map_err(|_| js_error!(TypeError: "Invalid URL for header value"))?,
+        );
+
+        Ok(Self {
+            url: js_string!(""),
+            r#type: ResponseType::Basic,
+            status: status_code.as_u16(),
+            status_text: JsString::from(status_code.canonical_reason().unwrap_or("")),
+            headers: JsHeaders::from_http(headers),
+            body: Rc::new(Vec::new()),
+        })
+    }
+
     /// Creates a `Response` with a JSON-serialized body and `Content-Type: application/json`.
     ///
     /// See <https://fetch.spec.whatwg.org/#dom-response-json>
@@ -414,6 +446,18 @@ impl JsResponse {
         false
     }
 
+    #[boa(rename = "clone")]
+    fn clone_response(&self) -> Self {
+        Self {
+            url: self.url.clone(),
+            r#type: self.r#type,
+            status: self.status,
+            status_text: self.status_text.clone(),
+            headers: self.headers.deep_clone(),
+            body: Rc::new((*self.body).clone()),
+        }
+    }
+
     fn bytes(&self, context: &mut Context) -> JsPromise {
         let body = self.body.clone();
         JsPromise::from_async_fn(

core/runtime/src/fetch/tests/request.rs

@@ -152,3 +152,66 @@ fn request_clone_no_body_preserved() {
         }),
     ]);
 }
+
+#[test]
+fn request_clone_method_preserves_body() {
+    run_test_actions([
+        TestAction::inspect_context(|ctx| {
+            let fetcher = TestFetcher::default();
+            crate::fetch::register(fetcher, None, ctx).expect("failed to register fetch");
+        }),
+        TestAction::run(
+            r#"
+                const original = new Request("http://unit.test", {
+                    method: "POST",
+                    body: "payload",
+                });
+                globalThis.cloned = original.clone();
+            "#,
+        ),
+        TestAction::inspect_context(|ctx| {
+            let cloned = ctx.global_object().get(js_str!("cloned"), ctx).unwrap();
+            let cloned_obj = cloned.as_object().unwrap();
+            let cloned_req = cloned_obj.downcast_ref::<JsRequest>().unwrap();
+            assert_eq!(cloned_req.inner().body().as_slice(), b"payload");
+        }),
+    ]);
+}
+
+#[test]
+fn request_clone_method_is_independent() {
+    run_test_actions([
+        TestAction::inspect_context(|ctx| {
+            let fetcher = TestFetcher::default();
+            crate::fetch::register(fetcher, None, ctx).expect("failed to register fetch");
+        }),
+        TestAction::run(
+            r#"
+                const original = new Request("http://unit.test", {
+                    method: "POST",
+                    body: "original-body",
+                });
+                globalThis.original = original;
+                globalThis.cloned = original.clone();
+            "#,
+        ),
+        TestAction::inspect_context(|ctx| {
+            let original = ctx.global_object().get(js_str!("original"), ctx).unwrap();
+            let original_obj = original.as_object().unwrap();
+            let original_req = original_obj.downcast_ref::<JsRequest>().unwrap();
+
+            let cloned = ctx.global_object().get(js_str!("cloned"), ctx).unwrap();
+            let cloned_obj = cloned.as_object().unwrap();
+            let cloned_req = cloned_obj.downcast_ref::<JsRequest>().unwrap();
+
+            assert_eq!(original_req.inner().body().as_slice(), b"original-body");
+            assert_eq!(cloned_req.inner().body().as_slice(), b"original-body");
+
+            // Verify they are distinct objects (different pointers).
+            assert!(!std::ptr::eq(
+                original_req.inner().body().as_ptr(),
+                cloned_req.inner().body().as_ptr()
+            ));
+        }),
+    ]);
+}

core/runtime/src/fetch/tests/response.rs

@@ -156,6 +156,86 @@ fn response_getter() {
     ]);
 }
 
+#[test]
+fn response_redirect_default_status() {
+    run_test_actions([
+        TestAction::harness(),
+        TestAction::inspect_context(|ctx| register(&[], ctx)),
+        TestAction::run(
+            r#"
+                const response = Response.redirect("http://example.com/");
+                assertEq(response.status, 302);
+                assertEq(response.headers.get("location"), "http://example.com/");
+            "#,
+        ),
+    ]);
+}
+
+#[test]
+fn response_redirect_custom_status_and_coercion() {
+    run_test_actions([
+        TestAction::harness(),
+        TestAction::inspect_context(|ctx| register(&[], ctx)),
+        TestAction::run(
+            r#"
+                const response = Response.redirect("http://example.com/", 301);
+                assertEq(response.status, 301);
+
+                // Tests Web IDL coercion of the URL parameter
+                const response2 = Response.redirect(12345);
+                assertEq(response2.headers.get("location"), "12345");
+            "#,
+        ),
+    ]);
+}
+
+#[test]
+fn response_redirect_invalid_status() {
+    run_test_actions([
+        TestAction::harness(),
+        TestAction::inspect_context(|ctx| register(&[], ctx)),
+        TestAction::run(
+            r#"
+                let threw = false;
+                try {
+                    Response.redirect("http://example.com/", 200);
+                } catch (e) {
+                    threw = true;
+                    if (!(e instanceof RangeError)) {
+                        throw new Error("Expected RangeError, got " + e.name);
+                    }
+                }
+                if (!threw) {
+                    throw new Error("Expected RangeError, but no error was thrown");
+                }
+            "#,
+        ),
+    ]);
+}
+
+#[test]
+fn response_json_static() {
+    run_test_actions([
+        TestAction::harness(),
+        TestAction::inspect_context(|ctx| register(&[], ctx)),
+        TestAction::run(
+            r#"
+                globalThis.p = (async () => {
+                    const response = Response.json({ hello: "world" });
+                    assertEq(response.status, 200);
+                    assertEq(response.headers.get("content-type"), "application/json");
+                    const body = await response.json();
+                    assertEq(body.hello, "world");
+                })();
+            "#,
+        ),
+        TestAction::inspect_context(|ctx| {
+            let p = ctx.global_object().get(js_str!("p"), ctx).unwrap();
+            p.as_promise().unwrap().await_blocking(ctx).unwrap();
+        }),
+    ]);
+}
+
 #[test]
 fn response_headers_get_combines_duplicate_values_with_comma_space() {
     run_test_actions([
@@ -184,3 +264,93 @@ fn response_headers_get_combines_duplicate_values_with_comma_space() {
         }),
     ]);
 }
+
+#[test]
+fn response_clone_read_both() {
+    run_test_actions([
+        TestAction::harness(),
+        TestAction::inspect_context(|ctx| {
+            register(
+                &[("http://unit.test", Response::new(b"Hello World".to_vec()))],
+                ctx,
+            );
+        }),
+        TestAction::run(
+            r#"
+                globalThis.response = (async () => {
+                    const response = await fetch(new Request("http://unit.test"));
+                    const cloned = response.clone();
+                    const t1 = await response.text();
+                    const t2 = await cloned.text();
+                    assertEq(t1, "Hello World");
+                    assertEq(t2, "Hello World");
+                })();
+            "#,
+        ),
+        TestAction::inspect_context(|ctx| {
+            let response = ctx.global_object().get(js_str!("response"), ctx).unwrap();
+            response.as_promise().unwrap().await_blocking(ctx).unwrap();
+        }),
+    ]);
+}
+
+#[test]
+fn response_clone_header_independence() {
+    run_test_actions([
+        TestAction::harness(),
+        TestAction::inspect_context(|ctx| {
+            let mut resp = Response::new(b"body".to_vec());
+            resp.headers_mut()
+                .append("x-original", "value".parse().unwrap());
+            register(&[("http://unit.test", resp)], ctx);
+        }),
+        TestAction::run(
+            r#"
+                globalThis.response = (async () => {
+                    const response = await fetch(new Request("http://unit.test"));
+                    const cloned = response.clone();
+
+                    cloned.headers.set("x-original", "mutated");
+                    cloned.headers.set("x-new", "added");
+
+                    assertEq(response.headers.get("x-original"), "value");
+                    assertEq(response.headers.get("x-new"), null);
+                    assertEq(cloned.headers.get("x-original"), "mutated");
+                    assertEq(cloned.headers.get("x-new"), "added");
+                })();
+            "#,
+        ),
+        TestAction::inspect_context(|ctx| {
+            let response = ctx.global_object().get(js_str!("response"), ctx).unwrap();
+            response.as_promise().unwrap().await_blocking(ctx).unwrap();
+        }),
+    ]);
+}
+
+#[test]
+fn response_clone_preserves_status() {
+    run_test_actions([
+        TestAction::harness(),
+        TestAction::inspect_context(|ctx| {
+            register(&[("http://unit.test", Response::new(b"ok".to_vec()))], ctx);
+        }),
+        TestAction::run(
+            r#"
+                globalThis.response = (async () => {
+                    const response = await fetch(new Request("http://unit.test"));
+                    const cloned = response.clone();
+
+                    assertEq(cloned.status, response.status);
+                    assertEq(cloned.statusText, response.statusText);
+                    assertEq(cloned.type, response.type);
+                    assertEq(cloned.url, response.url);
+                    assertEq(cloned.ok, response.ok);
+                })();
+            "#,
+        ),
+        TestAction::inspect_context(|ctx| {
+            let response = ctx.global_object().get(js_str!("response"), ctx).unwrap();
+            response.as_promise().unwrap().await_blocking(ctx).unwrap();
+        }),
+    ]);
+}