wreq-rb 0.6.0 → 0.6.2

data/vendor/wreq/src/cookie.rs

@@ -1,98 +1,27 @@
-//! HTTP Cookies
+//! HTTP cookie storage and request selection.
+//!
+//! [`Jar`] stores cookies received through `Set-Cookie` response fields and selects the cookies
+//! that apply to later requests. Domain, path, security, and expiration checks follow the
+//! [RFC 6265 storage and retrieval model]. [`CookieStore`] can be implemented to provide another
+//! storage backend while keeping the same client integration.
+//!
+//! [RFC 6265 storage and retrieval model]: https://www.rfc-editor.org/rfc/rfc6265.html#section-5
 
-use std::{collections::HashMap, convert::TryInto, fmt, sync::Arc, time::SystemTime};
+mod jar;
+mod store;
 
-use bytes::Bytes;
-use cookie::{Cookie as RawCookie, CookieJar, Expiration, SameSite, time::Duration};
-use http::{Uri, Version};
-
-use crate::{IntoUri, error::Error, ext::UriExt, header::HeaderValue, sync::RwLock};
-
-/// Cookie header values in two forms.
-#[derive(Debug, Clone)]
-#[non_exhaustive]
-pub enum Cookies {
-    /// All cookies combined into one header (compressed).
-    Compressed(HeaderValue),
+use std::{convert::TryInto, fmt, sync::Arc, time::SystemTime};
 
-    /// Each cookie sent as its own header (uncompressed).
-    Uncompressed(Vec<HeaderValue>),
-
-    /// No cookies.
-    Empty,
-}
-
-/// Actions for a persistent cookie store providing session support.
-pub trait CookieStore: Send + Sync {
-    /// Store a set of Set-Cookie header values received from `uri`
-    fn set_cookies(&self, cookie_headers: &mut dyn Iterator<Item = &HeaderValue>, uri: &Uri);
-
-    /// Returns cookies for the given URI and HTTP version.
-    ///
-    /// Following [RFC 9112 §5.6.3], HTTP/1.1 combines all cookies into a single header.
-    /// For [HTTP/2] and above, cookies are sent as separate header fields
-    /// as per [RFC 9113 §8.1.2.5].
-    ///
-    /// [RFC 9112 §5.6.3]: https://www.rfc-editor.org/rfc/rfc9112#section-5.6.3
-    /// [RFC 9113 §8.1.2.5]: https://www.rfc-editor.org/rfc/rfc9113#section-8.1.2.5
-    /// [HTTP/2]: https://datatracker.ietf.org/doc/html/rfc9113
-    fn cookies(&self, uri: &Uri, version: Version) -> Cookies;
-}
+use cookie::{Cookie as RawCookie, Expiration, SameSite};
+use http::{Uri, Version};
 
-impl_into_shared!(
-    /// Trait for converting types into a shared cookie store ([`Arc<dyn CookieStore>`]).
-    ///
-    /// Implemented for any [`CookieStore`] type, [`Arc<T>`] where `T: CookieStore`, and [`Arc<dyn
-    /// CookieStore>`]. Enables ergonomic conversion to a trait object for use in APIs without manual
-    /// boxing.
-    pub trait IntoCookieStore => CookieStore
-);
+pub use self::jar::Jar;
+use crate::{error::Error, header::HeaderValue};
 
-impl_request_config_value!(Arc<dyn CookieStore>);
-
-/// Trait for converting types into an owned cookie ([`Cookie<'static>`]).
-pub trait IntoCookie {
-    /// Converts the implementor into a optional owned [`Cookie<'static>`].
-    fn into_cookie(self) -> Option<Cookie<'static>>;
-}
-
-/// A single HTTP cookie.
+/// A parsed HTTP cookie.
 #[derive(Debug, Clone)]
 pub struct Cookie<'a>(RawCookie<'a>);
 
-/// A good default `CookieStore` implementation.
-///
-/// This is the implementation used when simply calling `cookie_store(true)`.
-/// This type is exposed to allow creating one and filling it with some
-/// existing cookies more easily, before creating a [`crate::Client`].
-#[derive(Debug, Default)]
-pub struct Jar(RwLock<HashMap<String, HashMap<String, CookieJar>>>);
-
-// ===== impl IntoCookie =====
-
-impl IntoCookie for Cookie<'_> {
-    #[inline]
-    fn into_cookie(self) -> Option<Cookie<'static>> {
-        Some(self.into_owned())
-    }
-}
-
-impl IntoCookie for RawCookie<'_> {
-    #[inline]
-    fn into_cookie(self) -> Option<Cookie<'static>> {
-        Some(Cookie(self.into_owned()))
-    }
-}
-
-impl IntoCookie for &str {
-    #[inline]
-    fn into_cookie(self) -> Option<Cookie<'static>> {
-        RawCookie::parse(self).map(|c| Cookie(c.into_owned())).ok()
-    }
-}
-
-// ===== impl Cookie =====
-
 impl<'a> Cookie<'a> {
     pub(crate) fn parse(value: &'a HeaderValue) -> crate::Result<Cookie<'a>> {
         std::str::from_utf8(value.as_bytes())
@@ -102,61 +31,69 @@ impl<'a> Cookie<'a> {
             .map(Cookie)
     }
 
-    /// The name of the cookie.
+    /// Returns the name of `self`.
     #[inline]
     pub fn name(&self) -> &str {
         self.0.name()
     }
 
-    /// The value of the cookie.
+    /// Returns the value of `self`.
+    ///
+    /// Does not strip surrounding quotes.
     #[inline]
     pub fn value(&self) -> &str {
         self.0.value()
     }
 
-    /// Returns true if the 'HttpOnly' directive is enabled.
+    /// Returns whether this cookie was marked `HttpOnly` or not.
     #[inline]
     pub fn http_only(&self) -> bool {
         self.0.http_only().unwrap_or(false)
     }
 
-    /// Returns true if the 'Secure' directive is enabled.
+    /// Returns whether this cookie was marked `Secure` or not.
     #[inline]
     pub fn secure(&self) -> bool {
         self.0.secure().unwrap_or(false)
     }
 
-    /// Returns true if  'SameSite' directive is 'Lax'.
+    /// Returns whether the `SameSite` attribute of this cookie is `Lax`.
     #[inline]
     pub fn same_site_lax(&self) -> bool {
         self.0.same_site() == Some(SameSite::Lax)
     }
 
-    /// Returns true if  'SameSite' directive is 'Strict'.
+    /// Returns whether the `SameSite` attribute of this cookie is `Strict`.
     #[inline]
     pub fn same_site_strict(&self) -> bool {
         self.0.same_site() == Some(SameSite::Strict)
     }
 
-    /// Returns the path directive of the cookie, if set.
+    /// Returns the `Path` of the cookie if one was specified.
     #[inline]
     pub fn path(&self) -> Option<&str> {
         self.0.path()
     }
 
-    /// Returns the domain directive of the cookie, if set.
+    /// Returns the `Domain` of the cookie if one was specified.
+    ///
+    /// This does not consider whether the `Domain` is valid; validation is left to higher-level
+    /// libraries, as needed. However, if the `Domain` starts with a leading `.`, the leading `.` is
+    /// stripped.
     #[inline]
     pub fn domain(&self) -> Option<&str> {
         self.0.domain()
     }
 
-    /// Get the Max-Age information.
+    /// Returns the specified max-age of the cookie if it is non-negative and representable.
     #[inline]
     pub fn max_age(&self) -> Option<std::time::Duration> {
         self.0.max_age().and_then(|d| d.try_into().ok())
     }
 
-    /// The cookie expiration time.
+    /// Returns the expiration date-time of the cookie if one was specified.
+    ///
+    /// Session cookies return `None`.
     #[inline]
     pub fn expires(&self) -> Option<SystemTime> {
         match self.0.expires() {
@@ -165,8 +102,7 @@ impl<'a> Cookie<'a> {
         }
     }
 
-    /// Converts `self` into a `Cookie` with a static lifetime with as few
-    /// allocations as possible.
+    /// Converts `self` into a `Cookie` with a static lifetime with as few allocations as possible.
     #[inline]
     pub fn into_owned(self) -> Cookie<'static> {
         Cookie(self.0.into_owned())
@@ -194,546 +130,106 @@ impl<'c> From<Cookie<'c>> for RawCookie<'c> {
     }
 }
 
-// ===== impl Jar =====
-
-macro_rules! into_uri {
-    ($expr:expr) => {
-        match $expr.into_uri() {
-            Ok(u) => u,
-            Err(_) => return,
-        }
-    };
-}
-
-impl Jar {
-    /// Get a cookie by name for a given Uri.
-    ///
-    /// Returns the cookie with the specified name for the domain and path
-    /// derived from the given Uri, if it exists.
-    ///
-    /// # Example
-    /// ```
-    /// use wreq::cookie::Jar;
-    /// let jar = Jar::default();
-    /// jar.add("foo=bar; Path=/foo; Domain=example.com", "http://example.com/foo");
-    /// let cookie = jar.get("foo", "http://example.com/foo").unwrap();
-    /// assert_eq!(cookie.value(), "bar");
-    /// ```
-    pub fn get<U: IntoUri>(&self, name: &str, uri: U) -> Option<Cookie<'static>> {
-        let uri = uri.into_uri().ok()?;
-        let host = normalize_domain(uri.host()?);
-        let cookie = self
-            .0
-            .read()
-            .get(host)?
-            .get(uri.path())?
-            .get(name)?
-            .clone()
-            .into_owned();
-        Some(Cookie(cookie))
-    }
+/// Serialized `Cookie` field values selected for an outgoing request.
+#[derive(Debug, Clone)]
+#[non_exhaustive]
+pub enum Cookies {
+    /// All cookie pairs combined into one field value.
+    Compressed(HeaderValue),
 
-    /// Get all cookies in this jar.
-    ///
-    /// Returns an iterator over all cookies currently stored in the jar,
-    /// regardless of domain or path.
-    ///
-    /// # Example
-    /// ```
-    /// use wreq::cookie::Jar;
-    /// let jar = Jar::default();
-    /// jar.add("foo=bar; Domain=example.com", "http://example.com");
-    /// for cookie in jar.get_all() {
-    ///     println!("{}={}", cookie.name(), cookie.value());
-    /// }
-    /// ```
-    pub fn get_all(&self) -> impl Iterator<Item = Cookie<'static>> {
-        self.0
-            .read()
-            .iter()
-            .flat_map(|(domain, path_map)| {
-                path_map.iter().flat_map(|(path, name_map)| {
-                    name_map.iter().map(|cookie| {
-                        let mut cookie = cookie.clone().into_owned();
-
-                        if cookie.domain().is_none() {
-                            cookie.set_domain(domain.to_owned());
-                        }
-
-                        if cookie.path().is_none() {
-                            cookie.set_path(path.to_owned());
-                        }
-
-                        Cookie(cookie)
-                    })
-                })
-            })
-            .collect::<Vec<_>>()
-            .into_iter()
-    }
+    /// Each cookie pair stored as a separate field value.
+    Uncompressed(Vec<HeaderValue>),
 
-    /// Add a cookie to this jar.
-    ///
-    /// # Example
-    ///
-    /// ```
-    /// use wreq::cookie::Jar;
-    /// use cookie::CookieBuilder;
-    /// let jar = Jar::default();
-    /// let cookie = CookieBuilder::new("foo", "bar")
-    ///     .domain("example.com")
-    ///     .path("/")
-    ///     .build();
-    /// jar.add(cookie, "http://example.com");
-    ///
-    /// let cookie = CookieBuilder::new("foo", "bar")
-    ///     .domain("example.com")
-    ///     .path("/")
-    ///     .build();
-    /// jar.add(cookie, "http://example.com");
-    /// ```
-    pub fn add<C, U>(&self, cookie: C, uri: U)
-    where
-        C: IntoCookie,
-        U: IntoUri,
-    {
-        if let Some(cookie) = cookie.into_cookie() {
-            let uri = into_uri!(uri);
-            let mut cookie: RawCookie<'static> = cookie.into();
-
-            // If the request-uri contains no host component:
-            let Some(host) = uri.host() else {
-                return;
-            };
-
-            // If the canonicalized request-host does not domain-match the
-            // domain-attribute:
-            //    Ignore the cookie entirely and abort these steps.
-            //
-            // RFC 6265 §5.3 + §5.1.3:
-            // https://datatracker.ietf.org/doc/html/rfc6265#section-5.3
-            // https://datatracker.ietf.org/doc/html/rfc6265#section-5.1.3
-            let domain = if let Some(domain) = cookie.domain() {
-                let domain = normalize_domain(domain);
-                if domain.is_empty() || !domain_match(normalize_domain(host), domain) {
-                    return;
-                }
-                domain
-            } else {
-                normalize_domain(host)
-            };
-
-            // If the request-uri contains no path component or if the first character of the
-            // path component of the request-uri is not a %x2F ("/") OR if the cookie's path-
-            // attribute is missing or does not start with a %x2F ("/"):
-            //    Let cookie-path be the default-path of the request-uri.
-            // Otherwise:
-            //    Let cookie-path be the substring of the request-uri's path from the first
-            // character    up to, not including, the right-most %x2F ("/").
-            //
-            // RFC 6265 §5.2.4 + §5.1.4:
-            // https://datatracker.ietf.org/doc/html/rfc6265#section-5.2.4
-            // https://datatracker.ietf.org/doc/html/rfc6265#section-5.1.4
-            let path = cookie
-                .path()
-                .filter(|path| path.starts_with(DEFAULT_PATH))
-                .unwrap_or_else(|| normalize_path(uri.path()));
-
-            let mut inner = self.0.write();
-            let name_map = inner
-                .entry(domain.to_owned())
-                .or_default()
-                .entry(path.to_owned())
-                .or_default();
-
-            // RFC 6265: If Max-Age=0 or Expires in the past, remove the cookie
-            let expired = cookie
-                .expires_datetime()
-                .is_some_and(|dt| dt <= SystemTime::now())
-                || cookie.max_age().is_some_and(Duration::is_zero);
-
-            if expired {
-                name_map.remove(cookie);
-            } else {
-                cookie.set_path(path.to_owned());
-                name_map.add(cookie);
-            }
-        }
-    }
+    /// No cookie applies to the request.
+    Empty,
+}
 
-    /// Remove a cookie by name for a given Uri.
-    ///
-    /// Removes the cookie with the specified name for the domain and path
-    /// derived from the given Uri, if it exists.
-    ///
-    /// # Example
-    /// ```
-    /// use wreq::cookie::Jar;
-    /// let jar = Jar::default();
-    /// jar.add("foo=bar; Path=/foo; Domain=example.com", "http://example.com/foo");
-    /// assert!(jar.get("foo", "http://example.com/foo").is_some());
-    /// jar.remove("foo", "http://example.com/foo");
-    /// assert!(jar.get("foo", "http://example.com/foo").is_none());
-    /// ```
-    pub fn remove<C, U>(&self, cookie: C, uri: U)
-    where
-        C: Into<RawCookie<'static>>,
-        U: IntoUri,
-    {
-        let uri = into_uri!(uri);
-        if let Some(host) = uri.host() {
-            let host = normalize_domain(host);
-            let mut inner = self.0.write();
-            if let Some(path_map) = inner.get_mut(host) {
-                if let Some(name_map) = path_map.get_mut(uri.path()) {
-                    name_map.remove(cookie.into());
-                }
-            }
-        }
-    }
+/// Thread-safe cookie storage used by [`crate::Client`].
+///
+/// Implementors receive `Set-Cookie` response fields through [`set_cookies`](Self::set_cookies)
+/// and produce `Cookie` request fields through [`cookies`](Self::cookies). Implementations are
+/// responsible for applying the [RFC 6265 storage and retrieval model].
+///
+/// [RFC 6265 storage and retrieval model]: https://www.rfc-editor.org/rfc/rfc6265.html#section-5
+pub trait CookieStore: Send + Sync {
+    /// Stores `Set-Cookie` field values received from `uri`.
+    fn set_cookies(&self, cookie_headers: &mut dyn Iterator<Item = &HeaderValue>, uri: &Uri);
 
-    /// Clear all cookies from this jar.
+    /// Serializes the cookies that apply to `uri` for the requested HTTP version.
     ///
-    /// Removes all cookies from the jar, leaving it empty.
+    /// HTTP/1.1 combines cookie pairs into one field value using the format from
+    /// [RFC 6265 section 5.4]. HTTP/2 and HTTP/3 may split them across field lines to improve
+    /// compression, as described by [RFC 9113 section 8.2.3] and [RFC 9114 section 4.2.1].
     ///
-    /// # Example
-    /// ```
-    /// use wreq::cookie::Jar;
-    /// let jar = Jar::default();
-    /// jar.add("foo=bar; Domain=example.com", "http://example.com");
-    /// assert_eq!(jar.get_all().count(), 1);
-    /// jar.clear();
-    /// assert_eq!(jar.get_all().count(), 0);
-    /// ```
-    pub fn clear(&self) {
-        self.0.write().clear();
-    }
+    /// [RFC 6265 section 5.4]: https://www.rfc-editor.org/rfc/rfc6265.html#section-5.4
+    /// [RFC 9113 section 8.2.3]: https://www.rfc-editor.org/rfc/rfc9113.html#section-8.2.3
+    /// [RFC 9114 section 4.2.1]: https://www.rfc-editor.org/rfc/rfc9114.html#section-4.2.1
+    fn cookies(&self, uri: &Uri, version: Version) -> Cookies;
 }
 
-impl CookieStore for Jar {
-    fn set_cookies(&self, cookie_headers: &mut dyn Iterator<Item = &HeaderValue>, uri: &Uri) {
-        let cookies = cookie_headers
-            .map(Cookie::parse)
-            .filter_map(Result::ok)
-            .map(|cookie| cookie.0.into_owned());
+/// Converts cookie stores into a shared [`CookieStore`].
+pub trait IntoCookieStore {
+    /// Converts this value into a shared cookie store.
+    fn into_shared(self) -> Arc<dyn CookieStore>;
+}
 
-        for cookie in cookies {
-            self.add(cookie, uri);
-        }
+impl IntoCookieStore for Arc<dyn CookieStore> {
+    #[inline]
+    fn into_shared(self) -> Arc<dyn CookieStore> {
+        self
     }
+}
 
-    fn cookies(&self, uri: &Uri, version: Version) -> Cookies {
-        let host = match uri.host() {
-            Some(h) => normalize_domain(h),
-            None => return Cookies::Empty,
-        };
-
-        let store = self.0.read();
-        let iter = store
-            .iter()
-            .filter(|(domain, _)| domain_match(host, domain))
-            .flat_map(|(_, path_map)| {
-                path_map
-                    .iter()
-                    .filter(|(path, _)| path_match(uri.path(), path))
-                    .flat_map(|(_, name_map)| {
-                        name_map.iter().filter(|cookie| {
-                            if cookie.secure() == Some(true) && uri.is_http() {
-                                return false;
-                            }
-
-                            if cookie
-                                .expires_datetime()
-                                .is_some_and(|dt| dt <= SystemTime::now())
-                            {
-                                return false;
-                            }
-
-                            true
-                        })
-                    })
-            });
-
-        if matches!(version, Version::HTTP_2 | Version::HTTP_3) {
-            let cookies = iter
-                .map(|cookie| {
-                    let name = cookie.name();
-                    let value = cookie.value();
-
-                    let mut cookie_str = String::with_capacity(name.len() + 1 + value.len());
-                    cookie_str.push_str(name);
-                    cookie_str.push('=');
-                    cookie_str.push_str(value);
-
-                    HeaderValue::from_maybe_shared(Bytes::from(cookie_str))
-                })
-                .filter_map(Result::ok)
-                .collect();
-
-            Cookies::Uncompressed(cookies)
-        } else {
-            let cookies = iter.fold(String::new(), |mut cookies, cookie| {
-                if !cookies.is_empty() {
-                    cookies.push_str("; ");
-                }
-                cookies.push_str(cookie.name());
-                cookies.push('=');
-                cookies.push_str(cookie.value());
-                cookies
-            });
-
-            if cookies.is_empty() {
-                return Cookies::Empty;
-            }
-
-            HeaderValue::from_maybe_shared(Bytes::from(cookies))
-                .map(Cookies::Compressed)
-                .unwrap_or(Cookies::Empty)
-        }
+impl<S: CookieStore + 'static> IntoCookieStore for Arc<S> {
+    #[inline]
+    fn into_shared(self) -> Arc<dyn CookieStore> {
+        self
     }
 }
 
-const DEFAULT_PATH: &str = "/";
-
-/// Determines if the given `host` matches the cookie `domain` according to
-/// [RFC 6265 section 5.1.3](https://datatracker.ietf.org/doc/html/rfc6265#section-5.1.3).
-///
-/// - Returns true if the host and domain are identical.
-/// - Returns true if the host is a subdomain of the domain (host ends with ".domain").
-/// - Returns false otherwise.
-fn domain_match(host: &str, domain: &str) -> bool {
-    if domain.is_empty() {
-        return false;
-    }
-    if host == domain {
-        return true;
+impl<S: CookieStore + 'static> IntoCookieStore for S {
+    #[inline]
+    fn into_shared(self) -> Arc<dyn CookieStore> {
+        Arc::new(self)
     }
-    host.len() > domain.len()
-        && host.as_bytes()[host.len() - domain.len() - 1] == b'.'
-        && host.ends_with(domain)
 }
 
-/// Determines if the request path matches the cookie path according to
-/// [RFC 6265 section 5.1.4](https://datatracker.ietf.org/doc/html/rfc6265#section-5.1.4).
-///
-/// - Returns true if the request path and cookie path are identical.
-/// - Returns true if the request path starts with the cookie path, and
-///   - the cookie path ends with '/', or
-///   - the next character in the request path after the cookie path is '/'.
-/// - Returns false otherwise.
-fn path_match(req_path: &str, cookie_path: &str) -> bool {
-    req_path == cookie_path
-        || req_path.starts_with(cookie_path)
-            && (cookie_path.ends_with(DEFAULT_PATH)
-                || req_path[cookie_path.len()..].starts_with(DEFAULT_PATH))
-}
+impl_request_config_value!(Arc<dyn CookieStore>);
 
-/// Normalizes a domain by stripping any port information.
+/// Converts cookie-like values into an owned [`Cookie`].
 ///
-/// According to [RFC 6265 section 5.2.3](https://datatracker.ietf.org/doc/html/rfc6265#section-5.2.3),
-/// the domain attribute of a cookie must not include a port. If a port is present (non-standard),
-/// it will be ignored for domain matching purposes.
-fn normalize_domain(domain: &str) -> &str {
-    let host_without_port = domain.split(':').next().unwrap_or(domain);
-    let without_leading = host_without_port
-        .strip_prefix(".")
-        .unwrap_or(host_without_port);
-    without_leading.strip_suffix(".").unwrap_or(without_leading)
+/// String implementations return `None` when the value cannot be parsed as a `Set-Cookie` value.
+pub trait IntoCookie {
+    /// Converts this value into an optional owned [`Cookie`].
+    fn into_cookie(self) -> Option<Cookie<'static>>;
 }
 
-/// Computes the normalized default path for a cookie as specified in
-/// [RFC 6265 section 5.1.4](https://datatracker.ietf.org/doc/html/rfc6265#section-5.1.4).
-///
-/// This function normalizes the path for a cookie, ensuring it matches
-/// browser and server expectations for default cookie scope.
-fn normalize_path(path: &str) -> &str {
-    if !path.starts_with(DEFAULT_PATH) {
-        return DEFAULT_PATH;
-    }
-    if let Some(pos) = path.rfind(DEFAULT_PATH) {
-        if pos == 0 {
-            return DEFAULT_PATH;
-        }
-        return &path[..pos];
+impl IntoCookie for Cookie<'_> {
+    #[inline]
+    fn into_cookie(self) -> Option<Cookie<'static>> {
+        Some(self.into_owned())
     }
-    DEFAULT_PATH
 }
 
-#[cfg(test)]
-mod tests {
-    use http::{Uri, Version};
-
-    use super::{CookieStore, Cookies, Jar};
-
-    #[test]
-    fn jar_get_all_backfills_domain_and_path() {
-        let jar = Jar::default();
-        jar.add("session=abc", "http://example.com/foo/bar");
-
-        let cookies = jar.get_all().collect::<Vec<_>>();
-        assert_eq!(cookies.len(), 1);
-
-        let cookie = &cookies[0];
-        assert_eq!(cookie.name(), "session");
-        assert_eq!(cookie.value(), "abc");
-        assert_eq!(cookie.domain(), Some("example.com"));
-        assert_eq!(cookie.path(), Some("/foo"));
-    }
-
-    #[test]
-    fn jar_get_all_keeps_existing_domain_and_path() {
-        let jar = Jar::default();
-        jar.add(
-            "session=abc; Domain=example.com; Path=/custom",
-            "http://example.com/foo/bar",
-        );
-
-        let cookies = jar.get_all().collect::<Vec<_>>();
-        assert_eq!(cookies.len(), 1);
-
-        let cookie = &cookies[0];
-        assert_eq!(cookie.name(), "session");
-        assert_eq!(cookie.value(), "abc");
-        assert_eq!(cookie.domain(), Some("example.com"));
-        assert_eq!(cookie.path(), Some("/custom"));
-    }
-
-    #[test]
-    fn jar_get_all_backfills_only_missing_field() {
-        let jar = Jar::default();
-        jar.add("a=1; Domain=example.com", "http://example.com/foo/bar");
-        jar.add("b=2; Path=/fixed", "http://example.com/foo/bar");
-
-        let mut cookies = jar.get_all().collect::<Vec<_>>();
-        cookies.sort_by(|left, right| left.name().cmp(right.name()));
-
-        let a = &cookies[0];
-        assert_eq!(a.name(), "a");
-        assert_eq!(a.domain(), Some("example.com"));
-        assert_eq!(a.path(), Some("/foo"));
-
-        let b = &cookies[1];
-        assert_eq!(b.name(), "b");
-        assert_eq!(b.domain(), Some("example.com"));
-        assert_eq!(b.path(), Some("/fixed"));
-    }
-
-    #[test]
-    fn jar_add_rejects_mismatched_domain() {
-        let jar = Jar::default();
-        jar.add("session=abc; Domain=other.com", "http://example.com/foo");
-
-        assert_eq!(jar.get_all().count(), 0);
-    }
-
-    #[test]
-    fn jar_add_accepts_matching_parent_domain() {
-        let jar = Jar::default();
-        jar.add(
-            "session=abc; Domain=example.com",
-            "http://api.example.com/foo",
-        );
-
-        let cookies = jar.get_all().collect::<Vec<_>>();
-        assert_eq!(cookies.len(), 1);
-        assert_eq!(cookies[0].domain(), Some("example.com"));
-    }
-
-    #[test]
-    fn jar_get_all_export_import_keeps_effective_path() {
-        let source = Jar::default();
-        source.add("session=abc", "http://example.com/foo/bar");
-
-        let exported = source.get_all().collect::<Vec<_>>();
-        assert_eq!(exported.len(), 1);
-        assert_eq!(exported[0].path(), Some("/foo"));
-
-        let target = Jar::default();
-        for cookie in exported {
-            target.add(cookie, "http://example.com/another/deeper");
-        }
-
-        let imported = target.get_all().collect::<Vec<_>>();
-        assert_eq!(imported.len(), 1);
-        assert_eq!(imported[0].path(), Some("/foo"));
-    }
-
-    #[test]
-    fn cookie_store_invalid_explicit_path_falls_back_to_default_path() {
-        let jar = Jar::default();
-        jar.add("key=val; Path=noslash", "http://example.com/foo/bar");
-
-        assert!(jar.get("key", "http://example.com/foo").is_some());
-        assert!(jar.get("key", "http://example.com/noslash").is_none());
-
-        let cookies = jar.get_all().collect::<Vec<_>>();
-        assert_eq!(cookies.len(), 1);
-        assert_eq!(cookies[0].path(), Some("/foo"));
+impl IntoCookie for cookie::Cookie<'_> {
+    #[inline]
+    fn into_cookie(self) -> Option<Cookie<'static>> {
+        Some(Cookie::from(self.into_owned()))
     }
+}
 
-    #[test]
-    fn jar_sends_parent_domain_cookie_to_subdomain() {
-        let jar = Jar::default();
-        jar.add(
-            "session=abc; Domain=example.com; Path=/",
-            "http://example.com/login",
-        );
-
-        let should_receive = [
-            "http://example.com/dashboard",
-            "http://api.example.com/dashboard",
-            "http://sub.api.example.com/dashboard",
-        ];
-        for uri_str in &should_receive {
-            let uri = Uri::from_static(uri_str);
-            match jar.cookies(&uri, Version::HTTP_11) {
-                Cookies::Compressed(v) => assert_eq!(
-                    v.to_str().unwrap(),
-                    "session=abc",
-                    "expected cookie to be sent to {uri_str}"
-                ),
-                other => panic!("expected Compressed cookie for {uri_str}, got {other:?}"),
-            }
-        }
-
-        let should_not_receive = [
-            "http://notexample.com/dashboard",
-            "http://fakeexample.com/dashboard",
-        ];
-        for uri_str in &should_not_receive {
-            let uri = Uri::from_static(uri_str);
-            assert!(
-                matches!(jar.cookies(&uri, Version::HTTP_11), Cookies::Empty),
-                "cookie must NOT be sent to {uri_str}"
-            );
-        }
+impl IntoCookie for &str {
+    #[inline]
+    fn into_cookie(self) -> Option<Cookie<'static>> {
+        cookie::Cookie::parse(self)
+            .map(|cookie| Cookie::from(cookie.into_owned()))
+            .ok()
     }
+}
 
-    #[test]
-    fn jar_subdomain_cookie_does_not_leak_to_parent_or_sibling() {
-        let jar = Jar::default();
-        jar.add(
-            "token=xyz; Domain=api.example.com; Path=/",
-            "http://api.example.com/",
-        );
-
-        let uri = Uri::from_static("http://api.example.com/");
-        assert!(
-            matches!(jar.cookies(&uri, Version::HTTP_11), Cookies::Compressed(_)),
-            "cookie must be sent to api.example.com"
-        );
-
-        let must_not_receive = [
-            "http://example.com/",
-            "http://other.example.com/",
-            "http://notapi.example.com/",
-        ];
-        for uri_str in &must_not_receive {
-            let uri = Uri::from_static(uri_str);
-            assert!(
-                matches!(jar.cookies(&uri, Version::HTTP_11), Cookies::Empty),
-                "cookie must NOT leak to {uri_str}"
-            );
-        }
+impl IntoCookie for String {
+    #[inline]
+    fn into_cookie(self) -> Option<Cookie<'static>> {
+        cookie::Cookie::parse(self).map(Cookie::from).ok()
     }
 }