http_stub 0.19.1 → 0.20.0

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

@@ -0,0 +1,90 @@
+describe HttpStub::Server::Stub::Match::Rule::Headers do
+
+  let(:request)         { instance_double(HttpStub::Server::Request) }
+
+  let(:stubbed_headers) { { "stub_key" => "value" } }
+
+  let(:request_headers) { described_class.new(stubbed_headers) }
+
+  describe "when stubbed headers are provided" 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)
+      )
+
+      request_headers
+    end
+
+  end
+
+  describe "when the stubbed headers are nil" do
+
+    let(:stubbed_headers) { nil }
+
+    it "creates a regexpable representation of an empty hash" do
+      expect(HttpStub::Server::Stub::Match::HashWithStringValueMatchers).to receive(:new).with({})
+
+      request_headers
+    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) }
+
+    subject { request_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)
+
+      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)
+
+      expect(subject).to eql(true)
+    end
+
+  end
+
+  describe "#to_s" do
+
+    let(:readable_hash) { instance_double(HttpStub::Server::FormattedHash, to_s: "readable header hash string") }
+
+    subject { request_headers.to_s }
+
+    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")
+    end
+
+    it "formats the headers with a ':' key value delimiter" do
+      expect(HttpStub::Server::FormattedHash).to receive(:new).with(stubbed_headers, ":")
+
+      subject
+    end
+
+  end
+
+end

data/spec/lib/http_stub/server/stub/{json_request_body_spec.rb → match/rule/json_body_spec.rb}

@@ -1,24 +1,23 @@
-describe HttpStub::Server::Stub::JsonRequestBody do
+describe HttpStub::Server::Stub::Match::Rule::JsonBody do
 
   let(:stubbed_schema_definition) { { "type" => "object", "properties" => { "some_property" => "some_type" } } }
 
-  let(:json_request_body) { HttpStub::Server::Stub::JsonRequestBody.new(stubbed_schema_definition) }
+  let(:json_body) { described_class.new(stubbed_schema_definition) }
 
-  describe "#match?" do
+  describe "#matches?" do
 
-    let(:logger)           { double("Logger").as_null_object }
-    let(:raw_request_body) { { "some_json_property" => "some_json_value" }.to_json }
-    let(:request_body)     { double("RackRequestBody", read: raw_request_body) }
-    let(:request)          { instance_double(Rack::Request, logger: logger, body: request_body) }
+    let(:request_body) { { "some_json_property" => "some_json_value" }.to_json }
+    let(:request)      { instance_double(HttpStub::Server::Request, body: request_body) }
+    let(:logger)       { instance_double(Logger, info: nil) }
 
     let(:validation_errors) { [] }
 
-    subject { json_request_body.match?(request) }
+    subject { json_body.matches?(request, logger) }
 
     before(:example) { allow(JSON::Validator).to receive(:fully_validate).and_return(validation_errors) }
 
     it "validates the request body using the stubbed schema definition" do
-      expect(JSON::Validator).to receive(:fully_validate).with(stubbed_schema_definition, raw_request_body, anything)
+      expect(JSON::Validator).to receive(:fully_validate).with(stubbed_schema_definition, request_body, anything)
 
       subject
     end
@@ -91,7 +90,7 @@ describe HttpStub::Server::Stub::JsonRequestBody do
 
   describe "#to_s" do
 
-    subject { json_request_body.to_s }
+    subject { json_body.to_s }
 
     it "returns the JSON representation of the schema definition" do
       expect(subject).to eql(stubbed_schema_definition.to_json)

data/spec/lib/http_stub/server/stub/{method_spec.rb → match/rule/method_spec.rb}

@@ -1,15 +1,16 @@
-describe HttpStub::Server::Stub::Method do
+describe HttpStub::Server::Stub::Match::Rule::Method do
 
   let(:raw_stub_method) { "put" }
 
-  let(:the_method) { HttpStub::Server::Stub::Method.new(raw_stub_method) }
+  let(:the_method) { described_class.new(raw_stub_method) }
 
-  describe "#match?" do
+  describe "#matches?" do
 
     let(:request_method) { "get" }
-    let(:request)        { instance_double(Rack::Request, request_method: request_method) }
+    let(:request)        { instance_double(HttpStub::Server::Request, method: request_method) }
+    let(:logger)         { instance_double(Logger) }
 
-    subject { the_method.match?(request) }
+    subject { the_method.matches?(request, logger) }
 
     context "when the request method is identical to the stub method" do
 

data/spec/lib/http_stub/server/stub/{request_parameters_spec.rb → match/rule/parameters_spec.rb}

@@ -1,17 +1,19 @@
-describe HttpStub::Server::Stub::RequestParameters do
+describe HttpStub::Server::Stub::Match::Rule::Parameters do
 
   let(:raw_request_parameters) { double("RequestParameters") }
-  let(:request)                { instance_double(Rack::Request, params: raw_request_parameters) }
+  let(:request)                { instance_double(HttpStub::Server::Request, parameters: raw_request_parameters) }
 
   let(:stubbed_parameters)            { { "key1" => "value1", "key2" => "value2", "key3" => "value3" } }
-  let(:regexpable_stubbed_paremeters) { double(HttpStub::Server::Stub::HashWithStringValueMatchers).as_null_object }
+  let(:regexpable_stubbed_paremeters) do
+    double(HttpStub::Server::Stub::Match::HashWithStringValueMatchers).as_null_object
+  end
 
-  let(:request_parameters) { HttpStub::Server::Stub::RequestParameters.new(stubbed_parameters) }
+  let(:request_parameters) { described_class.new(stubbed_parameters) }
 
   describe "when stubbed parameters are provided" do
 
     it "creates a regexpable representation of the stubbed parameters" do
-      expect(HttpStub::Server::Stub::HashWithStringValueMatchers).to receive(:new).with(stubbed_parameters)
+      expect(HttpStub::Server::Stub::Match::HashWithStringValueMatchers).to receive(:new).with(stubbed_parameters)
 
       request_parameters
     end
@@ -23,20 +25,24 @@ describe HttpStub::Server::Stub::RequestParameters do
     let(:stubbed_parameters) { nil }
 
     it "creates a regexpable representation of an empty hash" do
-      expect(HttpStub::Server::Stub::HashWithStringValueMatchers).to receive(:new).with({})
+      expect(HttpStub::Server::Stub::Match::HashWithStringValueMatchers).to receive(:new).with({})
 
       request_parameters
     end
 
   end
 
-  describe "#match?" do
+  describe "#matches?" do
+
+    let(:logger) { instance_double(Logger) }
 
     it "delegates to the regexpable representation of the stubbed parameters to determine a match" do
-      allow(HttpStub::Server::Stub::HashWithStringValueMatchers).to receive(:new).and_return(regexpable_stubbed_paremeters)
-      expect(regexpable_stubbed_paremeters).to receive(:match?).with(raw_request_parameters).and_return(true)
+      allow(HttpStub::Server::Stub::Match::HashWithStringValueMatchers).to(
+        receive(:new).and_return(regexpable_stubbed_paremeters)
+      )
+      expect(regexpable_stubbed_paremeters).to receive(:matches?).with(raw_request_parameters).and_return(true)
 
-      expect(request_parameters.match?(request)).to be(true)
+      expect(request_parameters.matches?(request, logger)).to be(true)
     end
 
   end

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

@@ -0,0 +1,46 @@
+describe HttpStub::Server::Stub::Match::Rule::SimpleBody do
+
+  let(:raw_body)      { "some body" }
+  let(:value_matcher) { instance_double(HttpStub::Server::Stub::Match::StringValueMatcher).as_null_object }
+
+  let(:simple_body) { described_class.new(raw_body) }
+
+  before(:example) do
+    allow(HttpStub::Server::Stub::Match::StringValueMatcher).to receive(:new).and_return(value_matcher)
+  end
+
+  describe "constructor" do
+
+    it "creates a value matcher for the provided body" do
+      expect(HttpStub::Server::Stub::Match::StringValueMatcher).to receive(:new).with(raw_body)
+
+      simple_body
+    end
+
+  end
+
+  describe "#matches?" do
+
+    let(:request_body) { "some request body" }
+    let(:request)      { instance_double(HttpStub::Server::Request, body: request_body) }
+    let(:logger)       { instance_double(Logger) }
+
+    it "delegates to the value matcher to match the request body" do
+      expect(value_matcher).to receive(:matches?).with(request_body).and_return(true)
+
+      expect(simple_body.matches?(request, logger)).to be(true)
+    end
+
+  end
+
+  describe "#to_s" do
+
+    it "delegates to the value matcher representation of the provided body" do
+      expect(value_matcher).to receive(:to_s).and_return("some value matcher string")
+
+      expect(simple_body.to_s).to eql("some value matcher string")
+    end
+
+  end
+
+end

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

@@ -0,0 +1,46 @@
+describe HttpStub::Server::Stub::Match::Rule::Uri do
+
+  let(:raw_uri)       { "/some/uri" }
+  let(:value_matcher) { instance_double(HttpStub::Server::Stub::Match::StringValueMatcher).as_null_object }
+
+  let(:uri) { described_class.new(raw_uri) }
+
+  before(:example) do
+    allow(HttpStub::Server::Stub::Match::StringValueMatcher).to receive(:new).and_return(value_matcher)
+  end
+
+  describe "constructor" do
+
+    it "creates a value matcher for the provided uri" do
+      expect(HttpStub::Server::Stub::Match::StringValueMatcher).to receive(:new).with(raw_uri)
+
+      uri
+    end
+
+  end
+
+  describe "#matches?" do
+
+    let(:request_uri) { "/some/uri" }
+    let(:request)     { instance_double(HttpStub::Server::Request, uri: request_uri) }
+    let(:logger)      { instance_double(Logger) }
+
+    it "delegates to the value matcher representation of the provided uri" do
+      expect(value_matcher).to receive(:matches?).with(request_uri).and_return(true)
+
+      expect(uri.matches?(request, logger)).to be(true)
+    end
+
+  end
+
+  describe "#to_s" do
+
+    it "delegates to the value matcher representation of the provided uri" do
+      expect(value_matcher).to receive(:to_s).and_return("some value matcher string")
+
+      expect(uri.to_s).to eql("some value matcher string")
+    end
+
+  end
+
+end

data/spec/lib/http_stub/server/stub/{string_value_matcher_spec.rb → match/string_value_matcher_spec.rb}

@@ -1,61 +1,63 @@
-describe HttpStub::Server::Stub::StringValueMatcher do
+describe HttpStub::Server::Stub::Match::StringValueMatcher do
 
   let(:stub_value) { "some stub value" }
 
-  let(:string_value_matcher) { HttpStub::Server::Stub::StringValueMatcher.new(stub_value) }
+  let(:string_value_matcher) { HttpStub::Server::Stub::Match::StringValueMatcher.new(stub_value) }
 
-  describe "#match?" do
+  describe "#matches?" do
 
     let(:actual_value) { "some actual value" }
 
+    subject { string_value_matcher.matches?(actual_value) }
+
     shared_examples_for "a StringValueMatcher that matches an expected stub value" do
 
       it "determines if actual value should be omitted" do
-        expect(HttpStub::Server::Stub::OmittedValueMatcher).to(
+        expect(HttpStub::Server::Stub::Match::OmittedValueMatcher).to(
           receive(:match?).with(expected_stub_match_value, actual_value)
         )
 
-        perform_match
+        subject
       end
 
       it "determines if the actual value matches a regular expression" do
-        expect(HttpStub::Server::Stub::RegexpValueMatcher).to(
+        expect(HttpStub::Server::Stub::Match::RegexpValueMatcher).to(
           receive(:match?).with(expected_stub_match_value, actual_value)
         )
 
-        perform_match
+        subject
       end
 
       it "determines if the actual value exactly matches the stub value" do
-        expect(HttpStub::Server::Stub::ExactValueMatcher).to(
+        expect(HttpStub::Server::Stub::Match::ExactValueMatcher).to(
           receive(:match?).with(expected_stub_match_value, actual_value)
         )
 
-        perform_match
+        subject
       end
 
       it "determines if actual value should be omitted" do
-        expect(HttpStub::Server::Stub::OmittedValueMatcher).to(
+        expect(HttpStub::Server::Stub::Match::OmittedValueMatcher).to(
           receive(:match?).with(expected_stub_match_value, actual_value)
         )
 
-        perform_match
+        subject
       end
 
       it "determines if the actual value matches a regular expression" do
-        expect(HttpStub::Server::Stub::RegexpValueMatcher).to(
+        expect(HttpStub::Server::Stub::Match::RegexpValueMatcher).to(
           receive(:match?).with(expected_stub_match_value, actual_value)
         )
 
-        perform_match
+        subject
       end
 
       it "determines if the actual value exactly matches the stub value" do
-        expect(HttpStub::Server::Stub::ExactValueMatcher).to(
+        expect(HttpStub::Server::Stub::Match::ExactValueMatcher).to(
           receive(:match?).with(expected_stub_match_value, actual_value)
         )
 
-        perform_match
+        subject
       end
 
     end
@@ -80,30 +82,36 @@ describe HttpStub::Server::Stub::StringValueMatcher do
 
     context "when an omitted match occurs" do
 
-      before(:example) { expect(HttpStub::Server::Stub::OmittedValueMatcher).to receive(:match?).and_return(true) }
+      before(:example) do
+        expect(HttpStub::Server::Stub::Match::OmittedValueMatcher).to receive(:match?).and_return(true)
+      end
 
       it "returns true" do
-        expect(perform_match).to be_truthy
+        expect(subject).to be(true)
       end
 
     end
 
     context "when a regular expression match occurs" do
 
-      before(:example) { expect(HttpStub::Server::Stub::RegexpValueMatcher).to receive(:match?).and_return(true) }
+      before(:example) do
+        expect(HttpStub::Server::Stub::Match::RegexpValueMatcher).to receive(:match?).and_return(true)
+      end
 
       it "returns true" do
-        expect(perform_match).to be_truthy
+        expect(subject).to be(true)
       end
 
     end
 
     context "when an exact match occurs" do
 
-      before(:example) { expect(HttpStub::Server::Stub::ExactValueMatcher).to receive(:match?).and_return(true) }
+      before(:example) do
+        expect(HttpStub::Server::Stub::Match::ExactValueMatcher).to receive(:match?).and_return(true)
+      end
 
       it "returns true" do
-        expect(perform_match).to be_truthy
+        expect(subject).to be(true)
       end
 
     end
@@ -111,14 +119,10 @@ describe HttpStub::Server::Stub::StringValueMatcher do
     context "when no match occurs" do
 
       it "returns false" do
-        expect(perform_match).to be_falsey
+        expect(subject).to be(false)
       end
 
     end
-    
-    def perform_match
-      string_value_matcher.match?(actual_value)
-    end
 
   end
 

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

@@ -0,0 +1,24 @@
+describe HttpStub::Server::Stub::Match::TruthyMatcher do
+
+  let(:truthy_matcher) { described_class }
+
+  describe "::matches?" do
+
+    let(:request) { instance_double(HttpStub::Server::Request) }
+    let(:logger)  { instance_double(Logger) }
+
+    it "returns true" do
+      expect(truthy_matcher.matches?(request, logger)).to be(true)
+    end
+
+  end
+
+  describe "::to_s" do
+
+    it "returns an empty string" do
+      expect(truthy_matcher.to_s).to eql("")
+    end
+
+  end
+
+end