wreq 1.1.0 → 1.2.0

data/test/cookie_test.rb

@@ -19,9 +19,9 @@ class CookieTest < Minitest::Test
     assert_equal 0, cookies.length
   end
 
-  def test_add_cookie_str_and_get_all
+  def test_add_and_get_all
     set_cookie = "sid=abc123; Path=/; Domain=example.com; HttpOnly; Secure"
-    @jar.add_cookie_str(set_cookie, @base_url)
+    @jar.add(set_cookie, @base_url)
 
     cookies = @jar.get_all
     assert_kind_of Array, cookies
@@ -42,9 +42,9 @@ class CookieTest < Minitest::Test
   end
 
   def test_add_multiple_and_remove
-    @jar.add_cookie_str("a=1; Path=/", @base_url)
-    @jar.add_cookie_str("b=2; Path=/", @base_url)
-    @jar.add_cookie_str("c=3; Path=/", @base_url)
+    @jar.add("a=1; Path=/", @base_url)
+    @jar.add("b=2; Path=/", @base_url)
+    @jar.add("c=3; Path=/", @base_url)
 
     cookies = @jar.get_all
     assert_equal 3, cookies.length
@@ -58,8 +58,8 @@ class CookieTest < Minitest::Test
   end
 
   def test_clear
-    @jar.add_cookie_str("x=1; Path=/", @base_url)
-    @jar.add_cookie_str("y=2; Path=/", @base_url)
+    @jar.add("x=1; Path=/", @base_url)
+    @jar.add("y=2; Path=/", @base_url)
     refute_empty @jar.get_all
 
     @jar.clear
@@ -69,7 +69,7 @@ class CookieTest < Minitest::Test
   def test_max_age_and_expires_optional
     # Max-Age only
     @jar.clear
-    @jar.add_cookie_str("ma=1; Max-Age=3600; Path=/", @base_url)
+    @jar.add("ma=1; Max-Age=3600; Path=/", @base_url)
     c1 = @jar.get_all.find { |c| c.name == "ma" }
     assert c1
     # can be nil or Integer; just ensure responds and is truthy integer
@@ -81,7 +81,7 @@ class CookieTest < Minitest::Test
     # Expires only
     @jar.clear
     t = Time.now + 3600
-    @jar.add_cookie_str("exp=1; Expires=#{t.gmtime.strftime("%a, %d %b %Y %H:%M:%S GMT")}; Path=/", @base_url)
+    @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
@@ -144,8 +144,8 @@ class CookieTest < Minitest::Test
 
   def test_same_site_flags_from_parsed_header
     @jar.clear
-    @jar.add_cookie_str("s1=1; Path=/; SameSite=Strict", @base_url)
-    @jar.add_cookie_str("s2=1; Path=/; SameSite=Lax", @base_url)
+    @jar.add("s1=1; Path=/; SameSite=Strict", @base_url)
+    @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?]] }
@@ -154,13 +154,27 @@ class CookieTest < Minitest::Test
     assert_equal [false, true], h["s2"]
   end
 
-  def test_request_cookie_value_percent_encoding
-    raw_value = "hello world?"
+  def test_request_uncompressed_cookies
     client = Wreq::Client.new
     resp = client.get(
-      "http://localhost:8080/cookies",
-      cookies: {"mykey" => raw_value}
+      "https://httpbin.io/cookies",
+      cookies: {"foo" => "bar", "baz" => "qux"}
     )
-    assert_includes resp.text, "hello%20world%3F"
+    json = resp.json
+    assert_instance_of Hash, json
+    assert_equal "bar", json["foo"]
+    assert_equal "qux", json["baz"]
+  end
+
+  def test_request_compressed_cookies
+    client = Wreq::Client.new
+    resp = client.get(
+      "https://httpbin.io/cookies",
+      cookies: "foo=bar; baz=qux"
+    )
+    json = resp.json
+    assert_instance_of Hash, json
+    assert_equal "bar", json["foo"]
+    assert_equal "qux", json["baz"]
   end
 end

data/test/emulation_test.rb

@@ -4,18 +4,18 @@ require "test_helper"
 
 class EmulationTest < Minitest::Test
   def test_all_emulation_device_constants_are_non_nil
-    Wreq::EmulationDevice.constants.each do |name|
-      const = Wreq::EmulationDevice.const_get(name)
-      assert_instance_of Wreq::EmulationDevice, const,
-        "#{name} should be EmulationDevice, got #{const.inspect}"
+    Wreq::Profile.constants.each do |name|
+      const = Wreq::Profile.const_get(name)
+      assert_instance_of Wreq::Profile, const,
+        "#{name} should be Profile, got #{const.inspect}"
     end
   end
 
   def test_all_emulation_os_constants_are_non_nil
-    Wreq::EmulationOS.constants.each do |name|
-      const = Wreq::EmulationOS.const_get(name)
-      assert_instance_of Wreq::EmulationOS, const,
-        "#{name} should be EmulationOS, got #{const.inspect}"
+    Wreq::Platform.constants.each do |name|
+      const = Wreq::Platform.const_get(name)
+      assert_instance_of Wreq::Platform, const,
+        "#{name} should be Platform, got #{const.inspect}"
     end
   end
 end

data/test/error_handling_test.rb

@@ -82,7 +82,10 @@ class ErrorHandlingTest < Minitest::Test
         Wreq.get(url, proxy: proxy, timeout: 5)
         flunk "Expected proxy connection error but got response"
       rescue => e
-        assert_instance_of Wreq::ProxyConnectionError, e
+        assert(
+          e.is_a?(Wreq::ProxyConnectionError) || e.is_a?(Wreq::RequestError),
+          "Expected ProxyConnectionError or RequestError, got #{e.class}: #{e.message}"
+        )
       end
     end
   end

data/test/inspect_test.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+class InspectTest < Minitest::Test
+  # ---- Headers ----
+
+  def test_headers_inspect_empty
+    headers = Wreq::Headers.new
+    assert_equal "#<Wreq::Headers [0 headers]>", headers.inspect
+  end
+
+  def test_headers_inspect_with_entries
+    headers = Wreq::Headers.new
+    headers.set("Content-Type", "text/html")
+    headers.set("Accept", "application/json")
+    assert_equal "#<Wreq::Headers [2 headers]>", headers.inspect
+  end
+
+  # ---- Cookie ----
+
+  def test_cookie_inspect_minimal
+    c = Wreq::Cookie.new("sid", "secret123")
+    result = c.inspect
+    assert_includes result, "#<Wreq::Cookie"
+    assert_includes result, "sid"
+    refute_includes result, "secret123"
+    assert result.end_with?(">")
+  end
+
+  def test_cookie_inspect_with_domain_and_path
+    c = Wreq::Cookie.new("sid", "val",
+      domain: "example.com",
+      path: "/app")
+    result = c.inspect
+    assert_includes result, "domain=example.com"
+    assert_includes result, "path=/app"
+  end
+
+  def test_cookie_inspect_with_flags
+    c = Wreq::Cookie.new("sid", "val",
+      secure: true,
+      http_only: true)
+    result = c.inspect
+    assert_includes result, "secure"
+    assert_includes result, "http_only"
+  end
+
+  def test_cookie_inspect_omits_nil_attributes
+    c = Wreq::Cookie.new("sid", "val")
+    result = c.inspect
+    refute_includes result, "domain="
+    refute_includes result, "path="
+    refute_includes result, "secure"
+    refute_includes result, "http_only"
+  end
+
+  # ---- Jar ----
+
+  def test_jar_inspect_empty
+    jar = Wreq::Jar.new
+    assert_equal "#<Wreq::Jar [0 cookies]>", jar.inspect
+  end
+
+  def test_jar_inspect_with_cookies
+    jar = Wreq::Jar.new
+    jar.add("a=1; Path=/", "https://example.com")
+    jar.add("b=2; Path=/", "https://example.com")
+    assert_equal "#<Wreq::Jar [2 cookies]>", jar.inspect
+  end
+
+  # ---- Client ----
+
+  def test_client_inspect
+    client = Wreq::Client.new
+    assert_equal "#<Wreq::Client>", client.inspect
+  end
+
+  def test_client_inspect_with_options
+    client = Wreq::Client.new(timeout: 30, gzip: true)
+    assert_equal "#<Wreq::Client>", client.inspect
+  end
+
+  # ---- Response ----
+
+  def test_response_to_s_returns_body
+    response = Wreq.get("http://localhost:8080/json")
+    assert_equal response.text, response.to_s
+  end
+
+  def test_response_inspect_format
+    response = Wreq.get("http://localhost:8080/json")
+    result = response.inspect
+    assert result.start_with?("#<Wreq::Response")
+    assert_includes result, "200"
+    assert result.end_with?(">")
+  end
+
+  # ---- StatusCode ----
+
+  def test_status_code_inspect
+    response = Wreq.get("http://localhost:8080/status/200")
+    result = response.status.inspect
+    assert result.start_with?("#<Wreq::StatusCode")
+    assert_includes result, response.status.to_s
+    assert result.end_with?(">")
+  end
+
+  # ---- Version ----
+
+  def test_version_inspect_from_constant
+    v = Wreq::Version::HTTP_11
+    result = v.inspect
+    assert result.start_with?("#<Wreq::Version")
+    assert_includes result, v.to_s
+    assert result.end_with?(">")
+  end
+
+  def test_version_inspect_from_response
+    response = Wreq.get("http://localhost:8080/get")
+    result = response.version.inspect
+    assert result.start_with?("#<Wreq::Version")
+    assert result.end_with?(">")
+  end
+end

data/test/stream_test.rb

@@ -8,12 +8,16 @@ class StreamTest < Minitest::Test
       3.times { |i| sender.push("chunk-#{i}\n") }
       sender.close
     end
+
     resp = client.post("http://localhost:8080/post", body: sender, headers: {"Content-Type" => "text/plain"})
+
     assert_equal 200, resp.code
+
     echoed = resp.json["data"]
     assert_includes echoed, "chunk-0"
     assert_includes echoed, "chunk-1"
     assert_includes echoed, "chunk-2"
+
     producer.join
   end
 
@@ -21,12 +25,124 @@ class StreamTest < Minitest::Test
     client = Wreq::Client.new
     resp = client.get("http://localhost:8080/stream/5")
     chunks = []
+
     resp.chunks do |chunk|
       chunks << chunk
-      assert_kind_of String, chunk
+      assert_kind_of String, chunk, "Each yielded chunk must be a String"
       assert_match(/\{.*\}/, chunk)
     end
-    assert_equal 5, chunks.size
+
+    assert_equal 5, chunks.size, "Should yield exactly 5 chunks from /stream/5"
+  end
+
+  def test_chunks_yields_binary_encoding
+    client = Wreq::Client.new
+    resp = client.get("http://localhost:8080/stream/3")
+
+    resp.chunks do |chunk|
+      assert chunk.encoding == Encoding::BINARY || chunk.encoding == Encoding::ASCII_8BIT,
+        "Chunk should have binary encoding, got #{chunk.encoding}"
+    end
+  end
+
+  def test_chunks_with_single_chunk_body
+    client = Wreq::Client.new
+    resp = client.get("http://localhost:8080/bytes/1024")
+    chunk_count = 0
+    total_bytes = 0
+
+    resp.chunks do |chunk|
+      chunk_count += 1
+      total_bytes += chunk.bytesize
+    end
+
+    assert chunk_count >= 1, "Should yield at least one chunk"
+    assert_equal 1024, total_bytes, "Total bytes should match content length"
+  end
+
+  def test_chunks_returns_nil
+    client = Wreq::Client.new
+    resp = client.get("http://localhost:8080/stream/3")
+
+    result = resp.chunks { |_chunk| :processing }
+
+    assert_nil result, "chunks should return nil after completion"
+  end
+
+  def test_chunks_with_empty_body
+    client = Wreq::Client.new
+    resp = client.get("http://localhost:8080/status/204")
+    chunk_count = 0
+
+    resp.chunks do |_chunk|
+      chunk_count += 1
+    end
+
+    assert_equal 0, chunk_count, "No chunks should be yielded for empty 204 response"
+  end
+
+  def test_chunks_without_block_raises_error
+    client = Wreq::Client.new
+    resp = client.get("http://localhost:8080/stream/3")
+
+    assert_raises(LocalJumpError) do
+      resp.chunks
+    end
+  end
+
+  def test_other_threads_run_during_streaming
+    client = Wreq::Client.new
+    resp = client.get("http://localhost:8080/drip?duration=3&numbytes=3&delay=1")
+
+    counter = 0
+    tick_thread = Thread.new do
+      30.times do
+        counter += 1
+        sleep 0.1
+      end
+    end
+
+    chunks_received = 0
+    resp.chunks do |_chunk|
+      chunks_received += 1
+    end
+
+    tick_thread.join(10)
+
+    assert counter > 5,
+      "Counter only reached #{counter} - other threads may not be running during streaming. " \
+      "GVL should be released during I/O waits."
+    assert chunks_received >= 1, "Should have received at least one chunk"
+  end
+
+  def test_multiple_concurrent_streams
+    client = Wreq::Client.new
+    results = {}
+    done = {}
+
+    t1 = Thread.new do
+      resp = client.get("http://localhost:8080/stream/3")
+      chunks = []
+      resp.chunks { |chunk| chunks << chunk }
+      results[:t1] = chunks.size
+      done[:t1] = true
+    end
+
+    t2 = Thread.new do
+      resp = client.get("http://localhost:8080/stream/3")
+      chunks = []
+      resp.chunks { |chunk| chunks << chunk }
+      results[:t2] = chunks.size
+      done[:t2] = true
+    end
+
+    t1.join(15)
+    t2.join(15)
+
+    assert done[:t1], "Thread 1 should complete"
+    assert done[:t2], "Thread 2 should complete"
+    assert_equal 3, results[:t1], "Thread 1 should receive 3 chunks"
+    assert_equal 3, results[:t2], "Thread 2 should receive 3 chunks"
   end
 
   def test_thread_interrupt_connect
@@ -35,9 +151,11 @@ class StreamTest < Minitest::Test
       Wreq.get(url)
     rescue => _
     end
+
     sleep 2
     thread.kill
     killed = thread.join(5)
+
     assert killed, "Connect phase should be interruptible"
   end
 
@@ -47,9 +165,11 @@ class StreamTest < Minitest::Test
       Wreq.get(url, timeout: 60)
     rescue => _
     end
+
     sleep 2
     thread.kill
     killed = thread.join(5)
+
     assert killed, "Connect+timeout phase should be interruptible"
   end
 
@@ -60,9 +180,11 @@ class StreamTest < Minitest::Test
       resp.text
     rescue => _
     end
+
     sleep 2
     thread.kill
     killed = thread.join(5)
+
     assert killed, "Body reading should be interruptible"
   end
 
@@ -73,9 +195,177 @@ class StreamTest < Minitest::Test
       resp.chunks { |chunk| chunk }
     rescue => _
     end
+
     sleep 2
     thread.kill
     killed = thread.join(5)
+
     assert killed, "Body streaming should be interruptible"
   end
+
+  def test_thread_interrupt_during_slow_stream_with_block_processing
+    url = "http://localhost:8080/drip?duration=5&numbytes=5&delay=1"
+    thread = Thread.new do
+      resp = Wreq.get(url)
+      resp.chunks do |_chunk|
+        sleep 0.5
+      end
+    rescue => _
+    end
+
+    sleep 2
+    thread.kill
+    killed = thread.join(5)
+
+    assert killed, "Streaming with slow block processing should be interruptible"
+  end
+
+  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|
+      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"
+  end
+
+  def test_exception_in_block_propagates
+    client = Wreq::Client.new
+    resp = client.get("http://localhost:8080/stream/5")
+    error_raised = false
+    chunks_before_error = 0
+
+    begin
+      resp.chunks do |_chunk|
+        chunks_before_error += 1
+        raise "intentional error in block" if chunks_before_error == 2
+      end
+    rescue RuntimeError => e
+      error_raised = true
+      assert_equal "intentional error in block", e.message
+    end
+
+    assert error_raised, "Exception raised inside the block should propagate out"
+    assert_equal 2, chunks_before_error, "Should have processed 2 chunks before the error"
+  end
+
+  def test_chunks_called_twice_raises_error
+    client = Wreq::Client.new
+    resp = client.get("http://localhost:8080/stream/3")
+    resp.chunks { |_chunk| }
+    error_raised = false
+
+    begin
+      resp.chunks { |_chunk| }
+    rescue => e
+      error_raised = true
+      assert_instance_of Wreq::MemoryError, e,
+        "Second chunks call should raise MemoryError, got #{e.class}: #{e.message}"
+    end
+
+    assert error_raised, "Second chunks call should raise an error"
+  end
+
+  def test_text_after_chunks_raises_error
+    client = Wreq::Client.new
+    resp = client.get("http://localhost:8080/stream/3")
+    resp.chunks { |_chunk| }
+    error_raised = false
+
+    begin
+      resp.text
+    rescue => e
+      error_raised = true
+      assert_instance_of Wreq::MemoryError, e,
+        "Calling text after chunks should raise MemoryError, got #{e.class}: #{e.message}"
+    end
+
+    assert error_raised, "Calling text after chunks should raise an error"
+  end
+
+  def test_chunks_content_matches_full_body
+    client = Wreq::Client.new
+    resp_full = client.get("http://localhost:8080/bytes/4096")
+    full_bytes = resp_full.bytes
+
+    resp_stream = client.get("http://localhost:8080/bytes/4096")
+    streamed_bytes = "".b
+    resp_stream.chunks do |chunk|
+      streamed_bytes << chunk
+    end
+
+    assert_equal full_bytes.bytesize, streamed_bytes.bytesize,
+      "Streamed body size should match full body size"
+  end
+
+  def test_chunks_json_stream_content
+    client = Wreq::Client.new
+    resp = client.get("http://localhost:8080/stream/5")
+    chunks = []
+
+    resp.chunks do |chunk|
+      chunks << chunk
+    end
+
+    chunks.each_with_index do |chunk, i|
+      assert_match(/\{.*\}/, chunk,
+        "Chunk #{i} should contain a JSON object, got: #{chunk[0..80]}")
+    end
+  end
+
+  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")
+    chunks_received = 0
+
+    resp.chunks do |_chunk|
+      chunks_received += 1
+      GC.start
+      GC.start
+    end
+
+    assert_equal 3, chunks_received,
+      "All 3 chunks should be received even with forced GC between yields"
+  end
+
+  def test_close_after_streaming
+    client = Wreq::Client.new
+    resp = client.get("http://localhost:8080/stream/3")
+
+    resp.chunks { |_chunk| }
+    resp.close
+  end
+
+  def test_chunks_via_module_method
+    resp = Wreq.get("http://localhost:8080/stream/3")
+    chunks = []
+
+    resp.chunks do |chunk|
+      chunks << chunk
+    end
+
+    assert_equal 3, chunks.size, "Module-level Wreq.get + chunks should work"
+  end
+
+  def test_chunks_via_client_instance
+    client = Wreq::Client.new
+    resp = client.get("http://localhost:8080/stream/3")
+    chunks = []
+
+    resp.chunks do |chunk|
+      chunks << chunk
+    end
+
+    assert_equal 3, chunks.size, "Client instance get + chunks should work"
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: wreq
 version: !ruby/object:Gem::Version
-  version: 1.1.0
+  version: 1.2.0
 platform: ruby
 authors:
 - SearchApi
@@ -29,7 +29,8 @@ files:
 - build.rs
 - examples/body.rb
 - examples/client.rb
-- examples/emulation_request.rb
+- examples/cookie.rb
+- examples/emulate_request.rb
 - examples/headers.rb
 - examples/proxy.rb
 - examples/send_stream.rb
@@ -40,7 +41,7 @@ files:
 - lib/wreq_ruby/body.rb
 - lib/wreq_ruby/client.rb
 - lib/wreq_ruby/cookie.rb
-- lib/wreq_ruby/emulation.rb
+- lib/wreq_ruby/emulate.rb
 - lib/wreq_ruby/error.rb
 - lib/wreq_ruby/header.rb
 - lib/wreq_ruby/http.rb
@@ -71,6 +72,7 @@ files:
 - test/emulation_test.rb
 - test/error_handling_test.rb
 - test/header_test.rb
+- test/inspect_test.rb
 - test/module_methods_test.rb
 - test/request_parameters_test.rb
 - test/request_test.rb