http_stub 0.22.4 → 0.23.0

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

@@ -1,111 +1,22 @@
 describe HttpStub::Server::Request do
 
-  let(:rack_path_info)      { "/rack/path/info" }
-  let(:rack_request_method) { "some method" }
-  let(:rack_parameters)     { { "parameter_key" => "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,
-                                   params:         rack_parameters,
-                                   body:           StringIO.new(rack_body))
-  end
-
-  let(:server_request) { described_class.new(rack_request) }
-
-  before(:example) do
-    allow(HttpStub::Server::HeaderParser).to receive(:parse).and_return({})
-    allow(HttpStub::Server::FormattedHash).to receive(:new)
-  end
-
-  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
-
-    let(:parsed_headers) { { "parsed_header_key" => "parsed header value" } }
-    let(:formatted_hash) { instance_double(HttpStub::Server::FormattedHash) }
-
-    subject { server_request.headers }
-
-    before(:example) do
-      allow(HttpStub::Server::HeaderParser).to receive(:parse).and_return(parsed_headers)
-      allow(HttpStub::Server::FormattedHash).to receive(:new).with(parsed_headers, anything).and_return(formatted_hash)
-    end
-
-    it "parses the headers from the rack request via the header parser" do
-      expect(HttpStub::Server::HeaderParser).to receive(:parse).with(rack_request)
-
-      subject
-    end
+  let(:rack_request) { instance_double(Rack::Request) }
 
-    it "creates a formatted hash containing the parsed headers" do
-      expect(HttpStub::Server::FormattedHash).to receive(:new).with(parsed_headers, anything)
+  describe "::create" do
 
-      subject
-    end
-
-    it "creates a formatted hash formatted by a ':' request value delimiter" do
-      expect(HttpStub::Server::FormattedHash).to receive(:new).with(anything, ":")
-
-      subject
-    end
-
-    it "is the formattted hash" do
-      expect(subject).to eql(formatted_hash)
-    end
-
-  end
-
-  describe "#parameters" do
-
-    let(:formatted_hash) { instance_double(HttpStub::Server::FormattedHash) }
+    subject { described_class.create(rack_request) }
 
-    subject { server_request.parameters }
-
-    before(:example) do
-      allow(HttpStub::Server::FormattedHash).to receive(:new).with(rack_parameters, anything).and_return(formatted_hash)
-    end
-
-    it "creates a formatted hash containing the rack request parameters" do
-      expect(HttpStub::Server::FormattedHash).to receive(:new).with(rack_parameters, anything)
-
-      subject
-    end
-
-    it "creates a formatted hash with a '=' request value delimiter" do
-      expect(HttpStub::Server::FormattedHash).to receive(:new).with(anything, "=")
+    it "creates a request for the rack request" do
+      expect(HttpStub::Server::Request::Request).to receive(:new).with(rack_request)
 
       subject
     end
 
-    it "is the formatted hash" do
-      expect(subject).to eql(formatted_hash)
-    end
-
-  end
-
-  describe "#body" do
-
-    subject { server_request.body }
+    it "returns the created request" do
+      http_stub_request = instance_double(HttpStub::Server::Request::Request)
+      allow(HttpStub::Server::Request::Request).to receive(:new).and_return(http_stub_request)
 
-    it "is the read rack request body" do
-      expect(subject).to eql(rack_body)
+      expect(subject).to eql(http_stub_request)
     end
 
   end

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

@@ -14,7 +14,7 @@ describe HttpStub::Server::Response do
 
   describe "::success" do
 
-    subject { HttpStub::Server::Response::success }
+    subject { described_class.success }
 
     it_behaves_like "a success response"
 
@@ -63,11 +63,7 @@ describe HttpStub::Server::Response do
     end
 
     it "has no body" do
-      expect(subject.body).to be(nil)
-    end
-
-    it "is empty" do
-      expect(subject).to be_empty
+      expect(subject.body.provided?).to be(false)
     end
 
   end

data/spec/lib/http_stub/server/scenario/controller_spec.rb

@@ -1,7 +1,7 @@
 describe HttpStub::Server::Scenario::Controller do
 
   let(:request_uri)       { "/some/request/path" }
-  let(:request)           { instance_double(HttpStub::Server::Request, uri: request_uri) }
+  let(:request)           { instance_double(HttpStub::Server::Request::Request, uri: request_uri) }
   let(:logger)            { instance_double(Logger) }
   let(:payload)           { HttpStub::ScenarioFixture.new.server_payload }
   let(:stubs)             { (1..3).map { instance_double(HttpStub::Server::Stub::Stub) } }

data/spec/lib/http_stub/server/scenario/parser_spec.rb

@@ -6,7 +6,9 @@ describe HttpStub::Server::Scenario::Parser do
 
     let(:parameters) { {} }
     let(:body_hash)  { {} }
-    let(:request)    { instance_double(HttpStub::Server::Request, parameters: parameters, body: body_hash.to_json) }
+    let(:request)    do
+      instance_double(HttpStub::Server::Request::Request, parameters: parameters, body: body_hash.to_json)
+    end
 
     subject { parser.parse(request) }
 

data/spec/lib/http_stub/server/stub/controller_spec.rb

@@ -1,6 +1,6 @@
 describe HttpStub::Server::Stub::Controller do
 
-  let(:request)  { instance_double(HttpStub::Server::Request) }
+  let(:request)  { instance_double(HttpStub::Server::Request::Request) }
   let(:logger)   { instance_double(Logger) }
   let(:payload)  { HttpStub::StubFixture.new.server_payload }
   let(:response) { instance_double(HttpStub::Server::Stub::Response::Base) }
@@ -62,10 +62,17 @@ describe HttpStub::Server::Stub::Controller do
 
       let(:matched_stub) { the_stub }
 
-      it "returns the stubs response" do
-        expect(the_stub).to receive(:response).and_return(response)
+      it "calculates the stubs response based on the request" do
+        expect(the_stub).to receive(:response_for).with(request)
 
-        expect(subject).to eql(response)
+        subject
+      end
+
+      it "returns the calculated response" do
+        calculated_response = instance_double(HttpStub::Server::Stub::Response::Base)
+        allow(the_stub).to receive(:response_for).and_return(calculated_response)
+
+        expect(subject).to eql(calculated_response)
       end
 
     end

data/spec/lib/http_stub/server/stub/empty_spec.rb

@@ -53,6 +53,16 @@ describe HttpStub::Server::Stub::Empty do
 
   end
 
+  describe "#response_for" do
+
+    let(:request) { instance_double(HttpStub::Server::Request) }
+
+    it "returns unchanged empty stub" do
+      expect(empty_stub.response_for(request)).to eql(empty_stub)
+    end
+
+  end
+
   describe "#to_s" do
 
     it "returns an empty string" do

data/spec/lib/http_stub/server/stub/match/hash_matcher_spec.rb

@@ -0,0 +1,122 @@
+describe HttpStub::Server::Stub::Match::HashMatcher do
+
+  let(:stub_hash) do
+    (1..3).each_with_object({}) { |i, result| result["key#{i}"] = "stub value #{i}" }
+  end
+
+  let(:string_value_matcher) { HttpStub::Server::Stub::Match::StringValueMatcher }
+
+  describe "::match?" do
+
+    let(:actual_hash) { {} }
+
+    subject { described_class.match?(stub_hash, actual_hash) }
+    
+    context "when the stub hash contains multiple entries" do
+
+      it "returns the result of evaluating a match for each stub value" do
+        stub_hash.values.each do |stub_value|
+          allow(string_value_matcher).to receive(:match?).with(stub_value, anything).and_return(true)
+        end
+
+        expect(subject).to be(true)
+      end
+
+      context "and the actual hash has the same number of entries" do
+
+        context "and the keys match" do
+
+          let(:actual_hash) do
+            (1..3).each_with_object({}) { |i, result| result["key#{i}"] = "actual value #{i}" }
+          end
+
+          context "and the values match" do
+
+            before(:example) { allow(string_value_matcher).to receive(:match?).and_return(true) }
+
+            it "returns true" do
+              expect(subject).to be(true)
+            end
+            
+          end
+
+          context "and a value does not match" do
+
+            before(:example) do
+              allow(string_value_matcher).to receive(:match?).and_return(true)
+              allow(string_value_matcher).to receive(:match?).with("stub value 2", "actual value 2").and_return(false)
+            end
+
+            it "returns false" do
+              expect(subject).to be(false)
+            end
+
+          end
+          
+        end
+
+        context "and a key does not match" do
+
+          let(:actual_hash) do
+            { "key1" => "actual value 1", "differentkey2" => "different value 2", "key3" => "actual value 3" }
+          end
+
+          before(:example) { allow(string_value_matcher).to receive(:match?).and_return(true) }
+
+          it "determines if the corresponding value matches nil" do
+            expect(string_value_matcher).to receive(:match?).with("stub value 2", nil)
+
+            subject
+          end
+
+        end
+
+      end
+
+      context "and the actual hash contains more entries" do
+
+        let(:actual_hash) do
+          (1..5).each_with_object({}) { |i, result| result["key#{i}"] = "actual value #{i}" }
+        end
+
+        it "only evaluates a match for each stub value" do
+          stub_hash.values.each do |stub_value|
+            allow(string_value_matcher).to receive(:match?).with(stub_value, anything).and_return(true)
+          end
+
+          expect(subject).to be(true)
+        end
+        
+      end
+      
+    end
+
+    context "when the stubbed hash is empty" do
+
+      let(:stub_hash) { {} }
+
+      context "and the actual hash is not empty" do
+
+        let(:actual_hash) { { "key" => "value" } }
+
+        it "returns true" do
+          expect(subject).to be(true)
+        end
+
+      end
+
+      context "and the provided hash is empty" do
+
+        let(:actual_hash) { {} }
+
+        it "returns true" do
+          expect(subject).to be(true)
+        end
+
+      end
+      
+    end
+    
+  end
+  
+end

data/spec/lib/http_stub/server/stub/match/rule/body_spec.rb

@@ -99,8 +99,8 @@ describe HttpStub::Server::Stub::Match::Rule::Body do
 
       let(:stubbed_body) { "" }
 
-      it "returns a truthy request matcher" do
-        expect(subject).to eql(HttpStub::Server::Stub::Match::TruthyMatcher)
+      it "returns a truthy match rule" do
+        expect(subject).to eql(HttpStub::Server::Stub::Match::Rule::Truthy)
       end
 
     end
@@ -109,8 +109,8 @@ describe HttpStub::Server::Stub::Match::Rule::Body do
 
       let(:stubbed_body) { nil }
 
-      it "returns a truthy request matcher" do
-        expect(subject).to eql(HttpStub::Server::Stub::Match::TruthyMatcher)
+      it "returns a truthy match rule" do
+        expect(subject).to eql(HttpStub::Server::Stub::Match::Rule::Truthy)
       end
 
     end

data/spec/lib/http_stub/server/stub/match/rule/headers_spec.rb

@@ -1,64 +1,53 @@
 describe HttpStub::Server::Stub::Match::Rule::Headers do
 
-  let(:request)         { instance_double(HttpStub::Server::Request) }
+  let(:stub_headers) { { "stub_key" => "value" } }
 
-  let(:stubbed_headers) { { "stub_key" => "value" } }
+  let(:headers) { described_class.new(stub_headers) }
 
-  let(:request_headers) { described_class.new(stubbed_headers) }
+  it "is a hash with indifferent and insensitive access" do
+    expect(headers).to be_a(HttpStub::Extensions::Core::Hash::IndifferentAndInsensitiveAccess)
+  end
 
-  describe "when stubbed headers are provided" do
+  context "when the stub header names contain hypens" do
 
-    it "creates a regexpable representation of the stubbed headers whose keys are downcased and underscored" do
-      downcased_and_underscored_hash = { "another_stub_key" => "value" }
-      expect(stubbed_headers).to receive(:downcase_and_underscore_keys).and_return(downcased_and_underscored_hash)
-      expect(HttpStub::Server::Stub::Match::HashWithStringValueMatchers).to(
-        receive(:new).with(downcased_and_underscored_hash)
-      )
+    let(:stub_headers) { (1..3).each_with_object({}) { |i, result| result["stub-key-#{i}"] = "value-#{i}" } }
 
-      request_headers
+    it "underscores the names to accommodate for Rack Header manipulation" do
+      expect(headers.keys).to eql(stub_headers.keys.map(&:underscore))
     end
 
-  end
+    it "leaves the values unchanged" do
+      expect(headers.values).to eql(stub_headers.values)
+    end
 
-  describe "when the stubbed headers are nil" do
+  end
 
-    let(:stubbed_headers) { nil }
+  context "when no headers are provided" do
 
-    it "creates a regexpable representation of an empty hash" do
-      expect(HttpStub::Server::Stub::Match::HashWithStringValueMatchers).to receive(:new).with({})
+    let(:stub_headers) { nil }
 
-      request_headers
+    it "is empty" do
+      expect(headers.empty?).to be(true)
     end
 
   end
 
   describe "#matches?" do
 
-    let(:request_header_hash)        { { "header_key" => "header value" } }
-    let(:regexpable_stubbed_headers) do
-      double(HttpStub::Server::Stub::Match::HashWithStringValueMatchers).as_null_object
-    end
-    let(:logger)                     { double(Logger) }
+    let(:request_headers) { instance_double(HttpStub::Server::Request::Headers) }
+    let(:request)         { instance_double(HttpStub::Server::Request::Request, headers: request_headers) }
+    let(:logger)          { double(Logger) }
 
-    subject { request_headers.matches?(request, logger) }
+    subject { headers.matches?(request, logger) }
 
-    before(:example) do
-      allow(request).to receive(:headers).and_return(request_header_hash)
-      allow(HttpStub::Server::Stub::Match::HashWithStringValueMatchers).to(
-        receive(:new).and_return(regexpable_stubbed_headers)
-      )
-    end
-
-    it "downcases and underscore the keys in the request header hash" do
-      expect(request_header_hash).to receive(:downcase_and_underscore_keys)
+    it "determines if the stub header and request header hashes match" do
+      expect(HttpStub::Server::Stub::Match::HashMatcher).to receive(:match?).with(headers, request_headers)
 
       subject
     end
 
-    it "delegates to the regexpable representation of the stubbed headers to determine a match" do
-      downcased_and_underscored_hash = { "another_request_key" => "value" }
-      allow(request_header_hash).to receive(:downcase_and_underscore_keys).and_return(downcased_and_underscored_hash)
-      expect(regexpable_stubbed_headers).to receive(:matches?).with(downcased_and_underscored_hash).and_return(true)
+    it "returns the result of the match" do
+      allow(HttpStub::Server::Stub::Match::HashMatcher).to receive(:match?).and_return(true)
 
       expect(subject).to eql(true)
     end
@@ -67,22 +56,42 @@ describe HttpStub::Server::Stub::Match::Rule::Headers do
 
   describe "#to_s" do
 
-    let(:readable_hash) { instance_double(HttpStub::Server::FormattedHash, to_s: "readable header hash string") }
+    subject { headers.to_s }
+
+    describe "when multiple headers are provided" do
+
+      let(:stub_headers) { (1..3).each_with_object({}) { |i, result| result["key#{i}"] = "value#{i}" } }
 
-    subject { request_headers.to_s }
+      it "returns a string with each header name and value separated by ':'" do
+        result = subject
+
+        stub_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
 
-    before(:example) do
-      allow(HttpStub::Server::FormattedHash).to receive(:new).with(stubbed_headers, anything).and_return(readable_hash)
     end
 
-    it "returns the string representation of the readable header hash" do
-      expect(subject).to eql("readable header hash string")
+    describe "when empty headers are provided" do
+
+      let(:stub_headers) { {} }
+
+      it "returns an empty string" do
+        expect(subject).to eql("")
+      end
+
     end
 
-    it "formats the headers with a ':' key value delimiter" do
-      expect(HttpStub::Server::FormattedHash).to receive(:new).with(stubbed_headers, ":")
+    describe "when nil headers are provided" do
+
+      let(:stub_headers) { nil }
+
+      it "returns an empty string" do
+        expect(subject).to eql("")
+      end
 
-      subject
     end
 
   end