http_stub 0.25.1 → 0.26.0

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

@@ -0,0 +1,25 @@
+describe HttpStub::Server::Scenario::NotFoundError do
+
+  let(:scenario_name) { "Some scenario name" }
+
+  let(:error) { described_class.new(scenario_name) }
+
+  it "is a Standard Error" do
+    expect(error).to be_a(::StandardError)
+  end
+
+  describe "#message" do
+
+    subject { error.message }
+
+    it "contains the name of the scenario" do
+      expect(subject).to include(scenario_name)
+    end
+
+    it "indicates the scenario was not found" do
+      expect(subject).to include("not found")
+    end
+
+  end
+
+end

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

@@ -0,0 +1,94 @@
+describe HttpStub::Server::Session::Configuration do
+
+  let(:identifier_setting) { nil }
+
+  let(:configuration) { described_class.new(identifier_setting) }
+
+  describe "#identifer_configuration" do
+
+    subject { configuration.identifier_configuration }
+
+    shared_examples_for "an identifier configuration starting with the default configuration" do
+
+      it "has the http_stub session id parameter as the first entry" do
+        expect(subject.first).to eql(parameter: :http_stub_session_id)
+      end
+
+      it "has the http_stub session id header as the second entry" do
+        expect(subject[1]).to eql(header: :http_stub_session_id)
+      end
+
+    end
+
+    context "when a setting is provided" do
+
+      let(:identifier_setting) { { header: :custom_session_header } }
+
+      it_behaves_like "an identifier configuration starting with the default configuration"
+
+      it "returns a configuration containing the setting as the last entry" do
+        expect(subject.last).to eql(header: :custom_session_header)
+      end
+
+      it "returns a configuration containing only the default settings and the provided setting" do
+        expect(subject.size).to eql(3)
+      end
+
+    end
+
+    context "when no setting is provided" do
+
+      let(:identifier_setting) { nil }
+
+      it_behaves_like "an identifier configuration starting with the default configuration"
+
+      it "returns a configuration containing only the default settings" do
+        expect(subject.size).to eql(2)
+      end
+
+    end
+
+  end
+
+  describe "#default_identifier" do
+
+    subject { configuration.default_identifier }
+
+    it "has an original value that is the memory session id" do
+      expect(subject).to eql(HttpStub::Server::Session::MEMORY_SESSION_ID)
+    end
+
+    context "when changed" do
+
+      let(:new_identifier) { "some other identifier" }
+
+      before(:example) { configuration.default_identifier = new_identifier }
+
+      it "returns the newly assigned value" do
+        expect(subject).to eql(new_identifier)
+      end
+
+    end
+
+  end
+
+  describe "#reset" do
+
+    subject { configuration.reset }
+
+    context "when the default indentifier has changed" do
+
+      before(:example) { configuration.default_identifier = "some other identifier" }
+
+      it "reverts the default identifier to it's original value" do
+        subject
+
+        expect(configuration.default_identifier).to eql(HttpStub::Server::Session::MEMORY_SESSION_ID)
+
+      end
+
+    end
+
+  end
+
+end

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

@@ -0,0 +1,106 @@
+describe HttpStub::Server::Session::Controller do
+
+  let(:session_configuration) { instance_double(HttpStub::Server::Session::Configuration) }
+  let(:session_registry)      { instance_double(HttpStub::Server::Session::Registry) }
+  let(:server_memory)         { instance_double(HttpStub::Server::Memory::Memory, sessions: session_registry) }
+
+  let(:session_id) { "some session id" }
+  let(:request)    { instance_double(HttpStub::Server::Request::Request, session_id: session_id) }
+  let(:logger)     { instance_double(Logger) }
+
+  let(:controller) { described_class.new(session_configuration, server_memory) }
+
+  describe "#find" do
+
+    subject { controller.find(request, logger) }
+
+    it "finds a session in the servers session registry with a session id matching that in the request" do
+      expect(session_registry).to receive(:find).with(session_id, logger)
+
+      subject
+    end
+
+    it "returns any found session" do
+      session = instance_double(HttpStub::Server::Session::Session)
+      allow(session_registry).to receive(:find).and_return(session)
+
+      expect(subject).to eql(session)
+    end
+
+  end
+
+  describe "#find_transactional" do
+
+    subject { controller.find_transactional(logger) }
+
+    it "finds a session in the servers session registry with the transactional session id" do
+      expect(session_registry).to receive(:find).with(HttpStub::Server::Session::TRANSACTIONAL_SESSION_ID, logger)
+
+      subject
+    end
+
+    it "returns any found session" do
+      transactional_session = instance_double(HttpStub::Server::Session::Session)
+      allow(session_registry).to receive(:find).and_return(transactional_session)
+
+      expect(subject).to eql(transactional_session)
+    end
+
+  end
+
+  describe "#find_all" do
+
+    subject { controller.find_all }
+
+    it "retrieves all sessions in the servers session reigstry" do
+      expect(session_registry).to receive(:all)
+
+      subject
+    end
+
+    it "returns the sessions" do
+      sessions = (1..3).map { instance_double(HttpStub::Server::Session::Session) }
+      allow(session_registry).to receive(:all).and_return(sessions)
+
+      expect(subject).to eql(sessions)
+    end
+
+  end
+
+  describe "#mark_default" do
+
+    subject { controller.mark_default(request) }
+
+    it "establishes the default session identifier in the servers session configuration" do
+      expect(session_configuration).to receive(:default_identifier=).with(session_id)
+
+      subject
+    end
+
+  end
+
+  describe "#delete" do
+
+    subject { controller.delete(request, logger) }
+
+    it "deletes the session identified in the request from servers session registry" do
+      expect(session_registry).to receive(:delete).with(session_id, logger)
+
+      subject
+    end
+
+  end
+
+  describe "#clear" do
+
+    subject { controller.clear(logger) }
+
+    it "delegates to the servers session registry" do
+      expect(session_registry).to receive(:clear).with(logger)
+
+      subject
+    end
+
+  end
+
+end

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

@@ -0,0 +1,13 @@
+describe HttpStub::Server::Session::Empty do
+
+  describe "::stubs" do
+
+    subject { described_class.stubs }
+
+    it "returns an empty array" do
+      expect(subject).to eql([])
+    end
+
+  end
+
+end

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

@@ -0,0 +1,126 @@
+describe HttpStub::Server::Session::IdentifierStrategy do
+
+  let(:identifier_configuration) { {} }
+  let(:session_configuration) do
+    instance_double(HttpStub::Server::Session::Configuration, identifier_configuration: identifier_configuration)
+  end
+
+  let(:identifier_strategy) { described_class.new(session_configuration) }
+
+  describe "#identifier_for" do
+
+    let(:request_headers)    { {} }
+    let(:request_parameters) { {} }
+    let(:sinatra_request)    do
+      instance_double(HttpStub::Server::Request::SinatraRequest, headers:    request_headers,
+                                                                 parameters: request_parameters)
+    end
+
+    subject { identifier_strategy.identifier_for(sinatra_request) }
+
+    context "when the session identifier configuration has multiple entries" do
+
+      let(:identifier_configuration) do
+        [
+          { header:    :first_session_header },
+          { parameter: :first_session_parameter },
+          { header:    :second_session_header },
+          { parameter: :second_session_parameter }
+        ]
+      end
+
+      context "and multiple session values are in the request" do
+
+        let(:request_headers)    do
+          { second_session_header: "second session header value", another_header: "another header value" }
+        end
+        let(:request_parameters) do
+          { first_session_parameter: "first session parameter value", another_parameter: "another parameter value" }
+        end
+
+        it "returns the first value from the configuration in the request" do
+          expect(subject).to eql("first session parameter value")
+        end
+
+      end
+
+      context "and one session value is in the request" do
+
+        let(:request_headers)    { { a_header: "a header value" } }
+        let(:request_parameters) do
+          { second_session_parameter: "second session parameter value", another_parameter: "another parameter value" }
+        end
+
+        it "returns the value" do
+          expect(subject).to eql("second session parameter value")
+        end
+
+      end
+
+      context "and the session value is not in the request" do
+
+        it "returns nil" do
+          expect(subject).to eql(nil)
+        end
+
+      end
+
+    end
+
+    context "when the session identifier configuration has one entry" do
+
+      context "that is a header" do
+
+        let(:identifier_configuration) { [ { header: :session_header } ] }
+
+        context "and the session value is in the request" do
+
+          let(:request_headers) { { session_header: "session header value", another_header: "another header value" } }
+
+          it "returns the value" do
+            expect(subject).to eql("session header value")
+          end
+
+        end
+
+        context "and the session value is not in the request" do
+
+          it "returns nil" do
+            expect(subject).to eql(nil)
+          end
+
+        end
+
+      end
+
+      context "that is a parameter" do
+
+        let(:identifier_configuration) { [ { parameter: :session_parameter } ] }
+
+        context "and the session value is in the request" do
+
+          let(:request_parameters) do
+            { session_parameter: "session parameter value", another_parameter: "another parameter value" }
+          end
+
+          it "returns the value" do
+            expect(subject).to eql("session parameter value")
+          end
+
+        end
+
+        context "and the session value is not in the request" do
+
+          it "returns nil" do
+            expect(subject).to eql(nil)
+          end
+
+        end
+
+      end
+
+    end
+
+  end
+
+end

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

@@ -0,0 +1,214 @@
+describe HttpStub::Server::Session::Registry do
+
+  let(:default_session_id)    { "some default session id" }
+  let(:session_configuration) do
+    instance_double(HttpStub::Server::Session::Configuration, default_identifier: default_session_id)
+  end
+  let(:scenario_registry)     { instance_double(HttpStub::Server::Registry) }
+  let(:memory_session)        { instance_double(HttpStub::Server::Session::Session) }
+
+  let(:logger)                      { instance_double(Logger) }
+  let(:underlying_session_registry) { instance_double(HttpStub::Server::Registry) }
+
+  let(:session_registry) { described_class.new(session_configuration, scenario_registry, memory_session) }
+
+  before(:example) { allow(HttpStub::Server::Registry).to receive(:new).and_return(underlying_session_registry) }
+
+  it "uses an underlying simple registry that is initialized with the memory session" do
+    expect(HttpStub::Server::Registry).to receive(:new).with("session", [ memory_session ])
+
+    session_registry
+  end
+
+  describe "#find" do
+
+    let(:id) { SecureRandom.uuid }
+
+    let(:found_session) { instance_double(HttpStub::Server::Session::Session) }
+
+    subject { session_registry.find(id, logger) }
+
+    before(:example) { allow(underlying_session_registry).to receive(:find).and_return(found_session) }
+
+    it "delegates to an underlying simple registry" do
+      expect(underlying_session_registry).to receive(:find).with(id, logger)
+
+      subject
+    end
+
+    it "returns any found session" do
+      expect(subject).to eql(found_session)
+    end
+
+  end
+
+  describe "#find_or_create" do
+
+    let(:session_id) { "some session id" }
+
+    let(:found_session) { instance_double(HttpStub::Server::Session::Session) }
+
+    subject { session_registry.find_or_create(session_id, logger) }
+
+    before(:example) { allow(underlying_session_registry).to receive(:find).and_return(found_session) }
+
+    context "when an id is provided" do
+
+      it "attempts to find a session with the provided id in the underlying simple registry" do
+        expect(underlying_session_registry).to receive(:find).with(session_id, logger)
+
+        subject
+      end
+
+      context "and a session is not found" do
+
+        let(:found_session) { nil }
+
+        before(:example) { allow(underlying_session_registry).to receive(:add) }
+
+        it "creates a session with the provided id" do
+          expect(HttpStub::Server::Session::Session).to receive(:new).with(session_id, anything, anything)
+
+          subject
+        end
+
+      end
+
+    end
+
+    context "when an id is not provided" do
+
+      let(:session_id) { nil }
+
+      it "attempts to find a session with the default id defined in the session configuration" do
+        expect(underlying_session_registry).to receive(:find).with(default_session_id, logger)
+
+        subject
+      end
+
+      context "and a session is not found" do
+
+        let(:found_session) { nil }
+
+        before(:example) { allow(underlying_session_registry).to receive(:add) }
+
+        it "creates a session with the default session id" do
+          expect(HttpStub::Server::Session::Session).to receive(:new).with(default_session_id, anything, anything)
+
+          subject
+        end
+
+      end
+
+    end
+
+    context "when a session is found" do
+
+      let(:found_session) { instance_double(HttpStub::Server::Session::Session) }
+
+      it "returns the found session" do
+        expect(subject).to eql(found_session)
+      end
+
+      it "does not add a session to the underlying simple registry" do
+        expect(underlying_session_registry).to_not receive(:add)
+
+        subject
+      end
+
+    end
+
+    context "when a session is not found" do
+
+      let(:found_session)   { nil }
+      let(:created_session) { instance_double(HttpStub::Server::Session::Session) }
+
+      before(:example) do
+        allow(HttpStub::Server::Session::Session).to receive(:new).and_return(created_session)
+        allow(underlying_session_registry).to receive(:add)
+      end
+
+      it "creates a session with the provided scenario registry" do
+        expect(HttpStub::Server::Session::Session).to receive(:new).with(anything, scenario_registry, anything)
+
+        subject
+      end
+
+      it "creates a session with the provided memory session" do
+        expect(HttpStub::Server::Session::Session).to receive(:new).with(anything, anything, memory_session)
+
+        subject
+      end
+
+      it "adds the created session to the underlying simple registry" do
+        expect(underlying_session_registry).to receive(:add).with(created_session, logger)
+
+        subject
+      end
+
+      it "returns the created session" do
+        expect(subject).to eql(created_session)
+      end
+
+    end
+
+  end
+
+  describe "#all" do
+
+    let(:sessions) { (1..3).map { instance_double(HttpStub::Server::Session::Session) } }
+
+    subject { session_registry.all }
+
+    before(:example) { allow(underlying_session_registry).to receive(:all).and_return(sessions) }
+
+    it "delegates to an underlying simple registry" do
+      expect(underlying_session_registry).to receive(:all)
+
+      subject
+    end
+
+    it "returns the result from the underlying simple registry" do
+      expect(subject).to eql(sessions)
+    end
+
+  end
+
+  describe "#delete" do
+
+    let(:id) { SecureRandom.uuid }
+
+    subject { session_registry.delete(id, logger) }
+
+    it "delegates to the underlying simple registry" do
+      expect(underlying_session_registry).to receive(:delete).with(id, logger)
+
+      subject
+    end
+
+  end
+
+  describe "#clear" do
+
+    subject { session_registry.clear(logger) }
+
+    before(:example) do
+      allow(memory_session).to receive(:clear)
+      allow(underlying_session_registry).to receive(:replace)
+    end
+
+    it "clears the memory session" do
+      expect(memory_session).to receive(:clear).with(logger)
+
+      subject
+    end
+
+    it "replaces all sessions in the underlying simple registry with the memory session" do
+      expect(underlying_session_registry).to receive(:replace).with([ memory_session ], logger)
+
+      subject
+    end
+
+  end
+
+end