wreq 1.2.1 → 1.2.3

data/src/client.rs

@@ -10,7 +10,7 @@ use magnus::{
     Module, Object, RHash, RModule, Ruby, TryConvert, Value, function, method, typed_data::Obj,
 };
 use serde::Deserialize;
-use wreq::{Proxy, header::HeaderValue};
+use wreq::Proxy;
 
 use crate::{
     client::{req::execute_request, resp::Response},
@@ -19,7 +19,7 @@ use crate::{
     error::wreq_error_to_magnus,
     extractor::Extractor,
     gvl,
-    header::{Headers, OrigHeaders},
+    header::{Headers, OrigHeaders, UserAgent},
     http::Method,
 };
 
@@ -31,7 +31,7 @@ struct Builder {
     emulation: Option<Emulation>,
     /// The user agent to use for the client.
     #[serde(skip)]
-    user_agent: Option<HeaderValue>,
+    user_agent: Option<UserAgent>,
     /// The headers to use for the client.
     #[serde(skip)]
     headers: Option<Headers>,
@@ -104,6 +104,7 @@ struct Builder {
     /// Bind to a local IP Address.
     local_address: Option<IpAddr>,
     /// Bind to an interface by `SO_BINDTODEVICE`.
+    #[allow(dead_code)]
     interface: Option<String>,
 
     // ========= Compression options =========
@@ -136,6 +137,10 @@ impl Builder {
             builder.emulation = Some((*Obj::<Emulation>::try_convert(v)?).clone());
         }
 
+        if let Some(v) = hash.get(ruby.to_symbol(stringify!(user_agent))) {
+            builder.user_agent = Some(UserAgent::try_convert(v)?);
+        }
+
         if let Some(v) = hash.get(ruby.to_symbol(stringify!(headers))) {
             builder.headers = Some(Headers::try_convert(v)?);
         }
@@ -148,11 +153,6 @@ impl Builder {
             builder.cookie_provider = Some((*Obj::<Jar>::try_convert(v)?).clone());
         }
 
-        if let Some(jar) = hash.get(ruby.to_symbol(stringify!(cookie_provider))) {
-            builder.cookie_provider = Some((*Obj::<Jar>::try_convert(jar)?).clone());
-        }
-
-        builder.user_agent = Extractor::<HeaderValue>::try_convert(*keyword)?.into_inner();
         builder.proxy = Extractor::<Proxy>::try_convert(*keyword)?.into_inner();
 
         Ok(builder)
@@ -173,7 +173,7 @@ impl Client {
                 apply_option!(set_if_some_inner, builder, params.emulation, emulation);
 
                 // User agent options.
-                apply_option!(set_if_some, builder, params.user_agent, user_agent);
+                apply_option!(set_if_some_inner, builder, params.user_agent, user_agent);
 
                 // Headers options.
                 apply_option!(
@@ -301,6 +301,18 @@ impl Client {
                 apply_option!(set_if_some, builder, params.proxy, proxy);
                 apply_option!(set_if_true, builder, params.no_proxy, no_proxy, false);
                 apply_option!(set_if_some, builder, params.local_address, local_address);
+                #[cfg(any(
+                    target_os = "android",
+                    target_os = "fuchsia",
+                    target_os = "illumos",
+                    target_os = "ios",
+                    target_os = "linux",
+                    target_os = "macos",
+                    target_os = "solaris",
+                    target_os = "tvos",
+                    target_os = "visionos",
+                    target_os = "watchos",
+                ))]
                 apply_option!(set_if_some, builder, params.interface, interface);
 
                 // Compression options.

data/src/emulate.rs

@@ -49,6 +49,7 @@ define_ruby_enum!(
     Chrome146,
     Chrome147,
     Chrome148,
+    Chrome149,
 
     Edge101,
     Edge122,

data/src/extractor.rs

@@ -32,31 +32,6 @@ where
     }
 }
 
-// ===== impl Extractor<HeaderValue> =====
-
-impl ExtractorName for HeaderValue {
-    const NAME: &str = "user_agent";
-}
-
-impl TryConvert for Extractor<HeaderValue> {
-    fn try_convert(value: magnus::Value) -> Result<Self, magnus::Error> {
-        let ruby = Ruby::get_with(value);
-        let keyword = RHash::try_convert(value)?;
-
-        if let Some(ruby_value) = keyword
-            .get(ruby.to_symbol(HeaderValue::NAME))
-            .and_then(RString::from_value)
-        {
-            return HeaderValue::from_maybe_shared(ruby_value.to_bytes())
-                .map(Some)
-                .map(Extractor)
-                .map_err(header_value_error_to_magnus);
-        }
-
-        Ok(Extractor(None))
-    }
-}
-
 // ===== impl Extractor<HeaderMap> =====
 
 impl ExtractorName for HeaderMap {

data/src/header.rs

@@ -15,6 +15,9 @@ use crate::error::{
     header_name_error_to_magnus, header_value_error_to_magnus, type_value_error_to_magnus,
 };
 
+/// A wrapper for the User-Agent header value.
+pub struct UserAgent(pub HeaderValue);
+
 /// HTTP headers collection with read and write operations.
 ///
 /// This class wraps HTTP headers and provides convenient methods for
@@ -31,6 +34,17 @@ struct HeaderIter {
     next_name: Option<HeaderName>,
 }
 
+// ===== impl UserAgent =====
+
+impl TryConvert for UserAgent {
+    fn try_convert(value: Value) -> Result<Self, Error> {
+        let s = RString::try_convert(value)?;
+        let header_value =
+            HeaderValue::from_maybe_shared(s.to_bytes()).map_err(header_value_error_to_magnus)?;
+        Ok(Self(header_value))
+    }
+}
+
 // ===== impl Headers =====
 
 impl Headers {

data/src/lib.rs

@@ -2,6 +2,7 @@
 
 #[macro_use]
 mod macros;
+mod arch;
 mod client;
 mod cookie;
 mod emulate;

data/src/rt.rs

@@ -5,25 +5,42 @@ use tokio::runtime::{Builder, Runtime};
 use crate::{error::interrupt_error, gvl};
 
 static RUNTIME: LazyLock<Runtime> = LazyLock::new(|| {
-    Builder::new_multi_thread()
+    let mut builder = Builder::new_multi_thread();
+
+    builder
         .enable_all()
         .build()
         .expect("Failed to initialize Tokio runtime")
 });
 
-/// Block on a future to completion on the global Tokio runtime,
-/// with support for cancellation via the provided `CancelFlag`.
-pub fn try_block_on<F, T>(future: F) -> F::Output
+enum BlockOnError<E> {
+    Interrupted,
+    Future(E),
+}
+
+/// Block on a future to completion on the global Tokio runtime.
+///
+/// The future runs without Ruby's GVL, so it must not construct Ruby objects or
+/// Ruby exceptions. Convert Rust errors back into Ruby errors after the GVL has
+/// been reacquired.
+pub fn try_block_on<F, T, E, M>(future: F, map_err: M) -> Result<T, magnus::Error>
 where
-    F: Future<Output = Result<T, magnus::Error>>,
+    F: Future<Output = Result<T, E>>,
+    M: FnOnce(E) -> magnus::Error,
 {
-    gvl::nogvl_cancellable(|flag| {
+    let result = gvl::nogvl_cancellable(|flag| {
         RUNTIME.block_on(async move {
             tokio::select! {
                 biased;
-                _ = flag.cancelled() => Err(interrupt_error()),
-                result = future => result,
+                _ = flag.cancelled() => Err(BlockOnError::Interrupted),
+                result = future => result.map_err(BlockOnError::Future),
             }
         })
-    })
+    });
+
+    match result {
+        Ok(value) => Ok(value),
+        Err(BlockOnError::Interrupted) => Err(interrupt_error()),
+        Err(BlockOnError::Future(err)) => Err(map_err(err)),
+    }
 }

data/test/client_cookie_test.rb

@@ -3,7 +3,7 @@
 require "test_helper"
 
 class ClientCookieProviderTest < Minitest::Test
-  HOST = "http://localhost:8080"
+  HOST = HTTPBIN_URL
 
   def setup
     @jar = Wreq::Jar.new
@@ -29,9 +29,9 @@ class ClientCookieProviderTest < Minitest::Test
     # subsequent request should send the stored cookie automatically
     res2 = @client.get("#{HOST}/cookies")
     assert_equal 200, res2.code
-    body = res2.json
-    assert_kind_of Hash, body
-    assert_equal "bar", body.dig("cookies", "foo")
+    cookies = httpbin_cookies(res2.json)
+    assert_kind_of Hash, cookies
+    assert_equal "bar", httpbin_fetch(cookies, "foo")
   end
 
   def test_prepopulated_jar_is_used_by_client
@@ -40,7 +40,7 @@ class ClientCookieProviderTest < Minitest::Test
 
     res = @client.get("#{HOST}/cookies")
     assert_equal 200, res.code
-    cookies = res.json["cookies"]
-    assert_equal "1", cookies["pref"]
+    cookies = httpbin_cookies(res.json)
+    assert_equal "1", httpbin_fetch(cookies, "pref")
   end
 end

data/test/client_test.rb

@@ -20,40 +20,40 @@ class ClientTest < Minitest::Test
   end
 
   def test_get_request
-    response = @client.get("http://localhost:8080/get")
+    response = @client.get("#{HTTPBIN_URL}/get")
     refute_nil response
     assert_equal 200, response.code
   end
 
   def test_post_request
-    response = @client.post("http://localhost:8080/post",
+    response = @client.post("#{HTTPBIN_URL}/post",
       json: {test: "wreq-ruby"})
     refute_nil response
     assert_equal 200, response.code
   end
 
   def test_put_request
-    response = @client.put("http://localhost:8080/put",
+    response = @client.put("#{HTTPBIN_URL}/put",
       json: {data: "test"})
     refute_nil response
     assert_equal 200, response.code
   end
 
   def test_delete_request
-    response = @client.delete("http://localhost:8080/delete")
+    response = @client.delete("#{HTTPBIN_URL}/delete")
     refute_nil response
     assert_equal 200, response.code
   end
 
   def test_patch_request
-    response = @client.patch("http://localhost:8080/patch",
+    response = @client.patch("#{HTTPBIN_URL}/patch",
       json: {update: "field"})
     refute_nil response
     assert_equal 200, response.code
   end
 
   def test_request_with_query_params
-    response = @client.get("http://localhost:8080/get",
+    response = @client.get("#{HTTPBIN_URL}/get",
       query: {"param" => "value"})
     refute_nil response
     assert_equal 200, response.code
@@ -61,7 +61,7 @@ class ClientTest < Minitest::Test
   end
 
   def test_request_with_form_data
-    response = @client.post("http://localhost:8080/post",
+    response = @client.post("#{HTTPBIN_URL}/post",
       form: {"field" => "value"})
     refute_nil response
     assert_equal 200, response.code
@@ -69,7 +69,7 @@ class ClientTest < Minitest::Test
   end
 
   def test_request_with_raw_body
-    response = @client.post("http://localhost:8080/post",
+    response = @client.post("#{HTTPBIN_URL}/post",
       body: "raw content",
       headers: {"Content-Type" => "text/plain"})
     refute_nil response
@@ -78,14 +78,14 @@ class ClientTest < Minitest::Test
   end
 
   def test_basic_authentication
-    response = @client.get("http://localhost:8080/basic-auth/user/pass",
+    response = @client.get("#{HTTPBIN_URL}/basic-auth/user/pass",
       basic_auth: ["user", "pass"])
     refute_nil response
     assert_equal 200, response.code
   end
 
   def test_bearer_authentication
-    response = @client.get("http://localhost:8080/bearer",
+    response = @client.get("#{HTTPBIN_URL}/bearer",
       bearer_auth: "test-token")
     refute_nil response
     assert_equal 200, response.code
@@ -93,21 +93,21 @@ class ClientTest < Minitest::Test
   end
 
   def test_redirect_following
-    response = @client.get("http://localhost:8080/redirect/1",
+    response = @client.get("#{HTTPBIN_URL}/redirect/1",
       allow_redirects: true)
     refute_nil response
     assert_equal 200, response.code
   end
 
   def test_redirect_blocking
-    response = @client.get("http://localhost:8080/redirect/1",
+    response = @client.get("#{HTTPBIN_URL}/redirect/1",
       allow_redirects: false)
     refute_nil response
     assert_equal 302, response.code
   end
 
   def test_gzip_compression
-    response = @client.get("http://localhost:8080/gzip", gzip: true)
+    response = @client.get("#{HTTPBIN_URL}/gzip", gzip: true)
     refute_nil response
     assert_equal 200, response.code
   end
@@ -115,12 +115,12 @@ class ClientTest < Minitest::Test
   def test_timeout_handling
     # Test that short timeouts properly raise exceptions
     assert_raises(Wreq::TimeoutError) do
-      @client.get("http://localhost:8080/delay/10", timeout: 1)
+      @client.get("#{HTTPBIN_URL}/delay/10", timeout: 1)
     end
 
     # Test that reasonable timeouts work normally
     start_time = Time.now
-    response = @client.get("http://localhost:8080/delay/1", timeout: 5)
+    response = @client.get("#{HTTPBIN_URL}/delay/1", timeout: 5)
     elapsed = Time.now - start_time
 
     refute_nil response
@@ -129,7 +129,7 @@ class ClientTest < Minitest::Test
   end
 
   def test_status_codes
-    response = @client.get("http://localhost:8080/status/404")
+    response = @client.get("#{HTTPBIN_URL}/status/404")
     refute_nil response
     assert_equal 404, response.code
   end

data/test/cookie_test.rb

@@ -157,24 +157,26 @@ class CookieTest < Minitest::Test
   def test_request_uncompressed_cookies
     client = Wreq::Client.new
     resp = client.get(
-      "https://httpbin.io/cookies",
+      "#{HTTPBIN_URL}/cookies",
       cookies: {"foo" => "bar", "baz" => "qux"}
     )
     json = resp.json
     assert_instance_of Hash, json
-    assert_equal "bar", json["foo"]
-    assert_equal "qux", json["baz"]
+    cookies = json.fetch("cookies", json)
+    assert_equal "bar", cookies["foo"]
+    assert_equal "qux", cookies["baz"]
   end
 
   def test_request_compressed_cookies
     client = Wreq::Client.new
     resp = client.get(
-      "https://httpbin.io/cookies",
+      "#{HTTPBIN_URL}/cookies",
       cookies: "foo=bar; baz=qux"
     )
     json = resp.json
     assert_instance_of Hash, json
-    assert_equal "bar", json["foo"]
-    assert_equal "qux", json["baz"]
+    cookies = json.fetch("cookies", json)
+    assert_equal "bar", cookies["foo"]
+    assert_equal "qux", cookies["baz"]
   end
 end

data/test/error_handling_test.rb

@@ -21,7 +21,7 @@ class ErrorHandlingTest < Minitest::Test
   def test_http_error_status_codes
     # These should not raise errors, just return responses with error codes
     [400, 401, 403, 404, 500, 502, 503].each do |status_code|
-      response = Wreq.get("http://localhost:8080/status/#{status_code}")
+      response = Wreq.get("#{HTTPBIN_URL}/status/#{status_code}")
       assert_equal status_code, response.code
       # Should not raise an exception for HTTP error codes
     end
@@ -31,7 +31,7 @@ class ErrorHandlingTest < Minitest::Test
     # Test timeout with a delay that should definitely cause timeout
 
     # Request with a very short timeout that should fail
-    response = Wreq.get("http://localhost:8080/delay/10", timeout: 1)
+    response = Wreq.get("#{HTTPBIN_URL}/delay/10", timeout: 1)
     # If we get here, the request didn't timeout (unexpected)
     flunk "Expected timeout error but got response: #{response.code}"
   rescue => e
@@ -42,7 +42,7 @@ class ErrorHandlingTest < Minitest::Test
 
   def test_invalid_json_response
     # Get a non-JSON response and try to parse as JSON
-    response = Wreq.get("http://localhost:8080/html")
+    response = Wreq.get("#{HTTPBIN_URL}/html")
     assert_equal 200, response.code
 
     # Should raise an error when trying to parse HTML as JSON
@@ -54,7 +54,7 @@ class ErrorHandlingTest < Minitest::Test
   end
 
   def test_empty_response_json
-    response = Wreq.get("http://localhost:8080/status/204")
+    response = Wreq.get("#{HTTPBIN_URL}/status/204")
     assert_equal 204, response.code
     assert_equal "", response.text
 

data/test/header_test.rb

@@ -2,7 +2,7 @@ require "test_helper"
 
 class HeadersTest < Minitest::Test
   def setup
-    @response = Wreq.get("http://localhost:8080/response-headers",
+    @response = Wreq.get("#{HTTPBIN_URL}/response-headers",
       query: {
         "X-Custom-Header" => "custom-value",
         "X-Multi-Header" => "value1"

data/test/inspect_test.rb

@@ -84,12 +84,12 @@ class InspectTest < Minitest::Test
   # ---- Response ----
 
   def test_response_to_s_returns_body
-    response = Wreq.get("http://localhost:8080/json")
+    response = Wreq.get("#{HTTPBIN_URL}/json")
     assert_equal response.text, response.to_s
   end
 
   def test_response_inspect_format
-    response = Wreq.get("http://localhost:8080/json")
+    response = Wreq.get("#{HTTPBIN_URL}/json")
     result = response.inspect
     assert result.start_with?("#<Wreq::Response")
     assert_includes result, "200"
@@ -99,7 +99,7 @@ class InspectTest < Minitest::Test
   # ---- StatusCode ----
 
   def test_status_code_inspect
-    response = Wreq.get("http://localhost:8080/status/200")
+    response = Wreq.get("#{HTTPBIN_URL}/status/200")
     result = response.status.inspect
     assert result.start_with?("#<Wreq::StatusCode")
     assert_includes result, response.status.to_s
@@ -117,7 +117,7 @@ class InspectTest < Minitest::Test
   end
 
   def test_version_inspect_from_response
-    response = Wreq.get("http://localhost:8080/get")
+    response = Wreq.get("#{HTTPBIN_URL}/get")
     result = response.version.inspect
     assert result.start_with?("#<Wreq::Version")
     assert result.end_with?(">")

data/test/module_methods_test.rb

@@ -2,33 +2,33 @@ require "test_helper"
 
 class ModuleMethodsTest < Minitest::Test
   def test_module_get
-    response = Wreq.get("http://localhost:8080/get")
+    response = Wreq.get("#{HTTPBIN_URL}/get")
     refute_nil response
     assert_equal 200, response.code
   end
 
   def test_module_post
-    response = Wreq.post("http://localhost:8080/post",
+    response = Wreq.post("#{HTTPBIN_URL}/post",
       json: {module: "test"})
     refute_nil response
     assert_equal 200, response.code
   end
 
   def test_module_put
-    response = Wreq.put("http://localhost:8080/put",
+    response = Wreq.put("#{HTTPBIN_URL}/put",
       json: {data: "test"})
     refute_nil response
     assert_equal 200, response.code
   end
 
   def test_module_delete
-    response = Wreq.delete("http://localhost:8080/delete")
+    response = Wreq.delete("#{HTTPBIN_URL}/delete")
     refute_nil response
     assert_equal 200, response.code
   end
 
   def test_module_patch
-    response = Wreq.patch("http://localhost:8080/patch",
+    response = Wreq.patch("#{HTTPBIN_URL}/patch",
       json: {update: "field"})
     refute_nil response
     assert_equal 200, response.code
@@ -37,23 +37,23 @@ class ModuleMethodsTest < Minitest::Test
   end
 
   def test_module_request_method
-    response = Wreq.request(Wreq::Method::GET, "http://localhost:8080/get")
+    response = Wreq.request(Wreq::Method::GET, "#{HTTPBIN_URL}/get")
     refute_nil response
     assert_equal 200, response.code
   end
 
   def test_module_methods_with_parameters
-    response = Wreq.get("http://localhost:8080/get",
+    response = Wreq.get("#{HTTPBIN_URL}/get",
       headers: {"Accept" => "application/json"},
       query: {"test" => "module"})
     refute_nil response
-    assert_equal response.url, "http://localhost:8080/get?test=module"
-    assert_includes response.text, "http://localhost:8080/get?test=module"
+    assert_equal "#{HTTPBIN_URL}/get?test=module", response.url
+    assert_equal "module", httpbin_fetch(response.json["args"], "test")
     assert_equal 200, response.code
   end
 
   def test_module_post_with_json
-    response = Wreq.post("http://localhost:8080/post",
+    response = Wreq.post("#{HTTPBIN_URL}/post",
       json: {
         string: "test",
         number: 123,
@@ -65,7 +65,7 @@ class ModuleMethodsTest < Minitest::Test
   end
 
   def test_module_post_with_form
-    response = Wreq.post("http://localhost:8080/post",
+    response = Wreq.post("#{HTTPBIN_URL}/post",
       form: {"field1" => "value1", "field2" => "value2"})
     refute_nil response
     assert_equal 200, response.code