wreq 1.2.2 → 1.2.3

data/test/request_test.rb

@@ -17,25 +17,25 @@ class WreqHttpbinTest < Minitest::Test
   end
 
   def test_module_get_method
-    response = Wreq.get("http://localhost:8080/get")
+    response = Wreq.get("#{HTTPBIN_URL}/get")
     assert_equal 200, response.code
     assert_respond_to response, :text
   end
 
   def test_module_post_with_json
     data = {name: "wreq-ruby", version: "0.1.0"}
-    response = Wreq.post("http://localhost:8080/post", json: data)
+    response = Wreq.post("#{HTTPBIN_URL}/post", json: data)
     assert_equal 200, response.code
   end
 
   def test_client_instance_basic
-    response = @client.get("http://localhost:8080/get")
+    response = @client.get("#{HTTPBIN_URL}/get")
     assert_equal 200, response.code
   end
 
   def test_client_with_custom_headers
     headers = {"User-Agent" => "wreq-ruby/test", "Accept" => "application/json"}
-    response = @client.get("http://localhost:8080/headers", headers: headers)
+    response = @client.get("#{HTTPBIN_URL}/headers", headers: headers)
     assert_equal 200, response.code
   end
 
@@ -51,14 +51,14 @@ class WreqHttpbinTest < Minitest::Test
     ]
 
     methods.each do |method|
-      response = @client.request(method, "http://localhost:8080/#{method}")
+      response = @client.request(method, "#{HTTPBIN_URL}/anything")
       assert [200, 405].include?(response.code), "client.#{method} failed with status #{response.code}"
     end
   end
 
   def test_request_with_query_params
     params = {"param1" => "value1", "param2" => "value2", "param3" => 123, "param4" => true}
-    response = Wreq.get("http://localhost:8080/get", query: params)
+    response = Wreq.get("#{HTTPBIN_URL}/get", query: params)
     assert_equal 200, response.code
     assert_includes response.text, "param1=value1"
     assert_includes response.text, "param2=value2"
@@ -68,7 +68,7 @@ class WreqHttpbinTest < Minitest::Test
 
   def test_post_with_form_data
     data = {"field1" => "value1", "field2" => "value2", "field3" => 456, "field4" => false}
-    response = Wreq.post("http://localhost:8080/post", form: data)
+    response = Wreq.post("#{HTTPBIN_URL}/post", form: data)
     assert_equal 200, response.code
     assert_includes response.text, "field1"
     assert_includes response.text, "value1"
@@ -83,33 +83,33 @@ class WreqHttpbinTest < Minitest::Test
   def test_post_with_raw_body
     body = "This is raw body content"
     headers = {"Content-Type" => "text/plain"}
-    response = Wreq.post("http://localhost:8080/post", body: body, headers: headers)
+    response = Wreq.post("#{HTTPBIN_URL}/post", body: body, headers: headers)
     assert_equal 200, response.code
     assert_includes response.text, body
   end
 
   def test_basic_authentication
-    response = Wreq.get("http://localhost:8080/basic-auth/user/pass", basic_auth: ["user", "pass"])
+    response = Wreq.get("#{HTTPBIN_URL}/basic-auth/user/pass", basic_auth: ["user", "pass"])
     assert_equal 200, response.code
   end
 
   def test_bearer_authentication
-    response = Wreq.get("http://localhost:8080/bearer", bearer_auth: "test-token")
+    response = Wreq.get("#{HTTPBIN_URL}/bearer", bearer_auth: "test-token")
     assert_equal 200, response.code
   end
 
   def test_redirect_following
-    response = Wreq.get("http://localhost:8080/redirect/2", allow_redirects: true)
+    response = Wreq.get("#{HTTPBIN_URL}/redirect/2", allow_redirects: true)
     assert_equal 200, response.code
   end
 
   def test_redirect_blocking
-    response = Wreq.get("http://localhost:8080/redirect/1", allow_redirects: false)
+    response = Wreq.get("#{HTTPBIN_URL}/redirect/1", allow_redirects: false)
     assert_equal 302, response.code
   end
 
   def test_response_status_methods
-    response = Wreq.get("http://localhost:8080/status/200")
+    response = Wreq.get("#{HTTPBIN_URL}/status/200")
     assert_equal 200, response.code
 
     if response.status.respond_to?(:success?)
@@ -118,7 +118,7 @@ class WreqHttpbinTest < Minitest::Test
   end
 
   def test_404_response
-    response = Wreq.get("http://localhost:8080/status/404")
+    response = Wreq.get("#{HTTPBIN_URL}/status/404")
     assert_equal 404, response.code
 
     if response.status.respond_to?(:client_error?)
@@ -127,7 +127,7 @@ class WreqHttpbinTest < Minitest::Test
   end
 
   def test_json_response_parsing
-    response = Wreq.get("http://localhost:8080/json")
+    response = Wreq.get("#{HTTPBIN_URL}/json")
     assert_equal 200, response.code
 
     if response.respond_to?(:json)
@@ -137,12 +137,12 @@ class WreqHttpbinTest < Minitest::Test
   end
 
   def test_gzip_compression
-    response = Wreq.get("http://localhost:8080/gzip", gzip: true)
+    response = Wreq.get("#{HTTPBIN_URL}/gzip", gzip: true)
     assert_equal 200, response.code
   end
 
   def test_headers_iteration
-    response = Wreq.get("http://localhost:8080/get")
+    response = Wreq.get("#{HTTPBIN_URL}/get")
 
     if response.respond_to?(:each_header)
       count = 0
@@ -157,7 +157,7 @@ class WreqHttpbinTest < Minitest::Test
   end
 
   def test_response_properties
-    response = Wreq.get("http://localhost:8080/get")
+    response = Wreq.get("#{HTTPBIN_URL}/get")
 
     assert_respond_to response, :code
     assert_respond_to response, :status
@@ -171,12 +171,12 @@ class WreqHttpbinTest < Minitest::Test
   def test_timeout_functionality
     # Test that short timeouts properly raise exceptions
     assert_raises(Wreq::TimeoutError) do
-      Wreq.get("http://localhost:8080/delay/10", timeout: 1)
+      Wreq.get("#{HTTPBIN_URL}/delay/10", timeout: 1)
     end
 
     # Test that reasonable timeouts work normally
     start_time = Time.now
-    response = Wreq.get("http://localhost:8080/delay/1", timeout: 5)
+    response = Wreq.get("#{HTTPBIN_URL}/delay/1", timeout: 5)
     elapsed = Time.now - start_time
 
     assert_equal 200, response.code
@@ -187,7 +187,7 @@ class WreqHttpbinTest < Minitest::Test
     start_time = Time.now
 
     3.times do |i|
-      response = Wreq.get("http://localhost:8080/get?request=#{i}")
+      response = Wreq.get("#{HTTPBIN_URL}/get?request=#{i}")
       assert_equal 200, response.code
     end
 
@@ -212,7 +212,7 @@ class WreqHttpbinTest < Minitest::Test
     assert_instance_of Wreq::Client, client
 
     # Test that it can make requests
-    response = client.get("http://localhost:8080/get")
+    response = client.get("#{HTTPBIN_URL}/get")
     assert_equal 200, response.code
   end
 

data/test/response_test.rb

@@ -2,7 +2,7 @@ require "test_helper"
 
 class ResponseTest < Minitest::Test
   def setup
-    @response = Wreq.get("http://localhost:8080/json")
+    @response = Wreq.get("#{HTTPBIN_URL}/json")
   end
 
   def test_response_code
@@ -39,7 +39,7 @@ class ResponseTest < Minitest::Test
   end
 
   def test_response_with_non_json_content
-    response = Wreq.get("http://localhost:8080/html")
+    response = Wreq.get("#{HTTPBIN_URL}/html")
     assert_equal 200, response.code
     assert_instance_of String, response.text
     assert response.text.include?("<html>")
@@ -51,19 +51,19 @@ class ResponseTest < Minitest::Test
   def test_response_status_codes
     # Test different status codes
     [200, 404, 500].each do |status|
-      response = Wreq.get("http://localhost:8080/status/#{status}")
+      response = Wreq.get("#{HTTPBIN_URL}/status/#{status}")
       assert_equal status, response.code
     end
   end
 
   def test_response_with_query_parameters
-    response = Wreq.get("http://localhost:8080/get",
+    response = Wreq.get("#{HTTPBIN_URL}/get",
       query: {"param1" => "value1", "param2" => "value2"})
     assert_equal 200, response.code
 
     json_data = response.json
     args = json_data["args"]
-    assert_equal "value1", args["param1"]
-    assert_equal "value2", args["param2"]
+    assert_equal "value1", httpbin_fetch(args, "param1")
+    assert_equal "value2", httpbin_fetch(args, "param2")
   end
 end

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,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: wreq
 version: !ruby/object:Gem::Version
-  version: 1.2.2
+  version: 1.2.3
 platform: ruby
 authors:
 - SearchApi
@@ -27,6 +27,7 @@ files:
 - README.md
 - Rakefile
 - build.rs
+- docs/windows-gnu-tokio-crash.md
 - examples/body.rb
 - examples/client.rb
 - examples/cookie.rb
@@ -47,6 +48,8 @@ files:
 - lib/wreq_ruby/http.rb
 - lib/wreq_ruby/response.rb
 - script/build_platform_gem.rb
+- script/build_windows_gnu.ps1
+- src/arch.rs
 - src/client.rs
 - src/client/body.rs
 - src/client/body/form.rs