webmock 1.6.4 → 1.7.0

data/lib/webmock/http_lib_adapters/{em_http_request.rb → em_http_request/em_http_request_0_x.rb}

@@ -1,8 +1,26 @@
 if defined?(EventMachine::HttpRequest)
+  module WebMock
+    module HttpLibAdapters
+      class EmHttpRequestAdapter < HttpLibAdapter
+        adapter_for :em_http_request
 
-  module EventMachine
-    OriginalHttpRequest = HttpRequest unless const_defined?(:OriginalHttpRequest)
+        OriginalHttpRequest = EventMachine::HttpRequest unless const_defined?(:OriginalHttpRequest)
+
+        def self.enable!
+          EventMachine.send(:remove_const, :HttpRequest)
+          EventMachine.send(:const_set, :HttpRequest, EventMachine::WebMockHttpRequest)
+        end
+
+        def self.disable!
+          EventMachine.send(:remove_const, :HttpRequest)
+          EventMachine.send(:const_set, :HttpRequest, OriginalHttpRequest)
+        end
+      end
+    end
+  end
 
+
+  module EventMachine
     class WebMockHttpRequest < EventMachine::HttpRequest
 
       include HttpEncoding
@@ -126,19 +144,6 @@ if defined?(EventMachine::HttpRequest)
         response_string << "" << body
         response_string.join("\n")
       end
-
-      def self.activate!
-        EventMachine.send(:remove_const, :HttpRequest)
-        EventMachine.send(:const_set, :HttpRequest, WebMockHttpRequest)
-      end
-
-      def self.deactivate!
-        EventMachine.send(:remove_const, :HttpRequest)
-        EventMachine.send(:const_set, :HttpRequest, OriginalHttpRequest)
-      end
     end
   end
-
-  EventMachine::WebMockHttpRequest.activate!
-
 end

data/lib/webmock/http_lib_adapters/em_http_request/em_http_request_1_x.rb

@@ -0,0 +1,201 @@
+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)
+      # 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 webmock_activate_connection(client)
+        request_signature = client.request_signature
+
+        if WebMock::StubRegistry.instance.registered_request?(request_signature)
+          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)
+          real_activate_connection(client)
+        else
+          raise WebMock::NetConnectNotAllowedError.new(request_signature)
+        end
+      end
+      alias_method :real_activate_connection, :activate_connection
+      alias_method :activate_connection, :webmock_activate_connection
+    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)
+          fail(self)
+        else
+          @conn.receive_data(response)
+          succeed(self)
+        end
+      end
+
+      def send_request_with_webmock(head, body)
+        WebMock::RequestRegistry.instance.requested_signatures.put(request_signature)
+
+        if WebMock::StubRegistry.instance.registered_request?(request_signature)
+          webmock_response = WebMock::StubRegistry.instance.response_for_request(request_signature)
+          on_error("WebMock timeout error") if webmock_response.should_timeout
+          WebMock::CallbackRegistry.invoke_callbacks({:lib => :em_http_request}, request_signature, webmock_response)
+          EM.next_tick {
+            setup(make_raw_response(webmock_response), @uri,
+                  webmock_response.should_timeout ? "WebMock timeout error" : nil)
+          }
+          self
+        elsif WebMock.net_connect_allowed?(request_signature.uri)
+          send_request_without_webmock(head, body)
+          callback {
+            if 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
+          }
+          self
+        else
+          raise WebMock::NetConnectNotAllowedError.new(request_signature)
+        end
+      end
+
+      alias_method :send_request_without_webmock, :send_request
+      alias_method :send_request, :send_request_with_webmock
+
+      def request_signature
+        @request_signature ||= build_request_signature
+      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 = @req.headers, @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
+        auth = @req.proxy[:authorization]
+        query = @req.query
+
+        if auth
+          userinfo = auth.join(':')
+          userinfo = WebMock::Util::URI.encode_unsafe_chars_in_userinfo(userinfo)
+          if @req
+            @req.proxy.reject! {|k,v| t.to_s == 'authorization' }
+          else
+            options.reject! {|k,v| k.to_s == 'authorization' } #we added it to url userinfo
+          end
+          uri.userinfo = userinfo
+        end
+
+        uri.query = encode_query(@req.uri, query).slice(/\?(.*)/, 1)
+
+        WebMock::RequestSignature.new(
+          method.downcase.to_sym,
+          uri.to_s,
+          :body => body,
+          :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.length unless headers["Content-Length"]
+        headers.each do |header, value|
+          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 if headers
+
+        response_string << "" << body
+        response_string.join("\n")
+      end
+    end
+  end
+end

data/lib/webmock/http_lib_adapters/em_http_request_adapter.rb

@@ -0,0 +1,11 @@
+begin
+  require 'em-http-request'
+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')
+end

data/lib/webmock/http_lib_adapters/http_lib_adapter.rb

@@ -0,0 +1,7 @@
+module WebMock
+  class HttpLibAdapter
+    def self.adapter_for(lib)
+      WebMock::HttpLibAdapterRegistry.instance.register(lib, self)
+    end
+  end
+end

data/lib/webmock/http_lib_adapters/http_lib_adapter_registry.rb

@@ -0,0 +1,19 @@
+module WebMock
+  class HttpLibAdapterRegistry
+    include Singleton
+
+    attr_accessor :http_lib_adapters
+
+    def initialize
+      @http_lib_adapters = {}
+    end
+
+    def register(lib, adapter)
+      @http_lib_adapters[lib] = adapter
+    end
+
+    def each_adapter(&block)
+      @http_lib_adapters.each(&block)
+    end
+  end
+end

data/lib/webmock/http_lib_adapters/{httpclient.rb → httpclient_adapter.rb}

@@ -1,6 +1,33 @@
+begin
+  require 'httpclient'
+rescue LoadError
+  # httpclient not found
+end
+
 if defined?(::HTTPClient)
 
-  class ::HTTPClient
+  module WebMock
+    module HttpLibAdapters
+      class HTTPClientAdapter < HttpLibAdapter
+        adapter_for :httpclient
+
+        OriginalHttpClient = ::HTTPClient unless const_defined?(:OriginalHttpClient)
+
+        def self.enable!
+          Object.send(:remove_const, :HTTPClient)
+          Object.send(:const_set, :HTTPClient, WebMockHTTPClient)
+        end
+
+        def self.disable!
+          Object.send(:remove_const, :HTTPClient)
+          Object.send(:const_set, :HTTPClient, OriginalHttpClient)
+        end
+      end
+    end
+  end
+
+
+  class WebMockHTTPClient < HTTPClient
 
     def do_get_block_with_webmock(req, proxy, conn, &block)
       do_get_with_webmock(req, proxy, conn, false, &block)
@@ -20,7 +47,7 @@ if defined?(::HTTPClient)
         response = build_httpclient_response(webmock_response, stream, &block)
         res = conn.push(response)
         WebMock::CallbackRegistry.invoke_callbacks(
-          {:lib => :http_client}, request_signature, webmock_response) 
+          {:lib => :httpclient}, request_signature, webmock_response)
         res
       elsif WebMock.net_connect_allowed?(request_signature.uri)
         res = if stream
@@ -33,7 +60,7 @@ if defined?(::HTTPClient)
         if WebMock::CallbackRegistry.any_callbacks?
           webmock_response = build_webmock_response(res)
           WebMock::CallbackRegistry.invoke_callbacks(
-            {:lib => :http_client, :real_request => true}, request_signature,
+            {:lib => :httpclient, :real_request => true}, request_signature,
             webmock_response)
         end
         res
@@ -45,7 +72,7 @@ if defined?(::HTTPClient)
     def do_request_async_with_webmock(method, uri, query, body, extheader)
       req = create_request(method, uri, query, body, extheader)
       request_signature = build_request_signature(req)
-      
+
       if WebMock::StubRegistry.instance.registered_request?(request_signature) ||
          WebMock.net_connect_allowed?(request_signature.uri)
         do_request_async_without_webmock(method, uri, query, body, extheader)
@@ -70,7 +97,7 @@ if defined?(::HTTPClient)
       response.reason=webmock_response.status[1]
       webmock_response.headers.to_a.each { |name, value| response.header.set(name, value) }
 
-      raise HTTPClient::TimeoutError if webmock_response.should_timeout              
+      raise HTTPClient::TimeoutError if webmock_response.should_timeout
       webmock_response.raise_error_if_any
 
       block.call(nil, body) if block
@@ -78,7 +105,7 @@ if defined?(::HTTPClient)
       response
     end
   end
-  
+
   def build_webmock_response(httpclient_response)
     webmock_response = WebMock::Response.new
     webmock_response.status = [httpclient_response.status, httpclient_response.reason]
@@ -102,8 +129,8 @@ if defined?(::HTTPClient)
 
     auth = www_auth.basic_auth
     auth.challenge(req.header.request_uri, nil)
-    
-    headers = req.header.all.inject({}) do |headers, header| 
+
+    headers = req.header.all.inject({}) do |headers, header|
       headers[header[0]] ||= [];
       headers[header[0]] << header[1]
       headers

data/lib/webmock/http_lib_adapters/net_http.rb

@@ -3,6 +3,36 @@ require 'net/https'
 require 'stringio'
 require File.join(File.dirname(__FILE__), 'net_http_response')
 
+
+module WebMock
+  module HttpLibAdapters
+    class NetHttpAdapter < HttpLibAdapter
+      adapter_for :net_http
+
+      OriginalNetHTTP = Net::HTTP unless const_defined?(:OriginalNetHTTP)
+      OriginalNetBufferedIO = Net::BufferedIO unless const_defined?(:OriginalNetBufferedIO)
+
+      def self.enable!
+        Net.send(:remove_const, :BufferedIO)
+        Net.send(:remove_const, :HTTP)
+        Net.send(:remove_const, :HTTPSession)
+        Net.send(:const_set, :HTTP, Net::WebMockNetHTTP)
+        Net.send(:const_set, :HTTPSession, Net::WebMockNetHTTP)
+        Net.send(:const_set, :BufferedIO, Net::WebMockNetBufferedIO)
+      end
+
+      def self.disable!
+        Net.send(:remove_const, :BufferedIO)
+        Net.send(:remove_const, :HTTP)
+        Net.send(:remove_const, :HTTPSession)
+        Net.send(:const_set, :HTTP, OriginalNetHTTP)
+        Net.send(:const_set, :HTTPSession, OriginalNetHTTP)
+        Net.send(:const_set, :BufferedIO, OriginalNetBufferedIO)
+      end
+    end
+  end
+end
+
 class StubSocket #:nodoc:
 
   def initialize(*args)
@@ -19,7 +49,7 @@ end
 
 module Net  #:nodoc: all
 
-  class BufferedIO
+  class WebMockNetBufferedIO < BufferedIO
     def initialize_with_webmock(io, debug_output = nil)
       @read_timeout = 60
       @rbuf = ''
@@ -37,7 +67,7 @@ module Net  #:nodoc: all
     alias_method :initialize, :initialize_with_webmock
   end
 
-  class HTTP
+  class WebMockNetHTTP < HTTP
     class << self
       def socket_type_with_webmock
         StubSocket
@@ -58,16 +88,27 @@ module Net  #:nodoc: all
           {:lib => :net_http}, request_signature, webmock_response)
         build_net_http_response(webmock_response, &block)
       elsif WebMock.net_connect_allowed?(request_signature.uri)
-        connect_without_webmock
-        response = request_without_webmock(request, nil)
-        if WebMock::CallbackRegistry.any_callbacks? && started?
-          webmock_response = build_webmock_response(response)
-          WebMock::CallbackRegistry.invoke_callbacks(
-            {:lib => :net_http, :real_request => true}, request_signature, webmock_response)
+        check_right_http_connection
+        after_request = lambda do |response|
+          if WebMock::CallbackRegistry.any_callbacks?
+            webmock_response = build_webmock_response(response)
+            WebMock::CallbackRegistry.invoke_callbacks(
+              {:lib => :net_http, :real_request => true}, request_signature, webmock_response)
+          end
+          response.extend Net::WebMockHTTPResponse
+          block.call response if block
+          response
+        end
+        response = if (started? && !WebMock::Config.instance.net_http_connect_on_start) || !started?
+          @started = false #otherwise start_with_connect wouldn't execute and connect
+          start_with_connect {
+            response = request_without_webmock(request, nil)
+            after_request.call(response)
+          }
+        else
+          response = request_without_webmock(request, nil)
+          after_request.call(response)
         end
-        response.extend WebMock::Net::HTTPResponse
-        yield response if block_given?
-        response
       else
         raise WebMock::NetConnectNotAllowedError.new(request_signature)
       end
@@ -75,33 +116,43 @@ module Net  #:nodoc: all
     alias_method :request_without_webmock, :request
     alias_method :request, :request_with_webmock
 
-
-    def connect_with_webmock
-      unless @@alredy_checked_for_right_http_connection ||= false
-        WebMock::NetHTTPUtility.puts_warning_for_right_http_if_needed
-        @@alredy_checked_for_right_http_connection = true
+    def start_without_connect
+      raise IOError, 'HTTP session already opened' if @started
+      if block_given?
+        begin
+          @started = true
+          return yield(self)
+        ensure
+          do_finish
+        end
       end
+      @started = true
+      self
+    end
+
+    def start_with_conditional_connect(&block)
       if WebMock::Config.instance.net_http_connect_on_start
-        return connect_without_webmock
+        start_with_connect(&block)
+      else
+        start_without_connect(&block)
       end
-      nil
     end
-    alias_method :connect_without_webmock, :connect
-    alias_method :connect, :connect_with_webmock
+    alias_method :start_with_connect, :start
+    alias_method :start, :start_with_conditional_connect
 
     def build_net_http_response(webmock_response, &block)
       response = Net::HTTPResponse.send(:response_class, webmock_response.status[0].to_s).new("1.0", webmock_response.status[0].to_s, webmock_response.status[1])
       response.instance_variable_set(:@body, webmock_response.body)
-      webmock_response.headers.to_a.each do |name, values| 
+      webmock_response.headers.to_a.each do |name, values|
         values = [values] unless values.is_a?(Array)
         values.each do |value|
           response.add_field(name, value)
         end
-      end  
+      end
 
       response.instance_variable_set(:@read, true)
 
-      response.extend WebMock::Net::HTTPResponse
+      response.extend Net::WebMockHTTPResponse
 
       raise Timeout::Error, "execution expired" if webmock_response.should_timeout
 
@@ -111,18 +162,26 @@ module Net  #:nodoc: all
 
       response
     end
-    
+
     def build_webmock_response(net_http_response)
       webmock_response = WebMock::Response.new
       webmock_response.status = [
          net_http_response.code.to_i,
          net_http_response.message]
       webmock_response.headers = net_http_response.to_hash
-      webmock_response.body = net_http_response.body   
+      webmock_response.body = net_http_response.body
       webmock_response
     end
 
+
+    def check_right_http_connection
+      unless @@alredy_checked_for_right_http_connection ||= false
+        WebMock::NetHTTPUtility.puts_warning_for_right_http_if_needed
+        @@alredy_checked_for_right_http_connection = true
+      end
+    end
   end
+  Net::WebMockNetHTTP.version_1_2
 
 end