http_stub 0.16.0.pre1 → 0.17.0.pre1

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

@@ -21,6 +21,7 @@ describe HttpStub::Server::Stub::Instance do
       "method" =>     "post",
       "headers" =>    { "triggered_header" => "triggered_header_value" },
       "parameters" => { "triggered_parameter" => "triggered_parameter_value" },
+      "body" =>       { "schema" => { "json" => "trigger schema definition" } },
       "response" => {
         "status" => 203,
         "body" =>   "Triggered body"
@@ -33,6 +34,7 @@ describe HttpStub::Server::Stub::Instance do
       "method" =>     stub_method,
       "headers" =>    request_header_payload,
       "parameters" => request_parameter_payload,
+      "body" =>       { "schema" => { "json" => "stub schema definition" } },
       "response" => {
         "status" => 201,
         "body" =>   "Some body"
@@ -44,6 +46,7 @@ describe HttpStub::Server::Stub::Instance do
   let(:uri)                { instance_double(HttpStub::Server::Stub::Uri, match?: true) }
   let(:request_headers)    { instance_double(HttpStub::Server::Stub::RequestHeaders, match?: true) }
   let(:request_parameters) { instance_double(HttpStub::Server::Stub::RequestParameters, match?: true) }
+  let(:request_body)       { double("HttpStub::Server::Stub::SomeRequestBody", match?: true) }
   let(:response)           { instance_double(HttpStub::Server::Stub::Response::Base) }
   let(:triggers)           { instance_double(HttpStub::Server::Stub::Triggers) }
 
@@ -54,6 +57,7 @@ describe HttpStub::Server::Stub::Instance do
     allow(HttpStub::Server::Stub::Uri).to receive(:new).and_return(uri)
     allow(HttpStub::Server::Stub::RequestHeaders).to receive(:new).and_return(request_headers)
     allow(HttpStub::Server::Stub::RequestParameters).to receive(:new).and_return(request_parameters)
+    allow(HttpStub::Server::Stub::RequestBody).to receive(:create).and_return(request_body)
     allow(HttpStub::Server::Stub::Response).to receive(:create).and_return(response)
     allow(HttpStub::Server::Stub::Triggers).to receive(:new).and_return(triggers)
   end
@@ -64,6 +68,8 @@ describe HttpStub::Server::Stub::Instance do
     let(:request_uri)    { "/a_request_uri" }
     let(:request)        { instance_double(Rack::Request, :request_method => request_method_payload) }
 
+    subject { the_stub.satisfies?(request) }
+
     describe "when the request uri matches" do
 
       before(:example) { allow(uri).to receive(:match?).with(request).and_return(true) }
@@ -82,8 +88,18 @@ describe HttpStub::Server::Stub::Instance do
 
                 before(:example) { allow(request_parameters).to receive(:match?).with(request).and_return(true) }
 
-                it "returns true" do
-                  expect(the_stub.satisfies?(request)).to be_truthy
+                describe "and a body match is configured" do
+
+                  describe "that matches" do
+
+                    before(:example) { allow(request_body).to receive(:match?).with(request).and_return(true) }
+
+                    it "returns true" do
+                      expect(subject).to be(true)
+                    end
+
+                  end
+
                 end
 
               end
@@ -98,22 +114,22 @@ describe HttpStub::Server::Stub::Instance do
 
     end
 
-    describe "when the request method does not match" do
+    describe "when the request uri does not match" do
 
-      before(:example) { allow(stub_method).to receive(:match?).with(request).and_return(false) }
+      before(:example) { allow(uri).to receive(:match?).with(request).and_return(false) }
 
       it "returns false" do
-        expect(the_stub.satisfies?(request)).to be(false)
+        expect(subject).to be(false)
       end
 
     end
 
-    describe "when the request uri does not match" do
+    describe "when the request method does not match" do
 
-      before(:example) { allow(uri).to receive(:match?).with(request).and_return(false) }
+      before(:example) { allow(stub_method).to receive(:match?).with(request).and_return(false) }
 
       it "returns false" do
-        expect(the_stub.satisfies?(request)).to be(false)
+        expect(subject).to be(false)
       end
 
     end
@@ -123,7 +139,7 @@ describe HttpStub::Server::Stub::Instance do
       before(:example) { allow(request_headers).to receive(:match?).with(request).and_return(false) }
 
       it "returns false" do
-        expect(the_stub.satisfies?(request)).to be(false)
+        expect(subject).to be(false)
       end
 
     end
@@ -133,7 +149,17 @@ describe HttpStub::Server::Stub::Instance do
       before(:example) { allow(request_parameters).to receive(:match?).with(request).and_return(false) }
 
       it "returns false" do
-        expect(the_stub.satisfies?(request)).to be(false)
+        expect(subject).to be(false)
+      end
+
+    end
+
+    describe "when the bodies do not match" do
+
+      before(:example) { allow(request_body).to receive(:match?).with(request).and_return(false) }
+
+      it "returns false" do
+        expect(subject).to be(false)
       end
 
     end
@@ -172,6 +198,14 @@ describe HttpStub::Server::Stub::Instance do
 
   end
 
+  describe "#body" do
+
+    it "returns the body model encapsulating the body provided in the request body" do
+      expect(the_stub.body).to eql(request_body)
+    end
+
+  end
+
   describe "#response" do
 
     it "exposes the response model encapsulating the response provided in the request body" do

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

@@ -0,0 +1,102 @@
+describe HttpStub::Server::Stub::JsonRequestBody do
+
+  let(:stubbed_schema_definition) { { "type" => "object", "properties" => { "some_property" => "some_type" } } }
+
+  let(:json_request_body) { HttpStub::Server::Stub::JsonRequestBody.new(stubbed_schema_definition) }
+
+  describe "#match?" 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(:validation_errors) { [] }
+
+    subject { json_request_body.match?(request) }
+
+    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)
+
+      subject
+    end
+
+    it "validates against raw JSON" do
+      expect(JSON::Validator).to receive(:fully_validate).with(anything, anything, hash_including(json: true))
+
+      subject
+    end
+
+    it "ensures the schema definition is valid" do
+      expect(JSON::Validator).to(
+        receive(:fully_validate).with(anything, anything, hash_including(validate_schema: true))
+      )
+
+      subject
+    end
+
+    context "when body is valid" do
+
+      let(:validation_errors) { [] }
+
+      it "returns true" do
+        expect(subject).to be(true)
+      end
+
+      it "logs nothing" do
+        expect(logger).not_to receive(:info)
+
+        subject
+      end
+
+    end
+
+    context "when the body is invalid" do
+
+      let(:validation_errors) { (1..3).map { |i| "The property '#/#{i}' failed validation"} }
+
+      it "returns false" do
+        expect(subject).to be(false)
+      end
+
+      it "logs each validation error" do
+        validation_errors.each { |validation_error| expect(logger).to receive(:info).with(validation_error) }
+
+        subject
+      end
+
+    end
+
+    context "when an error occurs validating the body" do
+
+      let(:error) { JSON::ParserError.new }
+
+      before(:example) { allow(JSON::Validator).to receive(:fully_validate).and_raise(JSON::ParserError.new) }
+
+      it "returns false" do
+        expect(subject).to be(false)
+      end
+
+      it "logs the error" do
+        expect(logger).to receive(:info).with(error.message)
+
+        subject
+      end
+
+    end
+
+  end
+
+  describe "#to_s" do
+
+    subject { json_request_body.to_s }
+
+    it "returns the JSON representation of the schema definition" do
+      expect(subject).to eql(stubbed_schema_definition.to_json)
+    end
+
+  end
+
+end

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

@@ -0,0 +1,120 @@
+describe HttpStub::Server::Stub::RequestBody do
+
+  describe "::create" do
+
+    subject { HttpStub::Server::Stub::RequestBody.create(stubbed_body) }
+
+    shared_context "a raw request body that causes a simple request body to be created" do
+
+      it "creates a simple request body with the body" do
+        expect(HttpStub::Server::Stub::SimpleRequestBody).to receive(:new).with(stubbed_body)
+
+        subject
+      end
+
+      it "returns the created request body" do
+        simple_request_body = instance_double(HttpStub::Server::Stub::SimpleRequestBody)
+        allow(HttpStub::Server::Stub::SimpleRequestBody).to receive(:new).and_return(simple_request_body)
+
+        expect(subject).to eql(simple_request_body)
+      end
+
+    end
+
+    context "when the stubbed body contains a schema" do
+
+      let(:stubbed_body) { { "schema" => raw_schema } }
+
+      context "that is JSON" do
+
+        let(:json_schema) { "some json schema" }
+        let(:raw_schema)  { { "type" => "json", "definition" => json_schema } }
+
+        it "creates a JSON request body with the schema" do
+          expect(HttpStub::Server::Stub::JsonRequestBody).to receive(:new).with(json_schema)
+
+          subject
+        end
+
+        it "returns the created request body" do
+          json_request_body = instance_double(HttpStub::Server::Stub::JsonRequestBody)
+          allow(HttpStub::Server::Stub::JsonRequestBody).to receive(:new).and_return(json_request_body)
+
+          expect(subject).to eql(json_request_body)
+        end
+
+      end
+
+      context "that is not JSON" do
+
+        let(:raw_schema) { { "type" => "xml", "definition" => "some xml schema" } }
+
+        it "raises an error indicating the body is invalid" do
+          expect { subject }.to(
+            raise_error("Stub request body schema #{raw_schema} is invalid: xml schema is not supported")
+          )
+        end
+
+      end
+
+      context "that does not have a type" do
+
+        let(:raw_schema) { { "definition" => "some defintion" } }
+
+        it "raises an error indicating the body is invalid" do
+          expect { subject }.to raise_error("Stub request body schema #{raw_schema} is invalid: type expected")
+        end
+
+      end
+
+      context "that does not have a definition" do
+
+        let(:raw_schema) { { "type" => "some type" } }
+
+        it "raises an error indicating the body is invalid" do
+          expect { subject }.to raise_error("Stub request body schema #{raw_schema} is invalid: definition expected")
+        end
+
+      end
+
+    end
+
+    context "when the stubbed body contains a string" do
+
+      let(:stubbed_body) { "some string" }
+
+      it_behaves_like "a raw request body that causes a simple request body to be created"
+
+    end
+
+    context "when the stubbed body contains a regular expression control value" do
+
+      let(:stubbed_body) { "regexp:some regex" }
+
+      it_behaves_like "a raw request body that causes a simple request body to be created"
+
+    end
+
+    context "when the stubbed body is empty" do
+
+      let(:stubbed_body) { "" }
+
+      it "returns a truthy request matcher" do
+        expect(subject).to eql(HttpStub::Server::Stub::TruthyRequestMatcher)
+      end
+
+    end
+
+    context "when the stubbed body is nil" do
+
+      let(:stubbed_body) { nil }
+
+      it "returns a truthy request matcher" do
+        expect(subject).to eql(HttpStub::Server::Stub::TruthyRequestMatcher)
+      end
+
+    end
+
+  end
+
+end

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

@@ -0,0 +1,43 @@
+describe HttpStub::Server::Stub::SimpleRequestBody do
+
+  let(:raw_body)      { "some body" }
+  let(:value_matcher) { instance_double(HttpStub::Server::Stub::StringValueMatcher).as_null_object }
+
+  let(:simple_request_body) { HttpStub::Server::Stub::SimpleRequestBody.new(raw_body) }
+
+  before(:example) { allow(HttpStub::Server::Stub::StringValueMatcher).to receive(:new).and_return(value_matcher) }
+
+  describe "constructor" do
+
+    it "creates a value matcher for the provided body" do
+      expect(HttpStub::Server::Stub::StringValueMatcher).to receive(:new).with(raw_body)
+
+      simple_request_body
+    end
+
+  end
+
+  describe "#match?" do
+
+    let(:request_body) { "some request body" }
+    let(:request)      { instance_double(Rack::Request, body: double("Rack::Body", read: request_body)) }
+
+    it "delegates to the value matcher to match the request body" do
+      expect(value_matcher).to receive(:match?).with(request_body).and_return(true)
+
+      expect(simple_request_body.match?(request)).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_request_body.to_s).to eql("some value matcher string")
+    end
+
+  end
+
+end

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

@@ -65,7 +65,7 @@ describe HttpStub::Server::Stub::StringValueMatcher do
       let(:stub_value)                { "some stub value" }
       let(:expected_stub_match_value) { "some stub value" }
 
-      it_should_behave_like "a StringValueMatcher that matches an expected stub value"
+      it_behaves_like "a StringValueMatcher that matches an expected stub value"
 
     end
 
@@ -74,7 +74,7 @@ describe HttpStub::Server::Stub::StringValueMatcher do
       let(:stub_value)                { 88 }
       let(:expected_stub_match_value) { "88" }
 
-      it_should_behave_like "a StringValueMatcher that matches an expected stub value"
+      it_behaves_like "a StringValueMatcher that matches an expected stub value"
 
     end
 

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

@@ -0,0 +1,23 @@
+describe HttpStub::Server::Stub::TruthyRequestMatcher do
+
+  let(:truthy_request_matcher) { HttpStub::Server::Stub::TruthyRequestMatcher }
+
+  describe "::match?" do
+
+    let(:request) { instance_double(Rack::Request) }
+
+    it "returns true" do
+      expect(truthy_request_matcher.match?(request)).to be(true)
+    end
+
+  end
+
+  describe "::to_s" do
+
+    it "returns an empty string" do
+      expect(truthy_request_matcher.to_s).to eql("")
+    end
+
+  end
+
+end

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

@@ -25,7 +25,7 @@ describe HttpStub::Server::Stub::Uri do
     it "delegates to the value matcher representation of the provided uri" do
       expect(value_matcher).to receive(:match?).with(request_uri).and_return(true)
 
-      expect(uri.match?(request)).to be_truthy
+      expect(uri.match?(request)).to be(true)
     end
 
   end