webmock 1.3.5 → 1.4.0

data/lib/webmock/http_lib_adapters/em_http_request.rb

@@ -30,8 +30,8 @@ if defined?(EventMachine::HttpRequest)
 
         WebMock::RequestRegistry.instance.requested_signatures.put(request_signature)
 
-        if WebMock.registered_request?(request_signature)
-          webmock_response = WebMock.response_for_request(request_signature)
+        if WebMock::RequestRegistry.instance.registered_request?(request_signature)
+          webmock_response = WebMock::RequestRegistry.instance.response_for_request(request_signature)
           WebMock::CallbackRegistry.invoke_callbacks(
             {:lib => :em_http_request}, request_signature, webmock_response)
           client = WebMockFakeHttpClient.new(nil)

data/lib/webmock/http_lib_adapters/httpclient.rb

@@ -15,8 +15,8 @@ if defined?(::HTTPClient)
 
       WebMock::RequestRegistry.instance.requested_signatures.put(request_signature)
 
-      if WebMock.registered_request?(request_signature)
-        webmock_response = WebMock.response_for_request(request_signature)
+      if WebMock::RequestRegistry.instance.registered_request?(request_signature)
+        webmock_response = WebMock::RequestRegistry.instance.response_for_request(request_signature)
         response = build_httpclient_response(webmock_response, stream, &block)
         res = conn.push(response)
         WebMock::CallbackRegistry.invoke_callbacks(
@@ -46,7 +46,8 @@ if defined?(::HTTPClient)
       req = create_request(method, uri, query, body, extheader)
       request_signature = build_request_signature(req)
       
-      if WebMock.registered_request?(request_signature) || WebMock.net_connect_allowed?(request_signature.uri)
+      if WebMock::RequestRegistry.instance.registered_request?(request_signature) ||
+         WebMock.net_connect_allowed?(request_signature.uri)
         do_request_async_without_webmock(method, uri, query, body, extheader)
       else
         raise WebMock::NetConnectNotAllowedError.new(request_signature)

data/lib/webmock/http_lib_adapters/net_http.rb

@@ -51,9 +51,9 @@ module Net  #:nodoc: all
 
       WebMock::RequestRegistry.instance.requested_signatures.put(request_signature)
 
-      if WebMock.registered_request?(request_signature)
+      if WebMock::RequestRegistry.instance.registered_request?(request_signature)
         @socket = Net::HTTP.socket_type.new
-        webmock_response = WebMock.response_for_request(request_signature)
+        webmock_response = WebMock::RequestRegistry.instance.response_for_request(request_signature)
         WebMock::CallbackRegistry.invoke_callbacks(
           {:lib => :net_http}, request_signature, webmock_response)
         build_net_http_response(webmock_response, &block)

data/lib/webmock/http_lib_adapters/net_http_response.rb

@@ -14,36 +14,18 @@
 module WebMock
   module Net
     module HTTPResponse
-      def self.extended(object)
-        body_object = object.instance_variable_get(:@body)
-        object.instance_variable_set(:@__orig_body__,
-          case body_object
-            when String then body_object
-            when nil then nil
-            else raise ArgumentError.new("Unexpected body object: #{body_object}")
-          end
-        )
-      end
-
       def read_body(dest = nil, &block)
-        if @__orig_body__
-          if dest && block
-            raise ArgumentError.new("both arg and block given for HTTP method")
-          elsif dest
-            dest << @__orig_body__
-          elsif block
-            @body = ::Net::ReadAdapter.new(block)
-            @body << @__orig_body__
-            @body
-          else
-            @body = @__orig_body__
-          end
-        else
-          super
-        end
+        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...
-        @__orig_body__ = nil
+        @__read_body_previously_called = true
       end
     end
   end

data/lib/webmock/http_lib_adapters/patron.rb

@@ -8,8 +8,8 @@ if defined?(Patron)
 
         WebMock::RequestRegistry.instance.requested_signatures.put(request_signature)
 
-        if WebMock.registered_request?(request_signature)
-          webmock_response = WebMock.response_for_request(request_signature)
+        if WebMock::RequestRegistry.instance.registered_request?(request_signature)
+          webmock_response = WebMock::RequestRegistry.instance.response_for_request(request_signature)
           handle_file_name(req, webmock_response)
           res = build_patron_response(webmock_response)
           WebMock::CallbackRegistry.invoke_callbacks(

data/lib/webmock/util/uri.rb

@@ -66,6 +66,11 @@ module WebMock
         Addressable::URI.encode_component(userinfo, Addressable::URI::CharacterClasses::USERINFO)
       end
 
+      def self.is_uri_localhost?(uri)
+        uri.is_a?(Addressable::URI) && 
+        %w(localhost 127.0.0.1 0.0.0.0).include?(uri.host)
+      end
+
       private
 
       def self.sort_query_values(query_values)

data/lib/webmock/webmock.rb

@@ -1,76 +1,82 @@
 module WebMock
-  extend self
 
-  def self.version
-    open(File.join(File.dirname(__FILE__), '../../VERSION')) { |f|
-      f.read.strip
-    }
-  end
-
-  def stub_request(method, uri)
-    RequestRegistry.instance.register_request_stub(RequestStub.new(method, uri))
+  def self.included(clazz)
+    WebMock::Deprecation.warning("include WebMock is deprecated. Please include WebMock::API instead")
+    if clazz.instance_methods.map(&:to_s).include?('request')
+      warn "WebMock#request was not included in #{clazz} to avoid name collision"
+    else
+      clazz.class_eval do
+        def request(method, uri)
+          WebMock::Deprecation.warning("WebMock#request is deprecated. Please use WebMock::API#a_request method instead")
+          WebMock.a_request(method, uri)
+        end
+      end
+    end
   end
 
-  alias_method :stub_http_request, :stub_request
-
-  def request(method, uri)
-    RequestPattern.new(method, uri)
-  end
+  include WebMock::API
+  extend WebMock::API
 
-  def assert_requested(method, uri, options = {}, &block)
-    expected_times_executed = options.delete(:times) || 1
-    request = RequestPattern.new(method, uri, options).with(&block)
-    verifier = RequestExecutionVerifier.new(request, expected_times_executed)
-    assertion_failure(verifier.failure_message) unless verifier.matches?
+  class << self
+    alias :request :a_request
   end
 
-  def assert_not_requested(method, uri, options = {}, &block)
-    request = RequestPattern.new(method, uri, options).with(&block)
-    verifier = RequestExecutionVerifier.new(request, options.delete(:times))
-    assertion_failure(verifier.negative_failure_message) unless verifier.does_not_match?
+  def self.version
+    open(File.join(File.dirname(__FILE__), '../../VERSION')) { |f|
+      f.read.strip
+    }
   end
 
-  def allow_net_connect!
+  def self.allow_net_connect!
     Config.instance.allow_net_connect = true
   end
 
-  def disable_net_connect!(options = {})
+  def self.disable_net_connect!(options = {})
     Config.instance.allow_net_connect = false
     Config.instance.allow_localhost = options[:allow_localhost]
     Config.instance.allow = options[:allow]
   end
 
-  def net_connect_allowed?(uri = nil)
+  def self.net_connect_allowed?(uri = nil)
     if uri.is_a?(String)
       uri = WebMock::Util::URI.normalize_uri(uri)
     end
     Config.instance.allow_net_connect ||
-      (Config.instance.allow_localhost && uri.is_a?(Addressable::URI) && (uri.host == 'localhost' || uri.host == '127.0.0.1')) ||
+      (Config.instance.allow_localhost && WebMock::Util::URI.is_uri_localhost?(uri)) ||
       Config.instance.allow && Config.instance.allow.include?(uri.host)
   end
 
-  def registered_request?(request_signature)
-    RequestRegistry.instance.registered_request?(request_signature)
+  def self.reset_webmock
+    WebMock::RequestRegistry.instance.reset_webmock
   end
 
-  def response_for_request(request_signature, &block)
-    RequestRegistry.instance.response_for_request(request_signature, &block)
+  def self.reset_callbacks
+    WebMock::CallbackRegistry.reset
   end
 
-  def reset_webmock
-    WebMock::RequestRegistry.instance.reset_webmock
+  def self.after_request(options={}, &block)
+    CallbackRegistry.add_callback(options, block)
   end
 
-  def reset_callbacks
-    WebMock::CallbackRegistry.reset
+  def self.registered_request?(request_signature)
+    RequestRegistry.instance.registered_request?(request_signature)
   end
 
-  def assertion_failure(message)
-    raise message
-  end
-  
-  def after_request(options={}, &block)
-    CallbackRegistry.add_callback(options, block)
+  %w(
+    allow_net_connect!
+    disable_net_connect!
+    net_connect_allowed?
+    reset_webmock
+    reset_callbacks
+    after_request
+    registered_request?
+  ).each do |method|
+    self.class_eval(%Q(
+      def #{method}(*args, &block)
+        WebMock::Deprecation.warning("WebMock##{method} instance method is deprecated. Please use WebMock.#{method} class method instead")
+        WebMock.#{method}(*args, &block)
+      end
+    ))
   end
 
 end

data/spec/curb_spec.rb

@@ -0,0 +1,173 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+require 'webmock_spec'
+
+unless RUBY_PLATFORM =~ /java/
+  require 'curb_spec_helper'
+
+  describe "Curb", :shared => true do
+    include CurbSpecHelper
+    
+    it_should_behave_like "WebMock"
+
+    describe "when doing PUTs" do
+      it "should stub them" do
+        stub_http_request(:put, "www.example.com").with(:body => "01234")
+        http_request(:put, "http://www.example.com", :body => "01234").
+          status.should == "200"
+      end
+    end
+  end
+
+  describe "Curb features" do
+    before(:each) do
+      WebMock.disable_net_connect!
+      WebMock::RequestRegistry.instance.reset_webmock
+    end
+
+    describe "callbacks" do
+      before(:each) do
+        @curl = Curl::Easy.new
+        @curl.url = "http://example.com"
+      end
+
+      it "should call on_success with 2xx response" do
+        body = "on_success fired"
+        stub_request(:any, "example.com").to_return(:body => body)
+
+        test = nil
+        @curl.on_success do |c| 
+          test = c.body_str
+        end
+        @curl.http_get
+        test.should == body
+      end
+
+      it "should call on_failure with 5xx response" do
+        response_code = 599
+        stub_request(:any, "example.com").
+          to_return(:status => [response_code, "Server On Fire"])
+
+        test = nil
+        @curl.on_failure do |c, code| 
+          test = code
+        end
+        @curl.http_get
+        test.should == response_code
+      end
+
+      it "should call on_body when response body is read" do
+        body = "on_body fired"
+        stub_request(:any, "example.com").
+          to_return(:body => body)
+
+        test = nil
+        @curl.on_body do |data| 
+          test = data
+        end
+        @curl.http_get
+        test.should == body
+      end
+      
+      it "should call on_header when response headers are read" do
+        stub_request(:any, "example.com").
+          to_return(:headers => {:one => 1})
+
+        test = nil
+        @curl.on_header do |data| 
+          test = data
+        end
+        @curl.http_get
+        test.should match /One: 1/
+      end
+
+      it "should call on_complete when request is complete" do
+        body = "on_complete fired"
+        stub_request(:any, "example.com").to_return(:body => body)
+
+        test = nil
+        @curl.on_complete do |curl|
+          test = curl.body_str
+        end
+        @curl.http_get
+        test.should == body
+      end
+
+      it "should call on_progress when portion of response body is read" do
+        stub_request(:any, "example.com").to_return(:body => "01234")
+
+        test = nil
+        @curl.on_progress do |*args|
+          args.length.should == 4
+          args.each {|arg| arg.is_a?(Float).should == true }
+          test = true
+        end
+        @curl.http_get
+        test.should == true
+      end
+
+      it "should call callbacks in correct order on successful request" do
+        stub_request(:any, "example.com")
+        order = []
+        @curl.on_success {|*args| order << :on_success }
+        @curl.on_failure {|*args| order << :on_failure }
+        @curl.on_header {|*args| order << :on_header }
+        @curl.on_body {|*args| order << :on_body }
+        @curl.on_complete {|*args| order << :on_complete }
+        @curl.on_progress {|*args| order << :on_progress }
+        @curl.http_get
+
+        order.should == [:on_progress,:on_header,:on_body,:on_complete,:on_success]
+      end
+
+      it "should call callbacks in correct order on successful request" do
+        stub_request(:any, "example.com").to_return(:status => [500, ""])
+        order = []
+        @curl.on_success {|*args| order << :on_success }
+        @curl.on_failure {|*args| order << :on_failure }
+        @curl.on_header {|*args| order << :on_header }
+        @curl.on_body {|*args| order << :on_body }
+        @curl.on_complete {|*args| order << :on_complete }
+        @curl.on_progress {|*args| order << :on_progress }
+        @curl.http_get
+
+        order.should == [:on_progress,:on_header,:on_body,:on_complete,:on_failure]
+      end
+    end
+  end
+
+  describe "Webmock with Curb" do
+    describe "using #http for requests" do
+      it_should_behave_like "Curb"
+      include CurbSpecHelper::DynamicHttp
+
+      it "should work with uppercase arguments" do
+        stub_request(:get, "www.example.com").to_return(:body => "abc")
+
+        c = Curl::Easy.new
+        c.url = "http://www.example.com"
+        c.http(:GET)
+        c.body_str.should == "abc"
+      end
+    end
+
+    describe "using #http_* methods for requests" do
+      it_should_behave_like "Curb"
+      include CurbSpecHelper::NamedHttp
+    end
+
+    describe "using #perform for requests" do
+      it_should_behave_like "Curb"
+      include CurbSpecHelper::Perform
+    end
+
+    describe "using .http_* methods for requests" do
+      it_should_behave_like "Curb"
+      include CurbSpecHelper::ClassNamedHttp
+    end
+
+    describe "using .perform for requests" do
+      it_should_behave_like "Curb"
+      include CurbSpecHelper::ClassPerform
+    end
+  end
+end

data/spec/curb_spec_helper.rb

@@ -0,0 +1,137 @@
+module CurbSpecHelper
+  def http_request(method, uri, options = {}, &block)
+    uri = Addressable::URI.heuristic_parse(uri)
+    body = options[:body]
+
+    curl = curb_http_request(uri, method, body, options)
+
+    status, response_headers = Curl::Easy::WebmockHelper.parse_header_string(curl.header_str)
+
+    OpenStruct.new(
+      :body => curl.body_str,
+      :headers => WebMock::Util::Headers.normalize_headers(response_headers),
+      :status => curl.response_code.to_s,
+      :message => status
+    )
+  end
+
+  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.timeout  = 10
+
+    if headers = options[:headers]
+      headers.each {|k,v| curl.headers[k] = v }
+    end
+
+    curl
+  end
+
+  def default_client_request_headers(request_method = nil, has_body = false)
+    nil
+  end
+
+  def client_timeout_exception_class
+    Curl::Err::TimeoutError
+  end
+
+  def connection_refused_exception_class
+    Curl::Err::ConnectionFailedError
+  end
+
+  def setup_expectations_for_real_request(options = {})
+  end
+
+  def http_library
+    :curb
+  end
+
+  module DynamicHttp
+    def curb_http_request(uri, method, body, options)
+      curl = setup_request(uri, nil, options)
+
+      case method
+      when :post
+        curl.post_body = body
+      when :put
+        curl.put_data = body
+      end  
+
+      curl.http(method)
+      curl
+    end
+  end
+
+  module NamedHttp
+    def curb_http_request(uri, method, body, options)
+      curl = setup_request(uri, nil, options)
+
+      case method
+      when :put, :post
+        curl.send( "http_#{method}", body )
+      else
+        curl.send( "http_#{method}" )
+      end
+      curl
+    end
+  end
+
+  module Perform
+    def curb_http_request(uri, method, body, options)
+      curl = setup_request(uri, nil, options)
+
+      case method
+      when :post
+        curl.post_body = body
+      when :put
+        curl.put_data = body
+      when :head
+        curl.head = true
+      when :delete
+        curl.delete = true
+      end
+
+      curl.perform
+      curl
+    end
+  end
+
+  module ClassNamedHttp
+    def curb_http_request(uri, method, body, options)
+      args = ["http_#{method}", uri]
+      args << body if method == :post || method == :put
+
+      c = Curl::Easy.send(*args) do |curl|
+        setup_request(uri, curl, options)
+      end
+
+      c
+    end
+  end
+
+  module ClassPerform
+    def curb_http_request(uri, method, body, options)
+      args = ["http_#{method}", uri]
+      args << body if method == :post || method == :put
+
+      c = Curl::Easy.send(*args) do |curl|
+        setup_request(uri, curl, options)
+
+        case method
+        when :post
+          curl.post_body = body
+        when :put
+          curl.put_data = body
+        when :head
+          curl.head = true
+        when :delete
+          curl.delete = true
+        end
+      end
+
+      c
+    end
+  end
+end