wreq 1.2.1-aarch64-linux → 1.2.3-aarch64-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a4fe6a278e93c2752ad962e6463bb9815640b95f1c529bfa8dcc699cc198be2a
-  data.tar.gz: a4390325af71d1a5b0377cc7e8412ee83f7b630a16a34c7df6e3e256e6a7ab19
+  metadata.gz: a47ab39ac373c828bb5dfe512749ece2faa56629c8db42e38bf18a22ce15d515
+  data.tar.gz: fb70422e9029953e2a53974f03bb398eac6f9b3a1453f47cd8d4bc6aec6ba40f
 SHA512:
-  metadata.gz: 6ccdfd91b1f58b450bdb5fed549e53be41ee98e0294304c402b2804271fa1abe9449beef9cdbf241dd1024d6ad5f48c3294d2b0f9b4dd494e85eb1945350dc0a
-  data.tar.gz: 9faca13e2e89958a6f185fb78a45643768842d291abeb02a16be46cc65872b94697452add56623db9a66b37134a3bfe3446cfa1dd5e46b5346a70313c516915e
+  metadata.gz: ccba25e28e305ce675f56dc8c3cf86e7433905e4029780cbe604e7e7ccfc129160ae6ab0955704a764f54dd2604efd29bfb88fcd067b7ff28fc3af3240edcdc5
+  data.tar.gz: 3d38f4979c3d2f761a287a3f64a69efbcc19256e825093d4ba59080966c540d7cf096a5b4af2e49920dce2e103ff4570b0db80e82d42d192e7e6abffa9548f73

data/Gemfile

@@ -8,6 +8,7 @@ group :development, :test do
   gem "rb_sys", "~> 0.9.110" # for Makefile generation in extconf.rb
   gem "rake-compiler", "~> 1.2.9" # to build a debug build
   gem "minitest", "~> 6.0" # test library
+  gem "minitest-retry", "~> 0.3", require: false # retry flaky network tests
   gem "activesupport", "~> 8.0.1" # testing support
   gem "standard", "~> 1.52" # linter with pre-specified rules
   gem "redcarpet", "~> 3.6" # for documentation markdown parsing

data/README.md

@@ -1,6 +1,7 @@
 # wreq-ruby
 
 [![CI](https://github.com/SearchApi/wreq-ruby/actions/workflows/ci.yml/badge.svg)](https://github.com/SearchApi/wreq-ruby/actions/workflows/ci.yml)
+![GitHub License](https://img.shields.io/github/license/SearchApi/wreq-ruby)
 [![Gem Version](https://badge.fury.io/rb/wreq.svg)](https://rubygems.org/gems/wreq)
 
 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, and powered by [wreq](https://github.com/0x676e67/wreq).
@@ -31,8 +32,10 @@ gem "wreq"
 ```
 
 Pre-compiled native gems are available for:
+
 - Linux (x86_64, aarch64)
 - macOS (arm64)
+- Windows (x86_64)
 
 ## Example
 
@@ -88,11 +91,11 @@ Most browser device models share identical TLS and HTTP/2 configurations, differ
 
   | **Browser** | **Versions** |
   | ----------- | ------------ |
-  | **Chrome**  | `Chrome100`, `Chrome101`, `Chrome104`, `Chrome105`, `Chrome106`, `Chrome107`, `Chrome108`, `Chrome109`, `Chrome110`, `Chrome114`, `Chrome116`, `Chrome117`, `Chrome118`, `Chrome119`, `Chrome120`, `Chrome123`, `Chrome124`, `Chrome126`, `Chrome127`, `Chrome128`, `Chrome129`, `Chrome130`, `Chrome131`, `Chrome132`, `Chrome133`, `Chrome134`, `Chrome135`, `Chrome136`, `Chrome137`, `Chrome138`, `Chrome139`, `Chrome140`, `Chrome141`, `Chrome142`, `Chrome143`, `Chrome144`, `Chrome145`, `Chrome146`, `Chrome147` |
-  | **Edge**    | `Edge101`, `Edge122`, `Edge127`, `Edge131`, `Edge134`, `Edge135`, `Edge136`, `Edge137`, `Edge138`, `Edge139`, `Edge140`, `Edge141`, `Edge142`, `Edge143`, `Edge144`, `Edge145`, `Edge146`, `Edge147` |
-  | **Firefox** | `Firefox109`, `Firefox117`, `Firefox128`, `Firefox133`, `Firefox135`, `FirefoxPrivate135`, `FirefoxAndroid135`, `Firefox136`, `FirefoxPrivate136`, `Firefox139`, `Firefox142`, `Firefox143`, `Firefox144`, `Firefox145`, `Firefox146`, `Firefox147`, `Firefox148`, `Firefox149` |
+  | **Chrome**  | `Chrome100`, `Chrome101`, `Chrome104`, `Chrome105`, `Chrome106`, `Chrome107`, `Chrome108`, `Chrome109`, `Chrome110`, `Chrome114`, `Chrome116`, `Chrome117`, `Chrome118`, `Chrome119`, `Chrome120`, `Chrome123`, `Chrome124`, `Chrome126`, `Chrome127`, `Chrome128`, `Chrome129`, `Chrome130`, `Chrome131`, `Chrome132`, `Chrome133`, `Chrome134`, `Chrome135`, `Chrome136`, `Chrome137`, `Chrome138`, `Chrome139`, `Chrome140`, `Chrome141`, `Chrome142`, `Chrome143`, `Chrome144`, `Chrome145`, `Chrome146`, `Chrome147`, `Chrome148`, `Chrome149` |
+  | **Edge**    | `Edge101`, `Edge122`, `Edge127`, `Edge131`, `Edge134`, `Edge135`, `Edge136`, `Edge137`, `Edge138`, `Edge139`, `Edge140`, `Edge141`, `Edge142`, `Edge143`, `Edge144`, `Edge145`, `Edge146`, `Edge147`, `Edge148` |
+  | **Firefox** | `Firefox109`, `Firefox117`, `Firefox128`, `Firefox133`, `Firefox135`, `FirefoxPrivate135`, `FirefoxAndroid135`, `Firefox136`, `FirefoxPrivate136`, `Firefox139`, `Firefox142`, `Firefox143`, `Firefox144`, `Firefox145`, `Firefox146`, `Firefox147`, `Firefox148`, `Firefox149`, `Firefox150`, `Firefox151` |
   | **Safari**  | `Safari15_3`, `Safari15_5`, `Safari15_6_1`, `Safari16`, `Safari16_5`, `Safari17_0`, `Safari17_2_1`, `Safari17_4_1`, `Safari17_5`, `Safari17_6`, `Safari18`, `Safari18_2`, `Safari18_3`, `Safari18_3_1`, `Safari18_5`, `Safari26`, `Safari26_1`, `Safari26_2`, `SafariIos16_5`, `SafariIos17_2`, `SafariIos17_4_1`, `SafariIos18_1_1`, `SafariIos26`, `SafariIos26_2`, `SafariIPad18`, `SafariIPad26`, `SafariIpad26_2` |
-  | **OkHttp**  | `OkHttp3_9`, `OkHttp3_11`, `OkHttp3_13`, `OkHttp3_14`, `OkHttp4_9`, `OkHttp4_10`, `OkHttp4_12`, `OkHttp5` |
+  | **OkHttp**  | `Opera116`, `Opera117`, `Opera118`, `Opera119`, `Opera120`, `Opera121`, `Opera122`, `Opera123`, `Opera124`, `Opera125`, `Opera126`, `Opera127`, `Opera128`, `Opera129`, `Opera130` |
   | **Opera**   | `Opera116`, `Opera117`, `Opera118`, `Opera119` |
 
   </details>

data/docs/windows-gnu-tokio-crash.md

@@ -0,0 +1,70 @@
+# Windows GNU Tokio multi-thread crash
+
+## Summary
+
+On RubyInstaller GNU/UCRT, Tokio's multi-thread runtime could crash when the
+native extension was loaded by Ruby. The issue was not Tokio's scheduler logic
+itself. It came from Windows symbol resolution while linking the Ruby extension.
+
+## Root cause
+
+RubyInstaller GNU/UCRT exports a Ruby-aware `Sleep` symbol from
+`x64-ucrt-ruby400.dll`.
+
+When the extension is linked with GNU ld, an unqualified `Sleep` reference can
+bind to Ruby's `Sleep` instead of `KERNEL32!Sleep`. Tokio's multi-thread runtime
+creates native worker threads that are not Ruby-managed threads. If one of those
+threads calls Ruby's `Sleep`, Ruby expects Ruby thread-local state to exist, but
+that TLS slot is empty on the Tokio worker thread. This can crash with an access
+violation or Ruby VM bug report.
+
+The local investigation found the fault inside:
+
+```text
+x64-ucrt-ruby400.dll!Sleep + 0x40
+```
+
+The import table also showed the bad binding:
+
+```text
+DLL Name: x64-ucrt-ruby400.dll
+  Sleep
+```
+
+## Fix
+
+For `x86_64-pc-windows-gnu`, the build now wraps `Sleep` at link time:
+
+```text
+-Wl,--wrap=Sleep
+```
+
+The wrapper lives in `src/arch.rs` and forwards calls to `KERNEL32!SleepEx`.
+This keeps Tokio's worker threads on the real Windows API path while preserving
+Tokio's multi-thread runtime and Ruby GVL release behavior.
+
+After the fix, the import table shows:
+
+```text
+DLL Name: KERNEL32.dll
+  Sleep
+  SleepEx
+```
+
+## Notes
+
+`windows-sys` raw-dylib was also tested. It is not enough on its own because the
+problematic `Sleep` reference can come from Rust std, MinGW, or pthread-related
+linking paths, not only from `windows-sys`.
+
+Verified with:
+
+```powershell
+.\script\build_windows_gnu.ps1 -SkipBundleInstall -SkipToolInstall -RunTests
+```
+
+Result:
+
+```text
+160 runs, 775 assertions, 0 failures, 0 errors
+```

data/lib/wreq_ruby/emulate.rb

@@ -57,6 +57,7 @@ module Wreq
       Chrome146 = nil
       Chrome147 = nil
       Chrome148 = nil
+      Chrome149 = nil
 
       Edge101 = nil
       Edge122 = nil

data/script/build_windows_gnu.ps1

@@ -0,0 +1,257 @@
+param(
+    [switch]$SkipBundleInstall,
+    [switch]$SkipToolInstall,
+    [switch]$BuildGem,
+    [switch]$TestGem,
+    [switch]$RunTests,
+    [string]$SmokeUrl = $env:WREQ_SMOKE_URL
+)
+
+$ErrorActionPreference = "Stop"
+
+$target = "x86_64-pc-windows-gnu"
+$platform = "x64-mingw-ucrt"
+$gemPattern = "pkg\wreq-*-$platform.gem"
+if ([string]::IsNullOrWhiteSpace($SmokeUrl)) {
+    $SmokeUrl = "https://httpbin.io/get"
+}
+$rubyRoot = Split-Path (Split-Path (Get-Command ruby).Source -Parent) -Parent
+$ucrt = Join-Path $rubyRoot "msys64\ucrt64"
+$ucrtBin = Join-Path $ucrt "bin"
+$msysPackages = @(
+    "mingw-w64-ucrt-x86_64-gcc",
+    "mingw-w64-ucrt-x86_64-clang",
+    "mingw-w64-ucrt-x86_64-cmake",
+    "mingw-w64-ucrt-x86_64-pkgconf"
+)
+
+function Invoke-Step {
+    param(
+        [string]$Name,
+        [scriptblock]$Command
+    )
+
+    Write-Host "==> $Name"
+    & $Command
+}
+
+function Get-MissingUcrtTools {
+    $missing = @()
+
+    if (-not (Test-Path (Join-Path $ucrtBin "gcc.exe")) -or -not (Test-Path (Join-Path $ucrtBin "g++.exe"))) {
+        $missing += "gcc/g++"
+    }
+
+    if (-not (Test-Path (Join-Path $ucrtBin "clang.exe")) -or -not (Test-Path (Join-Path $ucrtBin "libclang.dll"))) {
+        $missing += "clang/libclang"
+    }
+
+    if (-not (Test-Path (Join-Path $ucrtBin "cmake.exe"))) {
+        $missing += "cmake"
+    }
+
+    if (-not (Test-Path (Join-Path $ucrtBin "pkgconf.exe")) -and -not (Test-Path (Join-Path $ucrtBin "pkg-config.exe"))) {
+        $missing += "pkgconf"
+    }
+
+    $missing
+}
+
+function Get-LatestPlatformGem {
+    $gem = Get-ChildItem -Path $gemPattern -ErrorAction SilentlyContinue |
+        Sort-Object LastWriteTime -Descending |
+        Select-Object -First 1
+
+    if (-not $gem) {
+        throw "No Windows GNU platform gem found at '$gemPattern'. Re-run with -BuildGem first."
+    }
+
+    $gem
+}
+
+function Invoke-RubySmoke {
+    param(
+        [string]$Name,
+        [string]$Code
+    )
+
+    Write-Host "Smoke: $Name"
+    ruby -e $Code
+    if ($LASTEXITCODE -ne 0) {
+        throw "$Name failed with exit code $LASTEXITCODE."
+    }
+}
+
+Invoke-Step "Check Ruby platform" {
+    $rubyArch = & ruby -rrbconfig -e "print RbConfig::CONFIG['arch']"
+    if ($rubyArch -ne $platform) {
+        throw "Expected Ruby platform '$platform', got '$rubyArch'. Use RubyInstaller UCRT for this build."
+    }
+
+    ruby -v
+    ruby -rrbconfig -rrubygems -e "puts RbConfig::CONFIG.values_at('arch', 'host', 'CC').join(%q{ }); puts Gem::Platform.local"
+}
+
+Invoke-Step "Install Rust target" {
+    $installedTargets = @(rustup target list --installed)
+    if ($installedTargets -contains $target) {
+        Write-Host "Rust target $target already installed; skipping rustup."
+        return
+    }
+
+    rustup target add $target
+    if ($LASTEXITCODE -ne 0) {
+        throw "Failed to install Rust target $target."
+    }
+}
+
+Invoke-Step "Check MSYS2 UCRT build tools" {
+    $missing = @(Get-MissingUcrtTools)
+    if ($missing.Count -eq 0) {
+        Write-Host "MSYS2 UCRT build tools already present; skipping pacman."
+        return
+    }
+
+    if ($SkipToolInstall) {
+        throw "Missing MSYS2 UCRT build tools: $($missing -join ', '). Re-run without -SkipToolInstall or install them with ridk."
+    }
+
+    Write-Host "Missing MSYS2 UCRT build tools: $($missing -join ', ')"
+    ridk exec pacman -S --needed --noconfirm @msysPackages
+    if ($LASTEXITCODE -ne 0) {
+        $stillMissing = @(Get-MissingUcrtTools)
+        if ($stillMissing.Count -eq 0) {
+            Write-Warning "pacman returned exit code $LASTEXITCODE, but all required tools are present; continuing."
+            return
+        }
+
+        throw "Failed to install MSYS2 UCRT build tools. Missing: $($stillMissing -join ', '). If pacman cannot lock its database, close other pacman/ridk shells, run PowerShell as Administrator, or install RubyInstaller in a user-writable directory."
+    }
+}
+
+Invoke-Step "Configure Windows GNU toolchain" {
+    $env:CARGO_BUILD_TARGET = $target
+    $env:LIBCLANG_PATH = $ucrtBin
+    $env:CC_x86_64_pc_windows_gnu = Join-Path $ucrtBin "gcc.exe"
+    $env:CXX_x86_64_pc_windows_gnu = Join-Path $ucrtBin "g++.exe"
+    $env:CMAKE = Join-Path $ucrtBin "cmake.exe"
+    Remove-Item Env:\CMAKE_GENERATOR -ErrorAction SilentlyContinue
+
+    rustc -Vv
+    Write-Host "LIBCLANG_PATH=$env:LIBCLANG_PATH"
+    Write-Host "CC_x86_64_pc_windows_gnu=$env:CC_x86_64_pc_windows_gnu"
+    Write-Host "CXX_x86_64_pc_windows_gnu=$env:CXX_x86_64_pc_windows_gnu"
+    Write-Host "CMAKE=$env:CMAKE"
+}
+
+if (-not $SkipBundleInstall) {
+    Invoke-Step "Install Ruby dependencies" {
+        bundle install
+    }
+}
+
+Invoke-Step "Compile native extension" {
+    ridk exec ruby -S bundle exec rake compile
+}
+
+Invoke-Step "Verify extension loads" {
+    ruby -Ilib -rwreq -e "puts Wreq::VERSION; puts Wreq::Client.new.class"
+}
+
+if ($RunTests) {
+    Invoke-Step "Run tests" {
+        ridk exec ruby -S bundle exec rake test
+    }
+}
+
+if ($BuildGem) {
+    Invoke-Step "Build local platform gem" {
+        $rubyMinor = & ruby -e "print RUBY_VERSION[/\A\d+\.\d+/]"
+        $dest = "lib\wreq_ruby\$rubyMinor"
+        New-Item -ItemType Directory -Force $dest | Out-Null
+        Copy-Item "lib\wreq_ruby\wreq_ruby.so" (Join-Path $dest "wreq_ruby.so") -Force
+
+        ruby script/build_platform_gem.rb $platform
+    }
+}
+
+if ($TestGem) {
+    Invoke-Step "Install and smoke test platform gem" {
+        $gem = Get-LatestPlatformGem
+        $gemHome = Join-Path ([System.IO.Path]::GetTempPath()) "wreq-gem-test-$PID"
+        $gemBin = Join-Path $gemHome "bin"
+        $testDir = Join-Path ([System.IO.Path]::GetTempPath()) "wreq-gem-test-cwd-$PID"
+
+        Remove-Item -Recurse -Force $gemHome, $testDir -ErrorAction SilentlyContinue
+        New-Item -ItemType Directory -Force $gemHome, $gemBin, $testDir | Out-Null
+
+        $oldGemHome = $env:GEM_HOME
+        $oldGemPath = $env:GEM_PATH
+        $oldGemrc = $env:GEMRC
+        $oldRubyopt = $env:RUBYOPT
+        $oldRubylib = $env:RUBYLIB
+        $oldBundleGemfile = $env:BUNDLE_GEMFILE
+        $oldBundleBinPath = $env:BUNDLE_BIN_PATH
+        $oldBundlerVersion = $env:BUNDLER_VERSION
+        $oldSmokeUrl = $env:WREQ_SMOKE_URL
+        $oldWreqGemHome = $env:WREQ_GEM_HOME
+
+        try {
+            $env:GEM_HOME = $gemHome
+            $env:GEM_PATH = $gemHome
+            $env:GEMRC = ""
+            $env:RUBYOPT = ""
+            $env:RUBYLIB = ""
+            $env:BUNDLE_GEMFILE = ""
+            $env:BUNDLE_BIN_PATH = ""
+            $env:BUNDLER_VERSION = ""
+            $env:WREQ_SMOKE_URL = $SmokeUrl
+            $env:WREQ_GEM_HOME = $gemHome
+
+            gem install --norc --local --install-dir $gemHome --bindir $gemBin --no-document --force --no-user-install $gem.FullName
+            if ($LASTEXITCODE -ne 0) {
+                throw "Failed to install $($gem.FullName)."
+            }
+
+            Push-Location $testDir
+            try {
+                Invoke-RubySmoke "Load installed platform gem" @'
+STDOUT.sync = true
+STDERR.sync = true
+require "wreq"
+spec = Gem.loaded_specs.fetch("wreq")
+expected = File.expand_path(ENV.fetch("WREQ_GEM_HOME"))
+actual = File.expand_path(spec.full_gem_path)
+raise "loaded #{actual}, expected under #{expected}" unless actual.start_with?(expected)
+puts "loaded #{spec.full_name}"
+puts actual
+puts "wreq #{Wreq::VERSION}"
+'@
+
+                Invoke-RubySmoke "Request through installed platform gem" @'
+STDOUT.sync = true
+STDERR.sync = true
+require "wreq"
+client = Wreq::Client.new
+resp = client.get(ENV.fetch("WREQ_SMOKE_URL"), timeout: 20)
+puts "HTTP #{resp.code}"
+raise "unexpected status #{resp.code}" unless resp.code == 200
+'@
+            } finally {
+                Pop-Location
+            }
+        } finally {
+            $env:GEM_HOME = $oldGemHome
+            $env:GEM_PATH = $oldGemPath
+            $env:GEMRC = $oldGemrc
+            $env:RUBYOPT = $oldRubyopt
+            $env:RUBYLIB = $oldRubylib
+            $env:BUNDLE_GEMFILE = $oldBundleGemfile
+            $env:BUNDLE_BIN_PATH = $oldBundleBinPath
+            $env:BUNDLER_VERSION = $oldBundlerVersion
+            $env:WREQ_SMOKE_URL = $oldSmokeUrl
+            $env:WREQ_GEM_HOME = $oldWreqGemHome
+            Remove-Item -Recurse -Force $gemHome, $testDir -ErrorAction SilentlyContinue
+        }
+    }
+}

data/test/client_cookie_test.rb

@@ -3,7 +3,7 @@
 require "test_helper"
 
 class ClientCookieProviderTest < Minitest::Test
-  HOST = "http://localhost:8080"
+  HOST = HTTPBIN_URL
 
   def setup
     @jar = Wreq::Jar.new
@@ -29,9 +29,9 @@ class ClientCookieProviderTest < Minitest::Test
     # subsequent request should send the stored cookie automatically
     res2 = @client.get("#{HOST}/cookies")
     assert_equal 200, res2.code
-    body = res2.json
-    assert_kind_of Hash, body
-    assert_equal "bar", body.dig("cookies", "foo")
+    cookies = httpbin_cookies(res2.json)
+    assert_kind_of Hash, cookies
+    assert_equal "bar", httpbin_fetch(cookies, "foo")
   end
 
   def test_prepopulated_jar_is_used_by_client
@@ -40,7 +40,7 @@ class ClientCookieProviderTest < Minitest::Test
 
     res = @client.get("#{HOST}/cookies")
     assert_equal 200, res.code
-    cookies = res.json["cookies"]
-    assert_equal "1", cookies["pref"]
+    cookies = httpbin_cookies(res.json)
+    assert_equal "1", httpbin_fetch(cookies, "pref")
   end
 end

data/test/client_test.rb

@@ -20,40 +20,40 @@ class ClientTest < Minitest::Test
   end
 
   def test_get_request
-    response = @client.get("http://localhost:8080/get")
+    response = @client.get("#{HTTPBIN_URL}/get")
     refute_nil response
     assert_equal 200, response.code
   end
 
   def test_post_request
-    response = @client.post("http://localhost:8080/post",
+    response = @client.post("#{HTTPBIN_URL}/post",
       json: {test: "wreq-ruby"})
     refute_nil response
     assert_equal 200, response.code
   end
 
   def test_put_request
-    response = @client.put("http://localhost:8080/put",
+    response = @client.put("#{HTTPBIN_URL}/put",
       json: {data: "test"})
     refute_nil response
     assert_equal 200, response.code
   end
 
   def test_delete_request
-    response = @client.delete("http://localhost:8080/delete")
+    response = @client.delete("#{HTTPBIN_URL}/delete")
     refute_nil response
     assert_equal 200, response.code
   end
 
   def test_patch_request
-    response = @client.patch("http://localhost:8080/patch",
+    response = @client.patch("#{HTTPBIN_URL}/patch",
       json: {update: "field"})
     refute_nil response
     assert_equal 200, response.code
   end
 
   def test_request_with_query_params
-    response = @client.get("http://localhost:8080/get",
+    response = @client.get("#{HTTPBIN_URL}/get",
       query: {"param" => "value"})
     refute_nil response
     assert_equal 200, response.code
@@ -61,7 +61,7 @@ class ClientTest < Minitest::Test
   end
 
   def test_request_with_form_data
-    response = @client.post("http://localhost:8080/post",
+    response = @client.post("#{HTTPBIN_URL}/post",
       form: {"field" => "value"})
     refute_nil response
     assert_equal 200, response.code
@@ -69,7 +69,7 @@ class ClientTest < Minitest::Test
   end
 
   def test_request_with_raw_body
-    response = @client.post("http://localhost:8080/post",
+    response = @client.post("#{HTTPBIN_URL}/post",
       body: "raw content",
       headers: {"Content-Type" => "text/plain"})
     refute_nil response
@@ -78,14 +78,14 @@ class ClientTest < Minitest::Test
   end
 
   def test_basic_authentication
-    response = @client.get("http://localhost:8080/basic-auth/user/pass",
+    response = @client.get("#{HTTPBIN_URL}/basic-auth/user/pass",
       basic_auth: ["user", "pass"])
     refute_nil response
     assert_equal 200, response.code
   end
 
   def test_bearer_authentication
-    response = @client.get("http://localhost:8080/bearer",
+    response = @client.get("#{HTTPBIN_URL}/bearer",
       bearer_auth: "test-token")
     refute_nil response
     assert_equal 200, response.code
@@ -93,21 +93,21 @@ class ClientTest < Minitest::Test
   end
 
   def test_redirect_following
-    response = @client.get("http://localhost:8080/redirect/1",
+    response = @client.get("#{HTTPBIN_URL}/redirect/1",
       allow_redirects: true)
     refute_nil response
     assert_equal 200, response.code
   end
 
   def test_redirect_blocking
-    response = @client.get("http://localhost:8080/redirect/1",
+    response = @client.get("#{HTTPBIN_URL}/redirect/1",
       allow_redirects: false)
     refute_nil response
     assert_equal 302, response.code
   end
 
   def test_gzip_compression
-    response = @client.get("http://localhost:8080/gzip", gzip: true)
+    response = @client.get("#{HTTPBIN_URL}/gzip", gzip: true)
     refute_nil response
     assert_equal 200, response.code
   end
@@ -115,12 +115,12 @@ class ClientTest < Minitest::Test
   def test_timeout_handling
     # Test that short timeouts properly raise exceptions
     assert_raises(Wreq::TimeoutError) do
-      @client.get("http://localhost:8080/delay/10", timeout: 1)
+      @client.get("#{HTTPBIN_URL}/delay/10", timeout: 1)
     end
 
     # Test that reasonable timeouts work normally
     start_time = Time.now
-    response = @client.get("http://localhost:8080/delay/1", timeout: 5)
+    response = @client.get("#{HTTPBIN_URL}/delay/1", timeout: 5)
     elapsed = Time.now - start_time
 
     refute_nil response
@@ -129,7 +129,7 @@ class ClientTest < Minitest::Test
   end
 
   def test_status_codes
-    response = @client.get("http://localhost:8080/status/404")
+    response = @client.get("#{HTTPBIN_URL}/status/404")
     refute_nil response
     assert_equal 404, response.code
   end

data/test/cookie_test.rb

@@ -157,24 +157,26 @@ class CookieTest < Minitest::Test
   def test_request_uncompressed_cookies
     client = Wreq::Client.new
     resp = client.get(
-      "https://httpbin.io/cookies",
+      "#{HTTPBIN_URL}/cookies",
       cookies: {"foo" => "bar", "baz" => "qux"}
     )
     json = resp.json
     assert_instance_of Hash, json
-    assert_equal "bar", json["foo"]
-    assert_equal "qux", json["baz"]
+    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(
-      "https://httpbin.io/cookies",
+      "#{HTTPBIN_URL}/cookies",
       cookies: "foo=bar; baz=qux"
     )
     json = resp.json
     assert_instance_of Hash, json
-    assert_equal "bar", json["foo"]
-    assert_equal "qux", json["baz"]
+    cookies = json.fetch("cookies", json)
+    assert_equal "bar", cookies["foo"]
+    assert_equal "qux", cookies["baz"]
   end
 end

data/test/error_handling_test.rb

@@ -21,7 +21,7 @@ class ErrorHandlingTest < Minitest::Test
   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("http://localhost:8080/status/#{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
@@ -31,7 +31,7 @@ class ErrorHandlingTest < Minitest::Test
     # Test timeout with a delay that should definitely cause timeout
 
     # Request with a very short timeout that should fail
-    response = Wreq.get("http://localhost:8080/delay/10", timeout: 1)
+    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
@@ -42,7 +42,7 @@ class ErrorHandlingTest < Minitest::Test
 
   def test_invalid_json_response
     # Get a non-JSON response and try to parse as JSON
-    response = Wreq.get("http://localhost:8080/html")
+    response = Wreq.get("#{HTTPBIN_URL}/html")
     assert_equal 200, response.code
 
     # Should raise an error when trying to parse HTML as JSON
@@ -54,7 +54,7 @@ class ErrorHandlingTest < Minitest::Test
   end
 
   def test_empty_response_json
-    response = Wreq.get("http://localhost:8080/status/204")
+    response = Wreq.get("#{HTTPBIN_URL}/status/204")
     assert_equal 204, response.code
     assert_equal "", response.text
 

data/test/header_test.rb

@@ -2,7 +2,7 @@ require "test_helper"
 
 class HeadersTest < Minitest::Test
   def setup
-    @response = Wreq.get("http://localhost:8080/response-headers",
+    @response = Wreq.get("#{HTTPBIN_URL}/response-headers",
       query: {
         "X-Custom-Header" => "custom-value",
         "X-Multi-Header" => "value1"

data/test/inspect_test.rb

@@ -84,12 +84,12 @@ class InspectTest < Minitest::Test
   # ---- Response ----
 
   def test_response_to_s_returns_body
-    response = Wreq.get("http://localhost:8080/json")
+    response = Wreq.get("#{HTTPBIN_URL}/json")
     assert_equal response.text, response.to_s
   end
 
   def test_response_inspect_format
-    response = Wreq.get("http://localhost:8080/json")
+    response = Wreq.get("#{HTTPBIN_URL}/json")
     result = response.inspect
     assert result.start_with?("#<Wreq::Response")
     assert_includes result, "200"
@@ -99,7 +99,7 @@ class InspectTest < Minitest::Test
   # ---- StatusCode ----
 
   def test_status_code_inspect
-    response = Wreq.get("http://localhost:8080/status/200")
+    response = Wreq.get("#{HTTPBIN_URL}/status/200")
     result = response.status.inspect
     assert result.start_with?("#<Wreq::StatusCode")
     assert_includes result, response.status.to_s
@@ -117,7 +117,7 @@ class InspectTest < Minitest::Test
   end
 
   def test_version_inspect_from_response
-    response = Wreq.get("http://localhost:8080/get")
+    response = Wreq.get("#{HTTPBIN_URL}/get")
     result = response.version.inspect
     assert result.start_with?("#<Wreq::Version")
     assert result.end_with?(">")