httpi 4.0.3 → 4.0.4

data/spec/httpi/adapter/curb_spec.rb

@@ -1,351 +0,0 @@
-require "spec_helper"
-require "httpi/adapter/curb"
-require "httpi/request"
-
-require "integration/support/server"
-
-# curb does not run on jruby
-unless RUBY_PLATFORM =~ /java/
-  HTTPI::Adapter.load_adapter(:curb)
-
-  describe "NTLM authentication" do
-    before :all do
-      @server = IntegrationServer.run
-    end
-
-    after :all do
-      @server.stop
-    end
-
-    it "supports ntlm authentication" do
-      request = HTTPI::Request.new(@server.url + "ntlm-auth")
-      adapter = HTTPI::Adapter::Curb.new(request)
-
-      request.auth.ntlm("tester", "vReqSoafRe5O")
-      expect(adapter.request(:get).body).to eq("ntlm-auth")
-    end
-  end
-
-  describe HTTPI::Adapter::Curb do
-
-    let(:adapter) { HTTPI::Adapter::Curb.new(request) }
-    let(:curb)    { Curl::Easy.any_instance }
-    let(:request) { HTTPI::Request.new("http://example.com") }
-
-    describe "#request(:get)" do
-      before do
-        curb.expects(:http_get)
-        curb.expects(:response_code).returns(200)
-        curb.expects(:header_str).returns("Accept-encoding: utf-8")
-        curb.expects(:body_str).returns(Fixture.xml)
-      end
-
-      it "returns a valid HTTPI::Response" do
-        expect(adapter.request(:get)).to match_response(:body => Fixture.xml)
-      end
-    end
-
-    describe "#request(:post)" do
-      before do
-        curb.expects(:http_post)
-        curb.expects(:response_code).returns(200)
-        curb.expects(:header_str).returns("Accept-encoding: utf-8")
-        curb.expects(:body_str).returns(Fixture.xml)
-      end
-
-      it "returns a valid HTTPI::Response" do
-        expect(adapter.request(:post)).to match_response(:body => Fixture.xml)
-      end
-    end
-
-    describe "#request(:post)" do
-      it "sends the body in the request" do
-        curb.expects(:http_post).with("xml=hi&name=123")
-
-        request.body = "xml=hi&name=123"
-        adapter.request(:post)
-      end
-    end
-
-    describe "#request(:head)" do
-      before do
-        curb.expects(:http_head)
-        curb.expects(:response_code).returns(200)
-        curb.expects(:header_str).returns("Accept-encoding: utf-8")
-        curb.expects(:body_str).returns(Fixture.xml)
-      end
-
-      it "returns a valid HTTPI::Response" do
-        expect(adapter.request(:head)).to match_response(:body => Fixture.xml)
-      end
-    end
-
-    describe "#request(:put)" do
-      before do
-        curb.expects(:http_put)
-        curb.expects(:response_code).returns(200)
-        curb.expects(:header_str).returns("Accept-encoding: utf-8")
-        curb.expects(:body_str).returns(Fixture.xml)
-      end
-
-      it "returns a valid HTTPI::Response" do
-        expect(adapter.request(:put)).to match_response(:body => Fixture.xml)
-      end
-    end
-
-    describe "#request(:put)" do
-      it "sends the body in the request" do
-        curb.expects(:http_put).with('xml=hi&name=123')
-
-        request.body = 'xml=hi&name=123'
-        adapter.request(:put)
-      end
-    end
-
-    describe "#request(:delete)" do
-      before do
-        curb.expects(:http_delete)
-        curb.expects(:response_code).returns(200)
-        curb.expects(:header_str).returns("Accept-encoding: utf-8")
-        curb.expects(:body_str).returns("")
-      end
-
-      it "returns a valid HTTPI::Response" do
-        expect(adapter.request(:delete)).to match_response(:body => "")
-      end
-    end
-
-    describe "#request(:custom)" do
-      it "raises a NotSupportedError" do
-        expect { adapter.request(:custom) }.
-          to raise_error(HTTPI::NotSupportedError, "Curb does not support custom HTTP methods")
-      end
-    end
-
-    describe "settings:" do
-      before { curb.stubs(:http_get) }
-
-      describe "url" do
-        it "always sets the request url" do
-          curb.expects(:url=).with(request.url.to_s)
-          adapter.request(:get)
-        end
-      end
-
-      describe "proxy_url" do
-        it "is not set unless it's specified" do
-          curb.expects(:proxy_url=).never
-          adapter.request(:get)
-        end
-
-        it "is set if specified" do
-          request.proxy = "http://proxy.example.com"
-          curb.expects(:proxy_url=).with(request.proxy.to_s)
-
-          adapter.request(:get)
-        end
-      end
-
-      describe "timeout_ms" do
-        it "is not set unless it's specified" do
-          curb.expects(:timeout_ms=).never
-          adapter.request(:get)
-        end
-
-        it "is set if specified read_timeout" do
-          request.read_timeout = 30
-          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_ms" do
-        it "is not set unless it's specified" do
-          curb.expects(:connect_timeout_ms=).never
-          adapter.request(:get)
-        end
-
-        it "is set if specified" do
-          request.open_timeout = 30
-          curb.expects(:connect_timeout_ms=).with(30_000)
-
-          adapter.request(:get)
-        end
-      end
-
-      describe "headers" do
-        it "is always set" do
-          curb.expects(:headers=).with({})
-          adapter.request(:get)
-        end
-      end
-
-      describe "verbose" do
-        it "is always set to false" do
-          curb.expects(:verbose=).with(false)
-          adapter.request(:get)
-        end
-      end
-
-      describe "http_auth_types" do
-        it "is set to :basic for HTTP basic auth" do
-          request.auth.basic "username", "password"
-          curb.expects(:http_auth_types=).with(:basic)
-
-          adapter.request(:get)
-        end
-
-        it "is set to :digest for HTTP digest auth" do
-          request.auth.digest "username", "password"
-          curb.expects(:http_auth_types=).with(:digest)
-
-          adapter.request(:get)
-        end
-
-        it "is set to :gssnegotiate for HTTP Negotiate auth" do
-          request.auth.gssnegotiate
-          curb.expects(:http_auth_types=).with(:gssnegotiate)
-
-          adapter.request(:get)
-        end
-
-        it "is set to :ntlm for HTTP NTLM auth" do
-          request.auth.ntlm("tester", "vReqSoafRe5O")
-          curb.expects(:http_auth_types=).with(:ntlm)
-
-          adapter.request(:get)
-        end
-      end
-
-      describe "username and password" do
-        it "is set for HTTP basic auth" do
-          request.auth.basic "username", "password"
-
-          curb.expects(:username=).with("username")
-          curb.expects(:password=).with("password")
-          adapter.request(:get)
-        end
-
-        it "is set for HTTP digest auth" do
-          request.auth.digest "username", "password"
-
-          curb.expects(:username=).with("username")
-          curb.expects(:password=).with("password")
-          adapter.request(:get)
-        end
-      end
-
-      context "(for SSL without auth)" do
-        let(:request) do
-          request = HTTPI::Request.new("http://example.com")
-          request.ssl = true
-          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)
-            adapter.request(:get)
-          end
-
-          it 'to 1 when ssl_version is specified as TLSv1' do
-            request.auth.ssl.ssl_version = :TLSv1
-            curb.expects(:ssl_version=).with(1)
-
-            adapter.request(:get)
-          end
-
-          it 'to 2 when ssl_version is specified as SSLv2/SSLv23' do
-            version = HTTPI::Auth::SSL::SSL_VERSIONS.select { |method| method.to_s.match(/SSLv2|SSLv23/) }.first
-            request.auth.ssl.ssl_version = version
-            curb.expects(:ssl_version=).with(2)
-
-            adapter.request(:get)
-          end
-
-          it 'to 3 when ssl_version is specified as SSLv3' do
-            request.auth.ssl.ssl_version = :SSLv3
-            curb.expects(:ssl_version=).with(3)
-
-            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
-        let(:request) do
-          request = HTTPI::Request.new("http://example.com")
-          request.auth.ssl.cert_key_file = "spec/fixtures/client_key.pem"
-          request.auth.ssl.cert_file = "spec/fixtures/client_cert.pem"
-          request.auth.ssl.cert_key_password = 'example'
-          request
-        end
-
-        it "send certificate regardless of state of SSL verify mode" do
-          request.auth.ssl.verify_mode = :none
-          curb.expects(:ssl_verify_host=).with(0) # avoid "SSL peer certificate" error
-          curb.expects(:cert_key=).with(request.auth.ssl.cert_key_file)
-          curb.expects(:cert=).with(request.auth.ssl.cert_file)
-          curb.expects(:certpassword=).with(request.auth.ssl.cert_key_password)
-
-          adapter.request(:get)
-        end
-
-        it "cert_key, cert and ssl_verify_peer should be set" do
-          curb.expects(:cert_key=).with(request.auth.ssl.cert_key_file)
-          curb.expects(:cert=).with(request.auth.ssl.cert_file)
-          curb.expects(:certpassword=).with(request.auth.ssl.cert_key_password)
-          curb.expects(:ssl_verify_peer=).with(true)
-          curb.expects(:certtype=).with(request.auth.ssl.cert_type.to_s.upcase)
-
-          adapter.request(:get)
-        end
-
-        it "sets the cert_type to DER if specified" do
-          request.auth.ssl.cert_type = :der
-          curb.expects(:certtype=).with(:der.to_s.upcase)
-
-          adapter.request(:get)
-        end
-
-        it "raise if an invalid cert type was set" do
-          expect { request.auth.ssl.cert_type = :invalid }.
-            to raise_error(ArgumentError, "Invalid SSL cert type :invalid\nPlease specify one of [:pem, :der]")
-        end
-
-        it "sets the cacert if specified" do
-          request.auth.ssl.ca_cert_file = "spec/fixtures/client_cert.pem"
-          curb.expects(:cacert=).with(request.auth.ssl.ca_cert_file)
-
-          adapter.request(:get)
-        end
-      end
-    end
-
-  end
-end

data/spec/httpi/adapter/em_http_spec.rb

@@ -1,180 +0,0 @@
-require "spec_helper"
-require "httpi/adapter/em_http"
-require "httpi/request"
-
-unless RUBY_PLATFORM =~ /java/
-  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, :head => {}, :body => nil).
-          returns(http_message)
-
-        expect(adapter.request(:get)).to 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, :head => {}, :body => Fixture.xml).
-          returns(http_message)
-
-        request.body = Fixture.xml
-        expect(adapter.request(:post)).to 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, :head => {}, :body => nil).
-          returns(http_message)
-
-        expect(adapter.request(:head)).to 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, :head => {}, :body => Fixture.xml).
-          returns(http_message)
-
-        request.body = Fixture.xml
-        expect(adapter.request(:put)).to 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, :head => {}, :body => nil).
-          returns(http_message(""))
-
-        expect(adapter.request(:delete)).to match_response(:body => "")
-      end
-    end
-
-    describe "#request(:custom)" do
-      it "returns a valid HTTPI::Response" do
-        em_http.expects(:custom).
-          with(:query => nil, :head => {}, :body => nil).
-          returns(http_message(""))
-
-        expect(adapter.request(:custom)).to 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
-          url = "http://example.com:80"
-          connection_options = {
-            :proxy => {
-              :host => "proxy-host.com",
-              :port => 443,
-              :authorization => ["username", "password"]
-            }
-          }
-
-          EventMachine::HttpRequest.expects(:new).with(url, connection_options)
-
-          adapter
-        end
-      end
-
-      describe "connect_timeout" do
-        it "is passed as a connection option" do
-          request.open_timeout = 30
-
-          url = "http://example.com:80"
-          connection_options = { connect_timeout: 30 }
-
-          EventMachine::HttpRequest.expects(:new).with(url, connection_options)
-
-          adapter
-        end
-      end
-
-      describe "receive_timeout" do
-        it "is passed as a connection option (when read_timeout specified)" do
-          request.read_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)
-
-          adapter
-        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 HTTPI::NotSupportedError
-        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
-end

data/spec/httpi/adapter/excon_spec.rb

@@ -1,34 +0,0 @@
-require "spec_helper"
-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
-      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,28 +0,0 @@
-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