http 5.2.0 → 6.0.2

data/spec/lib/http/response/parser_spec.rb

@@ -1,74 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe HTTP::Response::Parser do
-  subject(:parser) { described_class.new }
-  let(:raw_response) do
-    "HTTP/1.1 200 OK\r\nContent-Length: 2\r\nContent-Type: application/json\r\nMyHeader: val\r\nEmptyHeader: \r\n\r\n{}"
-  end
-  let(:expected_headers) do
-    {
-      "Content-Length" => "2",
-      "Content-Type"   => "application/json",
-      "MyHeader"       => "val",
-      "EmptyHeader"    => ""
-    }
-  end
-  let(:expected_body) { "{}" }
-
-  before do
-    parts.each { |part| subject.add(part) }
-  end
-
-  context "whole response in one part" do
-    let(:parts) { [raw_response] }
-
-    it "parses headers" do
-      expect(subject.headers.to_h).to eq(expected_headers)
-    end
-
-    it "parses body" do
-      expect(subject.read(expected_body.size)).to eq(expected_body)
-    end
-  end
-
-  context "response in many parts" do
-    let(:parts) { raw_response.chars }
-
-    it "parses headers" do
-      expect(subject.headers.to_h).to eq(expected_headers)
-    end
-
-    it "parses body" do
-      expect(subject.read(expected_body.size)).to eq(expected_body)
-    end
-  end
-
-  context "when got 100 Continue response" do
-    let :raw_response do
-      "HTTP/1.1 100 Continue\r\n\r\n" \
-        "HTTP/1.1 200 OK\r\n" \
-        "Content-Length: 12\r\n\r\n" \
-        "Hello World!"
-    end
-
-    context "when response is feeded in one part" do
-      let(:parts) { [raw_response] }
-
-      it "skips to next non-info response" do
-        expect(subject.status_code).to eq(200)
-        expect(subject.headers).to eq("Content-Length" => "12")
-        expect(subject.read(12)).to eq("Hello World!")
-      end
-    end
-
-    context "when response is feeded in many parts" do
-      let(:parts) { raw_response.chars }
-
-      it "skips to next non-info response" do
-        expect(subject.status_code).to eq(200)
-        expect(subject.headers).to eq("Content-Length" => "12")
-        expect(subject.read(12)).to eq("Hello World!")
-      end
-    end
-  end
-end

data/spec/lib/http/response/status_spec.rb

@@ -1,253 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe HTTP::Response::Status do
-  describe ".new" do
-    it "fails if given value does not respond to #to_i" do
-      expect { described_class.new double }.to raise_error TypeError
-    end
-
-    it "accepts any object that responds to #to_i" do
-      expect { described_class.new double :to_i => 200 }.to_not raise_error
-    end
-  end
-
-  describe "#code" do
-    subject { described_class.new("200.0").code }
-    it { is_expected.to eq 200 }
-    it { is_expected.to be_a Integer }
-  end
-
-  describe "#reason" do
-    subject { described_class.new(code).reason }
-
-    context "with unknown code" do
-      let(:code) { 1024 }
-      it { is_expected.to be_nil }
-    end
-
-    described_class::REASONS.each do |code, reason|
-      class_eval <<-RUBY, __FILE__, __LINE__ + 1
-        context 'with well-known code: #{code}' do
-          let(:code) { #{code} }
-          it { is_expected.to eq #{reason.inspect} }
-          it { is_expected.to be_frozen }
-        end
-      RUBY
-    end
-  end
-
-  context "with 1xx codes" do
-    subject { (100...200).map { |code| described_class.new code } }
-
-    it "is #informational?" do
-      expect(subject).to all(satisfy(&:informational?))
-    end
-
-    it "is not #success?" do
-      expect(subject).to all(satisfy { |status| !status.success? })
-    end
-
-    it "is not #redirect?" do
-      expect(subject).to all(satisfy { |status| !status.redirect? })
-    end
-
-    it "is not #client_error?" do
-      expect(subject).to all(satisfy { |status| !status.client_error? })
-    end
-
-    it "is not #server_error?" do
-      expect(subject).to all(satisfy { |status| !status.server_error? })
-    end
-  end
-
-  context "with 2xx codes" do
-    subject { (200...300).map { |code| described_class.new code } }
-
-    it "is not #informational?" do
-      expect(subject).to all(satisfy { |status| !status.informational? })
-    end
-
-    it "is #success?" do
-      expect(subject).to all(satisfy(&:success?))
-    end
-
-    it "is not #redirect?" do
-      expect(subject).to all(satisfy { |status| !status.redirect? })
-    end
-
-    it "is not #client_error?" do
-      expect(subject).to all(satisfy { |status| !status.client_error? })
-    end
-
-    it "is not #server_error?" do
-      expect(subject).to all(satisfy { |status| !status.server_error? })
-    end
-  end
-
-  context "with 3xx codes" do
-    subject { (300...400).map { |code| described_class.new code } }
-
-    it "is not #informational?" do
-      expect(subject).to all(satisfy { |status| !status.informational? })
-    end
-
-    it "is not #success?" do
-      expect(subject).to all(satisfy { |status| !status.success? })
-    end
-
-    it "is #redirect?" do
-      expect(subject).to all(satisfy(&:redirect?))
-    end
-
-    it "is not #client_error?" do
-      expect(subject).to all(satisfy { |status| !status.client_error? })
-    end
-
-    it "is not #server_error?" do
-      expect(subject).to all(satisfy { |status| !status.server_error? })
-    end
-  end
-
-  context "with 4xx codes" do
-    subject { (400...500).map { |code| described_class.new code } }
-
-    it "is not #informational?" do
-      expect(subject).to all(satisfy { |status| !status.informational? })
-    end
-
-    it "is not #success?" do
-      expect(subject).to all(satisfy { |status| !status.success? })
-    end
-
-    it "is not #redirect?" do
-      expect(subject).to all(satisfy { |status| !status.redirect? })
-    end
-
-    it "is #client_error?" do
-      expect(subject).to all(satisfy(&:client_error?))
-    end
-
-    it "is not #server_error?" do
-      expect(subject).to all(satisfy { |status| !status.server_error? })
-    end
-  end
-
-  context "with 5xx codes" do
-    subject { (500...600).map { |code| described_class.new code } }
-
-    it "is not #informational?" do
-      expect(subject).to all(satisfy { |status| !status.informational? })
-    end
-
-    it "is not #success?" do
-      expect(subject).to all(satisfy { |status| !status.success? })
-    end
-
-    it "is not #redirect?" do
-      expect(subject).to all(satisfy { |status| !status.redirect? })
-    end
-
-    it "is not #client_error?" do
-      expect(subject).to all(satisfy { |status| !status.client_error? })
-    end
-
-    it "is #server_error?" do
-      expect(subject).to all(satisfy(&:server_error?))
-    end
-  end
-
-  describe "#to_sym" do
-    subject { described_class.new(code).to_sym }
-
-    context "with unknown code" do
-      let(:code) { 1024 }
-      it { is_expected.to be_nil }
-    end
-
-    described_class::SYMBOLS.each do |code, symbol|
-      class_eval <<-RUBY, __FILE__, __LINE__ + 1
-        context 'with well-known code: #{code}' do
-          let(:code) { #{code} }
-          it { is_expected.to be #{symbol.inspect} }
-        end
-      RUBY
-    end
-  end
-
-  describe "#inspect" do
-    it "returns quoted code and reason phrase" do
-      status = described_class.new 200
-      expect(status.inspect).to eq "#<HTTP::Response::Status 200 OK>"
-    end
-  end
-
-  # testing edge cases only
-  describe "::SYMBOLS" do
-    subject { described_class::SYMBOLS }
-
-    # "OK"
-    its([200]) { is_expected.to be :ok }
-
-    # "Bad Request"
-    its([400]) { is_expected.to be :bad_request }
-  end
-
-  described_class::SYMBOLS.each do |code, symbol|
-    class_eval <<-RUBY, __FILE__, __LINE__ + 1
-      describe '##{symbol}?' do
-        subject { status.#{symbol}? }
-
-        context 'when code is #{code}' do
-          let(:status) { described_class.new #{code} }
-          it { is_expected.to be true }
-        end
-
-        context 'when code is higher than #{code}' do
-          let(:status) { described_class.new #{code + 1} }
-          it { is_expected.to be false }
-        end
-
-        context 'when code is lower than #{code}' do
-          let(:status) { described_class.new #{code - 1} }
-          it { is_expected.to be false }
-        end
-      end
-    RUBY
-  end
-
-  describe ".coerce" do
-    context "with String" do
-      it "coerces reasons" do
-        expect(described_class.coerce("Bad request")).to eq described_class.new 400
-      end
-
-      it "fails when reason is unknown" do
-        expect { described_class.coerce "foobar" }.to raise_error HTTP::Error
-      end
-    end
-
-    context "with Symbol" do
-      it "coerces symbolized reasons" do
-        expect(described_class.coerce(:bad_request)).to eq described_class.new 400
-      end
-
-      it "fails when symbolized reason is unknown" do
-        expect { described_class.coerce(:foobar) }.to raise_error HTTP::Error
-      end
-    end
-
-    context "with Numeric" do
-      it "coerces as Fixnum code" do
-        expect(described_class.coerce(200.1)).to eq described_class.new 200
-      end
-    end
-
-    it "fails if coercion failed" do
-      expect { described_class.coerce(true) }.to raise_error HTTP::Error
-    end
-
-    it "is aliased as `.[]`" do
-      expect(described_class.method(:coerce)).to eq described_class.method :[]
-    end
-  end
-end

data/spec/lib/http/response_spec.rb

@@ -1,262 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe HTTP::Response do
-  let(:body)          { "Hello world!" }
-  let(:uri)           { "http://example.com/" }
-  let(:headers)       { {} }
-  let(:request)       { HTTP::Request.new(:verb => :get, :uri => uri) }
-
-  subject(:response) do
-    HTTP::Response.new(
-      :status  => 200,
-      :version => "1.1",
-      :headers => headers,
-      :body    => body,
-      :request => request
-    )
-  end
-
-  it "includes HTTP::Headers::Mixin" do
-    expect(described_class).to include HTTP::Headers::Mixin
-  end
-
-  describe "to_a" do
-    let(:body)         { "Hello world" }
-    let(:content_type) { "text/plain" }
-    let(:headers)      { {"Content-Type" => content_type} }
-
-    it "returns a Rack-like array" do
-      expect(subject.to_a).to eq([200, headers, body])
-    end
-  end
-
-  describe "#content_length" do
-    subject { response.content_length }
-
-    context "without Content-Length header" do
-      it { is_expected.to be_nil }
-    end
-
-    context "with Content-Length: 5" do
-      let(:headers) { {"Content-Length" => "5"} }
-      it { is_expected.to eq 5 }
-    end
-
-    context "with invalid Content-Length" do
-      let(:headers) { {"Content-Length" => "foo"} }
-      it { is_expected.to be_nil }
-    end
-  end
-
-  describe "mime_type" do
-    subject { response.mime_type }
-
-    context "without Content-Type header" do
-      let(:headers) { {} }
-      it { is_expected.to be_nil }
-    end
-
-    context "with Content-Type: text/html" do
-      let(:headers) { {"Content-Type" => "text/html"} }
-      it { is_expected.to eq "text/html" }
-    end
-
-    context "with Content-Type: text/html; charset=utf-8" do
-      let(:headers) { {"Content-Type" => "text/html; charset=utf-8"} }
-      it { is_expected.to eq "text/html" }
-    end
-  end
-
-  describe "charset" do
-    subject { response.charset }
-
-    context "without Content-Type header" do
-      let(:headers) { {} }
-      it { is_expected.to be_nil }
-    end
-
-    context "with Content-Type: text/html" do
-      let(:headers) { {"Content-Type" => "text/html"} }
-      it { is_expected.to be_nil }
-    end
-
-    context "with Content-Type: text/html; charset=utf-8" do
-      let(:headers) { {"Content-Type" => "text/html; charset=utf-8"} }
-      it { is_expected.to eq "utf-8" }
-    end
-  end
-
-  describe "#parse" do
-    let(:headers)   { {"Content-Type" => content_type} }
-    let(:body)      { '{"foo":"bar"}' }
-
-    context "with known content type" do
-      let(:content_type) { "application/json" }
-      it "returns parsed body" do
-        expect(response.parse).to eq "foo" => "bar"
-      end
-    end
-
-    context "with unknown content type" do
-      let(:content_type) { "application/deadbeef" }
-      it "raises HTTP::Error" do
-        expect { response.parse }.to raise_error HTTP::Error
-      end
-    end
-
-    context "with explicitly given mime type" do
-      let(:content_type) { "application/deadbeef" }
-      it "ignores mime_type of response" do
-        expect(response.parse("application/json")).to eq "foo" => "bar"
-      end
-
-      it "supports mime type aliases" do
-        expect(response.parse(:json)).to eq "foo" => "bar"
-      end
-    end
-  end
-
-  describe "#flush" do
-    let(:body) { double :to_s => "" }
-
-    it "returns response self-reference" do
-      expect(response.flush).to be response
-    end
-
-    it "flushes body" do
-      expect(body).to receive :to_s
-      response.flush
-    end
-  end
-
-  describe "#inspect" do
-    subject { response.inspect }
-
-    let(:headers) { {:content_type => "text/plain"} }
-    let(:body)    { double :to_s => "foobar" }
-
-    it { is_expected.to eq '#<HTTP::Response/1.1 200 OK {"Content-Type"=>"text/plain"}>' }
-  end
-
-  describe "#cookies" do
-    let(:cookies) { ["a=1", "b=2; domain=example.com", "c=3; domain=bad.org"] }
-    let(:headers) { {"Set-Cookie" => cookies} }
-
-    subject(:jar) { response.cookies }
-
-    it { is_expected.to be_an HTTP::CookieJar }
-
-    it "contains cookies without domain restriction" do
-      expect(jar.count { |c| "a" == c.name }).to eq 1
-    end
-
-    it "contains cookies limited to domain of request uri" do
-      expect(jar.count { |c| "b" == c.name }).to eq 1
-    end
-
-    it "does not contains cookies limited to non-requeted uri" do
-      expect(jar.count { |c| "c" == c.name }).to eq 0
-    end
-  end
-
-  describe "#connection" do
-    let(:connection) { double }
-
-    subject(:response) do
-      HTTP::Response.new(
-        :version    => "1.1",
-        :status     => 200,
-        :connection => connection,
-        :request    => request
-      )
-    end
-
-    it "returns the connection object used to instantiate the response" do
-      expect(response.connection).to eq connection
-    end
-  end
-
-  describe "#chunked?" do
-    subject { response }
-    context "when encoding is set to chunked" do
-      let(:headers) { {"Transfer-Encoding" => "chunked"} }
-      it { is_expected.to be_chunked }
-    end
-    it { is_expected.not_to be_chunked }
-  end
-
-  describe "backwards compatibilty with :uri" do
-    context "with no :verb" do
-      subject(:response) do
-        HTTP::Response.new(
-          :status  => 200,
-          :version => "1.1",
-          :headers => headers,
-          :body    => body,
-          :uri     => uri
-        )
-      end
-
-      it "defaults the uri to :uri" do
-        expect(response.request.uri.to_s).to eq uri
-      end
-
-      it "defaults to the verb to :get" do
-        expect(response.request.verb).to eq :get
-      end
-    end
-
-    context "with both a :request and :uri" do
-      subject(:response) do
-        HTTP::Response.new(
-          :status  => 200,
-          :version => "1.1",
-          :headers => headers,
-          :body    => body,
-          :uri     => uri,
-          :request => request
-        )
-      end
-
-      it "raises ArgumentError" do
-        expect { response }.to raise_error(ArgumentError)
-      end
-    end
-  end
-
-  describe "#body" do
-    let(:connection) { double(:sequence_id => 0) }
-    let(:chunks)     { ["Hello, ", "World!"] }
-
-    subject(:response) do
-      HTTP::Response.new(
-        :status     => 200,
-        :version    => "1.1",
-        :headers    => headers,
-        :request    => request,
-        :connection => connection
-      )
-    end
-
-    before do
-      allow(connection).to receive(:readpartial) { chunks.shift }
-      allow(connection).to receive(:body_completed?) { chunks.empty? }
-    end
-
-    context "with no Content-Type" do
-      let(:headers) { {} }
-
-      it "returns a body with default binary encoding" do
-        expect(response.body.to_s.encoding).to eq Encoding::BINARY
-      end
-    end
-
-    context "with Content-Type: application/json" do
-      let(:headers) { {"Content-Type" => "application/json"} }
-
-      it "returns a body with a default UTF_8 encoding" do
-        expect(response.body.to_s.encoding).to eq Encoding::UTF_8
-      end
-    end
-  end
-end

data/spec/lib/http/uri/normalizer_spec.rb

@@ -1,95 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe HTTP::URI::NORMALIZER do
-  describe "scheme" do
-    it "lower-cases scheme" do
-      expect(HTTP::URI::NORMALIZER.call("HttP://example.com").scheme).to eq "http"
-    end
-  end
-
-  describe "hostname" do
-    it "lower-cases hostname" do
-      expect(HTTP::URI::NORMALIZER.call("http://EXAMPLE.com").host).to eq "example.com"
-    end
-
-    it "decodes percent-encoded hostname" do
-      expect(HTTP::URI::NORMALIZER.call("http://ex%61mple.com").host).to eq "example.com"
-    end
-
-    it "removes trailing period in hostname" do
-      expect(HTTP::URI::NORMALIZER.call("http://example.com.").host).to eq "example.com"
-    end
-
-    it "IDN-encodes non-ASCII hostname" do
-      expect(HTTP::URI::NORMALIZER.call("http://exämple.com").host).to eq "xn--exmple-cua.com"
-    end
-  end
-
-  describe "path" do
-    it "ensures path is not empty" do
-      expect(HTTP::URI::NORMALIZER.call("http://example.com").path).to eq "/"
-    end
-
-    it "preserves double slashes in path" do
-      expect(HTTP::URI::NORMALIZER.call("http://example.com//a///b").path).to eq "//a///b"
-    end
-
-    it "resolves single-dot segments in path" do
-      expect(HTTP::URI::NORMALIZER.call("http://example.com/a/./b").path).to eq "/a/b"
-    end
-
-    it "resolves double-dot segments in path" do
-      expect(HTTP::URI::NORMALIZER.call("http://example.com/a/b/../c").path).to eq "/a/c"
-    end
-
-    it "resolves leading double-dot segments in path" do
-      expect(HTTP::URI::NORMALIZER.call("http://example.com/../a/b").path).to eq "/a/b"
-    end
-
-    it "percent-encodes control characters in path" do
-      expect(HTTP::URI::NORMALIZER.call("http://example.com/\x00\x7F\n").path).to eq "/%00%7F%0A"
-    end
-
-    it "percent-encodes space in path" do
-      expect(HTTP::URI::NORMALIZER.call("http://example.com/a b").path).to eq "/a%20b"
-    end
-
-    it "percent-encodes non-ASCII characters in path" do
-      expect(HTTP::URI::NORMALIZER.call("http://example.com/キョ").path).to eq "/%E3%82%AD%E3%83%A7"
-    end
-
-    it "does not percent-encode non-special characters in path" do
-      expect(HTTP::URI::NORMALIZER.call("http://example.com/~.-_!$&()*,;=:@{}").path).to eq "/~.-_!$&()*,;=:@{}"
-    end
-
-    it "preserves escape sequences in path" do
-      expect(HTTP::URI::NORMALIZER.call("http://example.com/%41").path).to eq "/%41"
-    end
-  end
-
-  describe "query" do
-    it "allows no query" do
-      expect(HTTP::URI::NORMALIZER.call("http://example.com").query).to be_nil
-    end
-
-    it "percent-encodes control characters in query" do
-      expect(HTTP::URI::NORMALIZER.call("http://example.com/?\x00\x7F\n").query).to eq "%00%7F%0A"
-    end
-
-    it "percent-encodes space in query" do
-      expect(HTTP::URI::NORMALIZER.call("http://example.com/?a b").query).to eq "a%20b"
-    end
-
-    it "percent-encodes non-ASCII characters in query" do
-      expect(HTTP::URI::NORMALIZER.call("http://example.com?キョ").query).to eq "%E3%82%AD%E3%83%A7"
-    end
-
-    it "does not percent-encode non-special characters in query" do
-      expect(HTTP::URI::NORMALIZER.call("http://example.com/?~.-_!$&()*,;=:@{}?").query).to eq "~.-_!$&()*,;=:@{}?"
-    end
-
-    it "preserves escape sequences in query" do
-      expect(HTTP::URI::NORMALIZER.call("http://example.com/?%41").query).to eq "%41"
-    end
-  end
-end