wreq 1.0.0-x86_64-linux → 1.2.0-x86_64-linux

data/lib/wreq_ruby/response.rb

@@ -88,26 +88,16 @@ unless defined?(Wreq)
       def bytes
       end
 
-      # Get the response body as text.
-      #
-      # @return [String] Response body decoded as UTF-8 text
-      # @example
-      #   html = response.text
-      #   puts html
-      # @raise [Wreq::DecodingError] if body cannot be decoded as binary
-      def text
-      end
-
       # 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
       # @example
-      #   html = response.text_with_charset("ISO-8859-1")
+      #   html = response.text("ISO-8859-1")
       #   puts html
       # @raise [Wreq::DecodingError] if body cannot be decoded with the specified encoding
-      def text_with_charset(default_encoding)
+      def text(default_encoding: "UTF-8")
       end
 
       # Parse the response body as JSON.
@@ -120,14 +110,17 @@ unless defined?(Wreq)
       def json
       end
 
-      # Get a streaming iterator for the response body, yielding each chunk.
+      # Stream the response body, yielding each chunk to the given block.
       #
       # This method allows you to process large HTTP responses efficiently,
       # by yielding each chunk of the body as it arrives, without loading
       # the entire response into memory.
       #
-      # @return An iterator over response body chunks (binary String)
+      # @return [nil]
       # @yield [chunk] Each chunk of the response body as a binary String
+      # @raise [LocalJumpError] if called without a block
+      # @raise [Wreq::TimeoutError, Wreq::BodyError, Wreq::ConnectionResetError, Wreq::RequestError]
+      #   if streaming fails while reading the response body
       # @example Save response to file
       #   File.open("output.bin", "wb") do |f|
       #     response.chunks { |chunk| f.write(chunk) }
@@ -137,7 +130,7 @@ unless defined?(Wreq)
       #   response.chunks { |chunk| total += chunk.bytesize }
       #   puts "Downloaded #{total} bytes"
       #
-      # Note: The returned Receiver is only for reading response bodies, not for uploads.
+      # Exceptions raised inside the block are propagated to the caller.
       def chunks
       end
 
@@ -156,27 +149,35 @@ end
 
 module Wreq
   class Response
-    # Returns a compact string representation of the response.
+    # Returns the response body as a string.
+    #
+    # @return [String] Response body text
+    # @example
+    #   puts response.to_s
+    #   puts response
+    #   File.write("page.html", response)
+    def to_s
+      text
+    end
+
+    # Returns a compact string representation for debugging.
     #
     # Format: #<Wreq::Response STATUS content-type="..." body=SIZE>
     #
     # @return [String] Compact formatted response information
     # @example
-    #   puts response.to_s
+    #   p response
     #   # => #<Wreq::Response 200 content-type="application/json" body=456B>
-    def to_s
+    def inspect
       parts = ["#<Wreq::Response"]
 
-      # Status code
       parts << code.to_s
 
-      # Content-Type header if present
       if headers.respond_to?(:get)
         content_type = headers.get("content-type")
         parts << "content-type=#{content_type.inspect}" if content_type
       end
 
-      # Body size
       if content_length
         parts << "body=#{format_bytes(content_length)}"
       end

data/test/client_cookie_test.rb

@@ -36,7 +36,7 @@ class ClientCookieProviderTest < Minitest::Test
 
   def test_prepopulated_jar_is_used_by_client
     # pre-populate jar
-    @jar.add_cookie_str("pref=1; Path=/", "#{HOST}/")
+    @jar.add("pref=1; Path=/", "#{HOST}/")
 
     res = @client.get("#{HOST}/cookies")
     assert_equal 200, res.code

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