wreq 1.2.4 → 1.2.5

data/test/header_test.rb

@@ -2,289 +2,325 @@ 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
+    @headers = Wreq::Headers.new(
+      "Content-Type" => "application/json",
+      "X-Custom-Header" => "custom-value"
+    )
   end
 
-  def test_headers_class
-    assert_instance_of Wreq::Headers, @headers
-  end
-
-  def test_initialize
+  def test_headers_class_and_empty_constructor
     headers = Wreq::Headers.new
+
     assert_instance_of Wreq::Headers, headers
     assert headers.empty?
     assert_equal 0, headers.length
+    assert_includes Wreq::Headers.ancestors, Enumerable
   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
+  def test_collection_api_methods_are_available
+    collection_methods = [:[], :[]=, :fetch, :delete, :size, :to_a, :to_h, :to_hash, :each]
+
+    collection_methods.each do |method|
+      assert_respond_to @headers, method
+    end
   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")
+  def test_initialize_from_hash_and_headers
+    headers = Wreq::Headers.new("Accept" => "application/json")
+    copy = Wreq::Headers.new(headers)
 
-    assert_equal value1, value2
-    assert_equal value2, value3
-  end
+    headers["Accept"] = "text/plain"
 
-  def test_get_nonexistent_header
-    result = @headers.get("X-Nonexistent-Header-12345")
-    assert_nil result
+    assert_equal "text/plain", headers["Accept"]
+    assert_equal "application/json", copy["Accept"]
   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
+  def test_initialize_from_enumerable_pairs
+    source = Class.new do
+      include Enumerable
+
+      def each
+        yield "X-First", "one"
+        yield :set_cookie, ["a=1", "b=2"]
+      end
+    end.new
+
+    headers = Wreq::Headers.new(source)
+
+    assert_includes headers.keys, "x-first"
+    assert_includes headers.keys, "set-cookie"
+    assert_equal ["a=1", "b=2"], headers[:set_cookie]
   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
+  def test_initialize_rejects_invalid_sources_and_pairs
+    assert_raises(Wreq::BuilderError) { Wreq::Headers.new(Object.new) }
+    assert_raises(Wreq::BuilderError) { Wreq::Headers.new([["Accept"]]) }
+    assert_raises(ArgumentError) { Wreq::Headers.new({}, {}) }
   end
 
-  def test_set_new_header
-    headers = Wreq::Headers.new
-    headers.set("X-Test-Header", "test-value")
+  def test_string_and_symbol_names_are_normalized
+    headers = Wreq::Headers.new(
+      "x-CuStOm-Header" => "value",
+      content_type: "application/json"
+    )
 
-    assert_equal "test-value", headers.get("X-Test-Header")
-    assert_equal 1, headers.length
+    assert_includes headers.keys, "x-custom-header"
+    assert_includes headers.keys, "content-type"
+    assert_equal "value", headers["X-CUSTOM-HEADER"]
+    assert_equal "application/json", headers[:content_type]
   end
 
-  def test_set_replaces_existing
-    headers = Wreq::Headers.new
-    headers.set("X-Test", "value1")
-    headers.set("X-Test", "value2")
+  def test_get_returns_first_value
+    headers = Wreq::Headers.new("Accept" => ["application/json", "text/plain"])
 
-    assert_equal "value2", headers.get("X-Test")
-    values = headers.get_all("X-Test")
-    assert_equal 1, values.length
-    assert_equal "value2", values.first
+    assert_equal "application/json", headers.get("accept")
+    assert_equal "application/json", headers.get(:accept)
+    assert_nil headers.get(:missing)
   end
 
-  def test_append_to_new_header
-    headers = Wreq::Headers.new
-    headers.append("Accept", "application/json")
+  def test_index_uses_nil_string_and_array_shapes
+    headers = Wreq::Headers.new(
+      "Accept" => "application/json",
+      "Set-Cookie" => ["a=1", "b=2"]
+    )
 
-    assert_equal "application/json", headers.get("Accept")
+    assert_nil headers["Missing"]
+    assert_equal "application/json", headers["Accept"]
+    assert_equal ["a=1", "b=2"], headers["Set-Cookie"]
   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")
+  def test_get_all_always_returns_an_array
+    assert_equal ["application/json"], @headers.get_all("CONTENT-TYPE")
+    assert_equal [], @headers.get_all("Missing")
+  end
+
+  def test_set_replaces_existing_occurrences
+    headers = Wreq::Headers.new("Accept" => ["application/json", "text/plain"])
+
+    headers.set("Accept", ["text/html", "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"
+    assert_equal ["text/html", "application/xml"], headers.get_all("Accept")
+    assert_equal 2, headers.length
   end
 
-  def test_remove_existing_header
-    headers = Wreq::Headers.new
-    headers.set("X-Remove-Me", "value")
+  def test_index_assignment_replaces_existing_occurrences
+    headers = Wreq::Headers.new("Set-Cookie" => "old=1")
 
-    removed_value = headers.remove("X-Remove-Me")
-    assert_equal "value", removed_value
-    assert_nil headers.get("X-Remove-Me")
+    assigned = headers.public_send(:[]=, :set_cookie, ["a=1", "b=2"])
+
+    assert_equal ["a=1", "b=2"], assigned
+    assert_equal ["a=1", "b=2"], headers.get_all("Set-Cookie")
   end
 
-  def test_remove_nonexistent_header
+  def test_append_keeps_values_as_separate_occurrences
     headers = Wreq::Headers.new
-    result = headers.remove("X-Nonexistent")
-    assert_nil result
+    headers.append("Set-Cookie", "a=1")
+    headers.append("Set-Cookie", ["b=2", "c=3"])
+
+    assert_equal ["a=1", "b=2", "c=3"], headers.get_all("Set-Cookie")
+    refute_includes headers.get_all("Set-Cookie"), "a=1,b=2,c=3"
   end
 
-  def test_delete_alias
+  def test_set_and_append_return_nil
     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")
+    assert_nil headers.set("Accept", "application/json")
+    assert_nil headers.append("Accept", "text/plain")
   end
 
-  def test_contains_existing
-    assert @headers.contains?("Content-Type")
-  end
+  def test_empty_array_values_remove_or_leave_headers_unchanged
+    headers = Wreq::Headers.new("Accept" => "application/json")
+
+    assert_nil headers.set("Accept", [])
+    refute headers.key?("Accept")
 
-  def test_contains_nonexistent
-    refute @headers.contains?("X-Nonexistent-Header-12345")
+    assert_nil headers.append("X-Empty", [])
+    refute headers.key?("X-Empty")
   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
+  def test_fetch_existing_and_missing_values
+    assert_equal "application/json", @headers.fetch(:content_type)
+    assert_equal "fallback", @headers.fetch("Missing", "fallback")
+    assert_equal "MISSING", @headers.fetch("Missing") { |name| name.upcase }
+    assert_raises(KeyError) { @headers.fetch("Missing") }
   end
 
-  def test_key_alias
-    # key? is an alias for contains?
-    assert_equal @headers.contains?("Content-Type"), @headers.key?("Content-Type")
+  def test_fetch_block_takes_precedence_over_default
+    result = @headers.fetch("Missing", "fallback") { "from block" }
+
+    assert_equal "from block", result
   end
 
-  def test_length
-    headers = Wreq::Headers.new
-    assert_equal 0, headers.length
+  def test_fetch_preserves_repeated_values_and_explicit_nil_default
+    headers = Wreq::Headers.new("Set-Cookie" => ["a=1", "b=2"])
 
-    headers.set("Header1", "value1")
-    assert_equal 1, headers.length
+    assert_equal ["a=1", "b=2"], headers.fetch(:set_cookie)
+    assert_nil headers.fetch("Missing", nil)
+  end
 
-    headers.set("Header2", "value2")
-    assert_equal 2, headers.length
+  def test_remove_and_delete_remove_every_occurrence
+    headers = Wreq::Headers.new("Set-Cookie" => ["a=1", "b=2"])
 
-    # Setting same header shouldn't increase length
-    headers.set("Header1", "new-value")
-    assert_equal 2, headers.length
+    assert_equal "a=1", headers.delete(:set_cookie)
+    assert_nil headers["Set-Cookie"]
+    assert_nil headers.remove("Set-Cookie")
   end
 
-  def test_empty_on_new_headers
-    headers = Wreq::Headers.new
-    assert headers.empty?
+  def test_contains_and_key_are_case_insensitive
+    assert @headers.contains?("CONTENT-TYPE")
+    assert @headers.contains?(:content_type)
+    assert @headers.key?("content-type")
+    refute @headers.key?("Missing")
   end
 
-  def test_empty_on_headers_with_data
-    refute @headers.empty?
+  def test_length_counts_occurrences_and_keys_are_unique
+    headers = Wreq::Headers.new(
+      "Accept" => ["application/json", "text/plain"],
+      "Content-Type" => "application/json"
+    )
+
+    assert_equal 3, headers.length
+    assert_equal 3, headers.size
+    assert_equal 2, headers.keys.length
   end
 
-  def test_clear
-    headers = Wreq::Headers.new
-    headers.set("Header1", "value1")
-    headers.set("Header2", "value2")
+  def test_clear_returns_self
+    headers = Wreq::Headers.new("Accept" => "application/json")
 
-    refute headers.empty?
-    headers.clear
+    assert_same headers, 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")
+  def test_values_include_every_occurrence
+    headers = Wreq::Headers.new("Accept" => ["application/json", "text/plain"])
 
-    keys = headers.keys
-    assert_instance_of Array, keys
-    assert_equal 2, keys.length
-    assert_includes keys, "content-type"
-    assert_includes keys, "authorization"
+    assert_equal ["application/json", "text/plain"], headers.values
   end
 
-  def test_keys_are_lowercase
-    headers = Wreq::Headers.new
-    headers.set("Content-Type", "text/html")
-    headers.set("X-Custom-Header", "value")
+  def test_each_yields_every_occurrence_and_returns_self
+    headers = Wreq::Headers.new("Set-Cookie" => ["a=1", "b=2"])
+    pairs = []
 
-    keys = headers.keys
-    keys.each do |key|
-      assert_equal key, key.downcase
-    end
+    returned = headers.each { |name, value| pairs << [name, value] }
+
+    assert_same headers, returned
+    assert_equal [["set-cookie", "a=1"], ["set-cookie", "b=2"]], pairs
   end
 
-  def test_values
-    headers = Wreq::Headers.new
-    headers.set("Content-Type", "application/json")
-    headers.set("Authorization", "Bearer token")
+  def test_each_without_a_block_returns_chainable_enumerator
+    headers = Wreq::Headers.new(
+      "Accept" => "application/json",
+      "Set-Cookie" => ["a=1", "b=2"]
+    )
+
+    enumerator = headers.each
+    cookies = enumerator.select { |name, _value| name == "set-cookie" }
 
-    values = headers.values
-    assert_instance_of Array, values
-    assert_equal 2, values.length
-    assert_includes values, "application/json"
-    assert_includes values, "Bearer token"
+    assert_instance_of Enumerator, enumerator
+    assert_equal [["set-cookie", "a=1"], ["set-cookie", "b=2"]], cookies
   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
+  def test_each_allows_mutating_headers_from_the_block
+    headers = Wreq::Headers.new("X-First" => "one")
+    yielded_names = []
+
+    headers.each do |name, _value|
+      yielded_names << name
+      headers["X-Added"] = "two"
     end
 
-    assert_equal 2, collected.length
-    assert_equal "value1", collected["header1"]
-    assert_equal "value2", collected["header2"]
+    assert_equal ["x-first"], yielded_names
+    assert_equal "two", headers["X-Added"]
   end
 
-  def test_multiple_operations_sequence
-    headers = Wreq::Headers.new
+  def test_enumerable_methods_use_each
+    headers = Wreq::Headers.new(
+      "Accept" => "application/json",
+      "Set-Cookie" => ["a=1", "b=2"]
+    )
 
-    # Add headers
-    headers.set("Content-Type", "application/json")
-    headers.set("Accept", "application/json")
+    cookies = headers.select { |name, _value| name == "set-cookie" }
 
-    assert_equal 2, headers.length
+    assert_equal [["set-cookie", "a=1"], ["set-cookie", "b=2"]], cookies
+  end
 
-    # Append to Accept
-    headers.append("Accept", "text/html")
-    assert_equal 2, headers.get_all("Accept").length
+  def test_to_a_and_to_h_preserve_duplicate_values
+    headers = Wreq::Headers.new(
+      "Accept" => "application/json",
+      "Set-Cookie" => ["a=1", "b=2"]
+    )
 
-    # Clear all
-    headers.clear
-    assert headers.empty?
+    expected_pairs = [
+      ["accept", "application/json"],
+      ["set-cookie", "a=1"],
+      ["set-cookie", "b=2"]
+    ]
+    assert_equal expected_pairs.sort, headers.to_a.sort
+    assert_equal({
+      "accept" => "application/json",
+      "set-cookie" => ["a=1", "b=2"]
+    }, headers.to_h)
+    assert_equal headers.to_h, headers.to_hash
   end
 
   def test_special_characters_in_header_values
+    value = "Bearer token-123_abc/xyz+456=789"
+    @headers.set("Authorization", value)
+
+    assert_equal value, @headers.get("Authorization")
+  end
+
+  def test_invalid_header_names_and_values_raise_builder_error
     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")
+    assert_raises(Wreq::BuilderError) { headers.set(123, "value") }
+    assert_raises(Wreq::BuilderError) { headers.set("Bad\nName", "value") }
+    assert_raises(Wreq::BuilderError) { headers.set("X-Test", 123) }
+    assert_raises(Wreq::BuilderError) { headers.append("X-Test", ["valid", 123]) }
+    assert headers.empty?
   end
 
-  def test_response_headers_integration
-    # Test that headers from actual HTTP response work correctly
-    assert_instance_of Wreq::Headers, @headers
-    refute @headers.empty?
+  def test_header_entry_limit_raises_builder_error_without_partial_update
+    headers = Wreq::Headers.new
+    values = Array.new(32_769, "value")
 
-    # Should have common HTTP headers
-    assert @headers.length > 0
+    error = assert_raises(Wreq::BuilderError) { headers.append("X-Large", values) }
+
+    assert_match(/32,768/, error.message)
+    assert headers.empty?
   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
+  def test_response_headers_integration
+    headers = response_headers
+    pairs = headers.each.to_a
 
-    assert count > 0
-    assert_equal @headers.length, count
+    assert_instance_of Wreq::Headers, headers
+    refute headers.empty?
+    assert headers.contains?("Content-Type")
+    assert_equal headers.length, pairs.length
   end
 
-  def test_headers_immutability_across_instances
-    headers1 = Wreq::Headers.new
-    headers2 = Wreq::Headers.new
+  def test_response_headers_are_fresh_mutable_snapshots
+    response = Wreq.get("#{HTTPBIN_URL}/response-headers", query: {"X-Test" => "original"})
+    first = response.headers
+    second = response.headers
+
+    refute_same first, second
+    first["X-Test"] = "changed"
+    first["X-Local"] = "value"
+
+    assert_equal "changed", first["X-Test"]
+    assert_equal "original", second["X-Test"]
+    assert_nil second["X-Local"]
+    assert_equal "original", response.headers["X-Test"]
+  end
 
-    headers1.set("X-Test", "value1")
-    headers2.set("X-Test", "value2")
+  private
 
-    assert_equal "value1", headers1.get("X-Test")
-    assert_equal "value2", headers2.get("X-Test")
+  def response_headers
+    Wreq.get(
+      "#{HTTPBIN_URL}/response-headers",
+      query: {"X-Custom-Header" => "custom-value"}
+    ).headers
   end
 end

data/test/stream_test.rb

@@ -1,5 +1,6 @@
 require "test_helper"
 require "socket"
+require "timeout"
 
 class StreamTest < Minitest::Test
   def test_simple_push_stream
@@ -174,6 +175,41 @@ class StreamTest < Minitest::Test
     assert killed, "Connect+timeout phase should be interruptible"
   end
 
+  def test_thread_raise_propagates_ruby_interrupt
+    server = TCPServer.new("127.0.0.1", 0)
+    accepted = Queue.new
+    errors = Queue.new
+
+    server_thread = Thread.new do
+      socket = server.accept
+      accepted << true
+      sleep
+    ensure
+      socket&.close
+    end
+
+    request_thread = Thread.new do
+      Wreq.get("http://127.0.0.1:#{server.addr[1]}/", timeout: 60)
+    rescue Interrupt, StandardError => error
+      errors << error
+    end
+
+    Timeout.timeout(5) { accepted.pop }
+    request_thread.raise(Interrupt, "test interrupt")
+
+    assert request_thread.join(5), "Interrupted request thread should stop"
+
+    error = Timeout.timeout(1) { errors.pop }
+    assert_instance_of Interrupt, error
+    assert_equal "test interrupt", error.message
+  ensure
+    request_thread&.kill
+    request_thread&.join(1)
+    server_thread&.kill
+    server_thread&.join(1)
+    server&.close
+  end
+
   def test_thread_interrupt_body_reading
     url = "#{HTTPBIN_URL}/drip?duration=5&numbytes=5"
     thread = Thread.new do

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: wreq
 version: !ruby/object:Gem::Version
-  version: 1.2.4
+  version: 1.2.5
 platform: ruby
 authors:
 - SearchApi
@@ -27,6 +27,58 @@ files:
 - README.md
 - Rakefile
 - build.rs
+- crates/wreq-util/.github/FUNDING.yml
+- crates/wreq-util/.github/ISSUE_TEMPLATE/bug_report.md
+- crates/wreq-util/.github/ISSUE_TEMPLATE/custom.md
+- crates/wreq-util/.github/ISSUE_TEMPLATE/feature_request.md
+- crates/wreq-util/.github/dependabot.yml
+- crates/wreq-util/.github/workflows/ci.yml
+- crates/wreq-util/.github/workflows/release-plz.yml
+- crates/wreq-util/.gitignore
+- crates/wreq-util/CHANGELOG.md
+- crates/wreq-util/Cargo.toml
+- crates/wreq-util/LICENSE
+- crates/wreq-util/README.md
+- crates/wreq-util/examples/emulate.rs
+- crates/wreq-util/examples/tower_delay.rs
+- crates/wreq-util/release-plz.toml
+- crates/wreq-util/rustfmt.toml
+- crates/wreq-util/src/emulate.rs
+- crates/wreq-util/src/emulate/compress.rs
+- crates/wreq-util/src/emulate/macros.rs
+- crates/wreq-util/src/emulate/profile.rs
+- crates/wreq-util/src/emulate/profile/chrome.rs
+- crates/wreq-util/src/emulate/profile/chrome/header.rs
+- crates/wreq-util/src/emulate/profile/chrome/http2.rs
+- crates/wreq-util/src/emulate/profile/chrome/tls.rs
+- crates/wreq-util/src/emulate/profile/firefox.rs
+- crates/wreq-util/src/emulate/profile/firefox/header.rs
+- crates/wreq-util/src/emulate/profile/firefox/http2.rs
+- crates/wreq-util/src/emulate/profile/firefox/tls.rs
+- crates/wreq-util/src/emulate/profile/okhttp.rs
+- crates/wreq-util/src/emulate/profile/opera.rs
+- crates/wreq-util/src/emulate/profile/opera/header.rs
+- crates/wreq-util/src/emulate/profile/opera/http2.rs
+- crates/wreq-util/src/emulate/profile/opera/tls.rs
+- crates/wreq-util/src/emulate/profile/safari.rs
+- crates/wreq-util/src/emulate/profile/safari/header.rs
+- crates/wreq-util/src/emulate/profile/safari/http2.rs
+- crates/wreq-util/src/emulate/profile/safari/tls.rs
+- crates/wreq-util/src/lib.rs
+- crates/wreq-util/src/rand.rs
+- crates/wreq-util/src/tower.rs
+- crates/wreq-util/src/tower/delay.rs
+- crates/wreq-util/src/tower/delay/future.rs
+- crates/wreq-util/src/tower/delay/layer.rs
+- crates/wreq-util/src/tower/delay/service.rs
+- crates/wreq-util/tests/client.rs
+- crates/wreq-util/tests/emulate_chrome.rs
+- crates/wreq-util/tests/emulate_firefox.rs
+- crates/wreq-util/tests/emulate_okhttp.rs
+- crates/wreq-util/tests/emulate_opera.rs
+- crates/wreq-util/tests/emulate_safari.rs
+- crates/wreq-util/tests/support/mod.rs
+- crates/wreq-util/tests/support/server.rs
 - docs/windows-gnu-tokio-crash.md
 - examples/body.rb
 - examples/client.rb
@@ -65,6 +117,7 @@ files:
 - src/extractor.rs
 - src/gvl.rs
 - src/header.rs
+- src/header/helper.rs
 - src/http.rs
 - src/lib.rs
 - src/macros.rs