wreq 1.2.3-x64-mingw-ucrt

data/test/module_methods_test.rb

@@ -0,0 +1,75 @@
+require "test_helper"
+
+class ModuleMethodsTest < Minitest::Test
+  def test_module_get
+    response = Wreq.get("#{HTTPBIN_URL}/get")
+    refute_nil response
+    assert_equal 200, response.code
+  end
+
+  def test_module_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("#{HTTPBIN_URL}/put",
+      json: {data: "test"})
+    refute_nil response
+    assert_equal 200, response.code
+  end
+
+  def test_module_delete
+    response = Wreq.delete("#{HTTPBIN_URL}/delete")
+    refute_nil response
+    assert_equal 200, response.code
+  end
+
+  def test_module_patch
+    response = Wreq.patch("#{HTTPBIN_URL}/patch",
+      json: {update: "field"})
+    refute_nil response
+    assert_equal 200, response.code
+    assert_includes response.text, "update"
+    assert_includes response.text, "field"
+  end
+
+  def test_module_request_method
+    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("#{HTTPBIN_URL}/get",
+      headers: {"Accept" => "application/json"},
+      query: {"test" => "module"})
+    refute_nil response
+    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("#{HTTPBIN_URL}/post",
+      json: {
+        string: "test",
+        number: 123,
+        boolean: true,
+        array: [1, 2, 3]
+      })
+    refute_nil response
+    assert_equal 200, response.code
+  end
+
+  def test_module_post_with_form
+    response = Wreq.post("#{HTTPBIN_URL}/post",
+      form: {"field1" => "value1", "field2" => "value2"})
+    refute_nil response
+    assert_equal 200, response.code
+    assert_includes response.text, "field1"
+    assert_includes response.text, "field2"
+  end
+end

data/test/orig_header_test.rb

@@ -0,0 +1,115 @@
+require "test_helper"
+
+class OrigHeaderTest < Minitest::Test
+  URL = "https://tls.browserleaks.com/http1"
+
+  CASES = [
+    {
+      name: "mixed_case_descending",
+      headers: {
+        "X-Zeta-Token" => "zeta",
+        "x-alpha-key" => "alpha",
+        "X-MiXeD-CaSe" => "mixed"
+      },
+      orig_headers: ["X-Zeta-Token", "x-alpha-key", "X-MiXeD-CaSe"]
+    },
+    {
+      name: "reverse_alpha_order",
+      headers: {
+        "X-Third" => "3",
+        "X-Second" => "2",
+        "X-First" => "1"
+      },
+      orig_headers: ["X-Third", "X-Second", "X-First"]
+    },
+    {
+      name: "preserve_weird_casing",
+      headers: {
+        "x-a" => "a",
+        "X-B" => "b",
+        "x-C" => "c"
+      },
+      orig_headers: ["x-C", "x-a", "X-B"]
+    },
+    {
+      name: "interleaved_tokens",
+      headers: {
+        "X-Token-3" => "v3",
+        "X-Token-1" => "v1",
+        "X-Token-2" => "v2"
+      },
+      orig_headers: ["X-Token-1", "X-Token-2", "X-Token-3"]
+    }
+  ].freeze
+
+  def test_client_default_orig_headers_preserves_header_order_in_multiple_shuffled_cases
+    CASES.each do |kase|
+      client = Wreq::Client.new(
+        headers: kase[:headers],
+        orig_headers: kase[:orig_headers]
+      )
+
+      response = client.get(URL, version: Wreq::Version::HTTP_11)
+      assert_equal 200, response.code, "case=#{kase[:name]}"
+
+      echoed_headers = extract_http1_headers(response.json, kase[:name])
+      assert_header_order(echoed_headers, kase[:orig_headers], kase[:name])
+      assert_header_values(echoed_headers, kase[:headers], kase[:name])
+    end
+  end
+
+  def test_module_request_orig_headers_preserves_header_order_in_multiple_shuffled_cases
+    CASES.each do |kase|
+      response = Wreq.get(
+        URL,
+        headers: kase[:headers],
+        orig_headers: kase[:orig_headers],
+        version: Wreq::Version::HTTP_11
+      )
+      assert_equal 200, response.code, "case=#{kase[:name]}"
+
+      echoed_headers = extract_http1_headers(response.json, kase[:name])
+      assert_header_order(echoed_headers, kase[:orig_headers], kase[:name])
+      assert_header_values(echoed_headers, kase[:headers], kase[:name])
+    end
+  end
+
+  private
+
+  def extract_http1_headers(json, case_name)
+    http1 = fetch_by_name(json, "http1")
+    refute_nil http1, "case=#{case_name}: expected JSON key 'http1', got #{json.keys.inspect}"
+
+    headers = fetch_by_name(http1, "headers")
+    refute_nil headers, "case=#{case_name}: expected JSON key 'http1.headers'"
+    headers
+  end
+
+  def fetch_by_name(hash_like, key_name)
+    return hash_like[key_name] if hash_like.respond_to?(:key?) && hash_like.key?(key_name)
+    return hash_like[key_name.to_sym] if hash_like.respond_to?(:key?) && hash_like.key?(key_name.to_sym)
+
+    pair = hash_like.find { |k, _| k.to_s == key_name }
+    pair&.last
+  end
+
+  def assert_header_order(echoed_headers, ordered_names, case_name)
+    echoed_keys = echoed_headers.keys
+    positions = ordered_names.map do |expected_name|
+      index = echoed_keys.index(expected_name)
+      refute_nil index, "case=#{case_name}: expected header to exist in echo: #{expected_name}"
+      index
+    end
+
+    assert_equal positions.sort, positions,
+      "case=#{case_name}: expected header order #{ordered_names.inspect}, got keys #{echoed_keys.inspect}"
+  end
+
+  def assert_header_values(echoed_headers, expected_headers, case_name)
+    expected_headers.each do |name, expected_value|
+      assert echoed_headers.key?(name),
+        "case=#{case_name}: expected exact-case header name #{name}, got #{echoed_headers.keys.inspect}"
+      assert_equal expected_value, echoed_headers[name]
+    end
+  end
+end

data/test/request_parameters_test.rb

@@ -0,0 +1,175 @@
+require "test_helper"
+
+class RequestParametersTest < Minitest::Test
+  def test_query_parameters
+    response = Wreq.get("#{HTTPBIN_URL}/get",
+      query: {
+        "string" => "value",
+        "number" => "123",
+        "boolean" => "true"
+      })
+    assert_equal 200, response.code
+
+    json_data = response.json
+    args = json_data["args"]
+    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
+    custom_headers = {
+      "X-Custom-Header" => "custom-value",
+      "User-Agent" => "wreq-ruby-test/1.0",
+      "Accept" => "application/json"
+    }
+
+    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", 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
+    json_data = {
+      "string" => "test",
+      "number" => 42,
+      "boolean" => true,
+      "array" => [1, 2, 3],
+      "object" => {"nested" => "value"}
+    }
+
+    response = Wreq.post("#{HTTPBIN_URL}/post", json: json_data)
+    assert_equal 200, response.code
+
+    response_data = response.json
+    sent_data = response_data["json"]
+
+    assert_equal "test", sent_data["string"]
+    assert_equal 42, sent_data["number"]
+    assert_equal true, sent_data["boolean"]
+    assert_equal [1, 2, 3], sent_data["array"]
+    assert_equal({"nested" => "value"}, sent_data["object"])
+  end
+
+  def test_form_body
+    form_data = {
+      "field1" => "value1",
+      "field2" => "value2",
+      "number" => "123"
+    }
+
+    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", 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("#{HTTPBIN_URL}/post",
+      query: {"q" => "search"},
+      headers: {"X-Test" => "combined"},
+      json: {"data" => "payload"})
+
+    assert_equal 200, response.code
+
+    json_data = response.json
+
+    # Check query parameters
+    assert_equal "search", httpbin_fetch(json_data["args"], "q")
+
+    # Check headers
+    assert_equal "combined", httpbin_fetch(json_data["headers"], "X-Test")
+
+    # Check JSON body
+    assert_equal "payload", json_data["json"]["data"]
+  end
+
+  def test_empty_parameters
+    # Test with no additional parameters
+    response = Wreq.get("#{HTTPBIN_URL}/get")
+    assert_equal 200, response.code
+
+    json_data = response.json
+    assert_instance_of Hash, json_data["args"]
+    assert json_data["args"].empty?
+  end
+
+  def test_special_characters_in_query
+    special_data = {
+      "space" => "value with spaces",
+      "symbols" => "!@#$%^&*()",
+      "unicode" => "测试中文",
+      "url_chars" => "a=b&c=d"
+    }
+
+    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", 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
+    nested_data = {
+      "level1" => {
+        "level2" => {
+          "level3" => {
+            "value" => "deep"
+          }
+        },
+        "array" => [
+          {"item" => 1},
+          {"item" => 2}
+        ]
+      }
+    }
+
+    response = Wreq.post("#{HTTPBIN_URL}/post", json: nested_data)
+    assert_equal 200, response.code
+
+    response_data = response.json
+    sent_json = response_data["json"]
+
+    assert_equal "deep", sent_json["level1"]["level2"]["level3"]["value"]
+    assert_equal 1, sent_json["level1"]["array"][0]["item"]
+    assert_equal 2, sent_json["level1"]["array"][1]["item"]
+  end
+
+  def test_method_specific_parameters
+    methods_and_urls = {
+      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|
+      response = Wreq.send(method, url,
+        headers: {"X-Method" => method.to_s},
+        query: {"method" => method.to_s})
+
+      assert_equal 200, response.code, "#{method} request failed"
+
+      json_data = response.json
+      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

@@ -0,0 +1,244 @@
+require "test_helper"
+
+class WreqHttpbinTest < Minitest::Test
+  def setup
+    # Ensure we have a working client
+    @client = Wreq::Client.new(timeout: 30)
+  end
+
+  def test_spec_http1_version
+    response = Wreq.get("https://tls.browserleaks.com", version: Wreq::Version::HTTP_11)
+    assert_equal response.version, Wreq::Version::HTTP_11
+  end
+
+  def test_spec_http2_version
+    response = Wreq.get("https://tls.browserleaks.com", version: Wreq::Version::HTTP_2)
+    assert_equal response.version, Wreq::Version::HTTP_2
+  end
+
+  def test_module_get_method
+    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("#{HTTPBIN_URL}/post", json: data)
+    assert_equal 200, response.code
+  end
+
+  def test_client_instance_basic
+    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("#{HTTPBIN_URL}/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, "#{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("#{HTTPBIN_URL}/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("#{HTTPBIN_URL}/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("#{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("#{HTTPBIN_URL}/basic-auth/user/pass", basic_auth: ["user", "pass"])
+    assert_equal 200, response.code
+  end
+
+  def test_bearer_authentication
+    response = Wreq.get("#{HTTPBIN_URL}/bearer", bearer_auth: "test-token")
+    assert_equal 200, response.code
+  end
+
+  def test_redirect_following
+    response = Wreq.get("#{HTTPBIN_URL}/redirect/2", allow_redirects: true)
+    assert_equal 200, response.code
+  end
+
+  def test_redirect_blocking
+    response = Wreq.get("#{HTTPBIN_URL}/redirect/1", allow_redirects: false)
+    assert_equal 302, response.code
+  end
+
+  def test_response_status_methods
+    response = Wreq.get("#{HTTPBIN_URL}/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("#{HTTPBIN_URL}/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("#{HTTPBIN_URL}/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("#{HTTPBIN_URL}/gzip", gzip: true)
+    assert_equal 200, response.code
+  end
+
+  def test_headers_iteration
+    response = Wreq.get("#{HTTPBIN_URL}/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("#{HTTPBIN_URL}/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("#{HTTPBIN_URL}/delay/10", timeout: 1)
+    end
+
+    # Test that reasonable timeouts work normally
+    start_time = Time.now
+    response = Wreq.get("#{HTTPBIN_URL}/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("#{HTTPBIN_URL}/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("#{HTTPBIN_URL}/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("#{HTTPBIN_URL}/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("#{HTTPBIN_URL}/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("#{HTTPBIN_URL}/status/#{status}")
+      assert_equal status, response.code
+    end
+  end
+
+  def test_response_with_query_parameters
+    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", httpbin_fetch(args, "param1")
+    assert_equal "value2", httpbin_fetch(args, "param2")
+  end
+end