wreq 1.2.2-x86_64-linux → 1.2.4-x86_64-linux

data/test/stream_test.rb

@@ -1,4 +1,5 @@
 require "test_helper"
+require "socket"
 
 class StreamTest < Minitest::Test
   def test_simple_push_stream
@@ -9,7 +10,7 @@ class StreamTest < Minitest::Test
       sender.close
     end
 
-    resp = client.post("http://localhost:8080/post", body: sender, headers: {"Content-Type" => "text/plain"})
+    resp = client.post("#{HTTPBIN_URL}/post", body: sender, headers: {"Content-Type" => "text/plain"})
 
     assert_equal 200, resp.code
 
@@ -23,7 +24,7 @@ class StreamTest < Minitest::Test
 
   def test_response_body_chunks_stream
     client = Wreq::Client.new
-    resp = client.get("http://localhost:8080/stream/5")
+    resp = client.get("#{HTTPBIN_URL}/stream/5")
     chunks = []
 
     resp.chunks do |chunk|
@@ -37,7 +38,7 @@ class StreamTest < Minitest::Test
 
   def test_chunks_yields_binary_encoding
     client = Wreq::Client.new
-    resp = client.get("http://localhost:8080/stream/3")
+    resp = client.get("#{HTTPBIN_URL}/stream/3")
 
     resp.chunks do |chunk|
       assert chunk.encoding == Encoding::BINARY || chunk.encoding == Encoding::ASCII_8BIT,
@@ -47,7 +48,7 @@ class StreamTest < Minitest::Test
 
   def test_chunks_with_single_chunk_body
     client = Wreq::Client.new
-    resp = client.get("http://localhost:8080/bytes/1024")
+    resp = client.get("#{HTTPBIN_URL}/bytes/1024")
     chunk_count = 0
     total_bytes = 0
 
@@ -62,7 +63,7 @@ class StreamTest < Minitest::Test
 
   def test_chunks_returns_nil
     client = Wreq::Client.new
-    resp = client.get("http://localhost:8080/stream/3")
+    resp = client.get("#{HTTPBIN_URL}/stream/3")
 
     result = resp.chunks { |_chunk| :processing }
 
@@ -71,7 +72,7 @@ class StreamTest < Minitest::Test
 
   def test_chunks_with_empty_body
     client = Wreq::Client.new
-    resp = client.get("http://localhost:8080/status/204")
+    resp = client.get("#{HTTPBIN_URL}/status/204")
     chunk_count = 0
 
     resp.chunks do |_chunk|
@@ -83,7 +84,7 @@ class StreamTest < Minitest::Test
 
   def test_chunks_without_block_raises_error
     client = Wreq::Client.new
-    resp = client.get("http://localhost:8080/stream/3")
+    resp = client.get("#{HTTPBIN_URL}/stream/3")
 
     assert_raises(LocalJumpError) do
       resp.chunks
@@ -92,7 +93,7 @@ class StreamTest < Minitest::Test
 
   def test_other_threads_run_during_streaming
     client = Wreq::Client.new
-    resp = client.get("http://localhost:8080/drip?duration=3&numbytes=3&delay=1")
+    resp = client.get("#{HTTPBIN_URL}/drip?duration=3&numbytes=3&delay=1")
 
     counter = 0
     tick_thread = Thread.new do
@@ -121,7 +122,7 @@ class StreamTest < Minitest::Test
     done = {}
 
     t1 = Thread.new do
-      resp = client.get("http://localhost:8080/stream/3")
+      resp = client.get("#{HTTPBIN_URL}/stream/3")
       chunks = []
       resp.chunks { |chunk| chunks << chunk }
       results[:t1] = chunks.size
@@ -129,7 +130,7 @@ class StreamTest < Minitest::Test
     end
 
     t2 = Thread.new do
-      resp = client.get("http://localhost:8080/stream/3")
+      resp = client.get("#{HTTPBIN_URL}/stream/3")
       chunks = []
       resp.chunks { |chunk| chunks << chunk }
       results[:t2] = chunks.size
@@ -174,7 +175,7 @@ class StreamTest < Minitest::Test
   end
 
   def test_thread_interrupt_body_reading
-    url = "http://localhost:8080/drip?duration=5&numbytes=5"
+    url = "#{HTTPBIN_URL}/drip?duration=5&numbytes=5"
     thread = Thread.new do
       resp = Wreq.get(url)
       resp.text
@@ -189,7 +190,7 @@ class StreamTest < Minitest::Test
   end
 
   def test_thread_interrupt_body_streaming
-    url = "http://localhost:8080/drip?duration=5&numbytes=5"
+    url = "#{HTTPBIN_URL}/drip?duration=5&numbytes=5"
     thread = Thread.new do
       resp = Wreq.get(url)
       resp.chunks { |chunk| chunk }
@@ -204,7 +205,7 @@ class StreamTest < Minitest::Test
   end
 
   def test_thread_interrupt_during_slow_stream_with_block_processing
-    url = "http://localhost:8080/drip?duration=5&numbytes=5&delay=1"
+    url = "#{HTTPBIN_URL}/drip?duration=5&numbytes=5&delay=1"
     thread = Thread.new do
       resp = Wreq.get(url)
       resp.chunks do |_chunk|
@@ -222,26 +223,21 @@ class StreamTest < Minitest::Test
 
   def test_chunks_propagates_streaming_errors
     client = Wreq::Client.new
-    resp = client.get("http://localhost:8080/drip?duration=10&numbytes=10", timeout: 1)
-    error_raised = false
 
-    begin
-      resp.chunks do |_chunk|
+    with_truncated_chunked_response do |url|
+      resp = client.get(url)
+      error = assert_raises(Wreq::BodyError, Wreq::ConnectionResetError, Wreq::DecodingError) do
+        resp.chunks do |_chunk|
+        end
       end
-    rescue => e
-      error_raised = true
-      assert(
-        e.is_a?(Wreq::TimeoutError) || e.is_a?(Wreq::BodyError) || e.is_a?(Wreq::ConnectionResetError),
-        "Expected a streaming error (TimeoutError/BodyError/ConnectionResetError), got #{e.class}: #{e.message}"
-      )
-    end
 
-    assert error_raised, "A streaming error should have been raised for a timed-out drip response"
+      assert_match(/body|connection|decode|incomplete|closed|unexpected/i, error.message)
+    end
   end
 
   def test_exception_in_block_propagates
     client = Wreq::Client.new
-    resp = client.get("http://localhost:8080/stream/5")
+    resp = client.get("#{HTTPBIN_URL}/stream/5")
     error_raised = false
     chunks_before_error = 0
 
@@ -261,7 +257,7 @@ class StreamTest < Minitest::Test
 
   def test_chunks_called_twice_raises_error
     client = Wreq::Client.new
-    resp = client.get("http://localhost:8080/stream/3")
+    resp = client.get("#{HTTPBIN_URL}/stream/3")
     resp.chunks { |_chunk| }
     error_raised = false
 
@@ -278,7 +274,7 @@ class StreamTest < Minitest::Test
 
   def test_text_after_chunks_raises_error
     client = Wreq::Client.new
-    resp = client.get("http://localhost:8080/stream/3")
+    resp = client.get("#{HTTPBIN_URL}/stream/3")
     resp.chunks { |_chunk| }
     error_raised = false
 
@@ -295,10 +291,10 @@ class StreamTest < Minitest::Test
 
   def test_chunks_content_matches_full_body
     client = Wreq::Client.new
-    resp_full = client.get("http://localhost:8080/bytes/4096")
+    resp_full = client.get("#{HTTPBIN_URL}/bytes/4096")
     full_bytes = resp_full.bytes
 
-    resp_stream = client.get("http://localhost:8080/bytes/4096")
+    resp_stream = client.get("#{HTTPBIN_URL}/bytes/4096")
     streamed_bytes = "".b
     resp_stream.chunks do |chunk|
       streamed_bytes << chunk
@@ -310,7 +306,7 @@ class StreamTest < Minitest::Test
 
   def test_chunks_json_stream_content
     client = Wreq::Client.new
-    resp = client.get("http://localhost:8080/stream/5")
+    resp = client.get("#{HTTPBIN_URL}/stream/5")
     chunks = []
 
     resp.chunks do |chunk|
@@ -325,7 +321,7 @@ class StreamTest < Minitest::Test
 
   def test_block_not_garbage_collected_during_streaming
     client = Wreq::Client.new
-    resp = client.get("http://localhost:8080/drip?duration=3&numbytes=3&delay=1")
+    resp = client.get("#{HTTPBIN_URL}/stream/3")
     chunks_received = 0
 
     resp.chunks do |_chunk|
@@ -340,14 +336,14 @@ class StreamTest < Minitest::Test
 
   def test_close_after_streaming
     client = Wreq::Client.new
-    resp = client.get("http://localhost:8080/stream/3")
+    resp = client.get("#{HTTPBIN_URL}/stream/3")
 
     resp.chunks { |_chunk| }
     resp.close
   end
 
   def test_chunks_via_module_method
-    resp = Wreq.get("http://localhost:8080/stream/3")
+    resp = Wreq.get("#{HTTPBIN_URL}/stream/3")
     chunks = []
 
     resp.chunks do |chunk|
@@ -359,7 +355,7 @@ class StreamTest < Minitest::Test
 
   def test_chunks_via_client_instance
     client = Wreq::Client.new
-    resp = client.get("http://localhost:8080/stream/3")
+    resp = client.get("#{HTTPBIN_URL}/stream/3")
     chunks = []
 
     resp.chunks do |chunk|
@@ -368,4 +364,34 @@ class StreamTest < Minitest::Test
 
     assert_equal 3, chunks.size, "Client instance get + chunks should work"
   end
+
+  private
+
+  def with_truncated_chunked_response
+    server = TCPServer.new("127.0.0.1", 0)
+    port = server.addr[1]
+    thread = Thread.new do
+      socket = server.accept
+      begin
+        socket.readpartial(4096) if IO.select([socket], nil, nil, 5)
+        socket.write "HTTP/1.1 200 OK\r\n"
+        socket.write "Content-Type: text/plain\r\n"
+        socket.write "Transfer-Encoding: chunked\r\n"
+        socket.write "\r\n"
+        socket.write "5\r\nhello\r\n"
+        socket.write "A\r\nshort"
+      ensure
+        socket.close unless socket.closed?
+      end
+    rescue IOError, SystemCallError
+    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
 end

data/test/test_helper.rb

@@ -1,9 +1,52 @@
 # frozen_string_literal: true
 
-#
-# Run httpbin server: `docker run -d -p 8080:80 --name httpbin kennethreitz/httpbin`
-
 $LOAD_PATH.unshift File.expand_path("../lib", __dir__)
 require "wreq"
 
+HTTPBIN_URL = ENV.fetch("HTTPBIN_URL", "https://httpbin.io").delete_suffix("/")
+MINITEST_RETRY_COUNT = Integer(ENV.fetch("MINITEST_RETRY_COUNT", "3"))
+MINITEST_RETRY_DISPLAY_FAILURE_MESSAGES =
+  ENV.fetch("MINITEST_RETRY_DISPLAY_FAILURE_MESSAGES", "true") != "false"
+MINITEST_RETRY_SLEEP_INTERVAL = Float(ENV.fetch("MINITEST_RETRY_SLEEP_INTERVAL", "1"))
+
 require "minitest/autorun"
+require "minitest/retry"
+
+# httpbin.io is a shared external service, so the integration tests can see
+# occasional network failures even when the client behavior is correct.
+Minitest::Retry.use!(
+  retry_count: MINITEST_RETRY_COUNT,
+  verbose: false,
+  io: $stderr
+)
+
+Minitest::Retry.on_retry do |klass, test_name, attempt, result|
+  $stderr.puts "[MinitestRetry] retry #{klass}##{test_name} (#{attempt}/#{MINITEST_RETRY_COUNT})"
+
+  if MINITEST_RETRY_DISPLAY_FAILURE_MESSAGES
+    result.failures.each do |failure|
+      message = failure.message.to_s.strip
+      $stderr.puts message unless message.empty?
+    end
+  end
+
+  sleep MINITEST_RETRY_SLEEP_INTERVAL if MINITEST_RETRY_SLEEP_INTERVAL.positive?
+end
+
+module HttpbinHelpers
+  def httpbin_value(value)
+    (value.is_a?(Array) && value.length == 1) ? value.first : value
+  end
+
+  def httpbin_fetch(hash, key)
+    httpbin_value(hash.fetch(key))
+  end
+
+  def httpbin_cookies(json)
+    json.fetch("cookies", json)
+  end
+end
+
+class Minitest::Test
+  include HttpbinHelpers
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: wreq
 version: !ruby/object:Gem::Version
-  version: 1.2.2
+  version: 1.2.4
 platform: x86_64-linux
 authors:
 - SearchApi
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2026-06-11 00:00:00.000000000 Z
+date: 2026-07-09 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
@@ -24,6 +24,7 @@ files:
 - LICENSE
 - README.md
 - Rakefile
+- docs/windows-gnu-tokio-crash.md
 - examples/body.rb
 - examples/client.rb
 - examples/cookie.rb
@@ -46,6 +47,7 @@ files:
 - lib/wreq_ruby/http.rb
 - lib/wreq_ruby/response.rb
 - script/build_platform_gem.rb
+- script/build_windows_gnu.ps1
 - test/client_cookie_test.rb
 - test/client_test.rb
 - test/cookie_test.rb