webmock 0.7.3 → 0.8.0

data/spec/request_profile_spec.rb

@@ -5,43 +5,50 @@ describe RequestProfile do
   describe "initialization" do
 
     it "should have assigned normalized uri" do
-      WebMock::Util::URI.should_receive(:normalize_uri).and_return("www.google.kom")
-      profile = RequestProfile.new(:get, "www.google.com")
-      profile.uri.should == "www.google.kom"
+      WebMock::Util::URI.should_receive(:normalize_uri).and_return("www.example.kom")
+      profile = RequestProfile.new(:get, "www.example.com")
+      profile.uri.should == "www.example.kom"
     end
 
     it "should have assigned uri without normalization if uri is URI" do
       WebMock::Util::URI.should_not_receive(:normalize_uri)
-      uri = Addressable::URI.parse("www.google.com")
+      uri = Addressable::URI.parse("www.example.com")
       profile = RequestProfile.new(:get, uri)
       profile.uri.should == uri
     end
 
     it "should have assigned normalized headers" do
       WebMock::Util::Headers.should_receive(:normalize_headers).with('A' => 'a').and_return('B' => 'b')
-      RequestProfile.new(:get, "www.google.com", nil, 'A' => 'a').headers.should == {'B' => 'b'}
+      RequestProfile.new(:get, "www.example.com", :headers => {'A' => 'a'}).headers.should == {'B' => 'b'}
     end
 
     it "should have assigned body" do
-      RequestProfile.new(:get, "www.google.com", "abc").body.should == "abc"
+      RequestProfile.new(:get, "www.example.com", :body => "abc").
+        body.should == RequestProfile::Body.new("abc")
     end
 
   end
 
   it "should report string describing itself" do
-    RequestProfile.new(:get, "www.google.com", "abc", {'A' => 'a', 'B' => 'b'}).to_s.should ==
-    "GET http://www.google.com/ with body 'abc' with headers {'A'=>'a', 'B'=>'b'}"
+    RequestProfile.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
 
 
   describe "with" do
     before(:each) do
-      @request_profile = RequestProfile.new(:get, "www.google.com")
+      @request_profile = RequestProfile.new(:get, "www.example.com")
     end
 
     it "should assign body to request profile" do
       @request_profile.with(:body => "abc")
-      @request_profile.body.should == "abc"
+      @request_profile.body.should == RequestProfile::Body.new("abc")
+    end
+
+    it "should have the same body" do
+      @request_profile.with(:body => "abc")
+      @request_profile.body.should == RequestProfile::Body.new("abc")
     end
 
     it "should assign normalized headers to request profile" do

data/spec/request_registry_spec.rb

@@ -4,9 +4,9 @@ describe RequestRegistry do
 
   before(:each) do
     RequestRegistry.instance.reset_webmock
-    @request_profile = RequestProfile.new(:get, "www.google.com")
-    @request_signature = RequestSignature.new(:get, "www.google.com")
-    @request_stub = RequestStub.new(:get, "www.google.com")
+    @request_profile = RequestProfile.new(:get, "www.example.com")
+    @request_signature = RequestSignature.new(:get, "www.example.com")
+    @request_stub = RequestStub.new(:get, "www.example.com")
   end
 
   describe "reset_webmock" do
@@ -60,11 +60,11 @@ describe RequestRegistry do
     end
 
     it "should always return last registered matching response" do
-      @request_stub1 = RequestStub.new(:get, "www.google.com")
+      @request_stub1 = RequestStub.new(:get, "www.example.com")
       @request_stub1.response = @response1 = Response.new
-      @request_stub2 = RequestStub.new(:get, "www.google.com")
+      @request_stub2 = RequestStub.new(:get, "www.example.com")
       @request_stub2.response = @response2 = Response.new
-      @request_stub3 = RequestStub.new(:get, "www.google.org")
+      @request_stub3 = RequestStub.new(:get, "www.example.org")
       @request_stub3.response = @response3 = Response.new
       RequestRegistry.instance.register_request_stub(@request_stub1)
       RequestRegistry.instance.register_request_stub(@request_stub2)
@@ -83,24 +83,24 @@ describe RequestRegistry do
     end
 
     before(:each) do
-      @request_stub1 = RequestStub.new(:get, "www.google.com")
-      @request_stub2 = RequestStub.new(:get, "www.google.net")
-      @request_stub3 = RequestStub.new(:get, "www.google.org")
-      RequestRegistry.instance.requested_signatures.put(RequestSignature.new(:get, "www.google.com"))
-      RequestRegistry.instance.requested_signatures.put(RequestSignature.new(:get, "www.google.com"))
-      RequestRegistry.instance.requested_signatures.put(RequestSignature.new(:get, "www.google.org"))
+      @request_stub1 = RequestStub.new(:get, "www.example.com")
+      @request_stub2 = RequestStub.new(:get, "www.example.net")
+      @request_stub3 = RequestStub.new(:get, "www.example.org")
+      RequestRegistry.instance.requested_signatures.put(RequestSignature.new(:get, "www.example.com"))
+      RequestRegistry.instance.requested_signatures.put(RequestSignature.new(:get, "www.example.com"))
+      RequestRegistry.instance.requested_signatures.put(RequestSignature.new(:get, "www.example.org"))
     end
 
     it "should report 0 if no request matching profile was requested" do
-      RequestRegistry.instance.times_executed(RequestProfile.new(:get, "www.google.net")).should == 0
+      RequestRegistry.instance.times_executed(RequestProfile.new(:get, "www.example.net")).should == 0
     end
 
     it "should report number of times matching profile was requested" do
-      RequestRegistry.instance.times_executed(RequestProfile.new(:get, "www.google.com")).should == 2
+      RequestRegistry.instance.times_executed(RequestProfile.new(:get, "www.example.com")).should == 2
     end
 
     it "should report number of times all matching profile were requested" do
-      RequestRegistry.instance.times_executed(RequestProfile.new(:get, /.*google.*/)).should == 3
+      RequestRegistry.instance.times_executed(RequestProfile.new(:get, /.*example.*/)).should == 3
     end
 
 

data/spec/request_signature_spec.rb

@@ -5,79 +5,79 @@ describe RequestSignature do
   describe "when matching" do
 
     it "should match if uri matches and method matches" do
-      RequestSignature.new(:get, "www.google.com").
-        should match(RequestProfile.new(:get, "www.google.com"))
+      RequestSignature.new(:get, "www.example.com").
+        should match(RequestProfile.new(:get, "www.example.com"))
     end
 
     it "should match if uri matches and method is any" do
-      RequestSignature.new(:get, "www.google.com").
-        should match(RequestProfile.new(:any, "www.google.com"))
+      RequestSignature.new(:get, "www.example.com").
+        should match(RequestProfile.new(:any, "www.example.com"))
     end
 
     it "should not match if other request profile has different method" do
-      RequestSignature.new(:get, "www.google.com").
-        should_not match(RequestProfile.new(:post, "www.google.com"))
+      RequestSignature.new(:get, "www.example.com").
+        should_not match(RequestProfile.new(:post, "www.example.com"))
     end
 
     it "should match if uri matches other uri" do
-      RequestSignature.new(:get, "www.google.com").
-        should match(RequestProfile.new(:get, "www.google.com"))
+      RequestSignature.new(:get, "www.example.com").
+        should match(RequestProfile.new(:get, "www.example.com"))
     end
     
     it "should match if uri matches other escaped using uri" do
-      RequestSignature.new(:get, "www.google.com/big image.jpg").
-        should match(RequestProfile.new(:get, "www.google.com/big%20image.jpg"))
+      RequestSignature.new(:get, "www.example.com/my path").
+        should match(RequestProfile.new(:get, "www.example.com/my%20path"))
     end
     
     it "should match if unescaped uri matches other uri" do
-      RequestSignature.new(:get, "www.google.com/big%20image.jpg").
-        should match(RequestProfile.new(:get, "www.google.com/big image.jpg"))
+      RequestSignature.new(:get, "www.example.com/my%20path").
+        should match(RequestProfile.new(:get, "www.example.com/my path"))
     end
     
     it "should match if unescaped uri matches other regexp uri" do
-      RequestSignature.new(:get, "www.google.com/big%20image.jpg").
-        should match(RequestProfile.new(:get, /.*big image.jpg.*/))
+      RequestSignature.new(:get, "www.example.com/my%20path").
+        should match(RequestProfile.new(:get, /.*my path.*/))
     end
 
     it "should match if uri matches other regex uri" do
-      RequestSignature.new(:get, "www.google.com").
-        should match(RequestProfile.new(:get, /.*google.*/))
+      RequestSignature.new(:get, "www.example.com").
+        should match(RequestProfile.new(:get, /.*example.*/))
     end
 
     it "should match for uris with same parameters" do
-      RequestSignature.new(:get, "www.google.com?a=1&b=2").
-        should match(RequestProfile.new(:get, "www.google.com?a=1&b=2"))
+      RequestSignature.new(:get, "www.example.com?a=1&b=2").
+        should match(RequestProfile.new(:get, "www.example.com?a=1&b=2"))
     end
 
     it "should not match for uris with different parameters" do
-      RequestSignature.new(:get, "www.google.com?a=2&b=1").
-        should_not match(RequestProfile.new(:get, "www.google.com?a=1&b=2"))
+      RequestSignature.new(:get, "www.example.com?a=2&b=1").
+        should_not match(RequestProfile.new(:get, "www.example.com?a=1&b=2"))
     end
 
     it "should match for parameters in different order" do
-      RequestSignature.new(:get, "www.google.com?a=1&b=2").
-        should match(RequestProfile.new(:get, "www.google.com?b=2&a=1"))
+      RequestSignature.new(:get, "www.example.com?a=1&b=2").
+        should match(RequestProfile.new(:get, "www.example.com?b=2&a=1"))
     end
     
     describe "when parameters are escaped" do
     
       it "should match if uri with non escaped parameters is the same as other uri with escaped parameters" do
-        RequestSignature.new(:get, "www.google.com/?a=a b").
-          should match(RequestProfile.new(:get, "www.google.com/?a=a%20b"))
+        RequestSignature.new(:get, "www.example.com/?a=a b").
+          should match(RequestProfile.new(:get, "www.example.com/?a=a%20b"))
       end
     
       it "should match if uri with escaped parameters is the same as other uri with non escaped parameters" do
-        RequestSignature.new(:get, "www.google.com/?a=a%20b").
-          should match(RequestProfile.new(:get, "www.google.com/?a=a b"))
+        RequestSignature.new(:get, "www.example.com/?a=a%20b").
+          should match(RequestProfile.new(:get, "www.example.com/?a=a b"))
       end
     
       it "should match if other regexp is for non escaped parameters but uri has escaped parameters" do
-        RequestSignature.new(:get, "www.google.com/?a=a%20b").
+        RequestSignature.new(:get, "www.example.com/?a=a%20b").
           should match(RequestProfile.new(:get, /.*a=a b.*/))
       end
     
       it "should match if other regexp is for escaped parameters but uri has non escaped parameters"  do
-        RequestSignature.new(:get, "www.google.com/?a=a b").
+        RequestSignature.new(:get, "www.example.com/?a=a b").
           should match(RequestProfile.new(:get, /.*a=a%20b.*/))
       end
     
@@ -86,68 +86,83 @@ describe RequestSignature do
     
 
     it "should match for same bodies" do
-      RequestSignature.new(:get, "www.google.com", "abc").
-        should match(RequestProfile.new(:get, "www.google.com", "abc"))
+      RequestSignature.new(:get, "www.example.com", :body => "abc").
+        should match(RequestProfile.new(:get, "www.example.com", :body => "abc"))
     end
 
     it "should not match for different bodies" do
-      RequestSignature.new(:get, "www.google.com", "abc").
-        should_not match(RequestProfile.new(:get, "www.google.com", "def"))
+      RequestSignature.new(:get, "www.example.com", :body => "abc").
+        should_not match(RequestProfile.new(:get, "www.example.com", :body => "def"))
     end
 
-    it "should match is other has nil body" do
-      RequestSignature.new(:get, "www.google.com", "abc").
-        should match(RequestProfile.new(:get, "www.google.com", nil))
+    it "should match if other has not specified body" do
+      RequestSignature.new(:get, "www.example.com", :body => "abc").
+        should match(RequestProfile.new(:get, "www.example.com"))
+    end
+    
+    it "should not match if other has nil body" do
+      RequestSignature.new(:get, "www.example.com", :body => "abc").
+        should_not match(RequestProfile.new(:get, "www.example.com", :body => nil))
     end
 
     it "should not match if other has empty body" do
-      RequestSignature.new(:get, "www.google.com", "abc").
-        should_not match(RequestProfile.new(:get, "www.google.com", ""))
+      RequestSignature.new(:get, "www.example.com", :body => "abc").
+        should_not match(RequestProfile.new(:get, "www.example.com", :body => ""))
+    end
+    
+    it "should not match if other has body" do
+      RequestSignature.new(:get, "www.example.com").
+        should_not match(RequestProfile.new(:get, "www.example.com", :body => "abc"))
     end
 
     it "should match for same headers" do
-      RequestSignature.new(:get, "www.google.com", nil, 'Content-Type' => 'image/jpeg').
-        should match(RequestProfile.new(:get, "www.google.com", nil, 'Content-Type' => 'image/jpeg'))
+      RequestSignature.new(:get, "www.example.com", :headers => {'Content-Type' => 'image/jpeg'}).
+        should match(RequestProfile.new(:get, "www.example.com", :headers => {'Content-Type' => 'image/jpeg'}))
     end
 
     it "should not match for different values of the same header" do
-      RequestSignature.new(:get, "www.google.com", nil, 'Content-Type' => 'image/jpeg').
-        should_not match(RequestProfile.new(:get, "www.google.com", nil, 'Content-Type' => 'image/png'))
+      RequestSignature.new(:get, "www.example.com", :headers => {'Content-Type' => 'image/jpeg'}).
+        should_not match(RequestProfile.new(:get, "www.example.com", :headers => {'Content-Type' => 'image/png'}))
     end
 
     it "should match if request has more headers than other" do
-      RequestSignature.new(:get, "www.google.com", nil, 'Content-Type' => 'image/jpeg', 'Content-Length' => '8888').
-        should match(RequestProfile.new(:get, "www.google.com", nil, 'Content-Type' => 'image/jpeg'))
+      RequestSignature.new(:get, "www.example.com", :headers => {'Content-Type' => 'image/jpeg', 'Content-Length' => '8888'}).
+        should match(RequestProfile.new(:get, "www.example.com", :headers => {'Content-Type' => 'image/jpeg'}))
     end
 
     it "should not match if request has less headers that the other and all match" do
-      RequestSignature.new(:get, "www.google.com", nil, 'Content-Type' => 'image/jpeg').
-        should_not match(RequestProfile.new(:get, "www.google.com", nil, 'Content-Type' => 'image/jpeg', 'Content-Length' => '8888'))
+      RequestSignature.new(:get, "www.example.com", :headers => {'Content-Type' => 'image/jpeg'}).
+        should_not match(RequestProfile.new(:get, "www.example.com", :headers => {'Content-Type' => 'image/jpeg', 'Content-Length' => '8888'}))
     end
 
     it "should match even is header keys or values are in different format" do
-      RequestSignature.new(:get, "www.google.com", nil, :ContentLength => 8888, 'content_type' => 'image/png').
-        should match(RequestProfile.new(:get, "www.google.com", nil, 'ContentLength' => '8888', 'Content-type' => 'image/png'))
+      RequestSignature.new(:get, "www.example.com", :headers => {:ContentLength => 8888, 'content_type' => 'image/png'}).
+        should match(RequestProfile.new(:get, "www.example.com", :headers => {'ContentLength' => '8888', 'Content-type' => 'image/png'}))
+    end
+    
+    it "should match is other has not specified" do
+      RequestSignature.new(:get, "www.example.com", :headers => {'A' => 'a'}).
+        should match(RequestProfile.new(:get, "www.example.com"))
     end
 
-    it "should match is other has nil headers" do
-      RequestSignature.new(:get, "www.google.com", nil, 'A' => 'a').
-        should match(RequestProfile.new(:get, "www.google.com", nil, nil))
+    it "should not match is other has nil headers" do
+      RequestSignature.new(:get, "www.example.com", :headers => {'A' => 'a'}).
+        should match(RequestProfile.new(:get, "www.example.com", :headers => nil))
     end
 
     it "should not match if other has empty headers" do
-      RequestSignature.new(:get, "www.google.com", nil, 'A' => 'a').
-        should_not match(RequestProfile.new(:get, "www.google.com", nil, {}))
+      RequestSignature.new(:get, "www.example.com", :headers => {'A' => 'a'}).
+        should_not match(RequestProfile.new(:get, "www.example.com", :headers => {}))
     end
 
     it "should not match if profile has no headers but other has headers" do
-      RequestSignature.new(:get, "www.google.com", nil, nil).
-        should_not match(RequestProfile.new(:get, "www.google.com", nil, {'A'=>'a'}))
+      RequestSignature.new(:get, "www.example.com").
+        should_not match(RequestProfile.new(:get, "www.example.com", :headers => {'A'=>'a'}))
     end
 
     it "should not match if profile has empty headers but other has headers" do
-      RequestSignature.new(:get, "www.google.com", nil, {}).
-        should_not match(RequestProfile.new(:get, "www.google.com", nil, {'A'=>'a'}))
+      RequestSignature.new(:get, "www.example.com", :headers => {}).
+        should_not match(RequestProfile.new(:get, "www.example.com", :headers => {'A'=>'a'}))
     end
 
   end

data/spec/request_stub_spec.rb

@@ -3,12 +3,12 @@ require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
 describe RequestStub do
 
   before(:each) do
-    @request_stub = RequestStub.new(:get, "www.google.com")
+    @request_stub = RequestStub.new(:get, "www.example.com")
   end
 
   it "should have request profile with method and uri" do
     @request_stub.request_profile.method.should == :get
-    @request_stub.request_profile.uri.host.should == "www.google.com"
+    @request_stub.request_profile.uri.host.should == "www.example.com"
   end
 
   it "should have response" do
@@ -19,7 +19,7 @@ describe RequestStub do
 
     it "should assign body to request profile" do
       @request_stub.with(:body => "abc")
-      @request_stub.request_profile.body.should == "abc"
+      @request_stub.request_profile.body.should == RequestProfile::Body.new("abc")
     end
 
     it "should assign normalized headers to request profile" do

data/spec/response_spec.rb

@@ -7,6 +7,7 @@ describe Response do
 
   it "should report normalized headers" do
     Util::Headers.should_receive(:normalize_headers).with('A' => 'a').and_return('B' => 'b')
+    @response = Response.new(:headers => {'A' => 'a'})
     @response.headers.should == {'B' => 'b'}
   end
 
@@ -49,8 +50,13 @@ describe Response do
       @response.body.should == "abc"
     end
     
-    it "should report content of a file as body if provided" do
+    it "should report string even if existing file path was provided" do
       @response = Response.new(:body => __FILE__)
+      @response.body.should == __FILE__
+    end
+    
+    it "should report content of a IO object if provided" do
+      @response = Response.new(:body => File.new(__FILE__))
       @response.body.should == File.new(__FILE__).read
     end
     

data/spec/spec_helper.rb

@@ -1,8 +1,9 @@
+require 'rubygems'
+require 'httpclient'
 $LOAD_PATH.unshift(File.dirname(__FILE__))
 $LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
 require 'spec'
 require 'spec/autorun'
-require 'rubygems'
 
 require 'webmock/rspec'
 
@@ -13,7 +14,7 @@ def fail()
 end
 
 def fail_with(message)
-  raise_error(Spec::Expectations::ExpectationNotMetError,message)
+  raise_error(Spec::Expectations::ExpectationNotMetError, message)
 end
 
 class Proc
@@ -22,37 +23,8 @@ class Proc
   end
 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
-# that a request isn't handled by WebMock
-#This solution is copied from FakeWeb project
-def setup_expectations_for_real_request(options = {})
-  # Socket handling
-  if options[:port] == 443
-    socket = mock("SSLSocket")
-    OpenSSL::SSL::SSLSocket.should_receive(:===).with(socket).at_least(:once).and_return(true)
-    OpenSSL::SSL::SSLSocket.should_receive(:new).with(socket, instance_of(OpenSSL::SSL::SSLContext)).at_least(:once).and_return(socket)
-    socket.stub!(:sync_close=).and_return(true)
-    socket.should_receive(:connect).at_least(:once).with()
-  else
-    socket = mock("TCPSocket")
-    Socket.should_receive(:===).with(socket).at_least(:once).and_return(true)
-  end
-
-  TCPSocket.should_receive(:open).with(options[:host], options[:port]).at_least(:once).and_return(socket)
-  socket.stub!(:closed?).and_return(false)
-  socket.stub!(:close).and_return(true)
-
-  # Request/response handling
-  request_parts = ["#{options[:method]} #{options[:path]} HTTP/1.1", "Host: #{options[:host]}"]
-  socket.should_receive(:write).with(/#{request_parts[0]}.*#{request_parts[1]}.*/m).and_return(100)
-
-  socket.should_receive(:sysread).once.and_return("HTTP/1.1 #{options[:response_code]} #{options[:response_message]}\nContent-Length: #{options[:response_body].length}\n\n#{options[:response_body]}")
-  socket.should_receive(:sysread).any_number_of_times.and_raise(EOFError)
-end
-
-def setup_expectations_for_real_google_request(options = {})
-  defaults = { :host => "www.google.com", :port => 80, :method => "GET",
+def setup_expectations_for_real_example_com_request(options = {})
+  defaults = { :host => "www.example.com", :port => 80, :method => "GET",
     :path => "/",
     :response_code => 200, :response_message => "OK",
     :response_body => "<title>Google fake response</title>" }