webmock 1.8.6 → 3.14.0

data/lib/webmock/http_lib_adapters/curb_adapter.rb

@@ -5,7 +5,7 @@ rescue LoadError
 end
 
 if defined?(Curl)
-  WebMock::VersionChecker.new('Curb', Gem.loaded_specs['curb'].version.to_s, '0.7.16').check_version!
+  WebMock::VersionChecker.new('Curb', Curl::CURB_VERSION, '0.7.16', '0.9.1', ['0.8.7']).check_version!
 
   module WebMock
     module HttpLibAdapters
@@ -55,14 +55,13 @@ if defined?(Curl)
   module Curl
     class WebMockCurlEasy < Curl::Easy
       def curb_or_webmock
-
         request_signature = build_request_signature
         WebMock::RequestRegistry.instance.requested_signatures.put(request_signature)
 
         if webmock_response = WebMock::StubRegistry.instance.response_for_request(request_signature)
           build_curb_response(webmock_response)
           WebMock::CallbackRegistry.invoke_callbacks(
-            {:lib => :curb}, request_signature, webmock_response)
+            {lib: :curb}, request_signature, webmock_response)
           invoke_curb_callbacks
           true
         elsif WebMock.net_connect_allowed?(request_signature.uri)
@@ -70,7 +69,7 @@ if defined?(Curl)
           if WebMock::CallbackRegistry.any_callbacks?
             webmock_response = build_webmock_response
             WebMock::CallbackRegistry.invoke_callbacks(
-              {:lib => :curb, :real_request => true}, request_signature,
+              {lib: :curb, real_request: true}, request_signature,
                 webmock_response)
           end
           res
@@ -84,11 +83,11 @@ if defined?(Curl)
 
         uri = WebMock::Util::URI.heuristic_parse(self.url)
         uri.path = uri.normalized_path.gsub("[^:]//","/")
-        uri.user = self.username
-        uri.password = self.password
+
+        headers = headers_as_hash(self.headers).merge(basic_auth_headers)
 
         request_body = case method
-        when :post
+        when :post, :patch
           self.post_body || @post_body
         when :put
           @put_data
@@ -96,15 +95,56 @@ if defined?(Curl)
           nil
         end
 
+        if defined?( @on_debug )
+          @on_debug.call("Trying 127.0.0.1...\r\n", 0)
+          @on_debug.call('Connected to ' + uri.hostname + "\r\n", 0)
+          @debug_method = method.upcase
+          @debug_path = uri.path
+          @debug_host = uri.hostname
+          http_request = ["#{@debug_method} #{@debug_path} HTTP/1.1"]
+          http_request << "Host: #{uri.hostname}"
+          headers.each do |name, value|
+            http_request << "#{name}: #{value}"
+          end
+          @on_debug.call(http_request.join("\r\n") + "\r\n\r\n", 2)
+          if request_body
+            @on_debug.call(request_body + "\r\n", 4)
+            @on_debug.call(
+              "upload completely sent off: #{request_body.bytesize}"\
+              " out of #{request_body.bytesize} bytes\r\n", 0
+            )
+          end
+        end
+
         request_signature = WebMock::RequestSignature.new(
           method,
           uri.to_s,
-          :body => request_body,
-          :headers => self.headers
+          body: request_body,
+          headers: headers
         )
         request_signature
       end
 
+      def headers_as_hash(headers)
+        if headers.is_a?(Array)
+          headers.inject({}) {|hash, header|
+            name, value = header.split(":").map(&:strip)
+            hash[name] = value
+            hash
+          }
+        else
+          headers
+        end
+      end
+
+      def basic_auth_headers
+        if self.username
+          {'Authorization' => WebMock::Util::Headers.basic_auth_header(self.username, self.password)}
+        else
+          {}
+        end
+      end
+
       def build_curb_response(webmock_response)
         raise Curl::Err::TimeoutError if webmock_response.should_timeout
         webmock_response.raise_error_if_any
@@ -112,11 +152,17 @@ if defined?(Curl)
         @body_str = webmock_response.body
         @response_code = webmock_response.status[0]
 
-        @header_str = "HTTP/1.1 #{webmock_response.status[0]} #{webmock_response.status[1]}\r\n"
+        @header_str = "HTTP/1.1 #{webmock_response.status[0]} #{webmock_response.status[1]}\r\n".dup
+
+        @on_debug.call(@header_str, 1) if defined?( @on_debug )
+
         if webmock_response.headers
           @header_str << webmock_response.headers.map do |k,v|
-            "#{k}: #{v.is_a?(Array) ? v.join(", ") : v}"
+            header = "#{k}: #{v.is_a?(Array) ? v.join(", ") : v}"
+            @on_debug.call(header + "\r\n", 1) if defined?( @on_debug )
+            header
           end.join("\r\n")
+          @on_debug.call("\r\n", 1) if defined?( @on_debug )
 
           location = webmock_response.headers['Location']
           if self.follow_location? && location
@@ -125,6 +171,7 @@ if defined?(Curl)
           end
 
           @content_type = webmock_response.headers["Content-Type"]
+          @transfer_encoding = webmock_response.headers["Transfer-Encoding"]
         end
 
         @last_effective_url ||= self.url
@@ -135,30 +182,54 @@ if defined?(Curl)
         self.url = location
 
         curb_or_webmock do
-          send( "http_#{@webmock_method}_without_webmock" )
+          send( :http, {'method' => @webmock_method} )
         end
 
         self.url = first_url
       end
 
       def invoke_curb_callbacks
-        @on_progress.call(0.0,1.0,0.0,1.0) if @on_progress
-        @on_header.call(self.header_str) if @on_header
-        @on_body.call(self.body_str) if @on_body
-        @on_complete.call(self) if @on_complete
+        @on_progress.call(0.0,1.0,0.0,1.0) if defined?( @on_progress )
+        self.header_str.lines.each { |header_line| @on_header.call header_line } if defined?( @on_header )
+        if defined?( @on_body )
+          if chunked_response?
+            self.body_str.each do |chunk|
+              @on_body.call(chunk)
+            end
+          else
+            @on_body.call(self.body_str)
+          end
+        end
+        @on_complete.call(self) if defined?( @on_complete )
 
         case response_code
         when 200..299
-          @on_success.call(self) if @on_success
-        when 400..599
-          @on_failure.call(self, self.response_code) if @on_failure
+          @on_success.call(self) if defined?( @on_success )
+        when 400..499
+          @on_missing.call(self, self.response_code) if defined?( @on_missing )
+        when 500..599
+          @on_failure.call(self, self.response_code) if defined?( @on_failure )
         end
       end
 
+      def chunked_response?
+        defined?( @transfer_encoding ) && @transfer_encoding == 'chunked' && self.body_str.respond_to?(:each)
+      end
+
       def build_webmock_response
         status, headers =
          WebMock::HttpLibAdapters::CurbAdapter.parse_header_string(self.header_str)
 
+        if defined?( @on_debug )
+          http_response = ["HTTP/1.0 #{@debug_method} #{@debug_path}"]
+          headers.each do |name, value|
+            http_response << "#{name}: #{value}"
+          end
+          http_response << self.body_str
+          @on_debug.call(http_response.join("\r\n") + "\r\n", 3)
+          @on_debug.call("Connection #0 to host #{@debug_host} left intact\r\n", 0)
+        end
+
         webmock_response = WebMock::Response.new
         webmock_response.status = [self.response_code, status]
         webmock_response.body = self.body_str
@@ -170,117 +241,110 @@ if defined?(Curl)
       ### Mocks of Curl::Easy methods below here.
       ###
 
-      def http_with_webmock(method)
+      def http(method)
         @webmock_method = method
-          http_without_webmock(method)
+        super
       end
-      alias_method :http_without_webmock, :http
-      alias_method :http, :http_with_webmock
 
       %w[ get head delete ].each do |verb|
-        define_method "http_#{verb}_with_webmock" do
+        define_method "http_#{verb}" do
           @webmock_method = verb
-          send( "http_#{verb}_without_webmock" )
+          super()
         end
-
-        alias_method "http_#{verb}_without_webmock", "http_#{verb}"
-        alias_method "http_#{verb}", "http_#{verb}_with_webmock"
       end
 
-      def http_put_with_webmock data = nil
+      def http_put data = nil
         @webmock_method = :put
         @put_data = data if data
-        http_put_without_webmock(data)
+        super
       end
-      alias_method :http_put_without_webmock, :http_put
-      alias_method :http_put, :http_put_with_webmock
+      alias put http_put
 
-      def http_post_with_webmock *data
+      def http_post *data
         @webmock_method = :post
         @post_body = data.join('&') if data && !data.empty?
-        http_post_without_webmock(*data)
+        super
       end
-      alias_method :http_post_without_webmock, :http_post
-      alias_method :http_post, :http_post_with_webmock
+      alias post http_post
 
-
-      def perform_with_webmock
+      def perform
         @webmock_method ||= :get
-        curb_or_webmock do
-          perform_without_webmock
-        end
+        curb_or_webmock { super }
+      ensure
+        reset_webmock_method
       end
-      alias :perform_without_webmock :perform
-      alias :perform :perform_with_webmock
 
-      def put_data_with_webmock= data
+      def put_data= data
         @webmock_method = :put
         @put_data = data
-        self.put_data_without_webmock = data
+        super
       end
-      alias_method :put_data_without_webmock=, :put_data=
-      alias_method :put_data=, :put_data_with_webmock=
 
-      def post_body_with_webmock= data
+      def post_body= data
         @webmock_method = :post
-        self.post_body_without_webmock = data
+        super
       end
-      alias_method :post_body_without_webmock=, :post_body=
-      alias_method :post_body=, :post_body_with_webmock=
 
-      def delete_with_webmock= value
+      def delete= value
         @webmock_method = :delete if value
-        self.delete_without_webmock = value
+        super
       end
-      alias_method :delete_without_webmock=, :delete=
-      alias_method :delete=, :delete_with_webmock=
 
-      def head_with_webmock= value
+      def head= value
         @webmock_method = :head if value
-        self.head_without_webmock = value
+        super
+      end
+
+      def verbose=(verbose)
+        @verbose = verbose
+      end
+
+      def verbose?
+        @verbose ||= false
       end
-      alias_method :head_without_webmock=, :head=
-      alias_method :head=, :head_with_webmock=
 
-      def body_str_with_webmock
-        @body_str || body_str_without_webmock
+      def body_str
+        @body_str ||= super
       end
-      alias :body_str_without_webmock :body_str
-      alias :body_str :body_str_with_webmock
+      alias body body_str
 
-      def response_code_with_webmock
-        @response_code || response_code_without_webmock
+      def response_code
+        @response_code ||= super
       end
-      alias :response_code_without_webmock :response_code
-      alias :response_code :response_code_with_webmock
 
-      def header_str_with_webmock
-        @header_str || header_str_without_webmock
+      def header_str
+        @header_str ||= super
       end
-      alias :header_str_without_webmock :header_str
-      alias :header_str :header_str_with_webmock
+      alias head header_str
 
-      def last_effective_url_with_webmock
-        @last_effective_url || last_effective_url_without_webmock
+      def last_effective_url
+        @last_effective_url ||= super
       end
-      alias :last_effective_url_without_webmock :last_effective_url
-      alias :last_effective_url :last_effective_url_with_webmock
 
-      def content_type_with_webmock
-        @content_type || content_type_without_webmock
+      def content_type
+        @content_type ||= super
       end
-      alias :content_type_without_webmock :content_type
-      alias :content_type :content_type_with_webmock
 
-      %w[ success failure header body complete progress ].each do |callback|
+      %w[ success failure missing header body complete progress debug ].each do |callback|
         class_eval <<-METHOD, __FILE__, __LINE__
-          def on_#{callback}_with_webmock &block
+          def on_#{callback} &block
             @on_#{callback} = block
-            on_#{callback}_without_webmock &block
+            super
           end
         METHOD
-        alias_method "on_#{callback}_without_webmock", "on_#{callback}"
-        alias_method "on_#{callback}", "on_#{callback}_with_webmock"
+      end
+
+      def reset_webmock_method
+        @webmock_method = :get
+      end
+
+      def reset
+        instance_variable_set(:@body_str, nil)
+        instance_variable_set(:@content_type, nil)
+        instance_variable_set(:@header_str, nil)
+        instance_variable_set(:@last_effective_url, nil)
+        instance_variable_set(:@response_code, nil)
+        super
       end
     end
   end

data/lib/webmock/http_lib_adapters/em_http_request_adapter.rb

@@ -4,8 +4,228 @@ rescue LoadError
   # em-http-request not found
 end
 
-if defined?(EventMachine::HttpConnection)
-  require File.expand_path(File.dirname(__FILE__) + '/em_http_request/em_http_request_1_x')
-else
-  require File.expand_path(File.dirname(__FILE__) + '/em_http_request/em_http_request_0_x')
+if defined?(EventMachine::HttpClient)
+  module WebMock
+    module HttpLibAdapters
+      class EmHttpRequestAdapter < HttpLibAdapter
+        adapter_for :em_http_request
+
+        OriginalHttpClient = EventMachine::HttpClient unless const_defined?(:OriginalHttpClient)
+        OriginalHttpConnection = EventMachine::HttpConnection unless const_defined?(:OriginalHttpConnection)
+
+        def self.enable!
+          EventMachine.send(:remove_const, :HttpConnection)
+          EventMachine.send(:const_set, :HttpConnection, EventMachine::WebMockHttpConnection)
+          EventMachine.send(:remove_const, :HttpClient)
+          EventMachine.send(:const_set, :HttpClient, EventMachine::WebMockHttpClient)
+        end
+
+        def self.disable!
+          EventMachine.send(:remove_const, :HttpConnection)
+          EventMachine.send(:const_set, :HttpConnection, OriginalHttpConnection)
+          EventMachine.send(:remove_const, :HttpClient)
+          EventMachine.send(:const_set, :HttpClient, OriginalHttpClient)
+        end
+      end
+    end
+  end
+
+  module EventMachine
+    if defined?(Synchrony) && HTTPMethods.instance_methods.include?(:aget)
+      # have to make the callbacks fire on the next tick in order
+      # to avoid the dreaded "double resume" exception
+      module HTTPMethods
+        %w[get head post delete put].each do |type|
+          class_eval %[
+            def #{type}(options = {}, &blk)
+              f = Fiber.current
+
+               conn = setup_request(:#{type}, options, &blk)
+               conn.callback { EM.next_tick { f.resume(conn) } }
+               conn.errback  { EM.next_tick { f.resume(conn) } }
+
+               Fiber.yield
+            end
+          ]
+        end
+      end
+    end
+
+    class WebMockHttpConnection < HttpConnection
+      def activate_connection(client)
+        request_signature = client.request_signature
+
+        if client.stubbed_webmock_response
+          conn = HttpStubConnection.new rand(10000)
+          post_init
+
+          @deferred = false
+          @conn = conn
+
+          conn.parent = self
+          conn.pending_connect_timeout = @connopts.connect_timeout
+          conn.comm_inactivity_timeout = @connopts.inactivity_timeout
+
+          finalize_request(client)
+          @conn.set_deferred_status :succeeded
+        elsif WebMock.net_connect_allowed?(request_signature.uri)
+          super
+        else
+          raise WebMock::NetConnectNotAllowedError.new(request_signature)
+        end
+      end
+
+      def drop_client
+        @clients.shift
+      end
+    end
+
+    class WebMockHttpClient < EventMachine::HttpClient
+      include HttpEncoding
+
+      def uri
+        @req.uri
+      end
+
+      def setup(response, uri, error = nil)
+        @last_effective_url = @uri = uri
+        if error
+          on_error(error)
+          @conn.drop_client
+          fail(self)
+        else
+          @conn.receive_data(response)
+          succeed(self)
+        end
+      end
+
+      def connection_completed
+        @state = :response_header
+        send_request(request_signature.headers, request_signature.body)
+      end
+
+      def send_request(head, body)
+        WebMock::RequestRegistry.instance.requested_signatures.put(request_signature)
+
+        if stubbed_webmock_response
+          WebMock::CallbackRegistry.invoke_callbacks({lib: :em_http_request}, request_signature, stubbed_webmock_response)
+          @uri ||= nil
+          EM.next_tick {
+            setup(make_raw_response(stubbed_webmock_response), @uri,
+                  stubbed_webmock_response.should_timeout ? Errno::ETIMEDOUT : nil)
+          }
+          self
+        elsif WebMock.net_connect_allowed?(request_signature.uri)
+          super
+        else
+          raise WebMock::NetConnectNotAllowedError.new(request_signature)
+        end
+      end
+
+      def unbind(reason = nil)
+        if !stubbed_webmock_response && WebMock::CallbackRegistry.any_callbacks?
+          webmock_response = build_webmock_response
+          WebMock::CallbackRegistry.invoke_callbacks(
+            {lib: :em_http_request, real_request: true},
+            request_signature,
+            webmock_response)
+        end
+        @request_signature = nil
+        remove_instance_variable(:@stubbed_webmock_response)
+
+        super
+      end
+
+      def request_signature
+        @request_signature ||= build_request_signature
+      end
+
+      def stubbed_webmock_response
+        unless defined?(@stubbed_webmock_response)
+          @stubbed_webmock_response = WebMock::StubRegistry.instance.response_for_request(request_signature)
+        end
+
+        @stubbed_webmock_response
+      end
+
+      def get_response_cookie(name)
+        name = name.to_s
+
+        raw_cookie = response_header.cookie
+        raw_cookie = [raw_cookie] if raw_cookie.is_a? String
+
+        cookie = raw_cookie.select { |c| c.start_with? name }.first
+        cookie and cookie.split('=', 2)[1]
+      end
+
+      private
+
+      def build_webmock_response
+        webmock_response = WebMock::Response.new
+        webmock_response.status = [response_header.status, response_header.http_reason]
+        webmock_response.headers = response_header
+        webmock_response.body = response
+        webmock_response
+      end
+
+      def build_request_signature
+        headers, body = build_request, @req.body
+
+        @conn.middleware.select {|m| m.respond_to?(:request) }.each do |m|
+          headers, body = m.request(self, headers, body)
+        end
+
+        method = @req.method
+        uri = @req.uri.clone
+        query = @req.query
+
+        uri.query = encode_query(@req.uri, query).slice(/\?(.*)/, 1)
+
+        body = form_encode_body(body) if body.is_a?(Hash)
+
+        if headers['authorization'] && headers['authorization'].is_a?(Array)
+          headers['Authorization'] = WebMock::Util::Headers.basic_auth_header(headers.delete('authorization'))
+        end
+
+        WebMock::RequestSignature.new(
+          method.downcase.to_sym,
+          uri.to_s,
+          body: body || (@req.file && File.read(@req.file)),
+          headers: headers
+        )
+      end
+
+      def make_raw_response(response)
+        response.raise_error_if_any
+
+        status, headers, body = response.status, response.headers, response.body
+        headers ||= {}
+
+        response_string = []
+        response_string << "HTTP/1.1 #{status[0]} #{status[1]}"
+
+        headers["Content-Length"] = body.bytesize unless headers["Content-Length"]
+        headers.each do |header, value|
+          if header =~ /set-cookie/i
+            [value].flatten.each do |cookie|
+              response_string << "#{header}: #{cookie}"
+            end
+          else
+            value = value.join(", ") if value.is_a?(Array)
+
+            # WebMock's internal processing will not handle the body
+            # correctly if the header indicates that it is chunked, unless
+            # we also create all the chunks.
+            # It's far easier just to remove the header.
+            next if header =~ /transfer-encoding/i && value =~/chunked/i
+
+            response_string << "#{header}: #{value}"
+          end
+        end if headers
+
+        response_string << "" << body
+        response_string.join("\n")
+      end
+    end
+  end
 end