wreq 1.2.2 → 1.2.4

data/src/emulate.rs

@@ -49,6 +49,7 @@ define_ruby_enum!(
     Chrome146,
     Chrome147,
     Chrome148,
+    Chrome149,
 
     Edge101,
     Edge122,
@@ -221,152 +222,12 @@ pub fn include(ruby: &Ruby, gem_module: &RModule) -> Result<(), Error> {
     // Profile enum binding
     let profile = gem_module.define_class("Profile", ruby.class_object())?;
     profile.define_method("to_s", method!(Profile::to_s, 0))?;
-    profile.const_set("Chrome100", Profile::Chrome100)?;
-    profile.const_set("Chrome101", Profile::Chrome101)?;
-    profile.const_set("Chrome104", Profile::Chrome104)?;
-    profile.const_set("Chrome105", Profile::Chrome105)?;
-    profile.const_set("Chrome106", Profile::Chrome106)?;
-    profile.const_set("Chrome107", Profile::Chrome107)?;
-    profile.const_set("Chrome108", Profile::Chrome108)?;
-    profile.const_set("Chrome109", Profile::Chrome109)?;
-    profile.const_set("Chrome110", Profile::Chrome110)?;
-    profile.const_set("Chrome114", Profile::Chrome114)?;
-    profile.const_set("Chrome116", Profile::Chrome116)?;
-    profile.const_set("Chrome117", Profile::Chrome117)?;
-    profile.const_set("Chrome118", Profile::Chrome118)?;
-    profile.const_set("Chrome119", Profile::Chrome119)?;
-    profile.const_set("Chrome120", Profile::Chrome120)?;
-    profile.const_set("Chrome123", Profile::Chrome123)?;
-    profile.const_set("Chrome124", Profile::Chrome124)?;
-    profile.const_set("Chrome126", Profile::Chrome126)?;
-    profile.const_set("Chrome127", Profile::Chrome127)?;
-    profile.const_set("Chrome128", Profile::Chrome128)?;
-    profile.const_set("Chrome129", Profile::Chrome129)?;
-    profile.const_set("Chrome130", Profile::Chrome130)?;
-    profile.const_set("Chrome131", Profile::Chrome131)?;
-    profile.const_set("Chrome132", Profile::Chrome132)?;
-    profile.const_set("Chrome133", Profile::Chrome133)?;
-    profile.const_set("Chrome134", Profile::Chrome134)?;
-    profile.const_set("Chrome135", Profile::Chrome135)?;
-    profile.const_set("Chrome136", Profile::Chrome136)?;
-    profile.const_set("Chrome137", Profile::Chrome137)?;
-    profile.const_set("Chrome138", Profile::Chrome138)?;
-    profile.const_set("Chrome139", Profile::Chrome139)?;
-    profile.const_set("Chrome140", Profile::Chrome140)?;
-    profile.const_set("Chrome141", Profile::Chrome141)?;
-    profile.const_set("Chrome142", Profile::Chrome142)?;
-    profile.const_set("Chrome143", Profile::Chrome143)?;
-    profile.const_set("Chrome144", Profile::Chrome144)?;
-    profile.const_set("Chrome145", Profile::Chrome145)?;
-    profile.const_set("Chrome146", Profile::Chrome146)?;
-    profile.const_set("Chrome147", Profile::Chrome147)?;
-    profile.const_set("Chrome148", Profile::Chrome148)?;
-
-    profile.const_set("Edge101", Profile::Edge101)?;
-    profile.const_set("Edge122", Profile::Edge122)?;
-    profile.const_set("Edge127", Profile::Edge127)?;
-    profile.const_set("Edge131", Profile::Edge131)?;
-    profile.const_set("Edge134", Profile::Edge134)?;
-    profile.const_set("Edge135", Profile::Edge135)?;
-    profile.const_set("Edge136", Profile::Edge136)?;
-    profile.const_set("Edge137", Profile::Edge137)?;
-    profile.const_set("Edge138", Profile::Edge138)?;
-    profile.const_set("Edge139", Profile::Edge139)?;
-    profile.const_set("Edge140", Profile::Edge140)?;
-    profile.const_set("Edge141", Profile::Edge141)?;
-    profile.const_set("Edge142", Profile::Edge142)?;
-    profile.const_set("Edge143", Profile::Edge143)?;
-    profile.const_set("Edge144", Profile::Edge144)?;
-    profile.const_set("Edge145", Profile::Edge145)?;
-    profile.const_set("Edge146", Profile::Edge146)?;
-    profile.const_set("Edge147", Profile::Edge147)?;
-    profile.const_set("Edge148", Profile::Edge148)?;
-
-    profile.const_set("Firefox109", Profile::Firefox109)?;
-    profile.const_set("Firefox117", Profile::Firefox117)?;
-    profile.const_set("Firefox128", Profile::Firefox128)?;
-    profile.const_set("Firefox133", Profile::Firefox133)?;
-    profile.const_set("Firefox135", Profile::Firefox135)?;
-    profile.const_set("FirefoxPrivate135", Profile::FirefoxPrivate135)?;
-    profile.const_set("FirefoxAndroid135", Profile::FirefoxAndroid135)?;
-    profile.const_set("Firefox136", Profile::Firefox136)?;
-    profile.const_set("FirefoxPrivate136", Profile::FirefoxPrivate136)?;
-    profile.const_set("Firefox139", Profile::Firefox139)?;
-    profile.const_set("Firefox142", Profile::Firefox142)?;
-    profile.const_set("Firefox143", Profile::Firefox143)?;
-    profile.const_set("Firefox144", Profile::Firefox144)?;
-    profile.const_set("Firefox145", Profile::Firefox145)?;
-    profile.const_set("Firefox146", Profile::Firefox146)?;
-    profile.const_set("Firefox147", Profile::Firefox147)?;
-    profile.const_set("Firefox148", Profile::Firefox148)?;
-    profile.const_set("Firefox149", Profile::Firefox149)?;
-    profile.const_set("Firefox150", Profile::Firefox150)?;
-    profile.const_set("Firefox151", Profile::Firefox151)?;
-
-    profile.const_set("SafariIos17_2", Profile::SafariIos17_2)?;
-    profile.const_set("SafariIos17_4_1", Profile::SafariIos17_4_1)?;
-    profile.const_set("SafariIos16_5", Profile::SafariIos16_5)?;
-    profile.const_set("Safari15_3", Profile::Safari15_3)?;
-    profile.const_set("Safari15_5", Profile::Safari15_5)?;
-    profile.const_set("Safari15_6_1", Profile::Safari15_6_1)?;
-    profile.const_set("Safari16", Profile::Safari16)?;
-    profile.const_set("Safari16_5", Profile::Safari16_5)?;
-    profile.const_set("Safari17_0", Profile::Safari17_0)?;
-    profile.const_set("Safari17_2_1", Profile::Safari17_2_1)?;
-    profile.const_set("Safari17_4_1", Profile::Safari17_4_1)?;
-    profile.const_set("Safari17_5", Profile::Safari17_5)?;
-    profile.const_set("Safari17_6", Profile::Safari17_6)?;
-    profile.const_set("Safari18", Profile::Safari18)?;
-    profile.const_set("SafariIPad18", Profile::SafariIPad18)?;
-    profile.const_set("Safari18_2", Profile::Safari18_2)?;
-    profile.const_set("Safari18_3", Profile::Safari18_3)?;
-    profile.const_set("Safari18_3_1", Profile::Safari18_3_1)?;
-    profile.const_set("SafariIos18_1_1", Profile::SafariIos18_1_1)?;
-    profile.const_set("Safari18_5", Profile::Safari18_5)?;
-    profile.const_set("Safari26", Profile::Safari26)?;
-    profile.const_set("Safari26_1", Profile::Safari26_1)?;
-    profile.const_set("Safari26_2", Profile::Safari26_2)?;
-    profile.const_set("Safari26_3", Profile::Safari26_3)?;
-    profile.const_set("Safari26_4", Profile::Safari26_4)?;
-    profile.const_set("SafariIos26", Profile::SafariIos26)?;
-    profile.const_set("SafariIos26_2", Profile::SafariIos26_2)?;
-    profile.const_set("SafariIPad26", Profile::SafariIPad26)?;
-    profile.const_set("SafariIpad26_2", Profile::SafariIpad26_2)?;
-
-    profile.const_set("OkHttp3_9", Profile::OkHttp3_9)?;
-    profile.const_set("OkHttp3_11", Profile::OkHttp3_11)?;
-    profile.const_set("OkHttp3_13", Profile::OkHttp3_13)?;
-    profile.const_set("OkHttp3_14", Profile::OkHttp3_14)?;
-    profile.const_set("OkHttp4_9", Profile::OkHttp4_9)?;
-    profile.const_set("OkHttp4_10", Profile::OkHttp4_10)?;
-    profile.const_set("OkHttp4_12", Profile::OkHttp4_12)?;
-    profile.const_set("OkHttp5", Profile::OkHttp5)?;
-
-    profile.const_set("Opera116", Profile::Opera116)?;
-    profile.const_set("Opera117", Profile::Opera117)?;
-    profile.const_set("Opera118", Profile::Opera118)?;
-    profile.const_set("Opera119", Profile::Opera119)?;
-    profile.const_set("Opera120", Profile::Opera120)?;
-    profile.const_set("Opera121", Profile::Opera121)?;
-    profile.const_set("Opera122", Profile::Opera122)?;
-    profile.const_set("Opera123", Profile::Opera123)?;
-    profile.const_set("Opera124", Profile::Opera124)?;
-    profile.const_set("Opera125", Profile::Opera125)?;
-    profile.const_set("Opera126", Profile::Opera126)?;
-    profile.const_set("Opera127", Profile::Opera127)?;
-    profile.const_set("Opera128", Profile::Opera128)?;
-    profile.const_set("Opera129", Profile::Opera129)?;
-    profile.const_set("Opera130", Profile::Opera130)?;
-    profile.const_set("Opera131", Profile::Opera131)?;
+    Profile::define_constants(profile)?;
 
     // Platform enum binding
     let platform = gem_module.define_class("Platform", ruby.class_object())?;
     platform.define_method("to_s", method!(Platform::to_s, 0))?;
-    platform.const_set("Windows", Platform::Windows)?;
-    platform.const_set("MacOS", Platform::MacOS)?;
-    platform.const_set("Linux", Platform::Linux)?;
-    platform.const_set("Android", Platform::Android)?;
-    platform.const_set("IOS", Platform::IOS)?;
+    Platform::define_constants(platform)?;
 
     // Emulation class binding
     let emulation = gem_module.define_class("Emulation", ruby.class_object())?;

data/src/http.rs

@@ -111,21 +111,10 @@ impl From<wreq::StatusCode> for StatusCode {
 
 pub fn include(ruby: &Ruby, gem_module: &RModule) -> Result<(), Error> {
     let method_class = gem_module.define_class("Method", ruby.class_object())?;
-    method_class.const_set("GET", Method::GET)?;
-    method_class.const_set("POST", Method::POST)?;
-    method_class.const_set("PUT", Method::PUT)?;
-    method_class.const_set("DELETE", Method::DELETE)?;
-    method_class.const_set("PATCH", Method::PATCH)?;
-    method_class.const_set("HEAD", Method::HEAD)?;
-    method_class.const_set("TRACE", Method::TRACE)?;
-    method_class.const_set("OPTIONS", Method::OPTIONS)?;
+    Method::define_constants(method_class)?;
 
     let version_class = gem_module.define_class("Version", ruby.class_object())?;
-    version_class.const_set("HTTP_09", Version::HTTP_09)?;
-    version_class.const_set("HTTP_10", Version::HTTP_10)?;
-    version_class.const_set("HTTP_11", Version::HTTP_11)?;
-    version_class.const_set("HTTP_2", Version::HTTP_2)?;
-    version_class.const_set("HTTP_3", Version::HTTP_3)?;
+    Version::define_constants(version_class)?;
     version_class.define_method("to_s", method!(Version::to_s, 0))?;
     version_class.define_method("==", method!(Version::equals, 1))?;
 

data/src/lib.rs

@@ -2,6 +2,7 @@
 
 #[macro_use]
 mod macros;
+mod arch;
 mod client;
 mod cookie;
 mod emulate;

data/src/macros.rs

@@ -75,6 +75,11 @@ macro_rules! define_ruby_enum {
                     _ => unreachable!(),
                 }
             }
+
+            pub fn define_constants(class: magnus::RClass) -> Result<(), magnus::Error> {
+                $(class.const_set(stringify!($rust_variant), <$enum_type>::$rust_variant)?;)*
+                Ok(())
+            }
         }
     };
 
@@ -103,6 +108,11 @@ macro_rules! define_ruby_enum {
                     _ => unreachable!(),
                 }
             }
+
+            pub fn define_constants(class: magnus::RClass) -> Result<(), magnus::Error> {
+                $(class.const_set(stringify!($rust_variant), <$enum_type>::$rust_variant)?;)*
+                Ok(())
+            }
         }
     };
 }

data/src/rt.rs

@@ -5,25 +5,42 @@ use tokio::runtime::{Builder, Runtime};
 use crate::{error::interrupt_error, gvl};
 
 static RUNTIME: LazyLock<Runtime> = LazyLock::new(|| {
-    Builder::new_multi_thread()
+    let mut builder = Builder::new_multi_thread();
+
+    builder
         .enable_all()
         .build()
         .expect("Failed to initialize Tokio runtime")
 });
 
-/// Block on a future to completion on the global Tokio runtime,
-/// with support for cancellation via the provided `CancelFlag`.
-pub fn try_block_on<F, T>(future: F) -> F::Output
+enum BlockOnError<E> {
+    Interrupted,
+    Future(E),
+}
+
+/// Block on a future to completion on the global Tokio runtime.
+///
+/// The future runs without Ruby's GVL, so it must not construct Ruby objects or
+/// Ruby exceptions. Convert Rust errors back into Ruby errors after the GVL has
+/// been reacquired.
+pub fn try_block_on<F, T, E, M>(future: F, map_err: M) -> Result<T, magnus::Error>
 where
-    F: Future<Output = Result<T, magnus::Error>>,
+    F: Future<Output = Result<T, E>>,
+    M: FnOnce(E) -> magnus::Error,
 {
-    gvl::nogvl_cancellable(|flag| {
+    let result = gvl::nogvl_cancellable(|flag| {
         RUNTIME.block_on(async move {
             tokio::select! {
                 biased;
-                _ = flag.cancelled() => Err(interrupt_error()),
-                result = future => result,
+                _ = flag.cancelled() => Err(BlockOnError::Interrupted),
+                result = future => result.map_err(BlockOnError::Future),
             }
         })
-    })
+    });
+
+    match result {
+        Ok(value) => Ok(value),
+        Err(BlockOnError::Interrupted) => Err(interrupt_error()),
+        Err(BlockOnError::Future(err)) => Err(map_err(err)),
+    }
 }

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?(">")

data/test/module_methods_test.rb

@@ -2,33 +2,33 @@ require "test_helper"
 
 class ModuleMethodsTest < Minitest::Test
   def test_module_get
-    response = Wreq.get("http://localhost:8080/get")
+    response = Wreq.get("#{HTTPBIN_URL}/get")
     refute_nil response
     assert_equal 200, response.code
   end
 
   def test_module_post
-    response = Wreq.post("http://localhost:8080/post",
+    response = Wreq.post("#{HTTPBIN_URL}/post",
       json: {module: "test"})
     refute_nil response
     assert_equal 200, response.code
   end
 
   def test_module_put
-    response = Wreq.put("http://localhost:8080/put",
+    response = Wreq.put("#{HTTPBIN_URL}/put",
       json: {data: "test"})
     refute_nil response
     assert_equal 200, response.code
   end
 
   def test_module_delete
-    response = Wreq.delete("http://localhost:8080/delete")
+    response = Wreq.delete("#{HTTPBIN_URL}/delete")
     refute_nil response
     assert_equal 200, response.code
   end
 
   def test_module_patch
-    response = Wreq.patch("http://localhost:8080/patch",
+    response = Wreq.patch("#{HTTPBIN_URL}/patch",
       json: {update: "field"})
     refute_nil response
     assert_equal 200, response.code
@@ -37,23 +37,23 @@ class ModuleMethodsTest < Minitest::Test
   end
 
   def test_module_request_method
-    response = Wreq.request(Wreq::Method::GET, "http://localhost:8080/get")
+    response = Wreq.request(Wreq::Method::GET, "#{HTTPBIN_URL}/get")
     refute_nil response
     assert_equal 200, response.code
   end
 
   def test_module_methods_with_parameters
-    response = Wreq.get("http://localhost:8080/get",
+    response = Wreq.get("#{HTTPBIN_URL}/get",
       headers: {"Accept" => "application/json"},
       query: {"test" => "module"})
     refute_nil response
-    assert_equal response.url, "http://localhost:8080/get?test=module"
-    assert_includes response.text, "http://localhost:8080/get?test=module"
+    assert_equal "#{HTTPBIN_URL}/get?test=module", response.url
+    assert_equal "module", httpbin_fetch(response.json["args"], "test")
     assert_equal 200, response.code
   end
 
   def test_module_post_with_json
-    response = Wreq.post("http://localhost:8080/post",
+    response = Wreq.post("#{HTTPBIN_URL}/post",
       json: {
         string: "test",
         number: 123,
@@ -65,7 +65,7 @@ class ModuleMethodsTest < Minitest::Test
   end
 
   def test_module_post_with_form
-    response = Wreq.post("http://localhost:8080/post",
+    response = Wreq.post("#{HTTPBIN_URL}/post",
       form: {"field1" => "value1", "field2" => "value2"})
     refute_nil response
     assert_equal 200, response.code