wreq 1.2.3-x64-mingw-ucrt

data/test/stream_test.rb

@@ -0,0 +1,397 @@
+require "test_helper"
+require "socket"
+
+class StreamTest < Minitest::Test
+  def test_simple_push_stream
+    client = Wreq::Client.new
+    sender = Wreq::BodySender.new(4)
+    producer = Thread.new do
+      3.times { |i| sender.push("chunk-#{i}\n") }
+      sender.close
+    end
+
+    resp = client.post("#{HTTPBIN_URL}/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
+
+  def test_response_body_chunks_stream
+    client = Wreq::Client.new
+    resp = client.get("#{HTTPBIN_URL}/stream/5")
+    chunks = []
+
+    resp.chunks do |chunk|
+      chunks << chunk
+      assert_kind_of String, chunk, "Each yielded chunk must be a String"
+      assert_match(/\{.*\}/, chunk)
+    end
+
+    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("#{HTTPBIN_URL}/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("#{HTTPBIN_URL}/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("#{HTTPBIN_URL}/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("#{HTTPBIN_URL}/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("#{HTTPBIN_URL}/stream/3")
+
+    assert_raises(LocalJumpError) do
+      resp.chunks
+    end
+  end
+
+  def test_other_threads_run_during_streaming
+    client = Wreq::Client.new
+    resp = client.get("#{HTTPBIN_URL}/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("#{HTTPBIN_URL}/stream/3")
+      chunks = []
+      resp.chunks { |chunk| chunks << chunk }
+      results[:t1] = chunks.size
+      done[:t1] = true
+    end
+
+    t2 = Thread.new do
+      resp = client.get("#{HTTPBIN_URL}/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
+    url = "http://10.255.255.1:12345/"
+    thread = Thread.new do
+      Wreq.get(url)
+    rescue => _
+    end
+
+    sleep 2
+    thread.kill
+    killed = thread.join(5)
+
+    assert killed, "Connect phase should be interruptible"
+  end
+
+  def test_thread_interrupt_connect_with_timeout
+    url = "http://10.255.255.1:12345/"
+    thread = Thread.new do
+      Wreq.get(url, timeout: 60)
+    rescue => _
+    end
+
+    sleep 2
+    thread.kill
+    killed = thread.join(5)
+
+    assert killed, "Connect+timeout phase should be interruptible"
+  end
+
+  def test_thread_interrupt_body_reading
+    url = "#{HTTPBIN_URL}/drip?duration=5&numbytes=5"
+    thread = Thread.new do
+      resp = Wreq.get(url)
+      resp.text
+    rescue => _
+    end
+
+    sleep 2
+    thread.kill
+    killed = thread.join(5)
+
+    assert killed, "Body reading should be interruptible"
+  end
+
+  def test_thread_interrupt_body_streaming
+    url = "#{HTTPBIN_URL}/drip?duration=5&numbytes=5"
+    thread = Thread.new do
+      resp = Wreq.get(url)
+      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 = "#{HTTPBIN_URL}/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
+
+    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
+
+      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("#{HTTPBIN_URL}/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("#{HTTPBIN_URL}/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("#{HTTPBIN_URL}/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("#{HTTPBIN_URL}/bytes/4096")
+    full_bytes = resp_full.bytes
+
+    resp_stream = client.get("#{HTTPBIN_URL}/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("#{HTTPBIN_URL}/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("#{HTTPBIN_URL}/stream/3")
+    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("#{HTTPBIN_URL}/stream/3")
+
+    resp.chunks { |_chunk| }
+    resp.close
+  end
+
+  def test_chunks_via_module_method
+    resp = Wreq.get("#{HTTPBIN_URL}/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("#{HTTPBIN_URL}/stream/3")
+    chunks = []
+
+    resp.chunks do |chunk|
+      chunks << chunk
+    end
+
+    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

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+$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

data/wreq.gemspec

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require "json"
+
+Gem::Specification.new do |spec|
+  spec.name = "wreq"
+  # RubyGems integrates and expects `cargo`.
+  # Read more about
+  # [Gem::Ext::CargoBuilder](https://github.com/rubygems/rubygems/blob/v3.5.23/lib/rubygems/ext/cargo_builder.rb)
+  #
+  # wreq relies on "version" in `Cargo.toml` for the release process. You can read this gem spec with:
+  # `bundle exec ruby -e 'puts Gem::Specification.load("wreq.gemspec")'`
+  #
+  # keep in sync the key "wreq-ruby" with `Rakefile`.
+  #
+  # uses `cargo` to extract the version.
+  cargo_output = `cargo metadata --format-version 1`
+  cargo_output.force_encoding("UTF-8")
+  spec.version = JSON.parse(cargo_output.strip)
+    .fetch("packages")
+    .find { |p| p["name"] == "wreq-ruby" }
+    .fetch("version")
+  spec.authors = ["SearchApi"]
+  spec.email = ["support@searchapi.io"]
+  spec.summary = "Ruby bindings for wreq, an HTTP client with TLS/HTTP2 browser fingerprinting"
+  spec.description = "An easy and powerful Ruby HTTP client with advanced browser fingerprinting " \
+                     "that accurately emulates Chrome, Edge, Firefox, Safari, Opera, and OkHttp " \
+                     "with precise TLS/HTTP2 signatures. Powered by wreq (Rust) and BoringSSL."
+  spec.homepage = "https://github.com/SearchApi/wreq-ruby"
+  spec.license = "Apache-2.0"
+  spec.metadata = {
+    "bug_tracker_uri" => "https://github.com/SearchApi/wreq-ruby/issues",
+    "changelog_uri" => "https://github.com/SearchApi/wreq-ruby/releases",
+    "documentation_uri" => "https://github.com/SearchApi/wreq-ruby#readme",
+    "homepage_uri" => spec.homepage,
+    "source_code_uri" => "https://github.com/SearchApi/wreq-ruby",
+    "rubygems_mfa_required" => "true"
+  }
+
+  # Specify which files should be added to a source release gem when we release wreq Ruby gem.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files = Dir.chdir(__dir__) do
+    git_output = `git ls-files -z`
+    git_output.force_encoding("UTF-8")
+    git_output.split("\x0").reject do |f|
+      f.start_with?(*%w[gems/ pkg/ target/ tmp/ .git]) ||
+        f.match?(/\.gem$/) || # Exclude gem files
+        f.match?(/^wreq-.*\.gem$/)  # Exclude any wreq gem files
+    end
+  end
+
+  spec.require_paths = ["lib"]
+
+  spec.extensions = ["./extconf.rb"]
+
+  # Exclude non-Ruby files from RDoc to prevent parsing errors
+  spec.rdoc_options = ["--exclude", "Cargo\\..*", "--exclude", "\\.rs$"]
+
+  spec.requirements = ["Rust >= 1.85"]
+  # use a Ruby version which:
+  # - supports Rubygems with the ability of compilation of Rust gem
+  # - not end of life
+  #
+  # keep in sync with `Rakefile`.
+  spec.required_ruby_version = ">= 3.3"
+
+  # intentionally skipping rb_sys gem because newer Rubygems will be present
+end

metadata

@@ -0,0 +1,123 @@
+--- !ruby/object:Gem::Specification
+name: wreq
+version: !ruby/object:Gem::Version
+  version: 1.2.3
+platform: x64-mingw-ucrt
+authors:
+- SearchApi
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies: []
+description: An easy and powerful Ruby HTTP client with advanced browser fingerprinting
+  that accurately emulates Chrome, Edge, Firefox, Safari, Opera, and OkHttp with precise
+  TLS/HTTP2 signatures. Powered by wreq (Rust) and BoringSSL.
+email:
+- support@searchapi.io
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- Cargo.lock
+- Cargo.toml
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- build.rs
+- docs/windows-gnu-tokio-crash.md
+- examples/body.rb
+- examples/client.rb
+- examples/cookie.rb
+- examples/emulate_request.rb
+- examples/headers.rb
+- examples/proxy.rb
+- examples/send_stream.rb
+- examples/stream.rb
+- examples/thread_interrupt.rb
+- extconf.rb
+- lib/wreq.rb
+- lib/wreq_ruby/3.3/wreq_ruby.so
+- lib/wreq_ruby/3.4/wreq_ruby.so
+- lib/wreq_ruby/4.0/wreq_ruby.so
+- lib/wreq_ruby/body.rb
+- lib/wreq_ruby/client.rb
+- lib/wreq_ruby/cookie.rb
+- lib/wreq_ruby/emulate.rb
+- lib/wreq_ruby/error.rb
+- lib/wreq_ruby/header.rb
+- 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
+- src/client/body/json.rs
+- src/client/body/stream.rs
+- src/client/param.rs
+- src/client/query.rs
+- src/client/req.rs
+- src/client/resp.rs
+- src/cookie.rs
+- src/emulate.rs
+- src/error.rs
+- src/extractor.rs
+- src/gvl.rs
+- src/header.rs
+- src/http.rs
+- src/lib.rs
+- src/macros.rs
+- src/rt.rs
+- test/client_cookie_test.rb
+- test/client_test.rb
+- test/cookie_test.rb
+- test/emulation_test.rb
+- test/error_handling_test.rb
+- test/header_test.rb
+- test/inspect_test.rb
+- test/module_methods_test.rb
+- test/orig_header_test.rb
+- test/request_parameters_test.rb
+- test/request_test.rb
+- test/response_test.rb
+- test/stream_test.rb
+- test/test_helper.rb
+- wreq.gemspec
+homepage: https://github.com/SearchApi/wreq-ruby
+licenses:
+- Apache-2.0
+metadata:
+  bug_tracker_uri: https://github.com/SearchApi/wreq-ruby/issues
+  changelog_uri: https://github.com/SearchApi/wreq-ruby/releases
+  documentation_uri: https://github.com/SearchApi/wreq-ruby#readme
+  homepage_uri: https://github.com/SearchApi/wreq-ruby
+  source_code_uri: https://github.com/SearchApi/wreq-ruby
+  rubygems_mfa_required: 'true'
+rdoc_options:
+- "--exclude"
+- Cargo\..*
+- "--exclude"
+- "\\.rs$"
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.3'
+  - - "<"
+    - !ruby/object:Gem::Version
+      version: 4.1.dev
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements:
+- Rust >= 1.85
+rubygems_version: 4.0.10
+specification_version: 4
+summary: Ruby bindings for wreq, an HTTP client with TLS/HTTP2 browser fingerprinting
+test_files: []