webmock 1.3.5 → 1.4.0

data/spec/util/hash_counter_spec.rb

@@ -1,13 +1,13 @@
 require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
 
-describe Util::HashCounter do
+describe WebMock::Util::HashCounter do
 
   it "should return 0 for non existing key" do
-    Util::HashCounter.new.get(:abc).should == 0
+    WebMock::Util::HashCounter.new.get(:abc).should == 0
   end
 
   it "should increase the returned value on every put with the same key" do
-    counter =Util::HashCounter.new
+    counter = WebMock::Util::HashCounter.new
     counter.put(:abc)
     counter.get(:abc).should == 1
     counter.put(:abc)
@@ -15,7 +15,7 @@ describe Util::HashCounter do
   end
 
   it "should only increase value for given key provided to put" do
-    counter =Util::HashCounter.new
+    counter = WebMock::Util::HashCounter.new
     counter.put(:abc)
     counter.get(:abc).should == 1
     counter.get(:def).should == 0

data/spec/util/headers_spec.rb

@@ -4,22 +4,22 @@ describe WebMock::Util::Headers do
 
   it "should decode_userinfo_from_header handles basic auth" do
     authorization_header = "Basic dXNlcm5hbWU6c2VjcmV0"
-    userinfo = Util::Headers.decode_userinfo_from_header(authorization_header)
+    userinfo = WebMock::Util::Headers.decode_userinfo_from_header(authorization_header)
     userinfo.should == "username:secret"
   end
 
   describe "sorted_headers_string" do
     
     it "should return nice string for hash with string values" do
-      Util::Headers.sorted_headers_string({"a" => "b"}).should == "{'A'=>'b'}"
+      WebMock::Util::Headers.sorted_headers_string({"a" => "b"}).should == "{'A'=>'b'}"
     end
     
     it "should return nice string for hash with array values" do
-      Util::Headers.sorted_headers_string({"a" => ["b", "c"]}).should == "{'A'=>['b', 'c']}"
+      WebMock::Util::Headers.sorted_headers_string({"a" => ["b", "c"]}).should == "{'A'=>['b', 'c']}"
     end
   
     it "should return nice string for hash with array values and string values" do
-      Util::Headers.sorted_headers_string({"a" => ["b", "c"], "d" => "e"}).should == "{'A'=>['b', 'c'], 'D'=>'e'}"
+      WebMock::Util::Headers.sorted_headers_string({"a" => ["b", "c"], "d" => "e"}).should == "{'A'=>['b', 'c'], 'D'=>'e'}"
     end
     
   

data/spec/webmock_spec.rb

@@ -2,7 +2,7 @@ require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
 
 unless defined? SAMPLE_HEADERS
   SAMPLE_HEADERS = { "Content-Length" => "8888", "Accept" => "application/json" }
-  ESCAPED_PARAMS = "x=ab%2Bc&z=%27Stop%21%27%20said%20Fred"
+  ESCAPED_PARAMS = "x=ab%20c&z=%27Stop%21%27%20said%20Fred"
   NOT_ESCAPED_PARAMS = "z='Stop!' said Fred&x=ab c"
   WWW_EXAMPLE_COM_CONTENT_LENGTH = 596
 end
@@ -21,7 +21,7 @@ end
 describe "WebMock", :shared => true do
   before(:each) do
     WebMock.disable_net_connect!
-    RequestRegistry.instance.reset_webmock
+    WebMock::RequestRegistry.instance.reset_webmock
   end
 
   describe "when web connect" do
@@ -98,6 +98,12 @@ describe "WebMock", :shared => true do
           http_request(:get, "http://127.0.0.1:12345/")
         }.should raise_error(connection_refused_exception_class)
       end
+
+       it "should allow a real request to 0.0.0.0" do
+          lambda {
+            http_request(:get, "http://0.0.0.0:12345/")
+          }.should raise_error(connection_refused_exception_class)
+        end
     end
     
    describe "is not allowed with exception for allowed domains" do
@@ -116,7 +122,7 @@ describe "WebMock", :shared => true do
         }.should raise_error(WebMock::NetConnectNotAllowedError, client_specific_request_string("Real HTTP connections are disabled. Unregistered request: GET http://www.example.com/"))
       end
 
-      it "should allow a real request to cms.local" do
+      it "should allow a real request to allowed host" do
         http_request(:get, "http://www.example.org/").status.should == "200"
       end
     end
@@ -833,76 +839,83 @@ describe "WebMock", :shared => true do
               it "should pass if request was executed with the same uri and method" do
                 lambda {
                   http_request(:get, "http://www.example.com/")
-                  request(:get, "http://www.example.com").should have_been_made.once
+                  a_request(:get, "http://www.example.com").should have_been_made.once
+                }.should_not raise_error
+              end
+
+              it "should accept verification as WebMock class method invocation" do
+                lambda {
+                  http_request(:get, "http://www.example.com/")
+                  WebMock.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.example.com").should_not have_been_made
+                  a_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.example.com/")
-                  request(:get, "http://www.example.com").should_not have_been_made
+                  a_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.example.com").should have_been_made
+                  a_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.example.com/")
-                  request(:get, "http://www.example.org").should have_been_made
+                  a_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.example.com/", :body => "abc")
-                  request(:get, "http://www.example.com").should have_been_made
+                  a_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.example.com/")
-                  request(:get, "www.example.com").should have_been_made
+                  a_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.example.com/")
-                  request(:get, "www.example.com:80").should have_been_made
+                  a_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.example.com/")
-                  request(:get, "www.example.com:80").should have_been_made
+                  a_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.example.com:80/")
-                  request(:get, "www.example.com:90").should have_been_made
+                  a_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.example.com/")
-                  request(:get, "https://www.example.com:443/").should have_been_made
+                  a_request(:get, "https://www.example.com:443/").should have_been_made
                 }.should_not raise_error
               end
 
@@ -916,21 +929,21 @@ describe "WebMock", :shared => true do
                 it "should pass if request was executed with escaped params" do
                   lambda {
                     http_request(:get, "http://www.example.com/?#{ESCAPED_PARAMS}")
-                    request(:get, "http://www.example.com/?#{NOT_ESCAPED_PARAMS}").should have_been_made
+                    a_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.example.com/?#{NOT_ESCAPED_PARAMS}")
-                    request(:get, "http://www.example.com/?#{ESCAPED_PARAMS}").should have_been_made
+                    a_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.example.com/?#{ESCAPED_PARAMS}")
-                    request(:get, /.*example.*/).should have_been_made
+                    a_request(:get, /.*example.*/).should have_been_made
                   }.should_not raise_error
                 end
                 
@@ -944,21 +957,21 @@ describe "WebMock", :shared => true do
                 it "should pass if the request was executed with query params declared in a hash in query option" do
                   lambda {
                     http_request(:get, "http://www.example.com/?a[]=b&a[]=c")
-                    request(:get, "www.example.com").with(:query => {"a" => ["b", "c"]}).should have_been_made
+                    a_request(:get, "www.example.com").with(:query => {"a" => ["b", "c"]}).should have_been_made
                   }.should_not raise_error
                 end
 
                 it "should pass if the request was executed with query params declared as string in query option" do
                   lambda {
                     http_request(:get, "http://www.example.com/?a[]=b&a[]=c")
-                    request(:get, "www.example.com").with(:query => "a[]=b&a[]=c").should have_been_made
+                    a_request(:get, "www.example.com").with(:query => "a[]=b&a[]=c").should have_been_made
                   }.should_not raise_error
                 end
 
                 it "should pass if the request was executed with query params both in uri and in query option" do
                   lambda {
                     http_request(:get, "http://www.example.com/?x=3&a[]=b&a[]=c")
-                    request(:get, "www.example.com/?x=3").with(:query => {"a" => ["b", "c"]}).should have_been_made
+                    a_request(:get, "www.example.com/?x=3").with(:query => {"a" => ["b", "c"]}).should have_been_made
                   }.should_not raise_error
                 end
               
@@ -968,35 +981,35 @@ describe "WebMock", :shared => true do
                 lambda {
                   http_request(:get, "http://www.example.com/")
                   http_request(:get, "http://www.example.com/")
-                  request(:get, "http://www.example.com").should have_been_made
+                  a_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.example.com/")
-                  request(:get, "http://www.example.com").should have_been_made.twice
+                  a_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.example.com/")
-                  request(:get, "http://www.example.com").should have_been_made.times(3)
+                  a_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(:post, "http://www.example.com/", :body => "abc")
-                  request(:post, "www.example.com").with(:body => "abc").should have_been_made
+                  a_request(:post, "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.example.com/", :body => "abc")
-                  request(:get, "www.example.com").
+                  a_request(:get, "www.example.com").
                   with(:body => "def").should have_been_made
                 }.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
@@ -1006,14 +1019,14 @@ describe "WebMock", :shared => true do
                 it "should succeed if request was executed with the same body" do
                   lambda {
                     http_request(:post, "http://www.example.com/", :body => "abc")
-                    request(:post, "www.example.com").with(:body => /^abc$/).should have_been_made
+                    a_request(:post, "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.example.com/", :body => /^abc/)
-                    request(:get, "www.example.com").
+                    a_request(:get, "www.example.com").
                     with(:body => "xabc").should have_been_made
                   }.should fail_with('The request GET http://www.example.com/ with body "xabc" was expected to execute 1 time but it executed 0 times')
                 end
@@ -1029,21 +1042,21 @@ describe "WebMock", :shared => true do
                   it "should succeed" do
                     lambda {
                       http_request(:post, "http://www.example.com/", :body => 'a=1&c[d][]=e&c[d][]=f&b=five')
-                      request(:post, "www.example.com").with(:body => body_hash).should have_been_made
+                      a_request(:post, "www.example.com").with(:body => body_hash).should have_been_made
                     }.should_not raise_error
                   end
                   
                   it "should succeed if url encoded params have different order" do
                     lambda {
                       http_request(:post, "http://www.example.com/", :body => 'a=1&c[d][]=e&b=five&c[d][]=f')
-                      request(:post, "www.example.com").with(:body => body_hash).should have_been_made
+                      a_request(:post, "www.example.com").with(:body => body_hash).should have_been_made
                     }.should_not raise_error
                   end
 
                   it "should fail if request is executed with url encoded body not matching hash" do
                     lambda {
                       http_request(:post, "http://www.example.com/", :body => 'c[d][]=f&a=1&c[d][]=e')
-                      request(:post, "www.example.com").with(:body => body_hash).should have_been_made
+                      a_request(:post, "www.example.com").with(:body => body_hash).should have_been_made
                     }.should fail_with(fail_message)
                   end
                 
@@ -1055,7 +1068,7 @@ describe "WebMock", :shared => true do
                     lambda {
                       http_request(:post, "http://www.example.com/", :headers => {'Content-Type' => 'application/json'},
                         :body => "{\"a\":\"1\",\"c\":{\"d\":[\"e\",\"f\"]},\"b\":\"five\"}")
-                      request(:post, "www.example.com").with(:body => body_hash).should have_been_made
+                      a_request(:post, "www.example.com").with(:body => body_hash).should have_been_made
                     }.should_not raise_error
                   end
                   
@@ -1063,7 +1076,7 @@ describe "WebMock", :shared => true do
                     lambda {
                       http_request(:post, "http://www.example.com/", :headers => {'Content-Type' => 'application/json'},
                         :body => "{\"a\":\"1\",\"b\":\"five\",\"c\":{\"d\":[\"e\",\"f\"]}}")
-                      request(:post, "www.example.com").with(:body => body_hash).should have_been_made
+                      a_request(:post, "www.example.com").with(:body => body_hash).should have_been_made
                     }.should_not raise_error
                   end
                 
@@ -1077,7 +1090,7 @@ describe "WebMock", :shared => true do
                     lambda {
                       http_request(:post, "http://www.example.com/", :headers => {'Content-Type' => 'application/xml'},
                         :body => "<opt a=\"1\" b=\"five\">\n  <c>\n    <d>e</d>\n    <d>f</d>\n  </c>\n</opt>\n")
-                      request(:post, "www.example.com").with(:body => body_hash).should have_been_made
+                      a_request(:post, "www.example.com").with(:body => body_hash).should have_been_made
                     }.should_not raise_error
                   end
                 
@@ -1085,7 +1098,7 @@ describe "WebMock", :shared => true do
                     lambda {
                       http_request(:post, "http://www.example.com/", :headers => {'Content-Type' => 'application/xml'},
                         :body => "<opt b=\"five\" a=\"1\">\n  <c>\n    <d>e</d>\n    <d>f</d>\n  </c>\n</opt>\n")
-                      request(:post, "www.example.com").with(:body => body_hash).should have_been_made
+                      a_request(:post, "www.example.com").with(:body => body_hash).should have_been_made
                     }.should_not raise_error
                   end
               
@@ -1096,7 +1109,7 @@ describe "WebMock", :shared => true do
               it "should succeed if request was executed with the same headers" do
                 lambda {
                   http_request(:get, "http://www.example.com/", :headers => SAMPLE_HEADERS)
-                  request(:get, "www.example.com").
+                  a_request(:get, "www.example.com").
                   with(:headers => SAMPLE_HEADERS).should have_been_made
                 }.should_not raise_error
               end
@@ -1104,7 +1117,7 @@ describe "WebMock", :shared => true do
                it "should succeed if request was executed with the same headers with value declared as array" do
                   lambda {
                     http_request(:get, "http://www.example.com/", :headers => {"a" => "b"})
-                    request(:get, "www.example.com").
+                    a_request(:get, "www.example.com").
                     with(:headers => {"a" => ["b"]}).should have_been_made
                   }.should_not raise_error
                 end
@@ -1114,7 +1127,7 @@ describe "WebMock", :shared => true do
                 it "should succeed if request was executed with the same headers" do
                   lambda {
                     http_request(:get, "http://www.example.com/", :headers => {"a" => ["b", "c"]})
-                    request(:get, "www.example.com").
+                    a_request(:get, "www.example.com").
                     with(:headers =>  {"a" => ["b", "c"]}).should have_been_made
                   }.should_not raise_error
                 end
@@ -1122,7 +1135,7 @@ describe "WebMock", :shared => true do
                 it "should succeed if request was executed with the same headers but different order" do
                   lambda {
                     http_request(:get, "http://www.example.com/", :headers => {"a" => ["b", "c"]})
-                    request(:get, "www.example.com").
+                    a_request(:get, "www.example.com").
                     with(:headers =>  {"a" => ["c", "b"]}).should have_been_made
                   }.should_not raise_error
                 end
@@ -1130,7 +1143,7 @@ describe "WebMock", :shared => true do
                 it "should fail if request was executed with different headers" do
                   lambda {
                     http_request(:get, "http://www.example.com/", :headers => {"a" => ["b", "c"]})
-                    request(:get, "www.example.com").
+                    a_request(:get, "www.example.com").
                     with(:headers => {"a" => ["b", "d"]}).should have_been_made
                   }.should fail_with("The request GET http://www.example.com/ with headers {'A'=>['b', 'd']} was expected to execute 1 time but it executed 0 times")
                 end
@@ -1140,7 +1153,7 @@ describe "WebMock", :shared => true do
               it "should fail if request was executed with different headers" do
                 lambda {
                   http_request(:get, "http://www.example.com/", :headers => SAMPLE_HEADERS)
-                  request(:get, "www.example.com").
+                  a_request(:get, "www.example.com").
                   with(:headers => { 'Content-Length' => '9999'}).should have_been_made
                 }.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
@@ -1148,7 +1161,7 @@ describe "WebMock", :shared => true do
               it "should fail if request was executed with less headers" do
                 lambda {
                   http_request(:get, "http://www.example.com/", :headers => {'A' => 'a'})
-                  request(:get, "www.example.com").
+                  a_request(:get, "www.example.com").
                   with(:headers => {'A' => 'a', 'B' => 'b'}).should have_been_made
                 }.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
@@ -1158,7 +1171,7 @@ describe "WebMock", :shared => true do
                   http_request(:get, "http://www.example.com/",
                     :headers => {'A' => 'a', 'B' => 'b'}
                   )
-                  request(:get, "www.example.com").
+                  a_request(:get, "www.example.com").
                   with(:headers => {'A' => 'a'}).should have_been_made
                 }.should_not raise_error
               end
@@ -1169,14 +1182,14 @@ describe "WebMock", :shared => true do
                     :body => "abc",
                     :headers => SAMPLE_HEADERS
                   )
-                  request(:get, "www.example.com").should have_been_made
+                  a_request(:get, "www.example.com").should have_been_made
                 }.should_not raise_error
               end
 
               it "should succeed if request was executed with headers matching regular expressions" do
                 lambda {
                   http_request(:get, "http://www.example.com/", :headers => { 'user-agent' => 'MyAppName' })
-                  request(:get, "www.example.com").
+                  a_request(:get, "www.example.com").
                   with(:headers => { :user_agent => /^MyAppName$/ }).should have_been_made
                 }.should_not raise_error
               end
@@ -1184,7 +1197,7 @@ describe "WebMock", :shared => true do
               it "should fail if request was executed with headers not matching regular expression" do
                 lambda {
                   http_request(:get, "http://www.example.com/", :headers => { 'user_agent' => 'xMyAppName' })
-                  request(:get, "www.example.com").
+                  a_request(:get, "www.example.com").
                   with(:headers => { :user_agent => /^MyAppName$/ }).should have_been_made
                 }.should fail_with("The request GET http://www.example.com/ with headers {'User-Agent'=>/^MyAppName$/} was expected to execute 1 time but it executed 0 times")
               end
@@ -1192,21 +1205,21 @@ describe "WebMock", :shared => true do
              it "should suceed if request was executed and block evaluated to true" do
                 lambda {
                   http_request(:post, "http://www.example.com/", :body => "wadus")
-                  request(:post, "www.example.com").with { |req| req.body == "wadus" }.should have_been_made
+                  a_request(:post, "www.example.com").with { |req| req.body == "wadus" }.should have_been_made
                 }.should_not raise_error
               end
 
               it "should fail if request was executed and block evaluated to false" do
                 lambda {
                   http_request(:post, "http://www.example.com/", :body => "abc")
-                  request(:post, "www.example.com").with { |req| req.body == "wadus" }.should have_been_made
+                  a_request(:post, "www.example.com").with { |req| req.body == "wadus" }.should have_been_made
                 }.should fail_with("The request POST http://www.example.com/ with given block was expected to execute 1 time but it executed 0 times")
               end
 
               it "should fail if request was not expected but it executed and block matched request" do
                 lambda {
                   http_request(:post, "http://www.example.com/", :body => "wadus")
-                  request(:post, "www.example.com").with { |req| req.body == "wadus" }.should_not have_been_made
+                  a_request(:post, "www.example.com").with { |req| req.body == "wadus" }.should_not have_been_made
                 }.should fail_with("The request POST http://www.example.com/ with given block was expected to execute 0 times but it executed 1 time")
               end
 
@@ -1219,28 +1232,28 @@ describe "WebMock", :shared => true do
                 it "should succeed if succeed if request was executed with expected credentials" do
                   lambda {
                     http_request(:get, "http://user:pass@www.example.com/")
-                    request(:get, "http://user:pass@www.example.com").should have_been_made.once
+                    a_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.example.com/")
-                    request(:get, "http://user:pazz@www.example.com").should have_been_made.once
+                    a_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.example.com/")
-                    request(:get, "http://user:pass@www.example.com").should have_been_made.once
+                    a_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.example.com/")
-                    request(:get, "http://www.example.com").should have_been_made.once
+                    a_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
 
@@ -1358,14 +1371,14 @@ describe "WebMock", :shared => true do
                 setup_expectations_for_real_example_com_request
                 lambda {
                   http_request(:get, "http://www.example.com/")
-                  request(:get, "http://www.example.com").should have_been_made
+                  a_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.example.com/")
-                  request(:get, "http://www.example.com").should_not have_been_made
+                  a_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