webmock 0.9.1 → 1.0.0

data/lib/webmock/util/headers.rb

@@ -12,6 +12,11 @@ module WebMock
         Hash[*array.flatten]
       end
 
+      def self.sorted_headers_string(headers)
+        headers = WebMock::Util::Headers.normalize_headers(headers)
+        '{' + headers.inspect[1..-2].split(', ').sort.join(', ').gsub("\"","'").gsub("\\","") + '}'
+      end
+      
       def self.decode_userinfo_from_header(header)
         header.sub(/^Basic /, "").unpack("m").first
       end

data/lib/webmock/webmock.rb

@@ -8,18 +8,18 @@ module WebMock
   alias_method :stub_http_request, :stub_request
 
   def request(method, uri)
-    RequestProfile.new(method, uri)
+    RequestPattern.new(method, uri)
   end
 
   def assert_requested(method, uri, options = {}, &block)
     expected_times_executed = options.delete(:times) || 1
-    request = RequestProfile.new(method, uri, options).with(&block)
+    request = RequestPattern.new(method, uri, options).with(&block)
     verifier = RequestExecutionVerifier.new(request, expected_times_executed)
     assertion_failure(verifier.failure_message) unless verifier.matches?
   end
 
   def assert_not_requested(method, uri, options = {}, &block)
-    request = RequestProfile.new(method, uri, options).with(&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?
   end
@@ -28,12 +28,16 @@ module WebMock
     Config.instance.allow_net_connect = true
   end
 
-  def disable_net_connect!
+  def disable_net_connect!(options = {})
     Config.instance.allow_net_connect = false
+    Config.instance.allow_localhost = options[:allow_localhost]
   end
 
-  def net_connect_allowed?
-    Config.instance.allow_net_connect
+  def net_connect_allowed?(uri = nil)
+    if uri.class == String
+      uri = URI::parse(uri)
+    end
+    Config.instance.allow_net_connect || ( Config.instance.allow_localhost && uri.is_a?(URI) && uri.host == 'localhost' )
   end
 
   def registered_request?(request_signature)

data/spec/httpclient_spec.rb

@@ -2,7 +2,6 @@ require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
 require 'webmock_spec'
 require 'ostruct'
 
-require 'httpclient'
 require 'httpclient_spec_helper'
 
 describe "Webmock with HTTPClient" do

data/spec/httpclient_spec_helper.rb

@@ -20,7 +20,17 @@ module HTTPClientSpecHelper
     OpenStruct.new({
       :body => HTTPClientSpecHelper.async_mode ? response.content.read : response.content,
       :headers => Hash[*response.header.all.flatten],
-      :status => response.code.to_s })
+      :status => response.code.to_s,
+      :message => response.reason
+    })
+  end
+
+  def client_timeout_exception_class
+    HTTPClient::TimeoutError
+  end
+
+  def connection_refused_exception_class
+    Errno::ECONNREFUSED
   end
 
   def default_client_request_headers(request_method = nil, has_body = false)

data/spec/net_http_spec.rb

@@ -29,7 +29,7 @@ describe "Webmock with Net:HTTP" do
     req.body = "my_params"
     Net::HTTP.start("www.example.com") { |http| http.request(req)}.body.should == "abc"
   end
-  
+
   it "should handle Net::HTTP::Post#body_stream" do
     stub_http_request(:post, "www.example.com").with(:body => "my_params").to_return(:body => "abc")
     req = Net::HTTP::Post.new("/")
@@ -46,5 +46,12 @@ describe "Webmock with Net:HTTP" do
     }.should raise_error("both of body argument and HTTPRequest#body set")
   end
 
+  it "should handle real requests with readable body" do
+    WebMock.allow_net_connect!
+    req = Net::HTTP::Post.new("/")
+    Net::HTTP.start("www.example.com") {|http| 
+      http.request(req, StringIO.new("my_params"))
+    }.body.should =~ /Example Web Page/
+  end
 
 end

data/spec/net_http_spec_helper.rb

@@ -21,7 +21,9 @@ module NetHTTPSpecHelper
     OpenStruct.new({
       :body => response.body,
       :headers => WebMock::Util::Headers.normalize_headers(headers),
-      :status => response.code })
+      :status => response.code, 
+      :message => response.message
+    })
   end
   
   def default_client_request_headers(request_method = nil, has_body = false)
@@ -30,6 +32,14 @@ module NetHTTPSpecHelper
       [k, v.flatten]
     }.flatten]
   end
+  
+  def client_timeout_exception_class
+    Timeout::Error
+  end
+
+  def connection_refused_exception_class
+    Errno::ECONNREFUSED
+  end
 
   # Sets several expectations that a real HTTP request makes it
   # past WebMock to the socket layer. You can use this when you need to check

data/spec/patron_spec.rb

@@ -0,0 +1,83 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+require 'webmock_spec'
+
+
+unless RUBY_PLATFORM =~ /java/
+  require 'patron_spec_helper'
+  require 'tmpdir'
+  require 'fileutils'
+
+  describe "Webmock with Patron" do
+    include PatronSpecHelper
+
+    it_should_behave_like "WebMock"
+
+    describe "when custom functionality is used" do
+      before(:each) do
+        @sess = Patron::Session.new
+        @sess.base_url = "http://www.example.com"
+      end
+
+      describe "file requests" do
+
+        before(:each) do
+          @dir_path = Dir.tmpdir
+          @file_path = File.join(@dir_path, "webmock_temp_test_file")
+          FileUtils.rm_rf(@file_path) if File.exists?(@file_path)
+        end
+
+        after(:each) do
+          FileUtils.rm_rf(@dir_path) if File.exist?(@dir_path)
+        end
+
+
+        it "should work with get_file" do
+          stub_http_request(:get, "www.example.com").to_return(:body => "abc")
+          @sess.get_file("/", @file_path)
+          File.read(@file_path).should == "abc"
+        end
+
+        it "should raise same error as Patron if file is not readable for get request" do
+          stub_http_request(:get, "www.example.com")
+          lambda {
+            @sess.get_file("/", "/non_existing_file")
+          }.should raise_error(ArgumentError, "Unable to open specified file.")
+        end
+
+        it "should work with put_file" do
+          File.open(@file_path, "w") {|f| f.write "abc"}
+          stub_http_request(:put, "www.example.com").with(:body => "abc")
+          @sess.put_file("/", @file_path)
+        end
+
+        it "should work with post_file" do
+          File.open(@file_path, "w") {|f| f.write "abc"}
+          stub_http_request(:post, "www.example.com").with(:body => "abc")
+          @sess.post_file("/", @file_path)
+        end
+
+        it "should raise same error as Patron if file is not readable for post request" do
+          stub_http_request(:post, "www.example.com").with(:body => "abc")
+          lambda {
+            @sess.post_file("/", "/non_existing_file")
+          }.should raise_error(ArgumentError, "Unable to open specified file.")
+        end
+
+      end
+
+      describe "handling errors same way as patron" do
+        it "should raise error if put request has neither upload_data nor file_name" do
+          stub_http_request(:post, "www.example.com")
+          lambda {
+            @sess.post("/", nil)
+          }.should raise_error(ArgumentError, "Must provide either data or a filename when doing a PUT or POST")
+        end
+      end
+
+      it "should work with WebDAV copy request" do
+        stub_http_request(:copy, "www.example.com/abc").with(:headers => {'Destination' => "/def"})
+        @sess.copy("/abc", "/def")
+      end
+    end
+  end
+end

data/spec/patron_spec_helper.rb

@@ -0,0 +1,44 @@
+module PatronSpecHelper
+  def http_request(method, uri, options = {}, &block)
+    uri = Addressable::URI.heuristic_parse(uri)
+    sess = Patron::Session.new
+    sess.base_url = "#{uri.omit(:userinfo, :query).normalize.to_s}".gsub(/\/$/,"")
+
+    sess.username = uri.user
+    sess.password = uri.password
+
+    sess.timeout = 10
+
+    response = sess.request(method, "#{uri.path}#{uri.query ? '?' : ''}#{uri.query}", options[:headers] || {}, {
+      :data => options[:body]
+    })
+
+    OpenStruct.new({
+      :body => response.body,
+      :headers => WebMock::Util::Headers.normalize_headers(response.headers),
+      :status => response.status.to_s,
+      :message => response.status_line
+    })
+  end
+
+  def default_client_request_headers(request_method = nil, has_body = false)
+    if Patron.version >= "0.4.6"
+      {'Expect'=>''}
+    else
+      nil
+    end
+  end
+
+  def client_timeout_exception_class
+    Patron::TimeoutError
+  end
+
+  def connection_refused_exception_class
+    Patron::ConnectionFailed
+  end
+
+  def setup_expectations_for_real_request(options = {})
+    #TODO
+  end
+
+end

data/spec/request_execution_verifier_spec.rb

@@ -3,8 +3,8 @@ require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
 describe RequestExecutionVerifier do
   before(:each) do
     @verifier = RequestExecutionVerifier.new
-    @request_profile = mock(RequestProfile, :to_s => "www.example.com")
-    @verifier.request_profile = @request_profile
+    @request_pattern = mock(RequestPattern, :to_s => "www.example.com")
+    @verifier.request_pattern = @request_pattern
   end
 
 
@@ -43,14 +43,14 @@ describe RequestExecutionVerifier do
 
     it "should succeed if request was executed expected number of times" do
       RequestRegistry.instance.
-        should_receive(:times_executed).with(@request_profile).and_return(10)
+        should_receive(:times_executed).with(@request_pattern).and_return(10)
       @verifier.expected_times_executed = 10
       @verifier.matches?.should be_true
     end
 
     it "should fail if request was not executed expected number of times" do
       RequestRegistry.instance.
-        should_receive(:times_executed).with(@request_profile).and_return(10)
+        should_receive(:times_executed).with(@request_pattern).and_return(10)
       @verifier.expected_times_executed = 5
       @verifier.matches?.should be_false
     end
@@ -61,26 +61,26 @@ describe RequestExecutionVerifier do
 
     it "should fail if request executed expected number of times" do
       RequestRegistry.instance.
-        should_receive(:times_executed).with(@request_profile).and_return(10)
+        should_receive(:times_executed).with(@request_pattern).and_return(10)
       @verifier.expected_times_executed = 10
       @verifier.does_not_match?.should be_false     
     end
     
     it "should succeed if request was not executed at all and expected number of times was not set" do
       RequestRegistry.instance.
-        should_receive(:times_executed).with(@request_profile).and_return(0)
+        should_receive(:times_executed).with(@request_pattern).and_return(0)
       @verifier.does_not_match?.should be_true      
     end
     
     it "should fail if request was executed and expected number of times was not set" do
       RequestRegistry.instance.
-        should_receive(:times_executed).with(@request_profile).and_return(1)
+        should_receive(:times_executed).with(@request_pattern).and_return(1)
       @verifier.does_not_match?.should be_false     
     end
 
     it "should succeed if request was not executed expected number of times" do
       RequestRegistry.instance.
-        should_receive(:times_executed).with(@request_profile).and_return(10)
+        should_receive(:times_executed).with(@request_pattern).and_return(10)
       @verifier.expected_times_executed = 5
       @verifier.does_not_match?.should be_true
     end

data/spec/request_pattern_spec.rb

@@ -0,0 +1,243 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe RequestPattern do
+
+  it "should report string describing itself" do
+    RequestPattern.new(:get, "www.example.com",
+      :body => "abc", :headers => {'A' => 'a', 'B' => 'b'}).to_s.should ==
+    "GET http://www.example.com/ with body 'abc' with headers {'A'=>'a', 'B'=>'b'}"
+  end
+
+  it "should report string describing itself with block" do
+    RequestPattern.new(:get, "www.example.com",
+      :body => "abc", :headers => {'A' => 'a', 'B' => 'b'}).with {|req| true}.to_s.should ==
+    "GET http://www.example.com/ with body 'abc' with headers {'A'=>'a', 'B'=>'b'} with given block"
+  end
+
+  describe "with" do
+    before(:each) do
+      @request_pattern = RequestPattern.new(:get, "www.example.com")
+    end
+
+    it "should have assigned body pattern" do
+      @request_pattern.with(:body => "abc")
+      @request_pattern.to_s.should == RequestPattern.new(:get, "www.example.com", :body => "abc").to_s
+    end
+
+    it "should have assigned normalized headers pattern" do
+      @request_pattern.with(:headers => {'A' => 'a'})
+      @request_pattern.to_s.should == RequestPattern.new(:get, "www.example.com", :headers => {'A' => 'a'}).to_s
+    end
+
+  end
+
+
+  class WebMock::RequestPattern
+    def match(request_signature)
+      self.matches?(request_signature)
+    end
+  end
+
+  describe "when matching" do
+
+    it "should match if uri matches and method matches" do
+      RequestPattern.new(:get, "www.example.com").
+        should match(RequestSignature.new(:get, "www.example.com"))
+    end
+
+    it "should match if uri matches and method pattern is any" do
+      RequestPattern.new(:any, "www.example.com").
+        should match(RequestSignature.new(:get, "www.example.com"))
+    end
+
+    it "should not match if request has different method" do
+      RequestPattern.new(:post, "www.example.com").
+        should_not match(RequestSignature.new(:get, "www.example.com"))
+    end
+
+    it "should match if uri matches request uri" do
+      RequestPattern.new(:get, "www.example.com").
+        should match(RequestSignature.new(:get, "www.example.com"))
+    end
+
+    it "should match if request has unescaped uri" do
+      RequestPattern.new(:get, "www.example.com/my%20path").
+        should match(RequestSignature.new(:get, "www.example.com/my path"))
+    end
+
+    it "should match if request has escaped uri" do
+      RequestPattern.new(:get, "www.example.com/my path").
+        should match(RequestSignature.new(:get, "www.example.com/my%20path"))
+    end
+
+    it "should match if uri regexp pattern matches unescaped form of request uri" do
+      RequestPattern.new(:get, /.*my path.*/).
+        should match(RequestSignature.new(:get, "www.example.com/my%20path"))
+    end
+
+    it "should match if uri regexp pattern matches request uri" do
+      RequestPattern.new(:get, /.*example.*/).
+        should match(RequestSignature.new(:get, "www.example.com"))
+    end
+
+    it "should match for uris with same parameters as pattern" do
+      RequestPattern.new(:get, "www.example.com?a=1&b=2").
+        should match(RequestSignature.new(:get, "www.example.com?a=1&b=2"))
+    end
+
+    it "should not match for uris with different parameters" do
+      RequestPattern.new(:get, "www.example.com?a=1&b=2").
+        should_not match(RequestSignature.new(:get, "www.example.com?a=2&b=1"))
+    end
+
+    it "should match for uri parameters in different order" do
+      RequestPattern.new(:get, "www.example.com?b=2&a=1").
+        should match(RequestSignature.new(:get, "www.example.com?a=1&b=2"))
+    end
+
+    describe "when parameters are escaped" do
+
+      it "should match if uri pattern has escaped parameters and request has unescaped parameters" do
+        RequestPattern.new(:get, "www.example.com/?a=a%20b").
+          should match(RequestSignature.new(:get, "www.example.com/?a=a b"))
+      end
+
+      it "should match if uri pattern has unescaped parameters and request has escaped parameters" do
+        RequestPattern.new(:get, "www.example.com/?a=a b").
+          should match(RequestSignature.new(:get, "www.example.com/?a=a%20b"))
+      end
+
+      it "should match if uri regexp pattern matches uri with unescaped parameters and request has escaped parameters" do
+        RequestPattern.new(:get, /.*a=a b.*/).
+          should match(RequestSignature.new(:get, "www.example.com/?a=a%20b"))
+      end
+
+      it "should match if uri regexp pattern matches uri with escaped parameters and request has unescaped parameters"  do
+        RequestPattern.new(:get, /.*a=a%20b.*/).
+          should match(RequestSignature.new(:get, "www.example.com/?a=a b"))
+      end
+
+    end
+
+
+
+    it "should match if request body and body pattern are the same" do
+      RequestPattern.new(:get, "www.example.com", :body => "abc").
+        should match(RequestSignature.new(:get, "www.example.com", :body => "abc"))
+    end
+
+    it "should match if request body matches regexp" do
+      RequestPattern.new(:get, "www.example.com", :body => /^abc$/).
+        should match(RequestSignature.new(:get, "www.example.com", :body => "abc"))
+    end
+
+    it "should not match if body pattern is different than request body" do
+      RequestPattern.new(:get, "www.example.com", :body => "def").
+        should_not match(RequestSignature.new(:get, "www.example.com", :body => "abc"))
+    end
+
+    it "should not match if request body doesn't match regexp pattern" do
+      RequestPattern.new(:get, "www.example.com", :body => /^abc$/).
+        should_not match(RequestSignature.new(:get, "www.example.com", :body => "xabc"))
+    end
+
+    it "should match if pattern doesn't have specified body" do
+      RequestPattern.new(:get, "www.example.com").
+        should match(RequestSignature.new(:get, "www.example.com", :body => "abc"))
+    end
+
+    it "should not match if pattern has body specified as nil but request body is not empty" do
+      RequestPattern.new(:get, "www.example.com", :body => nil).
+        should_not match(RequestSignature.new(:get, "www.example.com", :body => "abc"))
+    end
+
+    it "should not match if pattern has empty body but request body is not empty" do
+      RequestPattern.new(:get, "www.example.com", :body => "").
+        should_not match(RequestSignature.new(:get, "www.example.com", :body => "abc"))
+    end
+
+    it "should not match if pattern has body specified but request has no body" do
+      RequestPattern.new(:get, "www.example.com", :body => "abc").
+        should_not match(RequestSignature.new(:get, "www.example.com"))
+    end
+
+    it "should match if pattern and request have the same headers" do
+      RequestPattern.new(:get, "www.example.com", :headers => {'Content-Type' => 'image/jpeg'}).
+        should match(RequestSignature.new(:get, "www.example.com", :headers => {'Content-Type' => 'image/jpeg'}))
+    end
+
+    it "should match if pattern headers values are regexps matching request header values" do
+      RequestPattern.new(:get, "www.example.com", :headers => {'Content-Type' => %r{^image/jpeg$}}).
+        should match(RequestSignature.new(:get, "www.example.com", :headers => {'Content-Type' => 'image/jpeg'}))
+    end
+
+    it "should not match if pattern has different value of header than request" do
+      RequestPattern.new(:get, "www.example.com", :headers => {'Content-Type' => 'image/png'}).
+        should_not match(RequestSignature.new(:get, "www.example.com", :headers => {'Content-Type' => 'image/jpeg'}))
+    end
+
+    it "should not match if pattern header value regexp doesn't match request header value" do
+      RequestPattern.new(:get, "www.example.com", :headers => {'Content-Type' => %r{^image\/jpeg$}}).
+        should_not match(RequestSignature.new(:get, "www.example.com", :headers => {'Content-Type' => 'image/jpegx'}))
+    end
+
+    it "should match if request has more headers than request pattern" do
+      RequestPattern.new(:get, "www.example.com", :headers => {'Content-Type' => 'image/jpeg'}).
+        should match(RequestSignature.new(:get, "www.example.com", :headers => {'Content-Type' => 'image/jpeg', 'Content-Length' => '8888'}))
+    end
+
+    it "should not match if request has less headers than the request pattern" do
+      RequestPattern.new(:get, "www.example.com", :headers => {'Content-Type' => 'image/jpeg', 'Content-Length' => '8888'}).
+        should_not match(RequestSignature.new(:get, "www.example.com", :headers => {'Content-Type' => 'image/jpeg'}))
+    end
+
+    it "should match even is header keys are declared in different form" do
+      RequestPattern.new(:get, "www.example.com", :headers => {'ContentLength' => '8888', 'Content-type' => 'image/png'}).
+        should match(RequestSignature.new(:get, "www.example.com", :headers => {:ContentLength => 8888, 'content_type' => 'image/png'}))
+    end
+
+    it "should match is pattern doesn't have specified headers" do
+      RequestPattern.new(:get, "www.example.com").
+        should match(RequestSignature.new(:get, "www.example.com", :headers => {'A' => 'a'}))
+    end
+
+    it "should not match if pattern has nil headers but request has headers" do
+      RequestPattern.new(:get, "www.example.com", :headers => nil).
+        should_not match(RequestSignature.new(:get, "www.example.com", :headers => {'A' => 'a'}))
+    end
+
+    it "should not match if pattern has empty headers but request has headers" do
+      RequestPattern.new(:get, "www.example.com", :headers => {}).
+        should_not match(RequestSignature.new(:get, "www.example.com", :headers => {'A' => 'a'}))
+    end
+
+    it "should not match if pattern has specified headers but request has nil headers" do
+      RequestPattern.new(:get, "www.example.com", :headers => {'A'=>'a'}).
+        should_not match(RequestSignature.new(:get, "www.example.com"))
+    end
+
+    it "should not match if pattern has specified headers but request has empty headers" do
+      RequestPattern.new(:get, "www.example.com", :headers => {'A'=>'a'}).
+        should_not match(RequestSignature.new(:get, "www.example.com", :headers => {}))
+    end
+
+    it "should match if block given in pattern evaluates request to true" do
+      RequestPattern.new(:get, "www.example.com").with { |request| true }.
+        should match(RequestSignature.new(:get, "www.example.com"))
+    end
+
+    it "should not match if block given in pattrn evaluates request to false" do
+      RequestPattern.new(:get, "www.example.com").with { |request| false }.
+        should_not match(RequestSignature.new(:get, "www.example.com"))
+    end
+
+    it "should yield block with request signature" do
+      signature = RequestSignature.new(:get, "www.example.com")
+      RequestPattern.new(:get, "www.example.com").with { |request| request == signature }.
+        should match(signature)
+    end
+
+  end
+
+
+end