httparty 0.13.3 → 0.13.4

data/lib/httparty/connection_adapter.rb

@@ -50,7 +50,6 @@ module HTTParty
   # * :+ssl_ca_path+: see HTTParty::ClassMethods.ssl_ca_path.
   # * :+connection_adapter_options+: contains the hash you passed to HTTParty.connection_adapter when you configured your connection adapter
   class ConnectionAdapter
-
     # Private: Regex used to strip brackets from IPv6 URIs.
     StripIpv6BracketsRegex = /\A\[(.*)\]\z/
 
@@ -61,8 +60,8 @@ module HTTParty
 
     attr_reader :uri, :options
 
-    def initialize(uri, options={})
-      raise ArgumentError, "uri must be a URI, not a #{uri.class}" unless uri.kind_of? URI
+    def initialize(uri, options = {})
+      raise ArgumentError, "uri must be a URI, not a #{uri.class}" unless uri.is_a? URI
 
       @uri = uri
       @options = options
@@ -120,7 +119,7 @@ module HTTParty
         end
       end
 
-      return http
+      http
     end
 
     private

data/lib/httparty/cookie_hash.rb

@@ -1,6 +1,5 @@
 class HTTParty::CookieHash < Hash #:nodoc:
-
-  CLIENT_COOKIES = %w{path expires domain path secure httponly}
+  CLIENT_COOKIES = %w(path expires domain path secure httponly)
 
   def add_cookies(value)
     case value
@@ -8,7 +7,7 @@ class HTTParty::CookieHash < Hash #:nodoc:
       merge!(value)
     when String
       value.split('; ').each do |cookie|
-        array = cookie.split('=',2)
+        array = cookie.split('=', 2)
         self[array[0].to_sym] = array[1]
       end
     else

data/lib/httparty/hash_conversions.rb

@@ -12,9 +12,7 @@ module HTTParty
     #   }.to_params
     #     #=> "name=Bob&address[city]=Ruby Central&address[phones][]=111-111-1111&address[phones][]=222-222-2222&address[street]=111 Ruby Ave."
     def self.to_params(hash)
-      params = hash.to_hash.map { |k,v| normalize_param(k,v) }.join
-      params.chop! # trailing &
-      params
+      hash.to_hash.map { |k, v| normalize_param(k, v) }.join.chop
     end
 
     # @param key<Object> The key for the param.
@@ -30,9 +28,9 @@ module HTTParty
       if value.respond_to?(:to_ary)
         param << value.to_ary.map { |element| normalize_param("#{key}[]", element) }.join
       elsif value.respond_to?(:to_hash)
-        stack << [key,value.to_hash]
+        stack << [key, value.to_hash]
       else
-        param << "#{key}=#{URI.encode(value.to_s, Regexp.new("[^#{URI::PATTERN::UNRESERVED}]"))}&"
+        param << "#{key}=#{ERB::Util.url_encode(value.to_s)}&"
       end
 
       stack.each do |parent, hash|

data/lib/httparty/logger/apache_logger.rb

@@ -15,7 +15,7 @@ module HTTParty
         http_method    = request.http_method.name.split("::").last.upcase
         path           = request.path.to_s
         content_length = response.respond_to?(:headers) ? response.headers['Content-Length'] : response['Content-Length']
-        @logger.send @level, "[#{TAG_NAME}] [#{current_time}] #{response.code} \"#{http_method} #{path}\" #{content_length || "-"} "
+        @logger.send @level, "[#{TAG_NAME}] [#{current_time}] #{response.code} \"#{http_method} #{path}\" #{content_length || '-'} "
       end
     end
   end

data/lib/httparty/logger/logger.rb

@@ -4,7 +4,7 @@ require 'httparty/logger/curl_logger'
 module HTTParty
   module Logger
     def self.build(logger, level, formatter)
-      level  ||= :info
+      level ||= :info
       formatter ||= :apache
 
       case formatter

data/lib/httparty/module_inheritable_attributes.rb

@@ -10,7 +10,7 @@ module HTTParty
 
       duplicate.each_pair do |key, value|
         duplicate[key] = if value.is_a?(Hash)
-          hash_deep_dup(value)
+                           hash_deep_dup(value)
         elsif value.is_a?(Proc)
           duplicate[key] = value.dup
         else

data/lib/httparty/net_digest_auth.rb

@@ -4,10 +4,22 @@ require 'net/http'
 module Net
   module HTTPHeader
     def digest_auth(username, password, response)
-      @header['Authorization'] = DigestAuthenticator.new(username, password,
-          @method, @path, response).authorization_header
+      authenticator = DigestAuthenticator.new(
+        username,
+        password,
+        @method,
+        @path,
+        response
+      )
+
+      @header['Authorization'] = authenticator.authorization_header
+      @header['cookie'] = append_cookies(authenticator) if response['Set-Cookie']
     end
 
+    def append_cookies(authenticator)
+      cookies = @header['cookie'] ? @header['cookie'] : []
+      cookies.concat(authenticator.cookie_header)
+    end
 
     class DigestAuthenticator
       def initialize(username, password, method, path, response_header)
@@ -16,36 +28,41 @@ module Net
         @method   = method
         @path     = path
         @response = parse(response_header)
+        @cookies  = parse_cookies(response_header)
       end
 
       def authorization_header
         @cnonce = md5(random)
         header = [
-          %Q(Digest username="#{@username}"),
-          %Q(realm="#{@response['realm']}"),
-          %Q(nonce="#{@response['nonce']}"),
-          %Q(uri="#{@path}"),
-          %Q(response="#{request_digest}"),
+          %(Digest username="#{@username}"),
+          %(realm="#{@response['realm']}"),
+          %(nonce="#{@response['nonce']}"),
+          %(uri="#{@path}"),
+          %(response="#{request_digest}")
         ]
 
         if qop_present?
           fields = [
-            %Q(cnonce="#{@cnonce}"),
-            %Q(qop="#{@response['qop']}"),
-            %Q(nc=00000001)
+            %(cnonce="#{@cnonce}"),
+            %(qop="#{@response['qop']}"),
+            "nc=00000001"
           ]
           fields.each { |field| header << field }
         end
 
-        header << %Q(opaque="#{@response['opaque']}") if opaque_present?
+        header << %(opaque="#{@response['opaque']}") if opaque_present?
         header
       end
 
-    private
+      def cookie_header
+        @cookies
+      end
+
+      private
 
       def parse(response_header)
         header = response_header['www-authenticate']
-          .gsub(/qop=(auth(?:-int)?)/, %Q(qop="\\1"))
+                 .gsub(/qop=(auth(?:-int)?)/, 'qop="\\1"')
 
         header =~ /Digest (.*)/
         params = {}
@@ -53,16 +70,29 @@ module Net
         params
       end
 
+      def parse_cookies(response_header)
+        return [] unless response_header['Set-Cookie']
+
+        cookies = response_header['Set-Cookie'].split('; ')
+
+        cookies.reduce([]) do |ret, cookie|
+          ret << cookie
+          ret
+        end
+
+        cookies
+      end
+
       def opaque_present?
-        @response.has_key?('opaque') and not @response['opaque'].empty?
+        @response.key?('opaque') && !@response['opaque'].empty?
       end
 
       def qop_present?
-        @response.has_key?('qop') and not @response['qop'].empty?
+        @response.key?('qop') && !@response['qop'].empty?
       end
 
       def random
-        "%x" % (Time.now.to_i + rand(65535))
+        format "%x", (Time.now.to_i + rand(65535))
       end
 
       def request_digest

data/lib/httparty/request.rb

@@ -14,12 +14,12 @@ module HTTParty
 
     SupportedURISchemes  = [URI::HTTP, URI::HTTPS, URI::Generic]
 
-    NON_RAILS_QUERY_STRING_NORMALIZER = Proc.new do |query|
+    NON_RAILS_QUERY_STRING_NORMALIZER = proc do |query|
       Array(query).sort_by { |a| a[0].to_s }.map do |key, value|
         if value.nil?
           key.to_s
         elsif value.respond_to?(:to_ary)
-          value.to_ary.map {|v| "#{key}=#{URI.encode(v.to_s, Regexp.new("[^#{URI::PATTERN::UNRESERVED}]"))}"}
+          value.to_ary.map {|v| "#{key}=#{ERB::Util.url_encode(v.to_s)}"}
         else
           HashConversions.to_params(key => value)
         end
@@ -29,7 +29,7 @@ module HTTParty
     attr_accessor :http_method, :options, :last_response, :redirect, :last_uri
     attr_reader :path
 
-    def initialize(http_method, path, o={})
+    def initialize(http_method, path, o = {})
       self.http_method = http_method
       self.path = path
       self.options = {
@@ -57,7 +57,10 @@ module HTTParty
 
     def uri
       if redirect && path.relative? && path.path[0] != "/"
-        path.path = @last_uri.path.gsub(/[^\/]+$/, "") + path.path
+        last_uri_host = @last_uri.path.gsub(/[^\/]+$/, "")
+
+        path.path = "/#{path.path}" if last_uri_host[-1] != "/"
+        path.path = last_uri_host + path.path
       end
 
       new_uri = path.relative? ? URI.parse("#{base_uri}#{path}") : path.clone
@@ -164,7 +167,7 @@ module HTTParty
       auth_request.initialize_http_header(options[:headers].to_hash) if options[:headers].respond_to?(:to_hash)
       res = http.request(auth_request)
 
-      if res['www-authenticate'] != nil && res['www-authenticate'].length > 0
+      if !res['www-authenticate'].nil? && res['www-authenticate'].length > 0
         @raw_request.digest_auth(username, password, res)
       end
     end
@@ -202,12 +205,10 @@ module HTTParty
     end
 
     def encode_with_ruby_encoding(body, charset)
-      begin
-        encoding = Encoding.find(charset)
-        body.force_encoding(encoding)
-      rescue
-        body
-      end
+      encoding = Encoding.find(charset)
+      body.force_encoding(encoding)
+    rescue
+      body
     end
 
     def assume_utf16_is_big_endian
@@ -228,7 +229,6 @@ module HTTParty
       else
         body.force_encoding("UTF-16LE")
       end
-
     end
 
     def _encode_body(body)
@@ -263,7 +263,7 @@ module HTTParty
         self.path = last_response['location']
         self.redirect = true
         if last_response.class == Net::HTTPSeeOther
-          unless options[:maintain_method_across_redirects] and options[:resend_on_redirect]
+          unless options[:maintain_method_across_redirects] && options[:resend_on_redirect]
             self.http_method = Net::HTTP::Get
           end
         else
@@ -274,7 +274,7 @@ module HTTParty
         capture_cookies(last_response)
         perform(&block)
       else
-        body = body || last_response.body
+        body ||= last_response.body
         body = encode_body(body)
         Response.new(self, last_response, lambda { parse_response(body) }, body: body)
       end
@@ -311,7 +311,7 @@ module HTTParty
 
     def capture_cookies(response)
       return unless response['Set-Cookie']
-      cookies_hash = HTTParty::CookieHash.new()
+      cookies_hash = HTTParty::CookieHash.new
       cookies_hash.add_cookies(options[:headers].to_hash['Cookie']) if options[:headers] && options[:headers].to_hash['Cookie']
       response.get_fields('Set-Cookie').each { |cookie| cookies_hash.add_cookies(cookie) }
       options[:headers] ||= {}
@@ -344,7 +344,7 @@ module HTTParty
     def set_basic_auth_from_uri
       if path.userinfo
         username, password = path.userinfo.split(':')
-        options[:basic_auth] = {:username => username, :password => password}
+        options[:basic_auth] = {username: username, password: password}
       end
     end
   end

data/lib/httparty/response.rb

@@ -1,12 +1,12 @@
 module HTTParty
-  class Response < HTTParty::BasicObject #:nodoc:
+  class Response < BasicObject
     def self.underscore(string)
-      string.gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').gsub(/([a-z])([A-Z])/,'\1_\2').downcase
+      string.gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2').gsub(/([a-z])([A-Z])/, '\1_\2').downcase
     end
 
     attr_reader :request, :response, :body, :headers
 
-    def initialize(request, response, parsed_block, options={})
+    def initialize(request, response, parsed_block, options = {})
       @request      = request
       @response     = response
       @body         = options[:body] || response.body
@@ -31,8 +31,13 @@ module HTTParty
       response.code.to_i
     end
 
+    def tap
+      yield self
+      self
+    end
+
     def inspect
-      inspect_id = "%x" % (object_id * 2)
+      inspect_id = format "%x", (object_id * 2)
       %(#<#{self.class}:0x#{inspect_id} parsed_response=#{parsed_response.inspect}, @response=#{response.inspect}, @headers=#{headers.inspect}>)
     end
 

data/lib/httparty/version.rb

@@ -1,3 +1,3 @@
 module HTTParty
-  VERSION = "0.13.3"
+  VERSION = "0.13.4"
 end

data/spec/httparty/connection_adapter_spec.rb

@@ -1,7 +1,6 @@
 require File.expand_path(File.join(File.dirname(__FILE__), '..', 'spec_helper'))
 
-describe HTTParty::ConnectionAdapter do
-
+RSpec.describe HTTParty::ConnectionAdapter do
   describe "initialization" do
     let(:uri) { URI 'http://www.google.com' }
     it "takes a URI as input" do
@@ -18,7 +17,7 @@ describe HTTParty::ConnectionAdapter do
 
     it "sets the uri" do
       adapter = HTTParty::ConnectionAdapter.new(uri)
-      adapter.uri.should be uri
+      expect(adapter.uri).to be uri
     end
 
     it "also accepts an optional options hash" do
@@ -28,22 +27,22 @@ describe HTTParty::ConnectionAdapter do
     it "sets the options" do
       options = {foo: :bar}
       adapter = HTTParty::ConnectionAdapter.new(uri, options)
-      adapter.options.should be options
+      expect(adapter.options).to be options
     end
   end
 
   describe ".call" do
     it "generates an HTTParty::ConnectionAdapter instance with the given uri and options" do
-      HTTParty::ConnectionAdapter.should_receive(:new).with(@uri, @options).and_return(stub(connection: nil))
+      expect(HTTParty::ConnectionAdapter).to receive(:new).with(@uri, @options).and_return(double(connection: nil))
       HTTParty::ConnectionAdapter.call(@uri, @options)
     end
 
     it "calls #connection on the connection adapter" do
-      adapter = mock('Adapter')
-      connection = mock('Connection')
-      adapter.should_receive(:connection).and_return(connection)
-      HTTParty::ConnectionAdapter.stub(new: adapter)
-      HTTParty::ConnectionAdapter.call(@uri, @options).should be connection
+      adapter = double('Adapter')
+      connection = double('Connection')
+      expect(adapter).to receive(:connection).and_return(connection)
+      allow(HTTParty::ConnectionAdapter).to receive_messages(new: adapter)
+      expect(HTTParty::ConnectionAdapter.call(@uri, @options)).to be connection
     end
   end
 
@@ -54,52 +53,51 @@ describe HTTParty::ConnectionAdapter do
 
     describe "the resulting connection" do
       subject { adapter.connection }
-      it { should be_an_instance_of Net::HTTP }
+      it { is_expected.to be_an_instance_of Net::HTTP }
 
       context "using port 80" do
         let(:uri) { URI 'http://foobar.com' }
-        it { should_not use_ssl }
+        it { is_expected.not_to use_ssl }
       end
 
       context "when dealing with ssl" do
         let(:uri) { URI 'https://foobar.com' }
 
         context "uses the system cert_store, by default" do
-          let(:system_cert_store) do
-            system_cert_store = mock('default_cert_store')
-            system_cert_store.should_receive(:set_default_paths)
-            OpenSSL::X509::Store.should_receive(:new).and_return(system_cert_store)
+          let!(:system_cert_store) do
+            system_cert_store = double('default_cert_store')
+            expect(system_cert_store).to receive(:set_default_paths)
+            expect(OpenSSL::X509::Store).to receive(:new).and_return(system_cert_store)
             system_cert_store
           end
-          it { should use_cert_store(system_cert_store) }
+          it { is_expected.to use_cert_store(system_cert_store) }
         end
 
         context "should use the specified cert store, when one is given" do
-          let(:custom_cert_store) { mock('custom_cert_store') }
+          let(:custom_cert_store) { double('custom_cert_store') }
           let(:options) { {cert_store: custom_cert_store} }
-          it { should use_cert_store(custom_cert_store) }
+          it { is_expected.to use_cert_store(custom_cert_store) }
         end
 
         context "using port 443 for ssl" do
           let(:uri) { URI 'https://api.foo.com/v1:443' }
-          it { should use_ssl }
+          it { is_expected.to use_ssl }
         end
 
         context "https scheme with default port" do
-          it { should use_ssl }
+          it { is_expected.to use_ssl }
         end
 
         context "https scheme with non-standard port" do
           let(:uri) { URI 'https://foobar.com:123456' }
-          it { should use_ssl }
+          it { is_expected.to use_ssl }
         end
 
-
         context "when ssl version is set" do
           let(:options) { {ssl_version: :TLSv1} }
 
           it "sets ssl version" do
-            subject.ssl_version.should == :TLSv1
+            expect(subject.ssl_version).to eq(:TLSv1)
           end
         end if RUBY_VERSION > '1.9'
       end
@@ -108,7 +106,7 @@ describe HTTParty::ConnectionAdapter do
         let(:uri) { URI 'http://[fd00::1]' }
 
         it "strips brackets from the address" do
-          subject.address.should == 'fd00::1'
+          expect(subject.address).to eq('fd00::1')
         end
       end
 
@@ -116,16 +114,21 @@ describe HTTParty::ConnectionAdapter do
         let(:options) { {ciphers: 'RC4-SHA' } }
 
         it "should set the ciphers on the connection" do
-          subject.ciphers.should == 'RC4-SHA'
+          expect(subject.ciphers).to eq('RC4-SHA')
         end
       end if RUBY_VERSION > '1.9'
 
       context "when timeout is not set" do
         it "doesn't set the timeout" do
-          http = mock("http", null_object: true)
-          http.should_not_receive(:open_timeout=)
-          http.should_not_receive(:read_timeout=)
-          Net::HTTP.stub(new: http)
+          http = double(
+            "http",
+            :null_object => true,
+            :use_ssl= => false,
+            :use_ssl? => false
+          )
+          expect(http).not_to receive(:open_timeout=)
+          expect(http).not_to receive(:read_timeout=)
+          allow(Net::HTTP).to receive_messages(new: http)
 
           adapter.connection
         end
@@ -135,18 +138,30 @@ describe HTTParty::ConnectionAdapter do
         context "to 5 seconds" do
           let(:options) { {timeout: 5} }
 
-          its(:open_timeout) { should == 5 }
-          its(:read_timeout) { should == 5 }
+          describe '#open_timeout' do
+            subject { super().open_timeout }
+            it { is_expected.to eq(5) }
+          end
+
+          describe '#read_timeout' do
+            subject { super().read_timeout }
+            it { is_expected.to eq(5) }
+          end
         end
 
         context "and timeout is a string" do
           let(:options) { {timeout: "five seconds"} }
 
           it "doesn't set the timeout" do
-            http = mock("http", null_object: true)
-            http.should_not_receive(:open_timeout=)
-            http.should_not_receive(:read_timeout=)
-            Net::HTTP.stub(new: http)
+            http = double(
+              "http",
+              :null_object => true,
+              :use_ssl= => false,
+              :use_ssl? => false
+            )
+            expect(http).not_to receive(:open_timeout=)
+            expect(http).not_to receive(:read_timeout=)
+            allow(Net::HTTP).to receive_messages(new: http)
 
             adapter.connection
           end
@@ -156,12 +171,21 @@ describe HTTParty::ConnectionAdapter do
       context "when timeout is not set and read_timeout is set to 6 seconds" do
         let(:options) { {read_timeout: 6} }
 
-        its(:read_timeout) { should == 6 }
+        describe '#read_timeout' do
+          subject { super().read_timeout }
+          it { is_expected.to eq(6) }
+        end
 
         it "should not set the open_timeout" do
-          http = mock("http", null_object: true)
-          http.should_not_receive(:open_timeout=)
-          Net::HTTP.stub(new: http)
+          http = double(
+            "http",
+            :null_object => true,
+            :use_ssl= => false,
+            :use_ssl? => false,
+            :read_timeout= => 0
+          )
+          expect(http).not_to receive(:open_timeout=)
+          allow(Net::HTTP).to receive_messages(new: http)
           adapter.connection
         end
       end
@@ -169,14 +193,28 @@ describe HTTParty::ConnectionAdapter do
       context "when timeout is set and read_timeout is set to 6 seconds" do
         let(:options) { {timeout: 5, read_timeout: 6} }
 
-        its(:open_timeout) { should == 5 }
-        its(:read_timeout) { should == 6 }
+        describe '#open_timeout' do
+          subject { super().open_timeout }
+          it { is_expected.to eq(5) }
+        end
+
+        describe '#read_timeout' do
+          subject { super().read_timeout }
+          it { is_expected.to eq(6) }
+        end
 
         it "should override the timeout option" do
-          http = mock("http", null_object: true)
-          http.should_receive(:open_timeout=)
-          http.should_receive(:read_timeout=).twice
-          Net::HTTP.stub(new: http)
+          http = double(
+            "http",
+            :null_object => true,
+            :use_ssl= => false,
+            :use_ssl? => false,
+            :read_timeout= => 0,
+            :open_timeout= => 0
+          )
+          expect(http).to receive(:open_timeout=)
+          expect(http).to receive(:read_timeout=).twice
+          allow(Net::HTTP).to receive_messages(new: http)
           adapter.connection
         end
       end
@@ -184,12 +222,21 @@ describe HTTParty::ConnectionAdapter do
       context "when timeout is not set and open_timeout is set to 7 seconds" do
         let(:options) { {open_timeout: 7} }
 
-        its(:open_timeout) { should == 7 }
+        describe '#open_timeout' do
+          subject { super().open_timeout }
+          it { is_expected.to eq(7) }
+        end
 
         it "should not set the read_timeout" do
-          http = mock("http", null_object: true)
-          http.should_not_receive(:read_timeout=)
-          Net::HTTP.stub(new: http)
+          http = double(
+            "http",
+            :null_object => true,
+            :use_ssl= => false,
+            :use_ssl? => false,
+            :open_timeout= => 0
+          )
+          expect(http).not_to receive(:read_timeout=)
+          allow(Net::HTTP).to receive_messages(new: http)
           adapter.connection
         end
       end
@@ -197,14 +244,28 @@ describe HTTParty::ConnectionAdapter do
       context "when timeout is set and open_timeout is set to 7 seconds" do
         let(:options) { {timeout: 5, open_timeout: 7} }
 
-        its(:open_timeout) { should == 7 }
-        its(:read_timeout) { should == 5 }
+        describe '#open_timeout' do
+          subject { super().open_timeout }
+          it { is_expected.to eq(7) }
+        end
+
+        describe '#read_timeout' do
+          subject { super().read_timeout }
+          it { is_expected.to eq(5) }
+        end
 
         it "should override the timeout option" do
-          http = mock("http", null_object: true)
-          http.should_receive(:open_timeout=).twice
-          http.should_receive(:read_timeout=)
-          Net::HTTP.stub(new: http)
+          http = double(
+            "http",
+            :null_object => true,
+            :use_ssl= => false,
+            :use_ssl? => false,
+            :read_timeout= => 0,
+            :open_timeout= => 0
+          )
+          expect(http).to receive(:open_timeout=).twice
+          expect(http).to receive(:read_timeout=)
+          allow(Net::HTTP).to receive_messages(new: http)
           adapter.connection
         end
       end
@@ -212,20 +273,20 @@ describe HTTParty::ConnectionAdapter do
       context "when debug_output" do
         let(:http) { Net::HTTP.new(uri) }
         before do
-          Net::HTTP.stub(new: http)
+          allow(Net::HTTP).to receive_messages(new: http)
         end
 
         context "is set to $stderr" do
           let(:options) { {debug_output: $stderr} }
           it "has debug output set" do
-            http.should_receive(:set_debug_output).with($stderr)
+            expect(http).to receive(:set_debug_output).with($stderr)
             adapter.connection
           end
         end
 
         context "is not provided" do
           it "does not set_debug_output" do
-            http.should_not_receive(:set_debug_output)
+            expect(http).not_to receive(:set_debug_output)
             adapter.connection
           end
         end
@@ -234,17 +295,33 @@ describe HTTParty::ConnectionAdapter do
       context 'when providing proxy address and port' do
         let(:options) { {http_proxyaddr: '1.2.3.4', http_proxyport: 8080} }
 
-        it { should be_a_proxy }
-        its(:proxy_address) { should == '1.2.3.4' }
-        its(:proxy_port) { should == 8080 }
+        it { is_expected.to be_a_proxy }
+
+        describe '#proxy_address' do
+          subject { super().proxy_address }
+          it { is_expected.to eq('1.2.3.4') }
+        end
+
+        describe '#proxy_port' do
+          subject { super().proxy_port }
+          it { is_expected.to eq(8080) }
+        end
 
         context 'as well as proxy user and password' do
           let(:options) do
             {http_proxyaddr: '1.2.3.4', http_proxyport: 8080,
              http_proxyuser: 'user', http_proxypass: 'pass'}
           end
-          its(:proxy_user) { should == 'user' }
-          its(:proxy_pass) { should == 'pass' }
+
+          describe '#proxy_user' do
+            subject { super().proxy_user }
+            it { is_expected.to eq('user') }
+          end
+
+          describe '#proxy_pass' do
+            subject { super().proxy_pass }
+            it { is_expected.to eq('pass') }
+          end
         end
       end
 
@@ -253,7 +330,7 @@ describe HTTParty::ConnectionAdapter do
 
         it "does not pass any proxy parameters to the connection" do
           http = Net::HTTP.new("proxytest.com")
-          Net::HTTP.should_receive(:new).once.with("proxytest.com", 80).and_return(http)
+          expect(Net::HTTP).to receive(:new).once.with("proxytest.com", 80).and_return(http)
           adapter.connection
         end
       end
@@ -261,8 +338,15 @@ describe HTTParty::ConnectionAdapter do
       context 'when providing a local bind address and port' do
         let(:options) { {local_host: "127.0.0.1", local_port: 12345 } }
 
-        its(:local_host) { should == '127.0.0.1' }
-        its(:local_port) { should == 12345 }
+        describe '#local_host' do
+          subject { super().local_host }
+          it { is_expected.to eq('127.0.0.1') }
+        end
+
+        describe '#local_port' do
+          subject { super().local_port }
+          it { is_expected.to eq(12345) }
+        end
       end if RUBY_VERSION >= '2.0'
 
       context "when providing PEM certificates" do
@@ -271,28 +355,28 @@ describe HTTParty::ConnectionAdapter do
 
         context "when scheme is https" do
           let(:uri) { URI 'https://google.com' }
-          let(:cert) { mock("OpenSSL::X509::Certificate") }
-          let(:key) { mock("OpenSSL::PKey::RSA") }
+          let(:cert) { double("OpenSSL::X509::Certificate") }
+          let(:key) { double("OpenSSL::PKey::RSA") }
 
           before do
-            OpenSSL::X509::Certificate.should_receive(:new).with(pem).and_return(cert)
-            OpenSSL::PKey::RSA.should_receive(:new).with(pem, "password").and_return(key)
+            expect(OpenSSL::X509::Certificate).to receive(:new).with(pem).and_return(cert)
+            expect(OpenSSL::PKey::RSA).to receive(:new).with(pem, "password").and_return(key)
           end
 
           it "uses the provided PEM certificate" do
-            subject.cert.should == cert
-            subject.key.should == key
+            expect(subject.cert).to eq(cert)
+            expect(subject.key).to eq(key)
           end
 
           it "will verify the certificate" do
-            subject.verify_mode.should == OpenSSL::SSL::VERIFY_PEER
+            expect(subject.verify_mode).to eq(OpenSSL::SSL::VERIFY_PEER)
           end
-          
+
           context "when options include verify_peer=false" do
             let(:options) { {pem: pem, pem_password: "password", verify_peer: false} }
-            
+
             it "should not verify the certificate" do
-              subject.verify_mode.should == OpenSSL::SSL::VERIFY_NONE
+              expect(subject.verify_mode).to eq(OpenSSL::SSL::VERIFY_NONE)
             end
           end
         end
@@ -302,16 +386,16 @@ describe HTTParty::ConnectionAdapter do
           let(:http) { Net::HTTP.new(uri) }
 
           before do
-            Net::HTTP.stub(new: http)
-            OpenSSL::X509::Certificate.should_not_receive(:new).with(pem)
-            OpenSSL::PKey::RSA.should_not_receive(:new).with(pem, "password")
-            http.should_not_receive(:cert=)
-            http.should_not_receive(:key=)
+            allow(Net::HTTP).to receive_messages(new: http)
+            expect(OpenSSL::X509::Certificate).not_to receive(:new).with(pem)
+            expect(OpenSSL::PKey::RSA).not_to receive(:new).with(pem, "password")
+            expect(http).not_to receive(:cert=)
+            expect(http).not_to receive(:key=)
           end
 
           it "has no PEM certificate " do
-            subject.cert.should be_nil
-            subject.key.should be_nil
+            expect(subject.cert).to be_nil
+            expect(subject.key).to be_nil
           end
         end
       end
@@ -322,28 +406,28 @@ describe HTTParty::ConnectionAdapter do
 
         context "when scheme is https" do
           let(:uri) { URI 'https://google.com' }
-          let(:pkcs12) { mock("OpenSSL::PKCS12", certificate: cert, key: key) }
-          let(:cert) { mock("OpenSSL::X509::Certificate") }
-          let(:key) { mock("OpenSSL::PKey::RSA") }
+          let(:pkcs12) { double("OpenSSL::PKCS12", certificate: cert, key: key) }
+          let(:cert) { double("OpenSSL::X509::Certificate") }
+          let(:key) { double("OpenSSL::PKey::RSA") }
 
           before do
-            OpenSSL::PKCS12.should_receive(:new).with(p12, "password").and_return(pkcs12)
+            expect(OpenSSL::PKCS12).to receive(:new).with(p12, "password").and_return(pkcs12)
           end
 
           it "uses the provided P12 certificate " do
-            subject.cert.should == cert
-            subject.key.should == key
+            expect(subject.cert).to eq(cert)
+            expect(subject.key).to eq(key)
           end
 
           it "will verify the certificate" do
-            subject.verify_mode.should == OpenSSL::SSL::VERIFY_PEER
+            expect(subject.verify_mode).to eq(OpenSSL::SSL::VERIFY_PEER)
           end
-          
+
           context "when options include verify_peer=false" do
             let(:options) { {p12: p12, p12_password: "password", verify_peer: false} }
-            
+
             it "should not verify the certificate" do
-              subject.verify_mode.should == OpenSSL::SSL::VERIFY_NONE
+              expect(subject.verify_mode).to eq(OpenSSL::SSL::VERIFY_NONE)
             end
           end
         end
@@ -353,15 +437,15 @@ describe HTTParty::ConnectionAdapter do
           let(:http) { Net::HTTP.new(uri) }
 
           before do
-            Net::HTTP.stub(new: http)
-            OpenSSL::PKCS12.new.should_not_receive(:new).with(p12, "password")
-            http.should_not_receive(:cert=)
-            http.should_not_receive(:key=)
+            allow(Net::HTTP).to receive_messages(new: http)
+            expect(OpenSSL::PKCS12).not_to receive(:new).with(p12, "password")
+            expect(http).not_to receive(:cert=)
+            expect(http).not_to receive(:key=)
           end
 
           it "has no PKCS12 certificate " do
-            subject.cert.should be_nil
-            subject.key.should be_nil
+            expect(subject.cert).to be_nil
+            expect(subject.key).to be_nil
           end
         end
       end