http_stub 0.22.4 → 0.23.0

data/spec/lib/http_stub/{server/formatted_hash_spec.rb → extensions/core/hash/formatted_spec.rb}

@@ -1,13 +1,11 @@
-describe HttpStub::Server::FormattedHash do
+describe HttpStub::Extensions::Core::Hash::Formatted do
+
+  let(:testable_class) { Class.new(::Hash).tap { |hash_class| hash_class.send(:include, described_class) } }
 
   let(:underlying_hash)     { {} }
   let(:key_value_delimiter) { "=" }
 
-  let(:formatted_hash) { described_class.new(underlying_hash, key_value_delimiter) }
-
-  it "is a Hash" do
-    expect(formatted_hash).to be_a(Hash)
-  end
+  let(:formatted_hash) { testable_class.new(underlying_hash, key_value_delimiter) }
 
   describe "#to_s" do
 

data/spec/lib/http_stub/{hash_with_indifferent_and_insensitive_access_spec.rb → extensions/core/hash/indifferent_and_insensitive_access_spec.rb}

@@ -1,10 +1,14 @@
-describe HttpStub::HashWithIndifferentAndInsensitiveAccess do
+describe HttpStub::Extensions::Core::Hash::IndifferentAndInsensitiveAccess do
 
-  let(:enhanced_hash) { HttpStub::HashWithIndifferentAndInsensitiveAccess.new(original_hash) }
+  let(:testable_class) { Class.new(::Hash).tap { |hash_class| hash_class.send(:include, described_class) } }
+
+  let(:indifferent_and_insensitive_access_hash) { testable_class.new }
+
+  before(:example) { indifferent_and_insensitive_access_hash.merge!(original_hash) }
 
   describe "#[]" do
 
-    subject { enhanced_hash[key] }
+    subject { indifferent_and_insensitive_access_hash[key] }
 
     context "when the original hash contains symbol keys" do
 
@@ -90,7 +94,7 @@ describe HttpStub::HashWithIndifferentAndInsensitiveAccess do
 
     end
 
-    context "when the original hash string keys" do
+    context "when the original hash contains string keys" do
 
       let(:original_hash) { { "key" => "value", "another_key" => "another value" } }
 

data/spec/lib/http_stub/extensions/core/hash/with_indifferent_and_insensitive_access_spec.rb

@@ -0,0 +1,41 @@
+describe HttpStub::Extensions::Core::Hash::WithIndifferentAndInsensitiveAccess do
+
+  let(:hash_with_indifferent_and_insensitive_access) { described_class.new }
+
+  it "is a Hash" do
+    expect(hash_with_indifferent_and_insensitive_access).to be_a(::Hash)
+  end
+
+  it "has IndifferentAndInsensitiveAccess" do
+    expect(hash_with_indifferent_and_insensitive_access).to(
+      be_a(HttpStub::Extensions::Core::Hash::IndifferentAndInsensitiveAccess)
+    )
+  end
+
+  describe "constructor" do
+
+    let(:hash_with_indifferent_and_insensitive_access) { described_class.new(existing_hash) }
+
+    context "when provided an existing hash" do
+
+      let(:existing_hash) { { key: :value } }
+
+      it "creates an indifferent and insensitive hash that includes the entries from the provided hash" do
+        expect(hash_with_indifferent_and_insensitive_access).to include(existing_hash)
+      end
+
+    end
+
+    context "when provided nil" do
+
+      let(:existing_hash) { nil }
+
+      it "creates an empty indifferent and insensitive hash" do
+        expect(hash_with_indifferent_and_insensitive_access.empty?).to be(true)
+      end
+
+    end
+
+  end
+
+end

data/spec/lib/http_stub/extensions/core/hash_spec.rb

@@ -1,16 +1,10 @@
 describe HttpStub::Extensions::Core::Hash do
 
-  describe "#downcase_and_underscore_keys" do
+  describe "#underscore_keys" do
 
-    describe "when the hash contains keys which are strings" do
+    subject { hash.underscore_keys }
 
-      let(:hash) do
-        { "lower" => 1, "UPPER" => 2, "MiXeDcAsE" => 3 }
-      end
-
-      it "downcases the string keys" do
-        expect(hash.downcase_and_underscore_keys).to eql({ "lower" => 1, "upper" => 2, "mixedcase" => 3 })
-      end
+    describe "when the hash contains keys which are strings" do
 
       describe "and keys contain underscores and hyphens" do
 
@@ -19,9 +13,7 @@ describe HttpStub::Extensions::Core::Hash do
         end
 
         it "downcases the string keys" do
-          expect(hash.downcase_and_underscore_keys).to eql({ "has_underscore" => 1,
-                                                         "has_hypen" => 2,
-                                                         "has_underscore_and_hypen" => 3 })
+          expect(subject).to eql({ "has_underscore" => 1, "has_hypen" => 2, "has_underscore_and_hypen" => 3 })
         end
 
       end
@@ -34,120 +26,8 @@ describe HttpStub::Extensions::Core::Hash do
         { 1 => 2, :symbol => 3, nil => 4 }
       end
 
-      it "does not alter a hash" do
-        expect(hash.downcase_and_underscore_keys).to 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 "returns true" do
-          expect(hash.has_hash?(hash_parameter)).to be(true)
-        end
-
-      end
-
-      describe "and the hash contains more than those elements" do
-
-        let(:hash) { hash_parameter.merge("key4" => "value4") }
-
-        it "returns true" do
-          expect(hash.has_hash?(hash_parameter)).to 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 "returns false" do
-          expect(hash.has_hash?(hash_parameter)).to be(false)
-        end
-
-      end
-
-      describe "and the hash contains less than those elements" do
-
-        let(:hash) { { "key1" => "value1", "key3" => "value3" } }
-
-        it "returns false" do
-          expect(hash.has_hash?(hash_parameter)).to be(false)
-        end
-
-      end
-
-      describe "and the hash contains no elements" do
-
-        let(:hash) { {} }
-
-        it "returns false" do
-          expect(hash.has_hash?(hash_parameter)).to 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 "returns true" do
-          expect(hash.has_hash?(hash_parameter)).to be(true)
-        end
-
-      end
-
-      describe "when the hash contains elements" do
-
-        let(:hash) { { "key" => "value" } }
-
-        it "returns true" do
-          expect(hash.has_hash?(hash_parameter)).to 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 "returns true" do
-          expect(hash.has_hash?(hash_parameter)).to be(true)
-        end
-
-      end
-
-      describe "when the hash contains elements" do
-
-        let(:hash) { { "key" => "value" } }
-
-        it "returns true" do
-          expect(hash.has_hash?(hash_parameter)).to be(true)
-        end
-
+      it "does not alter the hash" do
+        expect(subject).to eql({ 1 => 2, :symbol => 3, nil => 4 })
       end
 
     end
@@ -157,18 +37,20 @@ describe HttpStub::Extensions::Core::Hash do
   describe "#with_indifferent_and_insensitive_access" do
 
     let(:hash)                             { { key: "value" } }
-    let(:indifferent_and_insensitive_hash) { instance_double(HttpStub::HashWithIndifferentAndInsensitiveAccess) }
+    let(:indifferent_and_insensitive_hash) do
+      instance_double(HttpStub::Extensions::Core::Hash::WithIndifferentAndInsensitiveAccess)
+    end
 
     subject { hash.with_indifferent_and_insensitive_access }
 
     before(:example) do
-      allow(HttpStub::HashWithIndifferentAndInsensitiveAccess).to(
+      allow(HttpStub::Extensions::Core::Hash::WithIndifferentAndInsensitiveAccess).to(
         receive(:new).and_return(indifferent_and_insensitive_hash)
       )
     end
 
     it "creates a hash with indifferent and insensitive access containing the current hash" do
-      expect(HttpStub::HashWithIndifferentAndInsensitiveAccess).to receive(:new).with(hash)
+      expect(HttpStub::Extensions::Core::Hash::WithIndifferentAndInsensitiveAccess).to receive(:new).with(hash)
 
       subject
     end

data/spec/lib/http_stub/server/application_spec.rb

@@ -285,7 +285,7 @@ describe HttpStub::Server::Application do
     before(:example) { allow(stub_controller).to receive(:match).and_return(stub_response) }
 
     it "attempts to match the request to a stub response via the stub controller" do
-      expect(stub_controller).to receive(:match).with(an_instance_of(HttpStub::Server::Request), anything)
+      expect(stub_controller).to receive(:match).with(an_instance_of(HttpStub::Server::Request::Request), anything)
 
       subject
     end

data/spec/lib/http_stub/server/payload_file_consolidator_spec.rb

@@ -5,7 +5,7 @@ describe HttpStub::Server::Stub::PayloadFileConsolidator do
   describe "::consolidate!" do
 
     let(:parameters) { {} }
-    let(:request)    { instance_double(HttpStub::Server::Request, parameters: parameters) }
+    let(:request)    { instance_double(HttpStub::Server::Request::Request, parameters: parameters) }
 
     subject { consolidator.consolidate!(payload, request) }
 

data/spec/lib/http_stub/server/request/headers_spec.rb

@@ -0,0 +1,89 @@
+describe HttpStub::Server::Request::Headers do
+
+  let(:header_hash) { {} }
+
+  let(:headers) { described_class.new(header_hash) }
+
+  it "is a hash with indifferent and insensitive access" do
+    expect(headers).to be_a(HttpStub::Extensions::Core::Hash::IndifferentAndInsensitiveAccess)
+  end
+
+  describe "::create" do
+
+    let(:non_header_env_elements) do
+      {
+        "rack.version"       => [1, 3],
+        "rack.multithreaded" => true,
+        "rack.multiprocess"  => false
+      }
+    end
+    let(:env)          { non_header_env_elements.merge(header_env_elements) }
+    let(:rack_request) { instance_double(Rack::Request, env: env) }
+
+    subject { described_class.create(rack_request) }
+
+    describe "when the request contains environment entries in upper case" do
+
+      let(:header_env_elements) { (1..3).each_with_object({}) { |i, result| result["KEY_#{i}"] = "value#{i}" } }
+
+      it "returns a hash containing those entries" do
+        expect(subject).to eql("KEY_1" => "value1", "KEY_2" => "value2", "KEY_3" => "value3")
+      end
+
+    end
+
+    describe "when the request contains environment entries in upper case prefixed with 'HTTP_'" do
+
+      let(:header_env_elements) { (1..3).each_with_object({}) { |i, result| result["HTTP_KEY_#{i}"] = "value#{i}" } }
+
+      it "returns a hash containing those entries with the prefix removed" do
+        expect(subject).to include("KEY_1" => "value1", "KEY_2" => "value2", "KEY_3" => "value3")
+      end
+
+    end
+
+    describe "when only has environment entries in lower case" do
+
+      let(:header_env_elements) { {} }
+
+      it "returns an empty hash" do
+        expect(subject).to eql({})
+      end
+
+    end
+
+  end
+
+  describe "#to_s" do
+
+    subject { headers.to_s }
+
+    context "when headers are provided" do
+
+      let(:header_hash) { (1..3).each_with_object({}) { |i, result| result["KEY_#{i}"] = "VALUE_#{i}" } }
+
+      it "returns a string with each header name and value separated by ':'" do
+        result = subject
+
+        headers.each { |name, value| expect(result).to match(/#{name}:#{value}/) }
+      end
+
+      it "separates each header with comma for readability" do
+        expect(subject).to match(/KEY_\d.VALUE_\d, KEY_\d.VALUE_\d, KEY_\d.VALUE_\d/)
+      end
+
+    end
+
+    context "when headers are not provided" do
+
+      let(:header_hash) { {} }
+
+      it "returns an empty string" do
+        expect(subject).to eql("")
+      end
+
+    end
+
+  end
+
+end

data/spec/lib/http_stub/server/request/parameters_spec.rb

@@ -0,0 +1,60 @@
+describe HttpStub::Server::Request::Parameters do
+
+  let(:parameter_hash) { {} }
+
+  let(:parameters) { described_class.new(parameter_hash) }
+
+  it "is a hash with indifferent access" do
+    expect(parameters).to be_a(HashWithIndifferentAccess)
+  end
+
+  describe "::create" do
+
+    let(:rack_params)  { { "some_parameter_name" => "some parameter value" } }
+    let(:rack_request) { instance_double(Rack::Request, params: rack_params) }
+
+    subject { described_class.create(rack_request) }
+
+    it "returns http stub request parameters" do
+      expect(subject).to be_an_instance_of(described_class)
+    end
+
+    it "returns parameters containing the rack request parameters" do
+      expect(subject).to eql(rack_params)
+    end
+
+  end
+
+  describe "#to_s" do
+
+    subject { parameters.to_s }
+
+    context "when parameters are provided" do
+
+      let(:parameter_hash) { (1..3).each_with_object({}) { |i, result| result["key#{i}"] = "value#{i}" } }
+
+      it "returns a string containing each parameter formatted as a conventional request parameter" do
+        result = subject
+
+        parameter_hash.each { |key, value| expect(result).to match(/#{key}=#{value}/) }
+      end
+
+      it "separates each parameter with the conventional request parameter delimiter" do
+        expect(subject).to match(/key\d.value\d\&key\d.value\d\&key\d.value\d/)
+      end
+
+    end
+
+    context "when parameters are not provided" do
+
+      let(:parameter_hash) { {} }
+
+      it "returns an empty string" do
+        expect(subject).to eql("")
+      end
+
+    end
+
+  end
+
+end

data/spec/lib/http_stub/server/request/request_spec.rb

@@ -0,0 +1,84 @@
+describe HttpStub::Server::Request::Request do
+
+  let(:rack_path_info)      { "/rack/path/info" }
+  let(:rack_request_method) { "some method" }
+  let(:rack_env)            { { "some_env_name" => "some env value" } }
+  let(:rack_parameters)     { { "some_parameter_name" => "some parameter value" } }
+  let(:rack_body)           { "some request body" }
+  let(:rack_request)        do
+    instance_double(Rack::Request, path_info:      rack_path_info,
+                                   request_method: rack_request_method,
+                                   env:            rack_env,
+                                   params:         rack_parameters,
+                                   body:           StringIO.new(rack_body))
+  end
+
+  let(:server_request) { described_class.new(rack_request) }
+
+  describe "#uri" do
+
+    it "is the rack request path information" do
+      expect(server_request.uri).to eql(rack_path_info)
+    end
+
+  end
+
+  describe "#method" do
+
+    subject { server_request.method }
+
+    it "is the rack request method" do
+      expect(subject).to eql(rack_request_method)
+    end
+
+  end
+
+  describe "#headers" do
+
+    subject { server_request.headers }
+
+    it "creates http stub request headers from the rack request" do
+      expect(HttpStub::Server::Request::Headers).to receive(:create).with(rack_request)
+
+      subject
+    end
+
+    it "returns the created http stub request headers" do
+      http_stub_request_headers = instance_double(HttpStub::Server::Request::Headers)
+      allow(HttpStub::Server::Request::Headers).to receive(:create).and_return(http_stub_request_headers)
+
+      expect(subject).to eql(http_stub_request_headers)
+    end
+
+  end
+
+  describe "#parameters" do
+
+    subject { server_request.parameters }
+
+    it "creates http stub request parameters from the rack request" do
+      expect(HttpStub::Server::Request::Parameters).to receive(:create).with(rack_request)
+
+      subject
+    end
+
+    it "returns the created http stub request parameters" do
+      http_stub_request_parameters = instance_double(HttpStub::Server::Request::Parameters)
+      allow(HttpStub::Server::Request::Parameters).to receive(:create).and_return(http_stub_request_parameters)
+
+      expect(subject).to eql(http_stub_request_parameters)
+    end
+
+  end
+
+  describe "#body" do
+
+    subject { server_request.body }
+
+    it "is the read rack request body" do
+      expect(subject).to eql(rack_body)
+    end
+
+  end
+
+end