RubyGems - http - Versions diffs - 6.0.0 → 6.0.1 - Mend

http 6.0.0 → 6.0.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (79) hide show

checksums.yaml +4 -4
data/http.gemspec +2 -2
data/lib/http/version.rb +1 -1
metadata +4 -79
data/CHANGELOG.md +0 -267
data/CONTRIBUTING.md +0 -26
data/SECURITY.md +0 -17
data/UPGRADING.md +0 -491
data/sig/deps.rbs +0 -122
data/test/http/base64_test.rb +0 -28
data/test/http/client_test.rb +0 -739
data/test/http/connection_test.rb +0 -1533
data/test/http/content_type_test.rb +0 -190
data/test/http/errors_test.rb +0 -28
data/test/http/feature_test.rb +0 -49
data/test/http/features/auto_deflate_test.rb +0 -317
data/test/http/features/auto_inflate_test.rb +0 -213
data/test/http/features/caching_test.rb +0 -942
data/test/http/features/digest_auth_test.rb +0 -996
data/test/http/features/instrumentation_test.rb +0 -246
data/test/http/features/logging_test.rb +0 -654
data/test/http/features/normalize_uri_test.rb +0 -41
data/test/http/features/raise_error_test.rb +0 -77
data/test/http/form_data/composite_io_test.rb +0 -215
data/test/http/form_data/file_test.rb +0 -255
data/test/http/form_data/fixtures/the-http-gem.info +0 -1
data/test/http/form_data/multipart_test.rb +0 -303
data/test/http/form_data/part_test.rb +0 -90
data/test/http/form_data/urlencoded_test.rb +0 -164
data/test/http/form_data_test.rb +0 -232
data/test/http/headers/normalizer_test.rb +0 -93
data/test/http/headers_test.rb +0 -888
data/test/http/mime_type/json_test.rb +0 -39
data/test/http/mime_type_test.rb +0 -150
data/test/http/options/base_uri_test.rb +0 -148
data/test/http/options/body_test.rb +0 -21
data/test/http/options/features_test.rb +0 -38
data/test/http/options/form_test.rb +0 -21
data/test/http/options/headers_test.rb +0 -32
data/test/http/options/json_test.rb +0 -21
data/test/http/options/merge_test.rb +0 -78
data/test/http/options/new_test.rb +0 -37
data/test/http/options/proxy_test.rb +0 -32
data/test/http/options_test.rb +0 -575
data/test/http/redirector_test.rb +0 -639
data/test/http/request/body_test.rb +0 -318
data/test/http/request/builder_test.rb +0 -623
data/test/http/request/writer_test.rb +0 -391
data/test/http/request_test.rb +0 -1733
data/test/http/response/body_test.rb +0 -292
data/test/http/response/parser_test.rb +0 -105
data/test/http/response/status_test.rb +0 -322
data/test/http/response_test.rb +0 -502
data/test/http/retriable/delay_calculator_test.rb +0 -194
data/test/http/retriable/errors_test.rb +0 -71
data/test/http/retriable/performer_test.rb +0 -551
data/test/http/session_test.rb +0 -424
data/test/http/timeout/global_test.rb +0 -239
data/test/http/timeout/null_test.rb +0 -218
data/test/http/timeout/per_operation_test.rb +0 -220
data/test/http/uri/normalizer_test.rb +0 -89
data/test/http/uri_test.rb +0 -1140
data/test/http/version_test.rb +0 -15
data/test/http_test.rb +0 -818
data/test/regression_tests.rb +0 -27
data/test/support/capture_warning.rb +0 -10
data/test/support/dummy_server/encoding_routes.rb +0 -47
data/test/support/dummy_server/routes.rb +0 -201
data/test/support/dummy_server/servlet.rb +0 -81
data/test/support/dummy_server.rb +0 -200
data/test/support/fakeio.rb +0 -21
data/test/support/http_handling_shared/connection_reuse_tests.rb +0 -97
data/test/support/http_handling_shared/timeout_tests.rb +0 -134
data/test/support/http_handling_shared.rb +0 -11
data/test/support/proxy_server.rb +0 -207
data/test/support/servers/runner.rb +0 -67
data/test/support/simplecov.rb +0 -28
data/test/support/ssl_helper.rb +0 -108
data/test/test_helper.rb +0 -38

data/test/regression_tests.rb DELETED Viewed

@@ -1,27 +0,0 @@
-# frozen_string_literal: true
-require "test_helper"
-class RegressionTest < Minitest::Test
-  # #248
-  def test_248_does_not_fail_with_github
-    github_uri = "http://github.com/"
-    HTTP.get(github_uri).to_s
-  end
-  def test_248_does_not_fail_with_googleapis
-    google_uri = "https://www.googleapis.com/oauth2/v1/userinfo?alt=json"
-    HTTP.get(google_uri).to_s
-  end
-  # #422
-  def test_422_reads_body_when_200_ok_response_contains_upgrade_header
-    res = HTTP.get("https://httpbin.org/response-headers?Upgrade=h2,h2c")
-    parsed = res.parse(:json)
-    assert_includes parsed, "Upgrade"
-    assert_equal "h2,h2c", parsed["Upgrade"]
-  end
-end

data/test/support/capture_warning.rb DELETED Viewed

@@ -1,10 +0,0 @@
-# frozen_string_literal: true
-def capture_warning
-  old_stderr = $stderr
-  $stderr = StringIO.new
-  yield
-  $stderr.string
-ensure
-  $stderr = old_stderr
-end

data/test/support/dummy_server/encoding_routes.rb DELETED Viewed

@@ -1,47 +0,0 @@
-# frozen_string_literal: true
-class DummyServer
-  class Servlet
-    post "/encoded-body" do |req, res|
-      res.status = 200
-      body = request_body(req)
-      res.body = case request_header(req, "Accept-Encoding")
-                 when "gzip"
-                   res["Content-Encoding"] = "gzip"
-                   StringIO.open do |out|
-                     Zlib::GzipWriter.wrap(out) do |gz|
-                       gz.write "#{body}-gzipped"
-                       gz.finish
-                       out.tap(&:rewind).read
-                     end
-                   end
-                 when "deflate"
-                   res["Content-Encoding"] = "deflate"
-                   Zlib::Deflate.deflate("#{body}-deflated")
-                 else
-                   "#{body}-raw"
-                 end
-    end
-    post "/no-content-204" do |req, res|
-      res.status = 204
-      res.body   = ""
-      case request_header(req, "Accept-Encoding")
-      when "gzip"
-        res["Content-Encoding"] = "gzip"
-      when "deflate"
-        res["Content-Encoding"] = "deflate"
-      end
-    end
-    get "/retry-2" do |_req, res|
-      @memo[:attempts] ||= 0
-      @memo[:attempts] += 1
-      res.body = "retried #{@memo[:attempts]}x"
-      res.status = @memo[:attempts] == 2 ? 200 : 500
-    end
-  end
-end

data/test/support/dummy_server/routes.rb DELETED Viewed

@@ -1,201 +0,0 @@
-# frozen_string_literal: true
-class DummyServer
-  class Servlet
-    get "/" do |req, res|
-      res.status = 200
-      case req["Accept"]
-      when "application/json"
-        res["Content-Type"] = "application/json"
-        res.body = '{"json": true}'
-      else
-        res["Content-Type"] = "text/html"
-        res.body = "<!doctype html>"
-      end
-    end
-    get "/sleep" do |_req, res|
-      sleep 0.02
-      res.status = 200
-      res.body   = "hello"
-    end
-    post "/sleep" do |_req, res|
-      sleep 0.02
-      res.status = 200
-      res.body   = "hello"
-    end
-    ["", "/1", "/2"].each do |path|
-      get "/socket#{path}" do |req, res|
-        socket = req.socket
-        self.class.sockets << socket
-        res.status = 200
-        res.body   = socket.object_id.to_s
-      end
-    end
-    get "/params" do |req, res|
-      if "foo=bar" == query_string(req)
-        res.status = 200
-        res.body   = "Params!"
-      else
-        res.status = 404
-        res.body   = "#{req.unparsed_uri} not found"
-      end
-    end
-    get "/multiple-params" do |req, res|
-      params = URI.decode_www_form(query_string(req)).group_by(&:first).transform_values { |v| v.map(&:last) }
-      if { "foo" => ["bar"], "baz" => ["quux"] } == params
-        res.status = 200
-        res.body   = "More Params!"
-      else
-        res.status = 404
-        res.body   = "#{req.unparsed_uri} not found"
-      end
-    end
-    get "/proxy" do |_req, res|
-      res.status = 200
-      res.body   = "Proxy!"
-    end
-    get "/not-found" do |_req, res|
-      res.status = 404
-      res.body   = "not found"
-    end
-    get "/redirect-301" do |_req, res|
-      res.status      = 301
-      res["Location"] = "http://#{server_addr}:#{server_port}/"
-    end
-    get "/redirect-302" do |_req, res|
-      res.status      = 302
-      res["Location"] = "http://#{server_addr}:#{server_port}/"
-    end
-    post "/form" do |req, res|
-      if "testing-form" == query_params(req)["example"]
-        res.status = 200
-        res.body   = "passed :)"
-      else
-        res.status = 400
-        res.body   = "invalid! >:E"
-      end
-    end
-    post "/body" do |req, res|
-      if "testing-body" == request_body(req)
-        res.status = 200
-        res.body   = "passed :)"
-      else
-        res.status = 400
-        res.body   = "invalid! >:E"
-      end
-    end
-    head "/" do |_req, res|
-      res.status          = 200
-      res["Content-Type"] = "text/html"
-    end
-    get "/bytes" do |_req, res|
-      bytes = [80, 75, 3, 4, 20, 0, 0, 0, 8, 0, 123, 104, 169, 70, 99, 243, 243]
-      res["Content-Type"] = "application/octet-stream"
-      res.body = bytes.pack("c*")
-    end
-    get "/iso-8859-1" do |_req, res|
-      res["Content-Type"] = "text/plain; charset=ISO-8859-1"
-      res.body = "testæ".encode(Encoding::ISO8859_1)
-    end
-    get "/cookies" do |req, res|
-      cookies = request_cookies(req)
-      res.cookies << SetCookie.new("foo", "bar")
-      res.body = cookies.map { |c| [c.name, c.value].join ": " }.join("\n")
-    end
-    post "/echo-body" do |req, res|
-      res.status = 200
-      res.body   = request_body(req)
-    end
-    get "/héllö-wörld".b do |_req, res|
-      res.status = 200
-      res.body   = "hello world"
-    end
-    get "/echo-cookies" do |req, res|
-      res.status = 200
-      cookies = request_cookies(req)
-      res.body = cookies.map { |c| "#{c.name}=#{c.value}" }.join("; ")
-    end
-    get "/redirect-with-cookie" do |_req, res|
-      res.status      = 301
-      res["Location"] = "http://#{server_addr}:#{server_port}/echo-cookies"
-      res.cookies << SetCookie.new("from_redirect", "yes", "/")
-    end
-    get "/redirect-cookie-chain/1" do |_req, res|
-      res.status      = 301
-      res["Location"] = "http://#{server_addr}:#{server_port}/redirect-cookie-chain/2"
-      res.cookies << SetCookie.new("first", "1", "/")
-    end
-    get "/redirect-cookie-chain/2" do |_req, res|
-      res.status      = 301
-      res["Location"] = "http://#{server_addr}:#{server_port}/echo-cookies"
-      res.cookies << SetCookie.new("second", "2", "/")
-    end
-    get "/redirect-set-then-delete/1" do |_req, res|
-      res.status      = 301
-      res["Location"] = "http://#{server_addr}:#{server_port}/redirect-set-then-delete/2"
-      res.cookies << SetCookie.new("temp", "present", "/")
-    end
-    get "/redirect-set-then-delete/2" do |_req, res|
-      res.status      = 301
-      res["Location"] = "http://#{server_addr}:#{server_port}/echo-cookies"
-      res.cookies << SetCookie.new("temp", "", "/")
-    end
-    get "/redirect-no-cookies" do |_req, res|
-      res.status      = 301
-      res["Location"] = "http://#{server_addr}:#{server_port}/echo-cookies"
-    end
-    get "/cookie-loop" do |req, res|
-      cookies = request_cookies(req)
-      if cookies.any? { |c| c.name == "auth" && c.value == "ok" }
-        res.status = 200
-        res.body   = "authenticated"
-      else
-        res.status = 302
-        res["Location"] = "http://#{server_addr}:#{server_port}/cookie-loop"
-        res.cookies << SetCookie.new("auth", "ok", "/")
-      end
-    end
-    get "/cross-origin-redirect" do |req, res|
-      target = query_params(req)["target"]
-      res.status      = 302
-      res["Location"] = target
-    end
-    get "/cross-origin-redirect-with-cookie" do |req, res|
-      target = query_params(req)["target"]
-      res.status      = 302
-      res["Location"] = target
-      res.cookies << SetCookie.new("from_origin", "yes", "/")
-    end
-  end
-end

data/test/support/dummy_server/servlet.rb DELETED Viewed

@@ -1,81 +0,0 @@
-# frozen_string_literal: true
-require "uri"
-class DummyServer
-  class Servlet
-    def self.sockets
-      @sockets ||= []
-    end
-    def initialize(server, memo)
-      @server = server
-      @memo   = memo
-    end
-    def service(req, res)
-      method  = req.request_method.downcase
-      handler = self.class.routes["#{method}:#{req.path}"]
-      if handler
-        instance_exec(req, res, &handler)
-      else
-        res.status = 404
-        res.body   = "#{req.unparsed_uri} not found"
-      end
-      res["Connection"] = "keep-alive"
-    end
-    class << self
-      def routes
-        @routes ||= {}
-      end
-      %w[get post head].each do |method|
-        define_method(method) do |path, &block|
-          routes["#{method}:#{path}"] = block
-        end
-      end
-    end
-    private
-    def request_body(req)
-      req.body
-    end
-    def request_header(req, name)
-      req[name]
-    end
-    def request_cookies(req)
-      req.cookies
-    end
-    def query_string(req)
-      req.query_string
-    end
-    def query_params(req)
-      if req.body && req["Content-Type"]&.include?("application/x-www-form-urlencoded")
-        URI.decode_www_form(req.body).to_h
-      elsif req.query_string && !req.query_string.empty?
-        URI.decode_www_form(req.query_string).to_h
-      else
-        {}
-      end
-    end
-    def server_addr
-      @server.addr
-    end
-    def server_port
-      @server.port
-    end
-  end
-end
-require "support/dummy_server/routes"
-require "support/dummy_server/encoding_routes"

data/test/support/dummy_server.rb DELETED Viewed

@@ -1,200 +0,0 @@
-# frozen_string_literal: true
-require "socket"
-require "openssl"
-require "support/dummy_server/servlet"
-require "support/servers/runner"
-require "support/ssl_helper"
-class DummyServer
-  def initialize(ssl: false)
-    @ssl        = ssl
-    @tcp_server = TCPServer.new("127.0.0.1", 0)
-    @port       = @tcp_server.addr[1]
-    @memo       = {}
-    @servlet    = Servlet.new(self, @memo)
-    @running    = false
-    @ready      = Queue.new
-    ssl_context if @ssl
-  end
-  def addr
-    "127.0.0.1"
-  end
-  attr_reader :port
-  def endpoint
-    "#{scheme}://#{addr}:#{port}"
-  end
-  def scheme
-    @ssl ? "https" : "http"
-  end
-  def wait_ready
-    @ready.pop
-  end
-  def start
-    server = @ssl ? OpenSSL::SSL::SSLServer.new(@tcp_server, ssl_context) : @tcp_server
-    @running = true
-    @ready << true
-    while @running
-      begin
-        client = server.accept
-      rescue OpenSSL::SSL::SSLError
-        next
-      end
-      Thread.new(client) { |c| handle_connection(c) }
-    end
-  rescue IOError, Errno::EBADF
-    # Server socket closed during shutdown
-  end
-  def reset
-    @memo.clear
-    Servlet.sockets.clear
-  end
-  def shutdown
-    @running = false
-    @tcp_server.close
-  rescue
-    nil
-  end
-  def ssl_context
-    @ssl_context ||= SSLHelper.server_context
-  end
-  # Simple HTTP request object for route handlers
-  Request = Struct.new(:request_method, :path, :query_string, :unparsed_uri,
-                       :headers, :body, :socket) do
-    def [](name)
-      headers.each { |k, v| return v if k.casecmp?(name) }
-      nil
-    end
-    def cookies
-      cookie_header = self["Cookie"]
-      return [] unless cookie_header
-      cookie_header.split("; ").map do |pair|
-        name, value = pair.split("=", 2)
-        DummyServer::Cookie.new(name, value || "")
-      end
-    end
-  end
-  # Simple HTTP response object for route handlers
-  class Response
-    attr_accessor :status
-    attr_accessor :body
-    attr_accessor :cookies
-    def initialize
-      @status  = 200
-      @body    = ""
-      @headers = {}
-      @cookies = []
-    end
-    def []=(name, value)
-      @headers[name] = value
-    end
-    def [](name)
-      @headers[name]
-    end
-    def serialize(head_request: false)
-      lines = ["HTTP/1.1 #{status} #{STATUS_TEXT.fetch(status, 'Unknown')}"]
-      cookies.each do |cookie|
-        value = "#{cookie.name}=#{cookie.value}"
-        value += "; path=#{cookie.path}" if cookie.path
-        lines << "Set-Cookie: #{value}"
-      end
-      @headers.each { |k, v| lines << "#{k}: #{v}" }
-      body_bytes = body.to_s.b
-      lines << "Content-Length: #{body_bytes.bytesize}" unless @headers.key?("Content-Length")
-      header_str = lines.join("\r\n") << "\r\n\r\n"
-      head_request ? header_str : header_str << body_bytes
-    end
-    STATUS_TEXT = {
-      200 => "OK", 204 => "No Content", 301 => "Moved Permanently",
-      302 => "Found", 400 => "Bad Request", 404 => "Not Found",
-      407 => "Proxy Authentication Required", 500 => "Internal Server Error"
-    }.freeze
-  end
-  Cookie    = Struct.new(:name, :value)
-  SetCookie = Struct.new(:name, :value, :path)
-  private
-  def handle_connection(client)
-    loop do
-      request = read_request(client)
-      break unless request
-      response = Response.new
-      @servlet.service(request, response)
-      client.write(response.serialize(head_request: request.request_method == "HEAD"))
-      break unless response["Connection"]&.casecmp?("keep-alive")
-    end
-  rescue IOError, Errno::EBADF, Errno::ECONNRESET, Errno::EPIPE, Errno::EPROTOTYPE, OpenSSL::SSL::SSLError
-    # Connection closed or SSL error
-  ensure
-    client.close rescue nil
-  end
-  def read_request(client)
-    line = client.gets
-    return unless line
-    method, uri, = line.split(" ", 3)
-    return bad_request(client) unless uri&.ascii_only?
-    raw_path, query_string = uri.split("?", 2)
-    headers = read_headers(client)
-    Request.new(
-      request_method: method, path: percent_decode(raw_path),
-      query_string: query_string, headers: headers,
-      body: read_body(client, headers), socket: client, unparsed_uri: uri
-    )
-  end
-  def read_headers(client)
-    headers = {}
-    while (header_line = client.gets)
-      break if header_line == "\r\n"
-      key, value = header_line.split(": ", 2)
-      headers[key] = value.strip if key && value
-    end
-    headers
-  end
-  def read_body(client, headers)
-    content_length = headers["Content-Length"]
-    client.read(content_length.to_i) if content_length
-  end
-  def bad_request(client)
-    client.write("HTTP/1.1 400 Bad Request\r\nContent-Length: 0\r\nConnection: close\r\n\r\n")
-    nil
-  end
-  def percent_decode(str)
-    str.b.gsub(/%([0-9A-Fa-f]{2})/) { [::Regexp.last_match(1)].pack("H2") }
-  end
-end

data/test/support/fakeio.rb DELETED Viewed

@@ -1,21 +0,0 @@
-# frozen_string_literal: true
-require "stringio"
-class FakeIO
-  def initialize(content)
-    @io = StringIO.new(content)
-  end
-  def string
-    @io.string
-  end
-  def read(*)
-    @io.read(*)
-  end
-  def size
-    @io.size
-  end
-end

data/test/support/http_handling_shared/connection_reuse_tests.rb DELETED Viewed

@@ -1,97 +0,0 @@
-# frozen_string_literal: true
-module ConnectionReuseTests
-  # Including class must provide:
-  #   - server: a DummyServer instance
-  #   - build_client(**options): builds an HTTP::Client with given options
-  def test_connection_reuse_enabled_infers_host_from_persistent
-    client = build_client(persistent: server.endpoint)
-    assert_equal "<!doctype html>", client.get("/").body.to_s
-  end
-  def test_connection_reuse_enabled_reuses_the_socket
-    client = build_client(persistent: server.endpoint)
-    sockets_used = [
-      client.get("#{server.endpoint}/socket/1").body.to_s,
-      client.get("#{server.endpoint}/socket/2").body.to_s
-    ]
-    refute_includes sockets_used, ""
-    assert_equal 1, sockets_used.uniq.length
-  end
-  def test_connection_reuse_enabled_mixed_state_reopens_connection
-    client = build_client(persistent: server.endpoint)
-    first_socket_id = client.get("#{server.endpoint}/socket/1").body.to_s
-    client.instance_variable_set(:@state, :dirty)
-    second_socket_id = client.get("#{server.endpoint}/socket/2").body.to_s
-    refute_equal first_socket_id, second_socket_id
-  end
-  def test_connection_reuse_enabled_auto_flushes_unread_body
-    client = build_client(persistent: server.endpoint)
-    first_res = client.get(server.endpoint)
-    second_res = client.get(server.endpoint)
-    assert_equal "<!doctype html>", first_res.body.to_s
-    assert_equal "<!doctype html>", second_res.body.to_s
-  end
-  def test_connection_reuse_enabled_reading_cached_body_succeeds
-    client = build_client(persistent: server.endpoint)
-    first_res = client.get(server.endpoint)
-    first_res.body.to_s
-    second_res = client.get(server.endpoint)
-    assert_equal "<!doctype html>", first_res.body.to_s
-    assert_equal "<!doctype html>", second_res.body.to_s
-  end
-  def test_connection_reuse_enabled_socket_issue_transparently_reopens
-    client = build_client(persistent: server.endpoint)
-    first_socket_id = client.get("#{server.endpoint}/socket").body.to_s
-    refute_equal "", first_socket_id
-    # Kill off the sockets we used
-    DummyServer::Servlet.sockets.each do |socket|
-      socket.close
-    rescue IOError
-      nil
-    end
-    DummyServer::Servlet.sockets.clear
-    # Should error because we tried to use a bad socket
-    assert_raises(HTTP::ConnectionError) do
-      client.get("#{server.endpoint}/socket").body.to_s
-    end
-    # Should succeed since we create a new socket
-    second_socket_id = client.get("#{server.endpoint}/socket").body.to_s
-    refute_equal first_socket_id, second_socket_id
-  end
-  def test_connection_reuse_enabled_change_in_host_errors
-    client = build_client(persistent: server.endpoint)
-    err = assert_raises(HTTP::StateError) { client.get("https://invalid.com/socket") }
-    assert_match(/Persistence is enabled/i, err.message)
-  end
-  def test_connection_reuse_disabled_opens_new_sockets
-    client = build_client
-    sockets_used = [
-      client.get("#{server.endpoint}/socket/1").body.to_s,
-      client.get("#{server.endpoint}/socket/2").body.to_s
-    ]
-    refute_includes sockets_used, ""
-    assert_equal 2, sockets_used.uniq.length
-  end
-end