httpi 1.1.1 → 2.0.0.rc1

data/spec/httpi/adapter/em_http_spec.rb

@@ -0,0 +1,168 @@
+require "spec_helper"
+require "httpi/adapter/em_http"
+require "httpi/request"
+
+begin
+  HTTPI::Adapter.load_adapter(:em_http)
+
+  describe HTTPI::Adapter::EmHttpRequest do
+
+    around(:each) do |example|
+      EM.synchrony do
+        example.run
+        EM.stop
+      end
+    end
+
+    let(:adapter) { HTTPI::Adapter::EmHttpRequest.new(request) }
+    let(:em_http) { EventMachine::HttpConnection.any_instance }
+    let(:request) { HTTPI::Request.new("http://example.com") }
+
+    describe "#request(:get)" do
+      it "returns a valid HTTPI::Response" do
+        em_http.expects(:get).
+          with(:query => nil, :connect_timeout => nil, :inactivity_timeout => nil, :head => {}, :body => nil).
+          returns(http_message)
+
+        adapter.request(:get).should match_response(:body => Fixture.xml)
+      end
+    end
+
+    describe "#request(:post)" do
+      it "returns a valid HTTPI::Response" do
+        em_http.expects(:post).
+          with(:query => nil, :connect_timeout => nil, :inactivity_timeout => nil, :head => {}, :body => Fixture.xml).
+          returns(http_message)
+
+        request.body = Fixture.xml
+        adapter.request(:post).should match_response(:body => Fixture.xml)
+      end
+    end
+
+    describe "#request(:head)" do
+      it "returns a valid HTTPI::Response" do
+        em_http.expects(:head).
+          with(:query => nil, :connect_timeout => nil, :inactivity_timeout => nil, :head => {}, :body => nil).
+          returns(http_message)
+
+        adapter.request(:head).should match_response(:body => Fixture.xml)
+      end
+    end
+
+    describe "#request(:put)" do
+      it "returns a valid HTTPI::Response" do
+        em_http.expects(:put).
+          with(:query => nil, :connect_timeout => nil, :inactivity_timeout => nil, :head => {}, :body => Fixture.xml).
+          returns(http_message)
+
+        request.body = Fixture.xml
+        adapter.request(:put).should match_response(:body => Fixture.xml)
+      end
+    end
+
+    describe "#request(:delete)" do
+      it "returns a valid HTTPI::Response" do
+        em_http.expects(:delete).
+          with(:query => nil, :connect_timeout => nil, :inactivity_timeout => nil, :head => {}, :body => nil).
+          returns(http_message(""))
+
+        adapter.request(:delete).should match_response(:body => "")
+      end
+    end
+
+    describe "#request(:custom)" do
+      it "returns a valid HTTPI::Response" do
+        em_http.expects(:custom).
+          with(:query => nil, :connect_timeout => nil, :inactivity_timeout => nil, :head => {}, :body => nil).
+          returns(http_message(""))
+
+        adapter.request(:custom).should match_response(:body => "")
+      end
+    end
+
+    describe "settings:" do
+      describe "proxy" do
+        before do
+          request.proxy = "http://proxy-host.com:443"
+          request.proxy.user = "username"
+          request.proxy.password = "password"
+        end
+
+        it "sets host, port, and authorization" do
+          em_http.expects(:get).once.
+            with(has_entries(:proxy => { :host => "proxy-host.com", :port => 443, :authorization => %w( username password ) })).
+            returns(http_message)
+
+          adapter.request(:get)
+        end
+      end
+
+      describe "connect_timeout" do
+        it "is not set unless specified" do
+          em_http.expects(:get).once.with(has_entries(:connect_timeout => nil)).returns(http_message)
+          adapter.request(:get)
+        end
+
+        it "is set if specified" do
+          request.open_timeout = 30
+          em_http.expects(:get).once.with(has_entries(:connect_timeout => 30)).returns(http_message)
+          adapter.request(:get)
+        end
+      end
+
+      describe "receive_timeout" do
+        it "is not set unless specified" do
+          em_http.expects(:get).once.with(has_entries(:inactivity_timeout => nil)).returns(http_message)
+          adapter.request(:get)
+        end
+
+        it "is set if specified" do
+          request.read_timeout = 30
+          em_http.expects(:get).once.with(has_entries(:inactivity_timeout => 30)).returns(http_message)
+          adapter.request(:get)
+        end
+      end
+
+      describe "set_auth" do
+        it "is set for HTTP basic auth" do
+          request.auth.basic "username", "password"
+          em_http.expects(:get).once.with(has_entries(:head => { :authorization => %w( username password) })).returns(http_message)
+          adapter.request(:get)
+        end
+
+        it "raises an error for HTTP digest auth" do
+          request.auth.digest "username", "password"
+          expect { adapter.request(:get) }.to raise_error
+        end
+      end
+
+      context "(for SSL client auth)" do
+        before do
+          request.auth.ssl.cert_key_file = "spec/fixtures/client_key.pem"
+          request.auth.ssl.cert_file = "spec/fixtures/client_cert.pem"
+        end
+
+        it "is not supported" do
+          expect { adapter.request(:get) }.
+            to raise_error(HTTPI::NotSupportedError, "EM-HTTP-Request does not support SSL client auth")
+        end
+      end
+    end
+
+    def http_message(body = Fixture.xml)
+      message = EventMachine::HttpClient.new("http://example.com", {})
+      message.instance_variable_set :@response, body
+      message.instance_variable_set :@response_header, EventMachine::HttpResponseHeader.new
+      message.response_header['Accept-encoding'] = 'utf-8'
+      message.response_header.http_status = '200'
+      message
+    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/httpclient_spec.rb

@@ -2,54 +2,62 @@ require "spec_helper"
 require "httpi/adapter/httpclient"
 require "httpi/request"
 
-require "httpclient"
+HTTPI::Adapter.load_adapter(:httpclient)
 
 describe HTTPI::Adapter::HTTPClient do
-  let(:adapter) { HTTPI::Adapter::HTTPClient.new }
+  let(:adapter)    { HTTPI::Adapter::HTTPClient.new(request) }
   let(:httpclient) { HTTPClient.any_instance }
   let(:ssl_config) { HTTPClient::SSLConfig.any_instance }
+  let(:request)    { HTTPI::Request.new("http://example.com") }
 
-  describe "#get" do
+  describe "#request(:get)" do
     it "returns a valid HTTPI::Response" do
-      httpclient.expects(:get).with(basic_request.url, nil, basic_request.headers).returns(http_message)
-      adapter.get(basic_request).should match_response(:body => Fixture.xml)
+      httpclient_expects(:get)
+      adapter.request(:get).should match_response(:body => Fixture.xml)
     end
   end
 
-  describe "#post" do
+  describe "#request(:post)" do
     it "returns a valid HTTPI::Response" do
-      request = HTTPI::Request.new :url => "http://example.com", :body => Fixture.xml
-      httpclient.expects(:post).with(request.url, request.body, request.headers).returns(http_message)
+      request.body = Fixture.xml
+      httpclient_expects(:post)
 
-      adapter.post(request).should match_response(:body => Fixture.xml)
+      adapter.request(:post).should match_response(:body => Fixture.xml)
     end
   end
 
-  describe "#head" do
+  describe "#request(:head)" do
     it "returns a valid HTTPI::Response" do
-      httpclient.expects(:head).with(basic_request.url, nil, basic_request.headers).returns(http_message)
-      adapter.head(basic_request).should match_response(:body => Fixture.xml)
+      httpclient_expects(:head)
+      adapter.request(:head).should match_response(:body => Fixture.xml)
     end
   end
 
-  describe "#put" do
+  describe "#request(:put)" do
     it "returns a valid HTTPI::Response" do
-      request = HTTPI::Request.new :url => "http://example.com", :body => Fixture.xml
-      httpclient.expects(:put).with(request.url, request.body, request.headers).returns(http_message)
+      request.body = Fixture.xml
+      httpclient_expects(:put)
 
-      adapter.put(request).should match_response(:body => Fixture.xml)
+      adapter.request(:put).should match_response(:body => Fixture.xml)
     end
   end
 
-  describe "#delete" do
+  describe "#request(:delete)" do
     it "returns a valid HTTPI::Response" do
-      httpclient.expects(:delete).with(basic_request.url, basic_request.headers).returns(http_message(""))
-      adapter.delete(basic_request).should match_response(:body => "")
+      httpclient_expects(:delete)
+      adapter.request(:delete).should match_response(:body => Fixture.xml)
+    end
+  end
+
+  describe "#request(:custom)" do
+    it "returns a valid HTTPI::Response" do
+      httpclient_expects(:custom)
+      adapter.request(:custom).should match_response(:body => Fixture.xml)
     end
   end
 
   describe "settings:" do
-    before { httpclient.stubs(:get).returns(http_message) }
+    before { httpclient.stubs(:request).returns(http_message) }
 
     describe "proxy" do
       it "have should specs"
@@ -58,107 +66,110 @@ describe HTTPI::Adapter::HTTPClient do
     describe "connect_timeout" do
       it "is not set unless specified" do
         httpclient.expects(:connect_timeout=).never
-        adapter.get(basic_request)
+        adapter.request(:get)
       end
 
       it "is set if specified" do
-        request = basic_request { |request| request.open_timeout = 30 }
+        request.open_timeout = 30
 
         httpclient.expects(:connect_timeout=).with(30)
-        adapter.get(request)
+        adapter.request(:get)
       end
     end
 
     describe "receive_timeout" do
       it "is not set unless specified" do
         httpclient.expects(:receive_timeout=).never
-        adapter.get(basic_request)
+        adapter.request(:get)
       end
 
       it "is set if specified" do
-        request = basic_request { |request| request.read_timeout = 30 }
+        request.read_timeout = 30
 
         httpclient.expects(:receive_timeout=).with(30)
-        adapter.get(request)
+        adapter.request(:get)
       end
     end
 
     describe "set_auth" do
       it "is set for HTTP basic auth" do
-        request = basic_request { |request| request.auth.basic "username", "password" }
+        request.auth.basic "username", "password"
 
         httpclient.expects(:set_auth).with(request.url, *request.auth.credentials)
-        adapter.get(request)
+        adapter.request(:get)
       end
 
       it "is set for HTTP digest auth" do
-        request = basic_request { |request| request.auth.digest "username", "password" }
+        request.auth.digest "username", "password"
 
         httpclient.expects(:set_auth).with(request.url, *request.auth.credentials)
-        adapter.get(request)
+        adapter.request(:get)
       end
     end
 
     context "(for SSL client auth)" do
-      let(:ssl_auth_request) do
-        basic_request do |request|
-          request.auth.ssl.cert_key_file = "spec/fixtures/client_key.pem"
-          request.auth.ssl.cert_file = "spec/fixtures/client_cert.pem"
-        end
+      before do
+        request.auth.ssl.cert_key_file = "spec/fixtures/client_key.pem"
+        request.auth.ssl.cert_file = "spec/fixtures/client_cert.pem"
       end
 
       it "client_cert, client_key and verify_mode should be set" do
-        ssl_config.expects(:client_cert=).with(ssl_auth_request.auth.ssl.cert)
-        ssl_config.expects(:client_key=).with(ssl_auth_request.auth.ssl.cert_key)
-        ssl_config.expects(:verify_mode=).with(ssl_auth_request.auth.ssl.openssl_verify_mode)
+        ssl_config.expects(:client_cert=).with(request.auth.ssl.cert)
+        ssl_config.expects(:client_key=).with(request.auth.ssl.cert_key)
+        ssl_config.expects(:verify_mode=).with(request.auth.ssl.openssl_verify_mode)
 
-        adapter.get(ssl_auth_request)
+        adapter.request(:get)
       end
 
       it "sets the client_ca if specified" do
-        ssl_auth_request.auth.ssl.ca_cert_file = "spec/fixtures/client_cert.pem"
-        ssl_config.expects(:client_ca=).with(ssl_auth_request.auth.ssl.ca_cert)
+        request.auth.ssl.ca_cert_file = "spec/fixtures/client_cert.pem"
+        ssl_config.expects(:add_trust_ca).with(request.auth.ssl.ca_cert_file)
 
-        adapter.get(ssl_auth_request)
+        adapter.request(:get)
+      end
+
+      it 'should set the ssl_version if specified' do
+        request.auth.ssl.ssl_version = :SSLv3
+        ssl_config.expects(:ssl_version=).with(request.auth.ssl.ssl_version)
+
+        adapter.request(:get)
       end
     end
 
     context "(for SSL client auth with a verify mode of :none with no certs provided)" do
-      let(:ssl_auth_request) do
-        basic_request do |request|
-          request.auth.ssl.verify_mode = :none
-        end
+      before do
+        request.auth.ssl.verify_mode = :none
       end
 
       it "verify_mode should be set" do
-        ssl_config.expects(:verify_mode=).with(ssl_auth_request.auth.ssl.openssl_verify_mode)
+        ssl_config.expects(:verify_mode=).with(request.auth.ssl.openssl_verify_mode)
 
-        adapter.get(ssl_auth_request)
+        adapter.request(:get)
       end
 
       it "does not set client_cert and client_key "do
         ssl_config.expects(:client_cert=).never
         ssl_config.expects(:client_key=).never
 
-        adapter.get(ssl_auth_request)
+        adapter.request(:get)
       end
 
       it "does not raise an exception" do
-        expect { adapter.get(ssl_auth_request) }.to_not raise_error
+        expect { adapter.request(:get) }.to_not raise_error
       end
     end
   end
 
+  def httpclient_expects(method)
+    httpclient.expects(:request).
+      with(method, request.url, nil, request.body, request.headers).
+      returns(http_message)
+  end
+
   def http_message(body = Fixture.xml)
     message = HTTP::Message.new_response body
     message.header.set "Accept-encoding", "utf-8"
     message
   end
 
-  def basic_request
-    request = HTTPI::Request.new "http://example.com"
-    yield request if block_given?
-    request
-  end
-
 end

data/spec/httpi/adapter/net_http_spec.rb

@@ -2,133 +2,148 @@ require "spec_helper"
 require "httpi/adapter/net_http"
 require "httpi/request"
 
+HTTPI::Adapter.load_adapter(:net_http)
+
 describe HTTPI::Adapter::NetHTTP do
-  let(:net_http) { Net::HTTP.any_instance }
+
+  let(:net_http)       { Net::HTTP.any_instance }
+  let(:request)        { HTTPI::Request.new("http://example.com") }
   let(:basic_response) { { :body => Fixture.xml, :headers => { "Accept-encoding" => "utf-8" } } }
 
-  def adapter(request)
-    @adapter ||= HTTPI::Adapter::NetHTTP.new request
-  end
+  let(:adapter) {
+    HTTPI::Adapter::NetHTTP.new(request)
+  }
 
-  describe "#get" do
+  describe "#request(:get)" do
     it "should return a valid HTTPI::Response" do
-      stub_request(:get, basic_request.url.to_s).to_return(basic_response)
-      adapter(basic_request).get(basic_request).should match_response(:body => Fixture.xml)
+      stub_request(:get, request.url.to_s).to_return(basic_response)
+      adapter.request(:get).should match_response(:body => Fixture.xml)
     end
   end
 
-  describe "#post" do
+  describe "#request(:post)" do
     it "should return a valid HTTPI::Response" do
-      request = HTTPI::Request.new :url => "http://example.com", :body => Fixture.xml
+      request.body = Fixture.xml
       stub_request(:post, request.url.to_s).with(:body => request.body).to_return(basic_response)
 
-      adapter(request).post(request).should match_response(:body => Fixture.xml)
+      adapter.request(:post).should match_response(:body => Fixture.xml)
     end
   end
 
-  describe "#head" do
+  describe "#request(:head)" do
     it "should return a valid HTTPI::Response" do
-      stub_request(:head, basic_request.url.to_s).to_return(basic_response)
-      adapter(basic_request).head(basic_request).should match_response(:body => Fixture.xml)
+      stub_request(:head, request.url.to_s).to_return(basic_response)
+      adapter.request(:head).should match_response(:body => Fixture.xml)
     end
   end
 
-  describe "#put" do
+  describe "#request(:put)" do
     it "should return a valid HTTPI::Response" do
-      request = HTTPI::Request.new(
-        :url     => "http://example.com",
-        :headers => { "Accept-encoding" => "utf-8" },
-        :body    => Fixture.xml
-      )
+      request.url     = "http://example.com"
+      request.headers = { "Accept-encoding" => "utf-8" }
+      request.body    = Fixture.xml
+
       stub_request(:put, request.url.to_s).with(:body => request.body).to_return(basic_response)
 
-      adapter(request).put(request).should match_response(:body => Fixture.xml)
+      adapter.request(:put).should match_response(:body => Fixture.xml)
     end
   end
 
-  describe "#delete" do
+  describe "#request(:delete)" do
     it "should return a valid HTTPI::Response" do
-      stub_request(:delete, basic_request.url.to_s).to_return(basic_response)
-      adapter(basic_request).delete(basic_request).should match_response(:body => Fixture.xml)
+      stub_request(:delete, request.url.to_s).to_return(basic_response)
+      adapter.request(:delete).should match_response(:body => Fixture.xml)
+    end
+  end
+
+  describe "#request(:custom)" do
+    it "raises a NotSupportedError" do
+      expect { adapter.request(:custom) }.
+        to raise_error(HTTPI::NotSupportedError, "Net::HTTP does not support custom HTTP methods")
     end
   end
 
   describe "settings:" do
-    before { stub_request(:get, basic_request.url.to_s) }
+    before { stub_request(:get, request.url.to_s) }
 
     describe "use_ssl" do
       it "should be set to false for non-SSL requests" do
         net_http.expects(:use_ssl=).with(false)
-        adapter(basic_request).get(basic_request)
+        adapter.request(:get)
       end
 
       it "should be set to true for SSL requests" do
-        request = basic_request { |request| request.ssl = true }
+        request.ssl = true
 
         net_http.expects(:use_ssl=).with(true)
-        adapter(request).get(request)
+        adapter.request(:get)
       end
     end
 
     describe "open_timeout" do
       it "should not be set if not specified" do
         net_http.expects(:open_timeout=).never
-        adapter(basic_request).get(basic_request)
+        adapter.request(:get)
       end
 
       it "should be set if specified" do
-        request = basic_request { |request| request.open_timeout = 30 }
+        request.open_timeout = 30
 
         net_http.expects(:open_timeout=).with(30)
-        adapter(request).get(request)
+        adapter.request(:get)
       end
     end
 
     describe "read_timeout" do
       it "should not be set if not specified" do
         net_http.expects(:read_timeout=).never
-        adapter(basic_request).get(basic_request)
+        adapter.request(:get)
       end
 
       it "should be set if specified" do
-        request = basic_request { |request| request.read_timeout = 30 }
+        request.read_timeout = 30
 
         net_http.expects(:read_timeout=).with(30)
-        adapter(request).get(request)
+        adapter.request(:get)
       end
     end
 
     describe "basic_auth" do
       it "should be set for HTTP basic auth" do
-        request = basic_request { |request| request.auth.basic "username", "password" }
+        request.auth.basic "username", "password"
 
         stub_request(:get, "http://username:password@example.com")
         Net::HTTP::Get.any_instance.expects(:basic_auth).with(*request.auth.credentials)
-        adapter(request).get(request)
+        adapter.request(:get)
       end
     end
 
     context "(for SSL client auth)" do
-      let(:ssl_auth_request) do
-        basic_request do |request|
-          request.auth.ssl.cert_key_file = "spec/fixtures/client_key.pem"
-          request.auth.ssl.cert_file = "spec/fixtures/client_cert.pem"
-        end
+      before do
+        request.auth.ssl.cert_key_file = "spec/fixtures/client_key.pem"
+        request.auth.ssl.cert_file = "spec/fixtures/client_cert.pem"
       end
 
       it "key, cert and verify_mode should be set" do
-        net_http.expects(:cert=).with(ssl_auth_request.auth.ssl.cert)
-        net_http.expects(:key=).with(ssl_auth_request.auth.ssl.cert_key)
-        net_http.expects(:verify_mode=).with(ssl_auth_request.auth.ssl.openssl_verify_mode)
+        net_http.expects(:cert=).with(request.auth.ssl.cert)
+        net_http.expects(:key=).with(request.auth.ssl.cert_key)
+        net_http.expects(:verify_mode=).with(request.auth.ssl.openssl_verify_mode)
 
-        adapter(ssl_auth_request).get(ssl_auth_request)
+        adapter.request(:get)
       end
 
       it "should set the client_ca if specified" do
-        ssl_auth_request.auth.ssl.ca_cert_file = "spec/fixtures/client_cert.pem"
-        net_http.expects(:ca_file=).with(ssl_auth_request.auth.ssl.ca_cert_file)
+        request.auth.ssl.ca_cert_file = "spec/fixtures/client_cert.pem"
+        net_http.expects(:ca_file=).with(request.auth.ssl.ca_cert_file)
+
+        adapter.request(:get)
+      end
+
+      it 'should set the ssl_version if specified' do
+        request.auth.ssl.ssl_version = :SSLv3
+        net_http.expects(:ssl_version=).with(request.auth.ssl.ssl_version)
 
-        adapter(ssl_auth_request).get(ssl_auth_request)
+        adapter.request(:get)
       end
     end
   end