httpi 2.4.3 → 2.4.4

data/spec/integration/http_spec.rb

@@ -30,6 +30,18 @@ describe HTTPI::Adapter::HTTP do
       expect(response.headers["Set-Cookie"]).to eq(cookies)
     end
 
+    it "it supports read timeout" do
+      require "http"
+
+      request = HTTPI::Request.new(@server.url + "timeout")
+      request.read_timeout = 0.5 # seconds
+
+      expect do
+        HTTPI.get(request, adapter)
+      end.to raise_exception(HTTP::TimeoutError)
+    end
+
+
     it "executes GET requests" do
       response = HTTPI.get(@server.url, adapter)
       expect(response.body).to eq("get")
@@ -68,6 +80,22 @@ describe HTTPI::Adapter::HTTP do
       expect(response.body).to eq("basic-auth")
     end
 
+    it "does not support digest authentication" do
+      request = HTTPI::Request.new(@server.url + "digest-auth")
+      request.auth.digest("admin", "secret")
+
+      expect { HTTPI.get(request, adapter) }.
+        to raise_error(HTTPI::NotSupportedError, /does not support HTTP digest authentication/)
+    end
+
+    it "does not support ntlm authentication" do
+      request = HTTPI::Request.new(@server.url + "ntlm-auth")
+      request.auth.ntlm("tester", "vReqSoafRe5O")
+
+      expect { HTTPI.get(request, adapter) }.
+        to raise_error(HTTPI::NotSupportedError, /does not support NTLM digest authentication/)
+    end
+
     it "supports chunked response" do
       skip("Needs investigation")
       request = HTTPI::Request.new(@server.url)

data/spec/integration/httpclient_spec.rb

@@ -30,6 +30,17 @@ describe HTTPI::Adapter::HTTPClient do
       expect(response.headers["Set-Cookie"]).to eq(cookies)
     end
 
+    it "it supports read timeout" do
+      require "httpclient"
+
+      request = HTTPI::Request.new(@server.url + "timeout")
+      request.read_timeout = 0.5 # seconds
+
+      expect do
+        HTTPI.get(request, adapter)
+      end.to raise_exception(HTTPClient::ReceiveTimeoutError)
+    end
+
     it "executes GET requests" do
       response = HTTPI.get(@server.url, adapter)
       expect(response.body).to eq("get")

data/spec/integration/net_http_persistent_spec.rb

@@ -30,6 +30,17 @@ describe HTTPI::Adapter::NetHTTP do
       expect(response.headers["Set-Cookie"]).to eq(cookies)
     end
 
+    it "it supports read timeout" do
+      require "net/http/persistent"
+
+      request = HTTPI::Request.new(@server.url + "timeout")
+      request.read_timeout = 0.5 # seconds
+
+      expect do
+        HTTPI.get(request, adapter)
+      end.to raise_exception(Net::HTTP::Persistent::Error, /Net::ReadTimeout/)
+    end
+
     it "executes GET requests" do
       response = HTTPI.get(@server.url, adapter)
       expect(response.body).to eq("get")
@@ -37,8 +48,8 @@ describe HTTPI::Adapter::NetHTTP do
     end
 
     it "executes POST requests" do
-      request = HTTPI::Request.new(url: @server.url, open_timeout: 1, read_timeout: 1, body: "<some>xml</some>")
-      
+      request = HTTPI::Request.new(url: @server.url, body: "<some>xml</some>")
+
       response = HTTPI.post(request, adapter)
       expect(response.body).to eq("post")
       expect(response.headers["Content-Type"]).to eq("text/plain")
@@ -70,6 +81,14 @@ describe HTTPI::Adapter::NetHTTP do
       expect(response.body).to eq("basic-auth")
     end
 
+    it "does not support ntlm authentication" do
+      request = HTTPI::Request.new(@server.url + "ntlm-auth")
+      request.auth.ntlm("tester", "vReqSoafRe5O")
+
+      expect { HTTPI.get(request, adapter) }.
+        to raise_error(HTTPI::NotSupportedError, /does not support NTLM authentication/)
+    end
+
     # it does not support digest authentication
 
     it "supports chunked response" do

data/spec/integration/net_http_spec.rb

@@ -14,6 +14,21 @@ describe HTTPI::Adapter::NetHTTP do
       @server.stop
     end
 
+    context "when socks is specified" do
+      let(:socks_client) { mock("socks_client") }
+      let(:request) { HTTPI::Request.new(@server.url) }
+
+      it "uses Net::HTTP.SOCKSProxy as client" do
+        socks_client.expects(:new).with(URI(@server.url).host, URI(@server.url).port).returns(:socks_client_instance)
+        Net::HTTP.expects(:SOCKSProxy).with("localhost", 8080).returns socks_client
+
+        request.proxy = "socks://localhost:8080"
+        adapter = HTTPI::Adapter::NetHTTP.new(request)
+
+        expect(adapter.client).to eq(:socks_client_instance)
+      end
+    end
+
     it "sends and receives HTTP headers" do
       request = HTTPI::Request.new(@server.url + "x-header")
       request.headers["X-Header"] = "HTTPI"
@@ -30,6 +45,17 @@ describe HTTPI::Adapter::NetHTTP do
       expect(response.headers["Set-Cookie"]).to eq(cookies)
     end
 
+    it "it supports read timeout" do
+      require "net/http"
+
+      request = HTTPI::Request.new(@server.url + "timeout")
+      request.read_timeout = 0.5 # seconds
+
+      expect do
+        HTTPI.get(request, adapter)
+      end.to raise_exception(Net::ReadTimeout)
+    end
+
     it "executes GET requests" do
       response = HTTPI.get(@server.url, adapter)
       expect(response.body).to eq("get")
@@ -60,6 +86,34 @@ describe HTTPI::Adapter::NetHTTP do
       expect(response.headers["Content-Type"]).to eq("text/plain")
     end
 
+    context "custom methods" do
+      let(:request) {
+        HTTPI::Request.new(@server.url).tap do |r|
+          r.body = request_body if request_body
+        end
+      }
+      let(:request_body) { nil }
+      let(:response) { HTTPI.request(http_method, request, adapter) }
+
+      shared_examples_for "any supported custom method" do
+        specify { response.body.should eq http_method.to_s }
+        specify { response.headers["Content-Type"].should eq("text/plain") }
+      end
+
+      context "PATCH method" do
+        let(:http_method) { :patch }
+        let(:request_body) { "<some>xml</some>" }
+
+        it_behaves_like "any supported custom method"
+      end
+
+      context "UNSUPPORTED method" do
+        let(:http_method) { :unsupported }
+
+        specify { expect { response }.to raise_error HTTPI::NotSupportedError }
+      end
+    end
+
     it "supports basic authentication" do
       request = HTTPI::Request.new(@server.url + "basic-auth")
       request.auth.basic("admin", "secret")
@@ -68,7 +122,69 @@ describe HTTPI::Adapter::NetHTTP do
       expect(response.body).to eq("basic-auth")
     end
 
-    # it does not support digest authentication
+    it "does not support digest authentication" do
+      request = HTTPI::Request.new(@server.url + "digest-auth")
+      request.auth.digest("admin", "secret")
+
+      expect { HTTPI.get(request, adapter) }.
+        to raise_error(HTTPI::NotSupportedError, /does not support HTTP digest authentication/)
+    end
+
+    it "supports ntlm authentication" do
+      request = HTTPI::Request.new(@server.url + "ntlm-auth")
+      request.auth.ntlm("tester", "vReqSoafRe5O")
+
+      response = HTTPI.get(request, adapter)
+      expect(response.body).to eq("ntlm-auth")
+    end
+
+    it "does not support ntlm authentication when Net::NTLM is not available" do
+      Net.expects(:const_defined?).with(:NTLM).returns false
+
+      request = HTTPI::Request.new(@server.url + "ntlm-auth")
+      request.auth.ntlm("testing", "failures")
+
+      expect { HTTPI.get(request, adapter) }.
+        to raise_error(HTTPI::NotSupportedError, /Net::NTLM is not available/)
+    end
+
+    it "does not require ntlm when ntlm authenication is not requested" do
+      HTTPI::Adapter::NetHTTP.any_instance.stubs(:check_net_ntlm_version!).raises(RuntimeError)
+        request = HTTPI::Request.new(@server.url)
+        expect(request.auth.ntlm?).to be false
+
+        # make sure a request doesn't call ntlm check if we don't ask for it.
+        expect { HTTPI.get(request, adapter) }.not_to raise_error
+      HTTPI::Adapter::NetHTTP.any_instance.unstub(:check_net_ntlm_version!)
+    end
+
+    it "does check ntlm when ntlm authentication is requested" do
+      request = HTTPI::Request.new(@server.url + "ntlm-auth")
+      request.auth.ntlm("tester", "vReqSoafRe5O")
+
+      expect { HTTPI.get(request, adapter) }.not_to raise_error
+
+      # the check should also verify that the version of ntlm is supported and still fail if it isn't
+      HTTPI::Adapter::NetHTTP.any_instance.stubs(:ntlm_version).returns("0.1.1")
+
+        request = HTTPI::Request.new(@server.url + "ntlm-auth")
+        request.auth.ntlm("tester", "vReqSoafRe5O")
+
+        expect { HTTPI.get(request, adapter) }.to raise_error(ArgumentError, /Invalid version/)
+
+      HTTPI::Adapter::NetHTTP.any_instance.unstub(:ntlm_version)
+    end
+
+    it "does not crash when authenticate header is missing (on second request)" do
+      request = HTTPI::Request.new(@server.url + "ntlm-auth")
+      request.auth.ntlm("tester", "vReqSoafRe5O")
+
+      expect { HTTPI.get(request, adapter) }.
+        to_not raise_error
+
+      expect { HTTPI.get(request, adapter) }.
+        to_not raise_error
+    end
 
     it "supports chunked response" do
       request = HTTPI::Request.new(@server.url)

data/spec/integration/support/application.rb

@@ -15,9 +15,10 @@ class IntegrationServer
       }
     end
 
-    map "/repeat" do
+    map "/timeout" do
       run lambda { |env|
-        IntegrationServer.respond_with :body => env["rack.input"].read
+        sleep 2
+        IntegrationServer.respond_with "done"
       }
     end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: httpi
 version: !ruby/object:Gem::Version
-  version: 2.4.3
+  version: 2.4.4
 platform: ruby
 authors:
 - Daniel Harrington
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-02-18 00:00:00.000000000 Z
+date: 2018-09-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rack
@@ -220,7 +220,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: httpi
-rubygems_version: 2.7.3
+rubygems_version: 2.7.6
 signing_key: 
 specification_version: 4
 summary: Common interface for Ruby's HTTP libraries