webmock 0.9.1 → 1.0.0

data/spec/request_registry_spec.rb

@@ -4,7 +4,7 @@ describe RequestRegistry do
 
   before(:each) do
     RequestRegistry.instance.reset_webmock
-    @request_profile = RequestProfile.new(:get, "www.example.com")
+    @request_pattern = RequestPattern.new(:get, "www.example.com")
     @request_signature = RequestSignature.new(:get, "www.example.com")
     @request_stub = RequestStub.new(:get, "www.example.com")
   end
@@ -22,9 +22,9 @@ describe RequestRegistry do
     end
 
     it "should clean list of executed requests" do
-      RequestRegistry.instance.times_executed(@request_profile).should == 1
+      RequestRegistry.instance.times_executed(@request_pattern).should == 1
       RequestRegistry.instance.reset_webmock
-      RequestRegistry.instance.times_executed(@request_profile).should == 0
+      RequestRegistry.instance.times_executed(@request_pattern).should == 0
     end
 
   end
@@ -49,10 +49,25 @@ describe RequestRegistry do
 
   describe "response for request" do
 
-    it "should registered response for request profile" do
-      @request_stub.instance_variable_set(:@responses, [@response = Response.new])
+    it "should report registered evaluated response for request pattern" do
+      @request_stub.to_return(:body => "abc")
       RequestRegistry.instance.register_request_stub(@request_stub)
-      RequestRegistry.instance.response_for_request(@request_signature).should == @response
+      RequestRegistry.instance.response_for_request(@request_signature).should == Response.new(:body => "abc")
+    end
+
+    it "should report evaluated response" do
+      @request_stub.to_return {|request| {:body => request.method.to_s} }
+      RequestRegistry.instance.register_request_stub(@request_stub)
+      response1 = RequestRegistry.instance.response_for_request(@request_signature)
+      response1.should == Response.new(:body => "get")
+    end
+
+    it "should report clone of theresponse" do
+      @request_stub.to_return {|request| {:body => request.method.to_s} }
+      RequestRegistry.instance.register_request_stub(@request_stub)
+      response1 = RequestRegistry.instance.response_for_request(@request_signature)
+      response2 = RequestRegistry.instance.response_for_request(@request_signature)
+      response1.should_not be(response2)
     end
 
     it "should report nothing if no response for request is registered" do
@@ -61,24 +76,24 @@ describe RequestRegistry do
 
     it "should always return last registered matching response" do
       @request_stub1 = RequestStub.new(:get, "www.example.com")
-      @request_stub1.instance_variable_set(:@responses, [@response1 = Response.new])
+      @request_stub1.to_return(:body => "abc")
       @request_stub2 = RequestStub.new(:get, "www.example.com")
-      @request_stub2.instance_variable_set(:@responses, [@response2 = Response.new])
+      @request_stub2.to_return(:body => "def")
       @request_stub3 = RequestStub.new(:get, "www.example.org")
-      @request_stub3.instance_variable_set(:@responses, [@response3 = Response.new])
+      @request_stub3.to_return(:body => "ghj")
       RequestRegistry.instance.register_request_stub(@request_stub1)
       RequestRegistry.instance.register_request_stub(@request_stub2)
       RequestRegistry.instance.register_request_stub(@request_stub3)
-      RequestRegistry.instance.response_for_request(@request_signature).should == @response2
+      RequestRegistry.instance.response_for_request(@request_signature).should == Response.new(:body => "def")
     end
 
   end
 
   describe "times executed" do
 
-    def times_executed(request_profile)
-      self.requested.hash.select { |executed_request_profile, times_executed|
-        executed_request_profile.match(request_profile)
+    def times_executed(request_pattern)
+      self.requested.hash.select { |executed_request_pattern, times_executed|
+        executed_request_pattern.match(request_pattern)
       }.inject(0) {|sum, (_, times_executed)| sum =+ times_executed }
     end
 
@@ -91,16 +106,16 @@ describe RequestRegistry do
       RequestRegistry.instance.requested_signatures.put(RequestSignature.new(:get, "www.example.org"))
     end
 
-    it "should report 0 if no request matching profile was requested" do
-      RequestRegistry.instance.times_executed(RequestProfile.new(:get, "www.example.net")).should == 0
+    it "should report 0 if no request matching pattern was requested" do
+      RequestRegistry.instance.times_executed(RequestPattern.new(:get, "www.example.net")).should == 0
     end
 
-    it "should report number of times matching profile was requested" do
-      RequestRegistry.instance.times_executed(RequestProfile.new(:get, "www.example.com")).should == 2
+    it "should report number of times matching pattern was requested" do
+      RequestRegistry.instance.times_executed(RequestPattern.new(:get, "www.example.com")).should == 2
     end
 
-    it "should report number of times all matching profile were requested" do
-      RequestRegistry.instance.times_executed(RequestProfile.new(:get, /.*example.*/)).should == 3
+    it "should report number of times all matching pattern were requested" do
+      RequestRegistry.instance.times_executed(RequestPattern.new(:get, /.*example.*/)).should == 3
     end
 
 

data/spec/request_signature_spec.rb

@@ -1,205 +1,37 @@
 require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
 
 describe RequestSignature do
+  
+  describe "initialization" do
 
-  describe "when matching" do
-
-    it "should match if uri matches and method matches" do
-      RequestSignature.new(:get, "www.example.com").
-        should match(RequestProfile.new(:get, "www.example.com"))
-    end
-
-    it "should match if uri matches and method is any" do
-      RequestSignature.new(:get, "www.example.com").
-        should match(RequestProfile.new(:any, "www.example.com"))
-    end
-
-    it "should not match if other request profile has different method" do
-      RequestSignature.new(:get, "www.example.com").
-        should_not match(RequestProfile.new(:post, "www.example.com"))
-    end
-
-    it "should match if uri matches other uri" do
-      RequestSignature.new(:get, "www.example.com").
-        should match(RequestProfile.new(:get, "www.example.com"))
-    end
-    
-    it "should match if uri matches other escaped using uri" do
-      RequestSignature.new(:get, "www.example.com/my path").
-        should match(RequestProfile.new(:get, "www.example.com/my%20path"))
-    end
-    
-    it "should match if unescaped uri matches other uri" do
-      RequestSignature.new(:get, "www.example.com/my%20path").
-        should match(RequestProfile.new(:get, "www.example.com/my path"))
-    end
-    
-    it "should match if unescaped uri matches other regexp uri" do
-      RequestSignature.new(:get, "www.example.com/my%20path").
-        should match(RequestProfile.new(:get, /.*my path.*/))
-    end
-
-    it "should match if uri matches other regex uri" do
-      RequestSignature.new(:get, "www.example.com").
-        should match(RequestProfile.new(:get, /.*example.*/))
-    end
-
-    it "should match for uris with same parameters" do
-      RequestSignature.new(:get, "www.example.com?a=1&b=2").
-        should match(RequestProfile.new(:get, "www.example.com?a=1&b=2"))
-    end
-
-    it "should not match for uris with different parameters" do
-      RequestSignature.new(:get, "www.example.com?a=2&b=1").
-        should_not match(RequestProfile.new(:get, "www.example.com?a=1&b=2"))
-    end
-
-    it "should match for parameters in different order" do
-      RequestSignature.new(:get, "www.example.com?a=1&b=2").
-        should match(RequestProfile.new(:get, "www.example.com?b=2&a=1"))
-    end
-    
-    describe "when parameters are escaped" do
-    
-      it "should match if uri with non escaped parameters is the same as other uri with escaped parameters" do
-        RequestSignature.new(:get, "www.example.com/?a=a b").
-          should match(RequestProfile.new(:get, "www.example.com/?a=a%20b"))
-      end
-    
-      it "should match if uri with escaped parameters is the same as other uri with non escaped parameters" do
-        RequestSignature.new(:get, "www.example.com/?a=a%20b").
-          should match(RequestProfile.new(:get, "www.example.com/?a=a b"))
-      end
-    
-      it "should match if other regexp is for non escaped parameters but uri has escaped parameters" do
-        RequestSignature.new(:get, "www.example.com/?a=a%20b").
-          should match(RequestProfile.new(:get, /.*a=a b.*/))
-      end
-    
-      it "should match if other regexp is for escaped parameters but uri has non escaped parameters"  do
-        RequestSignature.new(:get, "www.example.com/?a=a b").
-          should match(RequestProfile.new(:get, /.*a=a%20b.*/))
-      end
-    
-    end
-    
-    
-
-    it "should match for same bodies" do
-      RequestSignature.new(:get, "www.example.com", :body => "abc").
-        should match(RequestProfile.new(:get, "www.example.com", :body => "abc"))
-    end
-    
-    it "should match for body matching regexp" do
-      RequestSignature.new(:get, "www.example.com", :body => "abc").
-        should match(RequestProfile.new(:get, "www.example.com", :body => /^abc$/))
-    end
-
-    it "should not match for different bodies" do
-      RequestSignature.new(:get, "www.example.com", :body => "abc").
-        should_not match(RequestProfile.new(:get, "www.example.com", :body => "def"))
-    end
-    
-    it "should not match for body not matching regexp" do
-      RequestSignature.new(:get, "www.example.com", :body => "xabc").
-        should_not match(RequestProfile.new(:get, "www.example.com", :body => /^abc$/))
-    end
-
-    it "should match if other has not specified body" do
-      RequestSignature.new(:get, "www.example.com", :body => "abc").
-        should match(RequestProfile.new(:get, "www.example.com"))
-    end
-    
-    it "should not match if other has nil body" do
-      RequestSignature.new(:get, "www.example.com", :body => "abc").
-        should_not match(RequestProfile.new(:get, "www.example.com", :body => nil))
-    end
-
-    it "should not match if other has empty body" do
-      RequestSignature.new(:get, "www.example.com", :body => "abc").
-        should_not match(RequestProfile.new(:get, "www.example.com", :body => ""))
-    end
-    
-    it "should not match if other has body" do
-      RequestSignature.new(:get, "www.example.com").
-        should_not match(RequestProfile.new(:get, "www.example.com", :body => "abc"))
-    end
-
-    it "should match for same headers" do
-      RequestSignature.new(:get, "www.example.com", :headers => {'Content-Type' => 'image/jpeg'}).
-        should match(RequestProfile.new(:get, "www.example.com", :headers => {'Content-Type' => 'image/jpeg'}))
-    end
-    
-    it "should match for header values matching regexp" do
-      RequestSignature.new(:get, "www.example.com", :headers => {'Content-Type' => 'image/jpeg'}).
-        should match(RequestProfile.new(:get, "www.example.com", :headers => {'Content-Type' => %r{^image/jpeg$}}))
-    end
-
-    it "should not match for different values of the same header" do
-      RequestSignature.new(:get, "www.example.com", :headers => {'Content-Type' => 'image/jpeg'}).
-        should_not match(RequestProfile.new(:get, "www.example.com", :headers => {'Content-Type' => 'image/png'}))
-    end
-    
-    it "should not match for header values not matching regexp" do
-      RequestSignature.new(:get, "www.example.com", :headers => {'Content-Type' => 'image/jpegx'}).
-        should_not match(RequestProfile.new(:get, "www.example.com", :headers => {'Content-Type' => %r{^image\/jpeg$}}))
-    end
-
-    it "should match if request has more headers than other" do
-      RequestSignature.new(:get, "www.example.com", :headers => {'Content-Type' => 'image/jpeg', 'Content-Length' => '8888'}).
-        should match(RequestProfile.new(:get, "www.example.com", :headers => {'Content-Type' => 'image/jpeg'}))
-    end
-
-    it "should not match if request has less headers that the other and all match" do
-      RequestSignature.new(:get, "www.example.com", :headers => {'Content-Type' => 'image/jpeg'}).
-        should_not match(RequestProfile.new(:get, "www.example.com", :headers => {'Content-Type' => 'image/jpeg', 'Content-Length' => '8888'}))
-    end
-
-    it "should match even is header keys or values are in different format" do
-      RequestSignature.new(:get, "www.example.com", :headers => {:ContentLength => 8888, 'content_type' => 'image/png'}).
-        should match(RequestProfile.new(:get, "www.example.com", :headers => {'ContentLength' => '8888', 'Content-type' => 'image/png'}))
-    end
-    
-    it "should match is other has not specified" do
-      RequestSignature.new(:get, "www.example.com", :headers => {'A' => 'a'}).
-        should match(RequestProfile.new(:get, "www.example.com"))
-    end
-
-    it "should not match is other has nil headers" do
-      RequestSignature.new(:get, "www.example.com", :headers => {'A' => 'a'}).
-        should match(RequestProfile.new(:get, "www.example.com", :headers => nil))
-    end
-
-    it "should not match if other has empty headers" do
-      RequestSignature.new(:get, "www.example.com", :headers => {'A' => 'a'}).
-        should_not match(RequestProfile.new(:get, "www.example.com", :headers => {}))
+    it "should have assigned normalized uri" do
+      WebMock::Util::URI.should_receive(:normalize_uri).and_return("www.example.kom")
+      signature = RequestSignature.new(:get, "www.example.com")
+      signature.uri.should == "www.example.kom"
     end
 
-    it "should not match if profile has no headers but other has headers" do
-      RequestSignature.new(:get, "www.example.com").
-        should_not match(RequestProfile.new(:get, "www.example.com", :headers => {'A'=>'a'}))
+    it "should have assigned uri without normalization if uri is URI" do
+      WebMock::Util::URI.should_not_receive(:normalize_uri)
+      uri = Addressable::URI.parse("www.example.com")
+      signature = RequestSignature.new(:get, uri)
+      signature.uri.should == uri
     end
 
-    it "should not match if profile has empty headers but other has headers" do
-      RequestSignature.new(:get, "www.example.com", :headers => {}).
-        should_not match(RequestProfile.new(:get, "www.example.com", :headers => {'A'=>'a'}))
+    it "should have assigned normalized headers" do
+      WebMock::Util::Headers.should_receive(:normalize_headers).with('A' => 'a').and_return('B' => 'b')
+      RequestSignature.new(:get, "www.example.com", :headers => {'A' => 'a'}).headers.should == {'B' => 'b'}
     end
 
-    it "should match if block given to profile evaluates on request to true" do
-      RequestSignature.new(:get, "www.example.com").
-        should match(RequestProfile.new(:get, "www.example.com").with { |request| true } )
-    end
-    
-    it "should not match if block given to profile evaluates on request to false" do
-      RequestSignature.new(:get, "www.example.com").
-        should_not match( RequestProfile.new(:get, "www.example.com").with { |request| false } )
-    end
-    
-    it "should pass self to the block when matching" do
-      signature = RequestSignature.new(:get, "www.example.com")
-      signature.should match(RequestProfile.new(:get, "www.example.com").with { |request| request == signature } )
+    it "should have assigned body" do
+      RequestSignature.new(:get, "www.example.com", :body => "abc").body.should == "abc"
     end
 
   end
 
-end
+  it "should report string describing itself" do
+    RequestSignature.new(:get, "www.example.com",
+      :body => "abc", :headers => {'A' => 'a', 'B' => 'b'}).to_s.should ==
+    "GET http://www.example.com/ with body 'abc' with headers {'A'=>'a', 'B'=>'b'}"
+  end
+  
+end

data/spec/request_stub_spec.rb

@@ -6,9 +6,8 @@ describe RequestStub do
     @request_stub = RequestStub.new(:get, "www.example.com")
   end
 
-  it "should have request profile with method and uri" do
-    @request_stub.request_profile.method.should == :get
-    @request_stub.request_profile.uri.host.should == "www.example.com"
+  it "should have request pattern with method and uri" do
+    @request_stub.request_pattern.to_s.should == "GET http://www.example.com/"
   end
 
   it "should have response" do
@@ -17,20 +16,20 @@ describe RequestStub do
 
   describe "with" do
 
-    it "should assign body to request profile" do
+    it "should assign body to request pattern" do
       @request_stub.with(:body => "abc")
-      @request_stub.request_profile.body.should == RequestProfile::Body.new("abc")
+      @request_stub.request_pattern.to_s.should == RequestPattern.new(:get, "www.example.com", :body => "abc").to_s
     end
 
-    it "should assign normalized headers to request profile" do
-      Util::Headers.should_receive(:normalize_headers).with('A' => 'a').and_return('B' => 'b')
+    it "should assign normalized headers to request pattern" do
       @request_stub.with(:headers => {'A' => 'a'})
-      @request_stub.request_profile.headers.should == {'B' => 'b'}
+      @request_stub.request_pattern.to_s.should == 
+        RequestPattern.new(:get, "www.example.com", :headers => {'A' => 'a'}).to_s
     end
 
     it "should assign given block to request profile" do
-      @request_stub.with { |req| "block output" }
-      @request_stub.request_profile.with_block.call(nil).should == "block output"
+      @request_stub.with { |req| req.body == "abc" }
+      @request_stub.request_pattern.matches?(RequestSignature.new(:get, "www.example.com", :body => "abc")).should be_true
     end
 
   end
@@ -40,7 +39,7 @@ describe RequestStub do
     it "should assign response with provided options" do
       @request_stub.to_return(:body => "abc", :status => 500)
       @request_stub.response.body.should == "abc"
-      @request_stub.response.status.should == 500
+      @request_stub.response.status.should == [500, ""]
     end
 
     it "should assign responses with provided options" do
@@ -124,6 +123,28 @@ describe RequestStub do
 
   end
   
+  describe "to_timeout" do
+
+     it "should assign response with timeout" do
+       @request_stub.to_timeout
+       @request_stub.response.should_timeout.should be_true
+     end
+
+     it "should assign sequence of responses with response with timeout" do
+       @request_stub.to_return(:body => "abc").then.to_timeout
+       @request_stub.response.body.should == "abc"
+       @request_stub.response.should_timeout.should be_true
+     end
+
+     it "should allow multiple timeouts to be declared" do
+       @request_stub.to_timeout.then.to_timeout.then.to_return(:body => "abc")
+       @request_stub.response.should_timeout.should be_true
+       @request_stub.response.should_timeout.should be_true
+       @request_stub.response.body.should == "abc"
+     end
+
+   end
+  
   
   describe "times" do
     

data/spec/response_spec.rb

@@ -1,5 +1,26 @@
 require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
 
+describe ResponseFactory do
+
+  describe "response_for" do
+
+    it "should create response with options passed as arguments" do
+      options = {:body => "abc", :headers => {:a => :b}}
+      Response.should_receive(:new).with(options).and_return(@response = mock(Response))
+      ResponseFactory.response_for(options).should == @response
+    end
+
+
+    it "should create dynamic response for argument responding to call" do
+      callable = mock(:call => {:body => "abc"})
+      DynamicResponse.should_receive(:new).with(callable).and_return(@response = mock(Response))
+      ResponseFactory.response_for(callable).should == @response
+    end
+
+  end
+
+end
+
 describe Response do
   before(:each) do
     @response = Response.new(:headers => {'A' => 'a'})
@@ -13,13 +34,18 @@ describe Response do
 
   describe "status" do
 
-    it "should be 200 by default" do
-      @response.status.should == 200
+    it "should have 200 code and empty message by default" do
+      @response.status.should == [200, ""]
     end
 
     it "should return assigned status" do
       @response = Response.new(:status => 500)
-      @response.status.should == 500
+      @response.status.should == [500, ""]
+    end
+
+    it "should return assigned message" do
+      @response = Response.new(:status => [500, "Internal Server Error"])
+      @response.status.should == [500, "Internal Server Error"]
     end
 
   end
@@ -38,6 +64,20 @@ describe Response do
     end
 
   end
+  
+  describe "timeout" do
+
+    it "should know if it should timeout" do
+      @response = Response.new(:should_timeout => true)
+      @response.should_timeout.should be_true
+    end
+
+    it "should not timeout by default" do
+      @response = Response.new
+      @response.should_timeout.should be_false
+    end
+
+  end
 
   describe "body" do
 
@@ -78,7 +118,7 @@ describe Response do
 
 
       it "should read status" do
-        @response.status.should == 202
+        @response.status.should == [202, "OK"]
       end
 
       it "should read headers" do
@@ -107,7 +147,7 @@ describe Response do
       end
 
       it "should read status" do
-        @response.status.should == 202
+        @response.status.should == [202, "OK"]
       end
 
       it "should read headers" do
@@ -131,6 +171,59 @@ describe Response do
 
     end
 
+    describe "with dynamically evaluated options" do
+
+      before(:each) do
+        @request_signature = RequestSignature.new(:post, "www.example.com", :body => "abc", :headers => {'A' => 'a'})
+      end
+
+      it "should have evaluated body" do
+        @response = Response.new(:body => lambda {|request| request.body})
+        @response.evaluate!(@request_signature).body.should == "abc"
+      end
+
+      it "should have evaluated headers" do
+        @response = Response.new(:headers => lambda {|request| request.headers})
+        @response.evaluate!(@request_signature).headers.should == {'A' => 'a'}
+      end
+
+      it "should have evaluated status" do
+        @response = Response.new(:status => lambda {|request| 302})
+        @response.evaluate!(@request_signature).status.should == [302, ""]
+      end
+
+    end
+
+  end
+
+  describe DynamicResponse do
+
+    describe "evaluating response options" do
+
+      it "should have evaluated options" do
+        request_signature = RequestSignature.new(:post, "www.example.com", :body => "abc", :headers => {'A' => 'a'})
+        response = DynamicResponse.new(lambda {|request|
+          {
+            :body => request.body,
+            :headers => request.headers,
+            :status => 302
+          }
+        })
+        response.evaluate!(request_signature)
+        response.body.should == "abc"
+        response.headers.should == {'A' => 'a'}
+        response.status.should == [302, ""]
+      end
+
+      it "should be equal to static response after evaluation" do
+        request_signature = RequestSignature.new(:post, "www.example.com", :body => "abc")
+        response = DynamicResponse.new(lambda {|request| {:body => request.body}})
+        response.evaluate!(request_signature)
+        response.should == Response.new(:body => "abc")
+      end
+
+    end
+
   end
 
 end