http 5.3.1 → 6.0.0

data/test/http/timeout/null_test.rb

@@ -0,0 +1,218 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+class HTTPTimeoutNullTest < Minitest::Test
+  cover "HTTP::Timeout::Null*"
+
+  def setup
+    super
+    @io = fake(wait_readable: true, wait_writable: true)
+    @socket = fake(to_io: @io, closed?: false)
+    @timeout = HTTP::Timeout::Null.new
+    @timeout.instance_variable_set(:@socket, @socket)
+  end
+
+  # -- #initialize --
+
+  def test_initialize_stores_provided_options_compacted
+    t = HTTP::Timeout::Null.new(read_timeout: 5, write_timeout: 10)
+
+    assert_equal({ read_timeout: 5, write_timeout: 10 }, t.options)
+  end
+
+  # -- #start_tls --
+
+  def test_start_tls_skips_hostname_and_sync_close_when_not_responding
+    ssl_socket = fake(connect: nil)
+    ssl_socket_class = fake(new: ssl_socket)
+    ssl_context = OpenSSL::SSL::SSLContext.new
+    ssl_context.verify_mode = OpenSSL::SSL::VERIFY_NONE
+    @timeout.start_tls("example.com", ssl_socket_class, ssl_context)
+  end
+
+  def test_start_tls_skips_post_connection_check_when_verify_mode_not_verify_peer
+    post_connection_check_called = false
+    ssl_socket = fake(
+      connect:               nil,
+      "hostname=":           ->(*) {},
+      "sync_close=":         ->(*) {},
+      post_connection_check: ->(*) { post_connection_check_called = true }
+    )
+    ssl_socket_class = fake(new: ssl_socket)
+    ssl_context = OpenSSL::SSL::SSLContext.new
+    ssl_context.verify_mode = OpenSSL::SSL::VERIFY_NONE
+    @timeout.start_tls("example.com", ssl_socket_class, ssl_context)
+
+    refute post_connection_check_called
+  end
+
+  def test_start_tls_calls_post_connection_check_when_verify_peer_and_verify_hostname
+    post_connection_check_called = false
+    post_connection_check_arg = nil
+    ssl_socket = fake(
+      connect:               nil,
+      "hostname=":           ->(*) {},
+      "sync_close=":         ->(*) {},
+      post_connection_check: lambda { |host|
+        post_connection_check_called = true
+        post_connection_check_arg = host
+      }
+    )
+    ssl_socket_class = fake(new: ssl_socket)
+    ssl_context = OpenSSL::SSL::SSLContext.new
+    ssl_context.verify_mode = OpenSSL::SSL::VERIFY_PEER
+    ssl_context.verify_hostname = true
+    @timeout.start_tls("example.com", ssl_socket_class, ssl_context)
+
+    assert post_connection_check_called
+    assert_equal "example.com", post_connection_check_arg
+  end
+
+  def test_start_tls_skips_post_connection_check_when_verify_hostname_false
+    post_connection_check_called = false
+    ssl_socket = fake(
+      connect:               nil,
+      "hostname=":           ->(*) {},
+      "sync_close=":         ->(*) {},
+      post_connection_check: ->(*) { post_connection_check_called = true }
+    )
+    ssl_socket_class = fake(new: ssl_socket)
+    ssl_context = OpenSSL::SSL::SSLContext.new
+    ssl_context.verify_mode = OpenSSL::SSL::VERIFY_PEER
+    ssl_context.verify_hostname = false
+    @timeout.start_tls("example.com", ssl_socket_class, ssl_context)
+
+    refute post_connection_check_called
+  end
+
+  # -- #rescue_readable (private) --
+
+  def test_rescue_readable_yields_the_block
+    assert_equal :ok, @timeout.send(:rescue_readable, 1) { :ok }
+  end
+
+  def test_rescue_readable_when_wait_readable_raised_and_wait_succeeds_retries
+    call_count = 0
+    result = @timeout.send(:rescue_readable, 1) do
+      raise IO::EAGAINWaitReadable if (call_count += 1) == 1
+
+      :done
+    end
+
+    assert_equal :done, result
+  end
+
+  def test_rescue_readable_when_wait_readable_raised_and_wait_times_out_raises_timeout_error
+    io_with_nil_wait = fake(wait_readable: nil, wait_writable: true)
+    socket_with_nil_wait = fake(to_io: io_with_nil_wait, closed?: false)
+    @timeout.instance_variable_set(:@socket, socket_with_nil_wait)
+
+    err = assert_raises(HTTP::TimeoutError) do
+      @timeout.send(:rescue_readable, 1) { raise IO::EAGAINWaitReadable }
+    end
+    assert_match(/Read timed out/, err.message)
+  end
+
+  # -- #rescue_writable (private) --
+
+  def test_rescue_writable_yields_the_block
+    assert_equal :ok, @timeout.send(:rescue_writable, 1) { :ok }
+  end
+
+  def test_rescue_writable_when_wait_writable_raised_and_wait_succeeds_retries
+    call_count = 0
+    result = @timeout.send(:rescue_writable, 1) do
+      raise IO::EAGAINWaitWritable if (call_count += 1) == 1
+
+      :done
+    end
+
+    assert_equal :done, result
+  end
+
+  def test_rescue_writable_when_wait_writable_raised_and_wait_times_out_raises_timeout_error
+    io_with_nil_wait = fake(wait_readable: true, wait_writable: nil)
+    socket_with_nil_wait = fake(to_io: io_with_nil_wait, closed?: false)
+    @timeout.instance_variable_set(:@socket, socket_with_nil_wait)
+
+    err = assert_raises(HTTP::TimeoutError) do
+      @timeout.send(:rescue_writable, 1) { raise IO::EAGAINWaitWritable }
+    end
+    assert_match(/Write timed out/, err.message)
+  end
+
+  # -- NATIVE_CONNECT_TIMEOUT --
+
+  def test_native_connect_timeout_is_true_on_ruby_3_4_plus
+    assert_equal RUBY_VERSION >= "3.4", HTTP::Timeout::Null::NATIVE_CONNECT_TIMEOUT
+  end
+
+  # -- #open_socket (private) --
+
+  def test_open_socket_opens_a_socket_without_timeout
+    tcp_socket = fake(closed?: false)
+    socket_class = fake(open: tcp_socket)
+    result = @timeout.send(:open_socket, socket_class, "example.com", 80)
+
+    assert_same tcp_socket, result
+  end
+
+  def test_open_socket_passes_connect_timeout_natively_when_supported
+    received_args = nil
+    stub_open = lambda do |*args, **kwargs|
+      received_args = [args, kwargs]
+      fake(closed?: false)
+    end
+
+    @timeout.stub(:native_timeout?, true) do
+      TCPSocket.stub(:open, stub_open) do
+        @timeout.send(:open_socket, TCPSocket, "127.0.0.1", 1, connect_timeout: 5)
+      end
+    end
+
+    assert_equal [["127.0.0.1", 1], { connect_timeout: 5 }], received_args
+  end
+
+  def test_open_socket_does_not_pass_connect_timeout_to_non_tcp_socket_classes
+    received_args = nil
+    tcp_socket = fake(closed?: false)
+    socket_class = fake(open: proc { |*args|
+      received_args = args
+      tcp_socket
+    })
+
+    @timeout.send(:open_socket, socket_class, "example.com", 80, connect_timeout: 5)
+
+    assert_equal ["example.com", 80], received_args
+  end
+
+  def test_open_socket_converts_io_timeout_error_to_connect_timeout_error
+    socket_class = fake(open: proc { |*| raise IO::TimeoutError, "Connect timed out!" })
+
+    err = assert_raises(HTTP::ConnectTimeoutError) do
+      @timeout.send(:open_socket, socket_class, "example.com", 80, connect_timeout: 5)
+    end
+    assert_match(/Connect timed out/, err.message)
+  end
+
+  # -- #native_timeout? (private) --
+
+  if RUBY_VERSION >= "3.4"
+    def test_native_timeout_returns_true_for_tcp_socket_on_ruby_3_4_plus
+      assert @timeout.send(:native_timeout?, TCPSocket)
+    end
+  else
+    def test_native_timeout_returns_false_for_tcp_socket_on_ruby_below_3_4
+      refute @timeout.send(:native_timeout?, TCPSocket)
+    end
+  end
+
+  def test_native_timeout_returns_false_for_non_tcp_socket_classes
+    refute @timeout.send(:native_timeout?, OpenSSL::SSL::SSLSocket)
+  end
+
+  def test_native_timeout_returns_false_for_non_class_objects
+    refute @timeout.send(:native_timeout?, fake(open: nil))
+  end
+end

data/test/http/timeout/per_operation_test.rb

@@ -0,0 +1,220 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+class HTTPTimeoutPerOperationTest < Minitest::Test
+  cover "HTTP::Timeout::PerOperation*"
+
+  # -- instance tests --
+
+  def setup
+    super
+    @io = fake(wait_readable: true, wait_writable: true)
+    @socket = fake(to_io: @io, closed?: false)
+    @timeout = HTTP::Timeout::PerOperation.new(connect_timeout: 1, read_timeout: 1, write_timeout: 1)
+    @timeout.instance_variable_set(:@socket, @socket)
+  end
+  # -- .extract_global_timeout! --
+
+  def test_extract_global_timeout_extracts_short_global_key
+    opts = { global: 60, read: 5 }
+
+    assert_equal 60, HTTP::Timeout::PerOperation.send(:extract_global_timeout!, opts)
+    assert_equal({ read: 5 }, opts)
+  end
+
+  def test_extract_global_timeout_extracts_long_global_timeout_key
+    opts = { global_timeout: 60, read: 5 }
+
+    assert_equal 60, HTTP::Timeout::PerOperation.send(:extract_global_timeout!, opts)
+    assert_equal({ read: 5 }, opts)
+  end
+
+  def test_extract_global_timeout_returns_nil_when_no_global_key_present
+    opts = { read: 5 }
+
+    assert_nil HTTP::Timeout::PerOperation.send(:extract_global_timeout!, opts)
+    assert_equal({ read: 5 }, opts)
+  end
+
+  def test_extract_global_timeout_raises_when_both_global_and_global_timeout_given
+    assert_raises(ArgumentError) do
+      HTTP::Timeout::PerOperation.send(:extract_global_timeout!, global: 60, global_timeout: 60)
+    end
+  end
+
+  def test_extract_global_timeout_raises_for_non_numeric_global_value
+    assert_raises(ArgumentError) do
+      HTTP::Timeout::PerOperation.send(:extract_global_timeout!, global: "60")
+    end
+  end
+
+  # -- .normalize_options --
+
+  def test_normalize_options_normalizes_short_read_key
+    assert_equal({ read_timeout: 5 }, HTTP::Timeout::PerOperation.normalize_options(read: 5))
+  end
+
+  def test_normalize_options_normalizes_short_write_key
+    assert_equal({ write_timeout: 3 }, HTTP::Timeout::PerOperation.normalize_options(write: 3))
+  end
+
+  def test_normalize_options_normalizes_short_connect_key
+    assert_equal({ connect_timeout: 1 }, HTTP::Timeout::PerOperation.normalize_options(connect: 1))
+  end
+
+  def test_normalize_options_passes_through_long_form_keys
+    assert_equal({ read_timeout: 5 }, HTTP::Timeout::PerOperation.normalize_options(read_timeout: 5))
+  end
+
+  def test_normalize_options_normalizes_all_keys_together
+    result = HTTP::Timeout::PerOperation.normalize_options(read: 1, write: 2, connect: 3)
+
+    assert_equal({ read_timeout: 1, write_timeout: 2, connect_timeout: 3 }, result)
+  end
+
+  def test_normalize_options_accepts_float_values
+    assert_equal({ read_timeout: 1.5 }, HTTP::Timeout::PerOperation.normalize_options(read: 1.5))
+  end
+
+  def test_normalize_options_handles_frozen_hashes
+    result = HTTP::Timeout::PerOperation.normalize_options({ read: 5 }.freeze)
+
+    assert_equal({ read_timeout: 5 }, result)
+  end
+
+  def test_normalize_options_raises_when_both_short_and_long_form_given
+    assert_raises(ArgumentError) do
+      HTTP::Timeout::PerOperation.normalize_options(read: 1, read_timeout: 2)
+    end
+  end
+
+  def test_normalize_options_raises_for_non_numeric_values
+    assert_raises(ArgumentError) do
+      HTTP::Timeout::PerOperation.normalize_options(read: "5")
+    end
+  end
+
+  def test_normalize_options_raises_for_unknown_keys
+    assert_raises(ArgumentError) do
+      HTTP::Timeout::PerOperation.normalize_options(timeout: 5)
+    end
+  end
+
+  def test_normalize_options_raises_for_empty_hash
+    assert_raises(ArgumentError) do
+      HTTP::Timeout::PerOperation.normalize_options({})
+    end
+  end
+
+  # -- #connect --
+
+  def test_connect_sets_tcp_nodelay_when_nodelay_is_true
+    setsockopt_args = nil
+    tcp_socket = fake(
+      setsockopt: ->(*args) { setsockopt_args = args }
+    )
+
+    socket_class = fake(open: tcp_socket)
+    @timeout.connect(socket_class, "example.com", 80, nodelay: true)
+
+    assert_equal [Socket::IPPROTO_TCP, Socket::TCP_NODELAY, 1], setsockopt_args
+  end
+
+  # -- #connect_ssl --
+
+  def test_connect_ssl_completes_without_error
+    connected = Object.new
+    socket = fake(
+      to_io:            @io,
+      closed?:          false,
+      connect_nonblock: ->(*) { connected }
+    )
+    @timeout.instance_variable_set(:@socket, socket)
+    @timeout.connect_ssl
+  end
+
+  # -- #readpartial --
+
+  def test_readpartial_when_read_returns_nil_returns_eof
+    socket = fake(
+      to_io:         @io,
+      closed?:       false,
+      read_nonblock: nil
+    )
+    @timeout.instance_variable_set(:@socket, socket)
+
+    assert_equal :eof, @timeout.readpartial(10)
+  end
+
+  def test_readpartial_when_wait_writable_then_data_waits_and_retries
+    call_count = 0
+    socket = fake(
+      to_io:         @io,
+      closed?:       false,
+      read_nonblock: ->(*) { (call_count += 1) == 1 ? :wait_writable : "data" }
+    )
+    @timeout.instance_variable_set(:@socket, socket)
+
+    assert_equal "data", @timeout.readpartial(10)
+  end
+
+  def test_readpartial_when_wait_writable_and_times_out_raises_timeout_error
+    io_with_nil_wait = fake(wait_readable: nil, wait_writable: nil)
+    socket = fake(
+      to_io:         io_with_nil_wait,
+      closed?:       false,
+      read_nonblock: :wait_writable
+    )
+    @timeout.instance_variable_set(:@socket, socket)
+
+    err = assert_raises(HTTP::TimeoutError) do
+      @timeout.readpartial(10)
+    end
+    assert_match(/Read timed out/, err.message)
+  end
+
+  # -- #write --
+
+  def test_write_when_times_out_raises_timeout_error
+    io_with_nil_wait = fake(wait_readable: true, wait_writable: nil)
+    socket = fake(
+      to_io:          io_with_nil_wait,
+      closed?:        false,
+      write_nonblock: :wait_writable
+    )
+    @timeout.instance_variable_set(:@socket, socket)
+
+    err = assert_raises(HTTP::TimeoutError) do
+      @timeout.write("data")
+    end
+    assert_match(/Write timed out/, err.message)
+  end
+
+  def test_write_when_wait_readable_then_completes_waits_and_retries
+    call_count = 0
+    socket = fake(
+      to_io:          @io,
+      closed?:        false,
+      write_nonblock: ->(*) { (call_count += 1) == 1 ? :wait_readable : 4 }
+    )
+    @timeout.instance_variable_set(:@socket, socket)
+
+    assert_equal 4, @timeout.write("data")
+  end
+
+  def test_write_when_wait_readable_and_times_out_raises_timeout_error
+    io_with_nil_wait = fake(wait_readable: nil, wait_writable: nil)
+    socket = fake(
+      to_io:          io_with_nil_wait,
+      closed?:        false,
+      write_nonblock: :wait_readable
+    )
+    @timeout.instance_variable_set(:@socket, socket)
+
+    err = assert_raises(HTTP::TimeoutError) do
+      @timeout.write("data")
+    end
+    assert_match(/Write timed out/, err.message)
+  end
+end

data/test/http/uri/normalizer_test.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+class HTTPURINormalizerTest < Minitest::Test
+  def test_scheme_lower_cases_scheme
+    assert_equal "http", HTTP::URI::NORMALIZER.call("HttP://example.com").scheme
+  end
+
+  def test_hostname_lower_cases_hostname
+    assert_equal "example.com", HTTP::URI::NORMALIZER.call("http://EXAMPLE.com").host
+  end
+
+  def test_hostname_decodes_percent_encoded_hostname
+    assert_equal "example.com", HTTP::URI::NORMALIZER.call("http://ex%61mple.com").host
+  end
+
+  def test_hostname_removes_trailing_period_in_hostname
+    assert_equal "example.com", HTTP::URI::NORMALIZER.call("http://example.com.").host
+  end
+
+  def test_hostname_idn_encodes_non_ascii_hostname
+    assert_equal "xn--exmple-cua.com", HTTP::URI::NORMALIZER.call("http://ex\u00E4mple.com").host
+  end
+
+  def test_path_ensures_path_is_not_empty
+    assert_equal "/", HTTP::URI::NORMALIZER.call("http://example.com").path
+  end
+
+  def test_path_preserves_double_slashes_in_path
+    assert_equal "//a///b", HTTP::URI::NORMALIZER.call("http://example.com//a///b").path
+  end
+
+  def test_path_resolves_single_dot_segments_in_path
+    assert_equal "/a/b", HTTP::URI::NORMALIZER.call("http://example.com/a/./b").path
+  end
+
+  def test_path_resolves_double_dot_segments_in_path
+    assert_equal "/a/c", HTTP::URI::NORMALIZER.call("http://example.com/a/b/../c").path
+  end
+
+  def test_path_resolves_leading_double_dot_segments_in_path
+    assert_equal "/a/b", HTTP::URI::NORMALIZER.call("http://example.com/../a/b").path
+  end
+
+  def test_path_percent_encodes_control_characters_in_path
+    assert_equal "/%00%7F%0A", HTTP::URI::NORMALIZER.call("http://example.com/\x00\x7F\n").path
+  end
+
+  def test_path_percent_encodes_space_in_path
+    assert_equal "/a%20b", HTTP::URI::NORMALIZER.call("http://example.com/a b").path
+  end
+
+  def test_path_percent_encodes_non_ascii_characters_in_path
+    assert_equal "/%E3%82%AD%E3%83%A7", HTTP::URI::NORMALIZER.call("http://example.com/\u30AD\u30E7").path
+  end
+
+  def test_path_does_not_percent_encode_non_special_characters_in_path
+    assert_equal "/~.-_!$&()*,;=:@{}", HTTP::URI::NORMALIZER.call("http://example.com/~.-_!$&()*,;=:@{}").path
+  end
+
+  def test_path_preserves_escape_sequences_in_path
+    assert_equal "/%41", HTTP::URI::NORMALIZER.call("http://example.com/%41").path
+  end
+
+  def test_query_allows_no_query
+    assert_nil HTTP::URI::NORMALIZER.call("http://example.com").query
+  end
+
+  def test_query_percent_encodes_control_characters_in_query
+    assert_equal "%00%7F%0A", HTTP::URI::NORMALIZER.call("http://example.com/?\x00\x7F\n").query
+  end
+
+  def test_query_percent_encodes_space_in_query
+    assert_equal "a%20b", HTTP::URI::NORMALIZER.call("http://example.com/?a b").query
+  end
+
+  def test_query_percent_encodes_non_ascii_characters_in_query
+    assert_equal "%E3%82%AD%E3%83%A7", HTTP::URI::NORMALIZER.call("http://example.com?\u30AD\u30E7").query
+  end
+
+  def test_query_does_not_percent_encode_non_special_characters_in_query
+    assert_equal "~.-_!$&()*,;=:@{}?", HTTP::URI::NORMALIZER.call("http://example.com/?~.-_!$&()*,;=:@{}?").query
+  end
+
+  def test_query_preserves_escape_sequences_in_query
+    assert_equal "%41", HTTP::URI::NORMALIZER.call("http://example.com/?%41").query
+  end
+end