http 5.0.0.pre → 5.0.0.pre2

data/spec/lib/http/features/logging_spec.rb

@@ -17,10 +17,10 @@ RSpec.describe HTTP::Features::Logging do
   describe "logging the request" do
     let(:request) do
       HTTP::Request.new(
-        :verb     => :post,
-        :uri      => "https://example.com/",
-        :headers  => {:accept => "application/json"},
-        :body     => '{"hello": "world!"}'
+        :verb    => :post,
+        :uri     => "https://example.com/",
+        :headers => {:accept => "application/json"},
+        :body    => '{"hello": "world!"}'
       )
     end
 
@@ -47,7 +47,8 @@ RSpec.describe HTTP::Features::Logging do
         :uri     => "https://example.com",
         :status  => 200,
         :headers => {:content_type => "application/json"},
-        :body    => '{"success": true}'
+        :body    => '{"success": true}',
+        :request => HTTP::Request.new(:verb => :get, :uri => "https://example.com")
       )
     end
 

data/spec/lib/http/headers_spec.rb

@@ -13,7 +13,7 @@ RSpec.describe HTTP::Headers do
       expect(headers["Accept"]).to eq "application/json"
     end
 
-    it "normalizes header name" do
+    it "allows retrieval via normalized header name" do
       headers.set :content_type, "application/json"
       expect(headers["Content-Type"]).to eq "application/json"
     end
@@ -35,8 +35,15 @@ RSpec.describe HTTP::Headers do
         to raise_error HTTP::HeaderError
     end
 
-    it "fails with invalid header name" do
-      expect { headers.set "foo bar", "baz" }.
+    ["foo bar", "foo bar: ok\nfoo", "evil-header: evil-value\nfoo"].each do |name|
+      it "fails with invalid header name (#{name.inspect})" do
+        expect { headers.set name, "baz" }.
+          to raise_error HTTP::HeaderError
+      end
+    end
+
+    it "fails with invalid header value" do
+      expect { headers.set "foo", "bar\nEvil-Header: evil-value" }.
         to raise_error HTTP::HeaderError
     end
   end
@@ -47,7 +54,7 @@ RSpec.describe HTTP::Headers do
       expect(headers["Accept"]).to eq "application/json"
     end
 
-    it "normalizes header name" do
+    it "allows retrieval via normalized header name" do
       headers[:content_type] = "application/json"
       expect(headers["Content-Type"]).to eq "application/json"
     end
@@ -73,7 +80,7 @@ RSpec.describe HTTP::Headers do
       expect(headers["Content-Type"]).to be_nil
     end
 
-    it "normalizes header name" do
+    it "removes header that matches normalized version of specified name" do
       headers.delete :content_type
       expect(headers["Content-Type"]).to be_nil
     end
@@ -83,9 +90,11 @@ RSpec.describe HTTP::Headers do
         to raise_error HTTP::HeaderError
     end
 
-    it "fails with invalid header name" do
-      expect { headers.delete "foo bar" }.
-        to raise_error HTTP::HeaderError
+    ["foo bar", "foo bar: ok\nfoo"].each do |name|
+      it "fails with invalid header name (#{name.inspect})" do
+        expect { headers.delete name }.
+          to raise_error HTTP::HeaderError
+      end
     end
   end
 
@@ -95,13 +104,13 @@ RSpec.describe HTTP::Headers do
       expect(headers["Accept"]).to eq "application/json"
     end
 
-    it "normalizes header name" do
+    it "allows retrieval via normalized header name" do
       headers.add :content_type, "application/json"
       expect(headers["Content-Type"]).to eq "application/json"
     end
 
     it "appends new value if header exists" do
-      headers.add :set_cookie, "hoo=ray"
+      headers.add "Set-Cookie", "hoo=ray"
       headers.add :set_cookie, "woo=hoo"
       expect(headers["Set-Cookie"]).to eq %w[hoo=ray woo=hoo]
     end
@@ -117,8 +126,20 @@ RSpec.describe HTTP::Headers do
         to raise_error HTTP::HeaderError
     end
 
-    it "fails with invalid header name" do
-      expect { headers.add "foo bar", "baz" }.
+    ["foo bar", "foo bar: ok\nfoo"].each do |name|
+      it "fails with invalid header name (#{name.inspect})" do
+        expect { headers.add name, "baz" }.
+          to raise_error HTTP::HeaderError
+      end
+    end
+
+    it "fails with invalid header value" do
+      expect { headers.add "foo", "bar\nEvil-Header: evil-value" }.
+        to raise_error HTTP::HeaderError
+    end
+
+    it "fails when header name is not a String or Symbol" do
+      expect { headers.add 2, "foo" }.
         to raise_error HTTP::HeaderError
     end
   end
@@ -145,9 +166,11 @@ RSpec.describe HTTP::Headers do
         to raise_error HTTP::HeaderError
     end
 
-    it "fails with invalid header name" do
-      expect { headers.get("foo bar") }.
-        to raise_error HTTP::HeaderError
+    ["foo bar", "foo bar: ok\nfoo"].each do |name|
+      it "fails with invalid header name (#{name.inspect})" do
+        expect { headers.get name }.
+          to raise_error HTTP::HeaderError
+      end
     end
   end
 
@@ -296,6 +319,17 @@ RSpec.describe HTTP::Headers do
       )
     end
 
+    it "yields header keys specified as symbols in normalized form" do
+      keys = headers.each.map(&:first)
+      expect(keys).to eq(["Set-Cookie", "Content-Type", "Set-Cookie"])
+    end
+
+    it "yields headers specified as strings without conversion" do
+      headers.add "X_kEy", "value"
+      keys = headers.each.map(&:first)
+      expect(keys).to eq(["Set-Cookie", "Content-Type", "Set-Cookie", "X_kEy"])
+    end
+
     it "returns self instance if block given" do
       expect(headers.each { |*| }).to be headers
     end
@@ -472,14 +506,15 @@ RSpec.describe HTTP::Headers do
     end
 
     context "with duplicate header keys (mixed case)" do
-      let(:headers) { {"Set-Cookie" => "hoo=ray", "set-cookie" => "woo=hoo"} }
+      let(:headers) { {"Set-Cookie" => "hoo=ray", "set_cookie" => "woo=hoo", :set_cookie => "ta=da"} }
 
       it "adds all headers" do
         expect(described_class.coerce(headers).to_a).
           to match_array(
             [
               %w[Set-Cookie hoo=ray],
-              %w[Set-Cookie woo=hoo]
+              %w[set_cookie woo=hoo],
+              %w[Set-Cookie ta=da]
             ]
           )
       end

data/spec/lib/http/options/headers_spec.rb

@@ -8,7 +8,7 @@ RSpec.describe HTTP::Options, "headers" do
   end
 
   it "may be specified with with_headers" do
-    opts2 = opts.with_headers("accept" => "json")
+    opts2 = opts.with_headers(:accept => "json")
     expect(opts.headers).to be_empty
     expect(opts2.headers).to eq([%w[Accept json]])
   end

data/spec/lib/http/options/merge_spec.rb

@@ -18,28 +18,28 @@ RSpec.describe HTTP::Options, "merge" do
     # 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  => {}
+      :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"},
+      :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}
+      :ssl                => {:foo => "bar"},
+      :proxy              => {:proxy_address => "127.0.0.1", :proxy_port => 8080}
     )
 
     expect(foo.merge(bar).to_hash).to eq(

data/spec/lib/http/redirector_spec.rb

@@ -6,7 +6,8 @@ RSpec.describe HTTP::Redirector do
       :status  => status,
       :version => "1.1",
       :headers => headers,
-      :body    => body
+      :body    => body,
+      :request => HTTP::Request.new(:verb => :get, :uri => "http://example.com")
     )
   end
 
@@ -75,6 +76,19 @@ RSpec.describe HTTP::Redirector do
       expect(res.to_s).to eq "foo"
     end
 
+    it "concatenates multiple Location headers" do
+      req     = HTTP::Request.new :verb => :head, :uri => "http://example.com"
+      headers = HTTP::Headers.new
+
+      %w[http://example.com /123].each { |loc| headers.add("Location", loc) }
+
+      res = redirector.perform(req, simple_response(301, "", headers)) do |redirect|
+        simple_response(200, redirect.uri.to_s)
+      end
+
+      expect(res.to_s).to eq "http://example.com/123"
+    end
+
     context "following 300 redirect" do
       context "with strict mode" do
         let(:options) { {:strict => true} }

data/spec/lib/http/request/body_spec.rb

@@ -125,6 +125,28 @@ RSpec.describe HTTP::Request::Body do
       end
     end
 
+    context "when body is a pipe" do
+      let(:ios)  { IO.pipe }
+      let(:body) { ios[0] }
+
+      around do |example|
+        writer = Thread.new(ios[1]) do |io|
+          io << "abcdef"
+          io.close
+        end
+
+        begin
+          example.run
+        ensure
+          writer.join
+        end
+      end
+
+      it "yields chunks of content" do
+        expect(chunks.inject("", :+)).to eq("abcdef")
+      end
+    end
+
     context "when body is an Enumerable IO" do
       let(:data) { "a" * 16 * 1024 + "b" * 10 * 1024 }
       let(:body) { StringIO.new data }

data/spec/lib/http/request/writer_spec.rb

@@ -1,5 +1,5 @@
-# frozen_string_literal: true
 # coding: utf-8
+# frozen_string_literal: true
 
 RSpec.describe HTTP::Request::Writer do
   let(:io)          { StringIO.new }
@@ -22,6 +22,18 @@ RSpec.describe HTTP::Request::Writer do
       end
     end
 
+    context "when headers are specified as strings with mixed case" do
+      let(:headers) { HTTP::Headers.coerce "content-Type" => "text", "X_MAX" => "200" }
+
+      it "writes the headers with the same casing" do
+        writer.stream
+        expect(io.string).to eq [
+          "#{headerstart}\r\n",
+          "content-Type: text\r\nX_MAX: 200\r\nContent-Length: 0\r\n\r\n"
+        ].join
+      end
+    end
+
     context "when body is nonempty" do
       let(:body) { HTTP::Request::Body.new("content") }
 

data/spec/lib/http/request_spec.rb

@@ -1,5 +1,5 @@
-# frozen_string_literal: true
 # coding: utf-8
+# frozen_string_literal: true
 
 RSpec.describe HTTP::Request do
   let(:proxy)       { {} }
@@ -8,10 +8,10 @@ RSpec.describe HTTP::Request do
 
   subject :request do
     HTTP::Request.new(
-      :verb     => :get,
-      :uri      => request_uri,
-      :headers  => headers,
-      :proxy    => proxy
+      :verb    => :get,
+      :uri     => request_uri,
+      :headers => headers,
+      :proxy   => proxy
     )
   end
 

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

@@ -0,0 +1,45 @@
+# 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.split(//) }
+
+    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
+end

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

@@ -26,7 +26,7 @@ RSpec.describe HTTP::Response::Status do
     end
 
     described_class::REASONS.each do |code, reason|
-      class_eval <<-RUBY
+      class_eval <<-RUBY, __FILE__, __LINE__ + 1
         context 'with well-known code: #{code}' do
           let(:code) { #{code} }
           it { is_expected.to eq #{reason.inspect} }
@@ -165,7 +165,7 @@ RSpec.describe HTTP::Response::Status do
     end
 
     described_class::SYMBOLS.each do |code, symbol|
-      class_eval <<-RUBY
+      class_eval <<-RUBY, __FILE__, __LINE__ + 1
         context 'with well-known code: #{code}' do
           let(:code) { #{code} }
           it { is_expected.to be #{symbol.inspect} }
@@ -193,7 +193,7 @@ RSpec.describe HTTP::Response::Status do
   end
 
   described_class::SYMBOLS.each do |code, symbol|
-    class_eval <<-RUBY
+    class_eval <<-RUBY, __FILE__, __LINE__ + 1
       describe '##{symbol}?' do
         subject { status.#{symbol}? }
 

data/spec/lib/http/response_spec.rb

@@ -11,7 +11,8 @@ RSpec.describe HTTP::Response do
       :version => "1.1",
       :headers => headers,
       :body    => body,
-      :uri     => uri
+      :uri     => uri,
+      :request => HTTP::Request.new(:verb => :get, :uri => "http://example.com")
     )
   end
 
@@ -86,32 +87,19 @@ RSpec.describe HTTP::Response do
   end
 
   describe "#parse" do
-    let(:headers)   { {"Content-Type" => content_type} }
+    let(:headers)   { {"Content-Type" => "application/json"} }
     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
+    it "fails if MIME type decoder is not found" do
+      expect { response.parse "text/html" }.to raise_error(HTTP::Error)
     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
+    it "uses decoder found by given MIME type" do
+      expect(response.parse("application/json")).to eq("foo" => "bar")
     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
+    it "uses decoder found by given MIME type alias" do
+      expect(response.parse(:json)).to eq("foo" => "bar")
     end
   end
 
@@ -165,7 +153,8 @@ RSpec.describe HTTP::Response do
       HTTP::Response.new(
         :version    => "1.1",
         :status     => 200,
-        :connection => connection
+        :connection => connection,
+        :request    => HTTP::Request.new(:verb => :get, :uri => "http://example.com")
       )
     end