wreq 1.2.2-x86_64-linux → 1.2.3-x86_64-linux

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

data/test/request_parameters_test.rb

@@ -2,7 +2,7 @@ require "test_helper"
 
 class RequestParametersTest < Minitest::Test
   def test_query_parameters
-    response = Wreq.get("http://localhost:8080/get",
+    response = Wreq.get("#{HTTPBIN_URL}/get",
       query: {
         "string" => "value",
         "number" => "123",
@@ -12,9 +12,9 @@ class RequestParametersTest < Minitest::Test
 
     json_data = response.json
     args = json_data["args"]
-    assert_equal "value", args["string"]
-    assert_equal "123", args["number"]  # Query params are strings
-    assert_equal "true", args["boolean"]
+    assert_equal "value", httpbin_fetch(args, "string")
+    assert_equal "123", httpbin_fetch(args, "number")  # Query params are strings
+    assert_equal "true", httpbin_fetch(args, "boolean")
   end
 
   def test_headers
@@ -24,15 +24,15 @@ class RequestParametersTest < Minitest::Test
       "Accept" => "application/json"
     }
 
-    response = Wreq.get("http://localhost:8080/get", headers: custom_headers)
+    response = Wreq.get("#{HTTPBIN_URL}/get", headers: custom_headers)
     assert_equal 200, response.code
 
     json_data = response.json
     request_headers = json_data["headers"]
 
-    assert_equal "custom-value", request_headers["X-Custom-Header"]
-    assert_equal "wreq-ruby-test/1.0", request_headers["User-Agent"]
-    assert_equal "application/json", request_headers["Accept"]
+    assert_equal "custom-value", httpbin_fetch(request_headers, "X-Custom-Header")
+    assert_equal "wreq-ruby-test/1.0", httpbin_fetch(request_headers, "User-Agent")
+    assert_equal "application/json", httpbin_fetch(request_headers, "Accept")
   end
 
   def test_json_body
@@ -44,7 +44,7 @@ class RequestParametersTest < Minitest::Test
       "object" => {"nested" => "value"}
     }
 
-    response = Wreq.post("http://localhost:8080/post", json: json_data)
+    response = Wreq.post("#{HTTPBIN_URL}/post", json: json_data)
     assert_equal 200, response.code
 
     response_data = response.json
@@ -64,19 +64,19 @@ class RequestParametersTest < Minitest::Test
       "number" => "123"
     }
 
-    response = Wreq.post("http://localhost:8080/post", form: form_data)
+    response = Wreq.post("#{HTTPBIN_URL}/post", form: form_data)
     assert_equal 200, response.code
 
     response_data = response.json
     sent_form = response_data["form"]
 
-    assert_equal "value1", sent_form["field1"]
-    assert_equal "value2", sent_form["field2"]
-    assert_equal "123", sent_form["number"]
+    assert_equal "value1", httpbin_fetch(sent_form, "field1")
+    assert_equal "value2", httpbin_fetch(sent_form, "field2")
+    assert_equal "123", httpbin_fetch(sent_form, "number")
   end
 
   def test_combined_parameters
-    response = Wreq.post("http://localhost:8080/post",
+    response = Wreq.post("#{HTTPBIN_URL}/post",
       query: {"q" => "search"},
       headers: {"X-Test" => "combined"},
       json: {"data" => "payload"})
@@ -86,10 +86,10 @@ class RequestParametersTest < Minitest::Test
     json_data = response.json
 
     # Check query parameters
-    assert_equal "search", json_data["args"]["q"]
+    assert_equal "search", httpbin_fetch(json_data["args"], "q")
 
     # Check headers
-    assert_equal "combined", json_data["headers"]["X-Test"]
+    assert_equal "combined", httpbin_fetch(json_data["headers"], "X-Test")
 
     # Check JSON body
     assert_equal "payload", json_data["json"]["data"]
@@ -97,7 +97,7 @@ class RequestParametersTest < Minitest::Test
 
   def test_empty_parameters
     # Test with no additional parameters
-    response = Wreq.get("http://localhost:8080/get")
+    response = Wreq.get("#{HTTPBIN_URL}/get")
     assert_equal 200, response.code
 
     json_data = response.json
@@ -113,16 +113,16 @@ class RequestParametersTest < Minitest::Test
       "url_chars" => "a=b&c=d"
     }
 
-    response = Wreq.get("http://localhost:8080/get", query: special_data)
+    response = Wreq.get("#{HTTPBIN_URL}/get", query: special_data)
     assert_equal 200, response.code
 
     json_data = response.json
     args = json_data["args"]
 
-    assert_equal "value with spaces", args["space"]
-    assert_equal "!@#$%^&*()", args["symbols"]
-    assert_equal "测试中文", args["unicode"]
-    assert_equal "a=b&c=d", args["url_chars"]
+    assert_equal "value with spaces", httpbin_fetch(args, "space")
+    assert_equal "!@#$%^&*()", httpbin_fetch(args, "symbols")
+    assert_equal "测试中文", httpbin_fetch(args, "unicode")
+    assert_equal "a=b&c=d", httpbin_fetch(args, "url_chars")
   end
 
   def test_nested_json_data
@@ -140,7 +140,7 @@ class RequestParametersTest < Minitest::Test
       }
     }
 
-    response = Wreq.post("http://localhost:8080/post", json: nested_data)
+    response = Wreq.post("#{HTTPBIN_URL}/post", json: nested_data)
     assert_equal 200, response.code
 
     response_data = response.json
@@ -153,11 +153,11 @@ class RequestParametersTest < Minitest::Test
 
   def test_method_specific_parameters
     methods_and_urls = {
-      get: "http://localhost:8080/get",
-      post: "http://localhost:8080/post",
-      put: "http://localhost:8080/put",
-      patch: "http://localhost:8080/patch",
-      delete: "http://localhost:8080/delete"
+      get: "#{HTTPBIN_URL}/get",
+      post: "#{HTTPBIN_URL}/post",
+      put: "#{HTTPBIN_URL}/put",
+      patch: "#{HTTPBIN_URL}/patch",
+      delete: "#{HTTPBIN_URL}/delete"
     }
 
     methods_and_urls.each do |method, url|
@@ -168,8 +168,8 @@ class RequestParametersTest < Minitest::Test
       assert_equal 200, response.code, "#{method} request failed"
 
       json_data = response.json
-      assert_equal method.to_s, json_data["headers"]["X-Method"]
-      assert_equal method.to_s, json_data["args"]["method"]
+      assert_equal method.to_s, httpbin_fetch(json_data["headers"], "X-Method")
+      assert_equal method.to_s, httpbin_fetch(json_data["args"], "method")
     end
   end
 end

data/test/request_test.rb

@@ -17,25 +17,25 @@ class WreqHttpbinTest < Minitest::Test
   end
 
   def test_module_get_method
-    response = Wreq.get("http://localhost:8080/get")
+    response = Wreq.get("#{HTTPBIN_URL}/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)
+    response = Wreq.post("#{HTTPBIN_URL}/post", json: data)
     assert_equal 200, response.code
   end
 
   def test_client_instance_basic
-    response = @client.get("http://localhost:8080/get")
+    response = @client.get("#{HTTPBIN_URL}/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)
+    response = @client.get("#{HTTPBIN_URL}/headers", headers: headers)
     assert_equal 200, response.code
   end
 
@@ -51,14 +51,14 @@ class WreqHttpbinTest < Minitest::Test
     ]
 
     methods.each do |method|
-      response = @client.request(method, "http://localhost:8080/#{method}")
+      response = @client.request(method, "#{HTTPBIN_URL}/anything")
       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)
+    response = Wreq.get("#{HTTPBIN_URL}/get", query: params)
     assert_equal 200, response.code
     assert_includes response.text, "param1=value1"
     assert_includes response.text, "param2=value2"
@@ -68,7 +68,7 @@ class WreqHttpbinTest < Minitest::Test
 
   def test_post_with_form_data
     data = {"field1" => "value1", "field2" => "value2", "field3" => 456, "field4" => false}
-    response = Wreq.post("http://localhost:8080/post", form: data)
+    response = Wreq.post("#{HTTPBIN_URL}/post", form: data)
     assert_equal 200, response.code
     assert_includes response.text, "field1"
     assert_includes response.text, "value1"
@@ -83,33 +83,33 @@ class WreqHttpbinTest < Minitest::Test
   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)
+    response = Wreq.post("#{HTTPBIN_URL}/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"])
+    response = Wreq.get("#{HTTPBIN_URL}/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")
+    response = Wreq.get("#{HTTPBIN_URL}/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)
+    response = Wreq.get("#{HTTPBIN_URL}/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)
+    response = Wreq.get("#{HTTPBIN_URL}/redirect/1", allow_redirects: false)
     assert_equal 302, response.code
   end
 
   def test_response_status_methods
-    response = Wreq.get("http://localhost:8080/status/200")
+    response = Wreq.get("#{HTTPBIN_URL}/status/200")
     assert_equal 200, response.code
 
     if response.status.respond_to?(:success?)
@@ -118,7 +118,7 @@ class WreqHttpbinTest < Minitest::Test
   end
 
   def test_404_response
-    response = Wreq.get("http://localhost:8080/status/404")
+    response = Wreq.get("#{HTTPBIN_URL}/status/404")
     assert_equal 404, response.code
 
     if response.status.respond_to?(:client_error?)
@@ -127,7 +127,7 @@ class WreqHttpbinTest < Minitest::Test
   end
 
   def test_json_response_parsing
-    response = Wreq.get("http://localhost:8080/json")
+    response = Wreq.get("#{HTTPBIN_URL}/json")
     assert_equal 200, response.code
 
     if response.respond_to?(:json)
@@ -137,12 +137,12 @@ class WreqHttpbinTest < Minitest::Test
   end
 
   def test_gzip_compression
-    response = Wreq.get("http://localhost:8080/gzip", gzip: true)
+    response = Wreq.get("#{HTTPBIN_URL}/gzip", gzip: true)
     assert_equal 200, response.code
   end
 
   def test_headers_iteration
-    response = Wreq.get("http://localhost:8080/get")
+    response = Wreq.get("#{HTTPBIN_URL}/get")
 
     if response.respond_to?(:each_header)
       count = 0
@@ -157,7 +157,7 @@ class WreqHttpbinTest < Minitest::Test
   end
 
   def test_response_properties
-    response = Wreq.get("http://localhost:8080/get")
+    response = Wreq.get("#{HTTPBIN_URL}/get")
 
     assert_respond_to response, :code
     assert_respond_to response, :status
@@ -171,12 +171,12 @@ class WreqHttpbinTest < Minitest::Test
   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)
+      Wreq.get("#{HTTPBIN_URL}/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)
+    response = Wreq.get("#{HTTPBIN_URL}/delay/1", timeout: 5)
     elapsed = Time.now - start_time
 
     assert_equal 200, response.code
@@ -187,7 +187,7 @@ class WreqHttpbinTest < Minitest::Test
     start_time = Time.now
 
     3.times do |i|
-      response = Wreq.get("http://localhost:8080/get?request=#{i}")
+      response = Wreq.get("#{HTTPBIN_URL}/get?request=#{i}")
       assert_equal 200, response.code
     end
 
@@ -212,7 +212,7 @@ class WreqHttpbinTest < Minitest::Test
     assert_instance_of Wreq::Client, client
 
     # Test that it can make requests
-    response = client.get("http://localhost:8080/get")
+    response = client.get("#{HTTPBIN_URL}/get")
     assert_equal 200, response.code
   end
 

data/test/response_test.rb

@@ -2,7 +2,7 @@ require "test_helper"
 
 class ResponseTest < Minitest::Test
   def setup
-    @response = Wreq.get("http://localhost:8080/json")
+    @response = Wreq.get("#{HTTPBIN_URL}/json")
   end
 
   def test_response_code
@@ -39,7 +39,7 @@ class ResponseTest < Minitest::Test
   end
 
   def test_response_with_non_json_content
-    response = Wreq.get("http://localhost:8080/html")
+    response = Wreq.get("#{HTTPBIN_URL}/html")
     assert_equal 200, response.code
     assert_instance_of String, response.text
     assert response.text.include?("<html>")
@@ -51,19 +51,19 @@ class ResponseTest < Minitest::Test
   def test_response_status_codes
     # Test different status codes
     [200, 404, 500].each do |status|
-      response = Wreq.get("http://localhost:8080/status/#{status}")
+      response = Wreq.get("#{HTTPBIN_URL}/status/#{status}")
       assert_equal status, response.code
     end
   end
 
   def test_response_with_query_parameters
-    response = Wreq.get("http://localhost:8080/get",
+    response = Wreq.get("#{HTTPBIN_URL}/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"]
+    assert_equal "value1", httpbin_fetch(args, "param1")
+    assert_equal "value2", httpbin_fetch(args, "param2")
   end
 end