http 5.3.1 → 6.0.0

data/spec/lib/http/client_spec.rb

@@ -1,556 +0,0 @@
-# coding: utf-8
-# frozen_string_literal: true
-
-require "cgi"
-require "logger"
-
-require "support/http_handling_shared"
-require "support/dummy_server"
-require "support/ssl_helper"
-
-RSpec.describe HTTP::Client do
-  run_server(:dummy) { DummyServer.new }
-
-  before do
-    stubbed_client = Class.new(HTTP::Client) do
-      def perform(request, options)
-        stubbed = stubs[HTTP::URI::NORMALIZER.call(request.uri).to_s]
-        stubbed ? stubbed.call(request) : super(request, options)
-      end
-
-      def stubs
-        @stubs ||= {}
-      end
-
-      def stub(stubs)
-        @stubs = stubs.transform_keys do |k|
-          HTTP::URI::NORMALIZER.call(k).to_s
-        end
-
-        self
-      end
-    end
-
-    def redirect_response(location, status = 302)
-      lambda do |request|
-        HTTP::Response.new(
-          :status  => status,
-          :version => "1.1",
-          :headers => {"Location" => location},
-          :body    => "",
-          :request => request
-        )
-      end
-    end
-
-    def simple_response(body, status = 200)
-      lambda do |request|
-        HTTP::Response.new(
-          :status  => status,
-          :version => "1.1",
-          :body    => body,
-          :request => request
-        )
-      end
-    end
-
-    stub_const("StubbedClient", stubbed_client)
-  end
-
-  describe "following redirects" do
-    it "returns response of new location" do
-      client = StubbedClient.new(:follow => true).stub(
-        "http://example.com/"     => redirect_response("http://example.com/blog"),
-        "http://example.com/blog" => simple_response("OK")
-      )
-
-      expect(client.get("http://example.com/").to_s).to eq "OK"
-    end
-
-    it "prepends previous request uri scheme and host if needed" do
-      client = StubbedClient.new(:follow => true).stub(
-        "http://example.com/"           => redirect_response("/index"),
-        "http://example.com/index"      => redirect_response("/index.html"),
-        "http://example.com/index.html" => simple_response("OK")
-      )
-
-      expect(client.get("http://example.com/").to_s).to eq "OK"
-    end
-
-    it "fails upon endless redirects" do
-      client = StubbedClient.new(:follow => true).stub(
-        "http://example.com/" => redirect_response("/")
-      )
-
-      expect { client.get("http://example.com/") }.
-        to raise_error(HTTP::Redirector::EndlessRedirectError)
-    end
-
-    it "fails if max amount of hops reached" do
-      client = StubbedClient.new(:follow => {:max_hops => 5}).stub(
-        "http://example.com/"  => redirect_response("/1"),
-        "http://example.com/1" => redirect_response("/2"),
-        "http://example.com/2" => redirect_response("/3"),
-        "http://example.com/3" => redirect_response("/4"),
-        "http://example.com/4" => redirect_response("/5"),
-        "http://example.com/5" => redirect_response("/6"),
-        "http://example.com/6" => simple_response("OK")
-      )
-
-      expect { client.get("http://example.com/") }.
-        to raise_error(HTTP::Redirector::TooManyRedirectsError)
-    end
-
-    context "with non-ASCII URLs" do
-      it "theoretically works like a charm" do
-        client = StubbedClient.new(:follow => true).stub(
-          "http://example.com/"      => redirect_response("/könig"),
-          "http://example.com/könig" => simple_response("OK")
-        )
-
-        expect { client.get "http://example.com/könig" }.not_to raise_error
-      end
-
-      it "works like a charm in real world" do
-        expect(HTTP.follow.get("https://bit.ly/2UaBT4R").parse(:json)).
-          to include("url" => "https://httpbin.org/anything/könig")
-      end
-    end
-  end
-
-  describe "following redirects with logging" do
-    let(:logger) do
-      logger           = Logger.new(logdev)
-      logger.formatter = ->(severity, _, _, message) { format("** %s **\n%s\n", severity, message) }
-      logger.level     = Logger::INFO
-      logger
-    end
-
-    let(:logdev) { StringIO.new }
-
-    it "logs all requests" do
-      client = StubbedClient.new(:follow => true, :features => { :logging => { :logger => logger } }).stub(
-        "http://example.com/"  => redirect_response("/1"),
-        "http://example.com/1" => redirect_response("/2"),
-        "http://example.com/2" => redirect_response("/3"),
-        "http://example.com/3" => simple_response("OK")
-      )
-
-      expect { client.get("http://example.com/") }.not_to raise_error
-
-      expect(logdev.string).to eq <<~OUTPUT
-        ** INFO **
-        > GET http://example.com/
-        ** INFO **
-        > GET http://example.com/1
-        ** INFO **
-        > GET http://example.com/2
-        ** INFO **
-        > GET http://example.com/3
-      OUTPUT
-    end
-  end
-
-  describe "parsing params" do
-    let(:client) { HTTP::Client.new }
-    before { allow(client).to receive :perform }
-
-    it "accepts params within the provided URL" do
-      expect(HTTP::Request).to receive(:new) do |opts|
-        expect(CGI.parse(opts[:uri].query)).to eq("foo" => %w[bar])
-      end
-
-      client.get("http://example.com/?foo=bar")
-    end
-
-    it "combines GET params from the URI with the passed in params" do
-      expect(HTTP::Request).to receive(:new) do |opts|
-        expect(CGI.parse(opts[:uri].query)).to eq("foo" => %w[bar], "baz" => %w[quux])
-      end
-
-      client.get("http://example.com/?foo=bar", :params => {:baz => "quux"})
-    end
-
-    it "merges duplicate values" do
-      expect(HTTP::Request).to receive(:new) do |opts|
-        expect(opts[:uri].query).to match(/^(a=1&a=2|a=2&a=1)$/)
-      end
-
-      client.get("http://example.com/?a=1", :params => {:a => 2})
-    end
-
-    it "does not modifies query part if no params were given" do
-      expect(HTTP::Request).to receive(:new) do |opts|
-        expect(opts[:uri].query).to eq "deadbeef"
-      end
-
-      client.get("http://example.com/?deadbeef")
-    end
-
-    it "does not corrupts index-less arrays" do
-      expect(HTTP::Request).to receive(:new) do |opts|
-        expect(CGI.parse(opts[:uri].query)).to eq "a[]" => %w[b c], "d" => %w[e]
-      end
-
-      client.get("http://example.com/?a[]=b&a[]=c", :params => {:d => "e"})
-    end
-
-    it "properly encodes colons" do
-      expect(HTTP::Request).to receive(:new) do |opts|
-        expect(opts[:uri].query).to eq "t=1970-01-01T00%3A00%3A00Z"
-      end
-
-      client.get("http://example.com/", :params => {:t => "1970-01-01T00:00:00Z"})
-    end
-
-    it 'does not convert newlines into \r\n before encoding string values' do
-      expect(HTTP::Request).to receive(:new) do |opts|
-        expect(opts[:uri].query).to eq "foo=bar%0Abaz"
-      end
-
-      client.get("http://example.com/", :params => {:foo => "bar\nbaz"})
-    end
-  end
-
-  describe "passing multipart form data" do
-    it "creates url encoded form data object" do
-      client = HTTP::Client.new
-      allow(client).to receive(:perform)
-
-      expect(HTTP::Request).to receive(:new) do |opts|
-        expect(opts[:body]).to be_a(HTTP::FormData::Urlencoded)
-        expect(opts[:body].to_s).to eq "foo=bar"
-      end
-
-      client.get("http://example.com/", :form => {:foo => "bar"})
-    end
-
-    it "creates multipart form data object" do
-      client = HTTP::Client.new
-      allow(client).to receive(:perform)
-
-      expect(HTTP::Request).to receive(:new) do |opts|
-        expect(opts[:body]).to be_a(HTTP::FormData::Multipart)
-        expect(opts[:body].to_s).to include("content")
-      end
-
-      client.get("http://example.com/", :form => {:foo => HTTP::FormData::Part.new("content")})
-    end
-
-    context "when passing an HTTP::FormData object directly" do
-      it "creates url encoded form data object" do
-        client    = HTTP::Client.new
-        form_data = HTTP::FormData::Multipart.new({ :foo => "bar" })
-
-        allow(client).to receive(:perform)
-
-        expect(HTTP::Request).to receive(:new) do |opts|
-          expect(opts[:body]).to be form_data
-          expect(opts[:body].to_s).to match(/^Content-Disposition: form-data; name="foo"\r\n\r\nbar\r\n/m)
-        end
-
-        client.get("http://example.com/", :form => form_data)
-      end
-    end
-  end
-
-  describe "passing json" do
-    it "encodes given object" do
-      client = HTTP::Client.new
-      allow(client).to receive(:perform)
-
-      expect(HTTP::Request).to receive(:new) do |opts|
-        expect(opts[:body]).to eq '{"foo":"bar"}'
-        expect(opts[:headers]["Content-Type"]).to eq "application/json; charset=utf-8"
-      end
-
-      client.get("http://example.com/", :json => {:foo => :bar})
-    end
-  end
-
-  describe "#request" do
-    context "with non-ASCII URLs" do
-      it "theoretically works like a charm" do
-        client = described_class.new
-        expect { client.get "#{dummy.endpoint}/könig" }.not_to raise_error
-      end
-
-      it "works like a charm in real world" do
-        url = "https://httpbin.org/anything/ö無"
-
-        expect(HTTP.follow.get(url).parse(:json)).to include("url" => url)
-      end
-    end
-
-    context "with explicitly given `Host` header" do
-      let(:headers) { {"Host" => "another.example.com"} }
-      let(:client)  { described_class.new :headers => headers }
-
-      it "keeps `Host` header as is" do
-        expect(client).to receive(:perform) do |req, _|
-          expect(req["Host"]).to eq "another.example.com"
-        end
-
-        client.request(:get, "http://example.com/")
-      end
-    end
-
-    context "when :auto_deflate was specified" do
-      let(:headers) { {"Content-Length" => "12"} }
-      let(:client)  { described_class.new :headers => headers, :features => {:auto_deflate => {}}, :body => "foo" }
-
-      it "deletes Content-Length header" do
-        expect(client).to receive(:perform) do |req, _|
-          expect(req["Content-Length"]).to eq nil
-        end
-
-        client.request(:get, "http://example.com/")
-      end
-
-      it "sets Content-Encoding header" do
-        expect(client).to receive(:perform) do |req, _|
-          expect(req["Content-Encoding"]).to eq "gzip"
-        end
-
-        client.request(:get, "http://example.com/")
-      end
-
-      context "and there is no body" do
-        let(:client) { described_class.new :headers => headers, :features => {:auto_deflate => {}} }
-
-        it "doesn't set Content-Encoding header" do
-          expect(client).to receive(:perform) do |req, _|
-            expect(req.headers).not_to include "Content-Encoding"
-          end
-
-          client.request(:get, "http://example.com/")
-        end
-      end
-    end
-
-    context "Feature" do
-      let(:feature_class) do
-        Class.new(HTTP::Feature) do
-          attr_reader :captured_request, :captured_response, :captured_error
-
-          def wrap_request(request)
-            @captured_request = request
-          end
-
-          def wrap_response(response)
-            @captured_response = response
-          end
-
-          def on_error(request, error)
-            @captured_request = request
-            @captured_error = error
-          end
-        end
-      end
-
-      it "is given a chance to wrap the Request" do
-        feature_instance = feature_class.new
-
-        response = client.use(:test_feature => feature_instance).
-                   request(:get, dummy.endpoint)
-
-        expect(response.code).to eq(200)
-        expect(feature_instance.captured_request.verb).to eq(:get)
-        expect(feature_instance.captured_request.uri.to_s).to eq("#{dummy.endpoint}/")
-      end
-
-      it "is given a chance to wrap the Response" do
-        feature_instance = feature_class.new
-
-        response = client.use(:test_feature => feature_instance).
-                   request(:get, dummy.endpoint)
-
-        expect(feature_instance.captured_response).to eq(response)
-      end
-
-      it "is given a chance to handle an error" do
-        sleep_url = "#{dummy.endpoint}/sleep"
-        feature_instance = feature_class.new
-
-        expect do
-          client.use(:test_feature => feature_instance).
-            timeout(0.2).
-            request(:post, sleep_url)
-        end.to raise_error(HTTP::TimeoutError)
-
-        expect(feature_instance.captured_error).to be_a(HTTP::TimeoutError)
-        expect(feature_instance.captured_request.verb).to eq(:post)
-        expect(feature_instance.captured_request.uri.to_s).to eq(sleep_url)
-      end
-
-      it "is given a chance to handle a connection timeout error" do
-        allow(TCPSocket).to receive(:open) { sleep 1 }
-        sleep_url = "#{dummy.endpoint}/sleep"
-        feature_instance = feature_class.new
-
-        expect do
-          client.use(:test_feature => feature_instance).
-            timeout(0.001).
-            request(:post, sleep_url)
-        end.to raise_error(HTTP::ConnectTimeoutError)
-        expect(feature_instance.captured_error).to be_a(HTTP::ConnectTimeoutError)
-      end
-    end
-  end
-
-  include_context "HTTP handling" do
-    let(:extra_options) { {} }
-    let(:options) { {} }
-    let(:server)  { dummy }
-    let(:client)  { described_class.new(options.merge(extra_options)) }
-  end
-
-  # TODO: https://github.com/httprb/http/issues/627
-  xdescribe "working with SSL" do
-    run_server(:dummy_ssl) { DummyServer.new(:ssl => true) }
-
-    let(:extra_options) { {} }
-
-    let(:client) do
-      described_class.new options.merge(:ssl_context => SSLHelper.client_context).merge(extra_options)
-    end
-
-    include_context "HTTP handling" do
-      let(:server) { dummy_ssl }
-    end
-
-    it "just works" do
-      response = client.get(dummy_ssl.endpoint)
-      expect(response.body.to_s).to eq("<!doctype html>")
-    end
-
-    it "fails with OpenSSL::SSL::SSLError if host mismatch" do
-      expect { client.get(dummy_ssl.endpoint.gsub("127.0.0.1", "localhost")) }.
-        to raise_error(OpenSSL::SSL::SSLError, /does not match/)
-    end
-
-    context "with SSL options instead of a context" do
-      let(:client) do
-        described_class.new options.merge :ssl => SSLHelper.client_params
-      end
-
-      it "just works" do
-        response = client.get(dummy_ssl.endpoint)
-        expect(response.body.to_s).to eq("<!doctype html>")
-      end
-    end
-  end
-
-  describe "#perform" do
-    let(:client) { described_class.new }
-
-    it "calls finish_response once body was fully flushed" do
-      expect_any_instance_of(HTTP::Connection).to receive(:finish_response).and_call_original
-      client.get(dummy.endpoint).to_s
-    end
-
-    it "provides access to the Request from the Response" do
-      unique_value = "20190424"
-      response = client.headers("X-Value" => unique_value).get(dummy.endpoint)
-
-      expect(response.request).to be_a(HTTP::Request)
-      expect(response.request.headers["X-Value"]).to eq(unique_value)
-    end
-
-    context "with HEAD request" do
-      it "does not iterates through body" do
-        expect_any_instance_of(HTTP::Connection).to_not receive(:readpartial)
-        client.head(dummy.endpoint)
-      end
-
-      it "finishes response after headers were received" do
-        expect_any_instance_of(HTTP::Connection).to receive(:finish_response).and_call_original
-        client.head(dummy.endpoint)
-      end
-    end
-
-    context "when server fully flushes response in one chunk" do
-      before do
-        socket_spy = double
-
-        chunks = [
-          <<-RESPONSE.gsub(/^\s*\| */, "").gsub(/\n/, "\r\n")
-          | HTTP/1.1 200 OK
-          | Content-Type: text/html
-          | Server: WEBrick/1.3.1 (Ruby/1.9.3/2013-11-22)
-          | Date: Mon, 24 Mar 2014 00:32:22 GMT
-          | Content-Length: 15
-          | Connection: Keep-Alive
-          |
-          | <!doctype html>
-          RESPONSE
-        ]
-
-        allow(socket_spy).to receive(:close) { nil }
-        allow(socket_spy).to receive(:closed?) { true }
-        allow(socket_spy).to receive(:readpartial) { chunks.shift || :eof }
-        allow(socket_spy).to receive(:write) { chunks[0].length }
-
-        allow(TCPSocket).to receive(:open) { socket_spy }
-      end
-
-      it "properly reads body" do
-        body = client.get(dummy.endpoint).to_s
-        expect(body).to eq "<!doctype html>"
-      end
-    end
-
-    context "when uses chunked transfer encoding" do
-      let(:chunks) do
-        [
-          <<-RESPONSE.gsub(/^\s*\| */, "").gsub(/\n/, "\r\n") << body
-          | HTTP/1.1 200 OK
-          | Content-Type: application/json
-          | Transfer-Encoding: chunked
-          | Connection: close
-          |
-          RESPONSE
-        ]
-      end
-      let(:body) do
-        <<-BODY.gsub(/^\s*\| */, "").gsub(/\n/, "\r\n")
-        | 9
-        | {"state":
-        | 5
-        | "ok"}
-        | 0
-        |
-        BODY
-      end
-
-      before do
-        socket_spy = double
-
-        allow(socket_spy).to receive(:close) { nil }
-        allow(socket_spy).to receive(:closed?) { true }
-        allow(socket_spy).to receive(:readpartial) { chunks.shift || :eof }
-        allow(socket_spy).to receive(:write) { chunks[0].length }
-
-        allow(TCPSocket).to receive(:open) { socket_spy }
-      end
-
-      it "properly reads body" do
-        body = client.get(dummy.endpoint).to_s
-        expect(body).to eq '{"state":"ok"}'
-      end
-
-      context "with broken body (too early closed connection)" do
-        let(:body) do
-          <<-BODY.gsub(/^\s*\| */, "").gsub(/\n/, "\r\n")
-          | 9
-          | {"state":
-          BODY
-        end
-
-        xit "raises HTTP::ConnectionError" do
-          expect { client.get(dummy.endpoint).to_s }.to raise_error(HTTP::ConnectionError)
-        end
-      end
-    end
-  end
-end

data/spec/lib/http/connection_spec.rb

@@ -1,88 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe HTTP::Connection do
-  let(:req) do
-    HTTP::Request.new(
-      :verb    => :get,
-      :uri     => "http://example.com/",
-      :headers => {}
-    )
-  end
-  let(:socket) { double(:connect => nil, :close => nil) }
-  let(:timeout_class) { double(:new => socket) }
-  let(:opts) { HTTP::Options.new(:timeout_class => timeout_class) }
-  let(:connection) { HTTP::Connection.new(req, opts) }
-
-  describe "#initialize times out" do
-    let(:req) do
-      HTTP::Request.new(
-        :verb    => :get,
-        :uri     => "https://example.com/",
-        :headers => {}
-      )
-    end
-
-    before do
-      expect(socket).to receive(:start_tls).and_raise(HTTP::TimeoutError)
-      expect(socket).to receive(:closed?) { false }
-      expect(socket).to receive(:close)
-    end
-
-    it "closes the connection" do
-      expect { connection }.to raise_error(HTTP::TimeoutError)
-    end
-  end
-
-  describe "#read_headers!" do
-    before do
-      connection.instance_variable_set(:@pending_response, true)
-      expect(socket).to receive(:readpartial) do
-        <<-RESPONSE.gsub(/^\s*\| */, "").gsub(/\n/, "\r\n")
-        | HTTP/1.1 200 OK
-        | Content-Type: text
-        | foo_bar: 123
-        |
-        RESPONSE
-      end
-    end
-
-    it "populates headers collection, preserving casing" do
-      connection.read_headers!
-      expect(connection.headers).to eq("Content-Type" => "text", "foo_bar" => "123")
-      expect(connection.headers["Foo-Bar"]).to eq("123")
-      expect(connection.headers["foo_bar"]).to eq("123")
-    end
-  end
-
-  describe "#readpartial" do
-    before do
-      connection.instance_variable_set(:@pending_response, true)
-      expect(socket).to receive(:readpartial) do
-        <<-RESPONSE.gsub(/^\s*\| */, "").gsub(/\n/, "\r\n")
-        | HTTP/1.1 200 OK
-        | Content-Type: text
-        |
-        RESPONSE
-      end
-      expect(socket).to receive(:readpartial) { "1" }
-      expect(socket).to receive(:readpartial) { "23" }
-      expect(socket).to receive(:readpartial) { "456" }
-      expect(socket).to receive(:readpartial) { "78" }
-      expect(socket).to receive(:readpartial) { "9" }
-      expect(socket).to receive(:readpartial) { "0" }
-      expect(socket).to receive(:readpartial) { :eof }
-      expect(socket).to receive(:closed?) { true }
-    end
-
-    it "reads data in parts" do
-      connection.read_headers!
-      buffer = String.new
-      while (s = connection.readpartial(3))
-        expect(connection.finished_request?).to be false if s != ""
-        buffer << s
-      end
-      expect(buffer).to eq "1234567890"
-      expect(connection.finished_request?).to be true
-    end
-  end
-end

data/spec/lib/http/content_type_spec.rb

@@ -1,47 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe HTTP::ContentType do
-  describe ".parse" do
-    context "with text/plain" do
-      subject { described_class.parse "text/plain" }
-      its(:mime_type) { is_expected.to eq "text/plain" }
-      its(:charset)   { is_expected.to be_nil }
-    end
-
-    context "with tEXT/plaIN" do
-      subject { described_class.parse "tEXT/plaIN" }
-      its(:mime_type) { is_expected.to eq "text/plain" }
-      its(:charset)   { is_expected.to be_nil }
-    end
-
-    context "with text/plain; charset=utf-8" do
-      subject { described_class.parse "text/plain; charset=utf-8" }
-      its(:mime_type) { is_expected.to eq "text/plain" }
-      its(:charset)   { is_expected.to eq "utf-8" }
-    end
-
-    context 'with text/plain; charset="utf-8"' do
-      subject { described_class.parse 'text/plain; charset="utf-8"' }
-      its(:mime_type) { is_expected.to eq "text/plain" }
-      its(:charset)   { is_expected.to eq "utf-8" }
-    end
-
-    context "with text/plain; charSET=utf-8" do
-      subject { described_class.parse "text/plain; charSET=utf-8" }
-      its(:mime_type) { is_expected.to eq "text/plain" }
-      its(:charset)   { is_expected.to eq "utf-8" }
-    end
-
-    context "with text/plain; foo=bar; charset=utf-8" do
-      subject { described_class.parse "text/plain; foo=bar; charset=utf-8" }
-      its(:mime_type) { is_expected.to eq "text/plain" }
-      its(:charset)   { is_expected.to eq "utf-8" }
-    end
-
-    context "with text/plain;charset=utf-8;foo=bar" do
-      subject { described_class.parse "text/plain;charset=utf-8;foo=bar" }
-      its(:mime_type) { is_expected.to eq "text/plain" }
-      its(:charset)   { is_expected.to eq "utf-8" }
-    end
-  end
-end