http 5.3.1 → 6.0.0

data/test/http/mime_type/json_test.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+class HTTPMimeTypeJSONTest < Minitest::Test
+  cover "HTTP::MimeType*"
+
+  def adapter
+    @adapter ||= HTTP::MimeType::JSON.send(:new)
+  end
+
+  def test_encode_uses_to_json_when_available
+    assert_equal '{"foo":"bar"}', adapter.encode(foo: "bar")
+  end
+
+  def test_encode_prefers_to_json_over_json_dump
+    obj = Object.new
+    def obj.to_json(*args)
+      args.empty? ? '"direct"' : '"via_dump"'
+    end
+
+    assert_equal '"direct"', adapter.encode(obj)
+  end
+
+  def test_encode_falls_back_to_json_dump_for_objects_without_to_json
+    obj = Object.new
+    obj.define_singleton_method(:respond_to?) do |method, *args|
+      return false if method == :to_json
+
+      super(method, *args)
+    end
+
+    assert_kind_of String, adapter.encode(obj)
+  end
+
+  def test_decode_parses_json_strings
+    assert_equal({ "foo" => "bar" }, adapter.decode('{"foo":"bar"}'))
+  end
+end

data/test/http/mime_type_test.rb

@@ -0,0 +1,150 @@
+# frozen_string_literal: true
+
+require "test_helper"
+require "securerandom"
+
+class HTTPMimeTypeTest < Minitest::Test
+  cover "HTTP::MimeType*"
+
+  def sample_type
+    @sample_type ||= "application/mutant-check-#{SecureRandom.hex(4)}"
+  end
+
+  def sample_adapter
+    @sample_adapter ||= Module.new do
+      def self.encode(obj); end
+
+      def self.decode(str); end
+    end
+  end
+
+  def test_register_adapter_stores_the_adapter_retrievable_via_brackets
+    HTTP::MimeType.register_adapter(sample_type, sample_adapter)
+
+    assert_same sample_adapter, HTTP::MimeType[sample_type]
+  end
+
+  def test_register_adapter_calls_to_s_on_the_type_argument
+    type_str = "application/test-to-s-#{SecureRandom.hex(4)}"
+    type_obj = fake(to_s: type_str)
+
+    HTTP::MimeType.register_adapter(type_obj, sample_adapter)
+
+    assert_same sample_adapter, HTTP::MimeType[type_str]
+  end
+
+  def test_brackets_retrieves_a_registered_adapter
+    HTTP::MimeType.register_adapter(sample_type, sample_adapter)
+
+    assert_same sample_adapter, HTTP::MimeType[sample_type]
+  end
+
+  def test_brackets_raises_unsupported_mime_type_error_for_unknown_type
+    assert_raises(HTTP::UnsupportedMimeTypeError) do
+      HTTP::MimeType["application/nonexistent-#{SecureRandom.hex(4)}"]
+    end
+  end
+
+  def test_brackets_includes_the_type_in_the_error_message
+    unknown = "application/unknown-#{SecureRandom.hex(4)}"
+
+    err = assert_raises(HTTP::UnsupportedMimeTypeError) do
+      HTTP::MimeType[unknown]
+    end
+    assert_includes err.message, unknown
+  end
+
+  def test_brackets_resolves_aliases_when_looking_up_adapters
+    shortcut = :"test_shortcut_#{SecureRandom.hex(4)}"
+    HTTP::MimeType.register_adapter(sample_type, sample_adapter)
+    HTTP::MimeType.register_alias(sample_type, shortcut)
+
+    assert_same sample_adapter, HTTP::MimeType[shortcut]
+  end
+
+  def test_register_alias_stores_alias_resolvable_via_normalize
+    shortcut = :"test_alias_#{SecureRandom.hex(4)}"
+    HTTP::MimeType.register_alias(sample_type, shortcut)
+
+    assert_equal sample_type, HTTP::MimeType.normalize(shortcut)
+  end
+
+  def test_register_alias_calls_to_sym_on_the_shortcut_argument
+    shortcut_str = "test_sym_shortcut_#{SecureRandom.hex(4)}"
+    HTTP::MimeType.register_alias(sample_type, shortcut_str)
+
+    assert_equal sample_type, HTTP::MimeType.normalize(shortcut_str.to_sym)
+  end
+
+  def test_register_alias_calls_to_s_on_the_type_argument
+    type_str = "application/test-alias-to-s-#{SecureRandom.hex(4)}"
+    type_obj = fake(to_s: type_str)
+
+    shortcut = :"test_alias_to_s_#{SecureRandom.hex(4)}"
+    HTTP::MimeType.register_alias(type_obj, shortcut)
+
+    assert_equal type_str, HTTP::MimeType.normalize(shortcut)
+  end
+
+  def test_normalize_returns_the_type_string_if_no_alias_found
+    unaliased = "application/no-alias-#{SecureRandom.hex(4)}"
+
+    assert_equal unaliased, HTTP::MimeType.normalize(unaliased)
+  end
+
+  def test_normalize_returns_aliased_type_if_alias_exists
+    shortcut = :"test_norm_#{SecureRandom.hex(4)}"
+    HTTP::MimeType.register_alias(sample_type, shortcut)
+
+    assert_equal sample_type, HTTP::MimeType.normalize(shortcut)
+  end
+
+  def test_normalize_calls_to_s_on_the_argument_when_no_alias_found
+    type_str = "application/normalize-to-s-#{SecureRandom.hex(4)}"
+    type_obj = fake(to_s: type_str)
+
+    assert_equal type_str, HTTP::MimeType.normalize(type_obj)
+  end
+
+  def test_adapters_initializes_as_a_hash_when_accessed_for_the_first_time
+    original = HTTP::MimeType.instance_variable_get(:@adapters)
+    HTTP::MimeType.instance_variable_set(:@adapters, nil)
+    begin
+      result = HTTP::MimeType.send(:adapters)
+
+      assert_instance_of Hash, result
+    ensure
+      HTTP::MimeType.instance_variable_set(:@adapters, original)
+    end
+  end
+
+  def test_aliases_initializes_as_a_hash_when_accessed_for_the_first_time
+    original = HTTP::MimeType.instance_variable_get(:@aliases)
+    HTTP::MimeType.instance_variable_set(:@aliases, nil)
+    begin
+      result = HTTP::MimeType.send(:aliases)
+
+      assert_instance_of Hash, result
+    ensure
+      HTTP::MimeType.instance_variable_set(:@aliases, original)
+    end
+  end
+
+  def test_adapter_raises_error_on_encode_with_class_name_in_message
+    err = assert_raises(HTTP::Error) { HTTP::MimeType::Adapter.instance.encode("data") }
+    assert_equal "HTTP::MimeType::Adapter does not supports #encode", err.message
+  end
+
+  def test_adapter_raises_error_on_decode_with_class_name_in_message
+    err = assert_raises(HTTP::Error) { HTTP::MimeType::Adapter.instance.decode("data") }
+    assert_equal "HTTP::MimeType::Adapter does not supports #decode", err.message
+  end
+
+  def test_builtin_has_json_adapter_registered_for_application_json
+    assert_equal HTTP::MimeType::JSON, HTTP::MimeType["application/json"]
+  end
+
+  def test_builtin_has_json_alias_for_application_json
+    assert_equal "application/json", HTTP::MimeType.normalize(:json)
+  end
+end

data/test/http/options/base_uri_test.rb

@@ -0,0 +1,148 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+class HTTPOptionsBaseURITest < Minitest::Test
+  cover "HTTP::Options*"
+
+  # #with_base_uri
+
+  def test_with_base_uri_sets_base_uri_from_a_string
+    opts = HTTP::Options.new
+    result = opts.with_base_uri("https://example.com/api")
+
+    assert_equal "https://example.com/api", result.base_uri.to_s
+  end
+
+  def test_with_base_uri_sets_base_uri_from_an_http_uri
+    opts = HTTP::Options.new
+    uri = HTTP::URI.parse("https://example.com/api")
+    result = opts.with_base_uri(uri)
+
+    assert_equal "https://example.com/api", result.base_uri.to_s
+  end
+
+  def test_with_base_uri_raises_for_uri_without_scheme
+    opts = HTTP::Options.new
+    err = assert_raises(HTTP::Error) { opts.with_base_uri("/users") }
+
+    assert_includes err.message, "Invalid base URI"
+    assert_includes err.message, "/users"
+  end
+
+  def test_with_base_uri_raises_for_protocol_relative_uri
+    opts = HTTP::Options.new
+    err = assert_raises(HTTP::Error) { opts.with_base_uri("//example.com/users") }
+
+    assert_includes err.message, "Invalid base URI"
+    assert_includes err.message, "//example.com/users"
+  end
+
+  def test_with_base_uri_does_not_modify_the_original_options
+    opts = HTTP::Options.new
+    opts.with_base_uri("https://example.com")
+
+    refute_predicate opts, :base_uri?
+  end
+
+  # #base_uri?
+
+  def test_base_uri_predicate_returns_false_by_default
+    opts = HTTP::Options.new
+
+    refute_predicate opts, :base_uri?
+  end
+
+  def test_base_uri_predicate_returns_true_when_base_uri_is_set
+    opts = HTTP::Options.new
+    result = opts.with_base_uri("https://example.com")
+
+    assert_predicate result, :base_uri?
+  end
+
+  # chaining base URIs
+
+  def test_chaining_joins_a_relative_path_onto_existing_base_uri
+    opts = HTTP::Options.new
+    result = opts.with_base_uri("https://example.com").with_base_uri("api/v1")
+
+    assert_equal "https://example.com/api/v1", result.base_uri.to_s
+  end
+
+  def test_chaining_joins_an_absolute_path_onto_existing_base_uri
+    opts = HTTP::Options.new
+    result = opts.with_base_uri("https://example.com/api").with_base_uri("/v2")
+
+    assert_equal "https://example.com/v2", result.base_uri.to_s
+  end
+
+  def test_chaining_replaces_with_a_full_uri
+    opts = HTTP::Options.new
+    result = opts.with_base_uri("https://example.com/api").with_base_uri("https://other.com/v2")
+
+    assert_equal "https://other.com/v2", result.base_uri.to_s
+  end
+
+  def test_chaining_joins_onto_base_uri_with_trailing_slash
+    opts = HTTP::Options.new
+    result = opts.with_base_uri("https://example.com/api/").with_base_uri("v2")
+
+    assert_equal "https://example.com/api/v2", result.base_uri.to_s
+  end
+
+  def test_chaining_handles_parent_path_traversal
+    opts = HTTP::Options.new
+    result = opts.with_base_uri("https://example.com/api/v1").with_base_uri("../v2")
+
+    assert_equal "https://example.com/api/v2", result.base_uri.to_s
+  end
+
+  def test_chaining_does_not_mutate_the_intermediate_base_uri
+    opts = HTTP::Options.new
+    intermediate = opts.with_base_uri("https://example.com/api")
+    intermediate.with_base_uri("v2")
+
+    assert_equal "https://example.com/api", intermediate.base_uri.to_s
+  end
+
+  # persistent and base_uri interaction
+
+  def test_persistent_allows_compatible_persistent_and_base_uri
+    opts = HTTP::Options.new
+    result = opts.with_base_uri("https://example.com/api").with_persistent("https://example.com")
+
+    assert_equal "https://example.com/api", result.base_uri.to_s
+    assert_equal "https://example.com", result.persistent
+  end
+
+  def test_persistent_raises_when_persistent_origin_conflicts_with_base_uri
+    opts = HTTP::Options.new
+    with_base = opts.with_base_uri("https://example.com/api")
+
+    err = assert_raises(HTTP::Error) { with_base.with_persistent("https://other.com") }
+    assert_includes err.message, "https://other.com"
+    assert_includes err.message, "base URI origin (https://example.com)"
+  end
+
+  def test_persistent_raises_when_base_uri_origin_conflicts_with_persistent
+    opts = HTTP::Options.new
+    with_persistent = opts.with_persistent("https://example.com")
+
+    err = assert_raises(HTTP::Error) { with_persistent.with_base_uri("https://other.com/api") }
+    assert_includes err.message, "https://example.com"
+    assert_includes err.message, "base URI origin (https://other.com)"
+  end
+
+  def test_persistent_allows_setting_both_via_constructor_when_origins_match
+    result = HTTP::Options.new(base_uri: "https://example.com/api", persistent: "https://example.com")
+
+    assert_equal "https://example.com/api", result.base_uri.to_s
+    assert_equal "https://example.com", result.persistent
+  end
+
+  def test_persistent_raises_via_constructor_when_origins_conflict
+    assert_raises(HTTP::Error) do
+      HTTP::Options.new(base_uri: "https://example.com/api", persistent: "https://other.com")
+    end
+  end
+end

data/test/http/options/body_test.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+class HTTPOptionsBodyTest < Minitest::Test
+  cover "HTTP::Options*"
+
+  def test_defaults_to_nil
+    opts = HTTP::Options.new
+
+    assert_nil opts.body
+  end
+
+  def test_may_be_specified_with_with_body
+    opts = HTTP::Options.new
+    opts2 = opts.with_body("foo")
+
+    assert_nil opts.body
+    assert_equal "foo", opts2.body
+  end
+end

data/test/http/options/features_test.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+class HTTPOptionsFeaturesTest < Minitest::Test
+  cover "HTTP::Options*"
+
+  def test_defaults_to_be_empty
+    opts = HTTP::Options.new
+
+    assert_empty opts.features
+  end
+
+  def test_accepts_plain_symbols_in_array
+    opts = HTTP::Options.new
+    opts2 = opts.with_features([:auto_inflate])
+
+    assert_empty opts.features
+    assert_equal [:auto_inflate], opts2.features.keys
+    assert_instance_of HTTP::Features::AutoInflate, opts2.features[:auto_inflate]
+  end
+
+  def test_accepts_feature_name_with_its_options_in_array
+    opts = HTTP::Options.new
+    opts2 = opts.with_features([{ auto_deflate: { method: :deflate } }])
+
+    assert_empty opts.features
+    assert_equal [:auto_deflate], opts2.features.keys
+    assert_instance_of HTTP::Features::AutoDeflate, opts2.features[:auto_deflate]
+    assert_equal "deflate", opts2.features[:auto_deflate].method
+  end
+
+  def test_raises_error_for_not_supported_features
+    opts = HTTP::Options.new
+    error = assert_raises(HTTP::Error) { opts.with_features([:wrong_feature]) }
+    assert_equal "Unsupported feature: wrong_feature", error.message
+  end
+end

data/test/http/options/form_test.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+class HTTPOptionsFormTest < Minitest::Test
+  cover "HTTP::Options*"
+
+  def test_defaults_to_nil
+    opts = HTTP::Options.new
+
+    assert_nil opts.form
+  end
+
+  def test_may_be_specified_with_with_form_data
+    opts = HTTP::Options.new
+    opts2 = opts.with_form(foo: 42)
+
+    assert_nil opts.form
+    assert_equal({ foo: 42 }, opts2.form)
+  end
+end

data/test/http/options/headers_test.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+class HTTPOptionsHeadersTest < Minitest::Test
+  cover "HTTP::Options*"
+
+  def test_defaults_to_be_empty
+    opts = HTTP::Options.new
+
+    assert_empty opts.headers
+  end
+
+  def test_may_be_specified_with_with_headers
+    opts = HTTP::Options.new
+    opts2 = opts.with_headers(accept: "json")
+
+    assert_empty opts.headers
+    assert_equal [%w[Accept json]], opts2.headers.to_a
+  end
+
+  def test_accepts_any_object_that_respond_to_to_hash
+    opts = HTTP::Options.new
+    x = if RUBY_VERSION >= "3.2.0"
+          Data.define(:to_hash).new(to_hash: { "accept" => "json" })
+        else
+          Struct.new(:to_hash).new({ "accept" => "json" })
+        end
+
+    assert_equal "json", opts.with_headers(x).headers["accept"]
+  end
+end

data/test/http/options/json_test.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+class HTTPOptionsJSONTest < Minitest::Test
+  cover "HTTP::Options*"
+
+  def test_defaults_to_nil
+    opts = HTTP::Options.new
+
+    assert_nil opts.json
+  end
+
+  def test_may_be_specified_with_with_json_data
+    opts = HTTP::Options.new
+    opts2 = opts.with_json(foo: 42)
+
+    assert_nil opts.json
+    assert_equal({ foo: 42 }, opts2.json)
+  end
+end

data/test/http/options/merge_test.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+class HTTPOptionsMergeTest < Minitest::Test
+  cover "HTTP::Options*"
+
+  def test_supports_a_hash
+    opts = HTTP::Options.new
+    old_response = opts.response
+
+    assert_equal :body, opts.merge(response: :body).response
+    assert_equal old_response, opts.response
+  end
+
+  def test_supports_another_options
+    opts = HTTP::Options.new
+    merged = opts.merge(HTTP::Options.new(response: :body))
+
+    assert_equal :body, merged.response
+  end
+
+  def test_merges_as_expected_in_complex_cases
+    # FIXME: yuck :(
+
+    foo = HTTP::Options.new(
+      response: :body,
+      params:   { baz: "bar" },
+      form:     { foo: "foo" },
+      body:     "body-foo",
+      json:     { foo: "foo" },
+      headers:  { accept: "json", foo: "foo" },
+      proxy:    {},
+      features: {}
+    )
+
+    bar = HTTP::Options.new(
+      response:           :parsed_body,
+      persistent:         "https://www.googe.com",
+      params:             { plop: "plip" },
+      form:               { bar: "bar" },
+      body:               "body-bar",
+      json:               { bar: "bar" },
+      keep_alive_timeout: 10,
+      headers:            { accept: "xml", bar: "bar" },
+      timeout_options:    { foo: :bar },
+      ssl:                { foo: "bar" },
+      proxy:              { proxy_address: "127.0.0.1", proxy_port: 8080 }
+    )
+
+    assert_equal(
+      {
+        response:           :parsed_body,
+        timeout_class:      HTTP::Options.default_timeout_class,
+        timeout_options:    { foo: :bar },
+        params:             { plop: "plip" },
+        form:               { bar: "bar" },
+        body:               "body-bar",
+        json:               { bar: "bar" },
+        persistent:         "https://www.googe.com",
+        keep_alive_timeout: 10,
+        ssl:                { foo: "bar" },
+        headers:            { "Foo" => "foo", "Accept" => "xml", "Bar" => "bar" },
+        proxy:              { proxy_address: "127.0.0.1", proxy_port: 8080 },
+        follow:             nil,
+        retriable:          nil,
+        base_uri:           nil,
+        socket_class:       HTTP::Options.default_socket_class,
+        nodelay:            false,
+        ssl_socket_class:   HTTP::Options.default_ssl_socket_class,
+        ssl_context:        nil,
+        encoding:           nil,
+        features:           {}
+      },
+      foo.merge(bar).to_hash
+    )
+  end
+end

data/test/http/options/new_test.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+class HTTPOptionsNewTest < Minitest::Test
+  cover "HTTP::Options*"
+
+  def test_supports_a_options_instance
+    opts = HTTP::Options.new
+
+    assert_equal opts, HTTP::Options.new(opts)
+  end
+
+  def test_with_a_hash_coerces_response_correctly
+    opts = HTTP::Options.new(response: :object)
+
+    assert_equal :object, opts.response
+  end
+
+  def test_with_a_hash_coerces_headers_correctly
+    opts = HTTP::Options.new(headers: { accept: "json" })
+
+    assert_equal [%w[Accept json]], opts.headers.to_a
+  end
+
+  def test_with_a_hash_coerces_proxy_correctly
+    opts = HTTP::Options.new(proxy: { proxy_address: "127.0.0.1", proxy_port: 8080 })
+
+    assert_equal({ proxy_address: "127.0.0.1", proxy_port: 8080 }, opts.proxy)
+  end
+
+  def test_with_a_hash_coerces_form_correctly
+    opts = HTTP::Options.new(form: { foo: 42 })
+
+    assert_equal({ foo: 42 }, opts.form)
+  end
+end

data/test/http/options/proxy_test.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+class HTTPOptionsProxyTest < Minitest::Test
+  cover "HTTP::Options*"
+
+  def test_defaults_to_empty_hash
+    opts = HTTP::Options.new
+
+    assert_equal({}, opts.proxy)
+  end
+
+  def test_may_be_specified_with_with_proxy
+    opts = HTTP::Options.new
+    opts2 = opts.with_proxy(proxy_address: "127.0.0.1", proxy_port: 8080)
+
+    assert_equal({}, opts.proxy)
+    assert_equal({ proxy_address: "127.0.0.1", proxy_port: 8080 }, opts2.proxy)
+  end
+
+  def test_accepts_proxy_address_port_username_and_password
+    opts = HTTP::Options.new
+    opts2 = opts.with_proxy(proxy_address: "127.0.0.1", proxy_port: 8080, proxy_username: "username",
+                            proxy_password: "password")
+
+    assert_equal(
+      { proxy_address: "127.0.0.1", proxy_port: 8080, proxy_username: "username",
+proxy_password: "password" }, opts2.proxy
+    )
+  end
+end