wreq 1.0.0 → 1.2.0

data/src/emulate.rs

@@ -0,0 +1,375 @@
+use magnus::{
+    Error, Module, Object, RHash, RModule, Ruby, TryConvert, Value, function, method,
+    typed_data::{Inspect, Obj},
+};
+
+define_ruby_enum!(
+    /// An emulation profile.
+    const,
+    Profile,
+    "Wreq::Profile",
+    wreq_util::Profile,
+    Chrome100,
+    Chrome101,
+    Chrome104,
+    Chrome105,
+    Chrome106,
+    Chrome107,
+    Chrome108,
+    Chrome109,
+    Chrome110,
+    Chrome114,
+    Chrome116,
+    Chrome117,
+    Chrome118,
+    Chrome119,
+    Chrome120,
+    Chrome123,
+    Chrome124,
+    Chrome126,
+    Chrome127,
+    Chrome128,
+    Chrome129,
+    Chrome130,
+    Chrome131,
+    Chrome132,
+    Chrome133,
+    Chrome134,
+    Chrome135,
+    Chrome136,
+    Chrome137,
+    Chrome138,
+    Chrome139,
+    Chrome140,
+    Chrome141,
+    Chrome142,
+    Chrome143,
+    Chrome144,
+    Chrome145,
+    Chrome146,
+    Chrome147,
+    Chrome148,
+
+    Edge101,
+    Edge122,
+    Edge127,
+    Edge131,
+    Edge134,
+    Edge135,
+    Edge136,
+    Edge137,
+    Edge138,
+    Edge139,
+    Edge140,
+    Edge141,
+    Edge142,
+    Edge143,
+    Edge144,
+    Edge145,
+    Edge146,
+    Edge147,
+    Edge148,
+
+    Firefox109,
+    Firefox117,
+    Firefox128,
+    Firefox133,
+    Firefox135,
+    FirefoxPrivate135,
+    FirefoxAndroid135,
+    Firefox136,
+    FirefoxPrivate136,
+    Firefox139,
+    Firefox142,
+    Firefox143,
+    Firefox144,
+    Firefox145,
+    Firefox146,
+    Firefox147,
+    Firefox148,
+    Firefox149,
+    Firefox150,
+    Firefox151,
+
+    SafariIos17_2,
+    SafariIos17_4_1,
+    SafariIos16_5,
+    Safari15_3,
+    Safari15_5,
+    Safari15_6_1,
+    Safari16,
+    Safari16_5,
+    Safari17_0,
+    Safari17_2_1,
+    Safari17_4_1,
+    Safari17_5,
+    Safari17_6,
+    Safari18,
+    SafariIPad18,
+    Safari18_2,
+    Safari18_3,
+    Safari18_3_1,
+    SafariIos18_1_1,
+    Safari18_5,
+    Safari26,
+    Safari26_1,
+    Safari26_2,
+    Safari26_3,
+    Safari26_4,
+    SafariIos26,
+    SafariIos26_2,
+    SafariIPad26,
+    SafariIpad26_2,
+
+    OkHttp3_9,
+    OkHttp3_11,
+    OkHttp3_13,
+    OkHttp3_14,
+    OkHttp4_9,
+    OkHttp4_10,
+    OkHttp4_12,
+    OkHttp5,
+
+    Opera116,
+    Opera117,
+    Opera118,
+    Opera119,
+    Opera120,
+    Opera121,
+    Opera122,
+    Opera123,
+    Opera124,
+    Opera125,
+    Opera126,
+    Opera127,
+    Opera128,
+    Opera129,
+    Opera130,
+    Opera131,
+);
+
+define_ruby_enum!(
+    /// An emulation profile for OS.
+    const,
+    Platform,
+    "Wreq::Platform",
+    wreq_util::Platform,
+    Windows,
+    MacOS,
+    Linux,
+    Android,
+    IOS,
+);
+
+/// A struct to represent the `EmulationOption` class.
+#[derive(Clone)]
+#[magnus::wrap(class = "Wreq::Emulation", free_immediately, size)]
+pub struct Emulation(pub wreq_util::Emulation);
+
+// ===== impl Profile =====
+
+impl Profile {
+    pub fn to_s(&self) -> String {
+        self.into_ffi().inspect()
+    }
+}
+
+// ===== impl Platform =====
+
+impl Platform {
+    pub fn to_s(&self) -> String {
+        self.into_ffi().inspect()
+    }
+}
+
+// ===== impl Emulation =====
+
+impl Emulation {
+    fn new(ruby: &Ruby, args: &[Value]) -> Result<Self, Error> {
+        let mut profile = None;
+        let mut platform = None;
+        let mut http2 = None;
+        let mut headers = None;
+
+        if let Some(hash) = args.first().and_then(|v| RHash::from_value(*v)) {
+            if let Some(v) = hash.get(ruby.to_symbol(stringify!(profile))) {
+                profile = Some(Obj::<Profile>::try_convert(v)?);
+            }
+            if let Some(v) = hash.get(ruby.to_symbol(stringify!(platform))) {
+                platform = Some(Obj::<Platform>::try_convert(v)?);
+            }
+            if let Some(v) = hash.get(ruby.to_symbol(stringify!(http2))) {
+                http2 = Some(bool::try_convert(v)?);
+            }
+            if let Some(v) = hash.get(ruby.to_symbol(stringify!(headers))) {
+                headers = Some(bool::try_convert(v)?);
+            }
+        }
+
+        let emulation = wreq_util::Emulation::builder()
+            .profile(profile.map(|obj| obj.into_ffi()).unwrap_or_default())
+            .platform(platform.map(|os| os.into_ffi()).unwrap_or_default())
+            .http2(http2.unwrap_or(true))
+            .headers(headers.unwrap_or(true))
+            .build();
+
+        Ok(Self(emulation))
+    }
+}
+
+pub fn include(ruby: &Ruby, gem_module: &RModule) -> Result<(), Error> {
+    // Profile enum binding
+    let profile = gem_module.define_class("Profile", ruby.class_object())?;
+    profile.define_method("to_s", method!(Profile::to_s, 0))?;
+    profile.const_set("Chrome100", Profile::Chrome100)?;
+    profile.const_set("Chrome101", Profile::Chrome101)?;
+    profile.const_set("Chrome104", Profile::Chrome104)?;
+    profile.const_set("Chrome105", Profile::Chrome105)?;
+    profile.const_set("Chrome106", Profile::Chrome106)?;
+    profile.const_set("Chrome107", Profile::Chrome107)?;
+    profile.const_set("Chrome108", Profile::Chrome108)?;
+    profile.const_set("Chrome109", Profile::Chrome109)?;
+    profile.const_set("Chrome110", Profile::Chrome110)?;
+    profile.const_set("Chrome114", Profile::Chrome114)?;
+    profile.const_set("Chrome116", Profile::Chrome116)?;
+    profile.const_set("Chrome117", Profile::Chrome117)?;
+    profile.const_set("Chrome118", Profile::Chrome118)?;
+    profile.const_set("Chrome119", Profile::Chrome119)?;
+    profile.const_set("Chrome120", Profile::Chrome120)?;
+    profile.const_set("Chrome123", Profile::Chrome123)?;
+    profile.const_set("Chrome124", Profile::Chrome124)?;
+    profile.const_set("Chrome126", Profile::Chrome126)?;
+    profile.const_set("Chrome127", Profile::Chrome127)?;
+    profile.const_set("Chrome128", Profile::Chrome128)?;
+    profile.const_set("Chrome129", Profile::Chrome129)?;
+    profile.const_set("Chrome130", Profile::Chrome130)?;
+    profile.const_set("Chrome131", Profile::Chrome131)?;
+    profile.const_set("Chrome132", Profile::Chrome132)?;
+    profile.const_set("Chrome133", Profile::Chrome133)?;
+    profile.const_set("Chrome134", Profile::Chrome134)?;
+    profile.const_set("Chrome135", Profile::Chrome135)?;
+    profile.const_set("Chrome136", Profile::Chrome136)?;
+    profile.const_set("Chrome137", Profile::Chrome137)?;
+    profile.const_set("Chrome138", Profile::Chrome138)?;
+    profile.const_set("Chrome139", Profile::Chrome139)?;
+    profile.const_set("Chrome140", Profile::Chrome140)?;
+    profile.const_set("Chrome141", Profile::Chrome141)?;
+    profile.const_set("Chrome142", Profile::Chrome142)?;
+    profile.const_set("Chrome143", Profile::Chrome143)?;
+    profile.const_set("Chrome144", Profile::Chrome144)?;
+    profile.const_set("Chrome145", Profile::Chrome145)?;
+    profile.const_set("Chrome146", Profile::Chrome146)?;
+    profile.const_set("Chrome147", Profile::Chrome147)?;
+    profile.const_set("Chrome148", Profile::Chrome148)?;
+
+    profile.const_set("Edge101", Profile::Edge101)?;
+    profile.const_set("Edge122", Profile::Edge122)?;
+    profile.const_set("Edge127", Profile::Edge127)?;
+    profile.const_set("Edge131", Profile::Edge131)?;
+    profile.const_set("Edge134", Profile::Edge134)?;
+    profile.const_set("Edge135", Profile::Edge135)?;
+    profile.const_set("Edge136", Profile::Edge136)?;
+    profile.const_set("Edge137", Profile::Edge137)?;
+    profile.const_set("Edge138", Profile::Edge138)?;
+    profile.const_set("Edge139", Profile::Edge139)?;
+    profile.const_set("Edge140", Profile::Edge140)?;
+    profile.const_set("Edge141", Profile::Edge141)?;
+    profile.const_set("Edge142", Profile::Edge142)?;
+    profile.const_set("Edge143", Profile::Edge143)?;
+    profile.const_set("Edge144", Profile::Edge144)?;
+    profile.const_set("Edge145", Profile::Edge145)?;
+    profile.const_set("Edge146", Profile::Edge146)?;
+    profile.const_set("Edge147", Profile::Edge147)?;
+    profile.const_set("Edge148", Profile::Edge148)?;
+
+    profile.const_set("Firefox109", Profile::Firefox109)?;
+    profile.const_set("Firefox117", Profile::Firefox117)?;
+    profile.const_set("Firefox128", Profile::Firefox128)?;
+    profile.const_set("Firefox133", Profile::Firefox133)?;
+    profile.const_set("Firefox135", Profile::Firefox135)?;
+    profile.const_set("FirefoxPrivate135", Profile::FirefoxPrivate135)?;
+    profile.const_set("FirefoxAndroid135", Profile::FirefoxAndroid135)?;
+    profile.const_set("Firefox136", Profile::Firefox136)?;
+    profile.const_set("FirefoxPrivate136", Profile::FirefoxPrivate136)?;
+    profile.const_set("Firefox139", Profile::Firefox139)?;
+    profile.const_set("Firefox142", Profile::Firefox142)?;
+    profile.const_set("Firefox143", Profile::Firefox143)?;
+    profile.const_set("Firefox144", Profile::Firefox144)?;
+    profile.const_set("Firefox145", Profile::Firefox145)?;
+    profile.const_set("Firefox146", Profile::Firefox146)?;
+    profile.const_set("Firefox147", Profile::Firefox147)?;
+    profile.const_set("Firefox148", Profile::Firefox148)?;
+    profile.const_set("Firefox149", Profile::Firefox149)?;
+    profile.const_set("Firefox150", Profile::Firefox150)?;
+    profile.const_set("Firefox151", Profile::Firefox151)?;
+
+    profile.const_set("SafariIos17_2", Profile::SafariIos17_2)?;
+    profile.const_set("SafariIos17_4_1", Profile::SafariIos17_4_1)?;
+    profile.const_set("SafariIos16_5", Profile::SafariIos16_5)?;
+    profile.const_set("Safari15_3", Profile::Safari15_3)?;
+    profile.const_set("Safari15_5", Profile::Safari15_5)?;
+    profile.const_set("Safari15_6_1", Profile::Safari15_6_1)?;
+    profile.const_set("Safari16", Profile::Safari16)?;
+    profile.const_set("Safari16_5", Profile::Safari16_5)?;
+    profile.const_set("Safari17_0", Profile::Safari17_0)?;
+    profile.const_set("Safari17_2_1", Profile::Safari17_2_1)?;
+    profile.const_set("Safari17_4_1", Profile::Safari17_4_1)?;
+    profile.const_set("Safari17_5", Profile::Safari17_5)?;
+    profile.const_set("Safari17_6", Profile::Safari17_6)?;
+    profile.const_set("Safari18", Profile::Safari18)?;
+    profile.const_set("SafariIPad18", Profile::SafariIPad18)?;
+    profile.const_set("Safari18_2", Profile::Safari18_2)?;
+    profile.const_set("Safari18_3", Profile::Safari18_3)?;
+    profile.const_set("Safari18_3_1", Profile::Safari18_3_1)?;
+    profile.const_set("SafariIos18_1_1", Profile::SafariIos18_1_1)?;
+    profile.const_set("Safari18_5", Profile::Safari18_5)?;
+    profile.const_set("Safari26", Profile::Safari26)?;
+    profile.const_set("Safari26_1", Profile::Safari26_1)?;
+    profile.const_set("Safari26_2", Profile::Safari26_2)?;
+    profile.const_set("Safari26_3", Profile::Safari26_3)?;
+    profile.const_set("Safari26_4", Profile::Safari26_4)?;
+    profile.const_set("SafariIos26", Profile::SafariIos26)?;
+    profile.const_set("SafariIos26_2", Profile::SafariIos26_2)?;
+    profile.const_set("SafariIPad26", Profile::SafariIPad26)?;
+    profile.const_set("SafariIpad26_2", Profile::SafariIpad26_2)?;
+
+    profile.const_set("OkHttp3_9", Profile::OkHttp3_9)?;
+    profile.const_set("OkHttp3_11", Profile::OkHttp3_11)?;
+    profile.const_set("OkHttp3_13", Profile::OkHttp3_13)?;
+    profile.const_set("OkHttp3_14", Profile::OkHttp3_14)?;
+    profile.const_set("OkHttp4_9", Profile::OkHttp4_9)?;
+    profile.const_set("OkHttp4_10", Profile::OkHttp4_10)?;
+    profile.const_set("OkHttp4_12", Profile::OkHttp4_12)?;
+    profile.const_set("OkHttp5", Profile::OkHttp5)?;
+
+    profile.const_set("Opera116", Profile::Opera116)?;
+    profile.const_set("Opera117", Profile::Opera117)?;
+    profile.const_set("Opera118", Profile::Opera118)?;
+    profile.const_set("Opera119", Profile::Opera119)?;
+    profile.const_set("Opera120", Profile::Opera120)?;
+    profile.const_set("Opera121", Profile::Opera121)?;
+    profile.const_set("Opera122", Profile::Opera122)?;
+    profile.const_set("Opera123", Profile::Opera123)?;
+    profile.const_set("Opera124", Profile::Opera124)?;
+    profile.const_set("Opera125", Profile::Opera125)?;
+    profile.const_set("Opera126", Profile::Opera126)?;
+    profile.const_set("Opera127", Profile::Opera127)?;
+    profile.const_set("Opera128", Profile::Opera128)?;
+    profile.const_set("Opera129", Profile::Opera129)?;
+    profile.const_set("Opera130", Profile::Opera130)?;
+    profile.const_set("Opera131", Profile::Opera131)?;
+
+    // Platform enum binding
+    let platform = gem_module.define_class("Platform", ruby.class_object())?;
+    platform.define_method("to_s", method!(Platform::to_s, 0))?;
+    platform.const_set("Windows", Platform::Windows)?;
+    platform.const_set("MacOS", Platform::MacOS)?;
+    platform.const_set("Linux", Platform::Linux)?;
+    platform.const_set("Android", Platform::Android)?;
+    platform.const_set("IOS", Platform::IOS)?;
+
+    // Emulation class binding
+    let emulation = gem_module.define_class("Emulation", ruby.class_object())?;
+    emulation.define_singleton_method("new", function!(Emulation::new, -1))?;
+    Ok(())
+}

data/src/error.rs

@@ -85,6 +85,14 @@ pub fn interrupt_error() -> MagnusError {
     MagnusError::new(ruby!().get_inner(&INTERRUPT_ERROR), "request interrupted")
 }
 
+/// LocalJumpError for methods that require a Ruby block.
+pub fn no_block_given_error() -> MagnusError {
+    MagnusError::new(
+        ruby!().exception_local_jump_error(),
+        "no block given (yield)",
+    )
+}
+
 /// Map [`tokio::sync::mpsc::error::SendError`] to corresponding [`magnus::Error`]
 pub fn mpsc_send_error_to_magnus<T>(err: SendError<T>) -> MagnusError {
     MagnusError::new(

data/src/extractor.rs

@@ -1,4 +1,3 @@
-use bytes::Bytes;
 use magnus::{RArray, RHash, RString, Ruby, TryConvert, r_hash::ForEach};
 use wreq::{
     Proxy, Version,
@@ -138,41 +137,6 @@ impl TryConvert for Extractor<OrigHeaderMap> {
     }
 }
 
-// ===== impl Extractor<Vec<HeaderValue>> =====
-
-impl ExtractorName for Vec<HeaderValue> {
-    const NAME: &str = "cookies";
-}
-
-impl TryConvert for Extractor<Vec<HeaderValue>> {
-    fn try_convert(value: magnus::Value) -> Result<Self, magnus::Error> {
-        use percent_encoding::{NON_ALPHANUMERIC, percent_encode};
-
-        let ruby = Ruby::get_with(value);
-        let keyword = RHash::try_convert(value)?;
-
-        if let Some(hash) = keyword
-            .get(ruby.to_symbol(Vec::<HeaderValue>::NAME))
-            .and_then(RHash::from_value)
-        {
-            let mut cookies = Vec::new();
-            hash.foreach(|name: RString, value: RString| {
-                let value = value.to_bytes();
-                let encoded_value = percent_encode(&value, NON_ALPHANUMERIC);
-                let cookie = format!("{name}={encoded_value}");
-                let header_value = HeaderValue::from_maybe_shared(Bytes::from(cookie))
-                    .map_err(header_value_error_to_magnus)?;
-                cookies.push(header_value);
-                Ok(ForEach::Continue)
-            })?;
-
-            return Ok(Extractor(Some(cookies)));
-        }
-
-        Ok(Extractor(None))
-    }
-}
-
 // ===== impl Extractor<Proxy> =====
 
 impl ExtractorName for Proxy {
@@ -182,9 +146,9 @@ impl ExtractorName for Proxy {
 impl TryConvert for Extractor<Proxy> {
     fn try_convert(value: magnus::Value) -> Result<Self, magnus::Error> {
         let ruby = Ruby::get_with(value);
-        let keyword = RHash::try_convert(value)?;
+        let rhash = RHash::try_convert(value)?;
 
-        if let Some(proxy) = keyword
+        if let Some(proxy) = rhash
             .get(ruby.to_symbol(Proxy::NAME))
             .and_then(RString::from_value)
         {

data/src/header.rs

@@ -3,8 +3,11 @@ use std::cell::RefCell;
 use bytes::Bytes;
 use http::{HeaderMap, HeaderName, HeaderValue};
 use magnus::{
-    Error, Module, Object, RArray, RModule, Ruby, block::Yield, function, method,
-    typed_data::Inspect,
+    Error, Module, Object, RArray, RHash, RModule, RString, Ruby, TryConvert, Value,
+    block::Yield,
+    function, method,
+    r_hash::ForEach,
+    typed_data::{Inspect, Obj},
 };
 
 use crate::error::{header_name_error_to_magnus, header_value_error_to_magnus};
@@ -15,7 +18,14 @@ use crate::error::{header_name_error_to_magnus, header_value_error_to_magnus};
 /// accessing, modifying, and iterating over header name-value pairs.
 #[derive(Clone, Default)]
 #[magnus::wrap(class = "Wreq::Headers", free_immediately, size)]
-pub struct Headers(RefCell<HeaderMap>);
+pub struct Headers(pub RefCell<HeaderMap>);
+
+struct HeaderIter {
+    inner: http::header::IntoIter<HeaderValue>,
+    next_name: Option<HeaderName>,
+}
+
+// ===== impl Headers =====
 
 impl Headers {
     /// Create a new empty Headers instance.
@@ -132,11 +142,32 @@ impl From<HeaderMap> for Headers {
     }
 }
 
-struct HeaderIter {
-    inner: http::header::IntoIter<HeaderValue>,
-    next_name: Option<HeaderName>,
+impl TryConvert for Headers {
+    fn try_convert(value: Value) -> Result<Self, Error> {
+        if let Some(rhash) = RHash::from_value(value) {
+            let mut headers = HeaderMap::new();
+
+            rhash.foreach(|name: RString, value: RString| {
+                let name = HeaderName::from_bytes(&name.to_bytes())
+                    .map_err(header_name_error_to_magnus)?;
+                let value = HeaderValue::from_maybe_shared(value.to_bytes())
+                    .map_err(header_value_error_to_magnus)?;
+                headers.insert(name, value);
+
+                Ok(ForEach::Continue)
+            })?;
+
+            return Ok(Self::from(headers));
+        }
+
+        Obj::<Headers>::try_convert(value)
+            .map(|headers| headers.0.clone())
+            .map(Self)
+    }
 }
 
+// ===== impl HeaderIter =====
+
 impl Iterator for HeaderIter {
     type Item = (Bytes, Bytes);
     fn next(&mut self) -> Option<Self::Item> {

data/src/lib.rs

@@ -4,7 +4,7 @@
 mod macros;
 mod client;
 mod cookie;
-mod emulation;
+mod emulate;
 mod error;
 mod extractor;
 mod gvl;
@@ -91,7 +91,7 @@ fn init(ruby: &Ruby) -> Result<(), Error> {
     header::include(ruby, &gem_module)?;
     cookie::include(ruby, &gem_module)?;
     client::include(ruby, &gem_module)?;
-    emulation::include(ruby, &gem_module)?;
+    emulate::include(ruby, &gem_module)?;
     error::include(ruby);
     Ok(())
 }

data/src/macros.rs

@@ -14,6 +14,11 @@ macro_rules! apply_option {
             $builder = $builder.$method(value.0);
         }
     };
+    (set_if_some_into_inner, $builder:expr, $option:expr, $method:ident) => {
+        if let Some(value) = $option.take() {
+            $builder = $builder.$method(value.0.into_inner());
+        }
+    };
     (set_if_some_map, $builder:expr, $option:expr, $method:ident, $transform:expr) => {
         if let Some(value) = $option.take() {
             $builder = $builder.$method($transform(value));

data/src/rt.rs

@@ -27,21 +27,3 @@ where
         })
     })
 }
-
-/// Block on a future to completion on the global Tokio runtime,
-/// returning `None` if cancelled via the provided `CancelFlag`.
-#[inline]
-pub fn maybe_block_on<F, T>(future: F) -> F::Output
-where
-    F: Future<Output = Option<T>>,
-{
-    gvl::nogvl_cancellable(|flag| {
-        RUNTIME.block_on(async move {
-            tokio::select! {
-                biased;
-                _ = flag.cancelled() => None,
-                result = future => result,
-            }
-        })
-    })
-}

data/test/client_cookie_test.rb

@@ -36,7 +36,7 @@ class ClientCookieProviderTest < Minitest::Test
 
   def test_prepopulated_jar_is_used_by_client
     # pre-populate jar
-    @jar.add_cookie_str("pref=1; Path=/", "#{HOST}/")
+    @jar.add("pref=1; Path=/", "#{HOST}/")
 
     res = @client.get("#{HOST}/cookies")
     assert_equal 200, res.code

data/test/cookie_test.rb

@@ -19,9 +19,9 @@ class CookieTest < Minitest::Test
     assert_equal 0, cookies.length
   end
 
-  def test_add_cookie_str_and_get_all
+  def test_add_and_get_all
     set_cookie = "sid=abc123; Path=/; Domain=example.com; HttpOnly; Secure"
-    @jar.add_cookie_str(set_cookie, @base_url)
+    @jar.add(set_cookie, @base_url)
 
     cookies = @jar.get_all
     assert_kind_of Array, cookies
@@ -42,9 +42,9 @@ class CookieTest < Minitest::Test
   end
 
   def test_add_multiple_and_remove
-    @jar.add_cookie_str("a=1; Path=/", @base_url)
-    @jar.add_cookie_str("b=2; Path=/", @base_url)
-    @jar.add_cookie_str("c=3; Path=/", @base_url)
+    @jar.add("a=1; Path=/", @base_url)
+    @jar.add("b=2; Path=/", @base_url)
+    @jar.add("c=3; Path=/", @base_url)
 
     cookies = @jar.get_all
     assert_equal 3, cookies.length
@@ -58,8 +58,8 @@ class CookieTest < Minitest::Test
   end
 
   def test_clear
-    @jar.add_cookie_str("x=1; Path=/", @base_url)
-    @jar.add_cookie_str("y=2; Path=/", @base_url)
+    @jar.add("x=1; Path=/", @base_url)
+    @jar.add("y=2; Path=/", @base_url)
     refute_empty @jar.get_all
 
     @jar.clear
@@ -69,7 +69,7 @@ class CookieTest < Minitest::Test
   def test_max_age_and_expires_optional
     # Max-Age only
     @jar.clear
-    @jar.add_cookie_str("ma=1; Max-Age=3600; Path=/", @base_url)
+    @jar.add("ma=1; Max-Age=3600; Path=/", @base_url)
     c1 = @jar.get_all.find { |c| c.name == "ma" }
     assert c1
     # can be nil or Integer; just ensure responds and is truthy integer
@@ -81,7 +81,7 @@ class CookieTest < Minitest::Test
     # Expires only
     @jar.clear
     t = Time.now + 3600
-    @jar.add_cookie_str("exp=1; Expires=#{t.gmtime.strftime("%a, %d %b %Y %H:%M:%S GMT")}; Path=/", @base_url)
+    @jar.add("exp=1; Expires=#{t.gmtime.strftime("%a, %d %b %Y %H:%M:%S GMT")}; Path=/", @base_url)
     c2 = @jar.get_all.find { |c| c.name == "exp" }
     assert c2
     # expires returns Float (unix seconds) or nil
@@ -144,8 +144,8 @@ class CookieTest < Minitest::Test
 
   def test_same_site_flags_from_parsed_header
     @jar.clear
-    @jar.add_cookie_str("s1=1; Path=/; SameSite=Strict", @base_url)
-    @jar.add_cookie_str("s2=1; Path=/; SameSite=Lax", @base_url)
+    @jar.add("s1=1; Path=/; SameSite=Strict", @base_url)
+    @jar.add("s2=1; Path=/; SameSite=Lax", @base_url)
 
     cookies = @jar.get_all
     h = cookies.to_h { |ck| [ck.name, [ck.same_site_strict?, ck.same_site_lax?]] }
@@ -154,13 +154,27 @@ class CookieTest < Minitest::Test
     assert_equal [false, true], h["s2"]
   end
 
-  def test_request_cookie_value_percent_encoding
-    raw_value = "hello world?"
+  def test_request_uncompressed_cookies
     client = Wreq::Client.new
     resp = client.get(
-      "http://localhost:8080/cookies",
-      cookies: {"mykey" => raw_value}
+      "https://httpbin.io/cookies",
+      cookies: {"foo" => "bar", "baz" => "qux"}
     )
-    assert_includes resp.text, "hello%20world%3F"
+    json = resp.json
+    assert_instance_of Hash, json
+    assert_equal "bar", json["foo"]
+    assert_equal "qux", json["baz"]
+  end
+
+  def test_request_compressed_cookies
+    client = Wreq::Client.new
+    resp = client.get(
+      "https://httpbin.io/cookies",
+      cookies: "foo=bar; baz=qux"
+    )
+    json = resp.json
+    assert_instance_of Hash, json
+    assert_equal "bar", json["foo"]
+    assert_equal "qux", json["baz"]
   end
 end