http_stub 0.4.0 → 0.5.0

data/lib/http_stub.rb

@@ -9,7 +9,9 @@ require 'sass'
 require 'net/http'
 require 'json'
 
+require File.expand_path('../http_stub/hash_extensions', __FILE__)
 require File.expand_path('../http_stub/response', __FILE__)
+require File.expand_path('../http_stub/models/headers', __FILE__)
 require File.expand_path('../http_stub/models/parameters', __FILE__)
 require File.expand_path('../http_stub/models/stub', __FILE__)
 require File.expand_path('../http_stub/models/stub_activator', __FILE__)

data/lib/http_stub/configurer.rb

@@ -25,6 +25,7 @@ module HttpStub
             "activation_uri" => activation_uri,
             "uri" => stub_uri,
             "method" => options[:method],
+            "headers" => options[:headers] || {},
             "parameters" => options[:parameters] || {},
             "response" => {
                 "status" => response_options[:status] || "200",
@@ -68,6 +69,7 @@ module HttpStub
         request.body = {
             "uri" => uri,
             "method" => options[:method],
+            "headers" => options[:headers] || {},
             "parameters" => options[:parameters] || {},
             "response" => {
                 "status" => response_options[:status] || "200",

data/lib/http_stub/hash_extensions.rb

@@ -0,0 +1,22 @@
+module HttpStub
+
+  module HashExtensions
+
+    def downcase_keys
+      self.reduce({}) do |result, element|
+        result[element[0].is_a?(::String) ? element[0].downcase : element[0]] = element[1]
+        result
+      end
+    end
+
+    def has_hash?(other_hash)
+      other_hash.nil? || other_hash.reduce(true) do |result, element|
+        result && (self[element[0]] == element[1])
+      end
+    end
+
+  end
+
+end
+
+::Hash.send(:include, HttpStub::HashExtensions)

data/lib/http_stub/models/headers.rb

@@ -0,0 +1,31 @@
+module HttpStub
+  module Models
+
+    class Headers
+
+      def initialize(headers)
+        @headers = headers || {}
+      end
+
+      def match?(request)
+        headers_in(request).downcase_keys.has_hash?(@headers.downcase_keys)
+      end
+
+      def to_s
+        @headers ? @headers.map { |key_and_value| key_and_value.join(":") }.join(", ") : ""
+      end
+
+      private
+
+      def headers_in(request)
+        request.env.reduce({}) do |result, element|
+          match = element[0].match(/^HTTP_(.*)/)
+          result[match[1]] = element[1] if match
+          result
+        end
+      end
+
+    end
+
+  end
+end

data/lib/http_stub/models/parameters.rb

@@ -8,13 +8,11 @@ module HttpStub
       end
 
       def match?(request)
-        @parameters.nil? || @parameters.reduce(true) do |result, parameter|
-          result && (request.params[parameter[0]] == parameter[1])
-        end
+        request.params.has_hash?(@parameters)
       end
 
       def to_s
-        @parameters ? @parameters.map { |param| "#{param[0]}=#{param[1]}" }.join("&") : ""
+        @parameters ? @parameters.map { |key_and_value| key_and_value.join("=") }.join("&") : ""
       end
 
     end

data/lib/http_stub/models/stub.rb

@@ -3,16 +3,20 @@ module HttpStub
 
     class Stub
 
-      attr_reader :response
+      attr_reader :headers, :parameters, :response
 
       def initialize(options)
         @stub_options = options
+        @headers = HttpStub::Models::Headers.new(options["headers"])
         @parameters = HttpStub::Models::Parameters.new(options["parameters"])
         @response = HttpStub::Response.new(options["response"])
       end
 
       def satisfies?(request)
-        uri == request.path_info && method.downcase == request.request_method.downcase && @parameters.match?(request)
+        uri == request.path_info &&
+            method.downcase == request.request_method.downcase &&
+            @headers.match?(request) &&
+            @parameters.match?(request)
       end
 
       def uri
@@ -23,10 +27,6 @@ module HttpStub
         @stub_options["method"]
       end
 
-      def parameters
-        @parameters
-      end
-
       def to_s
         @stub_options.to_s
       end

data/lib/http_stub/server.rb

@@ -29,6 +29,10 @@ module HttpStub
     # {
     #   "uri": "/some/path",
     #   "method": "get",
+    #   "headers": {
+    #     "key": "value",
+    #     ...
+    #   },
     #   "parameters": {
     #     "key": "value",
     #     ...

data/lib/http_stub/version.rb

@@ -1,3 +1,3 @@
 module HttpStub
-  VERSION = "0.4.0"
+  VERSION = "0.5.0"
 end

data/lib/http_stub/views/_stub.haml

@@ -5,6 +5,9 @@
   %tr
     %td Method:
     %td=the_stub.method
+  %tr
+    %td Headers:
+    %td=h(the_stub.headers)
   %tr
     %td Parameters:
     %td=h(the_stub.parameters)

data/spec/lib/http_stub/configurer_integration_spec.rb

@@ -61,7 +61,7 @@ describe HttpStub::Configurer, "when the server is running" do
 
   describe "when a response for a request is stubbed" do
 
-    describe "that contains no parameters" do
+    describe "that contains no headers or parameters" do
 
       before(:each) do
         configurer.stub_response!("/path2", method: :get, response: { status: 201, body: "Stub body" })
@@ -96,16 +96,46 @@ describe HttpStub::Configurer, "when the server is running" do
 
     end
 
+    describe "that contains headers" do
+
+      before(:each) do
+        configurer.stub_response!("/path3", method: :get, headers: { key: "value" },
+                                                          response: { status: 202, body: "Another stub body" })
+      end
+
+      describe "and that request is made" do
+
+        let(:response) { HTTParty.get("http://localhost:8001/path3", 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) { HTTParty.get("http://localhost:8001/path3", headers: { "key" => "another_value" }) }
+
+        it "should respond with a 404 status code" do
+          response.code.should eql(404)
+        end
+
+      end
+
+    end
+
     describe "that contains parameters" do
 
       before(:each) do
-        configurer.stub_response!("/path3", method: :get, parameters: { key: "value" },
+        configurer.stub_response!("/path4", method: :get, parameters: { key: "value" },
                                                           response: { status: 202, body: "Another stub body" })
       end
 
       describe "and that request is made" do
 
-        let(:response) { Net::HTTP.get_response("localhost", "/path3?key=value", 8001) }
+        let(:response) { Net::HTTP.get_response("localhost", "/path4?key=value", 8001) }
 
         it "should replay the stubbed response" do
           response.code.should eql("202")
@@ -116,7 +146,7 @@ describe HttpStub::Configurer, "when the server is running" do
 
       describe "and a request with different parameters is made" do
 
-        let(:response) { Net::HTTP.get_response("localhost", "/path3?key=another_value", 8001) }
+        let(:response) { Net::HTTP.get_response("localhost", "/path4?key=another_value", 8001) }
 
         it "should respond with a 404 status code" do
           response.code.should eql("404")

data/spec/lib/http_stub/hash_extensions_spec.rb

@@ -0,0 +1,143 @@
+describe HttpStub::HashExtensions do
+
+  describe "#downcase_keys" do
+
+    describe "when the hash contains keys which are strings" do
+
+      let(:hash) do
+        { "lower" => 1, "UPPER" => 2, "MiXeDcAsE" => 3 }
+      end
+
+      it "should downcase the string keys" do
+        hash.downcase_keys.should eql({ "lower" => 1, "upper" => 2, "mixedcase" => 3 })
+      end
+
+    end
+
+    describe "when the hash contains keys which are not strings" do
+
+      let(:hash) do
+        { 1 => 2, :symbol => 3, nil => 4 }
+      end
+
+      it "should not alter a hash" do
+        hash.downcase_keys.should eql({ 1 => 2, :symbol => 3, nil => 4 })
+      end
+
+    end
+
+  end
+
+  describe "#has_hash?" do
+
+    describe "when many elements are provided" do
+
+      let(:hash_parameter) { { "key1" => "value1", "key2" => "value2", "key3" => "value3" } }
+
+      describe "and the hash contains only those elements" do
+
+        let(:hash) { hash_parameter }
+
+        it "should return true" do
+          hash.has_hash?(hash_parameter).should be(true)
+        end
+
+      end
+
+      describe "and the hash contains more than those elements" do
+
+        let(:hash) { hash_parameter.merge("key4" => "value4") }
+
+        it "should return true" do
+          hash.has_hash?(hash_parameter).should be(true)
+        end
+
+      end
+
+      describe "and the hash contains keys that match but values that do not match" do
+
+        let(:hash) { { "key1" => "value1", "key2" => "nonMatchingValue", "key3" => "value3" } }
+
+        it "should return false" do
+          hash.has_hash?(hash_parameter).should be(false)
+        end
+
+      end
+
+      describe "and the hash contains less than those elements" do
+
+        let(:hash) { { "key1" => "value1", "key3" => "value3" } }
+
+        it "should return false" do
+          hash.has_hash?(hash_parameter).should be(false)
+        end
+
+      end
+
+      describe "and the hash contains no elements" do
+
+        let(:hash) { {} }
+
+        it "should return false" do
+          hash.has_hash?(hash_parameter).should be(false)
+        end
+
+      end
+
+    end
+
+    describe "when no elements are provided" do
+
+      let(:hash_parameter) { {} }
+
+      describe "and the hash contains no element" do
+
+        let(:hash) { {} }
+
+        it "should return true" do
+          hash.has_hash?(hash_parameter).should be(true)
+        end
+
+      end
+
+      describe "when the hash contains elements" do
+
+        let(:hash) { { "key" => "value" } }
+
+        it "should return true" do
+          hash.has_hash?(hash_parameter).should be(true)
+        end
+
+      end
+
+    end
+
+    describe "when a nil hash is provided" do
+
+      let(:hash_parameter) { nil }
+
+      describe "and the hash contains no elements" do
+
+        let(:hash) { {} }
+
+        it "should return true" do
+          hash.has_hash?(hash_parameter).should be(true)
+        end
+
+      end
+
+      describe "when the hash contains elements" do
+
+        let(:hash) { { "key" => "value" } }
+
+        it "should return true" do
+          hash.has_hash?(hash_parameter).should be(true)
+        end
+
+      end
+
+    end
+
+  end
+
+end

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

@@ -0,0 +1,153 @@
+describe HttpStub::Models::Headers do
+
+  let(:non_http_env_elements) do
+    {
+        "GATEWAY_INTERFACE" => "CGI/1.1",
+        "QUERY_STRING" => "some string",
+        "REMOTE_ADDR" => "127.0.0.1",
+        "SCRIPT_NAME" => "some script",
+        "SERVER_NAME" => "localhost",
+    }
+  end
+  let(:env) { non_http_env_elements.merge(request_headers) }
+  let(:request) { double("HttpRequest", env: env) }
+
+  let(:model) { HttpStub::Models::Headers.new(mandatory_headers) }
+
+  describe "#match?" do
+
+    describe "when multiple headers are mandatory" do
+
+      let(:mandatory_headers) { { "KEY1" => "value1", "KEY2" => "value2", "KEY3" => "value3" } }
+
+      describe "and the mandatory headers are provided" do
+
+        let(:request_headers) { { "HTTP_KEY1" => "value1", "HTTP_KEY2" => "value2", "HTTP_KEY3" => "value3" } }
+
+        describe "and the casing of the header names is identical" do
+
+          it "should return true" do
+            model.match?(request).should be_true
+          end
+
+        end
+
+        describe "and the casing of the header names is different" do
+
+          let(:mandatory_headers) { { "key1" => "value1", "KEY2" => "value2", "key3" => "value3" } }
+
+          it "should return true" do
+            model.match?(request).should be_true
+          end
+
+        end
+
+      end
+
+      describe "and the request headers have different values" do
+
+        let(:request_headers) { { "HTTP_KEY1" => "value1", "HTTP_KEY2" => "doesNotMatch", "HTTP_KEY3" => "value3" } }
+
+        it "should return false" do
+          model.match?(request).should be_false
+        end
+
+      end
+
+      describe "and some mandatory headers are omitted" do
+
+        let(:request_headers) { { "HTTP_KEY1" => "value1", "HTTP_KEY3" => "value3" } }
+
+        it "should return false" do
+          model.match?(request).should be_false
+        end
+
+      end
+
+      describe "and all mandatory headers are omitted" do
+
+        let(:request_headers) { {} }
+
+        it "should return false" do
+          model.match?(request).should be_false
+        end
+
+      end
+
+    end
+
+    describe "when no headers are mandatory" do
+
+      let(:mandatory_headers) { {} }
+
+      describe "and headers are provided" do
+
+        let(:request_headers) { { "HTTP_KEY" => "value" } }
+
+        it "should return true" do
+          model.match?(request).should be_true
+        end
+
+      end
+
+    end
+
+    describe "when the mandatory headers are nil" do
+
+      let(:mandatory_headers) { nil }
+
+      describe "and headers are provided" do
+
+        let(:request_headers) { { "HTTP_KEY" => "value" } }
+
+        it "should return true" do
+          model.match?(request).should be_true
+        end
+
+      end
+
+    end
+
+  end
+
+  describe "#to_s" do
+
+    describe "when multiple headers are provided" do
+
+      let(:mandatory_headers) { { "key1" => "value1", "key2" => "value2", "key3" => "value3" } }
+
+      it "should return a string containing each header formatted as a conventional request header" do
+        result = model.to_s
+
+        mandatory_headers.each { |key, value| result.should match(/#{key}:#{value}/) }
+      end
+
+      it "should comma delimit the headers" do
+        model.to_s.should match(/key\d.value\d\, key\d.value\d\, key\d.value\d/)
+      end
+
+    end
+
+    describe "when empty headers are provided" do
+
+      let(:mandatory_headers) { {} }
+
+      it "should return an empty string" do
+        model.to_s.should eql("")
+      end
+
+    end
+
+    describe "when nil headers are provided" do
+
+      let(:mandatory_headers) { nil }
+
+      it "should return an empty string" do
+        model.to_s.should eql("")
+      end
+
+    end
+
+  end
+
+end

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

@@ -1,115 +1,29 @@
 describe HttpStub::Models::Parameters do
 
+  let(:request_params) { double("RequestParameters") }
   let(:request) { double("HttpRequest", params: request_params) }
 
-  let(:parameters) { HttpStub::Models::Parameters.new(params) }
+  let(:params) { { "key1" => "value1", "key2" => "value2", "key3" => "value3" } }
+  let(:model) { HttpStub::Models::Parameters.new(params) }
 
   describe "#match?" do
 
-    describe "when multiple parameters are provided" do
-
-      let(:params) { { "key1" => "value1", "key2" => "value2", "key3" => "value3" } }
-
-      describe "and the request contains only those parameters" do
-
-        let(:request_params) { params }
-
-        it "should return true" do
-          parameters.match?(request).should be(true)
-        end
-
-      end
-
-      describe "and the request contains more than those parameters" do
-
-        let(:request_params) { params.merge("key4" => "value4") }
-
-        it "should return true" do
-          parameters.match?(request).should be(true)
-        end
-
-      end
+    describe "when the request parameters contain the model parameters" do
 
-      describe "and the requests contains only those parameters with values that do not match" do
-
-        let(:request_params) { { "key1" => "value1", "key2" => "nonMatchingValue", "key3" => "value3" } }
-
-        it "should return false" do
-          parameters.match?(request).should be(false)
-        end
-
-      end
-
-      describe "and the request contains a subset of those parameters" do
-
-        let(:request_params) { { "key1" => "value1", "key3" => "value3" } }
-
-        it "should return false" do
-          parameters.match?(request).should be(false)
-        end
-
-      end
-
-      describe "and the request contains no parameters" do
-
-        let(:request_params) { {} }
-
-        it "should return false" do
-          parameters.match?(request).should be(false)
-        end
+      before(:each) { request_params.stub!(:has_hash?).with(params).and_return(true) }
 
+      it "should return true" do
+        model.match?(request).should be(true)
       end
 
     end
 
-    describe "when empty parameters are provided" do
-
-      let(:params) { {} }
-
-      describe "when the request contains no parameters" do
-
-        let(:request_params) { {} }
-
-        it "should return true" do
-          parameters.match?(request).should be(true)
-        end
-
-      end
-
-      describe "when the request contains parameters" do
-
-        let(:request_params) { { "key" => "value" } }
-
-        it "should return true" do
-          parameters.match?(request).should be(true)
-        end
-
-      end
-
-    end
-
-    describe "when nil parameters are provided" do
-
-      let(:params) { nil }
-
-      describe "when the request contains no parameters" do
-
-        let(:request_params) { {} }
-
-        it "should return true" do
-          parameters.match?(request).should be(true)
-        end
-
-      end
-
-      describe "when the request contains parameters" do
-
-        let(:request_params) { { "key" => "value" } }
+    describe "when the request parameters do not contain the model parameters" do
 
-        it "should return true" do
-          parameters.match?(request).should be(true)
-        end
+      before(:each) { request_params.stub!(:has_hash?).with(params).and_return(false) }
 
+      it "should return false" do
+        model.match?(request).should be(false)
       end
 
     end
@@ -123,13 +37,13 @@ describe HttpStub::Models::Parameters do
       let(:params) { { "key1" => "value1", "key2" => "value2", "key3" => "value3" } }
 
       it "should return a string containing each parameter formatted as a conventional request parameter" do
-        result = parameters.to_s
+        result = model.to_s
 
         params.each { |key, value| result.should match(/#{key}=#{value}/) }
       end
 
       it "should separate each parameter with the conventional request parameter delimiter" do
-        parameters.to_s.should match(/key\d=value\d\&key\d=value\d\&key\d=value\d/)
+        model.to_s.should match(/key\d.value\d\&key\d.value\d\&key\d.value\d/)
       end
 
     end
@@ -139,7 +53,7 @@ describe HttpStub::Models::Parameters do
       let(:params) { {} }
 
       it "should return an empty string" do
-        parameters.to_s.should eql("")
+        model.to_s.should eql("")
       end
 
     end
@@ -149,7 +63,7 @@ describe HttpStub::Models::Parameters do
       let(:params) { nil }
 
       it "should return an empty string" do
-        parameters.to_s.should eql("")
+        model.to_s.should eql("")
       end
 
     end

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

@@ -3,13 +3,17 @@ describe HttpStub::Models::Stub do
   let(:stub_uri) { "/a_path" }
   let(:stub_method) { "get" }
   let(:stub_parameters) do
-    { "param" => "value" }
+    { "param" => "param_value" }
+  end
+  let(:stub_headers) do
+    { "header" => "header_value" }
   end
   let(:stub_options) do
     {
       "uri" => stub_uri,
       "method" => stub_method,
       "parameters" => stub_parameters,
+      "headers" => stub_headers,
       "response" => {
         "status" => 201,
         "body" => "Foo"
@@ -18,8 +22,12 @@ describe HttpStub::Models::Stub do
   end
   let(:the_stub) { HttpStub::Models::Stub.new(stub_options) }
   let(:parameters_model) { double(HttpStub::Models::Parameters, match?: true) }
-  
-  before(:each) { HttpStub::Models::Parameters.stub!(:new).and_return(parameters_model) }
+  let(:headers_model) { double(HttpStub::Models::Headers, match?: true) }
+
+  before(:each) do
+    HttpStub::Models::Parameters.stub!(:new).and_return(parameters_model)
+    HttpStub::Models::Headers.stub!(:new).and_return(headers_model)
+  end
 
   describe "#satisfies?" do
 
@@ -31,24 +39,34 @@ describe HttpStub::Models::Stub do
 
       describe "and the request method matches" do
 
-        describe "and a parameter match is configured" do
-          
+        describe "and a header match is configured" do
+
           describe "that matches" do
-            
-            before(:each) { parameters_model.stub!(:match?).with(request).and_return(true) }
 
-            it "should return true" do
-              the_stub.satisfies?(request).should be_true
-            end
-            
-          end
-          
-          describe "that does not match" do
+            before(:each) { headers_model.stub!(:match?).with(request).and_return(true) }
+
+            describe "and a parameter match is configured" do
+
+              describe "that matches" do
+
+                before(:each) { parameters_model.stub!(:match?).with(request).and_return(true) }
 
-            before(:each) { parameters_model.stub!(:match?).with(request).and_return(false) }
+                it "should return true" do
+                  the_stub.satisfies?(request).should be_true
+                end
+
+              end
+
+              describe "that does not match" do
+
+                before(:each) { parameters_model.stub!(:match?).with(request).and_return(false) }
+
+                it "should return false" do
+                  the_stub.satisfies?(request).should be_false
+                end
+
+              end
 
-            it "should return false" do
-              the_stub.satisfies?(request).should be_false
             end
 
           end
@@ -79,6 +97,16 @@ describe HttpStub::Models::Stub do
 
     end
 
+    describe "when the headers do not match" do
+
+      before(:each) { headers_model.stub!(:match?).with(request).and_return(false) }
+
+      it "should return false" do
+        the_stub.satisfies?(request).should be_false
+      end
+
+    end
+
   end
 
   describe "#uri" do
@@ -97,6 +125,14 @@ describe HttpStub::Models::Stub do
 
   end
 
+  describe "#headers" do
+
+    it "should return the headers model encapsulating the headers provided in the request body" do
+      the_stub.headers.should eql(headers_model)
+    end
+
+  end
+
   describe "#parameters" do
 
     it "should return the parameters model encapsulating the parameters provided in the request body" do
@@ -119,11 +155,19 @@ describe HttpStub::Models::Stub do
 
   describe "#to_s" do
 
+    let(:stub_headers) do
+      {
+          "header1" => "header_value1",
+          "header2" => "header_value2",
+          "header3" => "header_value3"
+      }
+    end
+
     let(:stub_parameters) do
       {
-          "param1" => "value1",
-          "param2" => "value2",
-          "param3" => "value3"
+          "param1" => "param_value1",
+          "param2" => "param_value2",
+          "param3" => "param_value3"
       }
     end
 
@@ -135,6 +179,13 @@ describe HttpStub::Models::Stub do
       the_stub.to_s.should match(/get/)
     end
 
+    it "should return a string containing the stubbed headers" do
+      stub_headers.each_pair do |key, value|
+        the_stub.to_s.should match(/#{Regexp.escape(key)}/)
+        the_stub.to_s.should match(/#{Regexp.escape(value)}/)
+      end
+    end
+
     it "should return a string containing the stubbed parameters" do
       stub_parameters.each_pair do |key, value|
         the_stub.to_s.should match(/#{Regexp.escape(key)}/)

data/spec/lib/http_stub/server_integration_spec.rb

@@ -27,8 +27,12 @@ describe HttpStub::Server, "when the server is running" do
         (1..3).each { |i| response.body.should match(/#{escape_html("/path#{i}")}/) }
       end
 
+      it "should return a response whose body contains the headers of each activators stub" do
+        (1..3).each { |i| response.body.should match(/header#{i}:header_value#{i}/) }
+      end
+
       it "should return a response whose body contains the parameters of each activators stub" do
-        (1..3).each { |i| response.body.should match(/param#{i}=value#{i}/) }
+        (1..3).each { |i| response.body.should match(/param#{i}=param_value#{i}/) }
       end
 
       it "should return a response whose body contains the response status of each activators stub" do
@@ -62,8 +66,12 @@ describe HttpStub::Server, "when the server is running" do
           (1..3).each { |i| response.body.should match(/#{escape_html("/path#{i}")}/) }
         end
 
+        it "should return a response whose body contains the headers of each stub" do
+          (1..3).each { |i| response.body.should match(/header#{i}:header_value#{i}/) }
+        end
+
         it "should return a response whose body contains the parameters of each stub" do
-          (1..3).each { |i| response.body.should match(/param#{i}=value#{i}/) }
+          (1..3).each { |i| response.body.should match(/param#{i}=param_value#{i}/) }
         end
 
         it "should return a response whose body contains the response status of each stub" do

data/spec/spec_helper.rb

@@ -1,11 +1,12 @@
 require 'simplecov'
 SimpleCov.start do
   add_filter "/spec/"
-  minimum_coverage 96.1
+  minimum_coverage 96.5
   refuse_coverage_drop
 end if ENV["coverage"]
 
 require 'rack/test'
+require 'httparty'
 require 'nokogiri'
 
 require File.expand_path('../../lib/http_stub/start_server_rake_task', __FILE__)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: http_stub
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.5.0
   prerelease: 
 platform: ruby
 authors:
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-03-03 00:00:00.000000000 Z
+date: 2013-03-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sinatra
@@ -197,6 +197,8 @@ files:
 - ./lib/http_stub/configurer.rb
 - ./lib/http_stub/controllers/stub_activator_controller.rb
 - ./lib/http_stub/controllers/stub_controller.rb
+- ./lib/http_stub/hash_extensions.rb
+- ./lib/http_stub/models/headers.rb
 - ./lib/http_stub/models/parameters.rb
 - ./lib/http_stub/models/registry.rb
 - ./lib/http_stub/models/stub.rb
@@ -215,6 +217,8 @@ files:
 - ./spec/lib/http_stub/configurer_integration_spec.rb
 - ./spec/lib/http_stub/controllers/stub_activator_controller_spec.rb
 - ./spec/lib/http_stub/controllers/stub_controller_spec.rb
+- ./spec/lib/http_stub/hash_extensions_spec.rb
+- ./spec/lib/http_stub/models/headers_spec.rb
 - ./spec/lib/http_stub/models/parameters_spec.rb
 - ./spec/lib/http_stub/models/registry_spec.rb
 - ./spec/lib/http_stub/models/stub_activator_spec.rb
@@ -246,7 +250,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 3385338799402198881
+      hash: -2534473441515686622
 requirements: []
 rubyforge_project: http_stub
 rubygems_version: 1.8.25
@@ -258,6 +262,8 @@ test_files:
 - ./spec/lib/http_stub/configurer_integration_spec.rb
 - ./spec/lib/http_stub/controllers/stub_activator_controller_spec.rb
 - ./spec/lib/http_stub/controllers/stub_controller_spec.rb
+- ./spec/lib/http_stub/hash_extensions_spec.rb
+- ./spec/lib/http_stub/models/headers_spec.rb
 - ./spec/lib/http_stub/models/parameters_spec.rb
 - ./spec/lib/http_stub/models/registry_spec.rb
 - ./spec/lib/http_stub/models/stub_activator_spec.rb