http_stub 0.19.1 → 0.20.0

data/spec/lib/http_stub/server/stub/{request_parser_spec.rb → parser_spec.rb}

@@ -1,19 +1,19 @@
-describe HttpStub::Server::Stub::RequestParser do
+describe HttpStub::Server::Stub::Parser do
 
-  let(:request_parser) { described_class }
+  let(:parser) { described_class }
 
   describe "::parse" do
 
-    let(:params)    { {} }
-    let(:body_hash) { {} }
-    let(:request)   { instance_double(Rack::Request, params: params, body: StringIO.new(body_hash.to_json)) }
+    let(:parameters) { {} }
+    let(:body_hash)  { {} }
+    let(:request)    { instance_double(HttpStub::Server::Request, parameters: parameters, body: body_hash.to_json) }
 
-    subject { request_parser.parse(request) }
+    subject { parser.parse(request) }
 
     context "when the request contains a payload parameter" do
 
       let(:payload) { HttpStub::StubFixture.new.server_payload }
-      let(:params)  { { "payload" => payload.to_json } }
+      let(:parameters)  { { "payload" => payload.to_json } }
 
       it "consolidates any files into the payload" do
         expect(HttpStub::Server::Stub::PayloadFileConsolidator).to receive(:consolidate!).with(payload, request)

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

@@ -1,9 +1,9 @@
 describe HttpStub::Server::Stub::Registry, "integrating with real stubs" do
 
-  let(:logger)  { double("Logger").as_null_object }
-  let(:request) { instance_double(Rack::Request, logger: logger) }
+  let(:request_match_registry) { HttpStub::Server::Registry.new("request match") }
+  let(:logger)                 { instance_double(Logger, info: nil) }
 
-  let(:stub_registry) { HttpStub::Server::Stub::Registry.new }
+  let(:stub_registry) { HttpStub::Server::Stub::Registry.new(request_match_registry) }
 
   describe "#recall" do
 
@@ -13,7 +13,7 @@ describe HttpStub::Server::Stub::Registry, "integrating with real stubs" do
 
       let(:stubs) { (1..3).map { |i| create_stub(i) } }
 
-      before(:example) { stubs.each { |stub| stub_registry.add(stub, request) } }
+      before(:example) { stubs.each { |stub| stub_registry.add(stub, logger) } }
 
       context "and remembered" do
 
@@ -23,7 +23,7 @@ describe HttpStub::Server::Stub::Registry, "integrating with real stubs" do
 
           let(:stub_to_add) { create_stub(4) }
 
-          before(:example) { stub_registry.add(stub_to_add, request) }
+          before(:example) { stub_registry.add(stub_to_add, logger) }
 
           it "should restore all known stubs to the remembered state" do
             subject

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

@@ -1,80 +1,140 @@
 describe HttpStub::Server::Stub::Registry do
 
-  let(:registry)      { instance_double(HttpStub::Server::Registry) }
+  let(:match_registry)           { instance_double(HttpStub::Server::Registry) }
+  let(:underlying_stub_registry) { instance_double(HttpStub::Server::Registry) }
 
-  let(:stub_registry) { HttpStub::Server::Stub::Registry.new }
+  let(:logger)                   { instance_double(Logger) }
 
-  before(:example) { allow(HttpStub::Server::Registry).to receive(:new).and_return(registry) }
+  let(:stub_registry) { HttpStub::Server::Stub::Registry.new(match_registry) }
+
+  before(:example) { allow(HttpStub::Server::Registry).to receive(:new).and_return(underlying_stub_registry) }
 
   describe "#add" do
 
-    let(:stub)    { instance_double(HttpStub::Server::Stub::Instance) }
-    let(:request) { instance_double(Rack::Request) }
+    let(:stub) { instance_double(HttpStub::Server::Stub::Stub) }
+
+    subject { stub_registry.add(stub, logger) }
 
     it "delegates to an underlying simple registry" do
-      expect(registry).to receive(:add).with(stub, request)
+      expect(underlying_stub_registry).to receive(:add).with(stub, logger)
 
-      stub_registry.add(stub, request)
+      subject
     end
 
   end
 
   describe "#concat" do
 
-    let(:stubs)   { (1..3).map { instance_double(HttpStub::Server::Stub::Instance) } }
-    let(:request) { instance_double(Rack::Request) }
+    let(:stubs)  { (1..3).map { instance_double(HttpStub::Server::Stub::Stub) } }
+
+    subject { stub_registry.concat(stubs, logger) }
 
     it "delegates to an underlying simple registry" do
-      expect(registry).to receive(:concat).with(stubs, request)
+      expect(underlying_stub_registry).to receive(:concat).with(stubs, logger)
 
-      stub_registry.concat(stubs, request)
+      subject
     end
 
   end
 
-  describe "#find_for" do
+  describe "#find" do
 
-    let(:request) { instance_double(Rack::Request) }
+    let(:triggers) { instance_double(HttpStub::Server::Stub::Triggers, add_to: nil) }
+    let(:stub)     { instance_double(HttpStub::Server::Stub::Stub, triggers: triggers) }
 
-    subject { stub_registry.find_for(request) }
+    subject { stub_registry.find(criteria, logger) }
 
-    it "delegates to an underlying simple registry to find based on the request" do
-      expect(registry).to receive(:find).with(criteria: request, request: request)
+    shared_examples_for "an approach to finding a stub in the registry" do
 
-      subject
-    end
+      it "delegates to an underlying simple registry to find based on the criteria" do
+        expect(underlying_stub_registry).to receive(:find).with(criteria, logger)
 
-    context "when a stub is found" do
+        subject
+      end
 
-      let(:triggers) { instance_double(HttpStub::Server::Stub::Triggers) }
-      let(:stub)     { instance_double(HttpStub::Server::Stub::Instance, triggers: triggers) }
+      context "when a stub is found" do
 
-      before(:example) { allow(registry).to receive(:find).and_return(stub) }
+        before(:example) { allow(underlying_stub_registry).to receive(:find).and_return(stub) }
 
-      it "should add the stubs triggers to the registry" do
-        expect(triggers).to receive(:add_to).with(stub_registry, request)
+        it "returns the stub found in the underlying stub registry" do
+          expect(subject).to eql(stub)
+        end
 
-        subject
       end
 
-      it "returns the stub found in the underlying registry" do
-        allow(triggers).to receive(:add_to)
+      context "when a stub is not found" do
+
+        before(:example) { allow(underlying_stub_registry).to receive(:find).and_return(nil) }
+
+        it "returns the result from the underlying registry" do
+          expect(subject).to eql(nil)
+        end
 
-        expect(subject).to eql(stub)
       end
 
     end
 
-    context "when a stub is not found" do
+    context "when a request is provided" do
+
+      let(:request)  { HttpStub::Server::RequestFixture.create }
+      let(:criteria) { request }
+
+      before(:example) { allow(match_registry).to receive(:add) }
+
+      it_behaves_like "an approach to finding a stub in the registry"
+
+      context "when a stub is found" do
+
+        let(:stub_match) { instance_double(HttpStub::Server::Stub::Match::Match) }
+
+        before(:example) do
+          allow(underlying_stub_registry).to receive(:find).and_return(stub)
+          allow(HttpStub::Server::Stub::Match::Match).to receive(:new).and_return(stub_match)
+        end
+
+        it "creates a match containing the stub and request" do
+          expect(HttpStub::Server::Stub::Match::Match).to receive(:new).with(stub, request)
+
+          subject
+        end
+
+        it "adds the match to the match registry" do
+          expect(match_registry).to receive(:add).with(stub_match, logger)
 
-      before(:example) { allow(registry).to receive(:find).and_return(nil) }
+          subject
+        end
+
+        it "adds the stubs triggers to the underlying stub registry" do
+          expect(triggers).to receive(:add_to).with(stub_registry, logger)
+
+          subject
+        end
+
+      end
+
+      context "when a stub is not found" do
+
+        before(:example) { allow(underlying_stub_registry).to receive(:find).and_return(nil) }
+
+        it "does not add a match to the match registry" do
+          expect(match_registry).to_not receive(:add)
+
+          subject
+        end
 
-      it "returns the result from the underlying registry" do
-        expect(subject).to eql(nil)
       end
 
     end
 
+    context "when an id is provided" do
+
+      let(:id)       { SecureRandom.uuid }
+      let(:criteria) { id }
+
+      it_behaves_like "an approach to finding a stub in the registry"
+
+    end
+
   end
 
   describe "#recall" do
@@ -83,15 +143,15 @@ describe HttpStub::Server::Stub::Registry do
 
     context "when the state of the registry has been remembered" do
 
-      let(:last_stub_remembered) { instance_double(HttpStub::Server::Stub::Instance) }
+      let(:last_stub_remembered) { instance_double(HttpStub::Server::Stub::Stub) }
 
       before(:example) do
-        allow(registry).to receive(:last).and_return(last_stub_remembered)
+        allow(underlying_stub_registry).to receive(:last).and_return(last_stub_remembered)
         stub_registry.remember
       end
 
       it "causes the underlying registry to rollback to the last stub added before the state was remembered" do
-        expect(registry).to receive(:rollback_to).with(last_stub_remembered)
+        expect(underlying_stub_registry).to receive(:rollback_to).with(last_stub_remembered)
 
         subject
       end
@@ -101,7 +161,7 @@ describe HttpStub::Server::Stub::Registry do
     context "when the state of the registry has not been remembered" do
 
       it "does not rollback the underlying registry" do
-        expect(registry).to_not receive(:rollback_to)
+        expect(underlying_stub_registry).to_not receive(:rollback_to)
 
         subject
       end
@@ -112,18 +172,18 @@ describe HttpStub::Server::Stub::Registry do
 
   describe "#all" do
 
-    let(:stubs) { (1..3).map { instance_double(HttpStub::Server::Stub::Instance) } }
+    let(:stubs) { (1..3).map { instance_double(HttpStub::Server::Stub::Stub) } }
 
     subject { stub_registry.all }
 
     it "delegates to an underlying simple registry" do
-      expect(registry).to receive(:all)
+      expect(underlying_stub_registry).to receive(:all)
 
       subject
     end
 
     it "returns the result from the underlying registry" do
-      allow(registry).to receive(:all).and_return(stubs)
+      allow(underlying_stub_registry).to receive(:all).and_return(stubs)
 
       expect(subject).to eql(stubs)
     end
@@ -132,12 +192,23 @@ describe HttpStub::Server::Stub::Registry do
 
   describe "#clear" do
 
-    let(:request) { instance_double(Rack::Request) }
+    subject { stub_registry.clear(logger) }
 
-    it "delegates to an underlying simple registry" do
-      expect(registry).to receive(:clear).with(request)
+    before(:example) do
+      allow(underlying_stub_registry).to receive(:clear)
+      allow(match_registry).to receive(:clear)
+    end
+
+    it "clears the underlying simple registry" do
+      expect(underlying_stub_registry).to receive(:clear).with(logger)
 
-      stub_registry.clear(request)
+      subject
+    end
+
+    it "clears the match registry" do
+      expect(match_registry).to receive(:clear).with(logger)
+
+      subject
     end
 
   end

data/spec/lib/http_stub/server/stub/response/base_spec.rb

@@ -96,8 +96,14 @@ describe HttpStub::Server::Stub::Response::Base do
 
     let(:response_header_hash) { response.headers.to_hash }
 
-    it "is Headers" do
-      expect(response.headers).to be_a(HttpStub::Server::Stub::Headers)
+    it "is a readable hash" do
+      expect(response.headers).to be_a(HttpStub::Server::FormattedHash)
+    end
+
+    it "formats the hash with a ':' key value delimiter" do
+      expect(HttpStub::Server::FormattedHash).to receive(:new).with(anything, ":")
+
+      response.headers
     end
 
     context "when default headers have been added" do

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

@@ -0,0 +1,294 @@
+describe HttpStub::Server::Stub::Stub do
+
+  let(:request_header_payload) do
+    {
+        "header1" => "header_value1",
+        "header2" => "header_value2",
+        "header3" => "header_value3"
+    }
+  end
+  let(:request_parameter_payload) do
+    {
+        "param1" => "param_value1",
+        "param2" => "param_value2",
+        "param3" => "param_value3"
+    }
+  end
+  let(:request_method_payload) { "get" }
+  let(:trigger_payload) do
+    {
+      "uri" =>        "/a_triggered_path",
+      "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"
+      }
+    }
+  end
+  let(:stub_id)      { SecureRandom.uuid }
+  let(:stub_payload) do
+    {
+      "id" =>         stub_id,
+      "uri" =>        "/a_path",
+      "method" =>     stub_method,
+      "headers" =>    request_header_payload,
+      "parameters" => request_parameter_payload,
+      "body" =>       { "schema" => { "json" => "stub schema definition" } },
+      "response" => {
+        "status" => 201,
+        "body" =>   "Some body"
+      },
+      "triggers" => [ trigger_payload ]
+    }
+  end
+  let(:stub_method)        { instance_double(HttpStub::Server::Stub::Match::Rule::Method, matches?: true) }
+  let(:uri)                { instance_double(HttpStub::Server::Stub::Match::Rule::Uri, matches?: true) }
+  let(:request_headers)    { instance_double(HttpStub::Server::Stub::Match::Rule::Headers, matches?: true) }
+  let(:request_parameters) { instance_double(HttpStub::Server::Stub::Match::Rule::Parameters, matches?: true) }
+  let(:request_body)       { double("HttpStub::Server::Stub::SomeRequestBody", matches?: true) }
+  let(:response)           { instance_double(HttpStub::Server::Stub::Response::Base) }
+  let(:triggers)           { instance_double(HttpStub::Server::Stub::Triggers) }
+
+  let(:the_stub) { HttpStub::Server::Stub::Stub.new(stub_payload) }
+
+  before(:example) do
+    allow(HttpStub::Server::Stub::Match::Rule::Method).to receive(:new).and_return(stub_method)
+    allow(HttpStub::Server::Stub::Match::Rule::Uri).to receive(:new).and_return(uri)
+    allow(HttpStub::Server::Stub::Match::Rule::Headers).to receive(:new).and_return(request_headers)
+    allow(HttpStub::Server::Stub::Match::Rule::Parameters).to receive(:new).and_return(request_parameters)
+    allow(HttpStub::Server::Stub::Match::Rule::Body).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
+
+  describe "#matches?" do
+
+    let(:logger)         { instance_double(Logger) }
+
+    context "when a request is provided" do
+
+      let(:request_method) { request_method_payload }
+      let(:request_uri)    { "/a_request_uri" }
+      let(:request)        { instance_double(HttpStub::Server::Request, method: request_method_payload) }
+
+      subject { the_stub.matches?(request, logger) }
+
+      describe "when the request uri matches" do
+
+        before(:example) { allow(uri).to receive(:matches?).with(request, logger).and_return(true) }
+
+        describe "and the request method matches" do
+
+          describe "and a header match is configured" do
+
+            describe "that matches" do
+
+              before(:example) { allow(request_headers).to receive(:matches?).with(request, logger).and_return(true) }
+
+              describe "and a parameter match is configured" do
+
+                describe "that matches" do
+
+                  before(:example) do
+                    allow(request_parameters).to receive(:matches?).with(request, logger).and_return(true)
+                  end
+
+                  describe "and a body match is configured" do
+
+                    describe "that matches" do
+
+                      before(:example) do
+                        allow(request_body).to receive(:matches?).with(request, logger).and_return(true)
+                      end
+
+                      it "returns true" do
+                        expect(subject).to be(true)
+                      end
+
+                    end
+
+                  end
+
+                end
+
+              end
+
+            end
+
+          end
+
+        end
+
+      end
+
+
+      describe "when the request uri does not match" do
+
+        before(:example) { allow(uri).to receive(:matches?).with(request, logger).and_return(false) }
+
+        it "returns false" do
+          expect(subject).to be(false)
+        end
+
+      end
+
+      describe "when the request method does not match" do
+
+        before(:example) { allow(stub_method).to receive(:matches?).with(request, logger).and_return(false) }
+
+        it "returns false" do
+          expect(subject).to be(false)
+        end
+
+      end
+
+      describe "when the headers do not match" do
+
+        before(:example) { allow(request_headers).to receive(:matches?).with(request, logger).and_return(false) }
+
+        it "returns false" do
+          expect(subject).to be(false)
+        end
+
+      end
+
+      describe "when the parameters do not match" do
+
+        before(:example) { allow(request_parameters).to receive(:matches?).with(request, logger).and_return(false) }
+
+        it "returns false" do
+          expect(subject).to be(false)
+        end
+
+      end
+
+      describe "when the bodies do not match" do
+
+        before(:example) { allow(request_body).to receive(:matches?).with(request, logger).and_return(false) }
+
+        it "returns false" do
+          expect(subject).to be(false)
+        end
+
+      end
+
+    end
+
+    context "when an id is provided" do
+
+      subject { the_stub.matches?(id, logger) }
+
+      context "and the id matches the stubs id" do
+
+        let(:id) { stub_id }
+
+        it "returns true" do
+          expect(subject).to be(true)
+        end
+
+      end
+
+      context "and the id does not match the stubs id" do
+
+        let(:id) { "does-not-match" }
+
+        it "returns false" do
+          expect(subject).to be(false)
+        end
+
+      end
+
+    end
+
+  end
+
+  describe "#uri" do
+
+    it "returns the uri model encapsulating the uri provided in the request body" do
+      expect(the_stub.uri).to eql(uri)
+    end
+
+  end
+
+  describe "#method" do
+
+    it "returns the method model encapsulating the method provided in the request body" do
+      expect(the_stub.method).to eql(stub_method)
+    end
+
+  end
+
+  describe "#headers" do
+
+    it "returns the headers model encapsulating the headers provided in the request body" do
+      expect(the_stub.headers).to eql(request_headers)
+    end
+
+  end
+
+  describe "#parameters" do
+
+    it "returns the parameters model encapsulating the parameters provided in the request body" do
+      expect(the_stub.parameters).to eql(request_parameters)
+    end
+
+  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
+      expect(the_stub.response).to eql(response)
+    end
+
+  end
+
+  describe "#triggers" do
+
+    it "returns the triggers model encapsulating the triggers provided in the request body" do
+      expect(the_stub.triggers).to eql(triggers)
+    end
+
+  end
+
+  describe "#stub_uri" do
+
+    context "when an id is provided in the payload" do
+
+      it "returns a relative uri to the stub that includes the id" do
+        expect(the_stub.stub_uri).to eql("/stubs/#{stub_id}")
+      end
+
+    end
+
+    context "when an id is not provided in the payload" do
+
+      it "returns a relative uri to the stub that includes a generated id" do
+        expect(the_stub.stub_uri).to match(/\/stubs\/[a-zA-Z0-9-]+$/)
+      end
+
+    end
+
+  end
+
+  describe "#to_s" do
+
+    it "returns a string representation of the stub arguments" do
+      expect(stub_payload).to receive(:to_s).and_return("stub arguments string")
+
+      expect(the_stub.to_s).to eql("stub arguments string")
+    end
+
+  end
+
+end