httpi 2.4.3 → 3.0.0

data/spec/httpi/adapter/curb_spec.rb

@@ -146,29 +146,36 @@ unless RUBY_PLATFORM =~ /java/
         end
       end
 
-      describe "timeout" do
+      describe "timeout_ms" do
         it "is not set unless it's specified" do
-          curb.expects(:timeout=).never
+          curb.expects(:timeout_ms=).never
           adapter.request(:get)
         end
 
-        it "is set if specified" do
+        it "is set if specified read_timeout" do
           request.read_timeout = 30
-          curb.expects(:timeout=).with(request.read_timeout)
+          curb.expects(:timeout_ms=).with(30_000)
+
+          adapter.request(:get)
+        end
+
+        it "is set if specified write_timeout" do
+          request.write_timeout = 30
+          curb.expects(:timeout_ms=).with(30_000)
 
           adapter.request(:get)
         end
       end
 
-      describe "connect_timeout" do
+      describe "connect_timeout_ms" do
         it "is not set unless it's specified" do
-          curb.expects(:connect_timeout=).never
+          curb.expects(:connect_timeout_ms=).never
           adapter.request(:get)
         end
 
         it "is set if specified" do
           request.open_timeout = 30
-          curb.expects(:connect_timeout=).with(30)
+          curb.expects(:connect_timeout_ms=).with(30_000)
 
           adapter.request(:get)
         end
@@ -243,6 +250,13 @@ unless RUBY_PLATFORM =~ /java/
           request
         end
 
+        it 'sets ssl_cipher_list' do
+          request.auth.ssl.ciphers = ["AES128"]
+          curb.expects(:set).with(any_parameters).at_least(1)
+          curb.expects(:set).with(:ssl_cipher_list, anything)
+          adapter.request(:get)
+        end
+
         context 'sets ssl_version' do
           it 'defaults to nil when no ssl_version is specified' do
             curb.expects(:ssl_version=).with(nil)
@@ -271,6 +285,16 @@ unless RUBY_PLATFORM =~ /java/
             adapter.request(:get)
           end
         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, 'Curb 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, 'Curb adapter does not support #min_version or #max_version. Please, use #ssl_version instead.')
+        end
       end
 
       context "(for SSL client auth)" do

data/spec/httpi/adapter/em_http_spec.rb

@@ -2,7 +2,7 @@ require "spec_helper"
 require "httpi/adapter/em_http"
 require "httpi/request"
 
-begin
+unless RUBY_PLATFORM =~ /java/
   HTTPI::Adapter.load_adapter(:em_http)
 
   describe HTTPI::Adapter::EmHttpRequest do
@@ -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)
 
@@ -142,7 +150,7 @@ begin
 
         it "raises an error for HTTP digest auth" do
           request.auth.digest "username", "password"
-          expect { adapter.request(:get) }.to raise_error
+          expect { adapter.request(:get) }.to raise_error HTTPI::NotSupportedError
         end
       end
 
@@ -169,10 +177,4 @@ begin
     end
 
   end
-rescue LoadError => e
-  if e.message =~ /fiber/
-    warn "LoadError: #{e.message} (EventMachine requires fibers)"
-  else
-    raise e
-  end
 end

data/spec/httpi/adapter/excon_spec.rb

@@ -1,124 +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
-
-    it "supports disabling verify mode" do
-      request = HTTPI::Request.new(@server.url)
-      request.auth.ssl.verify_mode = :none
-      adapter_class = HTTPI::Adapter.load(adapter).new(request)
-      expect(adapter_class.client.data[:ssl_verify_peer]).to eq(false)
-    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 no client cert is specified" 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")
-      end
-
-      it "works with client cert and key provided as file path" do
-        request = HTTPI::Request.new(@server.url)
-        request.auth.ssl.ca_cert_file = IntegrationServer.ssl_ca_file
-        request.auth.ssl.cert_file = "spec/fixtures/client_cert.pem"
-        request.auth.ssl.cert_key_file = "spec/fixtures/client_key.pem"
-
-        response = HTTPI.get(request, adapter)
-        expect(response.body).to eq("get")
-      end
-
-      it "works with client cert and key set directly" do
-        request = HTTPI::Request.new(@server.url)
-        
-        request.auth.ssl.ca_cert_file = IntegrationServer.ssl_ca_file
-        request.auth.ssl.cert = OpenSSL::X509::Certificate.new File.open("spec/fixtures/client_cert.pem").read
-        request.auth.ssl.cert_key = OpenSSL::PKey.read File.open("spec/fixtures/client_key.pem").read
-
-        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

@@ -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

@@ -100,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"
@@ -127,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
@@ -164,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

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