webmock 1.24.6 → 2.0.0.beta1

data/lib/webmock/http_lib_adapters/excon_adapter.rb

@@ -102,6 +102,8 @@ if defined?(Excon)
 
         def self.build_request(params)
           params = params.dup
+          params.delete(:user)
+          params.delete(:password)
           method  = (params.delete(:method) || :get).to_s.downcase.to_sym
           params[:query] = to_query(params[:query]) if params[:query].is_a?(Hash)
           uri = Addressable::URI.new(params).to_s

data/lib/webmock/http_lib_adapters/http_rb/response.rb

@@ -33,7 +33,7 @@ module HTTP
       def normalize_uri(uri)
         return unless uri
 
-        uri = Addressable::URI.parse uri
+        uri = URI.parse uri
         uri.port = nil if uri.default_port && uri.port == uri.default_port
 
         uri

data/lib/webmock/http_lib_adapters/httpclient_adapter.rb

@@ -170,7 +170,6 @@ if defined?(::HTTPClient)
     uri = WebMock::Util::URI.heuristic_parse(req.header.request_uri.to_s)
     uri.query = WebMock::Util::QueryMapper.values_to_query(req.header.request_query, :notation => WebMock::Config.instance.query_values_notation) if req.header.request_query
     uri.port = req.header.request_uri.port
-    uri = uri.omit(:userinfo)
 
     @request_filter.each do |filter|
       filter.filter_request(req)
@@ -183,11 +182,6 @@ if defined?(::HTTPClient)
     end
     headers = headers_from_session(uri).merge(headers)
 
-    if auth_cred = auth_cred_from_www_auth(req) || auth_cred_from_headers(headers)
-      remove_authorization_header headers
-      uri.userinfo = userinfo_from_auth_cred auth_cred
-    end
-
     signature = WebMock::RequestSignature.new(
       req.header.request_method.downcase.to_sym,
       uri.to_s,
@@ -203,38 +197,6 @@ if defined?(::HTTPClient)
     signature
   end
 
-  def userinfo_from_auth_cred auth_cred
-    userinfo = WebMock::Util::Headers.decode_userinfo_from_header(auth_cred)
-    WebMock::Util::URI.encode_unsafe_chars_in_userinfo(userinfo)
-  end
-
-  def remove_authorization_header headers
-    headers.reject! do |name, value|
-      next unless name =~ /[Aa]uthorization/
-      if value.is_a? Array
-        value.reject! { |v| v =~ /^Basic / }
-        value.length == 0
-      elsif value.is_a? String
-        value =~ /^Basic /
-      end
-    end
-  end
-
-  def auth_cred_from_www_auth(req)
-    auth = www_auth.basic_auth
-    auth.challenge(req.header.request_uri, nil)
-    auth.get(req) if auth.scheme == 'Basic'
-  end
-
-  def auth_cred_from_headers(headers)
-    headers.each do |k,v|
-      next unless k =~ /[Aa]uthorization/
-      return v if v.is_a?(String) && v =~ /^Basic /
-      v.each { |v| return v if v =~ /^Basic / } if v.is_a? Array
-    end
-    nil
-  end
-
   def webmock_responses
     @webmock_responses ||= Hash.new do |hash, request_signature|
       hash[request_signature] = WebMock::StubRegistry.instance.response_for_request(request_signature)

data/lib/webmock/http_lib_adapters/manticore_adapter.rb

@@ -45,7 +45,7 @@ if defined?(Manticore)
           end
 
           def response_object_for(request, context, &block)
-            request_signature = generate_webmock_request_signature(request)
+            request_signature = generate_webmock_request_signature(request, context)
             WebMock::RequestRegistry.instance.requested_signatures.put(request_signature)
 
             if webmock_response = registered_response_for(request_signature)
@@ -74,12 +74,16 @@ if defined?(Manticore)
             WebMock.net_connect_allowed?(uri)
           end
 
-          def generate_webmock_request_signature(request)
+          def generate_webmock_request_signature(request, context)
             method = request.method.downcase
             uri = request.uri.to_s
             body = read_body(request)
             headers = split_array_values(request.headers)
 
+            if context.get_credentials_provider && credentials = context.get_credentials_provider.get_credentials(AuthScope::ANY)
+              headers['Authorization'] = WebMock::Util::Headers.basic_auth_header(credentials.get_user_name,credentials.get_password)
+            end
+
             WebMock::RequestSignature.new(method, uri, {:body => body, :headers => headers})
           end
 

data/lib/webmock/http_lib_adapters/net_http.rb

@@ -275,19 +275,11 @@ module WebMock
 
       path = WebMock::Util::URI.heuristic_parse(path).request_uri if path =~ /^http/
 
-      if request["authorization"] =~ /^Basic /
-        userinfo = WebMock::Util::Headers.decode_userinfo_from_header(request["authorization"])
-        userinfo = WebMock::Util::URI.encode_unsafe_chars_in_userinfo(userinfo) + "@"
-      else
-        userinfo = ""
-      end
-
-      uri = "#{protocol}://#{userinfo}#{net_http.address}:#{net_http.port}#{path}"
+      uri = "#{protocol}://#{net_http.address}:#{net_http.port}#{path}"
       method = request.method.downcase.to_sym
 
       headers = Hash[*request.to_hash.map {|k,v| [k, v]}.inject([]) {|r,x| r + x}]
       validate_headers(headers)
-      headers.reject! {|k,v| k =~ /[Aa]uthorization/ && v.first =~ /^Basic / } #we added it to url userinfo
 
       if request.body_stream
         body = request.body_stream.read
@@ -314,7 +306,7 @@ module WebMock
       #
       # So before this point, WebMock raises an ArgumentError if any of the headers are symbols
       # instead of the cryptic NoMethodError "undefined method `split' ...` from Net::HTTP
-      if Gem::Version.new(RUBY_VERSION.dup) < Gem::Version.new('2.3.0')
+      if Gem::Version.new(RUBY_VERSION) < Gem::Version.new('2.3.0')
         header_as_symbol = headers.keys.find {|header| header.is_a? Symbol}
         if header_as_symbol
           raise ArgumentError.new("Net:HTTP does not accept headers as symbols")

data/lib/webmock/http_lib_adapters/patron_adapter.rb

@@ -68,8 +68,6 @@ if defined?(::Patron)
         def self.build_request_signature(req)
           uri = WebMock::Util::URI.heuristic_parse(req.url)
           uri.path = uri.normalized_path.gsub("[^:]//","/")
-          uri.user = req.username
-          uri.password = req.password
 
           if [:put, :post].include?(req.action)
             if req.file_name
@@ -84,11 +82,17 @@ if defined?(::Patron)
             end
           end
 
+          headers = req.headers
+
+          if req.credentials
+            headers['Authorization'] = WebMock::Util::Headers.basic_auth_header(req.credentials)
+          end
+
           request_signature = WebMock::RequestSignature.new(
             req.action,
             uri.to_s,
             :body => request_body,
-            :headers => req.headers
+            :headers => headers
           )
           request_signature
         end

data/lib/webmock/http_lib_adapters/typhoeus_hydra_adapter.rb

@@ -53,8 +53,11 @@ if defined?(Typhoeus)
         def self.build_request_signature(req)
           uri = WebMock::Util::URI.heuristic_parse(req.url)
           uri.path = uri.normalized_path.gsub("[^:]//","/")
+
+          headers = req.options[:headers]
+
           if req.options[:userpwd]
-            uri.user, uri.password = req.options[:userpwd].split(':')
+            headers['Authorization'] = WebMock::Util::Headers.basic_auth_header(req.options[:userpwd])
           end
 
           body = req.options[:body]
@@ -67,7 +70,7 @@ if defined?(Typhoeus)
             req.options[:method] || :get,
             uri.to_s,
             :body => body,
-            :headers => req.options[:headers]
+            :headers => headers
           )
 
           req.instance_variable_set(:@__webmock_request_signature, request_signature)
@@ -75,6 +78,7 @@ if defined?(Typhoeus)
           request_signature
         end
 
+
         def self.build_webmock_response(typhoeus_response)
           webmock_response = WebMock::Response.new
           webmock_response.status = [typhoeus_response.code, typhoeus_response.status_message]

data/lib/webmock/minitest.rb

@@ -10,6 +10,8 @@ end
 
 require 'webmock'
 
+WebMock.enable!
+
 test_class.class_eval do
   include WebMock::API
 

data/lib/webmock/request_pattern.rb

@@ -50,12 +50,27 @@ module WebMock
 
     def assign_options(options)
       options = WebMock::Util::HashKeysStringifier.stringify_keys!(options, :deep => true)
-      HashValidator.new(options).validate_keys('body', 'headers', 'query')
+      HashValidator.new(options).validate_keys('body', 'headers', 'query', 'basic_auth')
+      set_basic_auth_as_headers!(options)
       @body_pattern = BodyPattern.new(options['body']) if options.has_key?('body')
       @headers_pattern = HeadersPattern.new(options['headers']) if options.has_key?('headers')
       @uri_pattern.add_query_params(options['query']) if options.has_key?('query')
     end
 
+    def set_basic_auth_as_headers!(options)
+      if basic_auth = options.delete('basic_auth')
+        validate_basic_auth!(basic_auth)
+        options['headers'] ||= {}
+        options['headers']['Authorization'] = WebMock::Util::Headers.basic_auth_header(basic_auth[0],basic_auth[1])
+      end
+    end
+
+    def validate_basic_auth!(basic_auth)
+      if !basic_auth.is_a?(Array) || basic_auth.map{|e| e.is_a?(String)}.uniq != [true]
+        raise "The basic_auth option value should be an array which contains 2 strings: username and password"
+      end
+    end
+
     def create_uri_pattern(uri)
       if uri.is_a?(Regexp)
         URIRegexpPattern.new(uri)

data/lib/webmock/response.rb

@@ -1,12 +1,5 @@
 require "pathname"
 
-#compatibility with Ruby 1.9.2 preview1 to allow reading raw responses
-if RUBY_VERSION <= "1.9.2"
-  class StringIO
-    alias_method :read_nonblock, :sysread
-  end
-end
-
 module WebMock
 
   class ResponseFactory

data/lib/webmock/rspec.rb

@@ -20,6 +20,8 @@ end
 
 require 'webmock/rspec/matchers'
 
+WebMock.enable!
+
 RSPEC_CONFIGURER.configure { |config|
 
   config.include WebMock::API

data/lib/webmock/test_unit.rb

@@ -1,6 +1,8 @@
 require 'test/unit'
 require 'webmock'
 
+WebMock.enable!
+
 module Test
   module Unit
     class TestCase

data/lib/webmock/util/headers.rb

@@ -36,6 +36,10 @@ module WebMock
         header.sub(/^Basic /, "").unpack("m").first
       end
 
+      def self.basic_auth_header(*credentials)
+        "Basic #{Base64.encode64(credentials.join(':')).chomp}"
+      end
+
     end
 
   end

data/lib/webmock/util/query_mapper.rb

@@ -146,7 +146,6 @@ module WebMock::Util
           last_container = current_node.select { |n| n.is_a?(Hash) }.last
           if last_container && !last_container.has_key?(last_key)
             if array_value
-              last_container[last_key] ||= []
               last_container[last_key] << value
             else
               last_container[last_key] = value
@@ -160,7 +159,7 @@ module WebMock::Util
           end
         else
           if array_value
-            current_node[last_key] ||= []
+            current_node[last_key] = [] unless current_node[last_key]
             current_node[last_key] << value
           else
             current_node[last_key] = value

data/lib/webmock/version.rb

@@ -1,3 +1,3 @@
 module WebMock
-  VERSION = '1.24.6' unless defined?(::WebMock::VERSION)
+  VERSION = '2.0.0.beta1' unless defined?(::WebMock::VERSION)
 end

data/lib/webmock/webmock.rb

@@ -153,6 +153,4 @@ module WebMock
                           end
     ))
   end
-
-  self.enable!
 end

data/spec/acceptance/curb/curb_spec_helper.rb

@@ -30,9 +30,12 @@ module CurbSpecHelper
 
   def setup_request(uri, curl, options={})
     curl          ||= Curl::Easy.new
-    curl.url      = uri.omit(:userinfo).to_s
-    curl.username = uri.user
-    curl.password = uri.password
+    curl.url      = uri.to_s
+    if options[:basic_auth]
+      curl.http_auth_types = :basic
+      curl.username = options[:basic_auth][0]
+      curl.password = options[:basic_auth][1]
+    end
     curl.timeout  = 30
     curl.connect_timeout = 30
 

data/spec/acceptance/em_http_request/em_http_request_spec_helper.rb

@@ -8,6 +8,9 @@ module EMHttpRequestSpecHelper
   def http_request(method, uri, options = {}, &block)
     @http = nil
     head = options[:headers] || {}
+    if options[:basic_auth]
+      head.merge!('authorization' => options[:basic_auth])
+    end
     response = nil
     error = nil
     error_set = false
@@ -19,7 +22,7 @@ module EMHttpRequestSpecHelper
         :body => options[:body],
         :file => options[:file],
         :query => options[:query],
-        :head => head.merge('authorization' => [uri.user, uri.password])
+        :head => head
       }, &block)
       http.errback {
         error_set = true

data/spec/acceptance/excon/excon_spec_helper.rb

@@ -5,14 +5,20 @@ module ExconSpecHelper
   def http_request(method, uri, options = {}, &block)
     Excon.defaults[:ssl_verify_peer] = false
     uri      = Addressable::URI.heuristic_parse(uri)
-    uri      = uri.omit(:userinfo).to_s.gsub(' ', '%20')
+    uri      = uri.to_s.gsub(' ', '%20')
+
+    excon_options = {}
+
+    if basic_auth = options.delete(:basic_auth)
+      excon_options = {user: basic_auth[0], password: basic_auth[1]}
+    end
 
     if Gem::Version.new(Excon::VERSION) < Gem::Version.new("0.29.0")
       options  = options.merge(:method => method, :nonblock => false) # Dup and merge
-      response = Excon.new(uri).request(options, &block)
+      response = Excon.new(uri, excon_options).request(options, &block)
     else
       options  = options.merge(:method => method) # Dup and merge
-      response = Excon.new(uri, :nonblock => false).request(options, &block)
+      response = Excon.new(uri, excon_options.merge(nonblock: false)).request(options, &block)
     end
 
     headers  = WebMock::Util::Headers.normalize_headers(response.headers)

data/spec/acceptance/http_rb/http_rb_spec_helper.rb

@@ -2,7 +2,13 @@ require "ostruct"
 
 module HttpRbSpecHelper
   def http_request(method, uri, options = {})
-    response = HTTP.request(method, normalize_uri(uri), options)
+    chain = HTTP
+
+    if basic_auth = options.delete(:basic_auth)
+      chain = chain.basic_auth(user: basic_auth[0], pass: basic_auth[1])
+    end
+
+    response = chain.request(method, normalize_uri(uri), options)
 
     OpenStruct.new({
       :body       => response.body.to_s,

data/spec/acceptance/httpclient/httpclient_spec_helper.rb

@@ -7,8 +7,11 @@ module HTTPClientSpecHelper
     uri = Addressable::URI.heuristic_parse(uri)
     c = options.fetch(:client) { HTTPClient.new }
     c.ssl_config.verify_mode = OpenSSL::SSL::VERIFY_NONE
-    c.set_basic_auth(nil, uri.user, uri.password) if uri.user
-    params = [method, "#{uri.omit(:userinfo, :query).normalize.to_s}",
+    if options[:basic_auth]
+      c.force_basic_auth = true
+      c.set_basic_auth(nil, options[:basic_auth][0], options[:basic_auth][1])
+    end
+    params = [method, uri.normalize.to_s,
       WebMock::Util::QueryMapper.query_to_values(uri.query, :notation => WebMock::Config.instance.query_values_notation), options[:body], options[:headers] || {}]
     if HTTPClientSpecHelper.async_mode
       connection = c.request_async(*params)

data/spec/acceptance/manticore/manticore_spec_helper.rb

@@ -1,8 +1,12 @@
 module ManticoreSpecHelper
   def http_request(method, uri, options = {})
     client = Manticore::Client.new
-    response = client.http(method, uri, options)
 
+    if basic_auth = options[:basic_auth]
+      options = options.merge(auth: {user: basic_auth[0], pass: basic_auth[1]})
+    end
+
+    response = client.http(method, uri, options)
     OpenStruct.new({
       :body => response.body || '',
       :headers => WebMock::Util::Headers.normalize_headers(join_array_values(response.headers)),

data/spec/acceptance/net_http/net_http_spec.rb

@@ -7,7 +7,7 @@ require 'acceptance/net_http/net_http_shared'
 include NetHTTPSpecHelper
 
 describe "Net:HTTP" do
-  include_examples "with WebMock"
+  include_examples "with WebMock", :no_url_auth
 
   let(:port) { WebMockServer.instance.port }
 
@@ -132,7 +132,7 @@ describe "Net:HTTP" do
       end
     end
 
-    if Gem::Version.new(RUBY_VERSION.dup) < Gem::Version.new('2.3.0')
+    if Gem::Version.new(RUBY_VERSION) < Gem::Version.new('2.3.0')
       expect do
         http.request(request)
       end.to raise_error ArgumentError, "Net:HTTP does not accept headers as symbols"

data/spec/acceptance/net_http/net_http_spec_helper.rb

@@ -18,7 +18,10 @@ module NetHTTPSpecHelper
       end
     end if options[:headers]
 
-    req.basic_auth uri.user, uri.password if uri.user
+    if options[:basic_auth]
+      req.basic_auth(options[:basic_auth][0], options[:basic_auth][1])
+    end
+
     http = Net::HTTP.new(uri.host, uri.port)
     if uri.scheme == "https"
       http.use_ssl = true