http_stub 0.27.0 → 0.28.0.beta1

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

@@ -1,6 +1,6 @@
 describe HttpStub::Server::Scenario do
 
-  let(:args) { HttpStub::ScenarioFixture.new.server_payload }
+  let(:args) { HttpStub::Configurator::ScenarioBuilder.new.build_hash }
 
   describe "::create" do
 

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

@@ -1,14 +1,13 @@
 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_registry) { instance_double(HttpStub::Server::Session::Registry) }
+  let(:server_memory)    { instance_double(HttpStub::Server::Memory::Memory, session_registry: session_registry) }
 
   let(:session_id) { "some session id" }
-  let(:request)    { instance_double(HttpStub::Server::Request::Request, session_id: session_id) }
+  let(:request)    { HttpStub::Server::RequestFixture.create(session_id: session_id) }
   let(:logger)     { instance_double(Logger) }
 
-  let(:controller) { described_class.new(session_configuration, server_memory) }
+  let(:controller) { described_class.new(server_memory) }
 
   describe "#find" do
 

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

@@ -1,77 +1,44 @@
 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_setting) { {} }
 
-  let(:identifier_strategy) { described_class.new(session_configuration) }
+  let(:identifier_strategy) { described_class.new(identifier_setting) }
 
   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)
+      HttpStub::Server::Request::SinatraRequestFixture.create(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
+    context "when a http stub session id header value is 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
+      let(:request_headers) { { http_stub_session_id: "some header value" } }
 
+      it "returns the parameter value" do
+        expect(subject).to eql("some header value")
       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
+    end
 
-      context "and the session value is not in the request" do
+    context "when a http stub session id parameter value is in the request" do
 
-        it "returns nil" do
-          expect(subject).to eql(nil)
-        end
+      let(:request_parameters) { { http_stub_session_id: "some parameter value" } }
 
+      it "returns the parameter value" do
+        expect(subject).to eql("some parameter value")
       end
 
     end
 
-    context "when the session identifier configuration has one entry" do
+    context "when an identifier setting is provided" do
 
       context "that is a header" do
 
-        let(:identifier_configuration) { [ { header: :session_header } ] }
+        let(:identifier_setting) { { header: :session_header } }
 
         context "and the session value is in the request" do
 
@@ -95,7 +62,7 @@ describe HttpStub::Server::Session::IdentifierStrategy do
 
       context "that is a parameter" do
 
-        let(:identifier_configuration) { [ { parameter: :session_parameter } ] }
+        let(:identifier_setting) { { parameter: :session_parameter } }
 
         context "and the session value is in the request" do
 

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

@@ -1,21 +1,19 @@
 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(:transactional_session_id) { HttpStub::Server::Session::TRANSACTIONAL_SESSION_ID }
+
+  let(:scenario_registry) { instance_double(HttpStub::Server::Scenario::Registry) }
+  let(:initial_stubs)     { (1..3).map { HttpStub::Server::StubFixture.create } }
 
   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) }
+  let(:session_registry) { described_class.new(scenario_registry, initial_stubs) }
 
   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 ])
+  it "uses an underlying simple registry" do
+    expect(HttpStub::Server::Registry).to receive(:new).with("session")
 
     session_registry
   end
@@ -80,8 +78,8 @@ describe HttpStub::Server::Session::Registry 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)
+      it "attempts to find the transactional session" do
+        expect(underlying_session_registry).to receive(:find).with(transactional_session_id, logger)
 
         subject
       end
@@ -92,8 +90,8 @@ describe HttpStub::Server::Session::Registry do
 
         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)
+        it "creates a transactional session" do
+          expect(HttpStub::Server::Session::Session).to receive(:new).with(transactional_session_id, anything, anything)
 
           subject
         end
@@ -134,8 +132,8 @@ describe HttpStub::Server::Session::Registry do
         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)
+      it "creates a session with the provided initial stubs" do
+        expect(HttpStub::Server::Session::Session).to receive(:new).with(anything, anything, initial_stubs)
 
         subject
       end
@@ -192,19 +190,8 @@ describe HttpStub::Server::Session::Registry 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)
+    it "delegates to the underlying simple registry" do
+      expect(underlying_session_registry).to receive(:clear).with(logger)
 
       subject
     end

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

@@ -1,8 +1,8 @@
 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(:id)                { "some session id" }
+  let(:scenario_registry) { instance_double(HttpStub::Server::Scenario::Registry) }
+  let(:initial_stubs)     { (1..3).map { HttpStub::Server::StubFixture.create } }
 
   let(:stub_registry)       { instance_double(HttpStub::Server::Stub::Registry) }
   let(:stub_match_registry) { instance_double(HttpStub::Server::Registry) }
@@ -10,7 +10,7 @@ describe HttpStub::Server::Session::Session do
 
   let(:logger) { instance_double(Logger) }
 
-  let(:session) { described_class.new(id, scenario_registry, memory_session) }
+  let(:session) { described_class.new(id, scenario_registry, initial_stubs) }
 
   before(:example) do
     allow(HttpStub::Server::Stub::Registry).to receive(:new).and_return(stub_registry)
@@ -18,8 +18,8 @@ describe HttpStub::Server::Session::Session do
     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)
+  it "uses a stub registry that is initialized with the provided initial stubs" do
+    expect(HttpStub::Server::Stub::Registry).to receive(:new).with(initial_stubs)
 
     session
   end
@@ -75,38 +75,22 @@ describe HttpStub::Server::Session::Session do
 
     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
+      let(:stubs_activated) { (1..3).map { HttpStub::Server::StubFixture.create } }
+      let(:scenario)        { instance_double(HttpStub::Server::Scenario::Scenario) }
 
       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(scenario_registry).to receive(:stubs_activated_by).and_return(stubs_activated)
         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
+      it "discovers the stubs activated by the scenario" do
+        expect(scenario_registry).to receive(:stubs_activated_by).with(scenario, logger)
 
         subject
       end
 
-      it "adds the scenarios stubs to the stub registry" do
-        expect(stub_registry).to receive(:concat).with(scenario_stubs, logger)
+      it "adds the stubs activated to the stub registry" do
+        expect(stub_registry).to receive(:concat).with(stubs_activated, logger)
 
         subject
       end
@@ -399,46 +383,4 @@ describe HttpStub::Server::Session::Session do
 
   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/stdout_logger_spec.rb

@@ -0,0 +1,17 @@
+describe HttpStub::Server::StdoutLogger do
+
+  describe "::info" do
+
+    let(:message) { "some message"}
+
+    subject { described_class.info(message) }
+
+    it "writes the message to std out" do
+      expect(described_class).to receive(:puts).with(message)
+
+      subject
+    end
+
+  end
+
+end

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

@@ -1,65 +1,19 @@
 describe HttpStub::Server::Stub::Controller do
 
-  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(:request_parameters) { {} }
+  let(:request)            { HttpStub::Server::RequestFixture.create(parameters: request_parameters) }
+  let(:session)            { request.session }
+  let(:logger)             { instance_double(Logger) }
+  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)
-
-      subject
-    end
-
-    it "creates a stub with the parsed payload" do
-      expect(HttpStub::Server::Stub).to receive(:create).with(payload).and_return(the_stub)
-
-      subject
-    end
-
-    it "adds the stub to the users session" do
-      expect(session).to receive(:add_stub).with(the_stub, logger)
-
-      subject
-    end
-
-    it "creates an ok response with a location header containing the stubs uri" do
-      expect(HttpStub::Server::Response).to receive(:ok).with("headers" => { "location" => stub_uri })
-
-      subject
-    end
-
-    it "returns the ok response" do
-      response = double("HttpStub::Server::Response")
-      allow(HttpStub::Server::Response).to receive(:ok).and_return(response)
-
-      expect(subject).to eql(response)
-    end
-
-  end
-
   describe "#match" do
 
     let(:matched_stub) { nil }
 
-    let(:calculated_stub_response) { instance_double(HttpStub::Server::Stub::Response::Base) }
+    let(:calculated_stub_response) { HttpStub::Server::Stub::ResponseFixture.create }
 
     subject { controller.match(request, logger) }
 
@@ -201,16 +155,4 @@ describe HttpStub::Server::Stub::Controller do
 
   end
 
-  describe "#clear" do
-
-    subject { controller.clear(request, logger) }
-
-    it "clears the users session" do
-      expect(session).to receive(:clear).with(logger)
-
-      subject
-    end
-
-  end
-
 end

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

@@ -2,6 +2,14 @@ describe HttpStub::Server::Stub::Empty do
 
   let(:empty_stub) { HttpStub::Server::Stub::Empty::INSTANCE }
 
+  describe "#stub_id" do
+
+    it "is an empty string" do
+      expect(empty_stub.stub_id).to eql("")
+    end
+
+  end
+
   describe "#uri" do
 
     it "is an empty string" do