http_stub 0.25.1 → 0.26.0

data/spec/lib/http_stub/server/session/session_spec.rb

@@ -0,0 +1,444 @@
+describe HttpStub::Server::Session::Session do
+
+  let(:id)                { "Some session id" }
+  let(:scenario_registry) { instance_double(HttpStub::Server::Registry) }
+  let(:memory_session)    { instance_double(HttpStub::Server::Session::Session) }
+
+  let(:stub_registry)       { instance_double(HttpStub::Server::Stub::Registry) }
+  let(:stub_match_registry) { instance_double(HttpStub::Server::Registry) }
+  let(:stub_miss_registry)  { instance_double(HttpStub::Server::Registry) }
+
+  let(:logger) { instance_double(Logger) }
+
+  let(:session) { described_class.new(id, scenario_registry, memory_session) }
+
+  before(:example) do
+    allow(HttpStub::Server::Stub::Registry).to receive(:new).and_return(stub_registry)
+    allow(HttpStub::Server::Registry).to receive(:new).with("stub match").and_return(stub_match_registry)
+    allow(HttpStub::Server::Registry).to receive(:new).with("stub miss").and_return(stub_miss_registry)
+  end
+
+  it "uses a stub registry that is initialized with the provided memory session" do
+    expect(HttpStub::Server::Stub::Registry).to receive(:new).with(memory_session)
+
+    session
+  end
+
+  describe "#id" do
+
+    it "returns the provided id" do
+      expect(session.id).to eql(id)
+    end
+
+  end
+
+  describe "#matches?" do
+
+    subject { session.matches?(provided_id, logger) }
+
+    context "when the provided id is equal to the session id" do
+
+      let(:provided_id) { id }
+
+      it "returns true" do
+        expect(subject).to be(true)
+      end
+
+    end
+
+    context "when the provided id is not equal to the session id" do
+
+      let(:provided_id) { "Another session id" }
+
+      it "returns false" do
+        expect(subject).to be(false)
+      end
+
+    end
+
+  end
+
+  describe "activate_scenario!" do
+
+    let(:scenario_name) { "Some scenario name" }
+    let(:scenario)      { nil }
+
+    subject { session.activate_scenario!(scenario_name, logger) }
+
+    before(:example) { allow(scenario_registry).to receive(:find).with(scenario_name, anything).and_return(scenario) }
+
+    it "attempts to retrieve the scenario with the provided name from the scenario registry" do
+      expect(scenario_registry).to receive(:find).with(scenario_name, logger)
+
+      subject rescue nil
+    end
+
+    context "when the scenario is found" do
+
+      let(:scenario_trigger_names) { (1..3).map { |i| "scenario trigger #{i}" } }
+      let(:scenario_triggers)      do
+        scenario_trigger_names.map { |name| instance_double(HttpStub::Server::Scenario::Trigger, name: name) }
+      end
+      let(:triggered_scenarios)    do
+        (1..3).map { instance_double(HttpStub::Server::Scenario::Scenario, triggered_scenarios: [], stubs: []) }
+      end
+      let(:scenario_stubs)         { (1..3).map { instance_double(HttpStub::Server::Stub::Stub) } }
+      let(:scenario)               do
+        instance_double(HttpStub::Server::Scenario::Scenario, triggered_scenarios: scenario_triggers,
+                        stubs:               scenario_stubs)
+      end
+
+      before(:example) do
+        scenario_trigger_names.zip(triggered_scenarios).each do |scenario_trigger_name, triggered_scenario|
+          allow(scenario_registry).to(
+            receive(:find).with(scenario_trigger_name, anything).and_return(triggered_scenario)
+          )
+        end
+        allow(stub_registry).to receive(:concat)
+      end
+
+      it "triggers activation of the scenario triggers of the scenario" do
+        scenario_trigger_names.zip(triggered_scenarios).each do |scenario_trigger_name, triggered_scenario|
+          expect(scenario_registry).to receive(:find).with(scenario_trigger_name, logger).and_return(triggered_scenario)
+        end
+
+        subject
+      end
+
+      it "adds the scenarios stubs to the stub registry" do
+        expect(stub_registry).to receive(:concat).with(scenario_stubs, logger)
+
+        subject
+      end
+
+    end
+
+    context "when the scenario is not found" do
+
+      let(:scenario) { nil }
+
+      it "raises a scenario not found error with the provided name" do
+        expect { subject }.to raise_error(HttpStub::Server::Scenario::NotFoundError, /#{scenario_name}/)
+      end
+
+    end
+
+  end
+
+  describe "#add_stub" do
+
+    let(:the_stub) { instance_double(HttpStub::Server::Stub::Stub) }
+
+    subject { session.add_stub(the_stub, logger) }
+
+    it "adds the provided stub to the stub regsitry" do
+      expect(stub_registry).to receive(:add).with(the_stub, logger)
+
+      subject
+    end
+
+  end
+
+  describe "#find_stub" do
+
+    let(:id)       { SecureRandom.uuid }
+    let(:the_stub) { instance_double(HttpStub::Server::Stub::Stub) }
+
+    subject { session.find_stub(id, logger) }
+
+    before(:example) { allow(stub_registry).to receive(:find).and_return(the_stub) }
+
+    it "finds the stub with the provided id in the stub regsitry" do
+      expect(stub_registry).to receive(:find).with(id, logger)
+
+      subject
+    end
+
+    it "returns any found stub in the stub regsitry" do
+      expect(subject).to eql(the_stub)
+    end
+
+  end
+
+  describe "#stubs" do
+
+    let(:the_stubs) { (1..3).map { instance_double(HttpStub::Server::Stub::Stub) } }
+
+    subject { session.stubs }
+
+    before(:example) { allow(stub_registry).to receive(:all).and_return(the_stubs) }
+
+    it "finds all stubs in the stub regsitry" do
+      expect(stub_registry).to receive(:all)
+
+      subject
+    end
+
+    it "returns the stubs in the stub regsitry" do
+      expect(subject).to eql(the_stubs)
+    end
+
+  end
+
+  describe "#match" do
+
+    let(:request) { instance_double(HttpStub::Server::Request::Request) }
+
+    let(:matched_stub) { instance_double(HttpStub::Server::Stub::Stub) }
+
+    subject { session.match(request, logger) }
+
+    before(:example) { allow(stub_registry).to receive(:match).and_return(matched_stub) }
+
+    it "delegates to the stub registry to match the request with a stub" do
+      expect(stub_registry).to receive(:match).with(request, logger)
+
+      subject
+    end
+
+    it "returns any matched stub" do
+      expect(subject).to eql(matched_stub)
+    end
+
+  end
+
+  describe "#add_match" do
+
+    let(:triggered_scenario_names) { [] }
+    let(:triggered_stubs)          { [] }
+    let(:match_stub_triggers)      do
+      instance_double(HttpStub::Server::Stub::Triggers, scenario_names: triggered_scenario_names,
+                                                        stubs:          triggered_stubs)
+    end
+    let(:match_stub)               do
+      instance_double(HttpStub::Server::Stub::Stub, triggers: match_stub_triggers)
+    end
+    let(:match)                    { instance_double(HttpStub::Server::Stub::Match::Match, stub: match_stub) }
+
+    subject { session.add_match(match, logger) }
+
+    before(:example) do
+      allow(stub_match_registry).to receive(:add)
+    end
+
+    it "adds the match to the match registry" do
+      expect(stub_match_registry).to receive(:add).with(match, logger)
+
+      subject
+    end
+
+    context "when scenarios are to be triggered by the stub" do
+
+      let(:triggered_scenario_names) { (1..3).map { |i| "triggered scenario #{i}" } }
+
+      it "activates the scenarios in the session" do
+        triggered_scenario_names.each do |scenario_name|
+          expect(session).to receive(:activate_scenario!).with(scenario_name, logger)
+        end
+
+        subject
+      end
+
+    end
+
+    context "when no scenarios are to be triggered by the stub" do
+
+      let(:triggered_scenario_names) { [] }
+
+      it "does not activate any scenarios in the session" do
+        expect(session).to_not receive(:activate_scenario!)
+
+        subject
+      end
+
+    end
+
+    context "when stubs are to be triggered by the stub" do
+
+      let(:triggered_stubs) { (1..3).map { instance_double(HttpStub::Server::Stub::Stub) } }
+
+      it "adds the stubs to the session" do
+        triggered_stubs.each { |triggered_stub| expect(session).to receive(:add_stub).with(triggered_stub, logger) }
+
+        subject
+      end
+
+    end
+
+    context "when no stubs are to be triggered by the stub" do
+
+      let(:triggered_stubs) { [] }
+
+      it "does not add any stubs to the session" do
+        expect(session).to_not receive(:add_stub)
+
+        subject
+      end
+
+    end
+
+  end
+
+  describe "#matches" do
+
+    let(:stub_matches) { (1..3).map { instance_double(HttpStub::Server::Stub::Match::Match) } }
+
+    subject { session.matches }
+
+    before(:example) { allow(stub_match_registry).to receive(:all).and_return(stub_matches) }
+
+    it "retrieves all the matches in the stub match registry" do
+      expect(stub_match_registry).to receive(:all)
+
+      subject
+    end
+
+    it "returns any matches" do
+      expect(subject).to eql(stub_matches)
+    end
+
+  end
+
+  describe "#last_match" do
+
+    let(:match_args) { { uri: "some uri", method: "some method" } }
+
+    let(:stub_match) { instance_double(HttpStub::Server::Stub::Match::Match) }
+
+    subject { session.last_match(match_args, logger) }
+
+    before(:example) { allow(stub_match_registry).to receive(:find).and_return(stub_match) }
+
+    it "retrieves the match for the provided URI and method via the stub match registry" do
+      expect(stub_match_registry).to receive(:find).with(match_args, logger)
+
+      subject
+    end
+
+    it "returns any match" do
+      expect(subject).to eql(stub_match)
+    end
+
+  end
+
+  describe "#add_miss" do
+
+    let(:stub_miss) { instance_double(HttpStub::Server::Stub::Match::Miss) }
+
+    subject { session.add_miss(stub_miss, logger) }
+
+    it "adds the miss to the stub miss registry" do
+      expect(stub_miss_registry).to receive(:add).with(stub_miss, logger)
+
+      subject
+    end
+
+  end
+
+  describe "#misses" do
+
+    let(:stub_misses) { (1..3).map { instance_double(HttpStub::Server::Stub::Match::Miss) } }
+
+    subject { session.misses }
+
+    before(:example) { allow(stub_miss_registry).to receive(:all).and_return(stub_misses) }
+
+    it "retrieves all the misses in the stub miss registry" do
+      expect(stub_miss_registry).to receive(:all)
+
+      subject
+    end
+
+    it "returns any misses" do
+      expect(subject).to eql(stub_misses)
+    end
+
+  end
+
+  describe "#reset" do
+
+    subject { session.reset(logger) }
+
+    before(:example) do
+      allow(stub_registry).to receive(:reset)
+      allow(stub_match_registry).to receive(:clear)
+      allow(stub_miss_registry).to receive(:clear)
+    end
+
+    it "resets the stub registry to revert it to its original state" do
+      expect(stub_registry).to receive(:reset).with(logger)
+
+      subject
+    end
+
+    it "clears the stub miss registry to revert it to its original state" do
+      expect(stub_miss_registry).to receive(:clear).with(logger)
+
+      subject
+    end
+
+    it "clears the stub match registry to revert it to its original state" do
+      expect(stub_match_registry).to receive(:clear).with(logger)
+
+      subject
+    end
+
+    it "clears stub misses before the resetting stubs" do
+      expect(stub_miss_registry).to receive(:clear).ordered
+      expect(stub_registry).to receive(:reset).ordered
+
+      subject
+    end
+
+    it "clears stub matches before the resetting stubs" do
+      expect(stub_match_registry).to receive(:clear).ordered
+      expect(stub_registry).to receive(:reset).ordered
+
+      subject
+    end
+
+  end
+
+  describe "#clear" do
+
+    subject { session.clear(logger) }
+
+    before(:example) do
+      [ stub_registry, stub_match_registry, stub_miss_registry ].each { |registry| allow(registry).to receive(:clear) }
+    end
+
+    it "clears the stub registry" do
+      expect(stub_registry).to receive(:clear).with(logger)
+
+      subject
+    end
+
+    it "clears the stub miss registry" do
+      expect(stub_miss_registry).to receive(:clear).with(logger)
+
+      subject
+    end
+
+    it "clears the stub match registry" do
+      expect(stub_match_registry).to receive(:clear).with(logger)
+
+      subject
+    end
+
+    it "clears stub misses before the stubs" do
+      expect(stub_miss_registry).to receive(:clear).ordered
+      expect(stub_registry).to receive(:clear).ordered
+
+      subject
+    end
+
+    it "clears stub matches before the stubs" do
+      expect(stub_match_registry).to receive(:clear).ordered
+      expect(stub_registry).to receive(:clear).ordered
+
+      subject
+    end
+
+  end
+
+end

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

@@ -1,26 +1,27 @@
 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(:stub_uri) { "/some/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_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_registry, miss_registry) }
-
-  before(:example) do
-    allow(HttpStub::Server::Stub::Parser).to receive(:parse).and_return(payload)
-    allow(HttpStub::Server::Stub).to receive(:create).and_return(the_stub)
+  let(:request_parameters)  { {} }
+  let(:session)             { instance_double(HttpStub::Server::Session::Session) }
+  let(:request)             do
+    instance_double(HttpStub::Server::Request::Request, parameters: request_parameters, session: session)
   end
+  let(:logger)              { instance_double(Logger) }
+  let(:payload)             { HttpStub::StubFixture.new.server_payload }
+  let(:stub_uri)            { "/some/stub/uri" }
+  let(:the_stub)            { instance_double(HttpStub::Server::Stub::Stub, uri: stub_uri) }
+
+  let(:controller) { described_class.new }
 
   describe "#register" do
 
     subject { controller.register(request, logger) }
 
+    before(:example) do
+      allow(HttpStub::Server::Stub::Parser).to receive(:parse).and_return(payload)
+      allow(HttpStub::Server::Stub).to receive(:create).and_return(the_stub)
+      allow(session).to receive(:add_stub)
+    end
+
     it "parses the payload from the request" do
       expect(HttpStub::Server::Stub::Parser).to receive(:parse).with(request).and_return(payload)
 
@@ -33,8 +34,8 @@ describe HttpStub::Server::Stub::Controller do
       subject
     end
 
-    it "adds the stub to the stub registry" do
-      expect(stub_registry).to receive(:add).with(the_stub, logger)
+    it "adds the stub to the users session" do
+      expect(session).to receive(:add_stub).with(the_stub, logger)
 
       subject
     end
@@ -56,20 +57,30 @@ describe HttpStub::Server::Stub::Controller do
 
   describe "#match" do
 
+    let(:matched_stub) { nil }
+
     let(:calculated_stub_response) { instance_double(HttpStub::Server::Stub::Response::Base) }
 
     subject { controller.match(request, logger) }
 
     before(:example) do
-      allow(stub_registry).to receive(:match).with(request, logger).and_return(matched_stub)
+      allow(session).to receive(:match).and_return(matched_stub)
       allow(the_stub).to receive(:response_for).and_return(calculated_stub_response)
     end
 
-    describe "when a stub has been registered that matches the request" do
+    it "evaluates the matching stub for the user" do
+      allow(session).to receive(:add_match)
+      allow(session).to receive(:add_miss)
+      expect(session).to receive(:match).with(request, logger)
+
+      subject
+    end
+
+    describe "when a stub matches the request" do
 
       let(:matched_stub) { the_stub }
 
-      before(:example) { allow(match_registry).to receive(:add) }
+      before(:example) { allow(session).to receive(:add_match) }
 
       it "calculates the stubs response based on the request" do
         expect(the_stub).to receive(:response_for).with(request)
@@ -83,16 +94,16 @@ describe HttpStub::Server::Stub::Controller do
         subject
       end
 
-      it "adds the match to the match registry" do
+      it "adds the match to the users session" 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)
+        expect(session).to receive(:add_match).with(match, logger)
 
         subject
       end
 
-      it "does not add to the miss registry" do
-        expect(miss_registry).to_not receive(:add)
+      it "does not add to the users session" do
+        expect(session).to_not receive(:add_miss)
 
         subject
       end
@@ -107,7 +118,7 @@ describe HttpStub::Server::Stub::Controller do
 
       let(:matched_stub) { nil }
 
-      before(:example) { allow(miss_registry).to receive(:add) }
+      before(:example) { allow(session).to receive(:add_miss) }
 
       it "returns a not found response" do
         expect(subject).to eql(HttpStub::Server::Response::NOT_FOUND)
@@ -119,16 +130,16 @@ describe HttpStub::Server::Stub::Controller do
         subject
       end
 
-      it "adds the miss to the miss registry" do
+      it "adds the miss to the users session" 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)
+        expect(session).to receive(:add_miss).with(miss, logger)
 
         subject
       end
 
-      it "does not add to the match registry" do
-        expect(match_registry).to_not receive(:add)
+      it "does not add to the match to the users session" do
+        expect(session).to_not receive(:add_match)
 
         subject
       end
@@ -137,24 +148,65 @@ describe HttpStub::Server::Stub::Controller do
 
   end
 
-  describe "#clear" do
+  describe "#find" do
+
+    let(:id)                 { SecureRandom.uuid }
+    let(:request_parameters) { { stub_id: id } }
+
+    subject { controller.find(request, logger) }
+
+    before(:example) { allow(session).to receive(:find_stub).and_return(the_stub) }
+
+    it "finds the stub with the parameterized id in the user session" do
+      expect(session).to receive(:find_stub).with(id, logger)
+
+      subject
+    end
+
+    it "returns the found stub" do
+      expect(subject).to eql(the_stub)
+    end
+
+  end
 
-    subject { controller.clear(logger) }
+  describe "#find_all" do
 
-    it "clears the stub registry" do
-      expect(stub_registry).to receive(:clear).with(logger)
+    let(:stubs) { (1..3).map { instance_double(HttpStub::Server::Stub::Stub) } }
+
+    subject { controller.find_all(request) }
+
+    before(:example) { allow(session).to receive(:stubs).and_return(stubs) }
+
+    it "retrieves all stubs from the users session" do
+      expect(session).to receive(:stubs)
 
       subject
     end
 
-    it "clears the match registry" do
-      expect(match_registry).to receive(:clear).with(logger)
+    it "returns the stubs" do
+      expect(subject).to eql(stubs)
+    end
+
+  end
+
+  describe "#reset" do
+
+    subject { controller.reset(request, logger) }
+
+    it "resets the users session" do
+      expect(session).to receive(:reset).with(logger)
 
       subject
     end
 
-    it "clears the miss registry" do
-      expect(miss_registry).to receive(:clear).with(logger)
+  end
+
+  describe "#clear" do
+
+    subject { controller.clear(request, logger) }
+
+    it "clears the users session" do
+      expect(session).to receive(:clear).with(logger)
 
       subject
     end