http_stub 0.7.0 → 0.7.1

data/spec/lib/http_stub/configurer_integration_spec.rb

@@ -224,28 +224,68 @@ describe HttpStub::Configurer, "when the server is running" do
 
       describe "that contains headers" do
 
-        before(:each) do
-          configurer.stub_response!("/stub_with_headers", method: :get, headers: { key: "value" },
-                                    response: { status: 202, body: "Another stub body" })
-        end
+        describe "whose values are strings" do
+
+          before(:each) do
+            configurer.stub_response!("/stub_with_headers", method: :get, headers: { key: "value" },
+                                      response: { status: 202, body: "Another stub body" })
+          end
+
+          describe "and that request is made" do
 
-        describe "and that request is made" do
+            let(:response) { HTTParty.get("http://localhost:8001/stub_with_headers", headers: { "key" => "value" }) }
 
-          let(:response) { HTTParty.get("http://localhost:8001/stub_with_headers", headers: { "key" => "value" }) }
+            it "should replay the stubbed response" do
+              response.code.should eql(202)
+              response.body.should eql("Another stub body")
+            end
+
+          end
+
+          describe "and a request with different headers is made" do
+
+            let(:response) do
+              HTTParty.get("http://localhost:8001/stub_with_headers", headers: { "key" => "other_value" })
+            end
+
+            it "should respond with a 404 status code" do
+              response.code.should eql(404)
+            end
 
-          it "should replay the stubbed response" do
-            response.code.should eql(202)
-            response.body.should eql("Another stub body")
           end
 
         end
 
-        describe "and a request with different headers is made" do
+        describe "whose values are regular expressions" do
 
-          let(:response) { HTTParty.get("http://localhost:8001/stub_with_headers", headers: { "key" => "other_value" }) }
+          before(:each) do
+            configurer.stub_response!("/stub_with_headers", method: :get, headers: { key: /^match.*/ },
+                                      response: { status: 202, body: "Another stub body" })
+          end
+
+          describe "and a request that matches is made" do
+
+            let(:response) do
+              HTTParty.get("http://localhost:8001/stub_with_headers", headers: { "key" => "matching_value" })
+            end
+
+            it "should replay the stubbed response" do
+              response.code.should eql(202)
+              response.body.should eql("Another stub body")
+            end
+
+          end
+
+          describe "and a request that does not match is made" do
+
+            let(:response) do
+              HTTParty.get("http://localhost:8001/stub_with_headers", headers: { "key" => "does_not_match_value" })
+            end
+
+            it "should respond with a 404 status code" do
+              response.code.should eql(404)
+            end
 
-          it "should respond with a 404 status code" do
-            response.code.should eql(404)
           end
 
         end
@@ -254,28 +294,64 @@ describe HttpStub::Configurer, "when the server is running" do
 
       describe "that contains parameters" do
 
-        before(:each) do
-          configurer.stub_response!("/stub_with_parameters", method: :get, parameters: { key: "value" },
-                                    response: { status: 202, body: "Another stub body" })
-        end
+        describe "whose values are strings" do
+
+          before(:each) do
+            configurer.stub_response!("/stub_with_parameters", method: :get, parameters: { key: "value" },
+                                      response: { status: 202, body: "Another stub body" })
+          end
+
+          describe "and that request is made" do
 
-        describe "and that request is made" do
+            let(:response) { Net::HTTP.get_response("localhost", "/stub_with_parameters?key=value", 8001) }
 
-          let(:response) { Net::HTTP.get_response("localhost", "/stub_with_parameters?key=value", 8001) }
+            it "should replay the stubbed response" do
+              response.code.should eql("202")
+              response.body.should eql("Another stub body")
+            end
+
+          end
+
+          describe "and a request with different parameters is made" do
+
+            let(:response) { Net::HTTP.get_response("localhost", "/stub_with_parameters?key=another_value", 8001) }
+
+            it "should respond with a 404 status code" do
+              response.code.should eql("404")
+            end
 
-          it "should replay the stubbed response" do
-            response.code.should eql("202")
-            response.body.should eql("Another stub body")
           end
 
         end
 
-        describe "and a request with different parameters is made" do
+        describe "whose values are regular expressions" do
 
-          let(:response) { Net::HTTP.get_response("localhost", "/stub_with_parameters?key=another_value", 8001) }
+          before(:each) do
+            configurer.stub_response!("/stub_with_parameters", method: :get, parameters: { key: /^match.*/ },
+                                      response: { status: 202, body: "Another stub body" })
+          end
+
+          describe "and a request that matches is made" do
+
+            let(:response) { Net::HTTP.get_response("localhost", "/stub_with_parameters?key=matching_value", 8001) }
+
+            it "should replay the stubbed response" do
+              response.code.should eql("202")
+              response.body.should eql("Another stub body")
+            end
+
+          end
+
+          describe "and a request that does not match is made" do
+
+            let(:response) do
+              Net::HTTP.get_response("localhost", "/stub_with_parameters?key=does_not_match_value", 8001)
+            end
+
+            it "should respond with a 404 status code" do
+              response.code.should eql("404")
+            end
 
-          it "should respond with a 404 status code" do
-            response.code.should eql("404")
           end
 
         end

data/spec/lib/http_stub/models/hash_with_regexpable_values_spec.rb

@@ -0,0 +1,149 @@
+describe HttpStub::Models::HashWithRegexpableValues do
+
+  let(:stubbed_hash) do
+    (1..3).reduce({}) do |result, i|
+      result["key#{i}"] = "value#{i}"
+      result
+    end
+  end
+
+  let(:regexpable_values) do
+    stubbed_hash.values.map { |value| double(HttpStub::Models::RegexpableValue, to_s: value).as_null_object }
+  end
+
+  let(:regexpable_hash) { HttpStub::Models::HashWithRegexpableValues.new(stubbed_hash) }
+
+  before(:each) do
+    regexpable_values.each { |value| HttpStub::Models::RegexpableValue.stub!(:new).with(value.to_s).and_return(value) }
+  end
+
+  it "should be hash" do
+    regexpable_hash.should be_a(Hash)
+  end
+
+  describe "constructor" do
+
+    it "should create a regexpable representation of each value in the hash" do
+      regexpable_values.each do |value|
+        HttpStub::Models::RegexpableValue.should_receive(:new).with(value.to_s).and_return(value)
+      end
+
+      regexpable_hash.values.should eql(regexpable_values)
+    end
+    
+  end
+  
+  describe "#match?" do
+    
+    describe "when the stubbed hash contains multiple entries" do
+      
+      describe "and the provided hash has the same number of entries" do
+        
+        describe "and the keys match" do
+
+          let(:provided_hash) do
+            stubbed_hash.reduce({}) do |result, entry|
+              result[entry[0]] = "another #{entry[1]}"
+              result
+            end
+          end
+
+          describe "and the values match" do
+
+            before(:each) do
+              regexpable_values.each { |value| value.stub!(:match?).with("another #{value}").and_return(true) }
+            end
+            
+            it "should return true" do
+              regexpable_hash.match?(provided_hash).should be_true
+            end
+            
+          end
+          
+          describe "and a value does not match" do
+
+            before(:each) do
+              regexpable_values.each { |value| value.stub!(:match?).with("another #{value}").and_return(true) }
+
+              non_matching_value = regexpable_values[1]
+              non_matching_value.stub!(:match?).with("another #{non_matching_value}").and_return(false)
+            end
+
+            it "should return false" do
+              regexpable_hash.match?(provided_hash).should be_false
+            end
+
+          end
+          
+        end
+        
+        describe "and a key does not match" do
+
+          let(:provided_hash) { { "key1" => "value1", "differentkey2" => "another value2", "key3" => "value3" } }
+
+          before(:each) do
+            regexpable_values.each { |value| value.stub!(:match?).with(value.to_s).and_return(true) }
+          end
+
+          it "should return false" do
+            regexpable_hash.match?(provided_hash).should be_false
+          end
+
+        end
+        
+      end
+      
+      describe "and the provided hash contains more entries" do
+
+        let(:provided_hash) do
+          (1..5).reduce({}) do |result, i|
+            result["key#{i}"] = "another value#{i}"
+            result
+          end
+        end
+
+        describe "and it has matching keys and values" do
+
+          before(:each) do
+            regexpable_values.each { |value| value.stub!(:match?).with("another #{value}").and_return(true) }
+          end
+
+          it "should return true" do
+            regexpable_hash.match?(provided_hash).should be_true
+          end
+          
+        end
+        
+      end
+      
+    end
+    
+    describe "when the stubbed hash is empty" do
+
+      let(:stubbed_hash) { {} }
+
+      describe "and the provided hash is not empty" do
+
+        let(:provided_hash) { { "key" => "value" } }
+
+        it "should return true" do
+          regexpable_hash.match?(provided_hash).should be_true
+        end
+
+      end
+      
+      describe "and the provided hash is empty" do
+
+        let(:provided_hash) { {} }
+
+        it "should return true" do
+          regexpable_hash.match?(provided_hash).should be_true
+        end
+
+      end
+      
+    end
+    
+  end
+  
+end

data/spec/lib/http_stub/models/regexpable_value_spec.rb

@@ -0,0 +1,69 @@
+describe HttpStub::Models::RegexpableValue do
+
+  let(:value) { "a simple string" }
+
+  let(:regexpable_value) { HttpStub::Models::RegexpableValue.new(value) }
+
+  describe "#match?" do
+
+    describe "when the value is a string prefixed with 'regexp:'" do
+
+      let(:value) { "regexp:^a[0-9]*z$" }
+
+      describe "and the provided value matches the regular expression" do
+
+        let(:other_value) { "a789z" }
+
+        it "should return true" do
+          regexpable_value.match?(other_value).should be_true
+        end
+
+      end
+
+      describe "and the provided value does not match the regular expression" do
+
+        let(:other_value) { "a789" }
+
+        it "should return false" do
+          regexpable_value.match?(other_value).should be_false
+        end
+
+      end
+
+    end
+
+    describe "when the value is a simple string" do
+
+      describe "and the provided value is equal to the string" do
+
+        let(:other_value) { value }
+
+        it "should return true" do
+          regexpable_value.match?(other_value).should be_true
+        end
+
+      end
+
+      describe "and the provided value is not equal to the string" do
+
+        let(:other_value) { "a not equal string" }
+
+        it "should return false" do
+          regexpable_value.match?(other_value).should be_false
+        end
+
+      end
+
+    end
+
+  end
+
+  describe "#to_s" do
+
+    it "should return the value provided" do
+      regexpable_value.to_s.should eql(value)
+    end
+
+  end
+
+end

data/spec/lib/http_stub/models/stub_headers_spec.rb

@@ -1,114 +1,62 @@
 describe HttpStub::Models::StubHeaders do
 
   let(:request) { double("HttpRequest") }
+  let(:stubbed_headers) { { "stub_key" => "value" } }
 
   let(:stub_headers) { HttpStub::Models::StubHeaders.new(stubbed_headers) }
 
-  describe "#match?" do
-
-    before(:each) { HttpStub::Models::RequestHeaderParser.stub!(:parse).with(request).and_return(request_headers) }
-
-    describe "when multiple headers are mandatory" do
-
-      let(:stubbed_headers) { { "KEY1" => "value1", "KEY2" => "value2", "KEY3" => "value3" } }
-
-      describe "and the mandatory headers are provided" do
-
-        let(:request_headers) { stubbed_headers }
-
-        describe "and the casing of the header names is identical" do
-
-          it "should return true" do
-            stub_headers.match?(request).should be_true
-          end
-
-        end
-
-        describe "and the casing of the header names is different" do
-
-          let(:stubbed_headers) { { "key1" => "value1", "KEY2" => "value2", "key3" => "value3" } }
-
-          it "should return true" do
-            stub_headers.match?(request).should be_true
-          end
-
-        end
-
-        describe "and the mandatory request header names have hyphens in place of underscores" do
-
-          let(:stubbed_headers) { { "KEY_1" => "value1", "KEY-2" => "value2", "KEY_3" => "value3" } }
-          let(:request_headers) { { "KEY-1" => "value1", "KEY_2" => "value2", "KEY-3" => "value3" } }
-
-          it "should return true" do
-            stub_headers.match?(request).should be_true
-          end
-
-        end
-
-      end
-
-      describe "and the request headers have different values" do
-
-        let(:request_headers) { { "KEY1" => "value1", "KEY2" => "doesNotMatch", "KEY3" => "value3" } }
+  describe "when stubbed headers are provided" do
 
-        it "should return false" do
-          stub_headers.match?(request).should be_false
-        end
+    it "should create a regexpable representation of the stubbed headers whose keys are downcased and underscored" do
+      downcased_and_underscored_hash = { "another_stub_key" => "value" }
+      stubbed_headers.should_receive(:downcase_and_underscore_keys).and_return(downcased_and_underscored_hash)
+      HttpStub::Models::HashWithRegexpableValues.should_receive(:new).with(downcased_and_underscored_hash)
 
-      end
-
-      describe "and some mandatory headers are omitted" do
-
-        let(:request_headers) { { "KEY1" => "value1", "KEY3" => "value3" } }
-
-        it "should return false" do
-          stub_headers.match?(request).should be_false
-        end
-
-      end
+      stub_headers
+    end
 
-      describe "and all mandatory headers are omitted" do
+  end
 
-        let(:request_headers) { {} }
+  describe "when the stubbed headers are nil" do
 
-        it "should return false" do
-          stub_headers.match?(request).should be_false
-        end
+    let(:stubbed_headers) { nil }
 
-      end
+    it "should create a regexpable representation of an empty hash" do
+      HttpStub::Models::HashWithRegexpableValues.should_receive(:new).with({})
 
+      stub_headers
     end
 
-    describe "when no headers are mandatory" do
-
-      let(:stubbed_headers) { {} }
-
-      describe "and headers are provided" do
-
-        let(:request_headers) { { "KEY" => "value" } }
+  end
 
-        it "should return true" do
-          stub_headers.match?(request).should be_true
-        end
+  describe "#match?" do
 
-      end
+    let(:request_headers) { { "request_key" => "value" } }
+    let(:regexpable_stubbed_headers) { double(HttpStub::Models::HashWithRegexpableValues).as_null_object }
 
+    before(:each) do
+      HttpStub::Models::HashWithRegexpableValues.stub!(:new).and_return(regexpable_stubbed_headers)
+      HttpStub::Models::RequestHeaderParser.stub!(:parse).with(request).and_return(request_headers)
     end
 
-    describe "when the mandatory headers are nil" do
+    it "should parse the requests headers into a hash" do
+      HttpStub::Models::RequestHeaderParser.should_receive(:parse).with(request).and_return(request_headers)
 
-      let(:stubbed_headers) { nil }
-
-      describe "and headers are provided" do
+      stub_headers.match?(request)
+    end
 
-        let(:request_headers) { { "KEY" => "value" } }
+    it "should downcase and underscore the keys in the request header hash" do
+      request_headers.should_receive(:downcase_and_underscore_keys)
 
-        it "should return true" do
-          stub_headers.match?(request).should be_true
-        end
+      stub_headers.match?(request)
+    end
 
-      end
+    it "should delegate to the regexpable representation of the stubbed headers to determine a match" do
+      downcased_and_underscored_hash = { "another_request_key" => "value" }
+      request_headers.stub!(:downcase_and_underscore_keys).and_return(downcased_and_underscored_hash)
+      regexpable_stubbed_headers.should_receive(:match?).with(downcased_and_underscored_hash).and_return(true)
 
+      stub_headers.match?(request).should be_true
     end
 
   end