wreq 1.0.0

data/src/rt.rs

@@ -0,0 +1,47 @@
+use std::sync::LazyLock;
+
+use tokio::runtime::{Builder, Runtime};
+
+use crate::{error::interrupt_error, gvl};
+
+static RUNTIME: LazyLock<Runtime> = LazyLock::new(|| {
+    Builder::new_multi_thread()
+        .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
+where
+    F: Future<Output = Result<T, magnus::Error>>,
+{
+    gvl::nogvl_cancellable(|flag| {
+        RUNTIME.block_on(async move {
+            tokio::select! {
+                biased;
+                _ = flag.cancelled() => Err(interrupt_error()),
+                result = future => result,
+            }
+        })
+    })
+}
+
+/// 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

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+class ClientCookieProviderTest < Minitest::Test
+  HOST = "http://localhost:8080"
+
+  def setup
+    @jar = Wreq::Jar.new
+    @client = Wreq::Client.new(
+      cookie_store: true,
+      cookie_provider: @jar,
+      allow_redirects: true
+    )
+  end
+
+  def test_custom_jar_captures_set_cookie_and_sends_back
+    # starts empty
+    assert_kind_of Array, @jar.get_all
+    assert_equal 0, @jar.get_all.length
+
+    # server sets cookie; client follows redirect; jar should store it
+    res1 = @client.get("#{HOST}/cookies/set?foo=bar")
+    assert_equal 200, res1.code
+
+    names = @jar.get_all.map(&:name)
+    assert_includes names, "foo"
+
+    # 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")
+  end
+
+  def test_prepopulated_jar_is_used_by_client
+    # pre-populate jar
+    @jar.add_cookie_str("pref=1; Path=/", "#{HOST}/")
+
+    res = @client.get("#{HOST}/cookies")
+    assert_equal 200, res.code
+    cookies = res.json["cookies"]
+    assert_equal "1", cookies["pref"]
+  end
+end

data/test/client_test.rb

@@ -0,0 +1,136 @@
+require "test_helper"
+
+class ClientTest < Minitest::Test
+  def setup
+    @client = Wreq::Client.new
+  end
+
+  def test_client_creation
+    refute_nil @client
+    assert_instance_of Wreq::Client, @client
+  end
+
+  def test_client_with_configuration
+    client = Wreq::Client.new(
+      timeout: 30,
+      headers: {"User-Agent" => "wreq-ruby/test"}
+    )
+    refute_nil client
+    assert_instance_of Wreq::Client, client
+  end
+
+  def test_get_request
+    response = @client.get("http://localhost:8080/get")
+    refute_nil response
+    assert_equal 200, response.code
+  end
+
+  def test_post_request
+    response = @client.post("http://localhost:8080/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",
+      json: {data: "test"})
+    refute_nil response
+    assert_equal 200, response.code
+  end
+
+  def test_delete_request
+    response = @client.delete("http://localhost:8080/delete")
+    refute_nil response
+    assert_equal 200, response.code
+  end
+
+  def test_patch_request
+    response = @client.patch("http://localhost:8080/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",
+      query: {"param" => "value"})
+    refute_nil response
+    assert_equal 200, response.code
+    assert_includes response.text, "param"
+  end
+
+  def test_request_with_form_data
+    response = @client.post("http://localhost:8080/post",
+      form: {"field" => "value"})
+    refute_nil response
+    assert_equal 200, response.code
+    assert_includes response.text, "field"
+  end
+
+  def test_request_with_raw_body
+    response = @client.post("http://localhost:8080/post",
+      body: "raw content",
+      headers: {"Content-Type" => "text/plain"})
+    refute_nil response
+    assert_equal 200, response.code
+    assert_includes response.text, "raw content"
+  end
+
+  def test_basic_authentication
+    response = @client.get("http://localhost:8080/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",
+      bearer_auth: "test-token")
+    refute_nil response
+    assert_equal 200, response.code
+    assert_includes response.text, "test-token"
+  end
+
+  def test_redirect_following
+    response = @client.get("http://localhost:8080/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",
+      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)
+    refute_nil response
+    assert_equal 200, response.code
+  end
+
+  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)
+    end
+
+    # Test that reasonable timeouts work normally
+    start_time = Time.now
+    response = @client.get("http://localhost:8080/delay/1", timeout: 5)
+    elapsed = Time.now - start_time
+
+    refute_nil response
+    assert_equal 200, response.code
+    assert elapsed < 5, "Request should complete within timeout"
+  end
+
+  def test_status_codes
+    response = @client.get("http://localhost:8080/status/404")
+    refute_nil response
+    assert_equal 404, response.code
+  end
+end

data/test/cookie_test.rb

@@ -0,0 +1,166 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+class CookieTest < Minitest::Test
+  def setup
+    @jar = Wreq::Jar.new
+    @base_url = "https://example.com"
+  end
+
+  def test_jar_initially_empty
+    assert_instance_of Wreq::Jar, @jar
+    cookies = begin
+      Wreq::Jar.get_all(@jar)
+    rescue
+      @jar.get_all
+    end # support either binding style
+    assert_kind_of Array, cookies
+    assert_equal 0, cookies.length
+  end
+
+  def test_add_cookie_str_and_get_all
+    set_cookie = "sid=abc123; Path=/; Domain=example.com; HttpOnly; Secure"
+    @jar.add_cookie_str(set_cookie, @base_url)
+
+    cookies = @jar.get_all
+    assert_kind_of Array, cookies
+    assert_equal 1, cookies.length
+
+    c = cookies.first
+    assert_instance_of Wreq::Cookie, c
+    assert_equal "sid", c.name
+    assert_equal "abc123", c.value
+
+    # attributes parsed from Set-Cookie
+    assert_equal "/", c.path
+    assert_equal "example.com", c.domain
+
+    # predicate-ish flags
+    assert_equal true, (c.http_only || c.http_only?)
+    assert_equal true, (c.secure || c.secure?)
+  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)
+
+    cookies = @jar.get_all
+    assert_equal 3, cookies.length
+
+    # remove one by name
+    @jar.remove("b", @base_url)
+    names = @jar.get_all.map(&:name)
+    refute_includes names, "b"
+    assert_includes names, "a"
+    assert_includes names, "c"
+  end
+
+  def test_clear
+    @jar.add_cookie_str("x=1; Path=/", @base_url)
+    @jar.add_cookie_str("y=2; Path=/", @base_url)
+    refute_empty @jar.get_all
+
+    @jar.clear
+    assert_empty @jar.get_all
+  end
+
+  def test_max_age_and_expires_optional
+    # Max-Age only
+    @jar.clear
+    @jar.add_cookie_str("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
+    if (v = c1.max_age)
+      assert_kind_of Integer, v
+      assert_operator v, :>=, 0
+    end
+
+    # 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)
+    c2 = @jar.get_all.find { |c| c.name == "exp" }
+    assert c2
+    # expires returns Float (unix seconds) or nil
+    if (e = c2.expires)
+      assert_kind_of Float, e
+      assert_operator e, :>, Time.now.to_f - 1_000_000 # sanity bound
+    end
+  end
+
+  # -------- Wreq::Cookie unit tests --------
+
+  def test_cookie_new_minimal
+    c = Wreq::Cookie.new("sid", "abc")
+
+    assert_instance_of Wreq::Cookie, c
+    assert_equal "sid", c.name
+    assert_equal "abc", c.value
+
+    assert_nil c.path
+    assert_nil c.domain
+    assert_nil c.max_age
+    assert_nil c.expires
+
+    assert_equal false, (c.http_only || c.http_only?)
+    assert_equal false, (c.secure || c.secure?)
+    assert_equal false, c.same_site_lax?
+    assert_equal false, c.same_site_strict?
+  end
+
+  def test_cookie_new_full_attributes
+    exp = Time.now.to_f + 7200.0
+    c = Wreq::Cookie.new("sess", "v",
+      domain: "example.com",
+      path: "/",
+      max_age: 3600,
+      expires: exp,
+      http_only: true,
+      secure: true,
+      same_site: Wreq::SameSite::Lax)
+
+    assert_equal "sess", c.name
+    assert_equal "v", c.value
+    assert_equal "example.com", c.domain
+    assert_equal "/", c.path
+
+    # Max-Age returns seconds as Integer
+    assert_equal 3600, c.max_age
+
+    # Expires returns Float seconds-since-epoch (with small tolerance)
+    assert c.expires
+    assert_kind_of Float, c.expires
+    assert_in_delta exp, c.expires, 2.0
+
+    assert_equal true, (c.http_only || c.http_only?)
+    assert_equal true, (c.secure || c.secure?)
+    # constructor currently sets SameSite to none
+    assert_equal true, c.same_site_lax?
+    assert_equal false, c.same_site_strict?
+  end
+
+  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)
+
+    cookies = @jar.get_all
+    h = cookies.to_h { |ck| [ck.name, [ck.same_site_strict?, ck.same_site_lax?]] }
+
+    assert_equal [true, false], h["s1"]
+    assert_equal [false, true], h["s2"]
+  end
+
+  def test_request_cookie_value_percent_encoding
+    raw_value = "hello world?"
+    client = Wreq::Client.new
+    resp = client.get(
+      "http://localhost:8080/cookies",
+      cookies: {"mykey" => raw_value}
+    )
+    assert_includes resp.text, "hello%20world%3F"
+  end
+end

data/test/emulation_test.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+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}"
+    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}"
+    end
+  end
+end

data/test/error_handling_test.rb

@@ -0,0 +1,89 @@
+require "test_helper"
+
+class ErrorHandlingTest < Minitest::Test
+  def test_network_error_handling
+    # Try to connect to a non-existent domain
+    response = Wreq.get("https://definitely-not-a-real-domain-12345.com")
+    flunk "Expected network error but got response: #{response.code}"
+  rescue => e
+    assert_instance_of Wreq::ConnectionError, e
+    # Network errors should be caught and wrapped appropriately
+  end
+
+  def test_invalid_url_handling
+    # Invalid URL format
+    response = Wreq.get("not-a-valid-url")
+    flunk "Expected URL error but got response: #{response.code}"
+  rescue => e
+    assert_instance_of Wreq::BuilderError, e
+  end
+
+  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}")
+      assert_equal status_code, response.code
+      # Should not raise an exception for HTTP error codes
+    end
+  end
+
+  def test_timeout_handling
+    # 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)
+    # If we get here, the request didn't timeout (unexpected)
+    flunk "Expected timeout error but got response: #{response.code}"
+  rescue => e
+    # Timeout error is expected
+    assert_instance_of Wreq::TimeoutError, e
+    # Could also check error message contains timeout-related keywords
+  end
+
+  def test_invalid_json_response
+    # Get a non-JSON response and try to parse as JSON
+    response = Wreq.get("http://localhost:8080/html")
+    assert_equal 200, response.code
+
+    # Should raise an error when trying to parse HTML as JSON
+    begin
+      response.json
+    rescue => e
+      assert_instance_of Wreq::DecodingError, e
+    end
+  end
+
+  def test_empty_response_json
+    response = Wreq.get("http://localhost:8080/status/204")
+    assert_equal 204, response.code
+    assert_equal "", response.text
+
+    # Empty body should raise error when parsing as JSON
+    begin
+      response.json
+    rescue => e
+      assert_instance_of Wreq::DecodingError, e
+    end
+  end
+
+  def test_proxy_error_handling
+    invalid_proxies = [
+      "http://invalid.proxy:8080",
+      "https://invalid.proxy:8080",
+      "socks4://invalid.proxy:8080",
+      "socks4a://invalid.proxy:8080",
+      "socks5://invalid.proxy:8080",
+      "socks5h://invalid.proxy:8080"
+    ]
+    target_urls = ["https://example.com", "http://example.com"]
+
+    invalid_proxies.each do |proxy|
+      target_urls.each do |url|
+        Wreq.get(url, proxy: proxy, timeout: 5)
+        flunk "Expected proxy connection error but got response"
+      rescue => e
+        assert_instance_of Wreq::ProxyConnectionError, e
+      end
+    end
+  end
+end