wreq 1.2.2 → 1.2.3

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

data/test/request_parameters_test.rb

@@ -2,7 +2,7 @@ require "test_helper"
 
 class RequestParametersTest < Minitest::Test
   def test_query_parameters
-    response = Wreq.get("http://localhost:8080/get",
+    response = Wreq.get("#{HTTPBIN_URL}/get",
       query: {
         "string" => "value",
         "number" => "123",
@@ -12,9 +12,9 @@ class RequestParametersTest < Minitest::Test
 
     json_data = response.json
     args = json_data["args"]
-    assert_equal "value", args["string"]
-    assert_equal "123", args["number"]  # Query params are strings
-    assert_equal "true", args["boolean"]
+    assert_equal "value", httpbin_fetch(args, "string")
+    assert_equal "123", httpbin_fetch(args, "number")  # Query params are strings
+    assert_equal "true", httpbin_fetch(args, "boolean")
   end
 
   def test_headers
@@ -24,15 +24,15 @@ class RequestParametersTest < Minitest::Test
       "Accept" => "application/json"
     }
 
-    response = Wreq.get("http://localhost:8080/get", headers: custom_headers)
+    response = Wreq.get("#{HTTPBIN_URL}/get", headers: custom_headers)
     assert_equal 200, response.code
 
     json_data = response.json
     request_headers = json_data["headers"]
 
-    assert_equal "custom-value", request_headers["X-Custom-Header"]
-    assert_equal "wreq-ruby-test/1.0", request_headers["User-Agent"]
-    assert_equal "application/json", request_headers["Accept"]
+    assert_equal "custom-value", httpbin_fetch(request_headers, "X-Custom-Header")
+    assert_equal "wreq-ruby-test/1.0", httpbin_fetch(request_headers, "User-Agent")
+    assert_equal "application/json", httpbin_fetch(request_headers, "Accept")
   end
 
   def test_json_body
@@ -44,7 +44,7 @@ class RequestParametersTest < Minitest::Test
       "object" => {"nested" => "value"}
     }
 
-    response = Wreq.post("http://localhost:8080/post", json: json_data)
+    response = Wreq.post("#{HTTPBIN_URL}/post", json: json_data)
     assert_equal 200, response.code
 
     response_data = response.json
@@ -64,19 +64,19 @@ class RequestParametersTest < Minitest::Test
       "number" => "123"
     }
 
-    response = Wreq.post("http://localhost:8080/post", form: form_data)
+    response = Wreq.post("#{HTTPBIN_URL}/post", form: form_data)
     assert_equal 200, response.code
 
     response_data = response.json
     sent_form = response_data["form"]
 
-    assert_equal "value1", sent_form["field1"]
-    assert_equal "value2", sent_form["field2"]
-    assert_equal "123", sent_form["number"]
+    assert_equal "value1", httpbin_fetch(sent_form, "field1")
+    assert_equal "value2", httpbin_fetch(sent_form, "field2")
+    assert_equal "123", httpbin_fetch(sent_form, "number")
   end
 
   def test_combined_parameters
-    response = Wreq.post("http://localhost:8080/post",
+    response = Wreq.post("#{HTTPBIN_URL}/post",
       query: {"q" => "search"},
       headers: {"X-Test" => "combined"},
       json: {"data" => "payload"})
@@ -86,10 +86,10 @@ class RequestParametersTest < Minitest::Test
     json_data = response.json
 
     # Check query parameters
-    assert_equal "search", json_data["args"]["q"]
+    assert_equal "search", httpbin_fetch(json_data["args"], "q")
 
     # Check headers
-    assert_equal "combined", json_data["headers"]["X-Test"]
+    assert_equal "combined", httpbin_fetch(json_data["headers"], "X-Test")
 
     # Check JSON body
     assert_equal "payload", json_data["json"]["data"]
@@ -97,7 +97,7 @@ class RequestParametersTest < Minitest::Test
 
   def test_empty_parameters
     # Test with no additional parameters
-    response = Wreq.get("http://localhost:8080/get")
+    response = Wreq.get("#{HTTPBIN_URL}/get")
     assert_equal 200, response.code
 
     json_data = response.json
@@ -113,16 +113,16 @@ class RequestParametersTest < Minitest::Test
       "url_chars" => "a=b&c=d"
     }
 
-    response = Wreq.get("http://localhost:8080/get", query: special_data)
+    response = Wreq.get("#{HTTPBIN_URL}/get", query: special_data)
     assert_equal 200, response.code
 
     json_data = response.json
     args = json_data["args"]
 
-    assert_equal "value with spaces", args["space"]
-    assert_equal "!@#$%^&*()", args["symbols"]
-    assert_equal "测试中文", args["unicode"]
-    assert_equal "a=b&c=d", args["url_chars"]
+    assert_equal "value with spaces", httpbin_fetch(args, "space")
+    assert_equal "!@#$%^&*()", httpbin_fetch(args, "symbols")
+    assert_equal "测试中文", httpbin_fetch(args, "unicode")
+    assert_equal "a=b&c=d", httpbin_fetch(args, "url_chars")
   end
 
   def test_nested_json_data
@@ -140,7 +140,7 @@ class RequestParametersTest < Minitest::Test
       }
     }
 
-    response = Wreq.post("http://localhost:8080/post", json: nested_data)
+    response = Wreq.post("#{HTTPBIN_URL}/post", json: nested_data)
     assert_equal 200, response.code
 
     response_data = response.json
@@ -153,11 +153,11 @@ class RequestParametersTest < Minitest::Test
 
   def test_method_specific_parameters
     methods_and_urls = {
-      get: "http://localhost:8080/get",
-      post: "http://localhost:8080/post",
-      put: "http://localhost:8080/put",
-      patch: "http://localhost:8080/patch",
-      delete: "http://localhost:8080/delete"
+      get: "#{HTTPBIN_URL}/get",
+      post: "#{HTTPBIN_URL}/post",
+      put: "#{HTTPBIN_URL}/put",
+      patch: "#{HTTPBIN_URL}/patch",
+      delete: "#{HTTPBIN_URL}/delete"
     }
 
     methods_and_urls.each do |method, url|
@@ -168,8 +168,8 @@ class RequestParametersTest < Minitest::Test
       assert_equal 200, response.code, "#{method} request failed"
 
       json_data = response.json
-      assert_equal method.to_s, json_data["headers"]["X-Method"]
-      assert_equal method.to_s, json_data["args"]["method"]
+      assert_equal method.to_s, httpbin_fetch(json_data["headers"], "X-Method")
+      assert_equal method.to_s, httpbin_fetch(json_data["args"], "method")
     end
   end
 end