httpi 2.4.0 → 2.4.5

data/spec/httpi/adapter/em_http_spec.rb

@@ -89,15 +89,12 @@ begin
         end
 
         it "sets host, port and authorization" do
-          url = 'http://example.com:80'
-
+          url = "http://example.com:80"
           connection_options = {
-            :connect_timeout    => nil,
-            :inactivity_timeout => nil,
-            :proxy              => {
-              :host          => 'proxy-host.com',
-              :port          => 443,
-              :authorization => ['username', 'password']
+            :proxy => {
+              :host => "proxy-host.com",
+              :port => 443,
+              :authorization => ["username", "password"]
             }
           }
 
@@ -111,8 +108,8 @@ begin
         it "is passed as a connection option" do
           request.open_timeout = 30
 
-          url = 'http://example.com:80'
-          connection_options = { :connect_timeout => 30, :inactivity_timeout => nil }
+          url = "http://example.com:80"
+          connection_options = { connect_timeout: 30 }
 
           EventMachine::HttpRequest.expects(:new).with(url, connection_options)
 
@@ -121,11 +118,22 @@ begin
       end
 
       describe "receive_timeout" do
-        it "is passed as a connection option" do
+        it "is passed as a connection option (when read_timeout specified)" do
           request.read_timeout = 60
 
-          url = 'http://example.com:80'
-          connection_options = { :connect_timeout => nil, :inactivity_timeout => 60 }
+          url = "http://example.com:80"
+          connection_options = { inactivity_timeout: 60 }
+
+          EventMachine::HttpRequest.expects(:new).with(url, connection_options)
+
+          adapter
+        end
+
+        it "is passed as a connection option (when write_timeout specified)" do
+          request.write_timeout = 60
+
+          url = "http://example.com:80"
+          connection_options = { inactivity_timeout: 60 }
 
           EventMachine::HttpRequest.expects(:new).with(url, connection_options)
 

data/spec/httpi/adapter/excon_spec.rb

@@ -1,96 +1,34 @@
 require "spec_helper"
-require "integration/support/server"
-
-describe HTTPI::Adapter::Excon do
-
-  subject(:adapter) { :excon }
-
-  context "http requests" do
-    before :all do
-      @server = IntegrationServer.run
-    end
-
-    after :all do
-      @server.stop
-    end
-
-    it "sends and receives HTTP headers" do
-      request = HTTPI::Request.new(@server.url + "x-header")
-      request.headers["X-Header"] = "HTTPI"
-
-      response = HTTPI.get(request, adapter)
-      expect(response.body).to include("HTTPI")
-    end
-
-    it "executes GET requests" do
-      response = HTTPI.get(@server.url, adapter)
-      expect(response.body).to eq("get")
-      expect(response.headers["Content-Type"]).to eq("text/plain")
-    end
-
-    it "executes POST requests" do
-      response = HTTPI.post(@server.url, "<some>xml</some>", adapter)
-      expect(response.body).to eq("post")
-      expect(response.headers["Content-Type"]).to eq("text/plain")
-    end
-
-    it "executes HEAD requests" do
-      response = HTTPI.head(@server.url, adapter)
-      expect(response.code).to eq(200)
-      expect(response.headers["Content-Type"]).to eq("text/plain")
-    end
-
-    it "executes PUT requests" do
-      response = HTTPI.put(@server.url, "<some>xml</some>", adapter)
-      expect(response.body).to eq("put")
-      expect(response.headers["Content-Type"]).to eq("text/plain")
-    end
-
-    it "executes DELETE requests" do
-      response = HTTPI.delete(@server.url, adapter)
-      expect(response.body).to eq("delete")
-      expect(response.headers["Content-Type"]).to eq("text/plain")
-    end
-
-    it "supports basic authentication" do
-      request = HTTPI::Request.new(@server.url + "basic-auth")
-      request.auth.basic("admin", "secret")
-
-      response = HTTPI.get(request, adapter)
-      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
-  end
-
-  # it does not support digest auth
-
-  if RUBY_PLATFORM =~ /java/
-    pending "Puma Server complains: SSL not supported on JRuby"
-  else
-    context "https requests" do
-      before :all do
-        @server = IntegrationServer.run(:ssl => true)
+require "httpi/adapter/excon"
+require "httpi/request"
+
+begin
+  HTTPI::Adapter.load_adapter(:excon)
+
+  describe HTTPI::Adapter::Excon do
+    let(:adapter) { HTTPI::Adapter::Excon.new(request) }
+    let(:request) { HTTPI::Request.new("http://example.com") }
+
+    describe "settings" do
+      describe "connect_timeout, read_timeout, write_timeout" do
+        it "are passed as connection options" do
+          request.open_timeout = 30
+          request.read_timeout = 40
+          request.write_timeout = 50
+
+          expect(adapter.client.data).to include(
+            connect_timeout: 30,
+            read_timeout: 40,
+            write_timeout: 50
+          )
+        end
       end
-      after :all do
-        @server.stop
-      end
-
-      # it does not raise when no certificate was set up
-      it "works when set up properly" do
-        request = HTTPI::Request.new(@server.url)
-        request.auth.ssl.ca_cert_file = IntegrationServer.ssl_ca_file
-
-        response = HTTPI.get(request, adapter)
-        expect(response.body).to eq("get")
+      describe "host, hostname" do
+        it "both are set" do
+          Excon.expects(:display_warning).never
+          expect(adapter.client.data).to include(host: 'example.com', hostname: 'example.com')
+        end
       end
     end
   end
-
 end

data/spec/httpi/adapter/http_spec.rb

@@ -0,0 +1,28 @@
+require "spec_helper"
+require "httpi/adapter/http"
+require "httpi/request"
+
+begin
+  HTTPI::Adapter.load_adapter(:http)
+
+  describe HTTPI::Adapter::HTTP do
+    let(:adapter) { HTTPI::Adapter::HTTP.new(request) }
+    let(:request) { HTTPI::Request.new("http://example.com") }
+
+    describe "settings" do
+      describe "connect_timeout, read_timeout, write_timeout" do
+        it "are being set on the client" do
+          request.open_timeout = 30
+          request.read_timeout = 40
+          request.write_timeout = 50
+
+          expect(adapter.client.default_options.timeout_options).to eq(
+            connect_timeout: 30,
+            read_timeout: 40,
+            write_timeout: 50
+          )
+        end
+      end
+    end
+  end
+end

data/spec/httpi/adapter/httpclient_spec.rb

@@ -1,6 +1,7 @@
 require "spec_helper"
 require "httpi/adapter/httpclient"
 require "httpi/request"
+require "integration/support/server"
 
 HTTPI::Adapter.load_adapter(:httpclient)
 
@@ -10,6 +11,14 @@ describe HTTPI::Adapter::HTTPClient do
   let(:ssl_config) { HTTPClient::SSLConfig.any_instance }
   let(:request)    { HTTPI::Request.new("http://example.com") }
 
+  before :all do
+    @server = IntegrationServer.run
+  end
+
+  after :all do
+    @server.stop
+  end
+
   describe "#request(:get)" do
     it "returns a valid HTTPI::Response" do
       httpclient_expects(:get)
@@ -91,6 +100,20 @@ describe HTTPI::Adapter::HTTPClient do
       end
     end
 
+    describe "send_timeout" do
+      it "is not set unless specified" do
+        httpclient.expects(:send_timeout=).never
+        adapter.request(:get)
+      end
+
+      it "is set if specified" do
+        request.write_timeout = 30
+
+        httpclient.expects(:send_timeout=).with(30)
+        adapter.request(:get)
+      end
+    end
+
     describe "set_auth" do
       it "is set for HTTP basic auth" do
         request.auth.basic "username", "password"
@@ -155,6 +178,17 @@ describe HTTPI::Adapter::HTTPClient do
 
         adapter.request(:get)
       end
+
+      it 'raises error when min_version not nil' do
+        request.auth.ssl.min_version = :TLS1_2
+        expect{ adapter.request(:get) }.
+          to raise_error(HTTPI::NotSupportedError, 'Httpclient adapter does not support #min_version or #max_version. Please, use #ssl_version instead')
+      end
+      it 'raises error when max_version not nil' do
+        request.auth.ssl.max_version = :TLS1_2
+        expect{ adapter.request(:get) }.
+          to raise_error(HTTPI::NotSupportedError, 'Httpclient adapter does not support #min_version or #max_version. Please, use #ssl_version instead')
+      end
     end
 
     context "(for SSL client auth with a verify mode of :none with no certs provided)" do
@@ -174,11 +208,12 @@ describe HTTPI::Adapter::HTTPClient do
     end
   end
 
-  it "does not support NTLM authentication" do
-    request.auth.ntlm("tester", "vReqSoafRe5O")
+  it "supports NTLM authentication" do
+    request = HTTPI::Request.new(@server.url + "ntlm-auth")
 
-    expect { adapter.request(:get) }.
-      to raise_error(HTTPI::NotSupportedError, /adapter does not support NTLM authentication/)
+    request.auth.ntlm("tester", "vReqSoafRe5O")
+    response = HTTPI.get(request, :httpclient)
+    expect(response.body).to eq("ntlm-auth")
   end
 
   def httpclient_expects(method)

data/spec/httpi/adapter/net_http_persistent_spec.rb

@@ -1,96 +1,46 @@
 require "spec_helper"
-require "integration/support/server"
+require "httpi/adapter/net_http_persistent"
+require "httpi/request"
 
-describe HTTPI::Adapter::NetHTTPPersistent do
+begin
+  HTTPI::Adapter.load_adapter(:net_http_persistent)
 
-  subject(:adapter) { :net_http_persistent }
+  describe HTTPI::Adapter::NetHTTPPersistent do
+    let(:adapter) { HTTPI::Adapter::NetHTTPPersistent.new(request) }
+    let(:request) { HTTPI::Request.new("http://example.com") }
 
-  context "http requests" do
-    before :all do
-      @server = IntegrationServer.run
-    end
-
-    after :all do
-      @server.stop
-    end
-
-    it "sends and receives HTTP headers" do
-      request = HTTPI::Request.new(@server.url + "x-header")
-      request.headers["X-Header"] = "HTTPI"
-
-      response = HTTPI.get(request, adapter)
-      expect(response.body).to include("HTTPI")
-    end
-
-    it "executes GET requests" do
-      response = HTTPI.get(@server.url, adapter)
-      expect(response.body).to eq("get")
-      expect(response.headers["Content-Type"]).to eq("text/plain")
-    end
-
-    it "executes POST requests" do
-      response = HTTPI.post(@server.url, "<some>xml</some>", adapter)
-      expect(response.body).to eq("post")
-      expect(response.headers["Content-Type"]).to eq("text/plain")
-    end
-
-    it "executes HEAD requests" do
-      response = HTTPI.head(@server.url, adapter)
-      expect(response.code).to eq(200)
-      expect(response.headers["Content-Type"]).to eq("text/plain")
-    end
-
-    it "executes PUT requests" do
-      response = HTTPI.put(@server.url, "<some>xml</some>", adapter)
-      expect(response.body).to eq("put")
-      expect(response.headers["Content-Type"]).to eq("text/plain")
-    end
-
-    it "executes DELETE requests" do
-      response = HTTPI.delete(@server.url, adapter)
-      expect(response.body).to eq("delete")
-      expect(response.headers["Content-Type"]).to eq("text/plain")
-    end
-
-    it "supports basic authentication" do
-      request = HTTPI::Request.new(@server.url + "basic-auth")
-      request.auth.basic("admin", "secret")
+    let(:response) {
+      Object.new.tap do |r|
+        r.stubs(:code).returns(200)
+        r.stubs(:body).returns("abc")
+        r.stubs(:to_hash).returns({"Content-Length" => "3"})
+      end
+    }
 
-      response = HTTPI.get(request, adapter)
-      expect(response.body).to eq("basic-auth")
+    before do
+      Net::HTTP::Persistent.any_instance.stubs(:start).returns(response)
     end
 
-    it "does not support ntlm authentication" do
-      request = HTTPI::Request.new(@server.url + "ntlm-auth")
-      request.auth.ntlm("tester", "vReqSoafRe5O")
+    describe "settings" do
+      describe "open_timeout, read_timeout" do
+        it "are being set on the client" do
+          request.open_timeout = 30
+          request.read_timeout = 40
 
-      expect { HTTPI.get(request, adapter) }.
-        to raise_error(HTTPI::NotSupportedError, /does not support NTLM authentication/)
-    end
-  end
-
-  # it does not support digest auth
+          adapter.client.expects(:open_timeout=).with(30)
+          adapter.client.expects(:read_timeout=).with(40)
 
-  if RUBY_PLATFORM =~ /java/
-    pending "Puma Server complains: SSL not supported on JRuby"
-  else
-    context "https requests" do
-      before :all do
-        @server = IntegrationServer.run(:ssl => true)
+          adapter.request(:get)
+        end
       end
-      after :all do
-        @server.stop
-      end
-
-      # it does not raise when no certificate was set up
-      it "works when set up properly" do
-        request = HTTPI::Request.new(@server.url)
-        request.auth.ssl.ca_cert_file = IntegrationServer.ssl_ca_file
 
-        response = HTTPI.get(request, adapter)
-        expect(response.body).to eq("get")
+      describe "write_timeout" do
+        it "is not supported" do
+          request.write_timeout = 50
+          expect { adapter.request(:get) }
+            .to raise_error(HTTPI::NotSupportedError, /write_timeout/)
+        end
       end
     end
   end
-
 end

data/spec/httpi/adapter/net_http_spec.rb

@@ -1,114 +1,54 @@
 require "spec_helper"
-require "integration/support/server"
+require "httpi/adapter/net_http"
+require "httpi/request"
 
-describe HTTPI::Adapter::NetHTTP do
+begin
+  HTTPI::Adapter.load_adapter(:net_http)
 
-  subject(:adapter) { :net_http }
+  describe HTTPI::Adapter::NetHTTP do
+    let(:adapter) { HTTPI::Adapter::NetHTTP.new(request) }
+    let(:request) { HTTPI::Request.new("http://example.com") }
 
-  context "http requests" do
-    before :all do
-      @server = IntegrationServer.run
-    end
-
-    after :all do
-      @server.stop
-    end
-
-    it "sends and receives HTTP headers" do
-      request = HTTPI::Request.new(@server.url + "x-header")
-      request.headers["X-Header"] = "HTTPI"
-
-      response = HTTPI.get(request, adapter)
-      expect(response.body).to include("HTTPI")
-    end
-
-    it "executes GET requests" do
-      response = HTTPI.get(@server.url, adapter)
-      expect(response.body).to eq("get")
-      expect(response.headers["Content-Type"]).to eq("text/plain")
-    end
-
-    it "executes POST requests" do
-      response = HTTPI.post(@server.url, "<some>xml</some>", adapter)
-      expect(response.body).to eq("post")
-      expect(response.headers["Content-Type"]).to eq("text/plain")
-    end
-
-    it "executes HEAD requests" do
-      response = HTTPI.head(@server.url, adapter)
-      expect(response.code).to eq(200)
-      expect(response.headers["Content-Type"]).to eq("text/plain")
-    end
-
-    it "executes PUT requests" do
-      response = HTTPI.put(@server.url, "<some>xml</some>", adapter)
-      expect(response.body).to eq("put")
-      expect(response.headers["Content-Type"]).to eq("text/plain")
-    end
-
-    it "executes DELETE requests" do
-      response = HTTPI.delete(@server.url, adapter)
-      expect(response.body).to eq("delete")
-      expect(response.headers["Content-Type"]).to eq("text/plain")
-    end
-
-    it "supports basic authentication" do
-      request = HTTPI::Request.new(@server.url + "basic-auth")
-      request.auth.basic("admin", "secret")
-
-      response = HTTPI.get(request, adapter)
-      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 "supports ntlm authentication" do
-      request = HTTPI::Request.new(@server.url + "ntlm-auth")
-      request.auth.ntlm("tester", "vReqSoafRe5O")
+    let(:response) {
+      Object.new.tap do |r|
+        r.stubs(:code).returns(200)
+        r.stubs(:body).returns("abc")
+        r.stubs(:to_hash).returns({"Content-Length" => "3"})
+      end
+    }
 
-      response = HTTPI.get(request, adapter)
-      expect(response.body).to eq("ntlm-auth")
+    before do
+      Net::HTTP.any_instance.stubs(:start).returns(response)
     end
 
-    it 'does not support ntlm authentication when Net::NTLM is not available' do
-      Net.expects(:const_defined?).with(:NTLM).returns false
+    describe "settings" do
+      describe "open_timeout, read_timeout" do
+        it "are being set on the client" do
+          request.open_timeout = 30
+          request.read_timeout = 40
 
-      request = HTTPI::Request.new(@server.url + 'ntlm-auth')
-      request.auth.ntlm("testing", "failures")
+          adapter.client.expects(:open_timeout=).with(30)
+          adapter.client.expects(:read_timeout=).with(40)
 
-      expect { HTTPI.get(request, adapter) }.
-        to raise_error(HTTPI::NotSupportedError, /Net::NTLM is not available/)
-    end
-  end
-
-  # it does not support digest auth
-
-  if RUBY_PLATFORM =~ /java/
-    pending "Puma Server complains: SSL not supported on JRuby"
-  else
-    context "https requests" do
-      before :all do
-        @server = IntegrationServer.run(:ssl => true)
+          adapter.request(:get)
+        end
       end
-      after :all do
-        @server.stop
-      end
-
-      # it does not raise when no certificate was set up
-      it "works when set up properly" do
-        request = HTTPI::Request.new(@server.url)
-        request.auth.ssl.ca_cert_file = IntegrationServer.ssl_ca_file
 
-        response = HTTPI.get(request, adapter)
-        expect(response.body).to eq("get")
+      describe "write_timeout" do
+        if Net::HTTP.method_defined?(:write_timeout=)
+          it "is being set on the client" do
+            request.write_timeout = 50
+            adapter.client.expects(:write_timeout=).with(50)
+            adapter.request(:get)
+          end
+        else
+          it "can not be set on the client" do
+            request.write_timeout = 50
+            expect { adapter.request(:get) }
+              .to raise_error(HTTPI::NotSupportedError, /write_timeout/)
+          end
+        end
       end
     end
   end
-
 end