wreq 1.2.3-x64-mingw-ucrt

data/test/cookie_test.rb

@@ -0,0 +1,182 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+class CookieTest < Minitest::Test
+  def setup
+    @jar = Wreq::Jar.new
+    @base_url = "https://example.com"
+  end
+
+  def test_jar_initially_empty
+    assert_instance_of Wreq::Jar, @jar
+    cookies = begin
+      Wreq::Jar.get_all(@jar)
+    rescue
+      @jar.get_all
+    end # support either binding style
+    assert_kind_of Array, cookies
+    assert_equal 0, cookies.length
+  end
+
+  def test_add_and_get_all
+    set_cookie = "sid=abc123; Path=/; Domain=example.com; HttpOnly; Secure"
+    @jar.add(set_cookie, @base_url)
+
+    cookies = @jar.get_all
+    assert_kind_of Array, cookies
+    assert_equal 1, cookies.length
+
+    c = cookies.first
+    assert_instance_of Wreq::Cookie, c
+    assert_equal "sid", c.name
+    assert_equal "abc123", c.value
+
+    # attributes parsed from Set-Cookie
+    assert_equal "/", c.path
+    assert_equal "example.com", c.domain
+
+    # predicate-ish flags
+    assert_equal true, (c.http_only || c.http_only?)
+    assert_equal true, (c.secure || c.secure?)
+  end
+
+  def test_add_multiple_and_remove
+    @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
+
+    # remove one by name
+    @jar.remove("b", @base_url)
+    names = @jar.get_all.map(&:name)
+    refute_includes names, "b"
+    assert_includes names, "a"
+    assert_includes names, "c"
+  end
+
+  def test_clear
+    @jar.add("x=1; Path=/", @base_url)
+    @jar.add("y=2; Path=/", @base_url)
+    refute_empty @jar.get_all
+
+    @jar.clear
+    assert_empty @jar.get_all
+  end
+
+  def test_max_age_and_expires_optional
+    # Max-Age only
+    @jar.clear
+    @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
+    if (v = c1.max_age)
+      assert_kind_of Integer, v
+      assert_operator v, :>=, 0
+    end
+
+    # Expires only
+    @jar.clear
+    t = Time.now + 3600
+    @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
+    if (e = c2.expires)
+      assert_kind_of Float, e
+      assert_operator e, :>, Time.now.to_f - 1_000_000 # sanity bound
+    end
+  end
+
+  # -------- Wreq::Cookie unit tests --------
+
+  def test_cookie_new_minimal
+    c = Wreq::Cookie.new("sid", "abc")
+
+    assert_instance_of Wreq::Cookie, c
+    assert_equal "sid", c.name
+    assert_equal "abc", c.value
+
+    assert_nil c.path
+    assert_nil c.domain
+    assert_nil c.max_age
+    assert_nil c.expires
+
+    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?
+  end
+
+  def test_cookie_new_full_attributes
+    exp = Time.now.to_f + 7200.0
+    c = Wreq::Cookie.new("sess", "v",
+      domain: "example.com",
+      path: "/",
+      max_age: 3600,
+      expires: exp,
+      http_only: true,
+      secure: true,
+      same_site: Wreq::SameSite::Lax)
+
+    assert_equal "sess", c.name
+    assert_equal "v", c.value
+    assert_equal "example.com", c.domain
+    assert_equal "/", c.path
+
+    # 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 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?
+  end
+
+  def test_same_site_flags_from_parsed_header
+    @jar.clear
+    @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?]] }
+
+    assert_equal [true, false], h["s1"]
+    assert_equal [false, true], h["s2"]
+  end
+
+  def test_request_uncompressed_cookies
+    client = Wreq::Client.new
+    resp = client.get(
+      "#{HTTPBIN_URL}/cookies",
+      cookies: {"foo" => "bar", "baz" => "qux"}
+    )
+    json = resp.json
+    assert_instance_of Hash, json
+    cookies = json.fetch("cookies", json)
+    assert_equal "bar", cookies["foo"]
+    assert_equal "qux", cookies["baz"]
+  end
+
+  def test_request_compressed_cookies
+    client = Wreq::Client.new
+    resp = client.get(
+      "#{HTTPBIN_URL}/cookies",
+      cookies: "foo=bar; baz=qux"
+    )
+    json = resp.json
+    assert_instance_of Hash, json
+    cookies = json.fetch("cookies", json)
+    assert_equal "bar", cookies["foo"]
+    assert_equal "qux", cookies["baz"]
+  end
+end

data/test/emulation_test.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+class EmulationTest < Minitest::Test
+  def test_all_emulation_device_constants_are_non_nil
+    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::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

@@ -0,0 +1,92 @@
+require "test_helper"
+
+class ErrorHandlingTest < Minitest::Test
+  def test_network_error_handling
+    # Try to connect to a non-existent domain
+    response = Wreq.get("https://definitely-not-a-real-domain-12345.com")
+    flunk "Expected network error but got response: #{response.code}"
+  rescue => e
+    assert_instance_of Wreq::ConnectionError, e
+    # Network errors should be caught and wrapped appropriately
+  end
+
+  def test_invalid_url_handling
+    # Invalid URL format
+    response = Wreq.get("not-a-valid-url")
+    flunk "Expected URL error but got response: #{response.code}"
+  rescue => e
+    assert_instance_of Wreq::BuilderError, e
+  end
+
+  def test_http_error_status_codes
+    # These should not raise errors, just return responses with error codes
+    [400, 401, 403, 404, 500, 502, 503].each do |status_code|
+      response = Wreq.get("#{HTTPBIN_URL}/status/#{status_code}")
+      assert_equal status_code, response.code
+      # Should not raise an exception for HTTP error codes
+    end
+  end
+
+  def test_timeout_handling
+    # Test timeout with a delay that should definitely cause timeout
+
+    # Request with a very short timeout that should fail
+    response = Wreq.get("#{HTTPBIN_URL}/delay/10", timeout: 1)
+    # If we get here, the request didn't timeout (unexpected)
+    flunk "Expected timeout error but got response: #{response.code}"
+  rescue => e
+    # Timeout error is expected
+    assert_instance_of Wreq::TimeoutError, e
+    # Could also check error message contains timeout-related keywords
+  end
+
+  def test_invalid_json_response
+    # Get a non-JSON response and try to parse as JSON
+    response = Wreq.get("#{HTTPBIN_URL}/html")
+    assert_equal 200, response.code
+
+    # Should raise an error when trying to parse HTML as JSON
+    begin
+      response.json
+    rescue => e
+      assert_instance_of Wreq::DecodingError, e
+    end
+  end
+
+  def test_empty_response_json
+    response = Wreq.get("#{HTTPBIN_URL}/status/204")
+    assert_equal 204, response.code
+    assert_equal "", response.text
+
+    # Empty body should raise error when parsing as JSON
+    begin
+      response.json
+    rescue => e
+      assert_instance_of Wreq::DecodingError, e
+    end
+  end
+
+  def test_proxy_error_handling
+    invalid_proxies = [
+      "http://invalid.proxy:8080",
+      "https://invalid.proxy:8080",
+      "socks4://invalid.proxy:8080",
+      "socks4a://invalid.proxy:8080",
+      "socks5://invalid.proxy:8080",
+      "socks5h://invalid.proxy:8080"
+    ]
+    target_urls = ["https://example.com", "http://example.com"]
+
+    invalid_proxies.each do |proxy|
+      target_urls.each do |url|
+        Wreq.get(url, proxy: proxy, timeout: 5)
+        flunk "Expected proxy connection error but got response"
+      rescue => e
+        assert(
+          e.is_a?(Wreq::ProxyConnectionError) || e.is_a?(Wreq::RequestError),
+          "Expected ProxyConnectionError or RequestError, got #{e.class}: #{e.message}"
+        )
+      end
+    end
+  end
+end

data/test/header_test.rb

@@ -0,0 +1,290 @@
+require "test_helper"
+
+class HeadersTest < Minitest::Test
+  def setup
+    @response = Wreq.get("#{HTTPBIN_URL}/response-headers",
+      query: {
+        "X-Custom-Header" => "custom-value",
+        "X-Multi-Header" => "value1"
+      })
+    @headers = @response.headers
+  end
+
+  def test_headers_class
+    assert_instance_of Wreq::Headers, @headers
+  end
+
+  def test_initialize
+    headers = Wreq::Headers.new
+    assert_instance_of Wreq::Headers, headers
+    assert headers.empty?
+    assert_equal 0, headers.length
+  end
+
+  def test_get_existing_header
+    # Content-Type should exist in response
+    content_type = @headers.get("Content-Type")
+    assert_instance_of String, content_type
+    refute_nil content_type
+  end
+
+  def test_get_case_insensitive
+    # Test case-insensitive lookup
+    value1 = @headers.get("content-type")
+    value2 = @headers.get("Content-Type")
+    value3 = @headers.get("CONTENT-TYPE")
+
+    assert_equal value1, value2
+    assert_equal value2, value3
+  end
+
+  def test_get_nonexistent_header
+    result = @headers.get("X-Nonexistent-Header-12345")
+    assert_nil result
+  end
+
+  def test_get_all_single_value
+    # Most headers have single values
+    values = @headers.get_all("Content-Type")
+    assert_instance_of Array, values
+    assert_equal 1, values.length
+    assert_equal @headers.get("Content-Type"), values.first
+  end
+
+  def test_get_all_nonexistent
+    values = @headers.get_all("X-Nonexistent-Header")
+    assert_instance_of Array, values
+    assert_equal 0, values.length
+    assert_empty values
+  end
+
+  def test_set_new_header
+    headers = Wreq::Headers.new
+    headers.set("X-Test-Header", "test-value")
+
+    assert_equal "test-value", headers.get("X-Test-Header")
+    assert_equal 1, headers.length
+  end
+
+  def test_set_replaces_existing
+    headers = Wreq::Headers.new
+    headers.set("X-Test", "value1")
+    headers.set("X-Test", "value2")
+
+    assert_equal "value2", headers.get("X-Test")
+    values = headers.get_all("X-Test")
+    assert_equal 1, values.length
+    assert_equal "value2", values.first
+  end
+
+  def test_append_to_new_header
+    headers = Wreq::Headers.new
+    headers.append("Accept", "application/json")
+
+    assert_equal "application/json", headers.get("Accept")
+  end
+
+  def test_append_to_existing_header
+    headers = Wreq::Headers.new
+    headers.set("Accept", "application/json")
+    headers.append("Accept", "text/html")
+    headers.append("Accept", "application/xml")
+
+    values = headers.get_all("Accept")
+    assert_equal 3, values.length
+    assert_includes values, "application/json"
+    assert_includes values, "text/html"
+    assert_includes values, "application/xml"
+  end
+
+  def test_remove_existing_header
+    headers = Wreq::Headers.new
+    headers.set("X-Remove-Me", "value")
+
+    removed_value = headers.remove("X-Remove-Me")
+    assert_equal "value", removed_value
+    assert_nil headers.get("X-Remove-Me")
+  end
+
+  def test_remove_nonexistent_header
+    headers = Wreq::Headers.new
+    result = headers.remove("X-Nonexistent")
+    assert_nil result
+  end
+
+  def test_delete_alias
+    headers = Wreq::Headers.new
+    headers.set("X-Delete-Me", "value")
+
+    removed_value = headers.remove("X-Delete-Me")
+    assert_equal "value", removed_value
+    assert_nil headers.get("X-Delete-Me")
+  end
+
+  def test_contains_existing
+    assert @headers.contains?("Content-Type")
+  end
+
+  def test_contains_nonexistent
+    refute @headers.contains?("X-Nonexistent-Header-12345")
+  end
+
+  def test_contains_case_insensitive
+    # If Content-Type exists
+    if @headers.contains?("Content-Type")
+      assert @headers.contains?("content-type")
+      assert @headers.contains?("CONTENT-TYPE")
+    end
+  end
+
+  def test_key_alias
+    # key? is an alias for contains?
+    assert_equal @headers.contains?("Content-Type"), @headers.key?("Content-Type")
+  end
+
+  def test_length
+    headers = Wreq::Headers.new
+    assert_equal 0, headers.length
+
+    headers.set("Header1", "value1")
+    assert_equal 1, headers.length
+
+    headers.set("Header2", "value2")
+    assert_equal 2, headers.length
+
+    # Setting same header shouldn't increase length
+    headers.set("Header1", "new-value")
+    assert_equal 2, headers.length
+  end
+
+  def test_empty_on_new_headers
+    headers = Wreq::Headers.new
+    assert headers.empty?
+  end
+
+  def test_empty_on_headers_with_data
+    refute @headers.empty?
+  end
+
+  def test_clear
+    headers = Wreq::Headers.new
+    headers.set("Header1", "value1")
+    headers.set("Header2", "value2")
+
+    refute headers.empty?
+    headers.clear
+    assert headers.empty?
+    assert_equal 0, headers.length
+  end
+
+  def test_keys
+    headers = Wreq::Headers.new
+    headers.set("Content-Type", "application/json")
+    headers.set("Authorization", "Bearer token")
+
+    keys = headers.keys
+    assert_instance_of Array, keys
+    assert_equal 2, keys.length
+    assert_includes keys, "content-type"
+    assert_includes keys, "authorization"
+  end
+
+  def test_keys_are_lowercase
+    headers = Wreq::Headers.new
+    headers.set("Content-Type", "text/html")
+    headers.set("X-Custom-Header", "value")
+
+    keys = headers.keys
+    keys.each do |key|
+      assert_equal key, key.downcase
+    end
+  end
+
+  def test_values
+    headers = Wreq::Headers.new
+    headers.set("Content-Type", "application/json")
+    headers.set("Authorization", "Bearer token")
+
+    values = headers.values
+    assert_instance_of Array, values
+    assert_equal 2, values.length
+    assert_includes values, "application/json"
+    assert_includes values, "Bearer token"
+  end
+
+  def test_each_with_block
+    headers = Wreq::Headers.new
+    headers.set("Header1", "value1")
+    headers.set("Header2", "value2")
+
+    collected = {}
+    headers.each do |name, value|
+      assert_instance_of String, name
+      assert_instance_of String, value
+      collected[name] = value
+    end
+
+    assert_equal 2, collected.length
+    assert_equal "value1", collected["header1"]
+    assert_equal "value2", collected["header2"]
+  end
+
+  def test_multiple_operations_sequence
+    headers = Wreq::Headers.new
+
+    # Add headers
+    headers.set("Content-Type", "application/json")
+    headers.set("Accept", "application/json")
+
+    assert_equal 2, headers.length
+
+    # Append to Accept
+    headers.append("Accept", "text/html")
+    assert_equal 2, headers.get_all("Accept").length
+
+    # Clear all
+    headers.clear
+    assert headers.empty?
+  end
+
+  def test_special_characters_in_header_values
+    headers = Wreq::Headers.new
+    special_value = "Bearer token-123_abc/xyz+456=789"
+    headers.set("Authorization", special_value)
+
+    assert_equal special_value, headers.get("Authorization")
+  end
+
+  def test_response_headers_integration
+    # Test that headers from actual HTTP response work correctly
+    assert_instance_of Wreq::Headers, @headers
+    refute @headers.empty?
+
+    # Should have common HTTP headers
+    assert @headers.length > 0
+  end
+
+  def test_response_headers_each
+    # Test iteration over real response headers
+    count = 0
+    @headers.each do |name, value|
+      assert_instance_of String, name
+      assert_instance_of String, value
+      count += 1
+    end
+
+    assert count > 0
+    assert_equal @headers.length, count
+  end
+
+  def test_headers_immutability_across_instances
+    headers1 = Wreq::Headers.new
+    headers2 = Wreq::Headers.new
+
+    headers1.set("X-Test", "value1")
+    headers2.set("X-Test", "value2")
+
+    assert_equal "value1", headers1.get("X-Test")
+    assert_equal "value2", headers2.get("X-Test")
+  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("#{HTTPBIN_URL}/json")
+    assert_equal response.text, response.to_s
+  end
+
+  def test_response_inspect_format
+    response = Wreq.get("#{HTTPBIN_URL}/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("#{HTTPBIN_URL}/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("#{HTTPBIN_URL}/get")
+    result = response.version.inspect
+    assert result.start_with?("#<Wreq::Version")
+    assert result.end_with?(">")
+  end
+end