wreq 1.2.4-x86_64-linux → 1.2.6-x86_64-linux

data/test/json_precision_test.rb

@@ -0,0 +1,209 @@
+require "test_helper"
+require "json"
+require "socket"
+
+class JsonPrecisionTest < Minitest::Test
+  INTEGER_BOUNDARIES = [
+    (2**53) - 1,
+    2**53,
+    (2**63) - 1,
+    2**63,
+    (2**64) - 1,
+    -((2**53) - 1),
+    -(2**53),
+    -((2**63) - 1),
+    -(2**63),
+    -(2**63) - 1,
+    -((2**64) - 1),
+    -(2**64),
+    2**100,
+    -(2**100),
+    2**256,
+    -(2**256)
+  ].freeze
+
+  def test_response_json_matches_json_parse_for_large_integers
+    payload = precision_payload
+
+    with_json_server(response_body: JSON.generate(payload)) do |url, _requests|
+      response = Wreq.get(url)
+      expected = JSON.parse(response.bytes)
+      actual = response.json
+
+      assert_equal payload, expected
+      assert_equal expected, actual
+      assert actual.fetch("integers").all? { |value| value.instance_of?(Integer) }
+      assert_instance_of Float, actual.fetch("fraction")
+      assert_instance_of Float, actual.fetch("exponent")
+    end
+  end
+
+  def test_request_json_preserves_large_integers_and_nested_values
+    payload = precision_payload
+
+    with_json_server do |url, requests|
+      response = Wreq.post(url, json: payload)
+      request = requests.pop
+
+      assert_equal "application/json", request.fetch(:headers).fetch("content-type")
+      assert_equal JSON.generate(payload), request.fetch(:body)
+      assert_equal payload, response.json
+    end
+  end
+
+  def test_request_json_nil_is_serialized_as_null
+    with_json_server do |url, requests|
+      response = Wreq.post(url, json: nil)
+      request = requests.pop
+
+      assert_equal "null", request.fetch(:body)
+      assert_nil response.json
+    end
+  end
+
+  def test_request_json_accepts_symbols_and_preserves_object_order
+    payload = {second: 2**100, first: :value}
+
+    with_json_server do |url, requests|
+      response = Wreq.post(url, json: payload)
+      request = requests.pop
+      actual = response.json
+
+      assert_equal JSON.generate(payload), request.fetch(:body)
+      assert_equal ["second", "first"], actual.keys
+      assert_equal({"second" => 2**100, "first" => "value"}, actual)
+    end
+  end
+
+  def test_request_json_enforces_documented_nesting_limit
+    accepted = 0
+    100.times { accepted = [accepted] }
+
+    with_json_server do |url, requests|
+      Wreq.post(url, json: accepted)
+
+      assert_equal JSON.generate(accepted), requests.pop.fetch(:body)
+    end
+
+    error = assert_raises(Wreq::BuilderError) do
+      Wreq.post("http://127.0.0.1:1/", json: [accepted])
+    end
+    assert_match(/nesting exceeds 100 levels/, error.message)
+  end
+
+  def test_unsupported_request_json_raises_before_socket_io
+    server = TCPServer.new("127.0.0.1", 0)
+    port = server.addr[1]
+
+    error = assert_raises(Wreq::BuilderError) do
+      Wreq.post("http://127.0.0.1:#{port}/", json: {"value" => Float::NAN})
+    end
+
+    cyclic = []
+    cyclic << cyclic
+    nesting_error = assert_raises(Wreq::BuilderError) do
+      Wreq.post("http://127.0.0.1:#{port}/", json: cyclic)
+    end
+
+    cyclic_hash = {}
+    cyclic_hash["self"] = cyclic_hash
+    hash_nesting_error = assert_raises(Wreq::BuilderError) do
+      Wreq.post("http://127.0.0.1:#{port}/", json: cyclic_hash)
+    end
+
+    key_error = assert_raises(Wreq::BuilderError) do
+      Wreq.post("http://127.0.0.1:#{port}/", json: {1 => "value"})
+    end
+
+    assert_match(/non-finite/, error.message)
+    assert_match(/nesting/, nesting_error.message)
+    assert_match(/nesting/, hash_nesting_error.message)
+    assert_match(/keys/, key_error.message)
+    assert_equal :wait_readable, server.accept_nonblock(exception: false)
+  ensure
+    server&.close unless server&.closed?
+  end
+
+  def test_invalid_response_json_raises_decoding_error
+    with_json_server(response_body: '{"id":') do |url, _requests|
+      response = Wreq.get(url)
+
+      assert_raises(Wreq::DecodingError) { response.json }
+    end
+  end
+
+  def test_fractional_and_large_exponent_numbers_match_json_parse
+    source = '{"fraction":0.12345678901234567890123456789,"exponent":1e400}'
+
+    with_json_server(response_body: source) do |url, _requests|
+      response = Wreq.get(url)
+      expected = JSON.parse(response.bytes)
+      actual = response.json
+
+      assert_equal expected, actual
+      assert_instance_of Float, actual.fetch("fraction")
+      assert_equal Float::INFINITY, actual.fetch("exponent")
+    end
+  end
+
+  private
+
+  def precision_payload
+    {
+      "integers" => INTEGER_BOUNDARIES,
+      "nested" => {
+        "array" => [2**100, {"negative" => -(2**100)}],
+        "object" => {"unsigned_64_max" => (2**64) - 1}
+      },
+      "shapes" => ["text", true, false, nil],
+      "fraction" => 1.25,
+      "exponent" => 1.0e40
+    }
+  end
+
+  def with_json_server(response_body: nil)
+    server = TCPServer.new("127.0.0.1", 0)
+    port = server.addr[1]
+    requests = Queue.new
+    thread = Thread.new do
+      socket = server.accept
+      begin
+        request_line = socket.gets
+        headers = read_headers(socket)
+        content_length = headers.fetch("content-length", "0").to_i
+        body = content_length.zero? ? "" : socket.read(content_length)
+        requests << {request_line: request_line, headers: headers, body: body}
+
+        response = response_body.nil? ? body : response_body
+        socket.write "HTTP/1.1 200 OK\r\n"
+        socket.write "Content-Type: application/json\r\n"
+        socket.write "Content-Length: #{response.bytesize}\r\n"
+        socket.write "Connection: close\r\n\r\n"
+        socket.write response
+      ensure
+        socket.close unless socket.closed?
+      end
+    rescue IOError, SystemCallError
+      nil
+    ensure
+      server.close unless server.closed?
+    end
+    thread.report_on_exception = false
+
+    yield "http://127.0.0.1:#{port}/", requests
+  ensure
+    server&.close unless server&.closed?
+    thread&.join(5)
+  end
+
+  def read_headers(socket)
+    headers = {}
+    while (line = socket.gets)
+      break if line == "\r\n"
+
+      name, value = line.split(":", 2)
+      headers[name.downcase] = value.strip
+    end
+    headers
+  end
+end

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/stream_test.rb

@@ -1,5 +1,6 @@
 require "test_helper"
 require "socket"
+require "timeout"
 
 class StreamTest < Minitest::Test
   def test_simple_push_stream
@@ -174,6 +175,41 @@ class StreamTest < Minitest::Test
     assert killed, "Connect+timeout phase should be interruptible"
   end
 
+  def test_thread_raise_propagates_ruby_interrupt
+    server = TCPServer.new("127.0.0.1", 0)
+    accepted = Queue.new
+    errors = Queue.new
+
+    server_thread = Thread.new do
+      socket = server.accept
+      accepted << true
+      sleep
+    ensure
+      socket&.close
+    end
+
+    request_thread = Thread.new do
+      Wreq.get("http://127.0.0.1:#{server.addr[1]}/", timeout: 60)
+    rescue Interrupt, StandardError => error
+      errors << error
+    end
+
+    Timeout.timeout(5) { accepted.pop }
+    request_thread.raise(Interrupt, "test interrupt")
+
+    assert request_thread.join(5), "Interrupted request thread should stop"
+
+    error = Timeout.timeout(1) { errors.pop }
+    assert_instance_of Interrupt, error
+    assert_equal "test interrupt", error.message
+  ensure
+    request_thread&.kill
+    request_thread&.join(1)
+    server_thread&.kill
+    server_thread&.join(1)
+    server&.close
+  end
+
   def test_thread_interrupt_body_reading
     url = "#{HTTPBIN_URL}/drip?duration=5&numbytes=5"
     thread = Thread.new do