http_stub 0.24.3 → 0.25.0

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

@@ -1,12 +1,14 @@
 describe HttpStub::Server::Request::Request do
 
+  let(:rack_base_url)       { "http://base_url:8888" }
   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,
+    instance_double(Rack::Request, base_url:       rack_base_url,
+                                   path_info:      rack_path_info,
                                    request_method: rack_request_method,
                                    env:            rack_env,
                                    params:         rack_parameters,
@@ -15,6 +17,14 @@ describe HttpStub::Server::Request::Request do
 
   let(:server_request) { described_class.new(rack_request) }
 
+  describe "#base_uri" do
+
+    it "is the rack base url" do
+      expect(server_request.base_uri).to eql(rack_base_url)
+    end
+
+  end
+
   describe "#uri" do
 
     it "is the rack request path information" do
@@ -81,4 +91,34 @@ describe HttpStub::Server::Request::Request do
 
   end
 
+  describe "#to_hash" do
+
+    subject { server_request.to_hash }
+
+    describe "supporting creating a JSON representation of the result" do
+
+      it "contains the requests uri" do
+        expect(subject).to include(uri: server_request.uri)
+      end
+
+      it "contains the requests method" do
+        expect(subject).to include(method: server_request.method)
+      end
+
+      it "contains the requests headers" do
+        expect(subject).to include(headers: server_request.headers)
+      end
+
+      it "contains the requests parameters" do
+        expect(subject).to include(parameters: server_request.parameters)
+      end
+
+      it "contains the requests body" do
+        expect(subject).to include(body: server_request.body)
+      end
+
+    end
+
+  end
+
 end

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

@@ -1,42 +1,48 @@
 describe HttpStub::Server::Response do
 
-  shared_examples_for "a success response" do
+  shared_examples_for "an ok response" do
 
     it "has a status of 200" do
       expect(subject.status).to eql(200)
     end
 
     it "has a body containing OK to visually indicate success to those interacting via a browser" do
-      expect(subject.body).to match(/OK/)
+      expect(subject.body).to include("OK")
     end
 
   end
 
-  describe "::success" do
+  describe "::ok" do
 
-    subject { described_class.success }
+    subject { described_class.ok }
 
-    it_behaves_like "a success response"
+    it_behaves_like "an ok response"
 
-    context "when headers are provided" do
+    context "when options are provided" do
 
       let(:headers) { { "response_header_key" => "response header value" } }
+      let(:body)    { "response body" }
+      let(:opts)    { { "headers" => headers, "body" => body } }
 
-      subject { HttpStub::Server::Response::success(headers) }
+      subject { HttpStub::Server::Response::ok(opts) }
 
-      it "established the headers" do
+      it "establishes any headers provided" do
         expect(subject.headers).to eql(headers)
       end
 
+      it "establishes any body provided" do
+        expect(subject.body).to eql(body)
+      end
+
     end
 
   end
 
-  describe "::SUCCESS" do
+  describe "::OK" do
 
-    subject { HttpStub::Server::Response::SUCCESS }
+    subject { HttpStub::Server::Response::OK }
 
-    it_behaves_like "a success response"
+    it_behaves_like "an ok response"
 
   end
 
@@ -49,7 +55,7 @@ describe HttpStub::Server::Response do
     end
 
     it "has a body containing NOT FOUND to visually indicate the response to those interacting via a browser" do
-      expect(subject.body).to match(/NOT FOUND/)
+      expect(subject.body).to include("NOT FOUND")
     end
 
   end

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

@@ -40,8 +40,8 @@ describe HttpStub::Server::Scenario::Controller do
       subject
     end
 
-    it "returns a success response" do
-      expect(subject).to eql(HttpStub::Server::Response::SUCCESS)
+    it "returns an ok response" do
+      expect(subject).to eql(HttpStub::Server::Response::OK)
     end
 
   end
@@ -68,8 +68,8 @@ describe HttpStub::Server::Scenario::Controller do
         subject
       end
 
-      it "returns a success response" do
-        expect(subject).to eql(HttpStub::Server::Response::SUCCESS)
+      it "returns an ok response" do
+        expect(subject).to eql(HttpStub::Server::Response::OK)
       end
 
     end

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

@@ -4,56 +4,59 @@ describe HttpStub::Server::Scenario::Parser do
 
   describe "::parse" do
 
-    let(:parameters) { {} }
-    let(:body_hash)  { {} }
-    let(:request)    do
-      instance_double(HttpStub::Server::Request::Request, parameters: parameters, body: body_hash.to_json)
-    end
+    let(:payload)           { HttpStub::ScenarioFixture.new.server_payload }
+    let(:payload_parameter) { payload.to_json }
+    let(:parameters)        { { "payload" => payload_parameter } }
+    let(:request)           { instance_double(HttpStub::Server::Request::Request, parameters: parameters) }
+
+    let(:parsed_payload) { payload.clone }
 
     subject { parser.parse(request) }
 
+    before(:example) { allow(JSON).to receive(:parse).and_return(parsed_payload) }
+
+    it "parses the JSON payload in the request" do
+      expect(JSON).to receive(:parse).with(payload_parameter)
+
+      subject
+    end
+
+    it "returns the modified payload" do
+      expect(subject).to eql(parsed_payload)
+    end
+
     context "when the request contains many stubs" do
 
-      let(:payload)       { HttpStub::ScenarioFixture.new.with_stubs!(3).server_payload }
-      let(:stub_payloads) { payload["stubs"] }
-      let(:parameters)    { { "payload" => payload.to_json } }
+      let(:payload) { HttpStub::ScenarioFixture.new.with_stubs!(3).server_payload }
 
-      it "consolidates any files into each stub payload" do
-        stub_payloads.each do |stub_payload|
-          expect(HttpStub::Server::Stub::PayloadFileConsolidator).to receive(:consolidate!).with(stub_payload, request)
-        end
+      let(:stub_payloads) { payload["stubs"] }
 
-        subject
+      before(:example) do
+        stub_payloads.each { |stub_payload| allow(HttpStub::Server::Stub::Payload).to receive(:modify!) }
       end
 
-      it "consolidates any files in each stub payload" do
-        stub_payloads.each_with_index.each do |stub_payload|
-          allow(HttpStub::Server::Stub::PayloadFileConsolidator).to receive(:consolidate!).with(stub_payload, anything)
+      it "modifies each stub payload" do
+        stub_payloads.each do |stub_payload|
+          expect(HttpStub::Server::Stub::Payload).to receive(:modify!).with(stub_payload, request)
         end
 
-        expect(subject).to eql(payload)
+        subject
       end
 
     end
 
     context "when the request contains one stub" do
 
-      let(:payload)      { HttpStub::ScenarioFixture.new.with_stubs!(1).server_payload }
+      let(:payload) { HttpStub::ScenarioFixture.new.with_stubs!(1).server_payload }
+
       let(:stub_payload) { payload["stubs"].first }
-      let(:parameters)   { { "payload" => payload.to_json } }
 
-      it "consolidates any file into the stub payload" do
-        expect(HttpStub::Server::Stub::PayloadFileConsolidator).to receive(:consolidate!).with(stub_payload, request)
+      it "modifies the stub payload" do
+        expect(HttpStub::Server::Stub::Payload).to receive(:modify!).with(stub_payload, request)
 
         subject
       end
 
-      it "consolidates any file in the stub payload" do
-        allow(HttpStub::Server::Stub::PayloadFileConsolidator).to receive(:consolidate!).with(stub_payload, anything)
-
-        expect(subject).to eql(payload)
-      end
-
     end
 
   end

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

@@ -3,14 +3,14 @@ describe HttpStub::Server::Stub::Controller do
   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) }
   let(:stub_uri) { "/some/stub/uri" }
-  let(:the_stub) { instance_double(HttpStub::Server::Stub::Stub, response: response, stub_uri: stub_uri) }
+  let(:the_stub) { instance_double(HttpStub::Server::Stub::Stub, uri: stub_uri) }
 
-  let(:stub_registry)         { instance_double(HttpStub::Server::Stub::Registry).as_null_object }
-  let(:match_result_registry) { instance_double(HttpStub::Server::Registry).as_null_object }
+  let(:stub_registry)  { instance_double(HttpStub::Server::Stub::Registry).as_null_object }
+  let(:match_registry) { instance_double(HttpStub::Server::Registry).as_null_object }
+  let(:miss_registry)  { instance_double(HttpStub::Server::Registry).as_null_object }
 
-  let(:controller) { HttpStub::Server::Stub::Controller.new(stub_registry, match_result_registry) }
+  let(:controller) { HttpStub::Server::Stub::Controller.new(stub_registry, match_registry, miss_registry) }
 
   before(:example) do
     allow(HttpStub::Server::Stub::Parser).to receive(:parse).and_return(payload)
@@ -39,15 +39,15 @@ describe HttpStub::Server::Stub::Controller do
       subject
     end
 
-    it "creates a success response with a location header containing the stubs uri" do
-      expect(HttpStub::Server::Response).to receive(:success).with("location" => stub_uri)
+    it "creates an ok response with a location header containing the stubs uri" do
+      expect(HttpStub::Server::Response).to receive(:ok).with("headers" => { "location" => stub_uri })
 
       subject
     end
 
-    it "returns the success response" do
+    it "returns the ok response" do
       response = double("HttpStub::Server::Response")
-      allow(HttpStub::Server::Response).to receive(:success).and_return(response)
+      allow(HttpStub::Server::Response).to receive(:ok).and_return(response)
 
       expect(subject).to eql(response)
     end
@@ -63,29 +63,36 @@ describe HttpStub::Server::Stub::Controller do
     before(:example) do
       allow(stub_registry).to receive(:match).with(request, logger).and_return(matched_stub)
       allow(the_stub).to receive(:response_for).and_return(calculated_stub_response)
-      allow(match_result_registry).to receive(:add)
     end
 
     describe "when a stub has been registered that matches the request" do
 
       let(:matched_stub) { the_stub }
 
+      before(:example) { allow(match_registry).to receive(:add) }
+
       it "calculates the stubs response based on the request" do
         expect(the_stub).to receive(:response_for).with(request)
 
         subject
       end
 
-      it "determines the match result for the request, calculated response and stub" do
-        expect(HttpStub::Server::Stub::Match::Result).to receive(:new).with(request, calculated_stub_response, the_stub)
+      it "creates a match for the request, calculated response and stub" do
+        expect(HttpStub::Server::Stub::Match::Match).to receive(:new).with(request, calculated_stub_response, the_stub)
 
         subject
       end
 
-      it "adds the match result to the match result registry" do
-        expect(match_result_registry).to(
-          receive(:add).with(an_instance_of(HttpStub::Server::Stub::Match::Result), logger)
-        )
+      it "adds the match to the match registry" do
+        match = instance_double(HttpStub::Server::Stub::Match::Match)
+        allow(HttpStub::Server::Stub::Match::Match).to receive(:new).and_return(match)
+        expect(match_registry).to receive(:add).with(match, logger)
+
+        subject
+      end
+
+      it "does not add to the miss registry" do
+        expect(miss_registry).to_not receive(:add)
 
         subject
       end
@@ -100,22 +107,28 @@ describe HttpStub::Server::Stub::Controller do
 
       let(:matched_stub) { nil }
 
+      before(:example) { allow(miss_registry).to receive(:add) }
+
       it "returns a not found response" do
         expect(subject).to eql(HttpStub::Server::Response::NOT_FOUND)
       end
 
-      it "creates a match result for request with the not found response and no stub" do
-        expect(HttpStub::Server::Stub::Match::Result).to(
-          receive(:new).with(request, HttpStub::Server::Response::NOT_FOUND, nil)
-        )
+      it "creates a miss for the request" do
+        expect(HttpStub::Server::Stub::Match::Miss).to receive(:new).with(request)
+
+        subject
+      end
+
+      it "adds the miss to the miss registry" do
+        miss = instance_double(HttpStub::Server::Stub::Match::Miss)
+        allow(HttpStub::Server::Stub::Match::Miss).to receive(:new).and_return(miss)
+        expect(miss_registry).to receive(:add).with(miss, logger)
 
         subject
       end
 
-      it "adds the match result to the match result registry" do
-        expect(match_result_registry).to(
-          receive(:add).with(an_instance_of(HttpStub::Server::Stub::Match::Result), logger)
-        )
+      it "does not add to the match registry" do
+        expect(match_registry).to_not receive(:add)
 
         subject
       end
@@ -134,8 +147,14 @@ describe HttpStub::Server::Stub::Controller do
       subject
     end
 
-    it "clears the match result registry" do
-      expect(match_result_registry).to receive(:clear).with(logger)
+    it "clears the match registry" do
+      expect(match_registry).to receive(:clear).with(logger)
+
+      subject
+    end
+
+    it "clears the miss registry" do
+      expect(miss_registry).to receive(:clear).with(logger)
 
       subject
     end

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

@@ -2,26 +2,18 @@ describe HttpStub::Server::Stub::Empty do
 
   let(:empty_stub) { HttpStub::Server::Stub::Empty::INSTANCE }
 
-  %w{ uri method stub_uri body }.each do |empty_string_attribute|
-
-    describe "##{empty_string_attribute}" do
-
-      it "is an empty string" do
-        expect(empty_stub.send(empty_string_attribute.to_sym)).to eql("")
-      end
+  describe "#uri" do
 
+    it "is an empty string" do
+      expect(empty_stub.uri).to eql("")
     end
 
   end
 
-  %w{ headers parameters }.each do |empty_hash_attribute|
-
-    describe "##{empty_hash_attribute}" do
-
-      it "is an empty hash" do
-        expect(empty_stub.send(empty_hash_attribute.to_sym)).to eql({})
-      end
+  describe "#match_rules" do
 
+    it "is empty" do
+      expect(empty_stub.match_rules).to eql(HttpStub::Server::Stub::Match::Rules::EMPTY)
     end
 
   end
@@ -63,6 +55,14 @@ describe HttpStub::Server::Stub::Empty do
 
   end
 
+  describe "#to_hash" do
+
+    it "returns an empty hash" do
+      expect(empty_stub.to_hash).to eql({})
+    end
+
+  end
+
   describe "#to_s" do
 
     it "returns an empty string" do

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

@@ -0,0 +1,69 @@
+describe HttpStub::Server::Stub::Match::Controller do
+
+  let(:registry) { instance_double(HttpStub::Server::Registry) }
+
+  let(:controller) { described_class.new(registry) }
+
+  describe "#find_last" do
+
+    let(:uri)        { "/some/endpoint/uri" }
+    let(:method)     { "PATCH" }
+    let(:parameters) { { uri: uri, method: method } }
+    let(:request)    { instance_double(HttpStub::Server::Request::Request, parameters: parameters) }
+    let(:logger)     { instance_double(Logger) }
+
+    subject { controller.find_last(request, logger) }
+
+    it "finds the match in the registry with the uri requested" do
+      expect(registry).to receive(:find).with(hash_including(uri: uri), anything)
+
+      subject
+    end
+
+    it "finds the match in the registry with the HTTP method requested" do
+      expect(registry).to receive(:find).with(hash_including(method: method), anything)
+
+      subject
+    end
+
+    it "finds the match using the provided logger for diagnostics" do
+      expect(registry).to receive(:find).with(anything, logger)
+
+      subject
+    end
+
+    context "when a match is found" do
+
+      let(:match_json) { "some match JSON" }
+      let(:match)      { instance_double(HttpStub::Server::Stub::Match::Match, to_json: match_json) }
+
+      before(:example) { allow(registry).to receive(:find).and_return(match) }
+
+      it "creates an ok response containing the JSON representation of the match" do
+        expect(HttpStub::Server::Response).to receive(:ok).with("body" => match_json)
+
+        subject
+      end
+
+      it "returns the response" do
+        response = instance_double(HttpStub::Server::Stub::Response::Text)
+        allow(HttpStub::Server::Response).to receive(:ok).and_return(response)
+
+        expect(subject).to eql(response)
+      end
+
+    end
+
+    context "when a match is not found" do
+
+      before(:example) { allow(registry).to receive(:find).and_return(nil) }
+
+      it "returns a not found response" do
+        expect(subject).to eql(HttpStub::Server::Response::NOT_FOUND)
+      end
+
+    end
+
+  end
+
+end