http 2.2.2 → 3.0.0.pre

data/lib/http/response/parser.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 module HTTP
   class Response
     class Parser

data/lib/http/response/status.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require "delegate"
 
 require "http/response/status/reasons"

data/lib/http/response/status/reasons.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 # AUTO-GENERATED FILE, DO NOT CHANGE IT MANUALLY
 
 require "delegate"

data/lib/http/timeout/global.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require "timeout"
 require "io/wait"
 

data/lib/http/timeout/null.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require "forwardable"
 require "io/wait"
 
@@ -11,7 +12,7 @@ module HTTP
 
       attr_reader :options, :socket
 
-      def initialize(options = {})
+      def initialize(options = {}) # rubocop:disable Style/OptionHash
         @options = options
       end
 

data/lib/http/timeout/per_operation.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require "timeout"
 
 require "http/timeout/null"
@@ -59,29 +60,41 @@ module HTTP
       else
         # Read data from the socket
         def readpartial(size)
+          timeout = false
           loop do
             result = @socket.read_nonblock(size, :exception => false)
 
             return :eof   if result.nil?
             return result if result != :wait_readable
 
-            unless IO.select([@socket], nil, nil, read_timeout)
-              raise TimeoutError, "Read timed out after #{read_timeout} seconds"
-            end
+            raise TimeoutError, "Read timed out after #{read_timeout} seconds" if timeout
+            # marking the socket for timeout. Why is this not being raised immediately?
+            # it seems there is some race-condition on the network level between calling
+            # #read_nonblock and #wait_readable, in which #read_nonblock signalizes waiting
+            # for reads, and when waiting for x seconds, it returns nil suddenly without completing
+            # the x seconds. In a normal case this would be a timeout on wait/read, but it can
+            # also mean that the socket has been closed by the server. Therefore we "mark" the
+            # socket for timeout and try to read more bytes. If it returns :eof, it's all good, no
+            # timeout. Else, the first timeout was a proper timeout.
+            # This hack has to be done because io/wait#wait_readable doesn't provide a value for when
+            # the socket is closed by the server, and HTTP::Parser doesn't provide the limit for the chunks.
+            timeout = true unless @socket.to_io.wait_readable(read_timeout)
           end
         end
 
         # Write data to the socket
         def write(data)
+          timeout = false
           loop do
             result = @socket.write_nonblock(data, :exception => false)
             return result unless result == :wait_writable
 
-            unless IO.select(nil, [@socket], nil, write_timeout)
-              raise TimeoutError, "Write timed out after #{write_timeout} seconds"
-            end
+            raise TimeoutError, "Write timed out after #{write_timeout} seconds" if timeout
+
+            timeout = true unless @socket.to_io.wait_writable(write_timeout)
           end
         end
+
       end
     end
   end

data/lib/http/uri.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require "addressable/uri"
 
 module HTTP
@@ -19,10 +20,10 @@ module HTTP
     def_delegators :@uri, :omit, :join, :normalize
 
     # @private
-    HTTP_SCHEME = "http".freeze
+    HTTP_SCHEME = "http"
 
     # @private
-    HTTPS_SCHEME = "https".freeze
+    HTTPS_SCHEME = "https"
 
     # Parse the given URI string, returning an HTTP::URI object
     #
@@ -114,6 +115,11 @@ module HTTP
       HTTPS_SCHEME == scheme
     end
 
+    # @return [Object] duplicated URI
+    def dup
+      self.class.new @uri.dup
+    end
+
     # Convert an HTTP::URI to a String
     #
     # @return [String] URI serialized as a String

data/lib/http/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module HTTP
-  VERSION = "2.2.2".freeze
+  VERSION = "3.0.0.pre"
 end

data/spec/lib/http/client_spec.rb

@@ -111,7 +111,7 @@ RSpec.describe HTTP::Client do
 
     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))
+        expect(CGI.parse(opts[:uri].query)).to eq("foo" => %w[bar])
       end
 
       client.get("http://example.com/?foo=bar")
@@ -119,7 +119,7 @@ RSpec.describe HTTP::Client do
 
     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))
+        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"})
@@ -143,7 +143,7 @@ RSpec.describe HTTP::Client do
 
     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)
+        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"})
@@ -158,6 +158,32 @@ RSpec.describe HTTP::Client do
     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
+  end
+
   describe "passing json" do
     it "encodes given object" do
       client = HTTP::Client.new
@@ -197,6 +223,27 @@ RSpec.describe HTTP::Client do
         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 => {}} }
+
+      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
+    end
   end
 
   include_context "HTTP handling" do
@@ -280,7 +327,7 @@ RSpec.describe HTTP::Client do
 
         allow(socket_spy).to receive(:close) { nil }
         allow(socket_spy).to receive(:closed?) { true }
-        allow(socket_spy).to receive(:readpartial) { chunks[0] }
+        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 }
@@ -291,5 +338,58 @@ RSpec.describe HTTP::Client do
         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
+
+        it "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/content_type_spec.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 RSpec.describe HTTP::ContentType do
   describe ".parse" do
     context "with text/plain" do

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

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 RSpec.describe HTTP::Features::AutoDeflate do
   subject { HTTP::Features::AutoDeflate.new }
 
@@ -25,84 +26,51 @@ RSpec.describe HTTP::Features::AutoDeflate do
     expect(subject.method).to eq("gzip")
   end
 
-  describe "#deflate" do
-    let(:headers) { HTTP::Headers.coerce("Content-Length" => "10") }
-
-    context "when body is nil" do
-      let(:body) { nil }
-
-      it "returns nil" do
-        expect(subject.deflate(headers, body)).to be_nil
-      end
-
-      it "does not remove Content-Length header" do
-        subject.deflate(headers, body)
-        expect(headers["Content-Length"]).to eq "10"
-      end
+  describe "#deflated_body" do
+    let(:body)          { %w[bees cows] }
+    let(:deflated_body) { subject.deflated_body(body) }
 
-      it "does not set Content-Encoding header" do
-        subject.deflate(headers, body)
-        expect(headers.include?("Content-Encoding")).to eq false
-      end
-    end
+    context "when method is gzip" do
+      subject { HTTP::Features::AutoDeflate.new(:method => :gzip) }
 
-    context "when body is not a string" do
-      let(:body) { {} }
+      it "returns object which yields gzipped content of the given body" do
+        io = StringIO.new
+        io.set_encoding(Encoding::BINARY)
+        gzip = Zlib::GzipWriter.new(io)
+        gzip.write("beescows")
+        gzip.close
+        gzipped = io.string
 
-      it "returns given body" do
-        expect(subject.deflate(headers, body).object_id).to eq(body.object_id)
+        expect(deflated_body.each.to_a.join).to eq gzipped
       end
 
-      it "does not remove Content-Length header" do
-        subject.deflate(headers, body)
-        expect(headers["Content-Length"]).to eq "10"
-      end
+      it "caches compressed content when size is called" do
+        io = StringIO.new
+        io.set_encoding(Encoding::BINARY)
+        gzip = Zlib::GzipWriter.new(io)
+        gzip.write("beescows")
+        gzip.close
+        gzipped = io.string
 
-      it "does not set Content-Encoding header" do
-        subject.deflate(headers, body)
-        expect(headers.include?("Content-Encoding")).to eq false
+        expect(deflated_body.size).to eq gzipped.bytesize
+        expect(deflated_body.each.to_a.join).to eq gzipped
       end
     end
 
-    context "when body is a string" do
-      let(:body) { "Hello HTTP!" }
-
-      it "encodes body" do
-        encoded = subject.deflate(headers, body)
-        decoded = Zlib::GzipReader.new(StringIO.new(encoded)).read
-
-        expect(decoded).to eq(body)
-      end
+    context "when method is deflate" do
+      subject { HTTP::Features::AutoDeflate.new(:method => :deflate) }
 
-      it "removes Content-Length header" do
-        subject.deflate(headers, body)
-        expect(headers.include?("Content-Length")).to eq false
-      end
+      it "returns object which yields deflated content of the given body" do
+        deflated = Zlib::Deflate.deflate("beescows")
 
-      it "sets Content-Encoding header" do
-        subject.deflate(headers, body)
-        expect(headers["Content-Encoding"]).to eq "gzip"
+        expect(deflated_body.each.to_a.join).to eq deflated
       end
 
-      context "as deflate method" do
-        subject { HTTP::Features::AutoDeflate.new(:method => :deflate) }
-
-        it "encodes body" do
-          encoded = subject.deflate(headers, body)
-          decoded = Zlib::Inflate.inflate(encoded)
-
-          expect(decoded).to eq(body)
-        end
-
-        it "removes Content-Length header" do
-          subject.deflate(headers, body)
-          expect(headers.include?("Content-Length")).to eq false
-        end
+      it "caches compressed content when size is called" do
+        deflated = Zlib::Deflate.deflate("beescows")
 
-        it "sets Content-Encoding header" do
-          subject.deflate(headers, body)
-          expect(headers["Content-Encoding"]).to eq "deflate"
-        end
+        expect(deflated_body.size).to eq deflated.bytesize
+        expect(deflated_body.each.to_a.join).to eq deflated
       end
     end
   end

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

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 RSpec.describe HTTP::Features::AutoInflate do
   subject { HTTP::Features::AutoInflate.new }
   let(:connection) { double }

data/spec/lib/http/headers/mixin_spec.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 RSpec.describe HTTP::Headers::Mixin do
   let :dummy_class do
     Class.new do

data/spec/lib/http/headers_spec.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 RSpec.describe HTTP::Headers do
   subject(:headers) { described_class.new }
 
@@ -25,18 +26,18 @@ RSpec.describe HTTP::Headers do
 
     it "allows set multiple values" do
       headers.set :set_cookie, "hoo=ray"
-      headers.set :set_cookie, %w(hoo=ray woo=hoo)
-      expect(headers["Set-Cookie"]).to eq %w(hoo=ray woo=hoo)
+      headers.set :set_cookie, %w[hoo=ray woo=hoo]
+      expect(headers["Set-Cookie"]).to eq %w[hoo=ray woo=hoo]
     end
 
     it "fails with empty header name" do
       expect { headers.set "", "foo bar" }.
-        to raise_error HTTP::InvalidHeaderNameError
+        to raise_error HTTP::HeaderError
     end
 
     it "fails with invalid header name" do
       expect { headers.set "foo bar", "baz" }.
-        to raise_error HTTP::InvalidHeaderNameError
+        to raise_error HTTP::HeaderError
     end
   end
 
@@ -59,8 +60,8 @@ RSpec.describe HTTP::Headers do
 
     it "allows set multiple values" do
       headers[:set_cookie] = "hoo=ray"
-      headers[:set_cookie] = %w(hoo=ray woo=hoo)
-      expect(headers["Set-Cookie"]).to eq %w(hoo=ray woo=hoo)
+      headers[:set_cookie] = %w[hoo=ray woo=hoo]
+      expect(headers["Set-Cookie"]).to eq %w[hoo=ray woo=hoo]
     end
   end
 
@@ -79,12 +80,12 @@ RSpec.describe HTTP::Headers do
 
     it "fails with empty header name" do
       expect { headers.delete "" }.
-        to raise_error HTTP::InvalidHeaderNameError
+        to raise_error HTTP::HeaderError
     end
 
     it "fails with invalid header name" do
       expect { headers.delete "foo bar" }.
-        to raise_error HTTP::InvalidHeaderNameError
+        to raise_error HTTP::HeaderError
     end
   end
 
@@ -102,23 +103,23 @@ RSpec.describe HTTP::Headers do
     it "appends new value if header exists" do
       headers.add :set_cookie, "hoo=ray"
       headers.add :set_cookie, "woo=hoo"
-      expect(headers["Set-Cookie"]).to eq %w(hoo=ray woo=hoo)
+      expect(headers["Set-Cookie"]).to eq %w[hoo=ray woo=hoo]
     end
 
     it "allows append multiple values" do
       headers.add :set_cookie, "hoo=ray"
-      headers.add :set_cookie, %w(woo=hoo yup=pie)
-      expect(headers["Set-Cookie"]).to eq %w(hoo=ray woo=hoo yup=pie)
+      headers.add :set_cookie, %w[woo=hoo yup=pie]
+      expect(headers["Set-Cookie"]).to eq %w[hoo=ray woo=hoo yup=pie]
     end
 
     it "fails with empty header name" do
       expect { headers.add("", "foobar") }.
-        to raise_error HTTP::InvalidHeaderNameError
+        to raise_error HTTP::HeaderError
     end
 
     it "fails with invalid header name" do
       expect { headers.add "foo bar", "baz" }.
-        to raise_error HTTP::InvalidHeaderNameError
+        to raise_error HTTP::HeaderError
     end
   end
 
@@ -126,11 +127,11 @@ RSpec.describe HTTP::Headers do
     before { headers.set("Content-Type", "application/json") }
 
     it "returns array of associated values" do
-      expect(headers.get("Content-Type")).to eq %w(application/json)
+      expect(headers.get("Content-Type")).to eq %w[application/json]
     end
 
     it "normalizes header name" do
-      expect(headers.get(:content_type)).to eq %w(application/json)
+      expect(headers.get(:content_type)).to eq %w[application/json]
     end
 
     context "when header does not exists" do
@@ -141,12 +142,12 @@ RSpec.describe HTTP::Headers do
 
     it "fails with empty header name" do
       expect { headers.get("") }.
-        to raise_error HTTP::InvalidHeaderNameError
+        to raise_error HTTP::HeaderError
     end
 
     it "fails with invalid header name" do
       expect { headers.get("foo bar") }.
-        to raise_error HTTP::InvalidHeaderNameError
+        to raise_error HTTP::HeaderError
     end
   end
 
@@ -180,7 +181,7 @@ RSpec.describe HTTP::Headers do
       end
 
       it "returns array of associated values" do
-        expect(headers[:set_cookie]).to eq %w(hoo=ray woo=hoo)
+        expect(headers[:set_cookie]).to eq %w[hoo=ray woo=hoo]
       end
     end
   end
@@ -217,7 +218,7 @@ RSpec.describe HTTP::Headers do
     end
 
     it "returns Hash with normalized keys" do
-      expect(headers.to_h.keys).to match_array %w(Content-Type Set-Cookie)
+      expect(headers.to_h.keys).to match_array %w[Content-Type Set-Cookie]
     end
 
     context "for a header with single value" do
@@ -228,7 +229,7 @@ RSpec.describe HTTP::Headers do
 
     context "for a header with multiple values" do
       it "provides an array of values" do
-        expect(headers.to_h["Set-Cookie"]).to eq %w(hoo=ray woo=hoo)
+        expect(headers.to_h["Set-Cookie"]).to eq %w[hoo=ray woo=hoo]
       end
     end
   end
@@ -246,15 +247,15 @@ RSpec.describe HTTP::Headers do
 
     it "returns Array of key/value pairs with normalized keys" do
       expect(headers.to_a).to eq [
-        %w(Content-Type application/json),
-        %w(Set-Cookie hoo=ray),
-        %w(Set-Cookie woo=hoo)
+        %w[Content-Type application/json],
+        %w[Set-Cookie hoo=ray],
+        %w[Set-Cookie woo=hoo]
       ]
     end
   end
 
   describe "#inspect" do
-    before  { headers.set :set_cookie, %w(hoo=ray woo=hoo) }
+    before  { headers.set :set_cookie, %w[hoo=ray woo=hoo] }
     subject { headers.inspect }
 
     it { is_expected.to eq '#<HTTP::Headers {"Set-Cookie"=>["hoo=ray", "woo=hoo"]}>' }
@@ -289,9 +290,9 @@ RSpec.describe HTTP::Headers do
 
     it "yields headers in the same order they were added" do
       expect { |b| headers.each(&b) }.to yield_successive_args(
-        %w(Set-Cookie hoo=ray),
-        %w(Content-Type application/json),
-        %w(Set-Cookie woo=hoo)
+        %w[Set-Cookie hoo=ray],
+        %w[Content-Type application/json],
+        %w[Set-Cookie woo=hoo]
       )
     end
 
@@ -351,7 +352,7 @@ RSpec.describe HTTP::Headers do
 
     it "allows comparison with Array of key/value pairs" do
       left.add :accept, "text/plain"
-      expect(left).to eq [%w(Accept text/plain)]
+      expect(left).to eq [%w[Accept text/plain]]
     end
 
     it "sensitive to headers order" do
@@ -402,7 +403,7 @@ RSpec.describe HTTP::Headers do
     before do
       headers.set :host, "example.com"
       headers.set :accept, "application/json"
-      headers.merge! :accept => "plain/text", :cookie => %w(hoo=ray woo=hoo)
+      headers.merge! :accept => "plain/text", :cookie => %w[hoo=ray woo=hoo]
     end
 
     it "leaves headers not presented in other as is" do
@@ -414,7 +415,7 @@ RSpec.describe HTTP::Headers do
     end
 
     it "appends other headers, not presented in base" do
-      expect(headers[:cookie]).to eq %w(hoo=ray woo=hoo)
+      expect(headers[:cookie]).to eq %w[hoo=ray woo=hoo]
     end
   end
 
@@ -425,7 +426,7 @@ RSpec.describe HTTP::Headers do
     end
 
     subject(:merged) do
-      headers.merge :accept => "plain/text", :cookie => %w(hoo=ray woo=hoo)
+      headers.merge :accept => "plain/text", :cookie => %w[hoo=ray woo=hoo]
     end
 
     it { is_expected.to be_a described_class }
@@ -444,7 +445,7 @@ RSpec.describe HTTP::Headers do
     end
 
     it "appends other headers, not presented in base" do
-      expect(merged[:cookie]).to eq %w(hoo=ray woo=hoo)
+      expect(merged[:cookie]).to eq %w[hoo=ray woo=hoo]
     end
   end
 
@@ -462,7 +463,7 @@ RSpec.describe HTTP::Headers do
     end
 
     it "accepts any object that respond to #to_a" do
-      hashie = double :to_a => [%w(accept json)]
+      hashie = double :to_a => [%w[accept json]]
       expect(described_class.coerce(hashie)["accept"]).to eq "json"
     end
 
@@ -477,8 +478,8 @@ RSpec.describe HTTP::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 hoo=ray],
+              %w[Set-Cookie woo=hoo]
             ]
           )
       end