http_stub 0.25.1 → 0.26.0

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

@@ -0,0 +1,74 @@
+describe HttpStub::Server::Request::Factory 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_identifier_strategy) { instance_double(HttpStub::Server::Session::IdentifierStrategy) }
+
+  let(:factory) { described_class.new(session_configuration, server_memory) }
+
+  before(:example) do
+    allow(HttpStub::Server::Session::IdentifierStrategy).to receive(:new).and_return(session_identifier_strategy)
+  end
+
+  it "creates a session identifier strategy based on the session configuration" do
+    expect(HttpStub::Server::Session::IdentifierStrategy).to receive(:new).with(session_configuration)
+
+    factory
+  end
+
+  describe "#create" do
+
+    let(:rack_request)       { Rack::RequestFixture.create }
+    let(:sinatra_parameters) { { some_parameter: "some parameter value" } }
+    let(:logger)             { instance_double(Logger) }
+
+    let(:discovered_session_id) { "some session id" }
+    let(:sinatra_request)       { instance_double(HttpStub::Server::Request::SinatraRequest) }
+    let(:session)               { instance_double(HttpStub::Server::Session::Session) }
+    let(:server_request)        { instance_double(HttpStub::Server::Request::Request) }
+
+    subject { factory.create(rack_request, sinatra_parameters, logger) }
+
+    before(:example) do
+      allow(HttpStub::Server::Request::SinatraRequest).to receive(:new).and_return(sinatra_request)
+      allow(session_identifier_strategy).to receive(:identifier_for).and_return(discovered_session_id)
+      allow(session_registry).to receive(:find_or_create).and_return(session)
+    end
+
+    it "creates a sinatra request for the rack request and sinatra parameters" do
+      expect(HttpStub::Server::Request::SinatraRequest).to receive(:new).with(rack_request, sinatra_parameters)
+
+      subject
+    end
+
+    it "discovers the session identifier for the sinatra request" do
+      expect(session_identifier_strategy).to receive(:identifier_for).with(sinatra_request)
+
+      subject
+    end
+
+    it "finds or creates the session for the identifier via the servers session registry" do
+      expect(session_registry).to receive(:find_or_create).with(discovered_session_id, logger)
+
+      subject
+    end
+
+    it "creates a http_stub request containing the sinatra request" do
+      expect(HttpStub::Server::Request::Request).to receive(:new).with(sinatra_request, anything, anything)
+
+      subject
+    end
+
+    it "returns a http_stub request containing the discovered session id" do
+      expect(subject.session_id).to eql(discovered_session_id)
+    end
+
+    it "returns a http_stub request containing the retrieved session" do
+      expect(subject.session).to eql(session)
+    end
+
+  end
+
+end

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

@@ -1,6 +1,6 @@
 describe HttpStub::Server::Request::Parameters do
 
-  let(:parameter_hash) { {} }
+  let(:parameter_hash) { { "some_parameter_name" => "some parameter value" } }
 
   let(:parameters) { described_class.new(parameter_hash) }
 
@@ -10,17 +10,14 @@ describe HttpStub::Server::Request::Parameters do
 
   describe "::create" do
 
-    let(:rack_params)  { { "some_parameter_name" => "some parameter value" } }
-    let(:rack_request) { instance_double(Rack::Request, params: rack_params) }
+    subject { described_class.create(parameter_hash) }
 
-    subject { described_class.create(rack_request) }
-
-    it "returns http stub request parameters" do
+    it "returns http_stub request parameters" do
       expect(subject).to be_an_instance_of(described_class)
     end
 
-    it "returns parameters containing the rack request parameters" do
-      expect(subject).to eql(rack_params)
+    it "contains the provided parameters" do
+      expect(subject).to eql(parameters)
     end
 
   end

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

@@ -1,34 +1,40 @@
 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, base_url:       rack_base_url,
-                                   path_info:      rack_path_info,
-                                   request_method: rack_request_method,
-                                   env:            rack_env,
-                                   params:         rack_parameters,
-                                   body:           StringIO.new(rack_body))
+  let(:sinatra_base_uri)       { "http://base_url:8888" }
+  let(:sinatra_uri)            { "/rack/path/info" }
+  let(:sinatra_request_method) { "some method" }
+  let(:sinatra_headers)        { { "some_header" => "some header value" } }
+  let(:sinatra_parameters)     { { "some_parameter" => "some parameter value" } }
+  let(:sinatra_body)           { "some request body" }
+  let(:sinatra_request)        do
+    instance_double(HttpStub::Server::Request::SinatraRequest, base_uri: sinatra_base_uri,
+                    uri:                                                 sinatra_uri,
+                    method:                                              sinatra_request_method,
+                    headers:                                             sinatra_headers,
+                    parameters:                                          sinatra_parameters,
+                    body:                                                sinatra_body)
   end
+  let(:session_id)             { "some session id" }
+  let(:session)                { instance_double(HttpStub::Server::Session::Session) }
 
-  let(:server_request) { described_class.new(rack_request) }
+  let(:server_request) { described_class.new(sinatra_request, session_id, session) }
 
   describe "#base_uri" do
 
-    it "is the rack base url" do
-      expect(server_request.base_uri).to eql(rack_base_url)
+    subject { server_request.base_uri }
+
+    it "is the sinatra requests base uri" do
+      expect(subject).to eql(sinatra_base_uri)
     end
 
   end
 
   describe "#uri" do
 
-    it "is the rack request path information" do
-      expect(server_request.uri).to eql(rack_path_info)
+    subject { server_request.uri }
+
+    it "is the sinatra requests uri" do
+      expect(subject).to eql(sinatra_uri)
     end
 
   end
@@ -37,8 +43,8 @@ describe HttpStub::Server::Request::Request do
 
     subject { server_request.method }
 
-    it "is the rack request method" do
-      expect(subject).to eql(rack_request_method)
+    it "is the sinatra requests method" do
+      expect(subject).to eql(sinatra_request_method)
     end
 
   end
@@ -47,72 +53,66 @@ describe HttpStub::Server::Request::Request do
 
     subject { server_request.headers }
 
-    it "creates http stub request headers from the rack request" do
-      expect(HttpStub::Server::Request::Headers).to receive(:create).with(rack_request)
+    it "is the sinatra requests headers" do
+      expect(subject).to eql(sinatra_headers)
 
       subject
     end
 
-    it "returns the created http stub request headers" do
-      http_stub_request_headers = instance_double(HttpStub::Server::Request::Headers)
-      allow(HttpStub::Server::Request::Headers).to receive(:create).and_return(http_stub_request_headers)
-
-      expect(subject).to eql(http_stub_request_headers)
-    end
-
   end
 
   describe "#parameters" do
 
     subject { server_request.parameters }
 
-    it "creates http stub request parameters from the rack request" do
-      expect(HttpStub::Server::Request::Parameters).to receive(:create).with(rack_request)
+    it "is the sinatra requests parameters" do
+      expect(subject).to eql(sinatra_parameters)
 
       subject
     end
 
-    it "returns the created http stub request parameters" do
-      http_stub_request_parameters = instance_double(HttpStub::Server::Request::Parameters)
-      allow(HttpStub::Server::Request::Parameters).to receive(:create).and_return(http_stub_request_parameters)
-
-      expect(subject).to eql(http_stub_request_parameters)
-    end
-
   end
 
   describe "#body" do
 
     subject { server_request.body }
 
-    it "is the read rack request body" do
-      expect(subject).to eql(rack_body)
+    it "is the sinatra requests body" do
+      expect(subject).to eql(sinatra_body)
     end
 
   end
 
   describe "#to_json" do
 
+    let(:sinatra_request_json) { "some json" }
+
     subject { server_request.to_json }
 
-    it "contains the requests uri" do
-      expect(subject).to include_in_json(uri: server_request.uri)
-    end
+    before(:example) { allow(sinatra_request).to receive(:to_json).and_return(sinatra_request_json) }
 
-    it "contains the requests method" do
-      expect(subject).to include_in_json(method: server_request.method)
+    it "returns the sinatra requests json representation" do
+      expect(subject).to eql(sinatra_request_json)
     end
 
-    it "contains the requests headers" do
-      expect(subject).to include_in_json(headers: server_request.headers)
-    end
+  end
+
+  describe "#session_id" do
+
+    subject { server_request.session_id }
 
-    it "contains the requests parameters" do
-      expect(subject).to include_in_json(parameters: server_request.parameters)
+    it "is the provided id" do
+      expect(subject).to eql(session_id)
     end
 
-    it "contains the requests body" do
-      expect(subject).to include_in_json(body: server_request.body)
+  end
+
+  describe "#session" do
+
+    subject { server_request.session }
+
+    it "is the provided session" do
+      expect(subject).to eql(session)
     end
 
   end

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

@@ -0,0 +1,132 @@
+describe HttpStub::Server::Request::SinatraRequest 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)     { { "rack_parameter_name" => "rack parameter value" } }
+  let(:rack_body_content)   { "some request body" }
+  let(:rack_body)           { StringIO.new(rack_body_content) }
+  let(:rack_request)        do
+    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,
+                                   body:           rack_body)
+  end
+  let(:sinatra_parameters)  { { "sinatra_parameter_name" => "sinatra parameter value" } }
+
+  let(:sinatra_request) { described_class.new(rack_request, sinatra_parameters) }
+
+  describe "#base_uri" do
+
+    it "is the rack base url" do
+      expect(sinatra_request.base_uri).to eql(rack_base_url)
+    end
+
+  end
+
+  describe "#uri" do
+
+    it "is the rack request path information" do
+      expect(sinatra_request.uri).to eql(rack_path_info)
+    end
+
+  end
+
+  describe "#method" do
+
+    subject { sinatra_request.method }
+
+    it "is the rack request method" do
+      expect(subject).to eql(rack_request_method)
+    end
+
+  end
+
+  describe "#headers" do
+
+    subject { sinatra_request.headers }
+
+    it "creates http stub request headers from the rack request" do
+      expect(HttpStub::Server::Request::Headers).to receive(:create).with(rack_request)
+
+      subject
+    end
+
+    it "returns the created http stub request headers" do
+      http_stub_request_headers = instance_double(HttpStub::Server::Request::Headers)
+      allow(HttpStub::Server::Request::Headers).to receive(:create).and_return(http_stub_request_headers)
+
+      expect(subject).to eql(http_stub_request_headers)
+    end
+
+  end
+
+  describe "#parameters" do
+
+    subject { sinatra_request.parameters }
+
+    it "creates http stub request parameters from the sinatra parameters" do
+      expect(HttpStub::Server::Request::Parameters).to receive(:create).with(sinatra_parameters)
+
+      subject
+    end
+
+    it "returns the created http stub request parameters" do
+      http_stub_request_parameters = instance_double(HttpStub::Server::Request::Parameters)
+      allow(HttpStub::Server::Request::Parameters).to receive(:create).and_return(http_stub_request_parameters)
+
+      expect(subject).to eql(http_stub_request_parameters)
+    end
+
+  end
+
+  describe "#body" do
+
+    subject { sinatra_request.body }
+
+    it "is the read rack request body" do
+      expect(subject).to eql(rack_body_content)
+    end
+
+    it "rewinds the Rack body to allow the body to be accessed in future" do
+      expect(rack_body).to receive(:rewind)
+
+      subject
+    end
+
+  end
+
+  describe "#to_json" do
+
+    subject { sinatra_request.to_json }
+
+    it "contains the requests uri" do
+      expect(subject).to include_in_json(uri: sinatra_request.uri)
+    end
+
+    it "contains the requests method" do
+      expect(subject).to include_in_json(method: sinatra_request.method)
+    end
+
+    it "contains the requests headers" do
+      expect(subject).to include_in_json(headers: sinatra_request.headers)
+    end
+
+    it "contains the requests parameters" do
+      expect(subject).to include_in_json(parameters: sinatra_request.parameters)
+    end
+
+    it "contains the requests body" do
+      expect(subject).to include_in_json(body: sinatra_request.body)
+    end
+
+    it "does not contains the session" do
+      expect(subject).to_not include("session")
+    end
+
+  end
+
+end

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

@@ -1,27 +1,34 @@
 describe HttpStub::Server::Scenario::Controller do
 
-  let(:request_uri)       { "/some/request/path" }
-  let(:request)           { instance_double(HttpStub::Server::Request::Request, uri: request_uri) }
-  let(:logger)            { instance_double(Logger) }
-  let(:payload)           { HttpStub::ScenarioFixture.new.server_payload }
-  let(:stubs)             { (1..3).map { instance_double(HttpStub::Server::Stub::Stub) } }
-  let(:scenario)          { instance_double(HttpStub::Server::Scenario::Scenario, stubs: stubs) }
-  let(:scenario_registry) { instance_double(HttpStub::Server::Registry).as_null_object }
-  let(:stub_registry)     { instance_double(HttpStub::Server::Stub::Registry).as_null_object }
-  let(:activator)         { instance_double(HttpStub::Server::Scenario::Activator).as_null_object }
-
-  let(:controller) { HttpStub::Server::Scenario::Controller.new(scenario_registry, stub_registry) }
-
-  before(:example) do
-    allow(HttpStub::Server::Scenario::Activator).to receive(:new).and_return(activator)
-    allow(HttpStub::Server::Scenario::Parser).to receive(:parse).and_return(payload)
-    allow(HttpStub::Server::Scenario).to receive(:create).and_return(scenario)
+  let(:scenario_registry) { instance_double(HttpStub::Server::Registry) }
+  let(:server_memory)     { instance_double(HttpStub::Server::Memory::Memory, scenarios: scenario_registry) }
+
+  let(:request_uri)        { "/some/request/path" }
+  let(:request_parameters) { {} }
+  let(:session)            { instance_double(HttpStub::Server::Session::Session) }
+  let(:request)            do
+    instance_double(HttpStub::Server::Request::Request, uri:        request_uri,
+                                                        parameters: request_parameters,
+                                                        session:    session)
   end
+  let(:logger)             { instance_double(Logger) }
+  let(:payload)            { HttpStub::ScenarioFixture.new.server_payload }
+  let(:stubs)              { (1..3).map { instance_double(HttpStub::Server::Stub::Stub) } }
+  let(:scenario)           { instance_double(HttpStub::Server::Scenario::Scenario, stubs: stubs) }
+  let(:activator)          { instance_double(HttpStub::Server::Scenario::Activator).as_null_object }
+
+  let(:controller) { described_class.new(server_memory) }
 
   describe "#register" do
 
     subject { controller.register(request, logger) }
 
+    before(:example) do
+      allow(HttpStub::Server::Scenario::Parser).to receive(:parse).and_return(payload)
+      allow(HttpStub::Server::Scenario).to receive(:create).and_return(scenario)
+      allow(scenario_registry).to receive(:add)
+    end
+
     it "parses the payload from the request" do
       expect(HttpStub::Server::Scenario::Parser).to receive(:parse).with(request).and_return(payload)
 
@@ -34,7 +41,7 @@ describe HttpStub::Server::Scenario::Controller do
       subject
     end
 
-    it "adds the created scenario to the scenario registry with the provided logger" do
+    it "adds the created scenario to the servers scenario registry with the provided logger" do
       expect(scenario_registry).to receive(:add).with(scenario, logger)
 
       subject
@@ -46,46 +53,125 @@ describe HttpStub::Server::Scenario::Controller do
 
   end
 
-  describe "#activate" do
+  describe "#find" do
+
+    let(:name)               { URI.encode_www_form_component("Some scenario name") }
+    let(:request_parameters) { { name: name } }
+
+    subject { controller.find(request, logger) }
 
-    let(:scenario_name) { "Some Scenario Name" }
+    before(:example) { allow(scenario_registry).to receive(:find).and_return(scenario) }
 
-    subject { controller.activate(scenario_name, logger) }
+    it "finds a scenario matching the parameterized name via the registry" do
+      expect(scenario_registry).to receive(:find).with(URI.decode_www_form_component("Some scenario name"), anything)
 
-    it "finds a scenario whose name matches the provided name" do
-      expect(scenario_registry).to receive(:find).with(scenario_name, logger)
+      subject
+    end
+
+    it "finds the scenario using the provided logger" do
+      expect(scenario_registry).to receive(:find).with(anything, logger)
 
       subject
     end
 
-    describe "when a scenario is found" do
+    it "returns the found scenario" do
+      expect(subject).to eql(scenario)
+    end
+
+  end
+
+  describe "#find_all" do
+
+    let(:scenarios) { (1..3).map { |i| HttpStub::Server::ScenarioFixture.create("#{4 - i}") } }
+
+    subject { controller.find_all }
+
+    before(:example) { allow(scenario_registry).to receive(:all).and_return(scenarios) }
+
+    it "retrieves all scenarios from the servers scenario registry" do
+      expect(scenario_registry).to receive(:all)
+
+      subject
+    end
+
+    it "returns the scenarios sorted by name" do
+      expect(subject).to eql(scenarios.reverse)
+    end
+
+  end
+
+  describe "#activate" do
 
-      before(:example) { allow(scenario_registry).to receive(:find).and_return(scenario) }
+    subject { controller.activate(request, logger) }
 
-      it "activates the scenario via the activator" do
-        expect(activator).to receive(:activate).with(scenario, logger)
+    context "when a scenario name is provided" do
+
+      let(:scenario_name)      { "some scenario name" }
+      let(:request_parameters) { { name: scenario_name } }
+
+      it "delegates to the users session to activate the scenario with the parameterized name" do
+        expect(session).to receive(:activate_scenario!).with(scenario_name, logger)
 
         subject
       end
 
-      it "returns an ok response" do
-        expect(subject).to eql(HttpStub::Server::Response::OK)
+      describe "when the scenario is not found" do
+
+        before(:example) do
+          allow(session).to(
+            receive(:activate_scenario!).and_raise(HttpStub::Server::Scenario::NotFoundError, scenario_name)
+          )
+        end
+
+        it "returns a not found response" do
+          expect(subject).to eql(HttpStub::Server::Response::NOT_FOUND)
+        end
+
       end
 
     end
 
-    describe "when no scenario is found" do
+    context "when scenario names are provided" do
 
-      before(:example) { allow(scenario_registry).to receive(:find).and_return(nil) }
+      let(:scenario_names)     { (1..3).map { |i| "scenario name #{i}" } }
+      let(:request_parameters) { { names: scenario_names } }
 
-      it "does not add a stub to the registry" do
-        expect(stub_registry).not_to receive(:concat)
+      it "delegates to the users session to activate the scenarios with the parameterized names" do
+        scenario_names.each do |scenario_name|
+          expect(session).to receive(:activate_scenario!).with(scenario_name, logger)
+        end
 
         subject
       end
 
-      it "returns a not found response" do
-        expect(subject).to eql(HttpStub::Server::Response::NOT_FOUND)
+      describe "when a scenario is not found" do
+
+        let(:scenario_name_not_found) { scenario_names[1] }
+
+        before(:example) do
+          allow(session).to receive(:activate_scenario!)
+          allow(session).to(
+            receive(:activate_scenario!).with(scenario_name_not_found, anything)
+              .and_raise(HttpStub::Server::Scenario::NotFoundError, scenario_name_not_found)
+          )
+        end
+
+        it "returns a not found response" do
+          expect(subject).to eql(HttpStub::Server::Response::NOT_FOUND)
+        end
+
+      end
+
+    end
+
+    describe "when all scenarios are successfully activated" do
+
+      let(:request_parameters) { { name: "some scenario name" } }
+
+      before(:example) { allow(session).to receive(:activate_scenario!) }
+
+      it "returns an ok response" do
+        expect(subject).to eql(HttpStub::Server::Response::OK)
       end
 
     end
@@ -96,7 +182,7 @@ describe HttpStub::Server::Scenario::Controller do
 
     subject { controller.clear(logger) }
 
-    it "clears the scenario registry" do
+    it "clears the servers scenario registry" do
       expect(scenario_registry).to receive(:clear).with(logger)
 
       subject