httpi 4.0.3 → 4.0.4

data/spec/httpi/auth/ssl_spec.rb

@@ -1,216 +0,0 @@
-require "spec_helper"
-require "httpi/auth/ssl"
-
-describe HTTPI::Auth::SSL do
-  before(:all) do
-    @ssl_versions = HTTPI::Auth::SSL::SSL_VERSIONS
-    @min_max_versions = HTTPI::Auth::SSL::MIN_MAX_VERSIONS
-  end
-
-  describe "VERIFY_MODES" do
-    it "contains the supported SSL verify modes" do
-      expect(HTTPI::Auth::SSL::VERIFY_MODES).to eq([:none, :peer, :fail_if_no_peer_cert, :client_once])
-    end
-  end
-
-  describe "#present?" do
-    it "defaults to return false" do
-      ssl = HTTPI::Auth::SSL.new
-      expect(ssl).not_to be_present
-    end
-
-    it "returns false if only a client key was specified" do
-      ssl = HTTPI::Auth::SSL.new
-      ssl.cert_key_file = "spec/fixtures/client_key.pem"
-
-      expect(ssl).not_to be_present
-    end
-
-    it "returns false if only a client key was specified" do
-      ssl = HTTPI::Auth::SSL.new
-      ssl.cert_file = "spec/fixtures/client_cert.pem"
-
-      expect(ssl).not_to be_present
-    end
-
-    it "returns true if both client key and cert are present" do
-      expect(ssl).to be_present
-    end
-
-    it "returns true of the verify_mode is :none" do
-      ssl = HTTPI::Auth::SSL.new
-      ssl.verify_mode = :none
-      expect(ssl).to be_present
-    end
-  end
-
-  describe "#verify_mode" do
-    it "defaults to return :peer" do
-      expect(ssl.verify_mode).to eq(:peer)
-    end
-
-    it "sets the verify mode to use" do
-      ssl = HTTPI::Auth::SSL.new
-
-      ssl.verify_mode = :none
-      expect(ssl.verify_mode).to eq(:none)
-    end
-
-    it "raises an ArgumentError if the given mode is not supported" do
-      expect { ssl.verify_mode = :invalid }.
-        to raise_error(ArgumentError, "Invalid SSL verify mode :invalid\n" +
-                                      "Please specify one of [:none, :peer, :fail_if_no_peer_cert, :client_once]")
-    end
-  end
-
-  describe "#cert" do
-    it "returns an OpenSSL::X509::Certificate for the given cert_file" do
-      expect(ssl.cert).to be_a(OpenSSL::X509::Certificate)
-    end
-
-    it "returns nil if no cert_file was given" do
-      ssl = HTTPI::Auth::SSL.new
-      expect(ssl.cert).to be_nil
-    end
-
-    it "returns the explicitly given certificate if set" do
-      ssl = HTTPI::Auth::SSL.new
-      cert = OpenSSL::X509::Certificate.new
-      ssl.cert = cert
-      expect(ssl.cert).to eq(cert)
-    end
-  end
-
-  describe "#cert_key" do
-    it "returns a OpenSSL::PKey::RSA for the given cert_key" do
-      expect(ssl.cert_key).to be_a(OpenSSL::PKey::RSA)
-    end
-
-    it "returns nil if no cert_key_file was given" do
-      ssl = HTTPI::Auth::SSL.new
-      expect(ssl.cert_key).to be_nil
-    end
-
-    it "returns the explicitly given key if set" do
-      ssl = HTTPI::Auth::SSL.new
-      key = OpenSSL::PKey::RSA.new
-      ssl.cert_key = key
-      expect(ssl.cert_key).to eq(key)
-    end
-  end
-
-  describe "#ca_cert" do
-    it "returns an OpenSSL::X509::Certificate for the given ca_cert_file" do
-      ssl = HTTPI::Auth::SSL.new
-
-      ssl.ca_cert_file = "spec/fixtures/client_cert.pem"
-      expect(ssl.ca_cert).to be_a(OpenSSL::X509::Certificate)
-    end
-  end
-
-  describe "#openssl_verify_mode" do
-    it "returns the OpenSSL verify mode for :none" do
-      ssl = HTTPI::Auth::SSL.new
-
-      ssl.verify_mode = :none
-      expect(ssl.openssl_verify_mode).to eq(OpenSSL::SSL::VERIFY_NONE)
-    end
-
-    it "returns the OpenSSL verify mode for :peer" do
-      ssl = HTTPI::Auth::SSL.new
-
-      ssl.verify_mode = :peer
-      expect(ssl.openssl_verify_mode).to eq(OpenSSL::SSL::VERIFY_PEER)
-    end
-
-    it "returns the OpenSSL verify mode for :fail_if_no_peer_cert" do
-      ssl = HTTPI::Auth::SSL.new
-
-      ssl.verify_mode = :fail_if_no_peer_cert
-      expect(ssl.openssl_verify_mode).to eq(OpenSSL::SSL::VERIFY_FAIL_IF_NO_PEER_CERT)
-    end
-
-    it "returns the OpenSSL verify mode for :client_once" do
-      ssl = HTTPI::Auth::SSL.new
-
-      ssl.verify_mode = :client_once
-      expect(ssl.openssl_verify_mode).to eq(OpenSSL::SSL::VERIFY_CLIENT_ONCE)
-    end
-  end
-
-  describe "SSL_VERSIONS" do
-    it "contains the supported SSL versions" do
-      expect(HTTPI::Auth::SSL::SSL_VERSIONS).to eq(@ssl_versions)
-    end
-  end
-
-  describe "#ssl_version" do
-    subject { HTTPI::Auth::SSL.new }
-
-    it "returns the SSL version" do
-      subject.ssl_version = @ssl_versions.first
-      expect(subject.ssl_version).to eq(@ssl_versions.first)
-    end
-
-    it 'raises ArgumentError if the version is unsupported' do
-      expect { ssl.ssl_version = :ssl_fail }.
-        to raise_error(ArgumentError, "Invalid SSL version :ssl_fail\n" +
-                                      "Please specify one of #{@ssl_versions}")
-    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"
-    ssl.cert_file = "spec/fixtures/client_cert.pem"
-    ssl
-  end
-
-end

data/spec/httpi/cookie_spec.rb

@@ -1,36 +0,0 @@
-require "spec_helper"
-require "httpi"
-
-describe HTTPI::Cookie do
-
-  let(:cookie) { HTTPI::Cookie.new("token=choc-choc-chip; Path=/; HttpOnly") }
-
-  describe ".list_from_headers" do
-    it "returns a list of cookies from a Hash of headers" do
-      headers = { "Set-Cookie" => "token=strawberry; Path=/; HttpOnly" }
-      cookies = HTTPI::Cookie.list_from_headers(headers)
-
-      expect(cookies.size).to eq(1)
-      expect(cookies.first).to be_a(HTTPI::Cookie)
-    end
-
-    it "handles multiple cookies" do
-      headers = { "Set-Cookie" => ["user=chucknorris; Path=/; HttpOnly", "token=strawberry; Path=/; HttpOnly"] }
-      cookies = HTTPI::Cookie.list_from_headers(headers)
-      expect(cookies.size).to eq(2)
-    end
-  end
-
-  describe "#name" do
-    it "returns the name of the cookie" do
-      expect(cookie.name).to eq("token")
-    end
-  end
-
-  describe "#name_and_value" do
-    it "returns the name and value of the cookie" do
-      expect(cookie.name_and_value).to eq("token=choc-choc-chip")
-    end
-  end
-
-end

data/spec/httpi/cookie_store_spec.rb

@@ -1,26 +0,0 @@
-require "spec_helper"
-require "httpi"
-
-describe HTTPI::CookieStore do
-
-  let(:user_cookie)  { some_cookie(:user, "chucknorris") }
-  let(:token_cookie) { some_cookie(:token, "strawberry") }
-
-  it "stores a set of cookies" do
-    cookie_store = HTTPI::CookieStore.new
-    cookie_store.add(user_cookie, token_cookie)
-    expect(cookie_store.fetch).to include("user=chucknorris", "token=strawberry")
-
-    # add a new token cookie with a different value
-    token_cookie = some_cookie(:token, "choc-choc-chip")
-    cookie_store.add(token_cookie)
-
-    expect(cookie_store.fetch).to include("token=choc-choc-chip")
-    expect(cookie_store.fetch).not_to include("token=strawberry")
-  end
-
-  def some_cookie(name, value)
-    HTTPI::Cookie.new("#{name}=#{value}; Path=/; HttpOnly")
-  end
-
-end

data/spec/httpi/error_spec.rb

@@ -1,43 +0,0 @@
-require "spec_helper"
-require "support/error_helper"
-
-describe HTTPI do
-  include ErrorHelper
-
-  context "with :httpclient" do
-    it "tags Errno::ECONNREFUSED with HTTPI::ConnectionError" do
-      expect_error(Errno::ECONNREFUSED, "Connection refused - connect(2)").to be_tagged_with(HTTPI::ConnectionError)
-    end
-
-    def fake_error(error, message)
-      request(:httpclient) { |client| client.expects(:request).raises(error, message) }
-    end
-  end
-
-  unless RUBY_PLATFORM =~ /java/
-    context "with :curb" do
-      it "tags Curl::Err::ConnectionFailedError with HTTPI::ConnectionError" do
-        expect_error(Curl::Err::ConnectionFailedError, "Curl::Err::ConnectionFailedError").to be_tagged_with(HTTPI::ConnectionError)
-      end
-
-      def fake_error(error, message)
-        request(:curb) { |client| client.expects(:send).raises(error, message) }
-      end
-    end
-  end
-
-  context "with :net_http" do
-    it "tags Errno::ECONNREFUSED with HTTPI::ConnectionError" do
-      expect_error(Errno::ECONNREFUSED, "Connection refused - connect(2)").to be_tagged_with(HTTPI::ConnectionError)
-    end
-
-    def fake_error(error, message)
-      request(:net_http) { |client| client.expects(:start).raises(error, message) }
-    end
-  end
-
-  def request(adapter)
-    HTTPI.get("http://example.com", adapter) { |client| yield client }
-  end
-
-end

data/spec/httpi/httpi_spec.rb

@@ -1,382 +0,0 @@
-require "spec_helper"
-require "integration/support/server"
-
-# find out why httpi doesn't load these automatically. [dh, 2012-12-15]
-require "excon"
-require "net/http/persistent"
-require "http"
-
-unless RUBY_PLATFORM =~ /java/
-  require "em-synchrony"
-  require "em-http-request"
-  require "curb"
-end
-
-describe HTTPI do
-  let(:client) { HTTPI }
-  let(:httpclient) { HTTPI::Adapter.load(:httpclient) }
-  let(:net_http) { HTTPI::Adapter.load(:net_http) }
-  let(:net_http_persistent) { HTTPI::Adapter.load(:net_http_persistent) }
-
-  before(:all) do
-    HTTPI::Adapter::Rack.mount('example.com', IntegrationServer::Application)
-  end
-
-  after(:all) do
-    HTTPI::Adapter::Rack.unmount('example.com')
-  end
-
-  describe ".adapter=" do
-    it "sets the default adapter to use" do
-      HTTPI::Adapter.expects(:use=).with(:net_http)
-      HTTPI.adapter = :net_http
-    end
-  end
-
-  describe ".adapter_client_setup=" do
-    after do
-      HTTPI.adapter_client_setup = nil
-    end
-
-    it "sets the adapter client setup block" do
-      block = proc { }
-      HTTPI.adapter_client_setup = block
-      expect(HTTPI::Adapter.client_setup_block).to eq(block)
-    end
-  end
-
-  describe ".query_builder" do
-    it "gets flat builder by default" do
-      expect(client.query_builder).to eq(HTTPI::QueryBuilder::Flat)
-    end
-    context "setter" do
-      after { client.query_builder = HTTPI::QueryBuilder::Flat }
-      it "looks up for class if symbol" do
-        client.query_builder = :nested
-        expect(client.query_builder).to eq(HTTPI::QueryBuilder::Nested)
-      end
-      it "validates if symbol is a valid option" do
-        expect do
-          client.query_builder = :xxx
-        end.to raise_error(ArgumentError)
-      end
-      it "validates if value respond to build" do
-        expect do
-          client.query_builder = nil
-        end.to raise_error(ArgumentError)
-      end
-      it "accepts valid class" do
-        client.query_builder = HTTPI::QueryBuilder::Nested
-        expect(client.query_builder).to eq(HTTPI::QueryBuilder::Nested)
-      end
-    end
-  end
-
-  describe ".get(request)" do
-    it "executes a GET request using the default adapter" do
-      request = HTTPI::Request.new("http://example.com")
-      httpclient.any_instance.expects(:request).with(:get)
-
-      client.get(request)
-    end
-  end
-
-  describe ".get(request, adapter)" do
-    it "executes a GET request using the given adapter" do
-      request = HTTPI::Request.new("http://example.com")
-      net_http.any_instance.expects(:request).with(:get)
-
-      client.get(request, :net_http)
-    end
-  end
-
-  describe ".get(url)" do
-    it "executes a GET request using the default adapter" do
-      httpclient.any_instance.expects(:request).with(:get)
-      client.get("http://example.com")
-    end
-  end
-
-  describe ".get(url, adapter)" do
-    it "executes a GET request using the given adapter" do
-      net_http.any_instance.expects(:request).with(:get)
-      client.get("http://example.com", :net_http)
-    end
-  end
-
-  describe ".post(request)" do
-    it "executes a POST request using the default adapter" do
-      request = HTTPI::Request.new("http://example.com")
-      httpclient.any_instance.expects(:request).with(:post)
-
-      client.post(request)
-    end
-  end
-
-  describe ".post(request, adapter)" do
-    it "executes a POST request using the given adapter" do
-      request = HTTPI::Request.new("http://example.com")
-      net_http.any_instance.expects(:request).with(:post, anything)
-
-      client.post(request, :net_http)
-    end
-  end
-
-  describe ".post(url, body)" do
-    it "executes a POST request using the default adapter" do
-      httpclient.any_instance.expects(:request).with(:post)
-      client.post("http://example.com", "<some>xml</some>")
-    end
-  end
-
-  describe ".post(url, body, adapter)" do
-    it "executes a POST request using the given adapter" do
-      net_http.any_instance.expects(:request).with(:post)
-      client.post("http://example.com", "<some>xml</some>", :net_http)
-    end
-  end
-
-  describe ".head(request)" do
-    it "executes a HEAD request using the default adapter" do
-      request = HTTPI::Request.new("http://example.com")
-      httpclient.any_instance.expects(:request).with(:head, anything)
-
-      client.head(request)
-    end
-  end
-
-  describe ".head(request, adapter)" do
-    it "executes a HEAD request using the given adapter" do
-      request = HTTPI::Request.new("http://example.com")
-      net_http.any_instance.expects(:request).with(:head, anything)
-
-      client.head(request, :net_http)
-    end
-  end
-
-  describe ".head(url)" do
-    it "executes a HEAD request using the default adapter" do
-      httpclient.any_instance.expects(:request).with(:head)
-      client.head("http://example.com")
-    end
-  end
-
-  describe ".head(url, adapter)" do
-    it "executes a HEAD request using the given adapter" do
-      net_http.any_instance.expects(:request).with(:head)
-      client.head("http://example.com", :net_http)
-    end
-  end
-
-  describe ".put(request)" do
-    it "executes a PUT request using the default adapter" do
-      request = HTTPI::Request.new("http://example.com")
-      httpclient.any_instance.expects(:request).with(:put, anything)
-
-      client.put(request)
-    end
-  end
-
-  describe ".put(request, adapter)" do
-    it "executes a PUT request using the given adapter" do
-      request = HTTPI::Request.new("http://example.com")
-      net_http.any_instance.expects(:request).with(:put, anything)
-
-      client.put(request, :net_http)
-    end
-  end
-
-  describe ".put(url, body)" do
-    it "executes a PUT request using the default adapter" do
-      httpclient.any_instance.expects(:request).with(:put)
-      client.put("http://example.com", "<some>xml</some>")
-    end
-  end
-
-  describe ".put(url, body, adapter)" do
-    it "executes a PUT request using the given adapter" do
-      net_http.any_instance.expects(:request).with(:put)
-      client.put("http://example.com", "<some>xml</some>", :net_http)
-    end
-  end
-
-  describe ".delete(request)" do
-    it "executes a DELETE request using the default adapter" do
-      request = HTTPI::Request.new("http://example.com")
-      httpclient.any_instance.expects(:request).with(:delete, anything)
-
-      client.delete(request)
-    end
-  end
-
-  describe ".delete(request, adapter)" do
-    it "executes a DELETE request using the given adapter" do
-      request = HTTPI::Request.new("http://example.com")
-      net_http.any_instance.expects(:request).with(:delete, anything)
-
-      client.delete(request, :net_http)
-    end
-  end
-
-  describe ".delete(url)" do
-    it "executes a DELETE request using the default adapter" do
-      httpclient.any_instance.expects(:request).with(:delete)
-      client.delete("http://example.com")
-    end
-  end
-
-  describe ".delete(url, adapter)" do
-    it "executes a DELETE request using the given adapter" do
-      net_http.any_instance.expects(:request).with(:delete)
-      client.delete("http://example.com", :net_http)
-    end
-  end
-
-  describe ".request" do
-    let(:request) { HTTPI::Request.new('http://example.com/foo/') }
-
-    it "allows custom HTTP methods" do
-      httpclient.any_instance.expects(:request).with(:custom)
-
-      client.request(:custom, request, :httpclient)
-    end
-
-    it 'follows redirects' do
-      request.follow_redirect = true
-      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).twice.with(:custom).returns(redirect, response)
-      request.expects(:url=).with(URI.parse(redirect_location))
-
-      client.request(:custom, request, :httpclient)
-    end
-
-    it 'follows redirects with absolute path' do
-      request.follow_redirect = true
-      redirect_location = '/bar/foo'
-
-      redirect = HTTPI::Response.new(302, {'location' => redirect_location}, 'Moved')
-      response = HTTPI::Response.new(200, {}, 'success')
-
-      httpclient.any_instance.expects(:request).twice.with(:custom).returns(redirect, response)
-      request.expects(:url=).with(URI.parse('http://example.com/bar/foo'))
-
-      client.request(:custom, request, :httpclient)
-    end
-
-    it 'follows redirects with relative path' do
-      request.follow_redirect = true
-      redirect_location = 'bar/foo'
-
-      redirect = HTTPI::Response.new(302, {'location' => redirect_location}, 'Moved')
-      response = HTTPI::Response.new(200, {}, 'success')
-
-      httpclient.any_instance.expects(:request).twice.with(:custom).returns(redirect, response)
-      request.expects(:url=).with(URI.parse('http://example.com/foo/bar/foo'))
-
-      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
-
-    describe "client setup block present" do
-      around do |example|
-        HTTPI::Adapter.client_setup_block = proc { |client| client.base_url = 'https://google.com'  }
-        example.run
-        HTTPI::Adapter.client_setup_block = nil
-      end
-
-      it 'calls client setup block' do
-        client.request(:get, request, :httpclient) { |client| expect(client.base_url).to eq('https://google.com') }
-      end
-    end
-  end
-
-  HTTPI::REQUEST_METHODS.each do |method|
-    describe ".#{method}" do
-      let(:request) { HTTPI::Request.new("http://example.com") }
-
-      it "raises an ArgumentError in case of an invalid adapter" do
-        expect { client.request method, request, :invalid }.to raise_error(ArgumentError)
-      end
-
-      HTTPI::Adapter::ADAPTERS.each do |adapter, opts|
-        unless (adapter == :em_http || adapter == :curb) && RUBY_PLATFORM =~ /java/
-          client_class = {
-            :httpclient => lambda { HTTPClient },
-            :curb       => lambda { Curl::Easy },
-            :net_http   => lambda { Net::HTTP },
-            :net_http_persistent => lambda { Net::HTTP::Persistent },
-            :em_http    => lambda { EventMachine::HttpConnection },
-            :rack       => lambda { Rack::MockRequest },
-            :excon      => lambda { Excon::Connection },
-            :http       => lambda { ::HTTP::Client }
-          }
-
-          context "using #{adapter}" do
-            before { opts[:class].any_instance.expects(:request).with(method) }
-
-            it "#request yields the HTTP client instance" do
-              expect { |b| client.request(method, request, adapter, &b) }.to yield_with_args(client_class[adapter].call)
-            end
-
-            it "##{method} yields the HTTP client instance" do
-              expect { |b| client.send(method, request, adapter, &b) }.to yield_with_args(client_class[adapter].call)
-            end
-          end
-        end
-      end
-    end
-  end
-
-  context "(with reset)" do
-    before { HTTPI.reset_config! }
-
-    after do
-      HTTPI.reset_config!
-      HTTPI.log = false  # disable for specs
-    end
-
-    describe ".log" do
-      it "defaults to true" do
-        expect(HTTPI.log?).to be_truthy
-      end
-    end
-
-    describe ".logger" do
-      it "defaults to Logger writing to STDOUT" do
-        expect(HTTPI.logger).to be_a(Logger)
-      end
-    end
-
-    describe ".log_level" do
-      it "defaults to :debug" do
-        expect(HTTPI.log_level).to eq(:debug)
-      end
-    end
-
-    describe ".log" do
-      it "logs the given messages" do
-        HTTPI.log_level = :info
-        HTTPI.logger.expects(:info).with("Log this")
-        HTTPI.log "Log this"
-      end
-    end
-  end
-
-end