http_stub 0.7.0 → 0.7.1

data/lib/http_stub.rb

@@ -11,6 +11,8 @@ 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/request_header_parser', __FILE__)
 require File.expand_path('../http_stub/models/stub_uri', __FILE__)
 require File.expand_path('../http_stub/models/stub_headers', __FILE__)
@@ -21,8 +23,10 @@ require File.expand_path('../http_stub/models/registry', __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/stub_request', __FILE__)
-require File.expand_path('../http_stub/configurer/stub_activator_request', __FILE__)
+require File.expand_path('../http_stub/configurer/request/regexpable_value', __FILE__)
+require File.expand_path('../http_stub/configurer/request/hash_with_regexpable_values', __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__)
 require File.expand_path('../http_stub/configurer/patient_command_chain', __FILE__)
 require File.expand_path('../http_stub/configurer/impatient_command_chain', __FILE__)

data/lib/http_stub/configurer.rb

@@ -18,12 +18,12 @@ module HttpStub
       end
 
       def stub_activator(activation_uri, stub_uri, options)
-        request = HttpStub::Configurer::StubActivatorRequest.new(activation_uri, stub_uri, options)
+        request = HttpStub::Configurer::Request::StubActivator.new(activation_uri, stub_uri, options)
         handle(request: request, description: "registering activator '#{activation_uri}'")
       end
 
       def stub!(uri, options)
-        request = HttpStub::Configurer::StubRequest.new(uri, options)
+        request = HttpStub::Configurer::Request::Stub.new(uri, options)
         handle(request: request, description: "stubbing '#{uri}'", resetable: true)
       end
 

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

@@ -0,0 +1,22 @@
+module HttpStub
+  module Configurer
+    module Request
+
+      class HashWithRegexpableValues
+
+        def initialize(hash)
+          @hash = hash.reduce({}) do |result, entry|
+            result[entry[0]] = HttpStub::Configurer::Request::RegexpableValue.new(entry[1])
+            result
+          end
+        end
+
+        def to_json(*args)
+          @hash.to_json(args)
+        end
+
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,18 @@
+module HttpStub
+  module Configurer
+    module Request
+
+      class RegexpableValue
+
+        def initialize(value)
+          @value = value
+        end
+
+        def to_s
+          @value.is_a?(Regexp) ? "regexp:#{@value.source.gsub(/\\/, "")}" : @value
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+module HttpStub
+  module Configurer
+    module Request
+
+      class Stub < Net::HTTP::Post
+
+        def initialize(uri, options)
+          super("/stubs")
+          self.content_type = "application/json"
+          self.body = {
+              "uri" => HttpStub::Configurer::Request::RegexpableValue.new(uri),
+              "method" => options[:method],
+              "headers" => HttpStub::Configurer::Request::HashWithRegexpableValues.new(options[:headers] || {}),
+              "parameters" => HttpStub::Configurer::Request::HashWithRegexpableValues.new(options[:parameters] || {}),
+              "response" => {
+                  "status" => options[:response][:status] || 200,
+                  "body" => options[:response][:body]
+              }
+          }.to_json
+        end
+
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,18 @@
+module HttpStub
+  module Configurer
+    module Request
+
+      class StubActivator < Net::HTTP::Post
+
+        def initialize(activation_uri, stub_uri, options)
+          super("/stubs/activators")
+          stub_request = HttpStub::Configurer::Request::Stub.new(stub_uri, options)
+          self.content_type = stub_request.content_type
+          self.body = JSON.parse(stub_request.body).merge({ "activation_uri" => activation_uri }).to_json
+        end
+
+      end
+
+    end
+  end
+end

data/lib/http_stub/models/hash_with_regexpable_values.rb

@@ -0,0 +1,20 @@
+module HttpStub
+  module Models
+
+    class HashWithRegexpableValues < Hash
+
+      def initialize(hash)
+        hash.each { |entry| self[entry[0]] = HttpStub::Models::RegexpableValue.new(entry[1]) }
+      end
+
+      def match?(other_hash)
+        !(self.find do |key_and_regexpable_value|
+          other_value = other_hash[key_and_regexpable_value[0]]
+          !(other_value && key_and_regexpable_value[1].match?(other_value))
+        end)
+      end
+
+    end
+
+  end
+end

data/lib/http_stub/models/regexpable_value.rb

@@ -0,0 +1,22 @@
+module HttpStub
+  module Models
+
+    class RegexpableValue
+
+      def initialize(value)
+        @value = value
+      end
+
+      def match?(other_value)
+        match_data = @value.match(/^regexp:(.*)/)
+        match_data ? !!Regexp.new(match_data[1]).match(other_value) : other_value == @value
+      end
+
+      def to_s
+        @value
+      end
+
+    end
+
+  end
+end

data/lib/http_stub/models/stub_headers.rb

@@ -4,15 +4,15 @@ module HttpStub
     class StubHeaders
 
       def initialize(headers)
-        @headers = headers || {}
+        @headers = HttpStub::Models::HashWithRegexpableValues.new((headers || {}).downcase_and_underscore_keys)
       end
 
       def match?(request)
-        headers_in(request).downcase_and_underscore_keys.has_hash?(@headers.downcase_and_underscore_keys)
+        @headers.match?(headers_in(request).downcase_and_underscore_keys)
       end
 
       def to_s
-        @headers ? @headers.map { |key_and_value| key_and_value.join(":") }.join(", ") : ""
+        @headers ? @headers.map { |key_and_value| key_and_value.map(&:to_s).join(":") }.join(", ") : ""
       end
 
       private

data/lib/http_stub/models/stub_parameters.rb

@@ -4,15 +4,15 @@ module HttpStub
     class StubParameters
 
       def initialize(parameters)
-        @parameters = parameters
+        @parameters = HttpStub::Models::HashWithRegexpableValues.new(parameters || {})
       end
 
       def match?(request)
-        request.params.has_hash?(@parameters)
+        @parameters.match?(request.params)
       end
 
       def to_s
-        @parameters ? @parameters.map { |key_and_value| key_and_value.join("=") }.join("&") : ""
+        @parameters ? @parameters.map { |key_and_value| key_and_value.map(&:to_s).join("=") }.join("&") : ""
       end
 
     end

data/lib/http_stub/models/stub_uri.rb

@@ -4,16 +4,15 @@ module HttpStub
     class StubUri
 
       def initialize(uri)
-        @uri = uri
+        @uri = HttpStub::Models::RegexpableValue.new(uri)
       end
 
       def match?(request)
-        match_data = @uri.match(/^regexp:(.*)/)
-        match_data ? !!Regexp.new(match_data[1]).match(request.path_info) : request.path_info == @uri
+        @uri.match?(request.path_info)
       end
 
       def to_s
-        @uri
+        @uri.to_s
       end
 
     end

data/lib/http_stub/version.rb

@@ -1,3 +1,3 @@
 module HttpStub
-  VERSION = "0.7.0"
+  VERSION = "0.7.1"
 end

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

@@ -0,0 +1,35 @@
+describe HttpStub::Configurer::Request::HashWithRegexpableValues do
+
+  let(:hash_with_regexpable_values) { HttpStub::Configurer::Request::HashWithRegexpableValues.new(raw_hash) }
+
+  describe "#to_json" do
+
+    describe "when provided a hash with multiple entries" do
+
+      let(:raw_hash) { { key1: "value1", key2: "value2", key3: "value3" } }
+
+      it "should return a json representation of the hash whose values are their regexpable form" do
+        raw_hash.values.each do |value|
+          regexpable_value = double(HttpStub::Configurer::Request::RegexpableValue, to_s: "regexpable_#{value}")
+          HttpStub::Configurer::Request::RegexpableValue.stub!(:new).with(value).and_return(regexpable_value)
+        end
+
+        expected_json = { key1: "regexpable_value1", key2: "regexpable_value2", key3: "regexpable_value3" }.to_json
+        hash_with_regexpable_values.to_json.should eql(expected_json)
+      end
+
+    end
+
+    describe "when provided an empty hash" do
+
+      let(:raw_hash) { {} }
+
+      it "should return a json representation of an empty hash" do
+        hash_with_regexpable_values.to_json.should eql({}.to_json)
+      end
+
+    end
+
+  end
+
+end

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

@@ -0,0 +1,55 @@
+describe HttpStub::Configurer::Request::RegexpableValue do
+
+  let(:regexpable_value) { HttpStub::Configurer::Request::RegexpableValue.new(raw_value) }
+
+  describe "#to_s" do
+
+    describe "when the option's value is a regular expression" do
+
+      let(:raw_value) { /.+?[a-z]/ }
+
+      it "should return a string prefixed by 'regexp:'" do
+        regexpable_value.to_s.should start_with("regexp:")
+      end
+
+      it "should contain the regular expression converted to a string" do
+        regexpable_value.to_s.should end_with(".+?[a-z]")
+      end
+
+      describe "and the regular expression contain path separators" do
+
+        let(:raw_value) { /\/some\/path/ }
+
+        it "should represent the path separators as a single forward-slash" do
+          regexpable_value.to_s.should end_with("/some/path")
+        end
+
+      end
+
+    end
+
+    describe "when the option's value is a string" do
+
+      let(:raw_value) { "some string value" }
+
+      it "should return the value unaltered" do
+        regexpable_value.to_s.should eql(raw_value)
+      end
+
+    end
+
+  end
+
+  describe "#inspect" do
+
+    let(:raw_value) { "some raw value" }
+
+    it "should delegate to #to_s" do
+      regexpable_value.should_receive(:to_s).and_return("some raw value as a string")
+
+      regexpable_value.inspect.should eql("some raw value as a string")
+    end
+
+  end
+
+end

data/spec/lib/http_stub/configurer/{stub_activator_request_spec.rb → request/stub_activator_spec.rb}

@@ -1,4 +1,4 @@
-describe HttpStub::Configurer::StubActivatorRequest do
+describe HttpStub::Configurer::Request::StubActivator do
 
   describe "#initialize" do
 
@@ -6,7 +6,7 @@ describe HttpStub::Configurer::StubActivatorRequest do
     let(:stub_request_content_type) { "Some content type" }
     let(:stub_request) { double("StubRequest", :content_type => stub_request_content_type, :body => stub_request_body) }
 
-    before(:each) { HttpStub::Configurer::StubRequest.stub!(:new).and_return(stub_request) }
+    before(:each) { HttpStub::Configurer::Request::Stub.stub!(:new).and_return(stub_request) }
 
     describe "when provided an activation uri, stub uri and stub options" do
 
@@ -14,7 +14,7 @@ describe HttpStub::Configurer::StubActivatorRequest do
       let(:stub_uri) { "Some stub URI" }
       let(:stub_options) { "Some options" }
 
-      let(:request) { HttpStub::Configurer::StubActivatorRequest.new(activation_uri, stub_uri, stub_options) }
+      let(:request) { HttpStub::Configurer::Request::StubActivator.new(activation_uri, stub_uri, stub_options) }
       let(:request_body) { JSON.parse(request.body) }
 
       it "should create a HTTP POST request" do
@@ -32,7 +32,7 @@ describe HttpStub::Configurer::StubActivatorRequest do
       describe "generates a JSON body which" do
 
         it "should contain entries for a stub request" do
-          HttpStub::Configurer::StubRequest.should_receive(:new).with(stub_uri, stub_options).and_return(stub_request)
+          HttpStub::Configurer::Request::Stub.should_receive(:new).with(stub_uri, stub_options).and_return(stub_request)
 
           request_body.should include(JSON.parse(stub_request_body))
         end

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

@@ -0,0 +1,152 @@
+describe HttpStub::Configurer::Request::Stub do
+
+  describe "#initialize" do
+
+    describe "when provided a uri and stub options" do
+
+      let(:uri) { "/some/uri" }
+      let(:stub_method) { "Some Method" }
+      let(:headers) { { "header_name" => "value" } }
+      let(:parameters) { { "parameter_name" => "value" } }
+      let(:response_status) { 500 }
+      let(:response_body) { "Some body" }
+
+      let(:stub_options) do
+        {
+            method: stub_method,
+            headers: headers,
+            parameters: parameters,
+            response: {
+                status: response_status,
+                body: response_body
+            }
+        }
+      end
+
+      let(:request) { HttpStub::Configurer::Request::Stub.new(uri, stub_options) }
+      let(:request_body) { JSON.parse(request.body) }
+
+      before(:each) do
+        HttpStub::Configurer::Request::HashWithRegexpableValues.stub!(:new).and_return(
+            double(HttpStub::Configurer::Request::HashWithRegexpableValues).as_null_object
+        )
+      end
+
+      it "should create a HTTP POST request" do
+        request.method.should eql("POST")
+      end
+
+      it "should submit the request to '/stubs'" do
+        request.path.should eql("/stubs")
+      end
+
+      it "should set the content type to json" do
+        request.content_type.should eql("application/json")
+      end
+
+      it "should create a regexpable representation of the uri" do
+        HttpStub::Configurer::Request::RegexpableValue.should_receive(:new).with(uri)
+
+        request
+      end
+
+      describe "when a header option is provided" do
+
+        it "should create a regexpable representation of the headers" do
+          HttpStub::Configurer::Request::HashWithRegexpableValues.should_receive(:new).with(headers)
+
+          request
+        end
+
+      end
+
+      describe "when no header is provided" do
+
+        let(:headers) { nil }
+
+        it "should create a regexpable representation of an empty header hash" do
+          HttpStub::Configurer::Request::HashWithRegexpableValues.should_receive(:new).with({})
+
+          request
+        end
+
+      end
+
+      describe "when a parameter option is provided" do
+
+        it "should create a regexpable representation of the parameters" do
+          HttpStub::Configurer::Request::HashWithRegexpableValues.should_receive(:new).with(parameters)
+
+          request
+        end
+
+      end
+
+      describe "when no parameter option is provided" do
+
+        let(:parameters) { nil }
+
+        it "should create a regexpable representation of an empty parameter hash" do
+          HttpStub::Configurer::Request::HashWithRegexpableValues.should_receive(:new).with({})
+
+          request
+        end
+
+      end
+
+      describe "generates a JSON body which" do
+
+        it "should have an entry containing the string representation of the uri" do
+          uri_value = double(HttpStub::Configurer::Request::RegexpableValue, to_s: "uri as a string")
+          HttpStub::Configurer::Request::RegexpableValue.stub!(:new).and_return(uri_value)
+
+          request_body.should include({ "uri" => "uri as a string" })
+        end
+
+        it "should have an entry for the method option" do
+          request_body.should include({ "method" => stub_method })
+        end
+
+        it "should have an entry containing the string representation of the headers" do
+          hash_value = double(HttpStub::Configurer::Request::HashWithRegexpableValues, to_s: "headers as string")
+          HttpStub::Configurer::Request::HashWithRegexpableValues.stub!(:new).with(headers).and_return(hash_value)
+
+          request_body.should include({ "headers" => "headers as string" })
+        end
+
+        it "should have an entry containing the string representation of the parameters" do
+          hash_value = double(HttpStub::Configurer::Request::HashWithRegexpableValues, to_s: "parameters as string")
+          HttpStub::Configurer::Request::HashWithRegexpableValues.stub!(:new).with(parameters).and_return(hash_value)
+
+          request_body.should include({ "parameters" => "parameters as string" })
+        end
+
+        describe "when a status response option is provided" do
+
+          it "should have a response entry for the option" do
+            request_body["response"].should include({ "status" => response_status })
+          end
+
+        end
+
+        describe "when no status response option is provided" do
+
+          let(:response_status) { nil }
+
+          it "should have a response entry with status code of 200" do
+            request_body["response"].should include({ "status" => 200 })
+          end
+
+        end
+
+        it "should have an entry for the response body option" do
+          request_body["response"].should include({ "body" => response_body })
+        end
+
+      end
+
+    end
+
+  end
+
+end