webmock 0.9.1 → 1.0.0

data/spec/spec_helper.rb

@@ -1,5 +1,7 @@
 require 'rubygems'
 require 'httpclient'
+require 'patron' unless RUBY_PLATFORM =~ /java/
+
 $LOAD_PATH.unshift(File.dirname(__FILE__))
 $LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
 require 'spec'
@@ -29,7 +31,7 @@ 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>" }
+    :response_body => "<title>example</title>" }
   setup_expectations_for_real_request(defaults.merge(options))
 end
 
@@ -38,23 +40,13 @@ def client_specific_request_string(string)
   has_body = string.include?(" with body")
   default_headers = default_client_request_headers(method, has_body)
   if default_headers
-   default_headers_string = WebMock::Util::Headers.normalize_headers(default_headers).inspect.gsub("\"","'")
-   default_headers_string.gsub!(/[{}]/, "")
-   if string.include?(" with headers")
+    if string.include?(" with headers")
       current_headers = JSON.parse(string.gsub(/.*with headers (\{[^}]+\}).*/, '\1').gsub("=>",":").gsub("'","\""))
       default_headers = WebMock::Util::Headers.normalize_headers(default_headers)
-      default_headers.reject! {|k,v| current_headers.has_key?(k) }
-      default_headers_string = default_headers.inspect.gsub("\"","'").gsub!(/[{}]/, "")
-      string.gsub!(/(.*)(with headers \{[^}]*)(\}.*)/, '\1\2' + ", #{default_headers_string}}") if !default_headers_string.empty?
-      string
-    else
-      headers_string = 
-      " with headers #{WebMock::Util::Headers.normalize_headers(default_headers).inspect.gsub("\"","'")}"
-      string << headers_string
-      end
+      default_headers.merge!(current_headers)
+      string.gsub!(/(.*) with headers.*/,'\1')
+    end
+    string << " with headers #{WebMock::Util::Headers.sorted_headers_string(default_headers)}"
   end
   string
 end
-
-
-

data/spec/webmock_spec.rb

@@ -24,13 +24,17 @@ describe "WebMock", :shared => true do
       it "should make a real web request if request is not stubbed" do
         setup_expectations_for_real_example_com_request
         http_request(:get, "http://www.example.com/").
-          body.should =~ /.*Google fake response.*/
+          body.should =~ /.*example.*/
       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.*/
+        setup_expectations_for_real_example_com_request(
+         :host => "www.paypal.com",
+         :port => 443,
+         :response_body => "hello paypal"
+        )
+        http_request(:get, "https://www.paypal.com/").
+          body.should =~ /.*paypal.*/
       end
 
       it "should return stubbed response if request was stubbed" do
@@ -56,6 +60,28 @@ describe "WebMock", :shared => true do
       end
     end
 
+    describe "is not allowed with exception for localhost" do
+      before(:each) do
+        WebMock.disable_net_connect!(:allow_localhost => true)
+      end
+
+      it "should return stubbed response if request was stubbed" do
+        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.example.com/")
+        }.should fail_with(client_specific_request_string("Real HTTP connections are disabled. Unregistered request: GET http://www.example.com/"))
+      end
+
+      it "should allow a real request localhost" do
+        lambda {
+          http_request(:get, "http://localhost:12345/")
+        }.should raise_error(connection_refused_exception_class)
+      end
+    end
   end
 
   describe "when matching requests" do
@@ -90,9 +116,9 @@ describe "WebMock", :shared => true do
         stub_http_request(:get, "www.example.com")
         http_request(:get, "http://www.example.com/").status.should == "200"
         lambda {
-          http_request(:post, "http://www.example.com/")
+          http_request(:delete, "http://www.example.com/")
         }.should fail_with(client_specific_request_string(
-        "Real HTTP connections are disabled. Unregistered request: POST http://www.example.com/")
+        "Real HTTP connections are disabled. Unregistered request: DELETE http://www.example.com/")
         )
       end
 
@@ -236,14 +262,14 @@ describe "WebMock", :shared => true do
       end
 
     end
-    
+
     describe "with block" do
-      
+
       it "should match if block returns true" do
         stub_http_request(:get, "www.example.com").with { |request| true }
         http_request(:get, "http://www.example.com/").status.should == "200"
       end
-      
+
       it "should not match if block returns false" do
         stub_http_request(:get, "www.example.com").with { |request| false }
         lambda {
@@ -251,7 +277,7 @@ describe "WebMock", :shared => true do
         }.should fail_with(client_specific_request_string(
         "Real HTTP connections are disabled. Unregistered request: GET http://www.example.com/"))
       end
-      
+
       it "should pass the request to the block" do
         stub_http_request(:post, "www.example.com").with { |request| request.body == "wadus" }
         http_request(
@@ -262,7 +288,7 @@ describe "WebMock", :shared => true do
         }.should fail_with(client_specific_request_string(
         "Real HTTP connections are disabled. Unregistered request: POST http://www.example.com/ with body 'jander'"))
       end
-      
+
     end
 
   end
@@ -287,6 +313,25 @@ describe "WebMock", :shared => true do
       end
 
 
+   describe "raising timeout errors" do
+          
+        it "should raise timeout exception if declared in a stubbed response" do
+          stub_http_request(:get, "www.example.com").to_timeout
+          lambda {
+            http_request(:get, "http://www.example.com/")
+          }.should raise_error(client_timeout_exception_class)
+        end
+
+        it "should raise exception if declared in a stubbed response after returning declared response" do
+          stub_http_request(:get, "www.example.com").to_return(:body => "abc").then.to_timeout
+          http_request(:get, "http://www.example.com/").body.should == "abc"
+          lambda {
+            http_request(:get, "http://www.example.com/")
+          }.should raise_error(client_timeout_exception_class)
+        end
+
+    end
+
       describe "returning stubbed responses" do
 
         it "should return declared body" do
@@ -300,10 +345,25 @@ describe "WebMock", :shared => true do
           response.headers["Content-Length"].should == "8888"
         end
 
-        it "should return declared status" do
+        it "should return declared status code" do
           stub_http_request(:get, "www.example.com").to_return(:status => 500)
           http_request(:get, "http://www.example.com/").status.should == "500"
         end
+        
+        it "should return declared status message" do
+          stub_http_request(:get, "www.example.com").to_return(:status => [500, "Internal Server Error"])
+          http_request(:get, "http://www.example.com/").message.should == "Internal Server Error"
+        end
+        
+        it "should return default status code" do
+          stub_http_request(:get, "www.example.com")
+          http_request(:get, "http://www.example.com/").status.should == "200"
+        end
+        
+        it "should return default empty message" do
+          stub_http_request(:get, "www.example.com")
+          http_request(:get, "http://www.example.com/").message.should == ""
+        end      
 
         it "should return body declared as IO" do
           stub_http_request(:get, "www.example.com").to_return(:body => File.new(__FILE__))
@@ -322,7 +382,7 @@ describe "WebMock", :shared => true do
           @file.should be_closed
         end
 
-        describe "dynamic responses" do
+        describe "dynamic response parts" do
 
           it "should return evaluated response body" do
             stub_http_request(:post, "www.example.com").to_return(:body => lambda { |request| request.body })
@@ -331,11 +391,48 @@ describe "WebMock", :shared => true do
 
           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'
+            http_request(:post, "http://www.example.com/", :body => "abc", :headers => {'A' => 'B'}).headers['A'].should == 'B'
           end
 
         end
 
+        describe "dynamic responses" do
+
+          class Responder
+            def call(request)
+              {:body => request.body}
+            end
+          end
+
+          it "should return evaluated response body" do
+            stub_http_request(:post, "www.example.com").to_return(lambda { |request|
+              {:body => 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(:get, "www.example.com").to_return(lambda { |request|
+              {:headers => request.headers}
+            })
+            http_request(:get, "http://www.example.com/", :headers => {'A' => 'B'}).headers['A'].should == 'B'
+          end
+
+          it "should create dynamic responses from blocks" do
+            stub_http_request(:post, "www.example.com").to_return do |request|
+              {:body => request.body}
+            end
+            http_request(:post, "http://www.example.com/", :body => "echo").body.should == "echo"
+          end
+
+          it "should create dynamic responses from objects responding to call" do
+            stub_http_request(:post, "www.example.com").to_return(Responder.new)
+            http_request(:post, "http://www.example.com/", :body => "echo").body.should == "echo"
+          end
+
+        end
+
+
         describe "replying raw responses from file" do
 
           before(:each) do
@@ -356,10 +453,14 @@ describe "WebMock", :shared => true do
           it "should return recorded body" do
             @response.body.size.should == 438
           end
-          
+
           it "should return recorded status" do
             @response.status.should == "202"
-          end          
+          end
+          
+          it "should return recorded status message" do
+            @response.message.should == "OK"
+          end
 
           it "should ensure file is closed" do
             @file.should be_closed
@@ -391,6 +492,10 @@ describe "WebMock", :shared => true do
           it "should return recorded status" do
             @response.status.should == "202"
           end
+          
+          it "should return recorded status message" do
+            @response.message.should == "OK"
+          end
         end
 
         describe "sequences of responses" do
@@ -437,7 +542,7 @@ describe "WebMock", :shared => true do
         end
 
         describe "repeating declared responses more than once" do
-          
+
           it "should repeat one response declared number of times" do
             stub_http_request(:get, "www.example.com").
               to_return({:body => "1"}).times(2).
@@ -446,8 +551,8 @@ describe "WebMock", :shared => true do
               http_request(:get, "http://www.example.com/").body.should == "1"
               http_request(:get, "http://www.example.com/").body.should == "2"
           end
-        
-        
+
+
           it "should repeat sequence of response declared number of times" do
              stub_http_request(:get, "www.example.com").
                 to_return({:body => "1"}, {:body => "2"}).times(2).
@@ -456,10 +561,10 @@ describe "WebMock", :shared => true do
                 http_request(:get, "http://www.example.com/").body.should == "2"
                 http_request(:get, "http://www.example.com/").body.should == "1"
                 http_request(:get, "http://www.example.com/").body.should == "2"
-                http_request(:get, "http://www.example.com/").body.should == "3"                
+                http_request(:get, "http://www.example.com/").body.should == "3"
           end
-        
-        
+
+
           it "should repeat infinitely last response even if number of declared times is lower" do
             stub_http_request(:get, "www.example.com").
               to_return({:body => "1"}).times(2)
@@ -467,17 +572,17 @@ describe "WebMock", :shared => true do
               http_request(:get, "http://www.example.com/").body.should == "1"
               http_request(:get, "http://www.example.com/").body.should == "1"
           end
-          
+
           it "should give error if times is declared without specifying response" do
             lambda {
               stub_http_request(:get, "www.example.com").times(3)
             }.should raise_error("Invalid WebMock stub declaration. times(N) can be declared only after response declaration.")
           end
-        
+
         end
-        
+
         describe "raising declared exceptions more than once" do
-        
+
           it "should repeat raising exception declared number of times" do
             stub_http_request(:get, "www.example.com").
               to_raise(MyException).times(2).
@@ -490,7 +595,7 @@ describe "WebMock", :shared => true do
               }.should raise_error(MyException, "Exception from WebMock")
               http_request(:get, "http://www.example.com/").body.should == "2"
           end
-          
+
            it "should repeat raising sequence of exceptions declared number of times" do
             stub_http_request(:get, "www.example.com").
               to_raise(MyException, ArgumentError).times(2).
@@ -574,7 +679,7 @@ describe "WebMock", :shared => true do
 
               it "should fail if request was executed with different method" do
                 lambda {
-                  http_request(:post, "http://www.example.com/")
+                  http_request(:post, "http://www.example.com/", :body => "abc")
                   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
@@ -667,8 +772,8 @@ describe "WebMock", :shared => true do
 
               it "should succeed if request was executed with the same body" do
                 lambda {
-                  http_request(:get, "http://www.example.com/", :body => "abc")
-                  request(:get, "www.example.com").with(:body => "abc").should have_been_made
+                  http_request(:post, "http://www.example.com/", :body => "abc")
+                  request(:post, "www.example.com").with(:body => "abc").should have_been_made
                 }.should_not raise_error
               end
 
@@ -682,8 +787,8 @@ describe "WebMock", :shared => true do
 
               it "should succeed if request was executed with the same body" do
                 lambda {
-                  http_request(:get, "http://www.example.com/", :body => "abc")
-                  request(:get, "www.example.com").with(:body => /^abc$/).should have_been_made
+                  http_request(:post, "http://www.example.com/", :body => "abc")
+                  request(:post, "www.example.com").with(:body => /^abc$/).should have_been_made
                 }.should_not raise_error
               end
 
@@ -754,7 +859,7 @@ describe "WebMock", :shared => true do
                   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
-              
+
              it "should suceed if request was executed and block evaluated to true" do
                 lambda {
                   http_request(:post, "http://www.example.com/", :body => "wadus")
@@ -764,9 +869,9 @@ describe "WebMock", :shared => true do
 
               it "should fail if request was executed and block evaluated to false" do
                 lambda {
-                  http_request(:post, "http://www.example.com/")
+                  http_request(:post, "http://www.example.com/", :body => "abc")
                   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")                                                
+                }.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
@@ -809,11 +914,11 @@ describe "WebMock", :shared => true do
                     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
-                
+
                 it "should be order insensitive" do
-                  stub_request(:post, "http://www.example.com")  
-                  http_request(:post, "http://www.example.com/", :body => "def")               
-                  http_request(:post, "http://www.example.com/", :body => "abc")   
+                  stub_request(:post, "http://www.example.com")
+                  http_request(:post, "http://www.example.com/", :body => "def")
+                  http_request(:post, "http://www.example.com/", :body => "abc")
                   WebMock.should have_requested(:post, "www.example.com").with(:body => "abc")
                   WebMock.should have_requested(:post, "www.example.com").with(:body => "def")
                 end
@@ -831,8 +936,8 @@ describe "WebMock", :shared => true do
 
                 it "should verify expected requests occured" do
                   lambda {
-                    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
+                    http_request(:post, "http://www.example.com/", :body => "abc", :headers => {'A' => 'a'})
+                    WebMock.should have_requested(:post, "http://www.example.com").with(:body => "abc", :headers => {'A' => 'a'}).once
                   }.should_not raise_error
                 end
 
@@ -842,7 +947,7 @@ describe "WebMock", :shared => true do
                     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
-                
+
                 it "should succeed if request was executed and block evaluated to true" do
                   lambda {
                     http_request(:post, "http://www.example.com/", :body => "wadus")
@@ -852,9 +957,9 @@ describe "WebMock", :shared => true do
 
                 it "should fail if request was executed and block evaluated to false" do
                   lambda {
-                    http_request(:post, "http://www.example.com/")
+                    http_request(:post, "http://www.example.com/", :body => "abc")
                     WebMock.should have_requested(:post, "www.example.com").with { |req| req.body == "wadus" }
-                  }.should fail_with("The request POST http://www.example.com/ with given block was expected to execute 1 time but it executed 0 times")                                                
+                  }.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 executed and block matched request" do
@@ -879,8 +984,8 @@ describe "WebMock", :shared => true do
 
                 it "should verify expected requests occured" do
                   lambda {
-                    http_request(:get, "http://www.example.com/", :body => "abc", :headers => {'A' => 'a'})
-                    assert_requested(:get, "http://www.example.com", :body => "abc", :headers => {'A' => 'a'})
+                    http_request(:post, "http://www.example.com/", :body => "abc", :headers => {'A' => 'a'})
+                    assert_requested(:post, "http://www.example.com", :body => "abc", :headers => {'A' => 'a'})
                   }.should_not raise_error
                 end
 
@@ -890,14 +995,14 @@ describe "WebMock", :shared => true do
                     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
-                
+
                  it "should verify if non expected request executed and block evaluated to true" do
                    lambda {
                      http_request(:post, "http://www.example.com/", :body => "wadus")
                      assert_not_requested(:post, "www.example.com") { |req| req.body == "wadus" }
                    }.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
-                
+
                 it "should verify if request was executed and block evaluated to true" do
                    lambda {
                      http_request(:post, "http://www.example.com/", :body => "wadus")
@@ -907,7 +1012,7 @@ describe "WebMock", :shared => true do
 
                  it "should verify if request was executed and block evaluated to false" do
                    lambda {
-                     http_request(:post, "http://www.example.com/")
+                     http_request(:post, "http://www.example.com/", :body => "abc")
                      assert_requested(:post, "www.example.com") { |req| req.body == "wadus" }
                    }.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