http_stub 0.25.1 → 0.26.0

data/spec/lib/http_stub/server/application/routes/session_integration_spec.rb

@@ -0,0 +1,46 @@
+describe HttpStub::Server::Application::Routes::Session, "when the server is running" do
+  include_context "server integration"
+
+  let(:transactional_session_id) { "http_stub_transactional" }
+
+  let(:response_document) { Nokogiri::HTML(response.body) }
+
+  before(:example) { establish_default_session(transactional_session_id) }
+
+  describe "GET /http_stub" do
+
+    let(:response) { HTTParty.get("#{server_uri}/http_stub") }
+
+    let(:transactional_session_parameter) { "http_stub_session_id=#{transactional_session_id}" }
+
+    it "returns a 200 response code" do
+      expect(response.code).to eql(200)
+    end
+
+    it "returns a response whose body links to the scenarios list for the transactional session" do
+      expect(link_for("scenarios")).to eql("/http_stub/scenarios?#{transactional_session_parameter}")
+    end
+
+    it "returns a response whose body links to the stubs list for the transactional session" do
+      expect(link_for("stubs")).to eql("/http_stub/stubs?#{transactional_session_parameter}")
+    end
+
+    it "returns a response whose body links to the matches list for the transactional session" do
+      expected_matches_link = "/http_stub/stubs/matches?#{transactional_session_parameter}"
+
+      expect(link_for("stub_matches")).to eql(expected_matches_link)
+    end
+
+    it "returns a response whose body links to the misses list for the transactional session" do
+      expected_misses_link = "/http_stub/stubs/misses?#{transactional_session_parameter}"
+
+      expect(link_for("stub_misses")).to eql(expected_misses_link)
+    end
+
+    def link_for(id)
+      response_document.at_css("a##{id}")["href"]
+    end
+
+  end
+
+end

data/spec/lib/http_stub/server/application/routes/session_spec.rb

@@ -0,0 +1,186 @@
+describe HttpStub::Server::Application::Routes::Session do
+  include_context "http_stub rack application test"
+
+  let(:session_controller) { instance_double(HttpStub::Server::Session::Controller) }
+
+  before(:example) { allow(HttpStub::Server::Session::Controller).to receive(:new).and_return(session_controller) }
+
+  describe "when a request to show the administration landing page is received" do
+
+    subject { get "/http_stub" }
+
+    context "and session support is enabled" do
+
+      include_context "enabled session support"
+
+      let(:found_sessions) { [ HttpStub::Server::SessionFixture.create ] }
+
+      before(:example) { allow(session_controller).to receive(:find_all).and_return(found_sessions) }
+
+      it "responds with a redirect" do
+        subject
+
+        expect(response.status).to eql(302)
+      end
+
+      it "redirects to the page listing all session" do
+        subject
+
+        expect(response.location).to end_with("/http_stub/sessions")
+      end
+
+    end
+
+    context "and session support is disabled" do
+
+      it "responds with a redirect" do
+        subject
+
+        expect(response.status).to eql(302)
+      end
+
+      it "redirects to the transactional session page" do
+        subject
+
+        expect(response.location).to end_with("/http_stub/sessions/transactional")
+      end
+
+    end
+
+  end
+
+  describe "when a request to list the sessions is received" do
+    include_context "request excludes a session identifier"
+
+    let(:found_sessions) { [ HttpStub::Server::SessionFixture.create ] }
+
+    subject { get "/http_stub/sessions" }
+
+    before(:example) do
+      allow(request).to receive(:session_id).and_return(nil)
+      allow(session_controller).to receive(:find_all).and_return(found_sessions)
+    end
+
+    it "retrieves all sessions via the session controller" do
+      expect(session_controller).to receive(:find_all).and_return(found_sessions)
+
+      subject
+    end
+
+    it "responds with a 200 status code" do
+      subject
+
+      expect(response.status).to eql(200)
+    end
+
+  end
+
+  describe "when a request to show a session is received" do
+    include_context "request includes a session identifier"
+
+    let(:found_session) { HttpStub::Server::SessionFixture.create }
+
+    subject { get "/http_stub/sessions" }
+
+    before(:example) { allow(session_controller).to receive(:find).and_return(found_session) }
+
+    it "retrieves the session identified in the request via the stub controller" do
+      expect(session_controller).to receive(:find).with(request, anything).and_return(found_session)
+
+      subject
+    end
+
+    it "responds with a 200 status code" do
+      subject
+
+      expect(response.status).to eql(200)
+    end
+
+  end
+
+  describe "when a request to show the transactional session is received" do
+
+    let(:transactional_session) { HttpStub::Server::SessionFixture.create }
+
+    subject { get "/http_stub/sessions/transactional" }
+
+    before(:example) { allow(session_controller).to receive(:find_transactional).and_return(transactional_session) }
+
+    it "retrieves the transactional session via the stub controller" do
+      expect(session_controller).to receive(:find_transactional).with(anything).and_return(transactional_session)
+
+      subject
+    end
+
+    it "responds with a 200 status code" do
+      subject
+
+      expect(response.status).to eql(200)
+    end
+
+  end
+
+  describe "when a request to mark a session as the default is received" do
+    include_context "request includes a session identifier"
+
+    subject { post "/http_stub/sessions/default" }
+
+    before(:example) { allow(session_controller).to receive(:mark_default) }
+
+    it "retrieves the session identified in the request via the stub controller" do
+      expect(session_controller).to receive(:mark_default).with(request)
+
+      subject
+    end
+
+    it "responds with a 200 status code" do
+      subject
+
+      expect(response.status).to eql(200)
+    end
+
+  end
+
+  describe "when a request to delete a session is received" do
+    include_context "request includes a session identifier"
+
+    subject { delete "/http_stub/sessions" }
+
+    before(:example) { allow(session_controller).to receive(:delete) }
+
+    it "deletes the session identified in the request via the stub controller" do
+      expect(session_controller).to receive(:delete).with(request, anything)
+
+      subject
+    end
+
+    it "responds with a 200 status code" do
+      subject
+
+      expect(response.status).to eql(200)
+    end
+
+  end
+
+  describe "when a request to clear the sessions is received" do
+    include_context "request excludes a session identifier"
+
+    subject { delete "/http_stub/sessions" }
+
+    before(:example) { allow(session_controller).to receive(:clear) }
+
+    it "clears the servers sessions via the stub controller" do
+      expect(session_controller).to receive(:clear).with(anything)
+
+      subject
+    end
+
+    it "responds with a 200 status code" do
+      subject
+
+      expect(response.status).to eql(200)
+    end
+
+  end
+
+end

data/spec/lib/http_stub/server/application/{application_integration_spec.rb → routes/stub_integration_spec.rb}

@@ -1,33 +1,11 @@
-describe HttpStub::Server::Application::Application, "when the server is running" do
+describe HttpStub::Server::Application::Routes::Stub, "when the server is running" do
   include_context "server integration"
 
-  let(:response_document) { Nokogiri::HTML(response.body) }
-
-  describe "GET /http_stub" do
-
-    let(:response) { HTTParty.get("#{server_uri}/http_stub") }
-
-    it "returns a 200 response code" do
-      expect(response.code).to eql(200)
-    end
-
-    it "returns a response whose body links to the stubs list" do
-      expect(link_for("stubs")).to eql("/http_stub/stubs")
-    end
-
-    it "returns a response whose body links to the scenarios list" do
-      expect(link_for("scenarios")).to eql("/http_stub/scenarios")
-    end
+  let(:transactional_session_id) { "http_stub_transactional" }
 
-    it "returns a response whose body links to the matches list" do
-      expect(link_for("stub_matches")).to eql("/http_stub/stubs/matches")
-    end
-
-    def link_for(id)
-      response_document.at_css("a##{id}")["href"]
-    end
+  let(:response_document) { Nokogiri::HTML(response.body) }
 
-  end
+  before(:example) { establish_default_session(transactional_session_id) }
 
   describe "POST /http_stub/stubs" do
 
@@ -40,6 +18,8 @@ describe HttpStub::Server::Application::Application, "when the server is running
         )
       end
 
+      after(:example) { reset_session }
+
       it "returns a 200 response code" do
         expect(response.code).to eql(200)
       end
@@ -58,21 +38,17 @@ describe HttpStub::Server::Application::Application, "when the server is running
   end
 
   describe "and a configurer with multiple scenarios is initialized" do
+    include_context "configurer integration"
 
-    before(:context) do
-      configurer = HttpStub::Examples::ConfigurerWithExhaustiveScenarios
-      configurer.stub_server.host = server_host
-      configurer.stub_server.port = server_port
-      configurer.initialize!
-    end
+    let(:configurer_specification) { { class: HttpStub::Examples::ConfigurerWithExhaustiveScenarios } }
 
     describe "GET /http_stub/stubs" do
 
       describe "when multiple stubs are configured" do
 
-        before(:context) do
+        before(:example) do
           (1..3).each do |i|
-            HTTParty.post("#{server_uri}/http_stub/scenarios/activate", :body => { :name => "Scenario #{i}" })
+            HTTParty.post("#{server_uri}/http_stub/scenarios/activate", :body => { name: "Scenario #{i}" })
           end
         end
 
@@ -219,6 +195,8 @@ describe HttpStub::Server::Application::Application, "when the server is running
 
       let(:response) { HTTParty.get("#{server_uri}/http_stub/scenarios") }
 
+      let(:transactional_session_parameter) { "http_stub_session_id=#{transactional_session_id}" }
+
       it "returns a response whose body contains the name of each scenario in alphabetical order" do
         expected_scenario_names = [ "Nested scenario", "Scenario" ].map do |scenario_name_prefix|
           (1..3).map { |i| "#{scenario_name_prefix} #{i}" }
@@ -229,17 +207,17 @@ describe HttpStub::Server::Application::Application, "when the server is running
         expect(scenario_names).to eql(expected_scenario_names)
       end
 
-      it "returns a response whose body contains links to activate each scenario" do
-        expected_activation_links = [ "/http_stub/scenarios/activate" ] * 6
+      it "returns a response whose body contains links to activate each scenario in the transactional session" do
+        expected_activation_links = [ "/http_stub/scenarios/activate?#{transactional_session_parameter}" ] * 6
 
         activation_links = response_document.css("a.activate_scenario").map { |link| link["href"] }
 
         expect(activation_links).to eql(expected_activation_links)
       end
 
-      it "returns a response whose body contains links to the details of each scenario" do
+      it "returns a response whose body contains links to the details of each scenario for the default session" do
         expected_detail_links = %w{ Nested+scenario Scenario }.map do |scenario_name_prefix|
-          (1..3).map { |i| "/http_stub/scenarios?name=#{scenario_name_prefix}+#{i}" }
+          (1..3).map { |i| "/http_stub/scenarios?name=#{scenario_name_prefix}+#{i}&#{transactional_session_parameter}" }
         end.flatten
 
         detail_links = response_document.css("a.view_scenario").map { |link| link["href"] }

data/spec/lib/http_stub/server/application/routes/stub_spec.rb

@@ -0,0 +1,202 @@
+describe HttpStub::Server::Application::Routes::Stub do
+  include_context "http_stub rack application test"
+
+  let(:stub_controller)       { instance_double(HttpStub::Server::Stub::Controller) }
+  let(:stub_match_controller) { instance_double(HttpStub::Server::Stub::Match::Controller) }
+
+  before(:example) do
+    allow(HttpStub::Server::Stub::Controller).to receive(:new).and_return(stub_controller)
+    allow(HttpStub::Server::Stub::Match::Controller).to receive(:new).and_return(stub_match_controller)
+  end
+
+  describe "when a stub registration request within a session is received" do
+    include_context "request includes a session identifier"
+
+    let(:payload) { { uri: "/a_path", method: "a method", response: { status: 200, body: "Foo" } }.to_json }
+
+    let(:registration_response) { instance_double(HttpStub::Server::Stub::Response::Base) }
+
+    subject { post "/http_stub/stubs" }
+
+    before(:example) do
+      allow(request).to receive(:body).and_return(payload)
+      allow(stub_controller).to receive(:register).and_return(registration_response)
+    end
+
+    it "registers the stub via the stub controller" do
+      expect(stub_controller).to receive(:register).and_return(registration_response)
+
+      subject
+    end
+
+    it "processes the stub controllers response via the response pipeline" do
+      expect(response_pipeline).to receive(:process).with(registration_response)
+
+      subject
+    end
+
+  end
+
+  describe "when a request to list the stubs in a session is received" do
+    include_context "request includes a session identifier"
+
+    let(:found_stubs) { [ HttpStub::Server::Stub::Empty::INSTANCE ] }
+
+    subject { get "/http_stub/stubs" }
+
+    it "retrieves the stubs for the current user via the stub controller" do
+      expect(stub_controller).to receive(:find_all).with(request).and_return(found_stubs)
+
+      subject
+    end
+
+  end
+
+  describe "when a request to show a stub in a session is received" do
+    include_context "request includes a session identifier"
+
+    let(:stub_id) { SecureRandom.uuid }
+
+    let(:found_stub) { HttpStub::Server::Stub::Empty::INSTANCE }
+
+    subject { get "/http_stub/stubs/#{stub_id}" }
+
+    before(:example) { allow(stub_controller).to receive(:find).and_return(found_stub) }
+
+    it "retrieves the stub for the current user via the stub controller" do
+      expect(stub_controller).to receive(:find).with(request, anything).and_return(found_stub)
+
+      subject
+    end
+
+    it "responds with a 200 status code" do
+      subject
+
+      expect(response.status).to eql(200)
+    end
+
+  end
+
+  describe "when a request to reset the stubs in a session is received" do
+    include_context "request includes a session identifier"
+
+    subject { post "/http_stub/stubs/reset" }
+
+    before(:example) { allow(stub_controller).to receive(:reset) }
+
+    it "resets the stubs in the session via the stub controller" do
+      expect(stub_controller).to receive(:reset).with(request, anything)
+
+      subject
+    end
+
+    it "responds with a 200 status code" do
+      subject
+
+      expect(response.status).to eql(200)
+    end
+
+  end
+
+  describe "when a request to clear the stubs in a session is received" do
+    include_context "request includes a session identifier"
+
+    subject { delete "/http_stub/stubs" }
+
+    before(:example) { allow(stub_controller).to receive(:clear) }
+
+    it "clears the stubs for the current user via the stub controller" do
+      expect(stub_controller).to receive(:clear).with(request, anything)
+
+      subject
+    end
+
+    it "responds with a 200 status code" do
+      subject
+
+      expect(response.status).to eql(200)
+    end
+
+  end
+
+  describe "when a request to list the stub matches in a session is received" do
+    include_context "request includes a session identifier"
+
+    let(:found_matches) { [ HttpStub::Server::Stub::Match::MatchFixture.create ] }
+
+    subject { get "/http_stub/stubs/matches" }
+
+    it "retrieves the matches for the current user via the stub match controller" do
+      expect(stub_match_controller).to receive(:matches).with(request).and_return(found_matches)
+
+      subject
+    end
+
+  end
+
+  describe "when a request to retrieve the last match for an endpoint in a session is received" do
+    include_context "request includes a session identifier"
+
+    let(:uri)                 { "/some/matched/uri" }
+    let(:method)              { "some http method" }
+    let(:last_match_response) { instance_double(HttpStub::Server::Stub::Response::Base) }
+
+    subject { get "/http_stub/stubs/matches/last" }
+
+    before(:example) do
+      allow(request).to receive(:parameters).and_return(uri: uri, method: method)
+      allow(stub_match_controller).to receive(:last_match).and_return(last_match_response)
+    end
+
+    it "retrieves the last match for the user via the match result controller" do
+      expect(stub_match_controller).to receive(:last_match).with(request, anything)
+
+      subject
+    end
+
+    it "processes the match result controllers response via the response pipeline" do
+      expect(response_pipeline).to receive(:process).with(last_match_response)
+
+      subject
+    end
+
+  end
+
+  describe "when a request to list the stub misses in a session is received" do
+    include_context "request includes a session identifier"
+
+    let(:found_misses) { [ HttpStub::Server::Stub::Match::MissFixture.create ] }
+
+    subject { get "/http_stub/stubs/misses" }
+
+    it "retrieves the misses for the current user via the stub match controller" do
+      expect(stub_match_controller).to receive(:misses).with(request).and_return(found_misses)
+
+      subject
+    end
+
+  end
+
+  describe "when any other request is received" do
+
+    let(:stub_response) { instance_double(HttpStub::Server::Stub::Response::Base) }
+
+    subject { get "/some_path" }
+
+    before(:example) { allow(stub_controller).to receive(:match).and_return(stub_response) }
+
+    it "attempts to match the request to a stub response via the stub controller" do
+      expect(stub_controller).to receive(:match).with(request, anything)
+
+      subject
+    end
+
+    it "processes the response via the response pipeline" do
+      expect(response_pipeline).to receive(:process).with(stub_response)
+
+      subject
+    end
+
+  end
+
+end