http_stub 0.9.6 → 0.9.7

data/lib/http_stub/configurer/request/controllable_value.rb

@@ -0,0 +1,21 @@
+module HttpStub
+  module Configurer
+    module Request
+
+      class ControllableValue
+
+        private
+
+        CONTROL_FORMATTERS = [ HttpStub::Configurer::Request::Regexpable,
+                               HttpStub::Configurer::Request::Omittable ].freeze
+
+        public
+
+        def self.format(value)
+          CONTROL_FORMATTERS.reduce(value) { |result, formatter| formatter.format(result) }
+        end
+
+      end
+    end
+  end
+end

data/lib/http_stub/configurer/request/omittable.rb

@@ -0,0 +1,18 @@
+module HttpStub
+  module Configurer
+    module Request
+
+      class Omittable
+
+        def self.format(value)
+          value.is_a?(Hash) ? value.reduce({}) do |result, entry|
+            key, value = entry
+            result[key] = value == :omitted ? "control:omitted" : value
+            result
+          end : value
+        end
+
+      end
+    end
+  end
+end

data/lib/http_stub/configurer/request/regexpable.rb

@@ -8,22 +8,17 @@ module HttpStub
 
           private
 
-          FORMATTERS = { String => :format_string, Regexp => :format_regexp, Hash => :format_hash }
+          FORMATTERS = { Regexp => :format_regexp, Hash => :format_hash }.freeze
 
           public
 
           def format(value)
             formatter = FORMATTERS.find { |formatter_entry| value.is_a?(formatter_entry[0]) }
-            raise "No Regexp formatter found for #{value}" unless formatter
-            self.send(formatter[1], value)
+            formatter ? self.send(formatter[1], value) : value
           end
 
           private
 
-          def format_string(string)
-            string
-          end
-
           def format_regexp(regexp)
             "regexp:#{regexp.source.gsub(/\\\//, "/")}"
           end

data/lib/http_stub/configurer/request/stub.rb

@@ -8,10 +8,10 @@ module HttpStub
           super("/stubs")
           self.content_type = "application/json"
           self.body = {
-              "uri" => HttpStub::Configurer::Request::Regexpable.format(uri),
+              "uri" => HttpStub::Configurer::Request::ControllableValue.format(uri),
               "method" => options[:method],
-              "headers" => HttpStub::Configurer::Request::Regexpable.format(options[:headers] || {}),
-              "parameters" => HttpStub::Configurer::Request::Regexpable.format(options[:parameters] || {}),
+              "headers" => HttpStub::Configurer::Request::ControllableValue.format(options[:headers] || {}),
+              "parameters" => HttpStub::Configurer::Request::ControllableValue.format(options[:parameters] || {}),
               "response" => {
                   "status" => options[:response][:status] || "",
                   "content_type" => options[:response][:content_type] || "application/json",

data/lib/http_stub/models/exact_value_matcher.rb

@@ -0,0 +1,13 @@
+module HttpStub
+  module Models
+
+    class ExactValueMatcher
+
+      def self.match?(stub_value, actual_value)
+        stub_value == actual_value
+      end
+
+    end
+
+  end
+end

data/lib/http_stub/models/hash_with_value_matchers.rb

@@ -0,0 +1,20 @@
+module HttpStub
+  module Models
+
+    class HashWithValueMatchers < Hash
+
+      def initialize(stub_hash)
+        stub_hash.each_pair { |key, value| self[key] = HttpStub::Models::ValueMatcher.new(value) }
+      end
+
+      def match?(actual_hash)
+        !(self.find do |key_and_value_matcher|
+          other_value = actual_hash[key_and_value_matcher[0]]
+          !key_and_value_matcher[1].match?(other_value)
+        end)
+      end
+
+    end
+
+  end
+end

data/lib/http_stub/models/omitted_value_matcher.rb

@@ -0,0 +1,19 @@
+module HttpStub
+  module Models
+
+    class OmittedValueMatcher
+
+      private
+
+      OMITTED_CONTROL_VALUE = "control:omitted".freeze
+
+      public
+
+      def self.match?(stub_value, actual_value)
+        stub_value == OMITTED_CONTROL_VALUE && actual_value.nil?
+      end
+
+    end
+
+  end
+end

data/lib/http_stub/models/regexp_value_matcher.rb

@@ -0,0 +1,14 @@
+module HttpStub
+  module Models
+
+    class RegexpValueMatcher
+
+      def self.match?(stub_value, actual_value)
+        match_data = stub_value.match(/^regexp:(.*)/)
+        match_data && !!Regexp.new(match_data[1]).match(actual_value)
+      end
+
+    end
+
+  end
+end

data/lib/http_stub/models/stub_headers.rb

@@ -4,7 +4,7 @@ module HttpStub
     class StubHeaders
 
       def initialize(headers)
-        @headers = HttpStub::Models::HashWithRegexpableValues.new((headers || {}).downcase_and_underscore_keys)
+        @headers = HttpStub::Models::HashWithValueMatchers.new((headers || {}).downcase_and_underscore_keys)
       end
 
       def match?(request)

data/lib/http_stub/models/stub_parameters.rb

@@ -4,7 +4,7 @@ module HttpStub
     class StubParameters
 
       def initialize(parameters)
-        @parameters = HttpStub::Models::HashWithRegexpableValues.new(parameters || {})
+        @parameters = HttpStub::Models::HashWithValueMatchers.new(parameters || {})
       end
 
       def match?(request)

data/lib/http_stub/models/stub_uri.rb

@@ -4,7 +4,7 @@ module HttpStub
     class StubUri
 
       def initialize(uri)
-        @uri = HttpStub::Models::RegexpableValue.new(uri)
+        @uri = HttpStub::Models::ValueMatcher.new(uri)
       end
 
       def match?(request)

data/lib/http_stub/models/value_matcher.rb

@@ -0,0 +1,29 @@
+module HttpStub
+  module Models
+
+    class ValueMatcher
+
+      private
+
+      MATCHERS = [ HttpStub::Models::OmittedValueMatcher,
+                   HttpStub::Models::RegexpValueMatcher,
+                   HttpStub::Models::ExactValueMatcher ].freeze
+
+      public
+
+      def initialize(stub_value)
+        @stub_value = stub_value
+      end
+
+      def match?(actual_value)
+        !!MATCHERS.find { |matcher| matcher.match?(@stub_value, actual_value) }
+      end
+
+      def to_s
+        @stub_value
+      end
+
+    end
+
+  end
+end

data/lib/http_stub/version.rb

@@ -1,3 +1,3 @@
 module HttpStub
-  VERSION = "0.9.6"
+  VERSION = "0.9.7"
 end

data/lib/http_stub.rb

@@ -11,8 +11,11 @@ require 'json'
 
 require File.expand_path('../http_stub/hash_extensions', __FILE__)
 require File.expand_path('../http_stub/models/response', __FILE__)
-require File.expand_path('../http_stub/models/regexpable_value', __FILE__)
-require File.expand_path('../http_stub/models/hash_with_regexpable_values', __FILE__)
+require File.expand_path('../http_stub/models/omitted_value_matcher', __FILE__)
+require File.expand_path('../http_stub/models/regexp_value_matcher', __FILE__)
+require File.expand_path('../http_stub/models/exact_value_matcher', __FILE__)
+require File.expand_path('../http_stub/models/value_matcher', __FILE__)
+require File.expand_path('../http_stub/models/hash_with_value_matchers', __FILE__)
 require File.expand_path('../http_stub/models/request_header_parser', __FILE__)
 require File.expand_path('../http_stub/models/stub_uri', __FILE__)
 require File.expand_path('../http_stub/models/stub_headers', __FILE__)
@@ -24,7 +27,9 @@ require File.expand_path('../http_stub/models/request_pipeline', __FILE__)
 require File.expand_path('../http_stub/controllers/stub_controller', __FILE__)
 require File.expand_path('../http_stub/controllers/stub_activator_controller', __FILE__)
 require File.expand_path('../http_stub/server', __FILE__)
+require File.expand_path('../http_stub/configurer/request/omittable', __FILE__)
 require File.expand_path('../http_stub/configurer/request/regexpable', __FILE__)
+require File.expand_path('../http_stub/configurer/request/controllable_value', __FILE__)
 require File.expand_path('../http_stub/configurer/request/stub', __FILE__)
 require File.expand_path('../http_stub/configurer/request/stub_activator', __FILE__)
 require File.expand_path('../http_stub/configurer/command', __FILE__)

data/spec/lib/http_stub/configurer/request/controllable_value_spec.rb

@@ -0,0 +1,34 @@
+describe HttpStub::Configurer::Request::ControllableValue do
+
+  describe ".format" do
+
+    let(:value) { "some value" }
+
+    it "should format the potential control value via the Regexpable formatter" do
+      HttpStub::Configurer::Request::Regexpable.should_receive(:format).with(value)
+
+      perform_format
+    end
+
+    it "should chain formatting by formatting the Regexpable formatter result via the Omittable formatter" do
+      regexp_formatted_value = "some regexp formatted value"
+      HttpStub::Configurer::Request::Regexpable.stub(:format).and_return(regexp_formatted_value)
+      HttpStub::Configurer::Request::Omittable.should_receive(:format).with(regexp_formatted_value)
+
+      perform_format
+    end
+
+    it "should return the Omittable formatter result" do
+      omit_formatted_value = "some omit formatted value"
+      HttpStub::Configurer::Request::Omittable.stub(:format).and_return(omit_formatted_value)
+
+      perform_format.should eql(omit_formatted_value)
+    end
+
+    def perform_format
+      HttpStub::Configurer::Request::ControllableValue.format(value)
+    end
+
+  end
+
+end

data/spec/lib/http_stub/configurer/request/omittable_spec.rb

@@ -0,0 +1,70 @@
+describe HttpStub::Configurer::Request::Omittable do
+
+  describe ".format" do
+
+    context "when the value is a hash" do
+
+      context "that contains entries with values that are :omitted" do
+
+        let(:value) do
+          (1..5).reduce({}) do |result, i|
+            result["key#{i}"] = (i % 2 == 0) ? "value#{i}" : :omitted
+            result
+          end
+        end
+
+        it "should return a hash containing the omitted values converted to 'control:omitted'" do
+          expected_hash = (1..5).reduce({}) do |result, i|
+            result["key#{i}"] = (i % 2 == 0) ? "value#{i}" : "control:omitted"
+            result
+          end
+
+          perform_format.should eql(expected_hash)
+        end
+
+      end
+
+      context "that contains no entries to be omitted" do
+
+        let(:value) do
+          (1..3).reduce({}) do |result, i|
+            result["key#{i}"] = "value#{i}"
+            result
+          end
+        end
+
+        it "should return the hash unchanged" do
+          perform_format.should eql(value)
+        end
+
+      end
+
+      context "that is empty" do
+
+        let(:value) { {} }
+
+        it "should return the hash unchanged" do
+          perform_format.should eql({})
+        end
+
+      end
+
+    end
+
+    context "when the value is not a hash" do
+
+      let(:value) { "not a hash" }
+
+      it "should return the value unchanged" do
+        perform_format.should eql(value)
+      end
+
+    end
+
+    def perform_format
+      HttpStub::Configurer::Request::Omittable.format(value)
+    end
+
+  end
+
+end

data/spec/lib/http_stub/configurer/request/stub_spec.rb

@@ -30,7 +30,7 @@ describe HttpStub::Configurer::Request::Stub do
       let(:request) { HttpStub::Configurer::Request::Stub.new(uri, stub_options) }
       let(:request_body) { JSON.parse(request.body) }
 
-      before(:each) { HttpStub::Configurer::Request::Regexpable.stub(:format) }
+      before(:each) { HttpStub::Configurer::Request::ControllableValue.stub(:format) }
 
       it "should create a HTTP POST request" do
         request.method.should eql("POST")
@@ -46,8 +46,8 @@ describe HttpStub::Configurer::Request::Stub do
 
       context "when a header option is provided" do
 
-        it "should format the headers with regexp support" do
-          HttpStub::Configurer::Request::Regexpable.should_receive(:format).with(headers)
+        it "should format the headers into control values" do
+          HttpStub::Configurer::Request::ControllableValue.should_receive(:format).with(headers)
 
           request
         end
@@ -59,7 +59,7 @@ describe HttpStub::Configurer::Request::Stub do
         let(:headers) { nil }
 
         it "should format an empty header hash" do
-          HttpStub::Configurer::Request::Regexpable.should_receive(:format).with({})
+          HttpStub::Configurer::Request::ControllableValue.should_receive(:format).with({})
 
           request
         end
@@ -68,8 +68,8 @@ describe HttpStub::Configurer::Request::Stub do
 
       context "when a parameter option is provided" do
 
-        it "should format the parameters with regexp support" do
-          HttpStub::Configurer::Request::Regexpable.should_receive(:format).with(parameters)
+        it "should format the parameters into control values" do
+          HttpStub::Configurer::Request::ControllableValue.should_receive(:format).with(parameters)
 
           request
         end
@@ -81,7 +81,7 @@ describe HttpStub::Configurer::Request::Stub do
         let(:parameters) { nil }
 
         it "should format an empty parameter hash" do
-          HttpStub::Configurer::Request::Regexpable.should_receive(:format).with({})
+          HttpStub::Configurer::Request::ControllableValue.should_receive(:format).with({})
 
           request
         end
@@ -90,8 +90,8 @@ describe HttpStub::Configurer::Request::Stub do
 
       context "generates a JSON body which" do
 
-        it "should have an entry containing the regexpable representation of the uri" do
-          HttpStub::Configurer::Request::Regexpable.should_receive(:format).with(uri).and_return("uri as a string")
+        it "should have an entry containing the control value representation of the uri" do
+          HttpStub::Configurer::Request::ControllableValue.should_receive(:format).with(uri).and_return("uri as a string")
 
           request_body.should include("uri" => "uri as a string")
         end
@@ -101,14 +101,14 @@ describe HttpStub::Configurer::Request::Stub do
         end
 
         it "should have an entry containing the string representation of the headers" do
-          HttpStub::Configurer::Request::Regexpable.should_receive(:format)
+          HttpStub::Configurer::Request::ControllableValue.should_receive(:format)
             .with(headers).and_return("headers as string")
 
           request_body.should include("headers" => "headers as string")
         end
 
         it "should have an entry containing the string representation of the parameters" do
-          HttpStub::Configurer::Request::Regexpable.should_receive(:format)
+          HttpStub::Configurer::Request::ControllableValue.should_receive(:format)
             .with(parameters).and_return("parameters as string")
 
           request_body.should include("parameters" => "parameters as string")

data/spec/lib/http_stub/configurer_integration_spec.rb

@@ -11,8 +11,8 @@ describe HttpStub::Configurer, "when the server is running" do
   context "and the configurer is initialized" do
 
     before(:each) do
-      configurer.class.host server_host
-      configurer.class.port server_port
+      configurer.class.host(server_host)
+      configurer.class.port(server_port)
       configurer.class.initialize!
     end
 
@@ -231,8 +231,10 @@ describe HttpStub::Configurer, "when the server is running" do
         context "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" })
+            configurer.stub_response!(
+              "/stub_with_headers", method: :get, headers: { key: "value" },
+              response: { status: 202, body: "Another stub body" }
+            )
           end
 
           context "and that request is made" do
@@ -261,8 +263,10 @@ describe HttpStub::Configurer, "when the server is running" do
         context "whose values are regular expressions" do
 
           before(:each) do
-            configurer.stub_response!("/stub_with_headers", method: :get, headers: { key: /^match.*/ },
-                                      response: { status: 202, body: "Another stub body" })
+            configurer.stub_response!(
+              "/stub_with_headers", method: :get, headers: { key: /^match.*/ },
+              response: { status: 202, body: "Another stub body" }
+            )
           end
 
           context "and a request that matches is made" do
@@ -331,8 +335,10 @@ describe HttpStub::Configurer, "when the server is running" do
         context "whose values are regular expressions" do
 
           before(:each) do
-            configurer.stub_response!("/stub_with_parameters", method: :get, parameters: { key: /^match.*/ },
-                                      response: { status: 202, body: "Another stub body" })
+            configurer.stub_response!(
+              "/stub_with_parameters", method: :get, parameters: { key: /^match.*/ },
+              response: { status: 202, body: "Another stub body" }
+            )
           end
 
           context "and a request that matches is made" do
@@ -362,6 +368,40 @@ describe HttpStub::Configurer, "when the server is running" do
 
         end
 
+        context "whose values indicate the parameters must be omitted" do
+
+          before(:each) do
+            configurer.stub_response!(
+              "/stub_with_omitted_parameters", method: :get, parameters: { key: :omitted },
+              response: { status: 202, body: "Omitted parameter stub body" }
+            )
+          end
+
+          context "and a request that matches is made" do
+
+            let(:response) { Net::HTTP.get_response(server_host, "/stub_with_omitted_parameters", server_port) }
+
+            it "should replay the stubbed response" do
+              response.code.should eql("202")
+              response.body.should eql("Omitted parameter stub body")
+            end
+
+          end
+
+          context "and a request that does not match is made" do
+
+            let(:response) do
+              Net::HTTP.get_response(server_host, "/stub_with_omitted_parameters?key=must_be_omitted", server_port)
+            end
+
+            it "should respond with a 404 status code" do
+              response.code.should eql("404")
+            end
+
+          end
+
+        end
+
       end
 
     end
@@ -430,7 +470,9 @@ describe HttpStub::Configurer, "when the server is running" do
       describe "and an attempt is made to register a response with a given content type" do
 
         before(:each) do
-          configurer.stub_response!("/some_stub_path", method: :get, response: { body: "Some stub body", content_type: "application/xhtml" })
+          configurer.stub_response!(
+            "/some_stub_path", method: :get, response: { body: "Some stub body", content_type: "application/xhtml" }
+          )
         end
 
         it "should register the stub" do

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

@@ -0,0 +1,33 @@
+describe HttpStub::Models::ExactValueMatcher do
+
+  describe ".match?" do
+
+    let(:stub_value) { "some stub value" }
+
+    describe "when the stub value is equal to the actual value" do
+
+      let(:actual_value) { stub_value }
+
+      it "should return true" do
+        perform_match.should be_true
+      end
+
+    end
+
+    describe "when the stub value is not equal to the actual value" do
+
+      let(:actual_value) { "not equal to stub value" }
+
+      it "should return false" do
+        perform_match.should be_false
+      end
+
+    end
+
+    def perform_match
+      HttpStub::Models::ExactValueMatcher.match?(stub_value, actual_value)
+    end
+
+  end
+
+end