wreq 1.2.4-aarch64-linux → 1.2.6-aarch64-linux

data/lib/wreq_ruby/response.rb

@@ -64,6 +64,19 @@ unless defined?(Wreq)
       def content_length
       end
 
+      # Get the response headers.
+      #
+      # Header names are case-insensitive. Use {Wreq::Headers#get_all} to get
+      # every value when a header appears more than once. Each call returns a
+      # fresh, mutable snapshot. Changing that snapshot does not change the
+      # response or a later snapshot, and object identity is not guaranteed.
+      #
+      # @return [Wreq::Headers] Response headers
+      # @example
+      #   response.headers.get("content-type")  # => "application/json"
+      def headers
+      end
+
       # Get the local socket address.
       #
       # @return [String, nil] Local address (e.g., "127.0.0.1:54321"), or nil
@@ -80,6 +93,18 @@ unless defined?(Wreq)
       def remote_addr
       end
 
+      # Get cookies parsed from the response's `Set-Cookie` headers.
+      #
+      # Invalid `Set-Cookie` values are skipped.
+      #
+      # @return [Array<Wreq::Cookie>] Parsed response cookies
+      # @example
+      #   response.cookies.each do |cookie|
+      #     puts "#{cookie.name}=#{cookie.value}"
+      #   end
+      def cookies
+      end
+
       # Get the response bytes as a binary string.
       # @return [String] Response body as binary data
       # @example
@@ -91,17 +116,20 @@ unless defined?(Wreq)
       # Get the response body as text with a specific charset.
       # This method allows you to specify a default encoding
       # to use when decoding the response body.
-      # # @param default_encoding [String] Default encoding to use (e.g., "UTF-8")
-      # # @return [String] Response body decoded as text using the specified encoding
+      # @param default_encoding [String] Default encoding to use (e.g., "UTF-8")
+      # @return [String] Response body decoded as text using the specified encoding
       # @example
       #   html = response.text("ISO-8859-1")
       #   puts html
       # @raise [Wreq::DecodingError] if body cannot be decoded with the specified encoding
-      def text(default_encoding: "UTF-8")
+      def text(default_encoding = "UTF-8")
       end
 
       # Parse the response body as JSON.
       #
+      # Integral JSON numbers are returned as arbitrary-precision Ruby Integer
+      # values. Fractional and exponent-form numbers are returned as Float values.
+      #
       # @return [Object] Parsed JSON (Hash, Array, String, Integer, Float, Boolean, nil)
       # @raise [Wreq::DecodingError] if body is not valid JSON
       # @example

data/script/build_windows_gnu.ps1

@@ -32,7 +32,12 @@ function Invoke-Step {
     )
 
     Write-Host "==> $Name"
+    # Native command failures do not honor ErrorActionPreference in Windows PowerShell.
+    $global:LASTEXITCODE = 0
     & $Command
+    if ($LASTEXITCODE -ne 0) {
+        throw "$Name failed with exit code $LASTEXITCODE."
+    }
 }
 
 function Get-MissingUcrtTools {
@@ -122,6 +127,7 @@ Invoke-Step "Check MSYS2 UCRT build tools" {
         $stillMissing = @(Get-MissingUcrtTools)
         if ($stillMissing.Count -eq 0) {
             Write-Warning "pacman returned exit code $LASTEXITCODE, but all required tools are present; continuing."
+            $global:LASTEXITCODE = 0
             return
         }
 

data/test/body_sender_test.rb

@@ -0,0 +1,246 @@
+require "test_helper"
+require "open3"
+require "rbconfig"
+require "socket"
+
+class BodySenderTest < Minitest::Test
+  def test_valid_capacity_creates_open_sender
+    sender = Wreq::BodySender.new(2)
+
+    refute_predicate sender, :closed?
+  ensure
+    sender&.close
+  end
+
+  def test_omitted_capacity_defaults_to_eight
+    sender = Wreq::BodySender.new
+    progress = Queue.new
+    producer = Thread.new do
+      9.times do |index|
+        sender.push(index.to_s)
+        progress << index
+      end
+      sender.close
+    end
+    producer.report_on_exception = false
+
+    assert wait_until { progress.size >= 8 }, "the default channel should buffer eight chunks"
+    assert_equal 8, progress.size
+    assert_predicate producer, :alive?, "the ninth push should wait for channel capacity"
+
+    with_request_body_server do |url, request_thread|
+      response = Wreq.post(url, body: sender)
+
+      assert_equal 200, response.code
+      assert producer.join(5), "the ninth push should finish once the request drains"
+      assert_equal "012345678", request_thread.value
+    end
+  ensure
+    producer&.kill if producer&.alive?
+    producer&.join(5)
+    sender&.close
+  end
+
+  def test_non_positive_and_excessive_capacities_raise_argument_error
+    [0, -1, 2**256].each do |capacity|
+      error = assert_raises(ArgumentError) { Wreq::BodySender.new(capacity) }
+      assert_match(/capacity/, error.message)
+    end
+  end
+
+  def test_non_integer_capacities_raise_type_error
+    [1.0, "not an integer"].each do |capacity|
+      error = assert_raises(TypeError) { Wreq::BodySender.new(capacity) }
+      assert_match(/capacity/, error.message)
+    end
+  end
+
+  def test_too_many_constructor_arguments_raise_argument_error
+    assert_raises(ArgumentError) { Wreq::BodySender.new(1, 2) }
+  end
+
+  def test_close_is_idempotent_and_updates_closed_state
+    sender = Wreq::BodySender.new
+
+    refute_predicate sender, :closed?
+    assert_nil sender.close
+    assert_predicate sender, :closed?
+    assert_nil sender.close
+  end
+
+  def test_push_after_close_raises_io_error
+    sender = Wreq::BodySender.new
+    sender.close
+
+    error = assert_raises(IOError) { sender.push("data") }
+    assert_equal "closed body sender", error.message
+  end
+
+  def test_queued_chunks_survive_close_before_request_attachment
+    sender = Wreq::BodySender.new(2)
+    sender.push("queued-")
+    sender.push("body")
+    sender.close
+
+    with_request_body_server do |url, request_thread|
+      response = Wreq.post(url, body: sender)
+
+      assert_equal 200, response.code
+      assert_equal "queued-body", request_thread.value
+    end
+  end
+
+  def test_valid_capacity_keeps_backpressure_until_request_drains
+    sender = Wreq::BodySender.new(1)
+    sender.push("first-")
+    producer = Thread.new do
+      sender.push("second")
+      sender.close
+    end
+    producer.report_on_exception = false
+
+    sleep 0.05
+    assert_predicate producer, :alive?, "the second push should wait for channel capacity"
+
+    with_request_body_server do |url, request_thread|
+      response = Wreq.post(url, body: sender)
+
+      assert_equal 200, response.code
+      assert producer.join(5), "the blocked producer should finish once the request drains"
+      assert_equal "first-second", request_thread.value
+    end
+  ensure
+    producer&.kill if producer&.alive?
+    producer&.join(5)
+    sender&.close
+  end
+
+  def test_receiver_termination_closes_sender
+    sender = Wreq::BodySender.new(1)
+    sender.push("data")
+
+    with_reset_server do |url|
+      assert_raises(StandardError) { Wreq.post(url, body: sender, timeout: 2) }
+    end
+
+    assert wait_until { sender.closed? }, "sender should close after the request drops its receiver"
+    assert_raises(IOError) { sender.push("more") }
+  ensure
+    sender&.close
+  end
+
+  def test_zero_capacity_regression_exits_subprocess_normally
+    lib_dir = File.expand_path("../lib", __dir__)
+    script = <<~RUBY
+      require "wreq"
+
+      begin
+        Wreq::BodySender.new(0)
+      rescue ArgumentError => error
+        warn "\#{error.class}: \#{error.message}"
+        exit 0
+      end
+
+      warn "zero capacity did not raise"
+      exit 2
+    RUBY
+
+    _stdout, stderr, status = Open3.capture3(RbConfig.ruby, "-I", lib_dir, "-e", script)
+
+    assert status.success?, "subprocess failed with #{status.inspect}: #{stderr}"
+    assert_match(/ArgumentError:.*capacity/, stderr)
+    refute_match(/panicked|mpsc bounded channel/i, stderr)
+  end
+
+  private
+
+  def wait_until(timeout: 2)
+    deadline = Process.clock_gettime(Process::CLOCK_MONOTONIC) + timeout
+    loop do
+      return true if yield
+      return false if Process.clock_gettime(Process::CLOCK_MONOTONIC) >= deadline
+
+      sleep 0.01
+    end
+  end
+
+  def with_request_body_server
+    server = TCPServer.new("127.0.0.1", 0)
+    port = server.addr[1]
+    request_thread = Thread.new do
+      socket = server.accept
+      begin
+        socket.gets
+        headers = read_headers(socket)
+        body = read_request_body(socket, headers)
+        socket.write "HTTP/1.1 200 OK\r\n"
+        socket.write "Content-Length: 0\r\n"
+        socket.write "Connection: close\r\n\r\n"
+        body
+      ensure
+        socket.close unless socket.closed?
+      end
+    ensure
+      server.close unless server.closed?
+    end
+    request_thread.report_on_exception = false
+
+    yield "http://127.0.0.1:#{port}/", request_thread
+  ensure
+    server&.close unless server&.closed?
+    request_thread&.join(5)
+  end
+
+  def with_reset_server
+    server = TCPServer.new("127.0.0.1", 0)
+    port = server.addr[1]
+    thread = Thread.new do
+      socket = server.accept
+      socket.close
+    ensure
+      server.close unless server.closed?
+    end
+    thread.report_on_exception = false
+
+    yield "http://127.0.0.1:#{port}/"
+  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
+
+  def read_request_body(socket, headers)
+    if headers.fetch("transfer-encoding", "").downcase.include?("chunked")
+      read_chunked_body(socket)
+    else
+      socket.read(headers.fetch("content-length", "0").to_i)
+    end
+  end
+
+  def read_chunked_body(socket)
+    body = "".b
+    loop do
+      size_line = socket.gets or raise EOFError, "missing chunk size"
+      size = Integer(size_line.split(";", 2).first, 16)
+      break if size.zero?
+
+      body << socket.read(size)
+      raise IOError, "missing chunk terminator" unless socket.read(2) == "\r\n"
+    end
+
+    while (line = socket.gets)
+      break if line == "\r\n"
+    end
+    body
+  end
+end

data/test/cookie_test.rb

@@ -1,6 +1,9 @@
 # frozen_string_literal: true
 
 require "test_helper"
+require "bigdecimal"
+require "open3"
+require "rbconfig"
 
 class CookieTest < Minitest::Test
   def setup
@@ -41,6 +44,14 @@ class CookieTest < Minitest::Test
     assert_equal true, (c.secure || c.secure?)
   end
 
+  def test_add_rejects_invalid_cookie_type
+    error = assert_raises(TypeError) do
+      @jar.add(Object.new, @base_url)
+    end
+
+    assert_equal "cookie must be a Wreq::Cookie or String", error.message
+  end
+
   def test_add_multiple_and_remove
     @jar.add("a=1; Path=/", @base_url)
     @jar.add("b=2; Path=/", @base_url)
@@ -84,7 +95,9 @@ class CookieTest < Minitest::Test
     @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
+    # expires_at returns Time. expires remains available for numeric callers.
+    assert_kind_of Time, c2.expires_at
+    assert_predicate c2.expires_at, :utc?
     if (e = c2.expires)
       assert_kind_of Float, e
       assert_operator e, :>, Time.now.to_f - 1_000_000 # sanity bound
@@ -104,15 +117,18 @@ class CookieTest < Minitest::Test
     assert_nil c.domain
     assert_nil c.max_age
     assert_nil c.expires
+    assert_nil c.expires_at
 
     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?
+    assert_nil c.same_site
+    assert_equal "sid=abc", c.to_s
   end
 
   def test_cookie_new_full_attributes
-    exp = Time.now.to_f + 7200.0
+    exp = Time.utc(2030, 1, 1, 0, 0, Rational(123_456_789, 1_000_000_000))
     c = Wreq::Cookie.new("sess", "v",
       domain: "example.com",
       path: "/",
@@ -130,16 +146,199 @@ class CookieTest < Minitest::Test
     # 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 exp, c.expires_at
+    assert_predicate c.expires_at, :utc?
+    assert_in_delta exp.to_f, c.expires, 1e-6
 
     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?
+    assert_equal Wreq::SameSite::Lax, c.same_site
+  end
+
+  def test_same_site_reader_distinguishes_none_from_unset
+    cookie = Wreq::Cookie.new("same-site", "value", same_site: Wreq::SameSite::None)
+
+    assert_equal Wreq::SameSite::None, cookie.same_site
+    refute cookie.same_site_lax?
+    refute cookie.same_site_strict?
+  end
+
+  def test_cookie_new_uses_shared_keyword_validation
+    cookie = Wreq::Cookie.new("sid", "abc", **{"path" => "/"})
+    assert_equal "/", cookie.path
+
+    secret = "must-not-appear"
+    unknown_error = assert_raises(ArgumentError) do
+      Wreq::Cookie.new("sid", "abc", domian: secret)
+    end
+    assert_includes unknown_error.message, ":domian"
+    refute_includes unknown_error.message, secret
+
+    duplicate_options = {path: "/one"}
+    duplicate_options["path"] = "/two"
+    duplicate_error = assert_raises(ArgumentError) do
+      Wreq::Cookie.new("sid", "abc", **duplicate_options)
+    end
+    assert_includes duplicate_error.message, "duplicate option: :path"
+  end
+
+  def test_expires_accepts_past_time
+    expiration = Time.at(Rational(-5, 4)).utc
+    cookie = Wreq::Cookie.new("past", "value", expires: expiration)
+
+    assert_equal expiration, cookie.expires_at
+    assert_in_delta(-1.25, cookie.expires, 1e-9)
+  end
+
+  def test_expires_accepts_integer_and_fractional_timestamps
+    [
+      1_893_456_000,
+      1_893_456_000.125,
+      Rational(-5, 4),
+      BigDecimal("1893456000.125")
+    ].each do |timestamp|
+      cookie = Wreq::Cookie.new("timestamp", "value", expires: timestamp)
+
+      assert_kind_of Time, cookie.expires_at
+      assert_predicate cookie.expires_at, :utc?
+      assert_in_delta timestamp.to_f, cookie.expires_at.to_f, 1e-6
+      assert_in_delta timestamp.to_f, cookie.expires, 1e-6
+    end
+  end
+
+  def test_expires_normalizes_time_to_utc_without_losing_precision
+    expiration = Time.new(
+      2030,
+      1,
+      1,
+      12,
+      34,
+      Rational(123_456_789, 1_000_000_000),
+      "+09:00"
+    )
+    actual = Wreq::Cookie.new("offset", "value", expires: expiration).expires_at
+
+    assert_predicate actual, :utc?
+    assert_equal expiration.to_r, actual.to_r
+  end
+
+  def test_expires_rejects_non_finite_timestamps
+    [Float::NAN, Float::INFINITY, -Float::INFINITY].each do |timestamp|
+      error = assert_raises(ArgumentError) do
+        Wreq::Cookie.new("invalid", "value", expires: timestamp)
+      end
+
+      assert_match(/expires.*finite/, error.message)
+    end
+  end
+
+  def test_expires_rejects_unrepresentable_times
+    expirations = [
+      -(2**63),
+      2**63 - 1,
+      -Float::MAX,
+      Float::MAX,
+      Time.utc(10_000, 1, 1)
+    ]
+
+    expirations.each do |expiration|
+      error = assert_raises(RangeError) do
+        Wreq::Cookie.new("invalid", "value", expires: expiration)
+      end
+
+      assert_match(/expires.*supported range/, error.message)
+    end
+  end
+
+  def test_max_age_accepts_signed_boundaries_without_wrapping
+    [-(2**63), -1, 0, 2**63 - 1].each do |max_age|
+      cookie = Wreq::Cookie.new("max-age", "value", max_age: max_age)
+
+      assert_equal max_age, cookie.max_age
+    end
+
+    [-(2**63) - 1, 2**63].each do |max_age|
+      assert_raises(RangeError) do
+        Wreq::Cookie.new("max-age", "value", max_age: max_age)
+      end
+    end
+  end
+
+  def test_non_positive_max_age_removes_cookie_from_jar
+    [-1, 0].each do |max_age|
+      jar = Wreq::Jar.new
+      jar.add("session=old; Path=/", @base_url)
+      deletion = Wreq::Cookie.new("session", "gone", path: "/", max_age: max_age)
+
+      jar.add(deletion, @base_url)
+
+      assert_equal max_age, deletion.max_age
+      assert_empty jar.get_all
+    end
+  end
+
+  def test_past_expiration_removes_cookie_from_jar
+    @jar.add("session=old; Path=/", @base_url)
+    deletion = Wreq::Cookie.new(
+      "session",
+      "gone",
+      path: "/",
+      expires: Time.at(-1).utc
+    )
+
+    @jar.add(deletion, @base_url)
+
+    assert_empty @jar.get_all
+  end
+
+  def test_expiration_regressions_exit_subprocess_normally
+    lib_dir = File.expand_path("../lib", __dir__)
+    script = <<~RUBY
+      require "wreq"
+
+      past = Wreq::Cookie.new("past", "value", expires: -1.0)
+      abort "past timestamp was not retained" unless past.expires_at == Time.at(-1).utc
+
+      [Float::NAN, Float::INFINITY, -Float::INFINITY].each do |timestamp|
+        begin
+          Wreq::Cookie.new("invalid", "value", expires: timestamp)
+        rescue ArgumentError
+          next
+        end
+
+        abort "non-finite timestamp did not raise ArgumentError"
+      end
+
+      [Float::MAX, -Float::MAX].each do |timestamp|
+        begin
+          Wreq::Cookie.new("invalid", "value", expires: timestamp)
+        rescue RangeError
+          next
+        end
+
+        abort "unrepresentable finite timestamp did not raise RangeError"
+      end
+
+      [-(2**63) - 1, 2**63].each do |max_age|
+        begin
+          Wreq::Cookie.new("invalid", "value", max_age: max_age)
+        rescue RangeError
+          next
+        end
+
+        abort "out-of-range Max-Age did not raise RangeError"
+      end
+
+      puts "ok"
+    RUBY
+
+    stdout, stderr, status = Open3.capture3(RbConfig.ruby, "-I", lib_dir, "-e", script)
+
+    assert status.success?, "subprocess failed with #{status.inspect}: #{stderr}"
+    assert_equal "ok\n", stdout
+    refute_match(/panicked|fatal|access violation|cannot convert float seconds to Duration/i, stderr)
   end
 
   def test_same_site_flags_from_parsed_header
@@ -148,10 +347,12 @@ class CookieTest < Minitest::Test
     @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?]] }
+    h = cookies.to_h do |cookie|
+      [cookie.name, [cookie.same_site, cookie.same_site_strict?, cookie.same_site_lax?]]
+    end
 
-    assert_equal [true, false], h["s1"]
-    assert_equal [false, true], h["s2"]
+    assert_equal [Wreq::SameSite::Strict, true, false], h["s1"]
+    assert_equal [Wreq::SameSite::Lax, false, true], h["s2"]
   end
 
   def test_request_uncompressed_cookies