wreq 1.0.0

data/test/header_test.rb

@@ -0,0 +1,290 @@
+require "test_helper"
+
+class HeadersTest < Minitest::Test
+  def setup
+    @response = Wreq.get("http://localhost:8080/response-headers",
+      query: {
+        "X-Custom-Header" => "custom-value",
+        "X-Multi-Header" => "value1"
+      })
+    @headers = @response.headers
+  end
+
+  def test_headers_class
+    assert_instance_of Wreq::Headers, @headers
+  end
+
+  def test_initialize
+    headers = Wreq::Headers.new
+    assert_instance_of Wreq::Headers, headers
+    assert headers.empty?
+    assert_equal 0, headers.length
+  end
+
+  def test_get_existing_header
+    # Content-Type should exist in response
+    content_type = @headers.get("Content-Type")
+    assert_instance_of String, content_type
+    refute_nil content_type
+  end
+
+  def test_get_case_insensitive
+    # Test case-insensitive lookup
+    value1 = @headers.get("content-type")
+    value2 = @headers.get("Content-Type")
+    value3 = @headers.get("CONTENT-TYPE")
+
+    assert_equal value1, value2
+    assert_equal value2, value3
+  end
+
+  def test_get_nonexistent_header
+    result = @headers.get("X-Nonexistent-Header-12345")
+    assert_nil result
+  end
+
+  def test_get_all_single_value
+    # Most headers have single values
+    values = @headers.get_all("Content-Type")
+    assert_instance_of Array, values
+    assert_equal 1, values.length
+    assert_equal @headers.get("Content-Type"), values.first
+  end
+
+  def test_get_all_nonexistent
+    values = @headers.get_all("X-Nonexistent-Header")
+    assert_instance_of Array, values
+    assert_equal 0, values.length
+    assert_empty values
+  end
+
+  def test_set_new_header
+    headers = Wreq::Headers.new
+    headers.set("X-Test-Header", "test-value")
+
+    assert_equal "test-value", headers.get("X-Test-Header")
+    assert_equal 1, headers.length
+  end
+
+  def test_set_replaces_existing
+    headers = Wreq::Headers.new
+    headers.set("X-Test", "value1")
+    headers.set("X-Test", "value2")
+
+    assert_equal "value2", headers.get("X-Test")
+    values = headers.get_all("X-Test")
+    assert_equal 1, values.length
+    assert_equal "value2", values.first
+  end
+
+  def test_append_to_new_header
+    headers = Wreq::Headers.new
+    headers.append("Accept", "application/json")
+
+    assert_equal "application/json", headers.get("Accept")
+  end
+
+  def test_append_to_existing_header
+    headers = Wreq::Headers.new
+    headers.set("Accept", "application/json")
+    headers.append("Accept", "text/html")
+    headers.append("Accept", "application/xml")
+
+    values = headers.get_all("Accept")
+    assert_equal 3, values.length
+    assert_includes values, "application/json"
+    assert_includes values, "text/html"
+    assert_includes values, "application/xml"
+  end
+
+  def test_remove_existing_header
+    headers = Wreq::Headers.new
+    headers.set("X-Remove-Me", "value")
+
+    removed_value = headers.remove("X-Remove-Me")
+    assert_equal "value", removed_value
+    assert_nil headers.get("X-Remove-Me")
+  end
+
+  def test_remove_nonexistent_header
+    headers = Wreq::Headers.new
+    result = headers.remove("X-Nonexistent")
+    assert_nil result
+  end
+
+  def test_delete_alias
+    headers = Wreq::Headers.new
+    headers.set("X-Delete-Me", "value")
+
+    removed_value = headers.remove("X-Delete-Me")
+    assert_equal "value", removed_value
+    assert_nil headers.get("X-Delete-Me")
+  end
+
+  def test_contains_existing
+    assert @headers.contains?("Content-Type")
+  end
+
+  def test_contains_nonexistent
+    refute @headers.contains?("X-Nonexistent-Header-12345")
+  end
+
+  def test_contains_case_insensitive
+    # If Content-Type exists
+    if @headers.contains?("Content-Type")
+      assert @headers.contains?("content-type")
+      assert @headers.contains?("CONTENT-TYPE")
+    end
+  end
+
+  def test_key_alias
+    # key? is an alias for contains?
+    assert_equal @headers.contains?("Content-Type"), @headers.key?("Content-Type")
+  end
+
+  def test_length
+    headers = Wreq::Headers.new
+    assert_equal 0, headers.length
+
+    headers.set("Header1", "value1")
+    assert_equal 1, headers.length
+
+    headers.set("Header2", "value2")
+    assert_equal 2, headers.length
+
+    # Setting same header shouldn't increase length
+    headers.set("Header1", "new-value")
+    assert_equal 2, headers.length
+  end
+
+  def test_empty_on_new_headers
+    headers = Wreq::Headers.new
+    assert headers.empty?
+  end
+
+  def test_empty_on_headers_with_data
+    refute @headers.empty?
+  end
+
+  def test_clear
+    headers = Wreq::Headers.new
+    headers.set("Header1", "value1")
+    headers.set("Header2", "value2")
+
+    refute headers.empty?
+    headers.clear
+    assert headers.empty?
+    assert_equal 0, headers.length
+  end
+
+  def test_keys
+    headers = Wreq::Headers.new
+    headers.set("Content-Type", "application/json")
+    headers.set("Authorization", "Bearer token")
+
+    keys = headers.keys
+    assert_instance_of Array, keys
+    assert_equal 2, keys.length
+    assert_includes keys, "content-type"
+    assert_includes keys, "authorization"
+  end
+
+  def test_keys_are_lowercase
+    headers = Wreq::Headers.new
+    headers.set("Content-Type", "text/html")
+    headers.set("X-Custom-Header", "value")
+
+    keys = headers.keys
+    keys.each do |key|
+      assert_equal key, key.downcase
+    end
+  end
+
+  def test_values
+    headers = Wreq::Headers.new
+    headers.set("Content-Type", "application/json")
+    headers.set("Authorization", "Bearer token")
+
+    values = headers.values
+    assert_instance_of Array, values
+    assert_equal 2, values.length
+    assert_includes values, "application/json"
+    assert_includes values, "Bearer token"
+  end
+
+  def test_each_with_block
+    headers = Wreq::Headers.new
+    headers.set("Header1", "value1")
+    headers.set("Header2", "value2")
+
+    collected = {}
+    headers.each do |name, value|
+      assert_instance_of String, name
+      assert_instance_of String, value
+      collected[name] = value
+    end
+
+    assert_equal 2, collected.length
+    assert_equal "value1", collected["header1"]
+    assert_equal "value2", collected["header2"]
+  end
+
+  def test_multiple_operations_sequence
+    headers = Wreq::Headers.new
+
+    # Add headers
+    headers.set("Content-Type", "application/json")
+    headers.set("Accept", "application/json")
+
+    assert_equal 2, headers.length
+
+    # Append to Accept
+    headers.append("Accept", "text/html")
+    assert_equal 2, headers.get_all("Accept").length
+
+    # Clear all
+    headers.clear
+    assert headers.empty?
+  end
+
+  def test_special_characters_in_header_values
+    headers = Wreq::Headers.new
+    special_value = "Bearer token-123_abc/xyz+456=789"
+    headers.set("Authorization", special_value)
+
+    assert_equal special_value, headers.get("Authorization")
+  end
+
+  def test_response_headers_integration
+    # Test that headers from actual HTTP response work correctly
+    assert_instance_of Wreq::Headers, @headers
+    refute @headers.empty?
+
+    # Should have common HTTP headers
+    assert @headers.length > 0
+  end
+
+  def test_response_headers_each
+    # Test iteration over real response headers
+    count = 0
+    @headers.each do |name, value|
+      assert_instance_of String, name
+      assert_instance_of String, value
+      count += 1
+    end
+
+    assert count > 0
+    assert_equal @headers.length, count
+  end
+
+  def test_headers_immutability_across_instances
+    headers1 = Wreq::Headers.new
+    headers2 = Wreq::Headers.new
+
+    headers1.set("X-Test", "value1")
+    headers2.set("X-Test", "value2")
+
+    assert_equal "value1", headers1.get("X-Test")
+    assert_equal "value2", headers2.get("X-Test")
+  end
+end

data/test/module_methods_test.rb

@@ -0,0 +1,75 @@
+require "test_helper"
+
+class ModuleMethodsTest < Minitest::Test
+  def test_module_get
+    response = Wreq.get("http://localhost:8080/get")
+    refute_nil response
+    assert_equal 200, response.code
+  end
+
+  def test_module_post
+    response = Wreq.post("http://localhost:8080/post",
+      json: {module: "test"})
+    refute_nil response
+    assert_equal 200, response.code
+  end
+
+  def test_module_put
+    response = Wreq.put("http://localhost:8080/put",
+      json: {data: "test"})
+    refute_nil response
+    assert_equal 200, response.code
+  end
+
+  def test_module_delete
+    response = Wreq.delete("http://localhost:8080/delete")
+    refute_nil response
+    assert_equal 200, response.code
+  end
+
+  def test_module_patch
+    response = Wreq.patch("http://localhost:8080/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, "http://localhost:8080/get")
+    refute_nil response
+    assert_equal 200, response.code
+  end
+
+  def test_module_methods_with_parameters
+    response = Wreq.get("http://localhost:8080/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 200, response.code
+  end
+
+  def test_module_post_with_json
+    response = Wreq.post("http://localhost:8080/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("http://localhost:8080/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/request_parameters_test.rb

@@ -0,0 +1,175 @@
+require "test_helper"
+
+class RequestParametersTest < Minitest::Test
+  def test_query_parameters
+    response = Wreq.get("http://localhost:8080/get",
+      query: {
+        "string" => "value",
+        "number" => "123",
+        "boolean" => "true"
+      })
+    assert_equal 200, response.code
+
+    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"]
+  end
+
+  def test_headers
+    custom_headers = {
+      "X-Custom-Header" => "custom-value",
+      "User-Agent" => "wreq-ruby-test/1.0",
+      "Accept" => "application/json"
+    }
+
+    response = Wreq.get("http://localhost:8080/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"]
+  end
+
+  def test_json_body
+    json_data = {
+      "string" => "test",
+      "number" => 42,
+      "boolean" => true,
+      "array" => [1, 2, 3],
+      "object" => {"nested" => "value"}
+    }
+
+    response = Wreq.post("http://localhost:8080/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("http://localhost:8080/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"]
+  end
+
+  def test_combined_parameters
+    response = Wreq.post("http://localhost:8080/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", json_data["args"]["q"]
+
+    # Check headers
+    assert_equal "combined", 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("http://localhost:8080/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("http://localhost:8080/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"]
+  end
+
+  def test_nested_json_data
+    nested_data = {
+      "level1" => {
+        "level2" => {
+          "level3" => {
+            "value" => "deep"
+          }
+        },
+        "array" => [
+          {"item" => 1},
+          {"item" => 2}
+        ]
+      }
+    }
+
+    response = Wreq.post("http://localhost:8080/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: "http://localhost:8080/get",
+      post: "http://localhost:8080/post",
+      put: "http://localhost:8080/put",
+      patch: "http://localhost:8080/patch",
+      delete: "http://localhost:8080/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, json_data["headers"]["X-Method"]
+      assert_equal method.to_s, json_data["args"]["method"]
+    end
+  end
+end