webmock 0.7.3 → 0.8.0

data/CHANGELOG

@@ -1,9 +1,24 @@
+== 0.8.0
+
+  * Support for HTTPClient (sync and async requests)
+  * Support for dynamic responses. Response body and headers can be now declared as lambda. 
+	(Thanks to Ivan Vega ( @ivanyv ) for suggesting this feature)
+  * Support for stubbing and expecting requests with empty body
+  * Executing non-stubbed request leads to failed expectation instead of error
+
+=== Bug fixes
+
+  * Basic authentication now works correctly
+  * Fixed problem where WebMock didn't call a block with the response when block was provided
+  * Fixed problem where uris with single slash were not matching uris without path provided
+
 == 0.7.3
 
   * Clarified documentation
   * Fixed some issues with loading of Webmock classes
   * Test::Unit and RSpec adapters have to be required separately
 
+
 == 0.7.2
 
   * Added support for matching escaped and non escaped URLs

data/README.md

@@ -13,6 +13,7 @@ Features
 * Smart matching of the same headers in different representations.
 * Support for Test::Unit and RSpec (and can be easily extended to other frameworks)
 * Support for Net::HTTP and other http libraries based on Net::HTTP (i.e RightHttpConnection, rest-client, HTTParty)
+* Support for HTTPClient library (both sync and async requests)
 * Easy to extend to other HTTP libraries except Net::HTTP
 
 Installation
@@ -47,15 +48,15 @@ You can also use WebMock without RSpec or Test::Unit support:
 
 ### Stubbed request based on uri only and with the default response
 
-	 stub_request(:any, "www.google.com")
+	 stub_request(:any, "www.example.com")
 
-	 Net::HTTP.get("www.google.com", "/")    # ===> Success
+	 Net::HTTP.get("www.example.com", "/")    # ===> Success
 
 ### Stubbing requests based on method, uri, body and headers
 
-	stub_request(:post, "www.google.com").with(:body => "abc", :headers => { 'Content-Length' => 3 })
+	stub_request(:post, "www.example.com").with(:body => "abc", :headers => { 'Content-Length' => 3 })
 
-	uri = URI.parse("http://www.google.com/")
+	uri = URI.parse("http://www.example.com/")
     req = Net::HTTP::Post.new(uri.path)
 	req['Content-Length'] = 3
     res = Net::HTTP.start(uri.host, uri.port) {|http|
@@ -64,10 +65,10 @@ You can also use WebMock without RSpec or Test::Unit support:
 
 ### Matching custom request headers
 
-    stub_request(:any, "www.google.com").
+    stub_request(:any, "www.example.com").
 	  with( :headers=>{ 'Header-Name' => 'Header-Value' } ).to_return(:body => "abc", :status => 200)
 
-	uri = URI.parse('http://www.google.com/')
+	uri = URI.parse('http://www.example.com/')
     req = Net::HTTP::Post.new(uri.path)
 	req['Header-Name'] = 'Header-Value'
     res = Net::HTTP.start(uri.host, uri.port) {|http|
@@ -76,37 +77,48 @@ You can also use WebMock without RSpec or Test::Unit support:
 
 ### Stubbing with custom response
 
-	stub_request(:any, "www.google.com").to_return(:body => "abc", :status => 200,  :headers => { 'Content-Length' => 3 } )
+	stub_request(:any, "www.example.com").to_return(:body => "abc", :status => 200,  :headers => { 'Content-Length' => 3 } )
 	
-	Net::HTTP.get("www.google.com", '/')    # ===> "abc"
+	Net::HTTP.get("www.example.com", '/')    # ===> "abc"
 
-### Custom response with body specified as a path to file
+### Custom response with body specified as IO object
 
 	File.open('/tmp/response_body.txt', 'w') { |f| f.puts 'abc' }
 
-	stub_request(:any, "www.google.com").to_return(:body => "/tmp/response_body.txt", :status => 200)
+	stub_request(:any, "www.example.com").to_return(:body => File.new('/tmp/response_body.txt'), :status => 200)
 
-	Net::HTTP.get('www.google.com', '/')    # ===> "abc\n"
+	Net::HTTP.get('www.example.com', '/')    # ===> "abc\n"
+
+### Custom response with dynamically evaluated response
+	
+    stub_request(:any, 'www.example.net').
+      to_return(:body => lambda { |request| request.body })
+
+    RestClient.post('www.example.net', 'abc')    # ===> "abc\n"	
 
 ### Request with basic authentication
 
-	stub_request(:any, "john:smith@www.google.com")
-	
-	Net::HTTP.get(URI.parse('http://john:smith@www.google.com'))    # ===> Success
+    stub_request(:get, "user:pass@www.example.com")
+
+    Net::HTTP.start('www.example.com') {|http|
+      req = Net::HTTP::Get.new('/')
+      req.basic_auth 'user', 'pass'
+      http.request(req)
+    }  # ===> Success
 
 ### Matching uris using regular expressions
 
-	 stub_request(:any, /.*google.*/)
+	 stub_request(:any, /.*example.*/)
 
-	 Net::HTTP.get('www.google.com', '/') # ===> Success
+	 Net::HTTP.get('www.example.com', '/') # ===> Success
 
 ### Real requests to network can be allowed or disabled
 
 	WebMock.allow_net_connect!
 
-	stub_request(:any, "www.google.com").to_return(:body => "abc")
+	stub_request(:any, "www.example.com").to_return(:body => "abc")
 
-	Net::HTTP.get('www.google.com', '/')    # ===> "abc"
+	Net::HTTP.get('www.example.com', '/')    # ===> "abc"
 	
 	Net::HTTP.get('www.something.com', '/') # ===> /.+Something.+/
 	
@@ -120,16 +132,16 @@ You can also use WebMock without RSpec or Test::Unit support:
 ### Setting expectations in Test::Unit
 	require 'webmock/test_unit'
 
-    stub_request(:any, "www.google.com")
+    stub_request(:any, "www.example.com")
 
-	uri = URI.parse('http://www.google.com/')
+	uri = URI.parse('http://www.example.com/')
     req = Net::HTTP::Post.new(uri.path)
 	req['Content-Length'] = 3
     res = Net::HTTP.start(uri.host, uri.port) {|http|
       http.request(req, 'abc')
     }
 
-	assert_requested :post, "http://www.google.com",
+	assert_requested :post, "http://www.example.com",
 	  :headers => {'Content-Length' => 3}, :body => "abc", :times => 1    # ===> Success
 	
 	assert_not_requested :get, "http://www.something.com"    # ===> Success
@@ -138,9 +150,9 @@ You can also use WebMock without RSpec or Test::Unit support:
 
 	WebMock.allow_net_connect!
 	
-	Net::HTTP.get('www.google.com', '/')    # ===> Success
+	Net::HTTP.get('www.example.com', '/')    # ===> Success
 
-	assert_requested :get, "http://www.google.com"    # ===> Success
+	assert_requested :get, "http://www.example.com"    # ===> Success
 
 
 ### Setting expectations in RSpec
@@ -148,13 +160,13 @@ You can also use WebMock without RSpec or Test::Unit support:
 
 	require 'webmock/rspec'
 
-	WebMock.should have_requested(:get, "www.google.com").with(:body => "abc", :headers => {'Content-Length' => 3}).twice
+	WebMock.should have_requested(:get, "www.example.com").with(:body => "abc", :headers => {'Content-Length' => 3}).twice
 	
 	WebMock.should_not have_requested(:get, "www.something.com")
 
 ### Different way of setting expectations in RSpec
 
-	request(:post, "www.google.com").with(:body => "abc", :headers => {'Content-Length' => 3}).should have_been_made.once
+	request(:post, "www.example.com").with(:body => "abc", :headers => {'Content-Length' => 3}).should have_been_made.once
 
 	request(:post, "www.something.com").should have_been_made.times(3)
 
@@ -165,34 +177,34 @@ You can also use WebMock without RSpec or Test::Unit support:
 
 If you want to reset all current stubs and history of requests use `WebMock.reset_webmock`
 
-	stub_request(:any, "www.google.com")
+	stub_request(:any, "www.example.com")
 
-	Net::HTTP.get('www.google.com', '/')    # ===> Success
+	Net::HTTP.get('www.example.com', '/')    # ===> Success
 
 	reset_webmock
 
-	Net::HTTP.get('www.google.com', '/')    # ===> Failure
+	Net::HTTP.get('www.example.com', '/')    # ===> Failure
 
-	assert_not_requested :get, "www.google.com"    # ===> Success
+	assert_not_requested :get, "www.example.com"    # ===> Success
 
 
 ## Matching requests
 
 An executed request matches stubbed request if it passes following criteria:
 
-  Request URI matches stubbed request URI string or Regexp pattern<br/>
+  When request URI matches stubbed request URI string or Regexp pattern<br/>
   And request method is the same as stubbed request method or stubbed request method is :any<br/>
-  And request body is the same as stubbed request body or stubbed request body is not set (is nil)<br/>
-  And request headers match stubbed request headers, or stubbed request headers match a subset of request headers, or stubbed request headers are not set
+  And request body is the same as stubbed request body or stubbed request body is not specified<br/>
+  And request headers match stubbed request headers, or stubbed request headers match a subset of request headers, or stubbed request headers are not specified
 
 ## Precedence of stubs
 
 Always the last declared stub matching the request will be applied i.e:
 
-	stub_request(:get, "www.google.com").to_return(:body => "abc")
-	stub_request(:get, "www.google.com").to_return(:body => "def")
+	stub_request(:get, "www.example.com").to_return(:body => "abc")
+	stub_request(:get, "www.example.com").to_return(:body => "def")
 
-	Net::HTTP.get('www.google.com', '/')   # ====> "def"
+	Net::HTTP.get('www.example.com', '/')   # ====> "def"
 
 ## Matching URIs
 
@@ -200,49 +212,49 @@ WebMock will match all different representations of the same URI.
 
 I.e all the following representations of the URI are equal:
 
-    "www.google.com"
-    "www.google.com/"
-    "www.google.com:80"
-    "www.google.com:80/"
-    "http://www.google.com"
-    "http://www.google.com/"
-    "http://www.google.com:80"
-    "http://www.google.com:80/"
+    "www.example.com"
+    "www.example.com/"
+    "www.example.com:80"
+    "www.example.com:80/"
+    "http://www.example.com"
+    "http://www.example.com/"
+    "http://www.example.com:80"
+    "http://www.example.com:80/"
 	
 The following URIs with basic authentication are also equal for WebMock
 
-	"a b:pass@www.google.com"
-	"a b:pass@www.google.com/"
-	"a b:pass@www.google.com:80"
-	"a b:pass@www.google.com:80/"
-	"http://a b:pass@www.google.com"
-	"http://a b:pass@www.google.com/"
-	"http://a b:pass@www.google.com:80"
-	"http://a b:pass@www.google.com:80/"
-	"a%20b:pass@www.google.com"
-	"a%20b:pass@www.google.com/"
-	"a%20b:pass@www.google.com:80"
-	"a%20b:pass@www.google.com:80/"
-	"http://a%20b:pass@www.google.com"
-	"http://a%20b:pass@www.google.com/"
-	"http://a%20b:pass@www.google.com:80"
-	"http://a%20b:pass@www.google.com:80/"	
+	"a b:pass@www.example.com"
+	"a b:pass@www.example.com/"
+	"a b:pass@www.example.com:80"
+	"a b:pass@www.example.com:80/"
+	"http://a b:pass@www.example.com"
+	"http://a b:pass@www.example.com/"
+	"http://a b:pass@www.example.com:80"
+	"http://a b:pass@www.example.com:80/"
+	"a%20b:pass@www.example.com"
+	"a%20b:pass@www.example.com/"
+	"a%20b:pass@www.example.com:80"
+	"a%20b:pass@www.example.com:80/"
+	"http://a%20b:pass@www.example.com"
+	"http://a%20b:pass@www.example.com/"
+	"http://a%20b:pass@www.example.com:80"
+	"http://a%20b:pass@www.example.com:80/"	
 
 or these
 
-	"www.google.com/big image.jpg/?a=big image&b=c"
-	"www.google.com/big%20image.jpg/?a=big%20image&b=c"
-	"www.google.com:80/big image.jpg/?a=big image&b=c"
-	"www.google.com:80/big%20image.jpg/?a=big%20image&b=c"
-	"http://www.google.com/big image.jpg/?a=big image&b=c"
-	"http://www.google.com/big%20image.jpg/?a=big%20image&b=c"
-	"http://www.google.com:80/big image.jpg/?a=big image&b=c"
-	"http://www.google.com:80/big%20image.jpg/?a=big%20image&b=c"
+	"www.example.com/my path/?a=my param&b=c"
+	"www.example.com/my%20path/?a=my%20param&b=c"
+	"www.example.com:80/my path/?a=my param&b=c"
+	"www.example.com:80/my%20path/?a=my%20param&b=c"
+	"http://www.example.com/my path/?a=my param&b=c"
+	"http://www.example.com/my%20path/?a=my%20param&b=c"
+	"http://www.example.com:80/my path/?a=my param&b=c"
+	"http://www.example.com:80/my%20path/?a=my%20param&b=c"
 
 
 If you provide Regexp to match URI, WebMock will try to match it against every valid form of the same url.
 
-I.e `/.*big image.*/` will match `www.google.com/big%20image.jpg` because it is equivalent of `www.google.com/big image.jpg`
+I.e `/.*my param.*/` will match `www.example.com/my%20path` because it is equivalent of `www.example.com/my path`
 
 
 ## Matching headers

data/Rakefile

@@ -12,6 +12,7 @@ begin
     gem.authors = ["Bartosz Blimke"]
     gem.add_dependency "addressable", ">= 2.1.1"
     gem.add_development_dependency "rspec", ">= 1.2.9"
+    gem.add_development_dependency "httpclient", ">= 2.1.5.2"
     # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
   end
   Jeweler::GemcutterTasks.new

data/VERSION

@@ -1 +1 @@
-0.7.3
+0.8.0

data/lib/webmock.rb

@@ -3,6 +3,7 @@ require 'singleton'
 require 'addressable/uri'
 
 require 'webmock/http_lib_adapters/net_http'
+require 'webmock/http_lib_adapters/httpclient'
 
 require 'webmock/errors'
 
@@ -10,6 +11,7 @@ require 'webmock/util/uri'
 require 'webmock/util/headers'
 require 'webmock/util/hash_counter'
 
+require 'webmock/request'
 require 'webmock/request_profile'
 require 'webmock/request_signature'
 require 'webmock/request_stub'

data/lib/webmock/adapters/rspec/webmock_matcher.rb

@@ -17,10 +17,7 @@ module WebMock
     end
 
     def with(options)
-      @request_execution_verifier.request_profile.body =
-        options[:body] if options.has_key?(:body)
-      @request_execution_verifier.request_profile.headers = 
-        options[:headers] if options.has_key?(:headers)
+      @request_execution_verifier.request_profile.with(options)
       self
     end
 

data/lib/webmock/http_lib_adapters/httpclient.rb

@@ -0,0 +1,96 @@
+if defined?(HTTPClient)
+
+  class HTTPClient
+
+    def do_get_block_with_webmock(req, proxy, conn, &block)
+      do_get_with_webmock(req, proxy, conn, false, &block)
+    end
+
+    def do_get_stream_with_webmock(req, proxy, conn, &block)
+      do_get_with_webmock(req, proxy, conn, true, &block)
+    end
+
+    def do_get_with_webmock(req, proxy, conn, stream = false, &block)
+      request_signature = build_request_signature(req)
+
+      WebMock::RequestRegistry.instance.requested_signatures.put(request_signature)
+
+      if WebMock.registered_request?(request_signature)
+        webmock_response = WebMock.response_for_request(request_signature)
+        response = build_httpclient_response(webmock_response, stream, &block)
+        conn.push(response)
+      elsif WebMock.net_connect_allowed?
+        if stream
+          do_get_stream_without_webmock(req, proxy, conn, &block)
+        else
+          do_get_block_without_webmock(req, proxy, conn, &block)
+        end
+      else
+        message = "Real HTTP connections are disabled. Unregistered request: #{request_signature}"
+        assertion_failure(message)
+      end
+    end
+
+    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.registered_request?(request_signature) || WebMock.net_connect_allowed?
+        do_request_async_without_webmock(method, uri, query, body, extheader)
+      else
+        message = "Real HTTP connections are disabled. Unregistered request: #{request_signature}"
+        assertion_failure(message)
+      end
+    end
+
+    alias_method :do_get_block_without_webmock, :do_get_block
+    alias_method :do_get_block, :do_get_block_with_webmock
+
+    alias_method :do_get_stream_without_webmock, :do_get_stream
+    alias_method :do_get_stream, :do_get_stream_with_webmock
+
+    alias_method :do_request_async_without_webmock, :do_request_async
+    alias_method :do_request_async, :do_request_async_with_webmock
+
+    def build_httpclient_response(webmock_response, stream = false, &block)
+      body = stream ? StringIO.new(webmock_response.body) : webmock_response.body
+      response = HTTP::Message.new_response(body)
+      response.header.init_response(webmock_response.status)
+
+      webmock_response.headers.to_a.each { |name, value| response.header.set(name, value) }
+
+      webmock_response.raise_error_if_any
+
+      block.call(nil, body) if block
+
+      response
+    end
+  end
+
+  def build_request_signature(req)
+    uri = Addressable::URI.heuristic_parse(req.header.request_uri.to_s)
+    uri.query_values = req.header.request_query if req.header.request_query
+    uri.port = req.header.request_uri.port
+    uri = uri.omit(:userinfo)
+
+    auth = www_auth.basic_auth
+    auth.challenge(req.header.request_uri, nil)
+
+    headers = Hash[req.header.all]
+
+    if (auth_cred = auth.get(req)) && auth.scheme == 'Basic'
+      userinfo = WebMock::Util::Headers.decode_userinfo_from_header(auth_cred)
+      userinfo = WebMock::Util::URI.encode_unsafe_chars_in_userinfo(userinfo)
+      headers.reject! {|k,v| k =~ /[Aa]uthorization/ && v =~ /^Basic / } #we added it to url userinfo
+      uri.userinfo = userinfo
+    end
+
+    request_signature = WebMock::RequestSignature.new(
+      req.header.request_method.downcase.to_sym,
+      uri.to_s,
+      :body => req.body.content,
+      :headers => headers
+    )
+  end
+
+end

data/lib/webmock/http_lib_adapters/net_http.rb

@@ -35,11 +35,7 @@ module Net  #:nodoc: all
       when Socket, OpenSSL::SSL::SSLSocket, IO
         io
       when String
-        if !io.include?("\0") && File.exists?(io) && !File.directory?(io)
-          File.open(io, "r")
-        else
-          StringIO.new(io)
-        end
+        StringIO.new(io)
       end
       raise "Unable to create local socket" unless @io
     end
@@ -74,8 +70,9 @@ module Net  #:nodoc: all
 
       headers = Hash[*request.to_hash.map {|k,v| [k, v.flatten]}.flatten]
       headers.reject! {|k,v| k =~ /[Aa]ccept/ && v = '*/*'} #removing header added by Net::HTTP
+      headers.reject! {|k,v| k =~ /[Aa]uthorization/ && v =~ /^Basic / } #we added it to url userinfo
 
-      request_signature = WebMock::RequestSignature.new(method, uri, body, headers)
+      request_signature = WebMock::RequestSignature.new(method, uri, :body => body, :headers => headers)
 
       WebMock::RequestRegistry.instance.requested_signatures.put(request_signature)
 
@@ -88,7 +85,7 @@ module Net  #:nodoc: all
         request_without_webmock(request, body, &block)
       else
         message = "Real HTTP connections are disabled. Unregistered request: #{request_signature}"
-        raise WebMock::NetConnectNotAllowedError, message
+        assertion_failure(message)
       end
     end
     alias_method :request_without_webmock, :request