http 3.3.0 → 4.4.1

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

@@ -74,5 +74,25 @@ RSpec.describe HTTP::Request::Writer do
         ].join
       end
     end
+
+    context "when server won't accept any more data" do
+      before do
+        expect(io).to receive(:write).and_raise(Errno::EPIPE)
+      end
+
+      it "aborts silently" do
+        writer.stream
+      end
+    end
+
+    context "when writing to socket raises an exception" do
+      before do
+        expect(io).to receive(:write).and_raise(Errno::ECONNRESET)
+      end
+
+      it "raises a ConnectionError" do
+        expect { writer.stream }.to raise_error(HTTP::ConnectionError)
+      end
+    end
   end
 end

data/spec/lib/http/request_spec.rb

@@ -225,4 +225,10 @@ RSpec.describe HTTP::Request do
       end
     end
   end
+
+  describe "#inspect" do
+    subject { request.inspect }
+
+    it { is_expected.to eq "#<HTTP::Request/1.1 GET #{request_uri}>" }
+  end
 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\nMy-Header: val\r\nEmpty-Header: \r\n\r\n{}"
+  end
+  let(:expected_headers) do
+    {
+      "Content-Length" => "2",
+      "Content-Type"   => "application/json",
+      "My-Header"      => "val",
+      "Empty-Header"   => ""
+    }
+  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_spec.rb

@@ -129,13 +129,12 @@ RSpec.describe HTTP::Response do
   end
 
   describe "#inspect" do
+    subject { response.inspect }
+
     let(:headers) { {:content_type => "text/plain"} }
     let(:body)    { double :to_s => "foobar" }
 
-    it "returns human-friendly response representation" do
-      expect(response.inspect).
-        to eq '#<HTTP::Response/1.1 200 OK {"Content-Type"=>"text/plain"}>'
-    end
+    it { is_expected.to eq '#<HTTP::Response/1.1 200 OK {"Content-Type"=>"text/plain"}>' }
   end
 
   describe "#cookies" do

data/spec/lib/http_spec.rb

@@ -55,38 +55,17 @@ RSpec.describe HTTP do
     end
 
     context "with a large request body" do
-      %w[global null per_operation].each do |timeout|
-        context "with a #{timeout} timeout" do
-          [16_000, 16_500, 17_000, 34_000, 68_000].each do |size|
-            [0, rand(0..100), rand(100..1000)].each do |fuzzer|
-              context "with a #{size} body and #{fuzzer} of fuzzing" do
-                let(:client) { HTTP.timeout(timeout, :read => 2, :write => 2, :connect => 2) }
-
-                let(:characters) { ("A".."Z").to_a }
-                let(:request_body) do
-                  Array.new(size + fuzzer) { |i| characters[i % characters.length] }.join
-                end
-
-                it "returns a large body" do
-                  response = client.post("#{dummy.endpoint}/echo-body", :body => request_body)
-
-                  expect(response.body.to_s).to eq(request_body)
-                  expect(response.headers["Content-Length"].to_i).to eq(request_body.bytesize)
-                end
-
-                context "when bytesize != length" do
-                  let(:characters) { ("A".."Z").to_a.push("“") }
-
-                  it "returns a large body" do
-                    body = {:data => request_body}
-                    response = client.post("#{dummy.endpoint}/echo-body", :json => body)
-
-                    expect(CGI.unescape(response.body.to_s)).to eq(body.to_json)
-                    expect(response.headers["Content-Length"].to_i).to eq(body.to_json.bytesize)
-                  end
-                end
-              end
-            end
+      let(:request_body) { "“" * 1_000_000 } # use multi-byte character
+
+      [:null, 6, {:read => 2, :write => 2, :connect => 2}].each do |timeout|
+        context "with `.timeout(#{timeout.inspect})`" do
+          let(:client) { HTTP.timeout(timeout) }
+
+          it "writes the whole body" do
+            response = client.post "#{dummy.endpoint}/echo-body", :body => request_body
+
+            expect(response.body.to_s).to eq(request_body.b)
+            expect(response.headers["Content-Length"].to_i).to eq request_body.bytesize
           end
         end
       end
@@ -194,7 +173,7 @@ RSpec.describe HTTP do
 
     context "with encoding option" do
       it "respects option" do
-        response = HTTP.get "#{dummy.endpoint}/iso-8859-1", "encoding" => Encoding::BINARY
+        response = HTTP.get "#{dummy.endpoint}/iso-8859-1", :encoding => Encoding::BINARY
         expect(response.to_s.encoding).to eq(Encoding::BINARY)
       end
     end
@@ -202,7 +181,7 @@ RSpec.describe HTTP do
 
   context "passing a string encoding type" do
     it "finds encoding" do
-      response = HTTP.get dummy.endpoint, "encoding" => "ascii"
+      response = HTTP.get dummy.endpoint, :encoding => "ascii"
       expect(response.to_s.encoding).to eq(Encoding::ASCII)
     end
   end
@@ -255,15 +234,15 @@ RSpec.describe HTTP do
 
   describe ".basic_auth" do
     it "fails when options is not a Hash" do
-      expect { HTTP.basic_auth "[FOOBAR]" }.to raise_error
+      expect { HTTP.basic_auth "[FOOBAR]" }.to raise_error(NoMethodError)
     end
 
     it "fails when :pass is not given" do
-      expect { HTTP.basic_auth :user => "[USER]" }.to raise_error
+      expect { HTTP.basic_auth :user => "[USER]" }.to raise_error(KeyError)
     end
 
     it "fails when :user is not given" do
-      expect { HTTP.basic_auth :pass => "[PASS]" }.to raise_error
+      expect { HTTP.basic_auth :pass => "[PASS]" }.to raise_error(KeyError)
     end
 
     it "sets Authorization header with proper BasicAuth value" do
@@ -305,22 +284,8 @@ RSpec.describe HTTP do
   end
 
   describe ".timeout" do
-    context "without timeout type" do
-      subject(:client) { HTTP.timeout :read => 123 }
-
-      it "sets timeout_class to PerOperation" do
-        expect(client.default_options.timeout_class).
-          to be HTTP::Timeout::PerOperation
-      end
-
-      it "sets given timeout options" do
-        expect(client.default_options.timeout_options).
-          to eq :read_timeout => 123
-      end
-    end
-
-    context "with :null type" do
-      subject(:client) { HTTP.timeout :null, :read => 123 }
+    context "specifying a null timeout" do
+      subject(:client) { HTTP.timeout :null }
 
       it "sets timeout_class to Null" do
         expect(client.default_options.timeout_class).
@@ -328,8 +293,8 @@ RSpec.describe HTTP do
       end
     end
 
-    context "with :per_operation type" do
-      subject(:client) { HTTP.timeout :per_operation, :read => 123 }
+    context "specifying per operation timeouts" do
+      subject(:client) { HTTP.timeout :read => 123 }
 
       it "sets timeout_class to PerOperation" do
         expect(client.default_options.timeout_class).
@@ -342,24 +307,19 @@ RSpec.describe HTTP do
       end
     end
 
-    context "with :global type" do
-      subject(:client) { HTTP.timeout :global, :read => 123 }
+    context "specifying a global timeout" do
+      subject(:client) { HTTP.timeout 123 }
 
       it "sets timeout_class to Global" do
         expect(client.default_options.timeout_class).
           to be HTTP::Timeout::Global
       end
 
-      it "sets given timeout options" do
+      it "sets given timeout option" do
         expect(client.default_options.timeout_options).
-          to eq :read_timeout => 123
+          to eq :global_timeout => 123
       end
     end
-
-    it "fails with unknown timeout type" do
-      expect { HTTP.timeout(:foobar, :read => 123) }.
-        to raise_error(ArgumentError, /foobar/)
-    end
   end
 
   describe ".cookies" do
@@ -470,13 +430,33 @@ RSpec.describe HTTP do
         expect(response.to_s).to eq("#{body}-deflated")
       end
     end
+
+    context "with :normalize_uri" do
+      it "normalizes URI" do
+        response = HTTP.get "#{dummy.endpoint}/hello world"
+        expect(response.to_s).to eq("hello world")
+      end
+
+      it "uses the custom URI Normalizer method" do
+        client = HTTP.use(:normalize_uri => {:normalizer => :itself.to_proc})
+        response = client.get("#{dummy.endpoint}/hello world")
+        expect(response.status).to eq(400)
+      end
+
+      it "uses the default URI normalizer" do
+        client = HTTP.use :normalize_uri
+        expect(HTTP::URI::NORMALIZER).to receive(:call).and_call_original
+        response = client.get("#{dummy.endpoint}/hello world")
+        expect(response.to_s).to eq("hello world")
+      end
+    end
   end
 
   it "unifies socket errors into HTTP::ConnectionError" do
     expect { HTTP.get "http://thishostshouldnotexists.com" }.
       to raise_error HTTP::ConnectionError
 
-    expect { HTTP.get "http://127.0.0.1:000" }.
+    expect { HTTP.get "http://127.0.0.1:111" }.
       to raise_error HTTP::ConnectionError
   end
 end

data/spec/regression_specs.rb

@@ -14,4 +14,11 @@ RSpec.describe "Regression testing" do
       expect { HTTP.get(google_uri).to_s }.not_to raise_error
     end
   end
+
+  describe "#422" do
+    it "reads body when 200 OK response contains Upgrade header" do
+      res = HTTP.get("https://httpbin.org/response-headers?Upgrade=h2,h2c")
+      expect(res.parse(:json)).to include("Upgrade" => "h2,h2c")
+    end
+  end
 end

data/spec/support/dummy_server/servlet.rb

@@ -148,6 +148,11 @@ class DummyServer < WEBrick::HTTPServer
       res.body   = req.body
     end
 
+    get "/hello world" do |_req, res|
+      res.status = 200
+      res.body   = "hello world"
+    end
+
     post "/encoded-body" do |req, res|
       res.status = 200
 

data/spec/support/http_handling_shared.rb

@@ -1,14 +1,20 @@
 # frozen_string_literal: true
 
 RSpec.shared_context "HTTP handling" do
-  describe "timeouts" do
-    let(:conn_timeout) { 1 }
-    let(:read_timeout) { 1 }
-    let(:write_timeout) { 1 }
+  context "without timeouts" do
+    let(:options) { {:timeout_class => HTTP::Timeout::Null, :timeout_options => {}} }
+
+    it "works" do
+      expect(client.get(server.endpoint).body.to_s).to eq("<!doctype html>")
+    end
+  end
+
+  context "with a per operation timeout" do
+    let(:response) { client.get(server.endpoint).body.to_s }
 
     let(:options) do
       {
-        :timeout_class => timeout_class,
+        :timeout_class => HTTP::Timeout::PerOperation,
         :timeout_options => {
           :connect_timeout => conn_timeout,
           :read_timeout => read_timeout,
@@ -16,87 +22,77 @@ RSpec.shared_context "HTTP handling" do
         }
       }
     end
+    let(:conn_timeout) { 1 }
+    let(:read_timeout) { 1 }
+    let(:write_timeout) { 1 }
 
-    context "without timeouts" do
-      let(:timeout_class) { HTTP::Timeout::Null }
-      let(:conn_timeout) { 0 }
-      let(:read_timeout) { 0 }
-      let(:write_timeout) { 0 }
-
-      it "works" do
-        expect(client.get(server.endpoint).body.to_s).to eq("<!doctype html>")
-      end
+    it "works" do
+      expect(response).to eq("<!doctype html>")
     end
 
-    context "with a per operation timeout" do
-      let(:timeout_class) { HTTP::Timeout::PerOperation }
-
-      let(:response) { client.get(server.endpoint).body.to_s }
-
-      it "works" do
-        expect(response).to eq("<!doctype html>")
-      end
+    context "connection" do
+      context "of 1" do
+        let(:conn_timeout) { 1 }
 
-      context "connection" do
-        context "of 1" do
-          let(:conn_timeout) { 1 }
-
-          it "does not time out" do
-            expect { response }.to_not raise_error
-          end
+        it "does not time out" do
+          expect { response }.to_not raise_error
         end
       end
+    end
 
-      context "read" do
-        context "of 0" do
-          let(:read_timeout) { 0 }
+    context "read" do
+      context "of 0" do
+        let(:read_timeout) { 0 }
 
-          it "times out", :flaky do
-            expect { response }.to raise_error(HTTP::TimeoutError, /Read/i)
-          end
+        it "times out", :flaky do
+          expect { response }.to raise_error(HTTP::TimeoutError, /Read/i)
         end
+      end
 
-        context "of 2.5" do
-          let(:read_timeout) { 2.5 }
+      context "of 2.5" do
+        let(:read_timeout) { 2.5 }
 
-          it "does not time out", :flaky do
-            expect { client.get("#{server.endpoint}/sleep").body.to_s }.to_not raise_error
-          end
+        it "does not time out", :flaky do
+          expect { client.get("#{server.endpoint}/sleep").body.to_s }.to_not raise_error
         end
       end
     end
+  end
 
-    context "with a global timeout" do
-      let(:timeout_class) { HTTP::Timeout::Global }
-
-      let(:conn_timeout) { 0 }
-      let(:read_timeout) { 1 }
-      let(:write_timeout) { 0 }
-
-      let(:response) { client.get(server.endpoint).body.to_s }
+  context "with a global timeout" do
+    let(:options) do
+      {
+        :timeout_class => HTTP::Timeout::Global,
+        :timeout_options => {
+          :global_timeout => global_timeout
+        }
+      }
+    end
+    let(:global_timeout) { 1 }
 
-      it "errors if connecting takes too long" do
-        expect(TCPSocket).to receive(:open) do
-          sleep 1.25
-        end
+    let(:response) { client.get(server.endpoint).body.to_s }
 
-        expect { response }.to raise_error(HTTP::TimeoutError, /execution/)
+    it "errors if connecting takes too long" do
+      expect(TCPSocket).to receive(:open) do
+        sleep 1.25
       end
 
-      it "errors if reading takes too long" do
-        expect { client.get("#{server.endpoint}/sleep").body.to_s }.
-          to raise_error(HTTP::TimeoutError, /Timed out/)
-      end
+      expect { response }.to raise_error(HTTP::TimeoutError, /execution/)
+    end
 
-      context "it resets state when reusing connections" do
-        let(:extra_options) { {:persistent => server.endpoint} }
+    it "errors if reading takes too long" do
+      expect { client.get("#{server.endpoint}/sleep").body.to_s }.
+        to raise_error(HTTP::TimeoutError, /Timed out/)
+    end
 
-        let(:read_timeout) { 2.5 }
+    context "it resets state when reusing connections" do
+      let(:extra_options) { {:persistent => server.endpoint} }
 
-        it "does not timeout", :flaky do
-          client.get("#{server.endpoint}/sleep").body.to_s
-          client.get("#{server.endpoint}/sleep").body.to_s
-        end
+      let(:global_timeout) { 2.5 }
+
+      it "does not timeout", :flaky do
+        client.get("#{server.endpoint}/sleep").body.to_s
+        client.get("#{server.endpoint}/sleep").body.to_s
       end
     end
   end