http_stub 0.19.1 → 0.20.0

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

@@ -4,21 +4,25 @@ describe HttpStub::Server::Application do
   let(:response)      { last_response }
   let(:response_body) { response.body.to_s }
 
+  let(:match_registry)    { instance_double(HttpStub::Server::Stub::Registry).as_null_object }
   let(:stub_registry)     { instance_double(HttpStub::Server::Stub::Registry).as_null_object }
   let(:scenario_registry) { instance_double(HttpStub::Server::Registry).as_null_object }
 
   let(:stub_controller)     { instance_double(HttpStub::Server::Stub::Controller).as_null_object }
   let(:scenario_controller) { instance_double(HttpStub::Server::Scenario::Controller).as_null_object }
 
+  let(:request_pipeline)  { instance_double(HttpStub::Server::RequestPipeline, process: nil) }
   let(:response_pipeline) { instance_double(HttpStub::Server::ResponsePipeline, process: nil) }
 
   let(:app) { HttpStub::Server::Application.new! }
 
   before(:example) do
-    allow(HttpStub::Server::Stub::Registry).to receive(:new).and_return(stub_registry)
+    allow(HttpStub::Server::Registry).to receive(:new).with("match").and_return(match_registry)
     allow(HttpStub::Server::Registry).to receive(:new).with("scenario").and_return(scenario_registry)
+    allow(HttpStub::Server::Stub::Registry).to receive(:new).and_return(stub_registry)
     allow(HttpStub::Server::Stub::Controller).to receive(:new).and_return(stub_controller)
     allow(HttpStub::Server::Scenario::Controller).to receive(:new).and_return(scenario_controller)
+    allow(HttpStub::Server::RequestPipeline).to receive(:new).and_return(request_pipeline)
     allow(HttpStub::Server::ResponsePipeline).to receive(:new).and_return(response_pipeline)
   end
 
@@ -46,6 +50,53 @@ describe HttpStub::Server::Application do
 
   end
 
+  context "when a request to list the stubs is received" do
+
+    let(:found_stubs) { [ HttpStub::Server::Stub::Empty::INSTANCE ] }
+
+    subject { get "/stubs" }
+
+    it "retrieves the stubs from the registry" do
+      expect(stub_registry).to receive(:all).and_return(found_stubs)
+
+      subject
+    end
+
+  end
+
+  context "when a request to show a stub is received" do
+
+    let(:stub_id)    { SecureRandom.uuid }
+    let(:found_stub) { HttpStub::Server::Stub::Empty::INSTANCE }
+
+    subject { get "/stubs/#{stub_id}" }
+
+    it "retrieves the stub from the registry" do
+      expect(stub_registry).to receive(:find).with(stub_id, anything).and_return(found_stub)
+
+      subject
+    end
+
+  end
+
+  context "when a request to clear the stubs is received" do
+
+    subject { delete "/stubs" }
+
+    it "delegates clearing to the stub controller" do
+      expect(stub_controller).to receive(:clear)
+
+      subject
+    end
+
+    it "responds with a 200 status code" do
+      subject
+
+      expect(response.status).to eql(200)
+    end
+
+  end
+
   context "when a request to commit the stubs to memory is received" do
 
     subject { post "/stubs/memory" }
@@ -82,20 +133,16 @@ describe HttpStub::Server::Application do
 
   end
 
-  context "when a request to clear the stubs has been received" do
+  context "when a request to list the matches is received" do
 
-    subject { delete "/stubs" }
+    let(:found_matches) { [ HttpStub::Server::Stub::Match::MatchFixture.empty ] }
 
-    it "delegates clearing to the stub controller" do
-      expect(stub_controller).to receive(:clear)
+    subject { get "/stubs/matches" }
 
-      subject
-    end
+    it "retrieves the matches from the registry" do
+      expect(match_registry).to receive(:all).and_return(found_matches)
 
-    it "responds with a 200 status code" do
       subject
-
-      expect(response.status).to eql(200)
     end
 
   end
@@ -129,6 +176,20 @@ describe HttpStub::Server::Application do
 
   end
 
+  context "when a request to list the scenarios is received" do
+
+    let(:found_scenarios) { [ HttpStub::Server::Scenario::ScenarioFixture.empty ] }
+
+    subject { get "/stubs/scenarios" }
+
+    it "retrieves the stubs from the registry" do
+      expect(scenario_registry).to receive(:all).and_return(found_scenarios)
+
+      subject
+    end
+
+  end
+
   context "when a request to clear the scenarios has been received" do
 
     subject { delete "/stubs/scenarios" }
@@ -149,57 +210,24 @@ describe HttpStub::Server::Application do
 
   context "when another type of request is received" do
 
-    let(:stub_response) { instance_double(HttpStub::Server::Stub::Response::Base) }
+    let(:request_pipeline_response) { instance_double(HttpStub::Server::Stub::Response::Base) }
 
     subject { get "/a_path" }
 
-    before(:example) { allow(stub_controller).to receive(:replay).and_return(stub_response) }
+    before(:example) { allow(request_pipeline).to receive(:process).and_return(request_pipeline_response) }
 
-    context "and the stub controller replays a response" do
-
-      before(:example) { allow(stub_response).to receive(:empty?).and_return(false) }
-
-      it "processes the response via the response pipeline" do
-        expect(response_pipeline).to receive(:process).with(stub_response)
-
-        subject
-      end
+    it "determines the response via the request pipeline" do
+      expect(request_pipeline).to(
+        receive(:process).with(an_instance_of(HttpStub::Server::Request), anything)
+      )
 
+      subject
     end
 
-    context "and the stub controller does not replay a response" do
-
-      let(:scenario_response) { double(HttpStub::Server::Stub::Response::Base, serve_on: nil) }
-
-      before(:example) do
-        allow(stub_response).to receive(:empty?).and_return(true)
-        allow(scenario_controller).to receive(:activate).and_return(scenario_response)
-      end
-
-      context "but the scenario controller activates a scenario" do
-
-        before(:each) { allow(scenario_response).to receive(:empty?).and_return(false) }
-
-        it "processes the scenario response via the response pipeline" do
-          expect(response_pipeline).to receive(:process).with(scenario_response)
-
-          subject
-        end
-
-      end
-
-      context "and the scenario controller does not activate a scenario" do
-
-        before(:each) { allow(scenario_response).to receive(:empty?).and_return(true) }
-
-        it "processes an error response via the response pipeline" do
-          expect(response_pipeline).to receive(:process).with(HttpStub::Server::Response::ERROR)
-
-          subject
-        end
-
-      end
+    it "processes the response via the response pipeline" do
+      expect(response_pipeline).to receive(:process).with(request_pipeline_response)
 
+      subject
     end
 
   end

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

@@ -0,0 +1,54 @@
+describe HttpStub::Server::FormattedHash do
+
+  let(:underlying_hash)     { {} }
+  let(:key_value_delimiter) { "=" }
+
+  let(:formatted_hash) { described_class.new(underlying_hash, key_value_delimiter) }
+
+  it "is a Hash" do
+    expect(formatted_hash).to be_a(Hash)
+  end
+
+  describe "#to_s" do
+
+    subject { formatted_hash.to_s }
+
+    describe "when a hash with multiple entires is provided" do
+
+      let(:underlying_hash) { { "key1" => "value1", "key2" => "value2", "key3" => "value3" } }
+
+      it "returns a string containing keys and values delimited by the provided delimiter" do
+        result = subject
+
+        underlying_hash.each { |key, value| expect(result).to match(/#{key}#{key_value_delimiter}#{value}/) }
+      end
+
+      it "comma delimits the entries" do
+        expect(subject).to match(/key\d.value\d\, key\d.value\d\, key\d.value\d/)
+      end
+
+    end
+
+    describe "when an empty hash is provided" do
+
+      let(:underlying_hash) { {} }
+
+      it "returns an empty string" do
+        expect(subject).to eql("")
+      end
+
+    end
+
+    describe "when a nil hash is provided" do
+
+      let(:underlying_hash) { nil }
+
+      it "returns an empty string" do
+        expect(subject).to eql("")
+      end
+
+    end
+
+  end
+
+end

data/spec/lib/http_stub/server/{stub/request_header_parser_spec.rb → header_parser_spec.rb}

@@ -1,4 +1,4 @@
-describe HttpStub::Server::Stub::RequestHeaderParser do
+describe HttpStub::Server::HeaderParser do
 
   let(:non_header_env_elements) do
     {
@@ -10,16 +10,18 @@ describe HttpStub::Server::Stub::RequestHeaderParser do
   let(:env)     { non_header_env_elements.merge(header_env_elements) }
   let(:request) { instance_double(Rack::Request, env: env) }
 
+  let(:header_parser) { described_class }
+
   describe "::parse" do
 
+    subject { header_parser.parse(request) }
+
     describe "when the request contains environment entries in upper case" do
 
       let(:header_env_elements) { { "KEY_1" => "value1", "KEY_2" => "value2", "KEY_3" => "value3" } }
 
       it "returns a hash containing those entries" do
-        expect(HttpStub::Server::Stub::RequestHeaderParser.parse(request)).to eql("KEY_1" => "value1",
-                                                                            "KEY_2" => "value2",
-                                                                            "KEY_3" => "value3")
+        expect(subject).to eql("KEY_1" => "value1", "KEY_2" => "value2", "KEY_3" => "value3")
       end
 
     end
@@ -29,9 +31,7 @@ describe HttpStub::Server::Stub::RequestHeaderParser do
       let(:header_env_elements) { { "HTTP_KEY_1" => "value1", "HTTP_KEY_2" => "value2", "HTTP_KEY_3" => "value3" } }
 
       it "returns a hash containing those entries with the prefix removed" do
-        expect(HttpStub::Server::Stub::RequestHeaderParser.parse(request)).to include("KEY_1" => "value1",
-                                                                                "KEY_2" => "value2",
-                                                                                "KEY_3" => "value3")
+        expect(subject).to include("KEY_1" => "value1", "KEY_2" => "value2", "KEY_3" => "value3")
       end
 
     end
@@ -41,9 +41,9 @@ describe HttpStub::Server::Stub::RequestHeaderParser do
       let(:header_env_elements) { {} }
 
       it "returns an empty hash" do
-        expect(HttpStub::Server::Stub::RequestHeaderParser.parse(request)).to eql({})
+        expect(subject).to eql({})
       end
-      
+
     end
 
   end

data/spec/lib/http_stub/server/{request_file_consolidator_spec.rb → payload_file_consolidator_spec.rb}

@@ -4,8 +4,8 @@ describe HttpStub::Server::Stub::PayloadFileConsolidator do
 
   describe "::consolidate!" do
 
-    let(:params)  { {} }
-    let(:request) { instance_double(Rack::Request, params: params) }
+    let(:parameters) { {} }
+    let(:request)    { instance_double(HttpStub::Server::Request, parameters: parameters) }
 
     subject { consolidator.consolidate!(payload, request) }
 
@@ -13,7 +13,7 @@ describe HttpStub::Server::Stub::PayloadFileConsolidator do
 
       let(:payload_fixture) { HttpStub::StubFixture.new.with_file_response! }
       let(:payload)         { payload_fixture.server_payload }
-      let(:params)          { { "response_file_#{payload_fixture.id}" => payload_fixture.file_parameter } }
+      let(:parameters)      { { "response_file_#{payload_fixture.id}" => payload_fixture.file_parameter } }
 
       it "returns the payload with a response body that contains the file parameter value" do
         expected_payload = payload.clone.tap { |hash| hash["response"]["body"] = payload_fixture.file_parameter }
@@ -41,7 +41,7 @@ describe HttpStub::Server::Stub::PayloadFileConsolidator do
       context "and the trigger payloads contain a response file with corresponding file parameters" do
 
         let(:trigger_fixtures) { (1..3).map { HttpStub::StubFixture.new.with_file_response! } }
-        let(:params) do
+        let(:parameters) do
           trigger_fixtures.reduce({}) do |result, fixture|
             result.merge("response_file_#{fixture.id}" => fixture.file_parameter)
           end

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

@@ -1,15 +1,14 @@
 describe HttpStub::Server::Registry do
 
-  let(:logger)  { double("Logger").as_null_object }
-  let(:request) { instance_double(Rack::Request, logger: logger) }
+  let(:logger)  { instance_double(Logger, info: nil) }
 
   let(:registry) { HttpStub::Server::Registry.new("a_model") }
 
   shared_context "register multiple models" do
 
-    let(:models) { (1..3).map { |i| double("HttpStub::Server::Model#{i}", :satisfies? => false) } }
+    let(:models) { (1..3).map { |i| double("HttpStub::Server::Model#{i}", :matches? => false) } }
 
-    before(:example) { registry.concat(models, request) }
+    before(:example) { registry.concat(models, logger) }
 
   end
 
@@ -18,7 +17,7 @@ describe HttpStub::Server::Registry do
     let(:model_string_representation) { "some model string" }
     let(:model)                       { double("HttpStub::Server::Model", to_s: model_string_representation) }
 
-    subject { registry.add(model, request) }
+    subject { registry.add(model, logger) }
 
     before(:example) { allow(logger).to receive(:info) }
 
@@ -45,7 +44,7 @@ describe HttpStub::Server::Registry do
       end
     end
 
-    subject { registry.concat(models, request) }
+    subject { registry.concat(models, logger) }
 
     it "logs that the models have been registered" do
       model_string_representations.each do |string_representation|
@@ -67,23 +66,23 @@ describe HttpStub::Server::Registry do
 
     let(:criteria) { double("Criteria", inspect: "Criteria inspect result") }
 
-    subject { registry.find(criteria: criteria, request: request) }
+    subject { registry.find(criteria, logger) }
 
     describe "when multiple models have been registered" do
 
       include_context "register multiple models"
 
       it "determines if the models satisfy the provided criteria" do
-        models.each { |model| expect(model).to receive(:satisfies?).with(criteria).and_return(false) }
+        models.each { |model| expect(model).to receive(:matches?).with(criteria, logger).and_return(false) }
 
         subject
       end
 
-      describe "and one registered model satisfies the criteria" do
+      describe "and one registered model matches the criteria" do
 
         let(:matching_model) { models[1] }
 
-        before(:example) { allow(matching_model).to receive(:satisfies?).and_return(true) }
+        before(:example) { allow(matching_model).to receive(:matches?).and_return(true) }
 
         it "returns the model" do
           expect(subject).to eql(matching_model)
@@ -91,7 +90,7 @@ describe HttpStub::Server::Registry do
 
         describe "and the registry is subsequently cleared" do
 
-          before(:example) { registry.clear(request) }
+          before(:example) { registry.clear(logger) }
 
           it "returns nil" do
             expect(subject).to be_nil
@@ -103,7 +102,7 @@ describe HttpStub::Server::Registry do
 
       describe "and multiple registered models satisfy the criteria" do
 
-        before(:example) { [0, 2].each { |i| allow(models[i]).to receive(:satisfies?).and_return(true) } }
+        before(:example) { [0, 2].each { |i| allow(models[i]).to receive(:matches?).and_return(true) } }
 
         it "supports model overrides by returning the last model registered" do
           expect(subject).to eql(models[2])
@@ -153,7 +152,7 @@ describe HttpStub::Server::Registry do
 
       let(:model) { double("HttpStub::Server::Model") }
 
-      before(:example) { registry.add(model, request) }
+      before(:example) { registry.add(model, logger) }
 
       it "returns the model" do
         expect(registry.last).to eql(model)
@@ -235,7 +234,7 @@ describe HttpStub::Server::Registry do
 
   describe "#clear" do
 
-    subject { registry.clear(request) }
+    subject { registry.clear(logger) }
 
     it "logs that the models are being cleared" do
       expect(logger).to receive(:info).with(/clearing a_model/i)

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

@@ -0,0 +1,80 @@
+describe HttpStub::Server::RequestPipeline do
+
+  let(:stub_controller)     { instance_double(HttpStub::Server::Stub::Controller).as_null_object }
+  let(:scenario_controller) { instance_double(HttpStub::Server::Scenario::Controller).as_null_object }
+  let(:match_registry)      { instance_double(HttpStub::Server::Stub::Registry).as_null_object }
+
+  let(:request_pipeline) { described_class.new(stub_controller, scenario_controller, match_registry) }
+
+  describe "#process" do
+
+    let(:request) { instance_double(HttpStub::Server::Request) }
+    let(:logger)  { instance_double(Logger) }
+
+    let(:stub_response) { instance_double(HttpStub::Server::Stub::Response::Base) }
+
+    subject { request_pipeline.process(request, logger) }
+
+    before(:example) { allow(stub_controller).to receive(:replay).and_return(stub_response) }
+
+    context "when the stub controller replays a response" do
+
+      before(:example) { allow(stub_response).to receive(:empty?).and_return(false) }
+
+      it "returns the replayed response" do
+        expect(subject).to eql(stub_response)
+      end
+
+    end
+
+    context "when the stub controller does not replay a response" do
+
+      let(:scenario_response) { double(HttpStub::Server::Stub::Response::Base, serve_on: nil) }
+
+      before(:example) do
+        allow(stub_response).to receive(:empty?).and_return(true)
+        allow(scenario_controller).to receive(:activate).and_return(scenario_response)
+      end
+
+      context "but the scenario controller activates a scenario" do
+
+        before(:each) { allow(scenario_response).to receive(:empty?).and_return(false) }
+
+        it "returns the scenario response" do
+          expect(subject).to eql(scenario_response)
+        end
+
+      end
+
+      context "and the scenario controller does not activate a scenario" do
+
+        let(:stub_match) { instance_double(HttpStub::Server::Stub::Match::Match) }
+
+        before(:each) do
+          allow(HttpStub::Server::Stub::Match::Match).to receive(:new).and_return(stub_match)
+          allow(scenario_response).to receive(:empty?).and_return(true)
+        end
+
+        it "creates a match with no stub to indicate their was no match" do
+          expect(HttpStub::Server::Stub::Match::Match).to receive(:new).with(nil, request)
+
+          subject
+        end
+
+        it "registers the created match in the match registry" do
+          expect(match_registry).to receive(:add).with(stub_match, logger)
+
+          subject
+        end
+
+        it "returns a not found response" do
+          expect(subject).to eql(HttpStub::Server::Response::NOT_FOUND)
+        end
+
+      end
+
+    end
+
+  end
+
+end