wreq 1.0.0

data/test/request_test.rb

@@ -0,0 +1,234 @@
+require "test_helper"
+
+class WreqHttpbinTest < Minitest::Test
+  def setup
+    # Ensure we have a working client
+    @client = Wreq::Client.new(timeout: 30)
+  end
+
+  def test_module_get_method
+    response = Wreq.get("http://localhost:8080/get")
+    assert_equal 200, response.code
+    assert_respond_to response, :text
+  end
+
+  def test_module_post_with_json
+    data = {name: "wreq-ruby", version: "0.1.0"}
+    response = Wreq.post("http://localhost:8080/post", json: data)
+    assert_equal 200, response.code
+  end
+
+  def test_client_instance_basic
+    response = @client.get("http://localhost:8080/get")
+    assert_equal 200, response.code
+  end
+
+  def test_client_with_custom_headers
+    headers = {"User-Agent" => "wreq-ruby/test", "Accept" => "application/json"}
+    response = @client.get("http://localhost:8080/headers", headers: headers)
+    assert_equal 200, response.code
+  end
+
+  def test_all_http_methods_client
+    methods = [
+      Wreq::Method::GET,
+      Wreq::Method::POST,
+      Wreq::Method::PUT,
+      Wreq::Method::DELETE,
+      Wreq::Method::PATCH,
+      Wreq::Method::HEAD,
+      Wreq::Method::OPTIONS
+    ]
+
+    methods.each do |method|
+      response = @client.request(method, "http://localhost:8080/#{method}")
+      assert [200, 405].include?(response.code), "client.#{method} failed with status #{response.code}"
+    end
+  end
+
+  def test_request_with_query_params
+    params = {"param1" => "value1", "param2" => "value2", "param3" => 123, "param4" => true}
+    response = Wreq.get("http://localhost:8080/get", query: params)
+    assert_equal 200, response.code
+    assert_includes response.text, "param1=value1"
+    assert_includes response.text, "param2=value2"
+    assert_includes response.text, "param3=123"
+    assert_includes response.text, "param4=true"
+  end
+
+  def test_post_with_form_data
+    data = {"field1" => "value1", "field2" => "value2", "field3" => 456, "field4" => false}
+    response = Wreq.post("http://localhost:8080/post", form: data)
+    assert_equal 200, response.code
+    assert_includes response.text, "field1"
+    assert_includes response.text, "value1"
+    assert_includes response.text, "field2"
+    assert_includes response.text, "value2"
+    assert_includes response.text, "field3"
+    assert_includes response.text, "456"
+    assert_includes response.text, "field4"
+    assert_includes response.text, "false"
+  end
+
+  def test_post_with_raw_body
+    body = "This is raw body content"
+    headers = {"Content-Type" => "text/plain"}
+    response = Wreq.post("http://localhost:8080/post", body: body, headers: headers)
+    assert_equal 200, response.code
+    assert_includes response.text, body
+  end
+
+  def test_basic_authentication
+    response = Wreq.get("http://localhost:8080/basic-auth/user/pass", basic_auth: ["user", "pass"])
+    assert_equal 200, response.code
+  end
+
+  def test_bearer_authentication
+    response = Wreq.get("http://localhost:8080/bearer", bearer_auth: "test-token")
+    assert_equal 200, response.code
+  end
+
+  def test_redirect_following
+    response = Wreq.get("http://localhost:8080/redirect/2", allow_redirects: true)
+    assert_equal 200, response.code
+  end
+
+  def test_redirect_blocking
+    response = Wreq.get("http://localhost:8080/redirect/1", allow_redirects: false)
+    assert_equal 302, response.code
+  end
+
+  def test_response_status_methods
+    response = Wreq.get("http://localhost:8080/status/200")
+    assert_equal 200, response.code
+
+    if response.status.respond_to?(:success?)
+      assert response.status.success?
+    end
+  end
+
+  def test_404_response
+    response = Wreq.get("http://localhost:8080/status/404")
+    assert_equal 404, response.code
+
+    if response.status.respond_to?(:client_error?)
+      assert response.status.client_error?
+    end
+  end
+
+  def test_json_response_parsing
+    response = Wreq.get("http://localhost:8080/json")
+    assert_equal 200, response.code
+
+    if response.respond_to?(:json)
+      json_data = response.json
+      assert json_data.is_a?(Hash)
+    end
+  end
+
+  def test_gzip_compression
+    response = Wreq.get("http://localhost:8080/gzip", gzip: true)
+    assert_equal 200, response.code
+  end
+
+  def test_headers_iteration
+    response = Wreq.get("http://localhost:8080/get")
+
+    if response.respond_to?(:each_header)
+      count = 0
+      response.each_header do |name, value|
+        assert name.is_a?(String)
+        assert value.is_a?(String)
+        count += 1
+        break if count >= 5  # Just test first few
+      end
+      assert count > 0, "Should iterate over at least one header"
+    end
+  end
+
+  def test_response_properties
+    response = Wreq.get("http://localhost:8080/get")
+
+    assert_respond_to response, :code
+    assert_respond_to response, :status
+    assert_respond_to response, :version
+    assert_respond_to response, :url
+
+    assert response.code.is_a?(Integer)
+    assert response.url.is_a?(String)
+  end
+
+  def test_timeout_functionality
+    # Test that short timeouts properly raise exceptions
+    assert_raises(Wreq::TimeoutError) do
+      Wreq.get("http://localhost:8080/delay/10", timeout: 1)
+    end
+
+    # Test that reasonable timeouts work normally
+    start_time = Time.now
+    response = Wreq.get("http://localhost:8080/delay/1", timeout: 5)
+    elapsed = Time.now - start_time
+
+    assert_equal 200, response.code
+    assert elapsed < 5, "Request should complete within timeout"
+  end
+
+  def test_multiple_requests_performance
+    start_time = Time.now
+
+    3.times do |i|
+      response = Wreq.get("http://localhost:8080/get?request=#{i}")
+      assert_equal 200, response.code
+    end
+
+    elapsed = Time.now - start_time
+    assert elapsed < 30, "3 requests should complete within 30 seconds"
+  end
+
+  def test_error_handling
+    assert_raises do
+      Wreq.get("https://this-domain-does-not-exist-12345.com")
+    end
+  end
+
+  def test_client_configuration
+    client = Wreq::Client.new(
+      timeout: 10,
+      headers: {"User-Agent" => "wreq-ruby-test"},
+      allow_redirects: false
+    )
+
+    # Test that client was created successfully
+    assert_instance_of Wreq::Client, client
+
+    # Test that it can make requests
+    response = client.get("http://localhost:8080/get")
+    assert_equal 200, response.code
+  end
+
+  def test_enum_constants
+    # Test Method enum
+    assert_const_defined "Wreq::Method"
+    if defined?(Wreq::Method)
+      %w[GET POST PUT DELETE HEAD PATCH OPTIONS].each do |method|
+        assert Wreq::Method.const_defined?(method), "Method::#{method} should be defined"
+      end
+    end
+
+    # Test Version enum
+    assert_const_defined "Wreq::Version"
+    if defined?(Wreq::Version)
+      %w[HTTP_11 HTTP_2].each do |version|
+        assert Wreq::Version.const_defined?(version), "Version::#{version} should be defined"
+      end
+    end
+  end
+
+  private
+
+  def assert_const_defined(const_name)
+    const_name.split("::").inject(Object) { |o, c| o.const_get(c) }
+  rescue NameError
+    flunk "#{const_name} should be defined"
+  end
+end

data/test/response_test.rb

@@ -0,0 +1,69 @@
+require "test_helper"
+
+class ResponseTest < Minitest::Test
+  def setup
+    @response = Wreq.get("http://localhost:8080/json")
+  end
+
+  def test_response_code
+    assert_respond_to @response, :code
+    assert_instance_of Integer, @response.code
+    assert_equal 200, @response.code
+  end
+
+  def test_response_text
+    assert_respond_to @response, :text
+    assert_instance_of String, @response.text
+    assert @response.text.length > 0
+  end
+
+  def test_response_json
+    assert_respond_to @response, :json
+    json_data = @response.json
+    assert_instance_of Hash, json_data
+
+    # httpbin.io/json returns a specific JSON structure
+    assert json_data.key?("slideshow")
+  end
+
+  def test_response_each_header
+    assert_respond_to @response, :headers
+
+    header_count = 0
+    @response.headers.each do |name, value|
+      assert_instance_of String, name
+      assert_instance_of String, value
+      header_count += 1
+    end
+    assert header_count > 0
+  end
+
+  def test_response_with_non_json_content
+    response = Wreq.get("http://localhost:8080/html")
+    assert_equal 200, response.code
+    assert_instance_of String, response.text
+    assert response.text.include?("<html>")
+
+    # JSON parsing should fail for HTML content
+    assert_raises(StandardError) { response.json }
+  end
+
+  def test_response_status_codes
+    # Test different status codes
+    [200, 404, 500].each do |status|
+      response = Wreq.get("http://localhost:8080/status/#{status}")
+      assert_equal status, response.code
+    end
+  end
+
+  def test_response_with_query_parameters
+    response = Wreq.get("http://localhost:8080/get",
+      query: {"param1" => "value1", "param2" => "value2"})
+    assert_equal 200, response.code
+
+    json_data = response.json
+    args = json_data["args"]
+    assert_equal "value1", args["param1"]
+    assert_equal "value2", args["param2"]
+  end
+end

data/test/stream_test.rb

@@ -0,0 +1,81 @@
+require "test_helper"
+
+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("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
+
+  def test_response_body_chunks_stream
+    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_match(/\{.*\}/, chunk)
+    end
+    assert_equal 5, chunks.size
+  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 = "http://localhost:8080/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 = "http://localhost:8080/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
+end

data/test/test_helper.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+#
+# Run httpbin server: `docker run -d -p 8080:80 --name httpbin kennethreitz/httpbin`
+
+$LOAD_PATH.unshift File.expand_path("../lib", __dir__)
+require "wreq"
+
+require "minitest/autorun"

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,112 @@
+--- !ruby/object:Gem::Specification
+name: wreq
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+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:
+- "./extconf.rb"
+extra_rdoc_files: []
+files:
+- "./extconf.rb"
+- Cargo.toml
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- build.rs
+- examples/body.rb
+- examples/client.rb
+- examples/emulation_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/body.rb
+- lib/wreq_ruby/client.rb
+- lib/wreq_ruby/cookie.rb
+- lib/wreq_ruby/emulation.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
+- 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/emulation.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/module_methods_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'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements:
+- Rust >= 1.85
+rubygems_version: 3.6.9
+specification_version: 4
+summary: Ruby bindings for wreq, an HTTP client with TLS/HTTP2 browser fingerprinting
+test_files: []