http 2.2.2 → 3.0.0.pre

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

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 RSpec.describe HTTP::Options, "body" do
   let(:opts) { HTTP::Options.new }
 

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

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 RSpec.describe HTTP::Options, "features" do
   let(:opts) { HTTP::Options.new }
 

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

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 RSpec.describe HTTP::Options, "form" do
   let(:opts) { HTTP::Options.new }
 

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

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 RSpec.describe HTTP::Options, "headers" do
   let(:opts) { HTTP::Options.new }
 
@@ -9,7 +10,7 @@ RSpec.describe HTTP::Options, "headers" do
   it "may be specified with with_headers" do
     opts2 = opts.with_headers("accept" => "json")
     expect(opts.headers).to be_empty
-    expect(opts2.headers).to eq([%w(Accept json)])
+    expect(opts2.headers).to eq([%w[Accept json]])
   end
 
   it "accepts any object that respond to :to_hash" do

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

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 RSpec.describe HTTP::Options, "json" do
   let(:opts) { HTTP::Options.new }
 

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

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 RSpec.describe HTTP::Options, "new" do
   it "supports a Options instance" do
     opts = HTTP::Options.new
@@ -13,7 +14,7 @@ RSpec.describe HTTP::Options, "new" do
 
     it "coerces :headers correctly" do
       opts = HTTP::Options.new(:headers => {:accept => "json"})
-      expect(opts.headers).to eq([%w(Accept json)])
+      expect(opts.headers).to eq([%w[Accept json]])
     end
 
     it "coerces :proxy correctly" do

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

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 RSpec.describe HTTP::Options, "proxy" do
   let(:opts) { HTTP::Options.new }
 

data/spec/lib/http/options_spec.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 RSpec.describe HTTP::Options do
   subject { described_class.new(:response => :body) }
 

data/spec/lib/http/redirector_spec.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 RSpec.describe HTTP::Redirector do
   def simple_response(status, body = "", headers = {})
     HTTP::Response.new(

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

@@ -0,0 +1,138 @@
+# frozen_string_literal: true
+
+RSpec.describe HTTP::Request::Body do
+  let(:body) { "" }
+  subject    { HTTP::Request::Body.new(body) }
+
+  describe "#initialize" do
+    context "when body is nil" do
+      let(:body) { nil }
+
+      it "does not raise an error" do
+        expect { subject }.not_to raise_error
+      end
+    end
+
+    context "when body is a string" do
+      let(:body) { "string body" }
+
+      it "does not raise an error" do
+        expect { subject }.not_to raise_error
+      end
+    end
+
+    context "when body is an IO" do
+      let(:body) { FakeIO.new("IO body") }
+
+      it "does not raise an error" do
+        expect { subject }.not_to raise_error
+      end
+    end
+
+    context "when body is an Enumerable" do
+      let(:body) { %w[bees cows] }
+
+      it "does not raise an error" do
+        expect { subject }.not_to raise_error
+      end
+    end
+
+    context "when body is of unrecognized type" do
+      let(:body) { 123 }
+
+      it "raises an error" do
+        expect { subject }.to raise_error(HTTP::RequestError)
+      end
+    end
+  end
+
+  describe "#size" do
+    context "when body is nil" do
+      let(:body) { nil }
+
+      it "returns zero" do
+        expect(subject.size).to eq 0
+      end
+    end
+
+    context "when body is a string" do
+      let(:body) { "Привет, мир!" }
+
+      it "returns string bytesize" do
+        expect(subject.size).to eq 21
+      end
+    end
+
+    context "when body is an IO with size" do
+      let(:body) { FakeIO.new("content") }
+
+      it "returns IO size" do
+        expect(subject.size).to eq 7
+      end
+    end
+
+    context "when body is an IO without size" do
+      let(:body) { IO.pipe[0] }
+
+      it "raises a RequestError" do
+        expect { subject.size }.to raise_error(HTTP::RequestError)
+      end
+    end
+
+    context "when body is an Enumerable" do
+      let(:body) { %w[bees cows] }
+
+      it "raises a RequestError" do
+        expect { subject.size }.to raise_error(HTTP::RequestError)
+      end
+    end
+  end
+
+  describe "#each" do
+    let(:chunks) do
+      chunks = []
+      subject.each { |chunk| chunks << chunk.dup }
+      chunks
+    end
+
+    context "when body is nil" do
+      let(:body) { nil }
+
+      it "yields nothing" do
+        expect(chunks).to eq []
+      end
+    end
+
+    context "when body is a string" do
+      let(:body) { "content" }
+
+      it "yields the string" do
+        expect(chunks).to eq %w[content]
+      end
+    end
+
+    context "when body is a non-Enumerable IO" do
+      let(:body) { FakeIO.new("a" * 16 * 1024 + "b" * 10 * 1024) }
+
+      it "yields chunks of content" do
+        expect(chunks.inject("", :+)).to eq "a" * 16 * 1024 + "b" * 10 * 1024
+      end
+    end
+
+    context "when body is an Enumerable IO" do
+      let(:body) { StringIO.new("a" * 16 * 1024 + "b" * 10 * 1024) }
+
+      it "yields chunks of content" do
+        expect(chunks.inject("", :+)).to eq "a" * 16 * 1024 + "b" * 10 * 1024
+      end
+    end
+
+    context "when body is an Enumerable" do
+      let(:body) { %w[bees cows] }
+
+      it "yields elements" do
+        expect(chunks).to eq %w[bees cows]
+      end
+    end
+  end
+end

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

@@ -3,105 +3,75 @@
 
 RSpec.describe HTTP::Request::Writer do
   let(:io)          { StringIO.new }
-  let(:body)        { "" }
+  let(:body)        { HTTP::Request::Body.new("") }
   let(:headers)     { HTTP::Headers.new }
   let(:headerstart) { "GET /test HTTP/1.1" }
 
   subject(:writer)  { described_class.new(io, body, headers, headerstart) }
 
-  describe "#initalize" do
-    context "when body is nil" do
-      let(:body) { nil }
-
-      it "does not raise an error" do
-        expect { writer }.not_to raise_error
-      end
-    end
-
-    context "when body is a string" do
-      let(:body) { "string body" }
-
-      it "does not raise an error" do
-        expect { writer }.not_to raise_error
-      end
-    end
-
-    context "when body is an Enumerable" do
-      let(:body) { %w(bees cows) }
+  describe "#stream" do
+    context "when multiple headers are set" do
+      let(:headers) { HTTP::Headers.coerce "Host" => "example.org" }
 
-      it "does not raise an error" do
-        expect { writer }.not_to raise_error
+      it "separates headers with carriage return and line feed" do
+        writer.stream
+        expect(io.string).to eq [
+          "#{headerstart}\r\n",
+          "Host: example.org\r\nContent-Length: 0\r\n\r\n"
+        ].join
       end
     end
 
-    context "when body is not string, enumerable or nil" do
-      let(:body) { 123 }
+    context "when body is nonempty" do
+      let(:body) { HTTP::Request::Body.new("content") }
 
-      it "raises an error" do
-        expect { writer }.to raise_error(HTTP::RequestError)
+      it "writes it to the socket and sets Content-Length" do
+        writer.stream
+        expect(io.string).to eq [
+          "#{headerstart}\r\n",
+          "Content-Length: 7\r\n\r\n",
+          "content"
+        ].join
       end
     end
-  end
-
-  describe "#stream" do
-    context "when body is Enumerable" do
-      let(:body)    { %w(bees cows) }
-      let(:headers) { HTTP::Headers.coerce "Transfer-Encoding" => "chunked" }
 
-      it "writes a chunked request from an Enumerable correctly" do
-        writer.stream
-        expect(io.string).to end_with "\r\n4\r\nbees\r\n4\r\ncows\r\n0\r\n\r\n"
-      end
+    context "when body is empty" do
+      let(:body) { HTTP::Request::Body.new(nil) }
 
-      it "writes Transfer-Encoding header only once" do
+      it "doesn't write anything to the socket and sets Content-Length" do
         writer.stream
-        expect(io.string).to start_with "#{headerstart}\r\nTransfer-Encoding: chunked\r\n\r\n"
-      end
-
-      context "when Transfer-Encoding not set" do
-        let(:headers) { HTTP::Headers.new }
-        specify { expect { writer.stream }.to raise_error(HTTP::RequestError) }
-      end
-
-      context "when Transfer-Encoding is not chunked" do
-        let(:headers) { HTTP::Headers.coerce "Transfer-Encoding" => "gzip" }
-        specify { expect { writer.stream }.to raise_error(HTTP::RequestError) }
+        expect(io.string).to eq [
+          "#{headerstart}\r\n",
+          "Content-Length: 0\r\n\r\n"
+        ].join
       end
     end
 
-    context "when body is nil" do
-      let(:body) { nil }
+    context "when Content-Length header is set" do
+      let(:headers) { HTTP::Headers.coerce "Content-Length" => "12" }
+      let(:body)    { HTTP::Request::Body.new("content") }
 
-      it "properly sets Content-Length header if needed" do
+      it "keeps the given value" do
         writer.stream
-        expect(io.string).to start_with "#{headerstart}\r\nContent-Length: 0\r\n\r\n"
-      end
-
-      context "when Content-Length explicitly set" do
-        let(:headers) { HTTP::Headers.coerce "Content-Length" => 12 }
-
-        it "keeps given value" do
-          writer.stream
-          expect(io.string).to start_with "#{headerstart}\r\nContent-Length: 12\r\n\r\n"
-        end
+        expect(io.string).to eq [
+          "#{headerstart}\r\n",
+          "Content-Length: 12\r\n\r\n",
+          "content"
+        ].join
       end
     end
 
-    context "when body is a unicode String" do
-      let(:body) { "Привет, мир!" }
+    context "when Transfer-Encoding is chunked" do
+      let(:headers) { HTTP::Headers.coerce "Transfer-Encoding" => "chunked" }
+      let(:body)    { HTTP::Request::Body.new(%w[request body]) }
 
-      it "properly calculates Content-Length if needed" do
+      it "writes encoded content and omits Content-Length" do
         writer.stream
-        expect(io.string).to start_with "#{headerstart}\r\nContent-Length: 21\r\n\r\n"
-      end
-
-      context "when Content-Length explicitly set" do
-        let(:headers) { HTTP::Headers.coerce "Content-Length" => 12 }
-
-        it "keeps given value" do
-          writer.stream
-          expect(io.string).to start_with "#{headerstart}\r\nContent-Length: 12\r\n\r\n"
-        end
+        expect(io.string).to eq [
+          "#{headerstart}\r\n",
+          "Transfer-Encoding: chunked\r\n\r\n",
+          "7\r\nrequest\r\n4\r\nbody\r\n0\r\n\r\n"
+        ].join
       end
     end
   end

data/spec/lib/http/request_spec.rb

@@ -94,6 +94,20 @@ RSpec.describe HTTP::Request do
       expect(redirected["Host"]).to eq "blog.example.com"
     end
 
+    context "with URL with non-standard port given" do
+      subject(:redirected) { request.redirect "http://example.com:8080" }
+
+      its(:uri)     { is_expected.to eq HTTP::URI.parse "http://example.com:8080" }
+
+      its(:verb)    { is_expected.to eq request.verb }
+      its(:body)    { is_expected.to eq request.body }
+      its(:proxy)   { is_expected.to eq request.proxy }
+
+      it "presets new Host header" do
+        expect(redirected["Host"]).to eq "example.com:8080"
+      end
+    end
+
     context "with schema-less absolute URL given" do
       subject(:redirected) { request.redirect "//another.example.com/blog" }
 

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

@@ -1,11 +1,15 @@
 # frozen_string_literal: true
+
 RSpec.describe HTTP::Response::Body do
   let(:connection) { double(:sequence_id => 0) }
   let(:chunks)     { [String.new("Hello, "), String.new("World!")] }
 
-  before           { allow(connection).to receive(:readpartial) { chunks.shift } }
+  before do
+    allow(connection).to receive(:readpartial) { chunks.shift }
+    allow(connection).to receive(:body_completed?) { chunks.empty? }
+  end
 
-  subject(:body)   { described_class.new(connection, Encoding::UTF_8) }
+  subject(:body) { described_class.new(connection, :encoding => Encoding::UTF_8) }
 
   it "streams bodies from responses" do
     expect(subject.to_s).to eq("Hello, World!")
@@ -37,6 +41,18 @@ RSpec.describe HTTP::Response::Body do
         body.readpartial
       end
     end
+
+    it "returns content in specified encoding" do
+      body = described_class.new(connection)
+      expect(connection).to receive(:readpartial).
+        and_return(String.new("content").force_encoding(Encoding::UTF_8))
+      expect(body.readpartial.encoding).to eq Encoding::BINARY
+
+      body = described_class.new(connection, :encoding => Encoding::UTF_8)
+      expect(connection).to receive(:readpartial).
+        and_return(String.new("content").force_encoding(Encoding::BINARY))
+      expect(body.readpartial.encoding).to eq Encoding::UTF_8
+    end
   end
 
   context "when body is gzipped" do
@@ -47,7 +63,7 @@ RSpec.describe HTTP::Response::Body do
     end
     subject(:body) do
       inflater = HTTP::Response::Inflater.new(connection)
-      described_class.new(inflater, Encoding::UTF_8)
+      described_class.new(inflater, :encoding => Encoding::UTF_8)
     end
 
     it "decodes body" do
@@ -58,7 +74,7 @@ RSpec.describe HTTP::Response::Body do
       it "streams decoded body" do
         [
           "Hi, HTTP ",
-          String.new("here ☺").force_encoding("ASCII-8BIT"),
+          "here ☺",
           nil
         ].each do |part|
           expect(subject.readpartial).to eq(part)

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

@@ -1,4 +1,5 @@
 # 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
@@ -13,7 +14,7 @@ RSpec.describe HTTP::Response::Status do
   describe "#code" do
     subject { described_class.new("200.0").code }
     it { is_expected.to eq 200 }
-    it { is_expected.to be_a Fixnum }
+    it { is_expected.to be_a Integer }
   end
 
   describe "#reason" do
@@ -39,23 +40,23 @@ RSpec.describe HTTP::Response::Status do
     subject { (100...200).map { |code| described_class.new code } }
 
     it "is #informational?" do
-      expect(subject).to all satisfy(&:informational?)
+      expect(subject).to all(satisfy(&:informational?))
     end
 
     it "is not #success?" do
-      expect(subject).to all satisfy { |status| !status.success? }
+      expect(subject).to all(satisfy { |status| !status.success? })
     end
 
     it "is not #redirect?" do
-      expect(subject).to all satisfy { |status| !status.redirect? }
+      expect(subject).to all(satisfy { |status| !status.redirect? })
     end
 
     it "is not #client_error?" do
-      expect(subject).to all satisfy { |status| !status.client_error? }
+      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? }
+      expect(subject).to all(satisfy { |status| !status.server_error? })
     end
   end
 
@@ -63,23 +64,23 @@ RSpec.describe HTTP::Response::Status do
     subject { (200...300).map { |code| described_class.new code } }
 
     it "is not #informational?" do
-      expect(subject).to all satisfy { |status| !status.informational? }
+      expect(subject).to all(satisfy { |status| !status.informational? })
     end
 
     it "is #success?" do
-      expect(subject).to all satisfy(&:success?)
+      expect(subject).to all(satisfy(&:success?))
     end
 
     it "is not #redirect?" do
-      expect(subject).to all satisfy { |status| !status.redirect? }
+      expect(subject).to all(satisfy { |status| !status.redirect? })
     end
 
     it "is not #client_error?" do
-      expect(subject).to all satisfy { |status| !status.client_error? }
+      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? }
+      expect(subject).to all(satisfy { |status| !status.server_error? })
     end
   end
 
@@ -87,23 +88,23 @@ RSpec.describe HTTP::Response::Status do
     subject { (300...400).map { |code| described_class.new code } }
 
     it "is not #informational?" do
-      expect(subject).to all satisfy { |status| !status.informational? }
+      expect(subject).to all(satisfy { |status| !status.informational? })
     end
 
     it "is not #success?" do
-      expect(subject).to all satisfy { |status| !status.success? }
+      expect(subject).to all(satisfy { |status| !status.success? })
     end
 
     it "is #redirect?" do
-      expect(subject).to all satisfy(&:redirect?)
+      expect(subject).to all(satisfy(&:redirect?))
     end
 
     it "is not #client_error?" do
-      expect(subject).to all satisfy { |status| !status.client_error? }
+      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? }
+      expect(subject).to all(satisfy { |status| !status.server_error? })
     end
   end
 
@@ -111,23 +112,23 @@ RSpec.describe HTTP::Response::Status do
     subject { (400...500).map { |code| described_class.new code } }
 
     it "is not #informational?" do
-      expect(subject).to all satisfy { |status| !status.informational? }
+      expect(subject).to all(satisfy { |status| !status.informational? })
     end
 
     it "is not #success?" do
-      expect(subject).to all satisfy { |status| !status.success? }
+      expect(subject).to all(satisfy { |status| !status.success? })
     end
 
     it "is not #redirect?" do
-      expect(subject).to all satisfy { |status| !status.redirect? }
+      expect(subject).to all(satisfy { |status| !status.redirect? })
     end
 
     it "is #client_error?" do
-      expect(subject).to all satisfy(&:client_error?)
+      expect(subject).to all(satisfy(&:client_error?))
     end
 
     it "is not #server_error?" do
-      expect(subject).to all satisfy { |status| !status.server_error? }
+      expect(subject).to all(satisfy { |status| !status.server_error? })
     end
   end
 
@@ -135,23 +136,23 @@ RSpec.describe HTTP::Response::Status do
     subject { (500...600).map { |code| described_class.new code } }
 
     it "is not #informational?" do
-      expect(subject).to all satisfy { |status| !status.informational? }
+      expect(subject).to all(satisfy { |status| !status.informational? })
     end
 
     it "is not #success?" do
-      expect(subject).to all satisfy { |status| !status.success? }
+      expect(subject).to all(satisfy { |status| !status.success? })
     end
 
     it "is not #redirect?" do
-      expect(subject).to all satisfy { |status| !status.redirect? }
+      expect(subject).to all(satisfy { |status| !status.redirect? })
     end
 
     it "is not #client_error?" do
-      expect(subject).to all satisfy { |status| !status.client_error? }
+      expect(subject).to all(satisfy { |status| !status.client_error? })
     end
 
     it "is #server_error?" do
-      expect(subject).to all satisfy(&:server_error?)
+      expect(subject).to all(satisfy(&:server_error?))
     end
   end