wreq 1.1.0 → 1.2.1

data/src/header.rs

@@ -3,11 +3,17 @@ 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 wreq::header::OrigHeaderMap;
 
-use crate::error::{header_name_error_to_magnus, header_value_error_to_magnus};
+use crate::error::{
+    header_name_error_to_magnus, header_value_error_to_magnus, type_value_error_to_magnus,
+};
 
 /// HTTP headers collection with read and write operations.
 ///
@@ -15,7 +21,17 @@ 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>);
+
+/// A map from header names to their original casing as received in an HTTP message.
+pub struct OrigHeaders(pub OrigHeaderMap);
+
+struct HeaderIter {
+    inner: http::header::IntoIter<HeaderValue>,
+    next_name: Option<HeaderName>,
+}
+
+// ===== impl Headers =====
 
 impl Headers {
     /// Create a new empty Headers instance.
@@ -132,11 +148,49 @@ 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 OrigHeaders =====
+
+impl TryConvert for OrigHeaders {
+    fn try_convert(value: magnus::Value) -> Result<Self, magnus::Error> {
+        let mut map = OrigHeaderMap::new();
+
+        let rarray = RArray::from_value(value)
+            .ok_or_else(|| type_value_error_to_magnus("Expected an array of strings"))?;
+
+        for value in rarray.into_iter().flat_map(RString::from_value) {
+            map.insert(value.to_bytes());
+        }
+
+        Ok(Self(map))
+    }
+}
+
+// ===== impl HeaderIter =====
+
 impl Iterator for HeaderIter {
     type Item = (Bytes, Bytes);
     fn next(&mut self) -> Option<Self::Item> {

data/src/http.rs

@@ -1,4 +1,4 @@
-use magnus::{Error, Module, RModule, Ruby, method, typed_data::Inspect};
+use magnus::{Error, Module, RModule, Ruby, TryConvert, Value, method, typed_data::Inspect};
 
 define_ruby_enum!(
     /// An HTTP version.
@@ -41,6 +41,20 @@ impl Version {
     pub fn to_s(&self) -> String {
         self.into_ffi().inspect()
     }
+
+    /// Value-based equality for Ruby (`==`).
+    #[inline]
+    pub fn equals(&self, other: Value) -> bool {
+        <&Version>::try_convert(other)
+            .map(|other| *self == *other)
+            .unwrap_or(false)
+    }
+}
+
+impl TryConvert for Version {
+    fn try_convert(value: magnus::Value) -> Result<Self, magnus::Error> {
+        <&Version>::try_convert(value).cloned()
+    }
 }
 
 // ===== impl StatusCode =====
@@ -113,6 +127,7 @@ pub fn include(ruby: &Ruby, gem_module: &RModule) -> Result<(), Error> {
     version_class.const_set("HTTP_2", Version::HTTP_2)?;
     version_class.const_set("HTTP_3", Version::HTTP_3)?;
     version_class.define_method("to_s", method!(Version::to_s, 0))?;
+    version_class.define_method("==", method!(Version::equals, 1))?;
 
     let status_code_class = gem_module.define_class("StatusCode", ruby.class_object())?;
     status_code_class.define_method("as_int", method!(StatusCode::as_int, 0))?;

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

data/test/emulation_test.rb

@@ -4,18 +4,18 @@ require "test_helper"
 
 class EmulationTest < Minitest::Test
   def test_all_emulation_device_constants_are_non_nil
-    Wreq::EmulationDevice.constants.each do |name|
-      const = Wreq::EmulationDevice.const_get(name)
-      assert_instance_of Wreq::EmulationDevice, const,
-        "#{name} should be EmulationDevice, got #{const.inspect}"
+    Wreq::Profile.constants.each do |name|
+      const = Wreq::Profile.const_get(name)
+      assert_instance_of Wreq::Profile, const,
+        "#{name} should be Profile, got #{const.inspect}"
     end
   end
 
   def test_all_emulation_os_constants_are_non_nil
-    Wreq::EmulationOS.constants.each do |name|
-      const = Wreq::EmulationOS.const_get(name)
-      assert_instance_of Wreq::EmulationOS, const,
-        "#{name} should be EmulationOS, got #{const.inspect}"
+    Wreq::Platform.constants.each do |name|
+      const = Wreq::Platform.const_get(name)
+      assert_instance_of Wreq::Platform, const,
+        "#{name} should be Platform, got #{const.inspect}"
     end
   end
 end

data/test/error_handling_test.rb

@@ -82,7 +82,10 @@ class ErrorHandlingTest < Minitest::Test
         Wreq.get(url, proxy: proxy, timeout: 5)
         flunk "Expected proxy connection error but got response"
       rescue => e
-        assert_instance_of Wreq::ProxyConnectionError, e
+        assert(
+          e.is_a?(Wreq::ProxyConnectionError) || e.is_a?(Wreq::RequestError),
+          "Expected ProxyConnectionError or RequestError, got #{e.class}: #{e.message}"
+        )
       end
     end
   end

data/test/inspect_test.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+class InspectTest < Minitest::Test
+  # ---- Headers ----
+
+  def test_headers_inspect_empty
+    headers = Wreq::Headers.new
+    assert_equal "#<Wreq::Headers [0 headers]>", headers.inspect
+  end
+
+  def test_headers_inspect_with_entries
+    headers = Wreq::Headers.new
+    headers.set("Content-Type", "text/html")
+    headers.set("Accept", "application/json")
+    assert_equal "#<Wreq::Headers [2 headers]>", headers.inspect
+  end
+
+  # ---- Cookie ----
+
+  def test_cookie_inspect_minimal
+    c = Wreq::Cookie.new("sid", "secret123")
+    result = c.inspect
+    assert_includes result, "#<Wreq::Cookie"
+    assert_includes result, "sid"
+    refute_includes result, "secret123"
+    assert result.end_with?(">")
+  end
+
+  def test_cookie_inspect_with_domain_and_path
+    c = Wreq::Cookie.new("sid", "val",
+      domain: "example.com",
+      path: "/app")
+    result = c.inspect
+    assert_includes result, "domain=example.com"
+    assert_includes result, "path=/app"
+  end
+
+  def test_cookie_inspect_with_flags
+    c = Wreq::Cookie.new("sid", "val",
+      secure: true,
+      http_only: true)
+    result = c.inspect
+    assert_includes result, "secure"
+    assert_includes result, "http_only"
+  end
+
+  def test_cookie_inspect_omits_nil_attributes
+    c = Wreq::Cookie.new("sid", "val")
+    result = c.inspect
+    refute_includes result, "domain="
+    refute_includes result, "path="
+    refute_includes result, "secure"
+    refute_includes result, "http_only"
+  end
+
+  # ---- Jar ----
+
+  def test_jar_inspect_empty
+    jar = Wreq::Jar.new
+    assert_equal "#<Wreq::Jar [0 cookies]>", jar.inspect
+  end
+
+  def test_jar_inspect_with_cookies
+    jar = Wreq::Jar.new
+    jar.add("a=1; Path=/", "https://example.com")
+    jar.add("b=2; Path=/", "https://example.com")
+    assert_equal "#<Wreq::Jar [2 cookies]>", jar.inspect
+  end
+
+  # ---- Client ----
+
+  def test_client_inspect
+    client = Wreq::Client.new
+    assert_equal "#<Wreq::Client>", client.inspect
+  end
+
+  def test_client_inspect_with_options
+    client = Wreq::Client.new(timeout: 30, gzip: true)
+    assert_equal "#<Wreq::Client>", client.inspect
+  end
+
+  # ---- Response ----
+
+  def test_response_to_s_returns_body
+    response = Wreq.get("http://localhost:8080/json")
+    assert_equal response.text, response.to_s
+  end
+
+  def test_response_inspect_format
+    response = Wreq.get("http://localhost:8080/json")
+    result = response.inspect
+    assert result.start_with?("#<Wreq::Response")
+    assert_includes result, "200"
+    assert result.end_with?(">")
+  end
+
+  # ---- StatusCode ----
+
+  def test_status_code_inspect
+    response = Wreq.get("http://localhost:8080/status/200")
+    result = response.status.inspect
+    assert result.start_with?("#<Wreq::StatusCode")
+    assert_includes result, response.status.to_s
+    assert result.end_with?(">")
+  end
+
+  # ---- Version ----
+
+  def test_version_inspect_from_constant
+    v = Wreq::Version::HTTP_11
+    result = v.inspect
+    assert result.start_with?("#<Wreq::Version")
+    assert_includes result, v.to_s
+    assert result.end_with?(">")
+  end
+
+  def test_version_inspect_from_response
+    response = Wreq.get("http://localhost:8080/get")
+    result = response.version.inspect
+    assert result.start_with?("#<Wreq::Version")
+    assert result.end_with?(">")
+  end
+end

data/test/orig_header_test.rb

@@ -0,0 +1,115 @@
+require "test_helper"
+
+class OrigHeaderTest < Minitest::Test
+  URL = "https://tls.browserleaks.com/http1"
+
+  CASES = [
+    {
+      name: "mixed_case_descending",
+      headers: {
+        "X-Zeta-Token" => "zeta",
+        "x-alpha-key" => "alpha",
+        "X-MiXeD-CaSe" => "mixed"
+      },
+      orig_headers: ["X-Zeta-Token", "x-alpha-key", "X-MiXeD-CaSe"]
+    },
+    {
+      name: "reverse_alpha_order",
+      headers: {
+        "X-Third" => "3",
+        "X-Second" => "2",
+        "X-First" => "1"
+      },
+      orig_headers: ["X-Third", "X-Second", "X-First"]
+    },
+    {
+      name: "preserve_weird_casing",
+      headers: {
+        "x-a" => "a",
+        "X-B" => "b",
+        "x-C" => "c"
+      },
+      orig_headers: ["x-C", "x-a", "X-B"]
+    },
+    {
+      name: "interleaved_tokens",
+      headers: {
+        "X-Token-3" => "v3",
+        "X-Token-1" => "v1",
+        "X-Token-2" => "v2"
+      },
+      orig_headers: ["X-Token-1", "X-Token-2", "X-Token-3"]
+    }
+  ].freeze
+
+  def test_client_default_orig_headers_preserves_header_order_in_multiple_shuffled_cases
+    CASES.each do |kase|
+      client = Wreq::Client.new(
+        headers: kase[:headers],
+        orig_headers: kase[:orig_headers]
+      )
+
+      response = client.get(URL, version: Wreq::Version::HTTP_11)
+      assert_equal 200, response.code, "case=#{kase[:name]}"
+
+      echoed_headers = extract_http1_headers(response.json, kase[:name])
+      assert_header_order(echoed_headers, kase[:orig_headers], kase[:name])
+      assert_header_values(echoed_headers, kase[:headers], kase[:name])
+    end
+  end
+
+  def test_module_request_orig_headers_preserves_header_order_in_multiple_shuffled_cases
+    CASES.each do |kase|
+      response = Wreq.get(
+        URL,
+        headers: kase[:headers],
+        orig_headers: kase[:orig_headers],
+        version: Wreq::Version::HTTP_11
+      )
+      assert_equal 200, response.code, "case=#{kase[:name]}"
+
+      echoed_headers = extract_http1_headers(response.json, kase[:name])
+      assert_header_order(echoed_headers, kase[:orig_headers], kase[:name])
+      assert_header_values(echoed_headers, kase[:headers], kase[:name])
+    end
+  end
+
+  private
+
+  def extract_http1_headers(json, case_name)
+    http1 = fetch_by_name(json, "http1")
+    refute_nil http1, "case=#{case_name}: expected JSON key 'http1', got #{json.keys.inspect}"
+
+    headers = fetch_by_name(http1, "headers")
+    refute_nil headers, "case=#{case_name}: expected JSON key 'http1.headers'"
+    headers
+  end
+
+  def fetch_by_name(hash_like, key_name)
+    return hash_like[key_name] if hash_like.respond_to?(:key?) && hash_like.key?(key_name)
+    return hash_like[key_name.to_sym] if hash_like.respond_to?(:key?) && hash_like.key?(key_name.to_sym)
+
+    pair = hash_like.find { |k, _| k.to_s == key_name }
+    pair&.last
+  end
+
+  def assert_header_order(echoed_headers, ordered_names, case_name)
+    echoed_keys = echoed_headers.keys
+    positions = ordered_names.map do |expected_name|
+      index = echoed_keys.index(expected_name)
+      refute_nil index, "case=#{case_name}: expected header to exist in echo: #{expected_name}"
+      index
+    end
+
+    assert_equal positions.sort, positions,
+      "case=#{case_name}: expected header order #{ordered_names.inspect}, got keys #{echoed_keys.inspect}"
+  end
+
+  def assert_header_values(echoed_headers, expected_headers, case_name)
+    expected_headers.each do |name, expected_value|
+      assert echoed_headers.key?(name),
+        "case=#{case_name}: expected exact-case header name #{name}, got #{echoed_headers.keys.inspect}"
+      assert_equal expected_value, echoed_headers[name]
+    end
+  end
+end

data/test/request_test.rb

@@ -6,6 +6,16 @@ class WreqHttpbinTest < Minitest::Test
     @client = Wreq::Client.new(timeout: 30)
   end
 
+  def test_spec_http1_version
+    response = Wreq.get("https://tls.browserleaks.com", version: Wreq::Version::HTTP_11)
+    assert_equal response.version, Wreq::Version::HTTP_11
+  end
+
+  def test_spec_http2_version
+    response = Wreq.get("https://tls.browserleaks.com", version: Wreq::Version::HTTP_2)
+    assert_equal response.version, Wreq::Version::HTTP_2
+  end
+
   def test_module_get_method
     response = Wreq.get("http://localhost:8080/get")
     assert_equal 200, response.code