webmock 0.7.3 → 0.8.0

data/spec/util/uri_spec.rb

@@ -3,62 +3,75 @@ require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
 
 URIS_WITHOUT_PATH_OR_PARAMS =
 [
-  "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/"
+].sort
+
+URIS_WITHOUT_PATH_BUT_WITH_PARAMS =
+[
+  "www.example.com?a=b",
+  "www.example.com/?a=b",
+  "www.example.com:80?a=b",
+  "www.example.com:80/?a=b",
+  "http://www.example.com?a=b",
+  "http://www.example.com/?a=b",
+  "http://www.example.com:80?a=b",
+  "http://www.example.com:80/?a=b"
 ].sort
 
 URIS_WITH_AUTH =
 [
-  "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/"
 ].sort
 
 URIS_WITH_PATH_AND_PARAMS =
 [
-  "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",
   ].sort
 
 URIS_WITH_DIFFERENT_PORT =
 [
-  "www.google.com:88",
-  "www.google.com:88/",
-  "http://www.google.com:88",
-  "http://www.google.com:88/"
+  "www.example.com:88",
+  "www.example.com:88/",
+  "http://www.example.com:88",
+  "http://www.example.com:88/"
 ].sort
 
+
 URIS_FOR_HTTPS =
 [
-  "https://www.google.com",
-  "https://www.google.com/",
-  "https://www.google.com:443",
-  "https://www.google.com:443/"
+  "https://www.example.com",
+  "https://www.example.com/",
+  "https://www.example.com:443",
+  "https://www.example.com:443/"
 ].sort
 
 
@@ -72,6 +85,12 @@ describe WebMock::Util::URI do
       end
     end
 
+    it "should find all variations of the same uri for all variations of uri with params but without path" do
+      URIS_WITHOUT_PATH_BUT_WITH_PARAMS.each do |uri|
+        WebMock::Util::URI.variations_of_uri_as_strings(uri).sort.should == URIS_WITHOUT_PATH_BUT_WITH_PARAMS
+      end
+    end
+
     it "should find all variations of the same uri for all variations of uri without params or path" do
       URIS_WITHOUT_PATH_OR_PARAMS.each do |uri|
         WebMock::Util::URI.variations_of_uri_as_strings(uri).sort.should == URIS_WITHOUT_PATH_OR_PARAMS
@@ -108,6 +127,14 @@ describe WebMock::Util::URI do
       end
     end
 
+    it "should successfully compare all variations of the same uri with path but with params" do
+      URIS_WITHOUT_PATH_BUT_WITH_PARAMS.each do |uri_a|
+        URIS_WITHOUT_PATH_BUT_WITH_PARAMS.each do |uri_b|
+          WebMock::Util::URI.normalize_uri(uri_a).should ===  WebMock::Util::URI.normalize_uri(uri_b)
+        end
+      end
+    end
+
     it "should successfully compare all variations of the same uri without path or params" do
       URIS_WITHOUT_PATH_OR_PARAMS.each do |uri_a|
         URIS_WITHOUT_PATH_OR_PARAMS.each do |uri_b|

data/spec/webmock_spec.rb

@@ -1,8 +1,10 @@
 require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
 
-SAMPLE_HEADERS = { "Content-Length" => "8888" }
-ESCAPED_PARAMS = "x=ab%2Bc&z=%27Stop%21%27%20said%20Fred"
-NOT_ESCAPED_PARAMS = "z='Stop!' said Fred&x=ab c"
+unless defined? SAMPLE_HEADERS
+  SAMPLE_HEADERS = { "Content-Length" => "8888" }
+  ESCAPED_PARAMS = "x=ab%2Bc&z=%27Stop%21%27%20said%20Fred"
+  NOT_ESCAPED_PARAMS = "z='Stop!' said Fred&x=ab c"
+end
 
 describe "WebMock", :shared => true do
   before(:each) do
@@ -18,14 +20,20 @@ describe "WebMock", :shared => true do
       end
 
       it "should make a real web request if request is not stubbed" do
-        setup_expectations_for_real_google_request
-        http_request(:get, "http://www.google.com/").
+        setup_expectations_for_real_example_com_request
+        http_request(:get, "http://www.example.com/").
+          body.should =~ /.*Google fake response.*/
+      end
+
+      it "should make a real https request if request is not stubbed" do
+        setup_expectations_for_real_example_com_request(:port => 443)
+        http_request(:get, "https://www.example.com/").
           body.should =~ /.*Google fake response.*/
       end
 
       it "should return stubbed response if request was stubbed" do
-        stub_http_request(:get, "www.google.com").to_return(:body => "abc")
-        http_request(:get, "http://www.google.com/").body.should == "abc"
+        stub_http_request(:get, "www.example.com").to_return(:body => "abc")
+        http_request(:get, "http://www.example.com/").body.should == "abc"
       end
     end
 
@@ -35,15 +43,14 @@ describe "WebMock", :shared => true do
       end
 
       it "should return stubbed response if request was stubbed" do
-        stub_http_request(:get, "www.google.com").to_return(:body => "abc")
-        http_request(:get, "http://www.google.com/").body.should == "abc"
+        stub_http_request(:get, "www.example.com").to_return(:body => "abc")
+        http_request(:get, "http://www.example.com/").body.should == "abc"
       end
 
       it "should raise exception if request was not stubbed" do
         lambda {
-          http_request(:get, "http://www.google.com/")
-        }.should raise_error(WebMock::NetConnectNotAllowedError,
-          "Real HTTP connections are disabled. Unregistered request: GET http://www.google.com/")
+          http_request(:get, "http://www.example.com/")
+        }.should fail_with("Real HTTP connections are disabled. Unregistered request: GET http://www.example.com/")
       end
     end
 
@@ -54,18 +61,18 @@ describe "WebMock", :shared => true do
     describe "on uri" do
 
       it "should match the request by uri with non escaped params if request have escaped parameters" do
-        stub_http_request(:get, "www.google.com/?#{NOT_ESCAPED_PARAMS}").to_return(:body => "abc")
-        http_request(:get, "http://www.google.com/?#{ESCAPED_PARAMS}").body.should == "abc"
+        stub_http_request(:get, "www.example.com/?#{NOT_ESCAPED_PARAMS}").to_return(:body => "abc")
+        http_request(:get, "http://www.example.com/?#{ESCAPED_PARAMS}").body.should == "abc"
       end
 
       it "should match the request by uri with escaped parameters even if request has non escaped params" do
-        stub_http_request(:get, "www.google.com/?#{ESCAPED_PARAMS}").to_return(:body => "abc")
-        http_request(:get, "http://www.google.com/?#{NOT_ESCAPED_PARAMS}").body.should == "abc"
+        stub_http_request(:get, "www.example.com/?#{ESCAPED_PARAMS}").to_return(:body => "abc")
+        http_request(:get, "http://www.example.com/?#{NOT_ESCAPED_PARAMS}").body.should == "abc"
       end
 
       it "should match the request by regexp matching non escaped params uri if request params are escaped" do
         stub_http_request(:get, /.*x=ab c.*/).to_return(:body => "abc")
-        http_request(:get, "http://www.google.com/?#{ESCAPED_PARAMS}").body.should == "abc"
+        http_request(:get, "http://www.example.com/?#{ESCAPED_PARAMS}").body.should == "abc"
       end
 
     end
@@ -73,17 +80,16 @@ describe "WebMock", :shared => true do
     describe "on method" do
 
       it "should match the request by method if registered" do
-        stub_http_request(:get, "www.google.com")
-        http_request(:get, "http://www.google.com/").status.should == "200"
+        stub_http_request(:get, "www.example.com")
+        http_request(:get, "http://www.example.com/").status.should == "200"
       end
 
       it "should not match requests if method is different" do
-        stub_http_request(:get, "www.google.com")
-        http_request(:get, "http://www.google.com/").status.should == "200"
+        stub_http_request(:get, "www.example.com")
+        http_request(:get, "http://www.example.com/").status.should == "200"
         lambda {
-          http_request(:post, "http://www.google.com/")
-        }.should raise_error(WebMock::NetConnectNotAllowedError,
-          "Real HTTP connections are disabled. Unregistered request: POST http://www.google.com/"
+          http_request(:post, "http://www.example.com/")
+        }.should fail_with("Real HTTP connections are disabled. Unregistered request: POST http://www.example.com/"
         )
       end
 
@@ -92,26 +98,24 @@ describe "WebMock", :shared => true do
     describe "on body" do
 
       it "should match requests if body is the same" do
-        stub_http_request(:get, "www.google.com").with(:body => "abc")
+        stub_http_request(:get, "www.example.com").with(:body => "abc")
         http_request(
-          :get, "http://www.google.com/",
+          :get, "http://www.example.com/",
           :body => "abc").status.should == "200"
       end
 
       it "should match requests if body is not set in the stub" do
-        stub_http_request(:get, "www.google.com")
+        stub_http_request(:get, "www.example.com")
         http_request(
-          :get, "http://www.google.com/",
+          :get, "http://www.example.com/",
           :body => "abc").status.should == "200"
       end
 
       it "should not match requests if body is different" do
-        stub_http_request(:get, "www.google.com").with(:body => "abc")
-
+        stub_http_request(:get, "www.example.com").with(:body => "abc")
         lambda {
-          http_request(:get, "http://www.google.com/", :body => "def")
-        }.should raise_error(WebMock::NetConnectNotAllowedError,
-          "Real HTTP connections are disabled. Unregistered request: GET http://www.google.com/ with body 'def'")
+          http_request(:get, "http://www.example.com/", :body => "def")
+        }.should fail_with("Real HTTP connections are disabled. Unregistered request: GET http://www.example.com/ with body 'def'")
       end
 
     end
@@ -119,61 +123,57 @@ describe "WebMock", :shared => true do
     describe "on headers" do
 
       it "should match requests if headers are the same" do
-        stub_http_request(:get, "www.google.com").with(:headers => SAMPLE_HEADERS )
+        stub_http_request(:get, "www.example.com").with(:headers => SAMPLE_HEADERS )
         http_request(
-          :get, "http://www.google.com/",
+          :get, "http://www.example.com/",
           :headers => SAMPLE_HEADERS).status.should == "200"
       end
 
       it "should match requests if request headers are not stubbed" do
-        stub_http_request(:get, "www.google.com")
+        stub_http_request(:get, "www.example.com")
         http_request(
-          :get, "http://www.google.com/",
+          :get, "http://www.example.com/",
           :headers => SAMPLE_HEADERS).status.should == "200"
       end
 
 
       it "should not match requests if headers are different" do
-        stub_http_request(:get, "www.google.com").with(:headers => SAMPLE_HEADERS)
+        stub_http_request(:get, "www.example.com").with(:headers => SAMPLE_HEADERS)
 
         lambda {
           http_request(
-            :get, "http://www.google.com/",
+            :get, "http://www.example.com/",
           :headers => { 'Content-Length' => '9999'})
-        }.should raise_error(WebMock::NetConnectNotAllowedError,
-          %q(Real HTTP connections are disabled. Unregistered request: GET http://www.google.com/ with headers {'Content-Length'=>'9999'}))
+        }.should fail_with(%q(Real HTTP connections are disabled. Unregistered request: GET http://www.example.com/ with headers {'Content-Length'=>'9999'}))
       end
     end
 
     describe "with basic authentication" do
 
       it "should match if credentials are the same" do
-        stub_http_request(:get, "user:pass@www.google.com")
-        http_request(:get, "http://user:pass@www.google.com/").status.should == "200"
+        stub_http_request(:get, "user:pass@www.example.com")
+        http_request(:get, "http://user:pass@www.example.com/").status.should == "200"
       end
 
       it "should not match if credentials are different" do
-        stub_http_request(:get, "user:pass@www.google.com")
+        stub_http_request(:get, "user:pass@www.example.com")
         lambda {
-          http_request(:get, "http://user:pazz@www.google.com/").status.should == "200"
-        }.should raise_error(WebMock::NetConnectNotAllowedError,
-          %q(Real HTTP connections are disabled. Unregistered request: GET http://user:pazz@www.google.com/ with headers {'Authorization'=>'Basic dXNlcjpwYXp6'}))
+          http_request(:get, "http://user:pazz@www.example.com/").status.should == "200"
+        }.should fail_with(%q(Real HTTP connections are disabled. Unregistered request: GET http://user:pazz@www.example.com/))
       end
 
       it "should not match if credentials are stubbed but not provided in the request" do
-        stub_http_request(:get, "user:pass@www.google.com")
+        stub_http_request(:get, "user:pass@www.example.com")
         lambda {
-          http_request(:get, "http://www.google.com/").status.should == "200"
-        }.should raise_error(WebMock::NetConnectNotAllowedError,
-          %q(Real HTTP connections are disabled. Unregistered request: GET http://www.google.com/))
+          http_request(:get, "http://www.example.com/").status.should == "200"
+        }.should fail_with(%q(Real HTTP connections are disabled. Unregistered request: GET http://www.example.com/))
       end
 
       it "should not match if credentials are not stubbed but exist in the request" do
-        stub_http_request(:get, "www.google.com")
+        stub_http_request(:get, "www.example.com")
         lambda {
-          http_request(:get, "http://user:pazz@www.google.com/").status.should == "200"
-        }.should raise_error(WebMock::NetConnectNotAllowedError,
-          %q(Real HTTP connections are disabled. Unregistered request: GET http://user:pazz@www.google.com/ with headers {'Authorization'=>'Basic dXNlcjpwYXp6'}))
+          http_request(:get, "http://user:pazz@www.example.com/").status.should == "200"
+        }.should fail_with(%q(Real HTTP connections are disabled. Unregistered request: GET http://user:pazz@www.example.com/))
       end
 
     end
@@ -184,9 +184,9 @@ describe "WebMock", :shared => true do
 
     it "should raise exception if declared in a stubbed response" do
       class MyException < StandardError; end;
-        stub_http_request(:get, "www.google.com").to_raise(MyException)
+        stub_http_request(:get, "www.example.com").to_raise(MyException)
         lambda {
-          http_request(:get, "http://www.google.com/")
+          http_request(:get, "http://www.example.com/")
         }.should raise_error(MyException, "Exception from WebMock")
       end
 
@@ -196,19 +196,34 @@ describe "WebMock", :shared => true do
     describe "returning stubbed responses" do
 
       it "should return declared body" do
-        stub_http_request(:get, "www.google.com").to_return(:body => "abc")
-        http_request(:get, "http://www.google.com/").body.should == "abc"
+        stub_http_request(:get, "www.example.com").to_return(:body => "abc")
+        http_request(:get, "http://www.example.com/").body.should == "abc"
       end
 
       it "should return declared headers" do
-        stub_http_request(:get, "www.google.com").to_return(:headers => SAMPLE_HEADERS)
-        response = http_request(:get, "http://www.google.com/")
+        stub_http_request(:get, "www.example.com").to_return(:headers => SAMPLE_HEADERS)
+        response = http_request(:get, "http://www.example.com/")
         response.headers["Content-Length"].should == "8888"
       end
 
       it "should return declared status" do
-        stub_http_request(:get, "www.google.com").to_return(:status => 500)
-        http_request(:get, "http://www.google.com/").status.should == "500"
+        stub_http_request(:get, "www.example.com").to_return(:status => 500)
+        http_request(:get, "http://www.example.com/").status.should == "500"
+      end
+
+
+      describe "dynamic responses" do
+        
+        it "should return evaluated response body" do
+          stub_http_request(:post, "www.example.com").to_return(:body => lambda { |request| request.body })
+          http_request(:post, "http://www.example.com/", :body => "echo").body.should == "echo"
+        end
+        
+        it "should return evaluated response headers" do
+          stub_http_request(:post, "www.example.com").to_return(:headers => lambda { |request| request.headers })
+          http_request(:post, "http://www.example.com/", :headers => {'A' => 'B'}).headers['A'].should == 'B'
+        end        
+        
       end
 
     end
@@ -217,15 +232,15 @@ describe "WebMock", :shared => true do
     describe "precedence of stubs" do
 
       it "should use the last declared matching request stub" do
-        stub_http_request(:get, "www.google.com").to_return(:body => "abc")
-        stub_http_request(:get, "www.google.com").to_return(:body => "def")
-        http_request(:get, "http://www.google.com/").body.should == "def"
+        stub_http_request(:get, "www.example.com").to_return(:body => "abc")
+        stub_http_request(:get, "www.example.com").to_return(:body => "def")
+        http_request(:get, "http://www.example.com/").body.should == "def"
       end
 
       it "should not be affected by the type of uri or request method" do
-        stub_http_request(:get, "www.google.com").to_return(:body => "abc")
-        stub_http_request(:any, /.*google.*/).to_return(:body => "def")
-        http_request(:get, "http://www.google.com/").body.should == "def"
+        stub_http_request(:get, "www.example.com").to_return(:body => "abc")
+        stub_http_request(:any, /.*example.*/).to_return(:body => "def")
+        http_request(:get, "http://www.example.com/").body.should == "def"
       end
 
     end
@@ -236,83 +251,83 @@ describe "WebMock", :shared => true do
 
         before(:each) do
           WebMock.disable_net_connect!
-          stub_http_request(:any, "http://www.google.com")
-          stub_http_request(:any, "https://www.google.com")
+          stub_http_request(:any, "http://www.example.com")
+          stub_http_request(:any, "https://www.example.com")
         end
 
         it "should pass if request was executed with the same uri and method" do
           lambda {
-            http_request(:get, "http://www.google.com/")
-            request(:get, "http://www.google.com").should have_been_made.once
+            http_request(:get, "http://www.example.com/")
+            request(:get, "http://www.example.com").should have_been_made.once
           }.should_not raise_error
         end
 
         it "should pass if request was not expected and not executed" do
           lambda {
-            request(:get, "http://www.google.com").should_not have_been_made
+            request(:get, "http://www.example.com").should_not have_been_made
           }.should_not raise_error
         end
 
         it "should fail if request was not expected but executed" do
           lambda {
-            http_request(:get, "http://www.google.com/")
-            request(:get, "http://www.google.com").should_not have_been_made
-          }.should fail_with("The request GET http://www.google.com/ was expected to execute 0 times but it executed 1 time")
+            http_request(:get, "http://www.example.com/")
+            request(:get, "http://www.example.com").should_not have_been_made
+          }.should fail_with("The request GET http://www.example.com/ was expected to execute 0 times but it executed 1 time")
         end
 
 
         it "should fail if request was not executed" do
           lambda {
-            request(:get, "http://www.google.com").should have_been_made
-          }.should fail_with("The request GET http://www.google.com/ was expected to execute 1 time but it executed 0 times")
+            request(:get, "http://www.example.com").should have_been_made
+          }.should fail_with("The request GET http://www.example.com/ was expected to execute 1 time but it executed 0 times")
         end
 
         it "should fail if request was executed to different uri" do
           lambda {
-            http_request(:get, "http://www.google.com/")
-            request(:get, "http://www.google.org").should have_been_made
-          }.should fail_with("The request GET http://www.google.org/ was expected to execute 1 time but it executed 0 times")
+            http_request(:get, "http://www.example.com/")
+            request(:get, "http://www.example.org").should have_been_made
+          }.should fail_with("The request GET http://www.example.org/ was expected to execute 1 time but it executed 0 times")
         end
 
         it "should fail if request was executed with different method" do
           lambda {
-            http_request(:post, "http://www.google.com/")
-            request(:get, "http://www.google.com").should have_been_made
-          }.should fail_with("The request GET http://www.google.com/ was expected to execute 1 time but it executed 0 times")
+            http_request(:post, "http://www.example.com/")
+            request(:get, "http://www.example.com").should have_been_made
+          }.should fail_with("The request GET http://www.example.com/ was expected to execute 1 time but it executed 0 times")
         end
 
         it "should pass if request was executed with different form of uri" do
           lambda {
-            http_request(:get, "http://www.google.com/")
-            request(:get, "www.google.com").should have_been_made
+            http_request(:get, "http://www.example.com/")
+            request(:get, "www.example.com").should have_been_made
           }.should_not raise_error
         end
 
         it "should pass if request was executed with different form of uri without port " do
           lambda {
-            http_request(:get, "http://www.google.com/")
-            request(:get, "www.google.com:80").should have_been_made
+            http_request(:get, "http://www.example.com/")
+            request(:get, "www.example.com:80").should have_been_made
           }.should_not raise_error
         end
 
         it "should pass if request was executed with different form of uri with port" do
           lambda {
-            http_request(:get, "http://www.google.com/")
-            request(:get, "www.google.com:80").should have_been_made
+            http_request(:get, "http://www.example.com/")
+            request(:get, "www.example.com:80").should have_been_made
           }.should_not raise_error
         end
 
         it "should fail if request was executed with different  port" do
           lambda {
-            http_request(:get, "http://www.google.com:80/")
-            request(:get, "www.google.com:90").should have_been_made
-          }.should fail_with("The request GET http://www.google.com:90/ was expected to execute 1 time but it executed 0 times")
+            http_request(:get, "http://www.example.com:80/")
+            request(:get, "www.example.com:90").should have_been_made
+          }.should fail_with("The request GET http://www.example.com:90/ was expected to execute 1 time but it executed 0 times")
         end
 
         it "should pass if request was executed with different form of uri with https port" do
           lambda {
-            http_request(:get, "https://www.google.com/")
-            request(:get, "https://www.google.com:443/").should have_been_made
+            http_request(:get, "https://www.example.com/")
+            request(:get, "https://www.example.com:443/").should have_been_made
           }.should_not raise_error
         end
 
@@ -320,145 +335,145 @@ describe "WebMock", :shared => true do
 
           before(:each) do
             WebMock.disable_net_connect!
-            stub_http_request(:any, "http://www.google.com/?#{NOT_ESCAPED_PARAMS}")
+            stub_http_request(:any, "http://www.example.com/?#{NOT_ESCAPED_PARAMS}")
           end
 
           it "should pass if request was executed with escaped params" do
             lambda {
-              http_request(:get, "http://www.google.com/?#{ESCAPED_PARAMS}")
-              request(:get, "http://www.google.com/?#{NOT_ESCAPED_PARAMS}").should have_been_made
+              http_request(:get, "http://www.example.com/?#{ESCAPED_PARAMS}")
+              request(:get, "http://www.example.com/?#{NOT_ESCAPED_PARAMS}").should have_been_made
             }.should_not raise_error
           end
 
           it "should pass if request was executed with non escaped params but escaped expected" do
             lambda {
-              http_request(:get, "http://www.google.com/?#{NOT_ESCAPED_PARAMS}")
-              request(:get, "http://www.google.com/?#{ESCAPED_PARAMS}").should have_been_made
+              http_request(:get, "http://www.example.com/?#{NOT_ESCAPED_PARAMS}")
+              request(:get, "http://www.example.com/?#{ESCAPED_PARAMS}").should have_been_made
             }.should_not raise_error
           end
 
           it "should pass if request was executed with escaped params but uri matichg regexp expected" do
             lambda {
-              http_request(:get, "http://www.google.com/?#{ESCAPED_PARAMS}")
-              request(:get, /.*google.*/).should have_been_made
+              http_request(:get, "http://www.example.com/?#{ESCAPED_PARAMS}")
+              request(:get, /.*example.*/).should have_been_made
             }.should_not raise_error
           end
         end
 
         it "should fail if requested more times than expected" do
           lambda {
-            http_request(:get, "http://www.google.com/")
-            http_request(:get, "http://www.google.com/")
-            request(:get, "http://www.google.com").should have_been_made
-          }.should fail_with("The request GET http://www.google.com/ was expected to execute 1 time but it executed 2 times")
+            http_request(:get, "http://www.example.com/")
+            http_request(:get, "http://www.example.com/")
+            request(:get, "http://www.example.com").should have_been_made
+          }.should fail_with("The request GET http://www.example.com/ was expected to execute 1 time but it executed 2 times")
         end
 
         it "should fail if requested less times than expected" do
           lambda {
-            http_request(:get, "http://www.google.com/")
-            request(:get, "http://www.google.com").should have_been_made.twice
-          }.should fail_with("The request GET http://www.google.com/ was expected to execute 2 times but it executed 1 time")
+            http_request(:get, "http://www.example.com/")
+            request(:get, "http://www.example.com").should have_been_made.twice
+          }.should fail_with("The request GET http://www.example.com/ was expected to execute 2 times but it executed 1 time")
         end
 
         it "should fail if requested less times than expected when 3 times expected" do
           lambda {
-            http_request(:get, "http://www.google.com/")
-            request(:get, "http://www.google.com").should have_been_made.times(3)
-          }.should fail_with("The request GET http://www.google.com/ was expected to execute 3 times but it executed 1 time")
+            http_request(:get, "http://www.example.com/")
+            request(:get, "http://www.example.com").should have_been_made.times(3)
+          }.should fail_with("The request GET http://www.example.com/ was expected to execute 3 times but it executed 1 time")
         end
 
         it "should succeed if request was executed with the same body" do
           lambda {
-            http_request(:get, "http://www.google.com/", :body => "abc")
-            request(:get, "www.google.com").with(:body => "abc").should have_been_made
+            http_request(:get, "http://www.example.com/", :body => "abc")
+            request(:get, "www.example.com").with(:body => "abc").should have_been_made
           }.should_not raise_error
         end
 
         it "should fail if request was executed with different body" do
           lambda {
-            http_request(:get, "http://www.google.com/", :body => "abc")
-            request(:get, "www.google.com").
+            http_request(:get, "http://www.example.com/", :body => "abc")
+            request(:get, "www.example.com").
             with(:body => "def").should have_been_made
-          }.should fail_with("The request GET http://www.google.com/ with body 'def' was expected to execute 1 time but it executed 0 times")
+          }.should fail_with("The request GET http://www.example.com/ with body 'def' was expected to execute 1 time but it executed 0 times")
         end
 
         it "should succeed if request was executed with the same headers" do
           lambda {
-            http_request(:get, "http://www.google.com/", :headers => SAMPLE_HEADERS)
-            request(:get, "www.google.com").
+            http_request(:get, "http://www.example.com/", :headers => SAMPLE_HEADERS)
+            request(:get, "www.example.com").
             with(:headers => SAMPLE_HEADERS).should have_been_made
           }.should_not raise_error
         end
 
         it "should fail if request was executed with different headers" do
           lambda {
-            http_request(:get, "http://www.google.com/", :headers => SAMPLE_HEADERS)
-            request(:get, "www.google.com").
+            http_request(:get, "http://www.example.com/", :headers => SAMPLE_HEADERS)
+            request(:get, "www.example.com").
             with(:headers => { 'Content-Length' => '9999'}).should have_been_made
-          }.should fail_with("The request GET http://www.google.com/ with headers {'Content-Length'=>'9999'} was expected to execute 1 time but it executed 0 times")
+          }.should fail_with("The request GET http://www.example.com/ with headers {'Content-Length'=>'9999'} was expected to execute 1 time but it executed 0 times")
         end
 
         it "should fail if request was executed with less headers" do
           lambda {
-            http_request(:get, "http://www.google.com/", :headers => {'A' => 'a'})
-            request(:get, "www.google.com").
+            http_request(:get, "http://www.example.com/", :headers => {'A' => 'a'})
+            request(:get, "www.example.com").
             with(:headers => {'A' => 'a', 'B' => 'b'}).should have_been_made
-          }.should fail_with("The request GET http://www.google.com/ with headers {'A'=>'a', 'B'=>'b'} was expected to execute 1 time but it executed 0 times")
+          }.should fail_with("The request GET http://www.example.com/ with headers {'A'=>'a', 'B'=>'b'} was expected to execute 1 time but it executed 0 times")
         end
 
         it "should succeed if request was executed with more headers" do
           lambda {
-            http_request(:get, "http://www.google.com/",
+            http_request(:get, "http://www.example.com/",
               :headers => {'A' => 'a', 'B' => 'b'}
             )
-            request(:get, "www.google.com").
+            request(:get, "www.example.com").
             with(:headers => {'A' => 'a'}).should have_been_made
           }.should_not raise_error
         end
 
         it "should succeed if request was executed with body and headers but they were not specified in expectantion" do
           lambda {
-            http_request(:get, "http://www.google.com/",
+            http_request(:get, "http://www.example.com/",
               :body => "abc",
               :headers => SAMPLE_HEADERS
             )
-            request(:get, "www.google.com").should have_been_made
+            request(:get, "www.example.com").should have_been_made
           }.should_not raise_error
         end
 
 
         describe "with authentication" do
           before(:each) do
-            stub_http_request(:any, "http://user:pass@www.google.com")
-            stub_http_request(:any, "http://user:pazz@www.google.com")
+            stub_http_request(:any, "http://user:pass@www.example.com")
+            stub_http_request(:any, "http://user:pazz@www.example.com")
           end
 
           it "should succeed if succeed if request was executed with expected credentials" do
             lambda {
-              http_request(:get, "http://user:pass@www.google.com/")
-              request(:get, "http://user:pass@www.google.com").should have_been_made.once
+              http_request(:get, "http://user:pass@www.example.com/")
+              request(:get, "http://user:pass@www.example.com").should have_been_made.once
             }.should_not raise_error
           end
 
           it "should fail if request was executed with different credentials than expected" do
             lambda {
-              http_request(:get, "http://user:pass@www.google.com/")
-              request(:get, "http://user:pazz@www.google.com").should have_been_made.once
-            }.should fail_with("The request GET http://user:pazz@www.google.com/ was expected to execute 1 time but it executed 0 times")
+              http_request(:get, "http://user:pass@www.example.com/")
+              request(:get, "http://user:pazz@www.example.com").should have_been_made.once
+            }.should fail_with("The request GET http://user:pazz@www.example.com/ was expected to execute 1 time but it executed 0 times")
           end
 
           it "should fail if request was executed without credentials but credentials were expected" do
             lambda {
-              http_request(:get, "http://www.google.com/")
-              request(:get, "http://user:pass@www.google.com").should have_been_made.once
-            }.should fail_with("The request GET http://user:pass@www.google.com/ was expected to execute 1 time but it executed 0 times")
+              http_request(:get, "http://www.example.com/")
+              request(:get, "http://user:pass@www.example.com").should have_been_made.once
+            }.should fail_with("The request GET http://user:pass@www.example.com/ was expected to execute 1 time but it executed 0 times")
           end
 
           it "should fail if request was executed with credentials but expected without" do
             lambda {
-              http_request(:get, "http://user:pass@www.google.com/")
-              request(:get, "http://www.google.com").should have_been_made.once
-            }.should fail_with("The request GET http://www.google.com/ was expected to execute 1 time but it executed 0 times")
+              http_request(:get, "http://user:pass@www.example.com/")
+              request(:get, "http://www.example.com").should have_been_made.once
+            }.should fail_with("The request GET http://www.example.com/ was expected to execute 1 time but it executed 0 times")
           end
 
         end
@@ -467,23 +482,23 @@ describe "WebMock", :shared => true do
 
           it "should verify expected requests occured" do
             lambda {
-              http_request(:get, "http://www.google.com/")
-              WebMock.should have_requested(:get, "http://www.google.com").once
+              http_request(:get, "http://www.example.com/")
+              WebMock.should have_requested(:get, "http://www.example.com").once
             }.should_not raise_error
           end
 
           it "should verify expected requests occured" do
             lambda {
-              http_request(:get, "http://www.google.com/", :body => "abc", :headers => {'A' => 'a'})
-              WebMock.should have_requested(:get, "http://www.google.com").with(:body => "abc", :headers => {'A' => 'a'}).once
+              http_request(:get, "http://www.example.com/", :body => "abc", :headers => {'A' => 'a'})
+              WebMock.should have_requested(:get, "http://www.example.com").with(:body => "abc", :headers => {'A' => 'a'}).once
             }.should_not raise_error
           end
 
           it "should verify that non expected requests didn't occur" do
             lambda {
-              http_request(:get, "http://www.google.com/")
-              WebMock.should_not have_requested(:get, "http://www.google.com")
-            }.should fail_with("The request GET http://www.google.com/ was expected to execute 0 times but it executed 1 time")
+              http_request(:get, "http://www.example.com/")
+              WebMock.should_not have_requested(:get, "http://www.example.com")
+            }.should fail_with("The request GET http://www.example.com/ was expected to execute 0 times but it executed 1 time")
           end
         end
 
@@ -493,24 +508,24 @@ describe "WebMock", :shared => true do
 
           it "should verify expected requests occured" do
             lambda {
-              http_request(:get, "http://www.google.com/")
-              assert_requested(:get, "http://www.google.com", :times => 1)
-              assert_requested(:get, "http://www.google.com")
+              http_request(:get, "http://www.example.com/")
+              assert_requested(:get, "http://www.example.com", :times => 1)
+              assert_requested(:get, "http://www.example.com")
             }.should_not raise_error
           end
 
           it "should verify expected requests occured" do
             lambda {
-              http_request(:get, "http://www.google.com/", :body => "abc", :headers => {'A' => 'a'})
-              assert_requested(:get, "http://www.google.com", :body => "abc", :headers => {'A' => 'a'})
+              http_request(:get, "http://www.example.com/", :body => "abc", :headers => {'A' => 'a'})
+              assert_requested(:get, "http://www.example.com", :body => "abc", :headers => {'A' => 'a'})
             }.should_not raise_error
           end
 
           it "should verify that non expected requests didn't occur" do
             lambda {
-              http_request(:get, "http://www.google.com/")
-              assert_not_requested(:get, "http://www.google.com")
-            }.should fail_with("The request GET http://www.google.com/ was expected to execute 0 times but it executed 1 time")
+              http_request(:get, "http://www.example.com/")
+              assert_not_requested(:get, "http://www.example.com")
+            }.should fail_with("The request GET http://www.example.com/ was expected to execute 0 times but it executed 1 time")
           end
         end
       end
@@ -522,18 +537,18 @@ describe "WebMock", :shared => true do
         end
 
         it "should verify expected requests occured" do
-          setup_expectations_for_real_google_request
+          setup_expectations_for_real_example_com_request
           lambda {
-            http_request(:get, "http://www.google.com/")
-            request(:get, "http://www.google.com").should have_been_made
+            http_request(:get, "http://www.example.com/")
+            request(:get, "http://www.example.com").should have_been_made
           }.should_not raise_error
         end
 
         it "should verify that non expected requests didn't occur" do
           lambda {
-            http_request(:get, "http://www.google.com/")
-            request(:get, "http://www.google.com").should_not have_been_made
-          }.should fail_with("The request GET http://www.google.com/ was expected to execute 0 times but it executed 1 time")
+            http_request(:get, "http://www.example.com/")
+            request(:get, "http://www.example.com").should_not have_been_made
+          }.should fail_with("The request GET http://www.example.com/ was expected to execute 0 times but it executed 1 time")
         end
       end