http_stub 0.25.1 → 0.26.0

data/spec/lib/http_stub/server/application/session_uri_support_spec.rb

@@ -0,0 +1,48 @@
+describe HttpStub::Server::Application::SessionUriSupport do
+
+  class HttpStub::Server::Application::SessionUriSupport::TestApplication
+    include HttpStub::Server::Application::SessionUriSupport
+
+    def initialize(request)
+      @request = request
+    end
+
+    def http_stub_request
+      @request
+    end
+
+  end
+
+  let(:session_id) { "some_session_id" }
+  let(:session)    { instance_double(HttpStub::Server::Session::Session, id: session_id) }
+  let(:request)    { instance_double(HttpStub::Server::Request::Request, session: session) }
+
+  let(:application) { HttpStub::Server::Application::SessionUriSupport::TestApplication.new(request) }
+
+  describe "#session_uri" do
+
+    let(:uri) { "http://some/uri" }
+
+    subject { application.session_uri(uri) }
+
+    context "when the uri contains parameters" do
+
+      let(:uri) { "http://some/uri?parameter_name=parameter_value" }
+
+      it "adds a http_stub_session_id parameter to the uri containing the current session id" do
+        expect(subject).to eql("#{uri}&http_stub_session_id=some_session_id")
+      end
+
+    end
+
+    context "when the uri does not contain parameters" do
+
+      it "adds a http_stub_session_id parameter to the uri containing the current session id" do
+        expect(subject).to eql("#{uri}?http_stub_session_id=some_session_id")
+      end
+
+    end
+
+  end
+
+end

data/spec/lib/http_stub/server/application/text_formatting_support_spec.rb

@@ -2,19 +2,19 @@ describe HttpStub::Server::Application::TextFormattingSupport do
 
   let(:text_formatting_support) { Class.new.extend(described_class) }
 
-  describe "::h" do
+  describe "#h" do
 
     let(:text) { "<tag>Some text</tag>" }
 
     subject { text_formatting_support.h(text) }
 
     it "should escape the provided HTML" do
-      expect(subject).to eq("&lt;tag&gt;Some text&lt;&#x2F;tag&gt;")
+      expect(subject).to eql("&lt;tag&gt;Some text&lt;&#x2F;tag&gt;")
     end
 
   end
 
-  describe "::pp" do
+  describe "#pp" do
 
     subject { text_formatting_support.pp(text) }
 

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

@@ -0,0 +1,47 @@
+describe HttpStub::Server::Memory::Controller do
+
+  let(:session_configuration) { instance_double(HttpStub::Server::Session::Configuration) }
+  let(:server_memory)         { instance_double(HttpStub::Server::Memory::Memory) }
+
+  let(:controller) { described_class.new(session_configuration, server_memory) }
+
+  describe "#find_stubs" do
+
+    let(:memorized_stubs) { (1..3).map { instance_double(HttpStub::Server::Stub::Stub) } }
+
+    subject { controller.find_stubs }
+
+    before(:example) { allow(server_memory).to receive(:stubs).and_return(memorized_stubs) }
+
+    it "returns the stubs within the servers memory" do
+      expect(subject).to eql(memorized_stubs)
+    end
+
+  end
+
+  describe "#reset" do
+
+    let(:logger) { instance_double(Logger) }
+
+    subject { controller.reset(logger) }
+
+    before(:example) do
+      allow(session_configuration).to receive(:reset)
+      allow(server_memory).to receive(:reset)
+    end
+
+    it "resets the servers session configuration" do
+      expect(session_configuration).to receive(:reset)
+
+      subject
+    end
+
+    it "resets the servers memory providing the logger" do
+      expect(server_memory).to receive(:reset).with(logger)
+
+      subject
+    end
+
+  end
+
+end

data/spec/lib/http_stub/server/memory/memory_spec.rb

@@ -0,0 +1,122 @@
+describe HttpStub::Server::Memory::Memory do
+
+  let(:session_configuration) { instance_double(HttpStub::Server::Session::Configuration) }
+
+  let(:memory_session)    { instance_double(HttpStub::Server::Session::Session) }
+  let(:scenario_registry) { instance_double(HttpStub::Server::Registry) }
+  let(:session_registry)  { instance_double(HttpStub::Server::Session::Registry) }
+
+  let(:memory) { described_class.new(session_configuration) }
+
+  before(:example) do
+    allow(HttpStub::Server::Session::Session).to receive(:new).and_return(memory_session)
+    allow(HttpStub::Server::Registry).to receive(:new).and_return(scenario_registry)
+    allow(HttpStub::Server::Session::Registry).to receive(:new).and_return(session_registry)
+  end
+
+  it "creates a simple scenario registry" do
+    expect(HttpStub::Server::Registry).to receive(:new).with("scenario")
+
+    memory
+  end
+
+  it "creates a memory session" do
+    expect(HttpStub::Server::Session::Session).to(
+      receive(:new).with(HttpStub::Server::Session::MEMORY_SESSION_ID, anything, anything)
+    )
+
+    memory
+  end
+
+  it "creates a memory session containing the scenario registry" do
+    expect(HttpStub::Server::Session::Session).to receive(:new).with(anything, scenario_registry, anything)
+
+    memory
+  end
+
+  it "creates a memory session containing an empty memory session" do
+    expect(HttpStub::Server::Session::Session).to(
+      receive(:new).with(anything, anything, HttpStub::Server::Session::Empty)
+    )
+
+    memory
+  end
+
+  it "creates a session registry containing the session configuration" do
+    expect(HttpStub::Server::Session::Registry).to receive(:new).with(session_configuration, anything, anything)
+
+    memory
+  end
+
+  it "creates a session registry containing the scenario registry" do
+    expect(HttpStub::Server::Session::Registry).to receive(:new).with(anything, scenario_registry, anything)
+
+    memory
+  end
+
+  it "creates a session registry initalised with the memory session" do
+    expect(HttpStub::Server::Session::Registry).to receive(:new).with(anything, anything, memory_session)
+
+    memory
+  end
+
+  describe "#scenarios" do
+
+    subject { memory.scenarios }
+
+    it "returns the servers scenario registry" do
+      expect(subject).to eql(scenario_registry)
+    end
+
+  end
+
+  describe "#sessions" do
+
+    subject { memory.sessions }
+
+    it "returns the servers session registry" do
+      expect(subject).to eql(session_registry)
+    end
+
+  end
+
+  describe "#stubs" do
+
+    let(:stubs) { (1..3).map { instance_double(HttpStub::Server::Stub::Stub) } }
+
+    subject { memory.stubs }
+
+    before(:example) { allow(memory_session).to receive(:stubs).and_return(stubs) }
+
+    it "returns the stubs within the memory session" do
+      expect(subject).to eql(stubs)
+    end
+
+  end
+
+  describe "#reset" do
+
+    let(:logger) { instance_double(Logger) }
+
+    subject { memory.reset(logger) }
+
+    before(:example) do
+      allow(scenario_registry).to receive(:clear)
+      allow(session_registry).to receive(:clear)
+    end
+
+    it "clears the servers scenarios" do
+      expect(scenario_registry).to receive(:clear).with(logger)
+
+      subject
+    end
+
+    it "clears the servers sessions" do
+      expect(session_registry).to receive(:clear).with(logger)
+
+      subject
+    end
+
+  end
+
+end

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

@@ -1,17 +1,65 @@
 describe HttpStub::Server::Registry do
 
-  let(:logger)  { instance_double(Logger, info: nil) }
+  let(:model_name) { "a_model" }
 
-  let(:registry) { HttpStub::Server::Registry.new("a_model") }
+  let(:logger) { instance_double(Logger, info: nil) }
 
-  shared_context "register multiple models" do
+  let(:registry) { described_class.new(model_name) }
+
+  shared_context "multiple models" do
 
-    let(:models) { (1..3).map { |i| double("HttpStub::Server::Model#{i}", :matches? => false) } }
+    let(:models) { (1..3).map { |i| double("HttpStub::Server::Model#{i}", matches?: false) } }
+
+  end
+
+  shared_context "register multiple models" do
+    include_context "multiple models"
 
     before(:example) { registry.concat(models, logger) }
 
   end
 
+  shared_context "one model matches" do
+
+    let(:matching_model) { models[1] }
+
+    before(:example) { allow(matching_model).to receive(:matches?).and_return(true) }
+
+  end
+
+  shared_context "many models match" do
+
+    let(:matching_models) { [ models[0], models[2] ] }
+
+    before(:example) { matching_models.each { |model| allow(model).to receive(:matches?).and_return(true) } }
+
+  end
+
+  describe "constructor" do
+
+    context "when models are provided" do
+      include_context "multiple models"
+
+      subject { described_class.new(model_name, models) }
+
+      it "creates a registry with the models" do
+        expect(subject.all).to eql(models)
+      end
+
+    end
+
+    context "when models are not provided" do
+
+      subject { described_class.new(model_name) }
+
+      it "creates a registy with no models" do
+        expect(subject.all).to eql([])
+      end
+
+    end
+
+  end
+
   describe "#add" do
 
     let(:model_string_representation) { "some model string" }
@@ -46,18 +94,69 @@ describe HttpStub::Server::Registry do
 
     subject { registry.concat(models, logger) }
 
+    it "adds the models" do
+      subject
+
+      expect_registry_to_contain(models)
+    end
+
     it "logs that the models have been registered" do
       model_string_representations.each do |string_representation|
-        expect(logger).to receive(:info).with(/#{string_representation}/)
+        expect(logger).to receive(:info).with(/Registered.+#{string_representation}/)
       end
 
       subject
     end
 
-    it "adds the models" do
+  end
+
+  describe "#replace" do
+
+    let(:model_string_representations) { (1..3).map { |i| "model string ##{i}" } }
+    let(:models) do
+      model_string_representations.map do |string_representation|
+        double("HttpStub::Server::Model", to_s: string_representation)
+      end
+    end
+
+    subject { registry.replace(models, logger) }
+
+    context "when no models had been added" do
+
+      it "establishes the models" do
+        subject
+
+        expect_registry_to_contain(models)
+      end
+
+    end
+
+    context "when models had been added" do
+
+      let(:original_models) { (1..3).map { double("HttpStub::Server::Model") } }
+
+      before(:example) { registry.concat(original_models, logger) }
+
+      it "replaces those models with the provided models" do
+        subject
+
+        expect_registry_to_contain(models)
+      end
+
+    end
+
+    it "logs that the models are being cleared" do
+      expect(logger).to receive(:info).with(/clearing a_model/i)
+
       subject
+    end
+
+    it "logs that the models have been registered" do
+      model_string_representations.each do |string_representation|
+        expect(logger).to receive(:info).with(/Registered.+#{string_representation}/)
+      end
 
-      expect(registry.all).to eql(models.reverse)
+      subject
     end
 
   end
@@ -78,10 +177,7 @@ describe HttpStub::Server::Registry do
       end
 
       describe "and one registered model matches the criteria" do
-
-        let(:matching_model) { models[1] }
-
-        before(:example) { allow(matching_model).to receive(:matches?).and_return(true) }
+        include_context "one model matches"
 
         it "returns the model" do
           expect(subject).to eql(matching_model)
@@ -100,11 +196,10 @@ describe HttpStub::Server::Registry do
       end
 
       describe "and multiple registered models satisfy the criteria" do
-
-        before(:example) { [0, 2].each { |i| allow(models[i]).to receive(:matches?).and_return(true) } }
+        include_context "many models match"
 
         it "supports model overrides by returning the last model registered" do
-          expect(subject).to eql(models[2])
+          expect(subject).to eql(matching_models.last)
         end
 
       end
@@ -127,7 +222,7 @@ describe HttpStub::Server::Registry do
 
     end
 
-    it "it should log model discovery diagnostics that includes the complete details of the criteria" do
+    it "logs model discovery diagnostics that include the complete details of the criteria" do
       expect(logger).to receive(:info).with(/Criteria inspect result/)
 
       subject
@@ -166,7 +261,7 @@ describe HttpStub::Server::Registry do
       include_context "register multiple models"
 
       it "returns the registered models in the order they were added" do
-        expect(registry.all).to eql(models.reverse)
+        expect_registry_to_contain(models)
       end
 
     end
@@ -174,58 +269,78 @@ describe HttpStub::Server::Registry do
     context "when no model has been registered" do
 
       it "returns an empty list" do
-        expect(registry.all).to eql([])
+        expect_registry_to_contain([])
       end
 
     end
 
   end
 
-  describe "#rollback_to" do
+  describe "#delete" do
 
-    subject { registry.rollback_to(model) }
+    let(:criteria) { double("Criteria", inspect: "Criteria inspect result") }
 
-    context "when models have been added" do
+    subject { registry.delete(criteria, logger) }
+
+    context "when multiple models have been registered" do
       include_context "register multiple models"
 
-      context "and the rollback is to one of those models" do
+      it "determines if the models satisfy the provided criteria" do
+        models.each { |model| expect(model).to receive(:matches?).with(criteria, logger).and_return(false) }
 
-        let(:model) { models[1] }
+        subject
+      end
+
+      context "when the criteria matches a model" do
+        include_context "one model matches"
 
-        it "the models remaining are those added up to and including the provided model" do
+        it "deletes the matched model from the registry" do
           subject
 
-          expect(registry.all).to eql(models[0, 2].reverse)
+          expect_registry_to_contain(models - [ matching_model ])
         end
 
       end
 
-      context "and the rollback is to a model that has not been added" do
+      context "when the criteria matches many models" do
+        include_context "many models match"
+
+        it "deletes all matching models" do
+          subject
 
-        let(:model) { double("HttpStub::Server::Model") }
+          expect_registry_to_contain(models - matching_models)
+        end
 
-        it "does not remove any models" do
+      end
+
+      context "when the criteria does not match any model" do
+
+        it "does not delete any models" do
           subject
 
-          expect(registry.all).to eql(models.reverse)
+          expect_registry_to_contain(models)
         end
 
       end
 
     end
 
-    context "when no models have been added" do
-
-      let(:model) { double("HttpStub::Server::Model") }
+    context "when no model has been registered" do
 
-      it "does not effect the known models" do
+      it "does not delete any models" do
         subject
 
-        expect(registry.all).to be_empty
+        expect_registry_to_contain([])
       end
 
     end
 
+    it "logs model deletion diagnostics that include the complete details of the criteria" do
+      expect(logger).to receive(:info).with(/Criteria inspect result/)
+
+      subject
+    end
+
   end
 
   describe "#clear" do
@@ -244,11 +359,15 @@ describe HttpStub::Server::Registry do
       it "releases all knowledge of the models" do
         subject
 
-        expect(registry.all).to be_empty
+        expect_registry_to_contain([])
       end
 
     end
 
   end
 
+  def expect_registry_to_contain(models)
+    expect(registry.all).to eql(models.reverse)
+  end
+
 end