http 3.3.0 → 4.0.0

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

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+RSpec.describe HTTP::Features::Instrumentation do
+  subject(:feature) { HTTP::Features::Instrumentation.new(:instrumenter => instrumenter) }
+  let(:instrumenter) { TestInstrumenter.new }
+
+  describe "logging the request" do
+    let(:request) do
+      HTTP::Request.new(
+        :verb => :post,
+        :uri => "https://example.com/",
+        :headers => {:accept => "application/json"},
+        :body => '{"hello": "world!"}'
+      )
+    end
+
+    it "should log the request" do
+      feature.wrap_request(request)
+
+      expect(instrumenter.output[:start]).to eq(:request => request)
+    end
+  end
+
+  describe "logging the response" do
+    let(:response) do
+      HTTP::Response.new(
+        :version => "1.1",
+        :uri => "https://example.com",
+        :status => 200,
+        :headers => {:content_type => "application/json"},
+        :body => '{"success": true}'
+      )
+    end
+
+    it "should log the response" do
+      feature.wrap_response(response)
+
+      expect(instrumenter.output[:finish]).to eq(:response => response)
+    end
+  end
+
+  class TestInstrumenter < HTTP::Features::Instrumentation::NullInstrumenter
+    attr_reader :output
+    def initialize
+      @output = {}
+    end
+
+    def start(_name, payload)
+      output[:start] = payload
+    end
+
+    def finish(_name, payload)
+      output[:finish] = payload
+    end
+  end
+end

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

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+RSpec.describe HTTP::Features::Logging do
+  subject(:feature) { HTTP::Features::Logging.new(:logger => logger) }
+  let(:logger) { TestLogger.new }
+
+  describe "logging the request" do
+    let(:request) do
+      HTTP::Request.new(
+        :verb => :post,
+        :uri => "https://example.com/",
+        :headers => {:accept => "application/json"},
+        :body => '{"hello": "world!"}'
+      )
+    end
+
+    it "should log the request" do
+      feature.wrap_request(request)
+
+      expect(logger.output).to eq(
+        [
+          "> POST https://example.com/",
+          <<~REQ.strip
+            Accept: application/json
+            Host: example.com
+            User-Agent: http.rb/4.0.0.dev
+
+            {"hello": "world!"}
+          REQ
+        ]
+      )
+    end
+  end
+
+  describe "logging the response" do
+    let(:response) do
+      HTTP::Response.new(
+        :version => "1.1",
+        :uri => "https://example.com",
+        :status => 200,
+        :headers => {:content_type => "application/json"},
+        :body => '{"success": true}'
+      )
+    end
+
+    it "should log the response" do
+      feature.wrap_response(response)
+
+      expect(logger.output).to eq(
+        [
+          "< 200 OK",
+          <<~REQ.strip
+            Content-Type: application/json
+
+            {"success": true}
+          REQ
+        ]
+      )
+    end
+  end
+
+  class TestLogger
+    attr_reader :output
+    def initialize
+      @output = []
+    end
+
+    %w[fatal error warn info debug].each do |level|
+      define_method(level.to_sym) do |*args, &block|
+        @output << (block ? block.call : args)
+      end
+    end
+  end
+end

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

@@ -157,4 +157,33 @@ RSpec.describe HTTP::Request::Body do
       end
     end
   end
+
+  describe "#==" do
+    context "when sources are equivalent" do
+      let(:body1) { HTTP::Request::Body.new("content") }
+      let(:body2) { HTTP::Request::Body.new("content") }
+
+      it "returns true" do
+        expect(body1).to eq body2
+      end
+    end
+
+    context "when sources are not equivalent" do
+      let(:body1) { HTTP::Request::Body.new("content") }
+      let(:body2) { HTTP::Request::Body.new(nil) }
+
+      it "returns false" do
+        expect(body1).not_to eq body2
+      end
+    end
+
+    context "when objects are not of the same class" do
+      let(:body1) { HTTP::Request::Body.new("content") }
+      let(:body2) { "content" }
+
+      it "returns false" do
+        expect(body1).not_to eq body2
+      end
+    end
+  end
 end

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_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
@@ -476,7 +436,7 @@ RSpec.describe HTTP 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/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