httpi 4.0.3 → 4.0.4

data/spec/httpi/adapter/httpclient_spec.rb

@@ -1,238 +0,0 @@
-require "spec_helper"
-require "httpi/adapter/httpclient"
-require "httpi/request"
-require "integration/support/server"
-
-HTTPI::Adapter.load_adapter(:httpclient)
-
-describe HTTPI::Adapter::HTTPClient do
-  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") }
-
-  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)
-      expect(adapter.request(:get)).to match_response(:body => Fixture.xml)
-    end
-  end
-
-  describe "#request(:post)" do
-    it "returns a valid HTTPI::Response" do
-      request.body = Fixture.xml
-      httpclient_expects(:post)
-
-      expect(adapter.request(:post)).to match_response(:body => Fixture.xml)
-    end
-  end
-
-  describe "#request(:head)" do
-    it "returns a valid HTTPI::Response" do
-      httpclient_expects(:head)
-      expect(adapter.request(:head)).to match_response(:body => Fixture.xml)
-    end
-  end
-
-  describe "#request(:put)" do
-    it "returns a valid HTTPI::Response" do
-      request.body = Fixture.xml
-      httpclient_expects(:put)
-
-      expect(adapter.request(:put)).to match_response(:body => Fixture.xml)
-    end
-  end
-
-  describe "#request(:delete)" do
-    it "returns a valid HTTPI::Response" do
-      httpclient_expects(:delete)
-      expect(adapter.request(:delete)).to match_response(:body => Fixture.xml)
-    end
-  end
-
-  describe "#request(:custom)" do
-    it "returns a valid HTTPI::Response" do
-      httpclient_expects(:custom)
-      expect(adapter.request(:custom)).to match_response(:body => Fixture.xml)
-    end
-  end
-
-  describe "settings:" do
-    before { httpclient.stubs(:request).returns(http_message) }
-
-    describe "proxy" do
-      it "have should specs"
-    end
-
-    describe "connect_timeout" do
-      it "is not set unless specified" do
-        httpclient.expects(:connect_timeout=).never
-        adapter.request(:get)
-      end
-
-      it "is set if specified" do
-        request.open_timeout = 30
-
-        httpclient.expects(:connect_timeout=).with(30)
-        adapter.request(:get)
-      end
-    end
-
-    describe "receive_timeout" do
-      it "is not set unless specified" do
-        httpclient.expects(:receive_timeout=).never
-        adapter.request(:get)
-      end
-
-      it "is set if specified" do
-        request.read_timeout = 30
-
-        httpclient.expects(:receive_timeout=).with(30)
-        adapter.request(:get)
-      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"
-
-        httpclient.expects(:set_auth).with(request.url, *request.auth.credentials)
-        adapter.request(:get)
-      end
-
-      it "is set for HTTP digest auth" do
-        request.auth.digest "username", "password"
-
-        httpclient.expects(:set_auth).with(request.url, *request.auth.credentials)
-        adapter.request(:get)
-      end
-    end
-
-    context "(for SSL without auth)" do
-      before do
-        request.ssl = true
-      end
-
-      it 'should set the ssl_version if specified' do
-        request.auth.ssl.ssl_version = :SSLv3
-        ssl_config.expects(:ssl_version=).with('SSLv3')
-
-        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
-      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 "send certificate regardless of state of SSL verify mode" do
-        request.auth.ssl.verify_mode = :none
-        ssl_config.expects(:client_cert=).with(request.auth.ssl.cert)
-        ssl_config.expects(:client_key=).with(request.auth.ssl.cert_key)
-
-        adapter.request(:get)
-      end
-
-      it "client_cert, client_key and verify_mode should be set" do
-        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.request(:get)
-      end
-
-      it "sets the client_ca if specified" do
-        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.request(:get)
-      end
-
-      it 'should set the ssl_version if specified' do
-        request.auth.ssl.ssl_version = :SSLv3
-        ssl_config.expects(:ssl_version=).with('SSLv3')
-
-        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
-      before do
-        request.auth.ssl.verify_mode = :none
-      end
-
-      it "verify_mode should be set" do
-        ssl_config.expects(:verify_mode=).with(request.auth.ssl.openssl_verify_mode)
-
-        adapter.request(:get)
-      end
-
-      it "does not raise an exception" do
-        expect { adapter.request(:get) }.to_not raise_error
-      end
-    end
-  end
-
-  it "supports NTLM authentication" do
-    request = HTTPI::Request.new(@server.url + "ntlm-auth")
-
-    request.auth.ntlm("tester", "vReqSoafRe5O")
-    response = HTTPI.get(request, :httpclient)
-    expect(response.body).to eq("ntlm-auth")
-  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
-
-end

data/spec/httpi/adapter/net_http_persistent_spec.rb

@@ -1,46 +0,0 @@
-require "spec_helper"
-require "httpi/adapter/net_http_persistent"
-require "httpi/request"
-
-begin
-  HTTPI::Adapter.load_adapter(:net_http_persistent)
-
-  describe HTTPI::Adapter::NetHTTPPersistent do
-    let(:adapter) { HTTPI::Adapter::NetHTTPPersistent.new(request) }
-    let(:request) { HTTPI::Request.new("http://example.com") }
-
-    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
-    }
-
-    before do
-      Net::HTTP::Persistent.any_instance.stubs(:start).returns(response)
-    end
-
-    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
-
-          adapter.client.expects(:open_timeout=).with(30)
-          adapter.client.expects(:read_timeout=).with(40)
-
-          adapter.request(:get)
-        end
-      end
-
-      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,54 +0,0 @@
-require "spec_helper"
-require "httpi/adapter/net_http"
-require "httpi/request"
-
-begin
-  HTTPI::Adapter.load_adapter(:net_http)
-
-  describe HTTPI::Adapter::NetHTTP do
-    let(:adapter) { HTTPI::Adapter::NetHTTP.new(request) }
-    let(:request) { HTTPI::Request.new("http://example.com") }
-
-    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
-    }
-
-    before do
-      Net::HTTP.any_instance.stubs(:start).returns(response)
-    end
-
-    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
-
-          adapter.client.expects(:open_timeout=).with(30)
-          adapter.client.expects(:read_timeout=).with(40)
-
-          adapter.request(:get)
-        end
-      end
-
-      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

@@ -1,109 +0,0 @@
-require "spec_helper"
-require "integration/support/application"
-
-describe HTTPI::Adapter::NetHTTP do
-
-  subject(:adapter) { :rack }
-
-  context "http requests" do
-    before :all do
-      @app = 'app'
-      @url = "http://#{@app}/"
-
-      HTTPI::Adapter::Rack.mount @app, IntegrationServer::Application
-    end
-
-    it "sends and receives HTTP headers" do
-      request = HTTPI::Request.new(@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(@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(@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(@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(@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(@url, adapter)
-      expect(response.body).to eq("delete")
-      expect(response.headers["Content-Type"]).to eq("text/plain")
-    end
-
-    describe "settings:" do
-
-      let(:request) { HTTPI::Request.new("http://#{@app}") }
-      let(:client)  { HTTPI::Adapter::Rack.new(request) }
-
-      describe "proxy" do
-        before do
-          request.proxy = "http://proxy-host.com:443"
-          request.proxy.user = "username"
-          request.proxy.password = "password"
-        end
-
-        it "is not supported" do
-          expect { client.request(:get) }.
-            to raise_error(HTTPI::NotSupportedError, "Rack adapter does not support proxying")
-        end
-      end
-
-      describe "on_body" do
-        before do
-          request.on_body do
-            # ola-la!
-          end
-        end
-
-        it "is not supported" do
-          expect { client.request(:get) }.
-            to raise_error(HTTPI::NotSupportedError, "Rack adapter does not support response streaming")
-        end
-      end
-
-      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
-
-      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 { client.request(:get) }.
-            to raise_error(HTTPI::NotSupportedError, "Rack adapter does not support SSL client auth")
-        end
-      end
-    end
-
-  end
-
-end

data/spec/httpi/adapter_spec.rb

@@ -1,68 +0,0 @@
-require "spec_helper"
-require "httpi/adapter"
-
-describe HTTPI::Adapter do
-  let(:adapter) { HTTPI::Adapter }
-
-  describe ".register" do
-    it "registers a new adapter" do
-      name  = :custom
-      klass = Class.new
-      deps  = %w(some_dependency)
-
-      adapter.register(name, klass, deps)
-
-      expect(HTTPI::Adapter::ADAPTERS[:custom]).to include(:class => klass, :deps => deps)
-      expect(HTTPI::Adapter::ADAPTER_CLASS_MAP[klass]).to be(name)
-    end
-  end
-
-  describe ".use" do
-    around do |example|
-      adapter.use = nil
-      example.run
-      adapter.use = nil
-    end
-
-    it "sets the adapter to use" do
-      expect(adapter.use).not_to eq(:net_http)
-
-      adapter.use = :net_http
-      expect(adapter.use).to eq(:net_http)
-    end
-
-    it "defaults to use the HTTPClient adapter" do
-      expect(adapter.use).to eq(:httpclient)
-    end
-
-    it "loads the adapter's client library" do
-      adapter.expects(:require).with("httpclient")
-      adapter.use = :httpclient
-    end
-
-    it "raises an ArgumentError in case of an invalid adapter" do
-      expect { adapter.use = :unknown }.to raise_error(ArgumentError)
-    end
-  end
-
-  describe ".load" do
-    context "called with a valid adapter" do
-      it "returns the adapter's name and class" do
-        expect(adapter.load(:net_http)).to eq(HTTPI::Adapter::NetHTTP)
-      end
-    end
-
-    context "called with nil" do
-      it "returns the default adapter's name and class" do
-        expect(adapter.load(nil)).to eq(HTTPI::Adapter::HTTPClient)
-      end
-    end
-
-    context "called with an invalid adapter" do
-      it "raises an ArgumentError" do
-        expect { adapter.use = :unknown }.to raise_error(ArgumentError)
-      end
-    end
-  end
-
-end

data/spec/httpi/auth/config_spec.rb

@@ -1,163 +0,0 @@
-require "spec_helper"
-require "httpi/auth/config"
-
-describe HTTPI::Auth::Config do
-  let(:auth) { HTTPI::Auth::Config.new }
-
-  describe "#basic" do
-    it "lets you specify the basic auth credentials" do
-      auth.basic "username", "password"
-      expect(auth.basic).to eq(["username", "password"])
-    end
-
-    it "also accepts an Array of credentials" do
-      auth.basic ["username", "password"]
-      expect(auth.basic).to eq(["username", "password"])
-    end
-
-    it "sets the authentication type to :basic" do
-      auth.basic "username", "password"
-      expect(auth.type).to eq(:basic)
-    end
-  end
-
-  describe "#basic?" do
-    it "defaults to return false" do
-      expect(auth).not_to be_basic
-    end
-
-    it "returns true for HTTP basic auth" do
-      auth.basic "username", "password"
-      expect(auth).to be_basic
-    end
-  end
-
-  describe "#digest" do
-    it "lets you specify the digest auth credentials" do
-      auth.digest "username", "password"
-      expect(auth.digest).to eq(["username", "password"])
-    end
-
-    it "also accepts an Array of credentials" do
-      auth.digest ["username", "password"]
-      expect(auth.digest).to eq(["username", "password"])
-    end
-
-    it "sets the authentication type to :digest" do
-      auth.digest "username", "password"
-      expect(auth.type).to eq(:digest)
-    end
-  end
-
-  describe "#digest?" do
-    it "defaults to return false" do
-      expect(auth).not_to be_digest
-    end
-
-    it "returns true for HTTP digest auth" do
-      auth.digest "username", "password"
-      expect(auth).to be_digest
-    end
-  end
-
-  describe "#gssnegotiate" do
-    it "sets the authentication type to :gssnegotiate" do
-      auth.gssnegotiate
-      expect(auth.type).to eq(:gssnegotiate)
-    end
-  end
-
-  describe "#gssnegotiate?" do
-    it "defaults to return false" do
-      expect(auth).not_to be_gssnegotiate
-    end
-
-    it "returns true for HTTP Negotiate auth" do
-      auth.gssnegotiate
-      expect(auth).to be_gssnegotiate
-    end
-  end
-
-  describe "#http?" do
-    it "defaults to return false" do
-      expect(auth).not_to be_http
-    end
-
-    it "returns true for HTTP basic auth" do
-      auth.basic "username", "password"
-      expect(auth).to be_http
-    end
-
-    it "returns true for HTTP digest auth" do
-      auth.digest "username", "password"
-      expect(auth).to be_http
-    end
-  end
-
-  describe "#ssl" do
-    it "returns the HTTPI::Auth::SSL object" do
-      expect(auth.ssl).to be_a(HTTPI::Auth::SSL)
-    end
-  end
-
-  describe "#ssl?" do
-    it "defaults to return false" do
-      expect(auth).not_to be_ssl
-    end
-
-    it "returns true for SSL client auth" do
-      auth.ssl.cert_key_file = "spec/fixtures/client_key.pem"
-      auth.ssl.cert_file = "spec/fixtures/client_cert.pem"
-
-      expect(auth).to be_ssl
-    end
-  end
-
-  describe "#type" do
-    it "returns the authentication type" do
-      auth.basic "username", "password"
-      expect(auth.type).to eq(:basic)
-    end
-  end
-
-  describe "#credentials" do
-    it "returns the credentials for HTTP basic auth" do
-      auth.basic "username", "basic"
-      expect(auth.credentials).to eq(["username", "basic"])
-    end
-
-    it "returns the credentials for HTTP digest auth" do
-      auth.digest "username", "digest"
-      expect(auth.credentials).to eq(["username", "digest"])
-    end
-  end
-
-  describe "#ntlm" do
-    it "lets you specify the ntlm auth credentials" do
-      auth.ntlm "username", "password"
-      expect(auth.ntlm).to eq(["username", "password"])
-    end
-
-    it "also accepts an Array of credentials" do
-      auth.ntlm ["username", "password"]
-      expect(auth.ntlm).to eq(["username", "password"])
-    end
-
-    it "sets the authentication type to :ntlm" do
-      auth.ntlm "username", "password"
-      expect(auth.type).to eq(:ntlm)
-    end
-  end
-
-  describe "#ntlm?" do
-    it "defaults to return false" do
-      expect(auth).not_to be_ntlm
-    end
-
-    it "returns true for HTTP ntlm auth" do
-      auth.ntlm "username", "password"
-      expect(auth).to be_ntlm
-    end
-  end
-
-end