wreq 1.2.5-aarch64-linux → 1.2.7-aarch64-linux

data/test/option_validation_test.rb

@@ -0,0 +1,311 @@
+require "test_helper"
+
+class OptionValidationTest < Minitest::Test
+  INVALID_URL = "not a url"
+
+  def test_unknown_client_option_names_every_invalid_key_without_values
+    secret = "must-not-appear"
+
+    error = assert_raises(ArgumentError) do
+      Wreq::Client.new(timout: secret, history: secret)
+    end
+
+    assert_includes error.message, ":timout"
+    assert_includes error.message, ":history"
+    refute_includes error.message, secret
+  end
+
+  def test_unknown_options_are_checked_before_known_values
+    secret = "must-not-appear"
+
+    error = assert_raises(ArgumentError) do
+      Wreq::Client.new(timeout: secret, history: Object.new, timout: secret)
+    end
+
+    assert_includes error.message, ":history"
+    assert_includes error.message, ":timout"
+    refute_includes error.message, secret
+
+    conflict_error = assert_raises(ArgumentError) do
+      Wreq::Client.new(http1_only: true, http2_only: true, history: secret)
+    end
+    assert_includes conflict_error.message, ":history"
+    refute_includes conflict_error.message, secret
+  end
+
+  def test_unknown_request_options_raise_for_client_and_module_methods
+    client_error = assert_raises(ArgumentError) do
+      Wreq::Client.new.get(INVALID_URL, history: true)
+    end
+    module_error = assert_raises(ArgumentError) do
+      Wreq.get(INVALID_URL, history: true)
+    end
+
+    assert_includes client_error.message, ":history"
+    assert_includes module_error.message, ":history"
+  end
+
+  def test_hash_expansion_uses_the_same_validation
+    valid = {timeout: 1, allow_redirects: true, max_redirects: 2}
+    invalid = {timout: 1}
+
+    assert_instance_of Wreq::Client, Wreq::Client.new(**valid)
+    error = assert_raises(ArgumentError) { Wreq::Client.new(**invalid) }
+    assert_includes error.message, ":timout"
+  end
+
+  def test_string_option_keys_are_supported_and_duplicate_forms_are_rejected
+    assert_instance_of Wreq::Client, Wreq::Client.new({"timeout" => 1})
+
+    error = assert_raises(ArgumentError) do
+      Wreq::Client.new({:timeout => 1, "timeout" => 2})
+    end
+    assert_includes error.message, "duplicate option: :timeout"
+  end
+
+  def test_non_string_or_symbol_option_key_raises_type_error
+    error = assert_raises(TypeError) { Wreq::Client.new({1 => true}) }
+
+    assert_includes error.message, "option keys"
+  end
+
+  def test_hash_subclass_cannot_hide_unknown_options
+    options_class = Class.new(Hash) do
+      def keys
+        []
+      end
+    end
+    options = options_class.new
+    options[:timout] = 1
+
+    error = assert_raises(ArgumentError) { Wreq::Client.new(options) }
+    assert_includes error.message, ":timout"
+  end
+
+  def test_invalid_known_values_name_the_option
+    timeout_error = assert_raises(TypeError) do
+      Wreq::Client.new(timeout: "slow")
+    end
+    address_error = assert_raises(ArgumentError) do
+      Wreq::Client.new(local_address: "not-an-address")
+    end
+    proxy_error = assert_raises(TypeError) do
+      Wreq::Client.new(proxy: Object.new)
+    end
+    proxy_uri_error = assert_raises(Wreq::BuilderError) do
+      Wreq::Client.new(proxy: "invalid://")
+    end
+    orig_headers_error = assert_raises(Wreq::BuilderError) do
+      Wreq.get(INVALID_URL, orig_headers: ["Accept", Object.new])
+    end
+
+    assert_includes timeout_error.message, ":timeout"
+    assert_includes address_error.message, ":local_address"
+    assert_includes proxy_error.message, ":proxy"
+    assert_includes proxy_uri_error.message, ":proxy"
+    assert_includes orig_headers_error.message, ":orig_headers"
+  end
+
+  def test_consumed_body_sender_error_preserves_class_and_names_option
+    sender = Wreq::BodySender.new(1)
+
+    assert_raises(Wreq::BuilderError) do
+      Wreq.post(INVALID_URL, body: sender)
+    end
+    error = assert_raises(Wreq::MemoryError) do
+      Wreq.post(INVALID_URL, body: sender)
+    end
+
+    assert_includes error.message, ":body"
+  ensure
+    sender&.close
+  end
+
+  def test_option_conversion_preserves_raised_exception_class
+    source = Object.new
+    source.define_singleton_method(:to_a) { raise IOError, "boom" }
+
+    error = assert_raises(IOError) do
+      Wreq::Client.new(headers: source)
+    end
+
+    assert_includes error.message, ":headers"
+    assert_includes error.message, "boom"
+  end
+
+  def test_out_of_range_integer_names_the_option
+    error = assert_raises(ArgumentError) do
+      Wreq::Client.new(timeout: 2**256)
+    end
+
+    assert_includes error.message, ":timeout"
+  end
+
+  def test_invalid_request_value_names_the_option_before_network_io
+    error = assert_raises(TypeError) do
+      Wreq.get(INVALID_URL, cookies: Object.new)
+    end
+
+    assert_includes error.message, ":cookies"
+  end
+
+  def test_client_constructor_rejects_non_hash_and_extra_arguments
+    assert_raises(TypeError) { Wreq::Client.new("ignored") }
+    assert_raises(ArgumentError) { Wreq::Client.new({}, {}) }
+  end
+
+  def test_emulation_constructor_rejects_invalid_arguments_and_options
+    assert_raises(TypeError) { Wreq::Emulation.new("ignored") }
+    assert_raises(ArgumentError) { Wreq::Emulation.new({}, {}) }
+
+    error = assert_raises(ArgumentError) { Wreq::Emulation.new(unknown: true) }
+    assert_includes error.message, ":unknown"
+  end
+
+  def test_invalid_emulation_values_name_the_option
+    http2_error = assert_raises(TypeError) do
+      Wreq::Emulation.new(http2: "yes")
+    end
+    profile_error = assert_raises(TypeError) do
+      Wreq::Emulation.new(profile: Object.new)
+    end
+
+    assert_includes http2_error.message, ":http2"
+    assert_includes profile_error.message, ":profile"
+  end
+
+  def test_body_options_are_mutually_exclusive
+    error = assert_raises(ArgumentError) do
+      Wreq.post(INVALID_URL, body: "raw", form: {a: 1}, json: {b: 2})
+    end
+
+    assert_includes error.message, ":body"
+    assert_includes error.message, ":form"
+    assert_includes error.message, ":json"
+  end
+
+  def test_body_conflict_does_not_consume_sender
+    sender = Wreq::BodySender.new(1)
+
+    assert_raises(ArgumentError) do
+      Wreq.post(INVALID_URL, body: sender, json: {value: true})
+    end
+    assert_raises(Wreq::BuilderError) do
+      Wreq.post(INVALID_URL, body: sender)
+    end
+  ensure
+    sender&.close
+  end
+
+  def test_dependent_option_error_does_not_consume_sender
+    sender = Wreq::BodySender.new(1)
+
+    assert_raises(ArgumentError) do
+      Wreq.post(INVALID_URL, body: sender, max_redirects: 2)
+    end
+    assert_raises(Wreq::BuilderError) do
+      Wreq.post(INVALID_URL, body: sender)
+    end
+  ensure
+    sender&.close
+  end
+
+  def test_authentication_options_are_mutually_exclusive
+    error = assert_raises(ArgumentError) do
+      Wreq.get(
+        INVALID_URL,
+        auth: "secret",
+        bearer_auth: "secret",
+        basic_auth: ["user", "secret"]
+      )
+    end
+
+    assert_includes error.message, ":auth"
+    assert_includes error.message, ":bearer_auth"
+    assert_includes error.message, ":basic_auth"
+    refute_includes error.message, "secret"
+  end
+
+  def test_protocol_only_options_are_mutually_exclusive
+    error = assert_raises(ArgumentError) do
+      Wreq::Client.new(http1_only: true, http2_only: true)
+    end
+
+    assert_includes error.message, ":http1_only"
+    assert_includes error.message, ":http2_only"
+  end
+
+  def test_validation_reports_the_first_failed_rule
+    error = assert_raises(ArgumentError) do
+      Wreq::Client.new(
+        http1_only: true,
+        http2_only: true,
+        max_redirects: 2,
+        headers: Object.new
+      )
+    end
+
+    assert_includes error.message, ":http1_only"
+    assert_includes error.message, ":http2_only"
+    refute_includes error.message, ":max_redirects"
+  end
+
+  def test_explicit_proxy_and_no_proxy_are_mutually_exclusive
+    error = assert_raises(ArgumentError) do
+      Wreq::Client.new(proxy: "http://127.0.0.1:8080", no_proxy: true)
+    end
+
+    assert_includes error.message, ":proxy"
+    assert_includes error.message, ":no_proxy"
+  end
+
+  def test_max_redirects_requires_redirects_to_be_enabled
+    client_error = assert_raises(ArgumentError) do
+      Wreq::Client.new(max_redirects: 2)
+    end
+    disabled_error = assert_raises(ArgumentError) do
+      Wreq::Client.new(allow_redirects: false, max_redirects: 2)
+    end
+    request_error = assert_raises(ArgumentError) do
+      Wreq.get(INVALID_URL, max_redirects: 2)
+    end
+
+    [client_error, disabled_error, request_error].each do |error|
+      assert_includes error.message, ":max_redirects"
+      assert_includes error.message, ":allow_redirects"
+    end
+  end
+
+  def test_unsupported_platform_option_raises_argument_error
+    return if RUBY_PLATFORM.match?(/linux|android|fuchsia/)
+
+    error = assert_raises(ArgumentError) do
+      Wreq::Client.new(tcp_user_timeout: 1)
+    end
+    assert_instance_of ArgumentError, error
+    assert_includes error.message, ":tcp_user_timeout"
+  end
+
+  def test_windows_rejects_interface_for_client_and_request
+    return unless Gem.win_platform?
+
+    client_error = assert_raises(ArgumentError) do
+      Wreq::Client.new(interface: "Ethernet")
+    end
+    request_error = assert_raises(ArgumentError) do
+      Wreq.get(INVALID_URL, interface: "Ethernet")
+    end
+
+    assert_instance_of ArgumentError, client_error
+    assert_instance_of ArgumentError, request_error
+    assert_includes client_error.message, ":interface"
+    assert_includes request_error.message, ":interface"
+  end
+
+  def test_valid_nil_and_zero_option_construction
+    assert_instance_of Wreq::Client, Wreq::Client.new
+    assert_instance_of Wreq::Client,
+      Wreq::Client.new(proxy: nil, interface: nil, tcp_user_timeout: nil)
+    assert_instance_of Wreq::Emulation, Wreq::Emulation.new(profile: nil, http2: true)
+  end
+end

data/test/value_semantics_test.rb

@@ -0,0 +1,238 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+class ValueSemanticsTest < Minitest::Test
+  # ---- StatusCode ----
+
+  def setup
+    @response = Wreq.get("#{HTTPBIN_URL}/status/201")
+  end
+
+  def test_status_code_to_i
+    assert_equal 201, @response.status.to_i
+  end
+
+  def test_status_code_as_int_still_works
+    assert_equal 201, @response.status.as_int
+  end
+
+  def test_status_code_to_i_matches_as_int
+    assert_equal @response.status.as_int, @response.status.to_i
+  end
+
+  def test_status_code_equality
+    a = @response.status
+    b = @response.status
+    assert_equal a, b
+  end
+
+  def test_status_code_eql
+    a = @response.status
+    b = @response.status
+    assert a.eql?(b)
+  end
+
+  def test_status_code_hash_consistent
+    a = @response.status
+    b = @response.status
+    assert_equal a.hash, b.hash
+  end
+
+  def test_status_code_as_hash_key
+    status = @response.status
+    h = {status => "created"}
+    assert_equal "created", h[@response.status]
+  end
+
+  def test_status_code_in_set
+    s = Set.new
+    s.add(@response.status)
+    assert_includes s, @response.status
+  end
+
+  def test_status_code_not_equal_to_integer
+    refute_equal @response.status, 201
+    refute @response.status.eql?(201)
+  end
+
+  def test_status_code_different_values_not_equal
+    ok = Wreq.get("#{HTTPBIN_URL}/status/200").status
+    created = @response.status
+    refute_equal ok, created
+    refute ok.eql?(created)
+  end
+
+  def test_response_code_still_returns_integer
+    assert_instance_of Integer, @response.code
+    assert_equal 201, @response.code
+  end
+
+  # ---- Version ----
+
+  def test_version_equality
+    assert_equal Wreq::Version::HTTP_11, Wreq::Version::HTTP_11
+    assert_equal "HTTP/0.9", Wreq::Version::HTTP_09.to_s
+    assert_equal "HTTP/1.0", Wreq::Version::HTTP_10.to_s
+    assert_equal "HTTP/1.1", Wreq::Version::HTTP_11.to_s
+    assert_equal "HTTP/2.0", Wreq::Version::HTTP_2.to_s
+    assert_equal "HTTP/3.0", Wreq::Version::HTTP_3.to_s
+  end
+
+  def test_version_eql
+    v = Wreq::Version::HTTP_11
+    assert v.eql?(Wreq::Version::HTTP_11)
+  end
+
+  def test_version_hash_consistent
+    a = Wreq::Version::HTTP_11
+    b = Wreq::Version::HTTP_11
+    assert_equal a.hash, b.hash
+  end
+
+  def test_version_different_values_not_equal
+    refute_equal Wreq::Version::HTTP_11, Wreq::Version::HTTP_2
+  end
+
+  def test_version_as_hash_key
+    v = Wreq::Version::HTTP_11
+    h = {v => "http1.1"}
+    assert_equal "http1.1", h[Wreq::Version::HTTP_11]
+  end
+
+  def test_version_in_set
+    s = Set.new([Wreq::Version::HTTP_11, Wreq::Version::HTTP_2])
+    assert_includes s, Wreq::Version::HTTP_11
+    assert_includes s, Wreq::Version::HTTP_2
+    refute_includes s, Wreq::Version::HTTP_3
+  end
+
+  # ---- Method ----
+
+  def test_method_to_s
+    assert_equal "GET", Wreq::Method::GET.to_s
+    assert_equal "POST", Wreq::Method::POST.to_s
+    assert_equal "PUT", Wreq::Method::PUT.to_s
+    assert_equal "DELETE", Wreq::Method::DELETE.to_s
+    assert_equal "HEAD", Wreq::Method::HEAD.to_s
+    assert_equal "OPTIONS", Wreq::Method::OPTIONS.to_s
+    assert_equal "TRACE", Wreq::Method::TRACE.to_s
+    assert_equal "PATCH", Wreq::Method::PATCH.to_s
+  end
+
+  def test_method_to_sym
+    assert_equal :get, Wreq::Method::GET.to_sym
+    assert_equal :post, Wreq::Method::POST.to_sym
+    assert_equal :put, Wreq::Method::PUT.to_sym
+    assert_equal :delete, Wreq::Method::DELETE.to_sym
+    assert_equal :head, Wreq::Method::HEAD.to_sym
+    assert_equal :options, Wreq::Method::OPTIONS.to_sym
+    assert_equal :trace, Wreq::Method::TRACE.to_sym
+    assert_equal :patch, Wreq::Method::PATCH.to_sym
+  end
+
+  def test_method_equality
+    assert_equal Wreq::Method::GET, Wreq::Method::GET
+    refute_equal Wreq::Method::GET, Wreq::Method::POST
+  end
+
+  def test_method_eql
+    assert Wreq::Method::GET.eql?(Wreq::Method::GET)
+    refute Wreq::Method::GET.eql?(Wreq::Method::POST)
+  end
+
+  def test_method_hash_consistent
+    assert_equal Wreq::Method::GET.hash, Wreq::Method::GET.hash
+    refute_equal Wreq::Method::GET.hash, Wreq::Method::POST.hash
+  end
+
+  def test_method_as_hash_key
+    h = {Wreq::Method::GET => "get it"}
+    assert_equal "get it", h[Wreq::Method::GET]
+    assert_nil h[Wreq::Method::POST]
+  end
+
+  # ---- SameSite ----
+
+  def test_same_site_to_s
+    assert_equal "Strict", Wreq::SameSite::Strict.to_s
+    assert_equal "Lax", Wreq::SameSite::Lax.to_s
+    assert_equal "None", Wreq::SameSite::None.to_s
+  end
+
+  def test_same_site_to_sym
+    assert_equal :strict, Wreq::SameSite::Strict.to_sym
+    assert_equal :lax, Wreq::SameSite::Lax.to_sym
+    assert_equal :none, Wreq::SameSite::None.to_sym
+  end
+
+  def test_same_site_equality
+    assert_equal Wreq::SameSite::Lax, Wreq::SameSite::Lax
+    refute_equal Wreq::SameSite::Lax, Wreq::SameSite::Strict
+  end
+
+  def test_same_site_eql_and_hash
+    assert Wreq::SameSite::Lax.eql?(Wreq::SameSite::Lax)
+    assert_equal Wreq::SameSite::Lax.hash, Wreq::SameSite::Lax.hash
+  end
+
+  # ---- Profile ----
+
+  def test_profile_equality
+    assert_equal Wreq::Profile::Chrome134, Wreq::Profile::Chrome134
+    refute_equal Wreq::Profile::Chrome134, Wreq::Profile::Chrome135
+    assert_equal "Chrome134", Wreq::Profile::Chrome134.to_s
+    assert_equal "SafariIos17_4_1", Wreq::Profile::SafariIos17_4_1.to_s
+    assert_equal "OkHttp4_12", Wreq::Profile::OkHttp4_12.to_s
+  end
+
+  def test_profile_eql_and_hash
+    assert Wreq::Profile::Chrome134.eql?(Wreq::Profile::Chrome134)
+    assert_equal Wreq::Profile::Chrome134.hash, Wreq::Profile::Chrome134.hash
+  end
+
+  def test_profile_as_hash_key
+    h = {Wreq::Profile::Chrome134 => "chrome"}
+    assert_equal "chrome", h[Wreq::Profile::Chrome134]
+    assert_nil h[Wreq::Profile::Chrome135]
+  end
+
+  # ---- Platform ----
+
+  def test_platform_equality
+    assert_equal Wreq::Platform::Windows, Wreq::Platform::Windows
+    refute_equal Wreq::Platform::Windows, Wreq::Platform::Linux
+  end
+
+  def test_platform_eql_and_hash
+    assert Wreq::Platform::Windows.eql?(Wreq::Platform::Windows)
+    assert_equal Wreq::Platform::Windows.hash, Wreq::Platform::Windows.hash
+  end
+
+  def test_platform_to_sym
+    assert_equal "Windows", Wreq::Platform::Windows.to_s
+    assert_equal "MacOS", Wreq::Platform::MacOS.to_s
+    assert_equal "Linux", Wreq::Platform::Linux.to_s
+    assert_equal "Android", Wreq::Platform::Android.to_s
+    assert_equal "IOS", Wreq::Platform::IOS.to_s
+
+    assert_equal :windows, Wreq::Platform::Windows.to_sym
+    assert_equal :macos, Wreq::Platform::MacOS.to_sym
+    assert_equal :linux, Wreq::Platform::Linux.to_sym
+    assert_equal :android, Wreq::Platform::Android.to_sym
+    assert_equal :ios, Wreq::Platform::IOS.to_sym
+  end
+
+  # ---- Cross-type comparisons ----
+
+  def test_cross_type_not_equal
+    refute_equal Wreq::Method::GET, Wreq::Version::HTTP_11
+    refute_equal Wreq::SameSite::Lax, Wreq::Method::GET
+    refute_equal Wreq::Platform::Windows, Wreq::Profile::Chrome134
+  end
+
+  def test_cross_type_eql_false
+    refute Wreq::Method::GET.eql?(Wreq::Version::HTTP_11)
+    refute Wreq::SameSite::Lax.eql?(Wreq::Method::GET)
+  end
+end

data/wreq.gemspec

@@ -56,7 +56,7 @@ Gem::Specification.new do |spec|
   # Exclude non-Ruby files from RDoc to prevent parsing errors
   spec.rdoc_options = ["--exclude", "Cargo\\..*", "--exclude", "\\.rs$"]
 
-  spec.requirements = ["Rust >= 1.85"]
+  spec.requirements = ["Rust >= 1.97"]
   # use a Ruby version which:
   # - supports Rubygems with the ability of compilation of Rust gem
   # - not end of life

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: wreq
 version: !ruby/object:Gem::Version
-  version: 1.2.5
+  version: 1.2.7
 platform: aarch64-linux
 authors:
 - SearchApi
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2026-07-15 00:00:00.000000000 Z
+date: 2026-07-24 00:00:00.000000000 Z
 dependencies: []
 description: An easy and powerful Ruby HTTP client with advanced browser fingerprinting
   that accurately emulates Chrome, Edge, Firefox, Safari, Opera, and OkHttp with precise
@@ -20,6 +20,7 @@ extensions: []
 extra_rdoc_files: []
 files:
 - "./extconf.rb"
+- ".cargo/config.toml"
 - Gemfile
 - LICENSE
 - README.md
@@ -60,7 +61,8 @@ files:
 - lib/wreq_ruby/http.rb
 - lib/wreq_ruby/response.rb
 - script/build_platform_gem.rb
-- script/build_windows_gnu.ps1
+- script/rust_env.rb
+- test/body_sender_test.rb
 - test/client_cookie_test.rb
 - test/client_test.rb
 - test/cookie_test.rb
@@ -68,13 +70,16 @@ files:
 - test/error_handling_test.rb
 - test/header_test.rb
 - test/inspect_test.rb
+- test/json_precision_test.rb
 - test/module_methods_test.rb
+- test/option_validation_test.rb
 - test/orig_header_test.rb
 - test/request_parameters_test.rb
 - test/request_test.rb
 - test/response_test.rb
 - test/stream_test.rb
 - test/test_helper.rb
+- test/value_semantics_test.rb
 - wreq.gemspec
 homepage: https://github.com/SearchApi/wreq-ruby
 licenses:
@@ -108,7 +113,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements:
-- Rust >= 1.85
+- Rust >= 1.97
 rubygems_version: 3.5.23
 signing_key: 
 specification_version: 4