httpi 2.4.1 → 3.0.0

data/spec/httpi/adapter/http_spec.rb

@@ -1,101 +1,28 @@
 require "spec_helper"
-require "integration/support/server"
-
-describe HTTPI::Adapter::HTTP do
-
-  subject(:adapter) { :http }
-
-  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 "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
-  end
-
-  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)
-      end
-      after :all do
-        @server.stop
-      end
-
-      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")
+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"
@@ -118,6 +141,13 @@ describe HTTPI::Adapter::HTTPClient do
 
         adapter.request(:get)
       end
+
+      it 'should set the ciphers if specified' do
+        request.auth.ssl.ciphers = OpenSSL::SSL::SSLContext.new.ciphers
+        ssl_config.expects(:ciphers=).with(request.auth.ssl.ciphers)
+
+        adapter.request(:get)
+      end
     end
 
     context "(for SSL client auth)" do
@@ -155,6 +185,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 +215,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

data/spec/httpi/adapter/rack_spec.rb

@@ -82,14 +82,12 @@ describe HTTPI::Adapter::NetHTTP do
         end
       end
 
-      describe "set_auth" do
-        before do
-          request.auth.basic "username", "password"
-        end
-
-        it "is not supported" do
-          expect { client.request(:get) }.
-            to raise_error(HTTPI::NotSupportedError, "Rack adapter does not support HTTP auth")
+      describe "basic auth" do
+        it "is supported" do
+          request = HTTPI::Request.new(@url + "basic-auth")
+          request.auth.basic("admin", "secret")
+          response = HTTPI.get(request, adapter)
+          expect(response.body).to eq("basic-auth")
         end
       end
 

data/spec/httpi/auth/ssl_spec.rb

@@ -3,7 +3,8 @@ require "httpi/auth/ssl"
 
 describe HTTPI::Auth::SSL do
   before(:all) do
-    @ssl_versions = OpenSSL::SSL::SSLContext::METHODS.reject { |method| method.match /server|client/ }.sort.reverse
+    @ssl_versions = HTTPI::Auth::SSL::SSL_VERSIONS
+    @min_max_versions = HTTPI::Auth::SSL::MIN_MAX_VERSIONS
   end
 
   describe "VERIFY_MODES" do
@@ -158,6 +159,53 @@ describe HTTPI::Auth::SSL do
     end
   end
 
+  describe "#min_version" do
+    subject { HTTPI::Auth::SSL.new }
+
+    it "returns the min_version" do
+      subject.min_version = @min_max_versions.first
+      expect(subject.min_version).to eq(@min_max_versions.first)
+    end
+
+    it 'raises ArgumentError if the version is unsupported' do
+      expect { ssl.min_version = :ssl_fail }.
+        to raise_error(ArgumentError, "Invalid SSL min_version :ssl_fail\n" +
+                                      "Please specify one of #{@min_max_versions}")
+    end
+  end
+
+  describe "#max_version" do
+    subject { HTTPI::Auth::SSL.new }
+
+    it "returns the SSL version" do
+      subject.max_version = @min_max_versions.first
+      expect(subject.max_version).to eq(@min_max_versions.first)
+    end
+
+    it 'raises ArgumentError if the version is unsupported' do
+      expect { ssl.max_version = :ssl_fail }.
+        to raise_error(ArgumentError, "Invalid SSL max_version :ssl_fail\n" +
+                                      "Please specify one of #{@min_max_versions}")
+    end
+  end
+
+  describe '#ciphers' do
+    subject { ssl.ciphers }
+    let(:ssl) { HTTPI::Auth::SSL.new }
+
+    context 'without ciphers' do
+      before { ssl.ciphers = nil }
+
+      it { is_expected.to eq(nil) }
+    end
+
+    context 'with ciphers' do
+      before { ssl.ciphers = OpenSSL::SSL::SSLContext.new.ciphers }
+
+      it { is_expected.to be_any.and(all(be_an_instance_of(String))) }
+    end
+  end
+
   def ssl
     ssl = HTTPI::Auth::SSL.new
     ssl.cert_key_file = "spec/fixtures/client_key.pem"

data/spec/httpi/httpi_spec.rb

@@ -6,11 +6,9 @@ require "excon"
 require "net/http/persistent"
 require "http"
 
-unless RUBY_VERSION < "1.9"
+unless RUBY_PLATFORM =~ /java/
   require "em-synchrony"
   require "em-http-request"
-end
-unless RUBY_PLATFORM =~ /java/
   require "curb"
 end
 
@@ -269,6 +267,20 @@ describe HTTPI do
 
       client.request(:custom, request, :httpclient)
     end
+
+    it 'follows redirects at maximum of the redirect limit' do
+      request.follow_redirect = true
+      request.redirect_limit = 2
+      redirect_location = 'http://foo.bar'
+
+      redirect = HTTPI::Response.new(302, {'location' => redirect_location}, 'Moved')
+      response = HTTPI::Response.new(200, {}, 'success')
+
+      httpclient.any_instance.expects(:request).times(2).with(:custom).returns(redirect, response)
+      request.expects(:url=).with(URI.parse(redirect_location))
+
+      client.request(:custom, request, :httpclient)
+    end
   end
 
   HTTPI::REQUEST_METHODS.each do |method|
@@ -280,7 +292,7 @@ describe HTTPI do
       end
 
       HTTPI::Adapter::ADAPTERS.each do |adapter, opts|
-        unless (adapter == :em_http && RUBY_VERSION =~ /1\.8/) || (adapter == :curb && RUBY_PLATFORM =~ /java/)
+        unless (adapter == :em_http || adapter == :curb) && RUBY_PLATFORM =~ /java/
           client_class = {
             :httpclient => lambda { HTTPClient },
             :curb       => lambda { Curl::Easy },

data/spec/httpi/request_spec.rb

@@ -108,6 +108,11 @@ describe HTTPI::Request do
       expect(request.proxy).to eq(URI("http://proxy.example.com"))
     end
 
+    it 'also accepts the socks URL to use as a String' do
+      request.proxy ="socks://socks.example.com"
+      expect(request.proxy).to eq(URI("socks://socks.example.com"))
+    end
+
     it "also accepts a URI object" do
       request.proxy = URI("http://proxy.example.com")
       expect(request.proxy).to eq(URI("http://proxy.example.com"))

data/spec/integration/curb_spec.rb

@@ -33,6 +33,17 @@ describe HTTPI::Adapter::Curb do
         expect(response.headers["Set-Cookie"]).to eq(cookies)
       end
 
+      it "it supports read timeout" do
+        require "curb"
+
+        request = HTTPI::Request.new(@server.url + "timeout")
+        request.read_timeout = 0.5 # seconds
+
+        expect do
+          HTTPI.get(request, adapter)
+        end.to raise_exception(Curl::Err::TimeoutError)
+      end
+
       it "executes GET requests" do
         response = HTTPI.get(@server.url, adapter)
         expect(response.body).to eq("get")
@@ -112,6 +123,15 @@ describe HTTPI::Adapter::Curb do
         response = HTTPI.get(request, adapter)
         expect(response.body).to eq("get")
       end
+
+      it "works with ciphers" do
+        request = HTTPI::Request.new(@server.url)
+        request.auth.ssl.ca_cert_file = IntegrationServer.ssl_ca_file
+        request.auth.ssl.ciphers = OpenSSL::SSL::SSLContext.new.ciphers
+
+        response = HTTPI.get(request, adapter)
+        expect(response.body).to eq("get")
+      end
     end
 
   end