webmock 1.6.4 → 1.7.0

data/lib/webmock/http_lib_adapters/net_http_response.rb

@@ -1,4 +1,4 @@
-# This code is entierly copied from VCR (http://github.com/myronmarston/vcr) by courtesy of Myron Marston  
+# This code is entierly copied from VCR (http://github.com/myronmarston/vcr) by courtesy of Myron Marston
 
 # A Net::HTTP response that has already been read raises an IOError when #read_body
 # is called with a destination string or block.
@@ -11,22 +11,22 @@
 # after it has aleady been read.  This attemps to preserve the behavior of
 # #read_body, acting just as if it had never been read.
 
-module WebMock
-  module Net
-    module HTTPResponse
-      def read_body(dest = nil, &block)
-        return super if @__read_body_previously_called
-        return @body if dest.nil? && block.nil?
-        raise ArgumentError.new("both arg and block given for HTTP method") if dest && block
-        return nil if @body.nil?
 
-        dest ||= ::Net::ReadAdapter.new(block)
-        dest << @body
-        @body = dest
-      ensure
-        # allow subsequent calls to #read_body to proceed as normal, without our hack...
-        @__read_body_previously_called = true
-      end
+module Net
+  module WebMockHTTPResponse
+    def read_body(dest = nil, &block)
+      return super if @__read_body_previously_called
+      return @body if dest.nil? && block.nil?
+      raise ArgumentError.new("both arg and block given for HTTP method") if dest && block
+      return nil if @body.nil?
+
+      dest ||= ::Net::ReadAdapter.new(block)
+      dest << @body
+      @body = dest
+    ensure
+      # allow subsequent calls to #read_body to proceed as normal, without our hack...
+      @__read_body_previously_called = true
     end
   end
-end
+end
+

data/lib/webmock/http_lib_adapters/patron_adapter.rb

@@ -0,0 +1,124 @@
+begin
+  require 'patron'
+rescue LoadError
+  # patron not found
+end
+
+if defined?(::Patron)
+  module WebMock
+    module HttpLibAdapters
+      class PatronAdapter < ::WebMock::HttpLibAdapter
+        adapter_for :patron
+
+        OriginalPatronSession = ::Patron::Session unless const_defined?(:OriginalPatronSession)
+
+        class WebMockPatronSession < ::Patron::Session
+          def handle_request_with_webmock(req)
+            request_signature =
+              WebMock::HttpLibAdapters::PatronAdapter.build_request_signature(req)
+
+            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)
+              WebMock::HttpLibAdapters::PatronAdapter.
+                handle_file_name(req, webmock_response)
+              res = WebMock::HttpLibAdapters::PatronAdapter.
+                build_patron_response(webmock_response)
+              WebMock::CallbackRegistry.invoke_callbacks(
+                {:lib => :patron}, request_signature, webmock_response)
+              res
+            elsif WebMock.net_connect_allowed?(request_signature.uri)
+              res = handle_request_without_webmock(req)
+              if WebMock::CallbackRegistry.any_callbacks?
+                webmock_response = WebMock::HttpLibAdapters::PatronAdapter.
+                  build_webmock_response(res)
+                WebMock::CallbackRegistry.invoke_callbacks(
+                  {:lib => :patron, :real_request => true}, request_signature,
+                    webmock_response)
+              end
+              res
+            else
+              raise WebMock::NetConnectNotAllowedError.new(request_signature)
+            end
+          end
+
+          alias_method :handle_request_without_webmock, :handle_request
+          alias_method :handle_request, :handle_request_with_webmock
+        end
+
+        def self.enable!
+          Patron.send(:remove_const, :Session)
+          Patron.send(:const_set, :Session, WebMockPatronSession)
+        end
+
+        def self.disable!
+          Patron.send(:remove_const, :Session)
+          Patron.send(:const_set, :Session, OriginalPatronSession)
+        end
+
+        def self.handle_file_name(req, webmock_response)
+          if req.action == :get && req.file_name
+            begin
+              File.open(req.file_name, "w") do |f|
+                f.write webmock_response.body
+              end
+            rescue Errno::EACCES
+              raise ArgumentError.new("Unable to open specified file.")
+            end
+          end
+        end
+
+        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
+              if !File.exist?(req.file_name) || !File.readable?(req.file_name)
+                raise ArgumentError.new("Unable to open specified file.")
+              end
+              request_body = File.read(req.file_name)
+            elsif req.upload_data
+              request_body = req.upload_data
+            else
+              raise ArgumentError.new("Must provide either data or a filename when doing a PUT or POST")
+            end
+          end
+
+          request_signature = WebMock::RequestSignature.new(
+            req.action,
+            uri.to_s,
+            :body => request_body,
+            :headers => req.headers
+          )
+          request_signature
+        end
+
+        def self.build_patron_response(webmock_response)
+          raise ::Patron::TimeoutError if webmock_response.should_timeout
+          webmock_response.raise_error_if_any
+          res = ::Patron::Response.new
+          res.instance_variable_set(:@body, webmock_response.body)
+          res.instance_variable_set(:@status, webmock_response.status[0])
+          res.instance_variable_set(:@status_line, webmock_response.status[1])
+          res.instance_variable_set(:@headers, webmock_response.headers)
+          res
+        end
+
+        def self.build_webmock_response(patron_response)
+          webmock_response = WebMock::Response.new
+          reason = patron_response.status_line.
+            scan(%r(\AHTTP/(\d+\.\d+)\s+(\d\d\d)\s*([^\r\n]+)?))[0][2]
+          webmock_response.status = [patron_response.status, reason]
+          webmock_response.body = patron_response.body
+          webmock_response.headers = patron_response.headers
+          webmock_response
+        end
+      end
+    end
+  end
+end

data/lib/webmock/http_lib_adapters/typhoeus_hydra_adapter.rb

@@ -0,0 +1,166 @@
+begin
+  require 'typhoeus'
+rescue LoadError
+  # typhoeus not found
+end
+
+if defined?(Typhoeus)
+
+  module WebMock
+    module HttpLibAdapters
+      class TyphoeusAdapter < HttpLibAdapter
+        adapter_for :typhoeus
+
+        def self.enable!
+          @disabled = false
+          add_after_request_callback
+          ::Typhoeus::Hydra.allow_net_connect = true
+        end
+
+        def self.disable!
+          @disabled = true
+          remove_after_request_callback
+          ::Typhoeus::Hydra.allow_net_connect = true
+        end
+
+        def self.disabled?
+          !!@disabled
+        end
+
+        def self.add_after_request_callback
+          unless Typhoeus::Hydra.
+            global_hooks[:after_request_before_on_complete].
+              include?(AFTER_REQUEST_CALLBACK)
+            Typhoeus::Hydra.
+              global_hooks[:after_request_before_on_complete] << AFTER_REQUEST_CALLBACK
+          end
+        end
+
+        def self.remove_after_request_callback
+          Typhoeus::Hydra.global_hooks[:after_request_before_on_complete].
+            delete_if {|v| v == AFTER_REQUEST_CALLBACK }
+        end
+
+        def self.build_request_signature(req)
+          uri = WebMock::Util::URI.heuristic_parse(req.url)
+          uri.path = uri.normalized_path.gsub("[^:]//","/")
+          if req.username
+            uri.user = req.username
+            uri.password = req.password
+          end
+
+          request_signature = WebMock::RequestSignature.new(
+            req.method,
+            uri.to_s,
+            :body => req.body,
+            :headers => req.headers
+          )
+          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]
+          webmock_response.body = typhoeus_response.body
+          webmock_response.headers = typhoeus_response.headers_hash
+          webmock_response
+        end
+
+        def self.stub_typhoeus(request_signature, webmock_response, typhoeus)
+          response = if webmock_response.should_timeout
+            ::Typhoeus::Response.new(
+              :code         => 0,
+              :status_message => "",
+              :body         => "",
+              :headers_hash => {}
+            )
+          else
+            ::Typhoeus::Response.new(
+              :code         => webmock_response.status[0],
+              :status_message => webmock_response.status[1],
+              :body         => webmock_response.body,
+              :headers_hash => webmock_response.headers
+            )
+          end
+
+
+          typhoeus.stub(
+            request_signature.method || :any,
+            /.*/,
+            :webmock_stub => true
+          ).and_return(response)
+        end
+
+        def self.request_hash(request_signature)
+          hash = {}
+
+          hash[:body]    = request_signature.body
+          hash[:headers] = request_signature.headers
+
+          hash
+        end
+
+        AFTER_REQUEST_CALLBACK = Proc.new do |request|
+          request_signature =
+            ::WebMock::HttpLibAdapters::TyphoeusAdapter.
+              build_request_signature(request)
+          webmock_response =
+            ::WebMock::HttpLibAdapters::TyphoeusAdapter.
+              build_webmock_response(request.response)
+          if request.response.mock?
+            WebMock::CallbackRegistry.invoke_callbacks(
+              {:lib => :typhoeus},
+              request_signature,
+              webmock_response
+            )
+          else
+            WebMock::CallbackRegistry.invoke_callbacks(
+              {:lib => :typhoeus, :real_request => true},
+              request_signature,
+              webmock_response
+            )
+          end
+        end
+      end
+    end
+  end
+
+
+  module Typhoeus
+    class Hydra
+      def queue_with_webmock(request)
+        self.clear_webmock_stubs
+
+        if WebMock::HttpLibAdapters::TyphoeusAdapter.disabled?
+          return queue_without_webmock(request)
+        end
+
+        request_signature =
+         ::WebMock::HttpLibAdapters::TyphoeusAdapter.build_request_signature(request)
+
+        ::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)
+          ::WebMock::HttpLibAdapters::TyphoeusAdapter.
+            stub_typhoeus(request_signature, webmock_response, self)
+          webmock_response.raise_error_if_any
+        elsif !WebMock.net_connect_allowed?(request_signature.uri)
+          raise WebMock::NetConnectNotAllowedError.new(request_signature)
+        end
+        queue_without_webmock(request)
+      end
+
+      alias_method :queue_without_webmock, :queue
+      alias_method :queue, :queue_with_webmock
+
+      def clear_webmock_stubs
+        self.stubs = [] unless self.stubs
+        self.stubs.delete_if {|s|
+          s.instance_variable_get(:@options)[:webmock_stub]
+        }
+      end
+    end
+  end
+end

data/lib/webmock/minitest.rb

@@ -0,0 +1,15 @@
+require 'minitest/unit'
+require 'webmock'
+
+MiniTest::Unit::TestCase.class_eval do
+  include WebMock::API
+
+  alias_method :teardown_without_webmock, :teardown
+  def teardown_with_webmock
+    teardown_without_webmock
+    WebMock.reset!
+  end
+  alias_method :teardown, :teardown_with_webmock
+end
+
+WebMock::AssertionFailure.error_class = MiniTest::Assertion

data/lib/webmock/rack_response.rb

@@ -0,0 +1,52 @@
+module WebMock
+  class RackResponse < Response
+    def initialize(app)
+      @app = app
+    end
+
+    def evaluate(request)
+      env = build_rack_env(request)
+
+      status, headers, response = @app.call(env)
+
+      Response.new(
+        :body => response.join,
+        :headers => headers,
+        :status => status
+      )
+    end
+
+    def build_rack_env(request)
+      uri = request.uri
+      headers = request.headers || {}
+      body = request.body || ''
+
+      env = {
+        # CGI variables specified by Rack
+        'REQUEST_METHOD' => request.method.to_s.upcase,
+        'CONTENT_TYPE'   => headers.delete('Content-Type'),
+        'CONTENT_LENGTH' => body.size,
+        'PATH_INFO'      => uri.path,
+        'QUERY_STRING'   => uri.query || '',
+        'SERVER_NAME'    => uri.host
+      }
+
+      # Rack-specific variables
+      env['rack.input']      = StringIO.new(body)
+      env['rack.version']    = Rack::VERSION
+      env['rack.url_scheme'] = uri.scheme
+      env['rack.run_once']   = true
+      env['rack.session']    = session
+
+      headers.each do |k, v|
+        env["HTTP_#{k.tr('-','_').upcase}"] = v
+      end
+
+      env
+    end
+
+    def session
+      @session ||= {}
+    end
+  end
+end

data/lib/webmock/request_pattern.rb

@@ -2,6 +2,8 @@ module WebMock
 
   class RequestPattern
 
+    attr_reader :method_pattern, :uri_pattern, :body_pattern, :headers_pattern
+
     def initialize(method, uri, options = {})
       @method_pattern = MethodPattern.new(method)
       @uri_pattern = create_uri_pattern(uri)
@@ -40,7 +42,7 @@ module WebMock
       @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 create_uri_pattern(uri)
       if uri.is_a?(Regexp)
         URIRegexpPattern.new(uri)
@@ -143,7 +145,7 @@ module WebMock
 
         case BODY_FORMATS[content_type]
         when :json then
-          matching_hashes?(Crack::JSON.parse(body), @pattern)
+          matching_hashes?(WebMock::Util::JSON.parse(body), @pattern)
         when :xml then
           matching_hashes?(Crack::XML.parse(body), @pattern)
         else

data/lib/webmock/request_signature.rb

@@ -33,6 +33,10 @@ module WebMock
       self.to_s == other.to_s
     end
 
+    def url_encoded?
+      headers && headers['Content-Type'] == 'application/x-www-form-urlencoded'
+    end
+
     private
 
     def assign_options(options)

data/lib/webmock/request_stub.rb

@@ -23,13 +23,17 @@ module WebMock
       self
     end
 
+    def to_rack(app, options={})
+      @responses_sequences << ResponsesSequence.new([RackResponse.new(app)])
+    end
+
     def to_raise(*exceptions)
-      @responses_sequences << ResponsesSequence.new([*exceptions].flatten.map {|e| 
+      @responses_sequences << ResponsesSequence.new([*exceptions].flatten.map {|e|
         ResponseFactory.response_for(:exception => e)
       })
       self
     end
-    
+
     def to_timeout
       @responses_sequences << ResponsesSequence.new([ResponseFactory.response_for(:should_timeout => true)])
       self
@@ -46,6 +50,10 @@ module WebMock
       end
     end
 
+    def has_responses?
+      !@responses_sequences.empty?
+    end
+
     def then
       self
     end
@@ -60,5 +68,30 @@ module WebMock
       self
     end
 
+    def matches?(request_signature)
+      self.request_pattern.matches?(request_signature)
+    end
+
+    def to_s
+      self.request_pattern.to_s
+    end
+
+    def self.from_request_signature(signature)
+      stub = self.new(signature.method.to_sym, signature.uri.to_s)
+
+      if signature.body.to_s != ''
+        body = if signature.url_encoded?
+          Addressable::URI.parse('?' + signature.body).query_values
+        else
+          signature.body
+        end
+        stub.with(:body => body)
+      end
+
+      if (signature.headers && !signature.headers.empty?)
+        stub.with(:headers => signature.headers)
+      end
+      stub
+    end
   end
 end