http_stub 0.9.6 → 0.9.7

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

@@ -0,0 +1,156 @@
+describe HttpStub::Models::HashWithValueMatchers do
+
+  let(:stubbed_hash) do
+    (1..3).reduce({}) do |result, i|
+      result["key#{i}"] = "value#{i}"
+      result
+    end
+  end
+
+  let(:value_matchers) do
+    stubbed_hash.values.map { |value| double(HttpStub::Models::ValueMatcher, to_s: value).as_null_object }
+  end
+
+  let(:value_matcher_hash) { HttpStub::Models::HashWithValueMatchers.new(stubbed_hash) }
+
+  before(:each) do
+    value_matchers.each { |value| HttpStub::Models::ValueMatcher.stub(:new).with(value.to_s).and_return(value) }
+  end
+
+  it "should be hash" do
+    value_matcher_hash.should be_a(Hash)
+  end
+
+  describe "constructor" do
+
+    it "should create a value matcher representation of each value in the hash" do
+      value_matchers.each do |value|
+        HttpStub::Models::ValueMatcher.should_receive(:new).with(value.to_s).and_return(value)
+      end
+
+      value_matcher_hash.values.should eql(value_matchers)
+    end
+    
+  end
+  
+  describe "#match?" do
+    
+    context "when the stubbed hash contains multiple entries" do
+
+      context "and the provided hash has the same number of entries" do
+
+        context "and the keys match" do
+
+          let(:provided_hash) do
+            stubbed_hash.reduce({}) do |result, entry|
+              result[entry[0]] = "another #{entry[1]}"
+              result
+            end
+          end
+
+          context "and the values match" do
+
+            before(:each) do
+              value_matchers.each { |value| value.stub(:match?).with("another #{value}").and_return(true) }
+            end
+            
+            it "should return true" do
+              value_matcher_hash.match?(provided_hash).should be_true
+            end
+            
+          end
+
+          context "and a value does not match" do
+
+            before(:each) do
+              value_matchers.each { |value| value.stub(:match?).with("another #{value}").and_return(true) }
+
+              non_matching_value = value_matchers[1]
+              non_matching_value.stub(:match?).with("another #{non_matching_value}").and_return(false)
+            end
+
+            it "should return false" do
+              value_matcher_hash.match?(provided_hash).should be_false
+            end
+
+          end
+          
+        end
+
+        context "and a key does not match" do
+
+          let(:provided_hash) { { "key1" => "value1", "differentkey2" => "another value2", "key3" => "value3" } }
+
+          it "should determine if the corresponding value matches nil" do
+            expected_values = [ "value1", nil, "value3" ]
+            value_matchers.zip(expected_values).each do |value_matcher, expected_value|
+              value_matcher.stub(:match?).with(expected_value)
+            end
+
+            value_matcher_hash.match?(provided_hash)
+          end
+
+          it "should return the result of evaluating the value matchers" do
+            value_matchers.each { |value| value.stub(:match?).and_return(true) }
+
+            value_matcher_hash.match?(provided_hash).should be_true
+          end
+
+        end
+
+      end
+
+      context "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
+
+        context "and it has matching keys and values" do
+
+          before(:each) do
+            value_matchers.each { |value| value.stub(:match?).with("another #{value}").and_return(true) }
+          end
+
+          it "should return true" do
+            value_matcher_hash.match?(provided_hash).should be_true
+          end
+          
+        end
+        
+      end
+      
+    end
+
+    context "when the stubbed hash is empty" do
+
+      let(:stubbed_hash) { {} }
+
+      context "and the provided hash is not empty" do
+
+        let(:provided_hash) { { "key" => "value" } }
+
+        it "should return true" do
+          value_matcher_hash.match?(provided_hash).should be_true
+        end
+
+      end
+
+      context "and the provided hash is empty" do
+
+        let(:provided_hash) { {} }
+
+        it "should return true" do
+          value_matcher_hash.match?(provided_hash).should be_true
+        end
+
+      end
+      
+    end
+    
+  end
+  
+end

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

@@ -0,0 +1,58 @@
+describe HttpStub::Models::OmittedValueMatcher  do
+
+  describe ".match?" do
+
+    context "when the stubbed value is 'control:omitted'" do
+
+      let(:stub_value) { "control:omitted" }
+
+      context "and the actual value is nil" do
+
+        let(:actual_value) { nil }
+
+        it "should return true" do
+          perform_match.should be_true
+        end
+
+      end
+
+      context "and the actual value is non-empty string" do
+
+        let(:actual_value) { "some non-empty string" }
+
+        it "should return false" do
+          perform_match.should be_false
+        end
+
+      end
+
+      context "and the actual value is an empty string" do
+
+        let(:actual_value) { "" }
+
+        it "should return false" do
+          perform_match.should be_false
+        end
+
+      end
+
+    end
+
+    context "when the stub value is not 'control:omitted'" do
+
+      let(:stub_value) { "some other stub value" }
+      let(:actual_value) { nil }
+
+      it "should return false" do
+        perform_match.should be_false
+      end
+
+    end
+
+    def perform_match
+      HttpStub::Models::OmittedValueMatcher.match?(stub_value, actual_value)
+    end
+
+  end
+
+end

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

@@ -0,0 +1,48 @@
+describe HttpStub::Models::RegexpValueMatcher do
+
+  describe ".match?" do
+
+    context "when the stub value is a string prefixed with 'regexp:'" do
+
+      let(:stub_value) { "regexp:^a[0-9]*\\$z$" }
+
+      context "and the actual value matches the regular expression" do
+
+        let(:actual_value) { "a789$z" }
+
+        it "should return true" do
+          perform_match.should be_true
+        end
+
+      end
+
+      context "and the actual value does not match the regular expression" do
+
+        let(:actual_value) { "a789" }
+
+        it "should return false" do
+          perform_match.should be_false
+        end
+
+      end
+
+    end
+
+    context "when the provided value is not a string prefixed with 'regexp'" do
+
+      let(:stub_value) { "does not start with regexp:" }
+      let(:actual_value) { "some actual value" }
+
+      it "should return false" do
+        perform_match.should be_false
+      end
+
+    end
+    
+    def perform_match
+      HttpStub::Models::RegexpValueMatcher.match?(stub_value, actual_value)
+    end
+
+  end
+
+end

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

@@ -10,7 +10,7 @@ describe HttpStub::Models::StubHeaders do
     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)
+      HttpStub::Models::HashWithValueMatchers.should_receive(:new).with(downcased_and_underscored_hash)
 
       stub_headers
     end
@@ -22,7 +22,7 @@ describe HttpStub::Models::StubHeaders do
     let(:stubbed_headers) { nil }
 
     it "should create a regexpable representation of an empty hash" do
-      HttpStub::Models::HashWithRegexpableValues.should_receive(:new).with({})
+      HttpStub::Models::HashWithValueMatchers.should_receive(:new).with({})
 
       stub_headers
     end
@@ -32,10 +32,10 @@ describe HttpStub::Models::StubHeaders do
   describe "#match?" do
 
     let(:request_headers) { { "request_key" => "value" } }
-    let(:regexpable_stubbed_headers) { double(HttpStub::Models::HashWithRegexpableValues).as_null_object }
+    let(:regexpable_stubbed_headers) { double(HttpStub::Models::HashWithValueMatchers).as_null_object }
 
     before(:each) do
-      HttpStub::Models::HashWithRegexpableValues.stub(:new).and_return(regexpable_stubbed_headers)
+      HttpStub::Models::HashWithValueMatchers.stub(:new).and_return(regexpable_stubbed_headers)
       HttpStub::Models::RequestHeaderParser.stub(:parse).with(request).and_return(request_headers)
     end
 

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

@@ -4,14 +4,14 @@ describe HttpStub::Models::StubParameters do
   let(:request) { double("HttpRequest", params: request_parameters) }
 
   let(:stubbed_parameters) { { "key1" => "value1", "key2" => "value2", "key3" => "value3" } }
-  let(:regexpable_stubbed_paremeters) { double(HttpStub::Models::HashWithRegexpableValues).as_null_object }
+  let(:regexpable_stubbed_paremeters) { double(HttpStub::Models::HashWithValueMatchers).as_null_object }
 
   let(:stub_parameters) { HttpStub::Models::StubParameters.new(stubbed_parameters) }
 
   describe "when stubbed parameters are provided" do
 
     it "should create a regexpable representation of the stubbed parameters" do
-      HttpStub::Models::HashWithRegexpableValues.should_receive(:new).with(stubbed_parameters)
+      HttpStub::Models::HashWithValueMatchers.should_receive(:new).with(stubbed_parameters)
 
       stub_parameters
     end
@@ -23,7 +23,7 @@ describe HttpStub::Models::StubParameters do
     let(:stubbed_parameters) { nil }
 
     it "should create a regexpable representation of an empty hash" do
-      HttpStub::Models::HashWithRegexpableValues.should_receive(:new).with({})
+      HttpStub::Models::HashWithValueMatchers.should_receive(:new).with({})
 
       stub_parameters
     end
@@ -33,7 +33,7 @@ describe HttpStub::Models::StubParameters do
   describe "#match?" do
 
     it "should delegate to the regexpable representation of the stubbed parameters to determine a match" do
-      HttpStub::Models::HashWithRegexpableValues.stub(:new).and_return(regexpable_stubbed_paremeters)
+      HttpStub::Models::HashWithValueMatchers.stub(:new).and_return(regexpable_stubbed_paremeters)
       regexpable_stubbed_paremeters.should_receive(:match?).with(request_parameters).and_return(true)
 
       stub_parameters.match?(request).should be(true)

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

@@ -2,15 +2,15 @@ describe HttpStub::Models::StubUri do
 
   let(:stubbed_uri) { "/some/uri" }
   let(:request) { double("HttpRequest", path_info: request_uri) }
-  let(:regexpable_value) { double(HttpStub::Models::RegexpableValue).as_null_object }
+  let(:value_matcher) { double(HttpStub::Models::ValueMatcher).as_null_object }
   let(:stub_uri) { HttpStub::Models::StubUri.new(stubbed_uri) }
 
-  before(:each) { HttpStub::Models::RegexpableValue.stub(:new).and_return(regexpable_value) }
+  before(:each) { HttpStub::Models::ValueMatcher.stub(:new).and_return(value_matcher) }
 
   describe "constructor" do
 
-    it "should create a regexpable representation of the provided uri" do
-      HttpStub::Models::RegexpableValue.should_receive(:new).with(stubbed_uri)
+    it "should create a value matcher for the provided uri" do
+      HttpStub::Models::ValueMatcher.should_receive(:new).with(stubbed_uri)
 
       stub_uri
     end
@@ -21,8 +21,8 @@ describe HttpStub::Models::StubUri do
 
     let(:request_uri) { "/some/uri" }
 
-    it "should delegate to the regexpable representation of the provided uri" do
-      regexpable_value.should_receive(:match?).with(request_uri).and_return(true)
+    it "should delegate to the value matcher representation of the provided uri" do
+      value_matcher.should_receive(:match?).with(request_uri).and_return(true)
 
       stub_uri.match?(request).should be_true
     end
@@ -31,10 +31,10 @@ describe HttpStub::Models::StubUri do
 
   describe "#to_s" do
 
-    it "should delegate to the regexpable representation of the provided uri" do
-      regexpable_value.should_receive(:to_s).and_return("some regexpable value string")
+    it "should delegate to the value matcher representation of the provided uri" do
+      value_matcher.should_receive(:to_s).and_return("some value matcher string")
 
-      stub_uri.to_s.should eql("some regexpable value string")
+      stub_uri.to_s.should eql("some value matcher string")
     end
 
   end

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

@@ -0,0 +1,81 @@
+describe HttpStub::Models::ValueMatcher do
+
+  let(:stub_value) { "some stub value" }
+
+  let(:value_matcher) { HttpStub::Models::ValueMatcher.new(stub_value) }
+
+  describe "#match?" do
+
+    let(:actual_value) { "some actual value" }
+
+    it "should determine if actual value should be omitted" do
+      HttpStub::Models::OmittedValueMatcher.should_receive(:match?).with(stub_value, actual_value)
+
+      perform_match
+    end
+
+    it "should determine if the actual value matches a regular expression" do
+      HttpStub::Models::RegexpValueMatcher.should_receive(:match?).with(stub_value, actual_value)
+
+      perform_match
+    end
+
+    it "should determine if the actual value exactly matches the stub value" do
+      HttpStub::Models::ExactValueMatcher.should_receive(:match?).with(stub_value, actual_value)
+
+      perform_match
+    end
+
+    context "when an omitted match occurs" do
+
+      before(:each) { HttpStub::Models::OmittedValueMatcher.should_receive(:match?).and_return(true) }
+
+      it "should return true" do
+        perform_match.should be_true
+      end
+
+    end
+
+    context "when a regular expression match occurs" do
+
+      before(:each) { HttpStub::Models::RegexpValueMatcher.should_receive(:match?).and_return(true) }
+
+      it "should return true" do
+        perform_match.should be_true
+      end
+
+    end
+
+    context "when an exact match occurs" do
+
+      before(:each) { HttpStub::Models::ExactValueMatcher.should_receive(:match?).and_return(true) }
+
+      it "should return true" do
+        perform_match.should be_true
+      end
+
+    end
+
+    context "when no match occurs" do
+
+      it "should return false" do
+        perform_match.should be_false
+      end
+
+    end
+    
+    def perform_match
+      value_matcher.match?(actual_value)
+    end
+
+  end
+
+  describe "#to_s" do
+
+    it "should return the stub value provided" do
+      value_matcher.to_s.should eql(stub_value)
+    end
+
+  end
+
+end

data/spec/lib/http_stub/server_integration_spec.rb

@@ -4,21 +4,47 @@ describe HttpStub::Server, "when the server is running" do
 
   let(:configurer) { HttpStub::Examples::ConfigurerWithManyActivators.new }
 
+  describe "POST #stubs" do
+
+    context "when provided with the minimum data required" do
+
+      before(:each) do
+        @response = HTTParty.post(
+          "#{server_uri}/stubs",
+          body: { uri: "/some/path", method: "get", response: { status: 200, body: "Some body" } }.to_json
+        )
+      end
+
+      it "should return a 200 response code" do
+        @response.code.should eql(200)
+      end
+
+      it "should register a stub returning the provided response for a matching request" do
+        stubbed_response = HTTParty.get("#{server_uri}/some/path")
+
+        stubbed_response.code.should eql(200)
+        stubbed_response.body.should eql("Some body")
+      end
+
+    end
+
+  end
+
   describe "and a configurer with multiple stub activators is initialized" do
 
     before(:all) do
-      HttpStub::Examples::ConfigurerWithManyActivators.host server_host
-      HttpStub::Examples::ConfigurerWithManyActivators.port server_port
+      HttpStub::Examples::ConfigurerWithManyActivators.host(server_host)
+      HttpStub::Examples::ConfigurerWithManyActivators.port(server_port)
       HttpStub::Examples::ConfigurerWithManyActivators.initialize!
     end
 
     describe "GET #stubs/activators" do
 
-      let(:response) { Net::HTTP.get_response(server_host, "/stubs/activators", server_port) }
+      let(:response) { HTTParty.get("#{server_uri}/stubs/activators") }
       let(:response_document) { Nokogiri::HTML(response.body) }
 
       it "should return a 200 response code" do
-        response.code.should eql("200")
+        response.code.should eql(200)
       end
 
       it "should return response whose body contains a link to each activator in alphabetical order" do
@@ -56,14 +82,14 @@ describe HttpStub::Server, "when the server is running" do
       describe "when multiple stubs are configured" do
 
         before(:all) do
-          (1..3).each { |i| Net::HTTP.get_response(server_host, "/activator#{i}", server_port) }
+          (1..3).each { |i| HTTParty.get("#{server_uri}/activator#{i}") }
         end
 
-        let(:response) { Net::HTTP.get_response(server_host, "/stubs", server_port) }
+        let(:response) { HTTParty.get("#{server_uri}/stubs") }
         let(:response_document) { Nokogiri::HTML(response.body) }
 
         it "should return a 200 response code" do
-          response.code.should eql("200")
+          response.code.should eql(200)
         end
 
         it "should return a response whose body contains the uri of each stub" do

data/spec/lib/http_stub/server_spec.rb

@@ -37,12 +37,8 @@ describe HttpStub::Server do
 
     def issue_stub_request
       post "/stubs", {
-          "uri" => "/a_path",
-          "method" => "a method",
-          "response" => {
-              "status" => 200,
-              "body" => "Foo"
-          }
+        uri: "/a_path", method: "a method",
+        response: { status: 200, body: "Foo" }
       }.to_json
     end
 
@@ -57,7 +53,9 @@ describe HttpStub::Server do
     end
 
     it "should respond with the response provided by the controller" do
-      stub_activator_controller.stub(:register).and_return(HttpStub::Models::Response.new("status" => 302, "body" => ""))
+      stub_activator_controller.stub(:register).and_return(
+        HttpStub::Models::Response.new("status" => 302, "body" => "")
+      )
 
       issue_stub_activator_request
 
@@ -66,13 +64,8 @@ describe HttpStub::Server do
 
     def issue_stub_activator_request
       post "/stubs/activators", {
-          "activation_uri" => "/an_activation_path",
-          "uri" => "/a_path",
-          "method" => "a method",
-          "response" => {
-              "status" => 200,
-              "body" => "Foo"
-          }
+          activation_uri: "/an_activation_path", uri: "/a_path", method: "a method",
+          response: { status: 200, body: "Foo" }
       }.to_json
     end
 
@@ -141,7 +134,9 @@ describe HttpStub::Server do
       context "but the stub activator controller activates a stub" do
 
         before(:each) do
-          stub_activator_controller.stub(:activate).and_return(HttpStub::Models::Response.new("status" => 300, "body" => "A body"))
+          stub_activator_controller.stub(:activate).and_return(
+            HttpStub::Models::Response.new("status" => 300, "body" => "A body")
+          )
         end
 
         it "should respond with the activation response status code" do
@@ -185,7 +180,9 @@ describe HttpStub::Server do
     end
 
     it "should respond with the response's content type" do
-      stub_controller.stub(:replay).and_return(HttpStub::Models::Response.new("status" => 200, "body" => "A body", "content_type" => "application/xhtml"))
+      stub_controller.stub(:replay).and_return(
+        HttpStub::Models::Response.new("status" => 200, "body" => "A body", "content_type" => "application/xhtml")
+      )
       get "/some/stubbed/uri"
       response.content_type.should eql("application/xhtml")
     end

data/spec/spec_helper.rb

@@ -2,7 +2,7 @@ require 'simplecov'
 SimpleCov.start do
   add_filter "/spec/"
   add_filter "/vendor/"
-  minimum_coverage 98.1
+  minimum_coverage 98.3
   refuse_coverage_drop
 end if ENV["coverage"]