http_stub 0.21.0 → 0.22.0

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

@@ -4,14 +4,13 @@ describe HttpStub::Server::Application do
   let(:response)      { last_response }
   let(:response_body) { response.body.to_s }
 
-  let(:match_registry)    { instance_double(HttpStub::Server::Stub::Registry).as_null_object }
-  let(:stub_registry)     { instance_double(HttpStub::Server::Stub::Registry).as_null_object }
-  let(:scenario_registry) { instance_double(HttpStub::Server::Registry).as_null_object }
+  let(:match_registry)    { instance_double(HttpStub::Server::Stub::Registry) }
+  let(:stub_registry)     { instance_double(HttpStub::Server::Stub::Registry) }
+  let(:scenario_registry) { instance_double(HttpStub::Server::Registry) }
 
-  let(:stub_controller)     { instance_double(HttpStub::Server::Stub::Controller).as_null_object }
-  let(:scenario_controller) { instance_double(HttpStub::Server::Scenario::Controller).as_null_object }
+  let(:stub_controller)     { instance_double(HttpStub::Server::Stub::Controller) }
+  let(:scenario_controller) { instance_double(HttpStub::Server::Scenario::Controller) }
 
-  let(:request_pipeline)  { instance_double(HttpStub::Server::RequestPipeline, process: nil) }
   let(:response_pipeline) { instance_double(HttpStub::Server::ResponsePipeline, process: nil) }
 
   let(:app) { HttpStub::Server::Application.new! }
@@ -22,10 +21,21 @@ describe HttpStub::Server::Application do
     allow(HttpStub::Server::Stub::Registry).to receive(:new).and_return(stub_registry)
     allow(HttpStub::Server::Stub::Controller).to receive(:new).and_return(stub_controller)
     allow(HttpStub::Server::Scenario::Controller).to receive(:new).and_return(scenario_controller)
-    allow(HttpStub::Server::RequestPipeline).to receive(:new).and_return(request_pipeline)
     allow(HttpStub::Server::ResponsePipeline).to receive(:new).and_return(response_pipeline)
   end
 
+  context "when the diagnostics landing page is retrieved" do
+
+    subject { get "/http_stub" }
+
+    it "responds without error" do
+      subject
+
+      expect(response.status).to eql(200)
+    end
+
+  end
+
   context "when a stub registration request is received" do
 
     let(:registration_response) { instance_double(HttpStub::Server::Stub::Response::Base) }
@@ -83,6 +93,8 @@ describe HttpStub::Server::Application do
 
     subject { delete "/http_stub/stubs" }
 
+    before(:example) { allow(stub_controller).to receive(:clear) }
+
     it "delegates clearing to the stub controller" do
       expect(stub_controller).to receive(:clear)
 
@@ -101,6 +113,8 @@ describe HttpStub::Server::Application do
 
     subject { post "/http_stub/stubs/memory" }
 
+    before(:example) { allow(stub_registry).to receive(:remember) }
+
     it "remembers the stubs in the stub registry" do
       expect(stub_registry).to receive(:remember)
 
@@ -119,6 +133,8 @@ describe HttpStub::Server::Application do
 
     subject { get "/http_stub/stubs/memory" }
 
+    before(:example) { allow(stub_registry).to receive(:recall) }
+
     it "recalls the stubs remembered by the stub registry" do
       expect(stub_registry).to receive(:recall)
 
@@ -168,7 +184,7 @@ describe HttpStub::Server::Application do
       subject
     end
 
-    it "processes the scenarion controllers response via the response pipeline" do
+    it "processes the scenario controllers response via the response pipeline" do
       expect(response_pipeline).to receive(:process).with(registration_response)
 
       subject
@@ -176,6 +192,21 @@ describe HttpStub::Server::Application do
 
   end
 
+  context "when a request to show a scenario is received" do
+
+    let(:scenario_name)  { "Some scenario name" }
+    let(:found_scenario) { HttpStub::Server::Scenario::ScenarioFixture.empty }
+
+    subject { get "/http_stub/scenarios?#{URI.encode_www_form(:name => scenario_name)}" }
+
+    it "retrieves the scenario from the scenario registry" do
+      expect(scenario_registry).to receive(:find).with(scenario_name, anything).and_return(found_scenario)
+
+      subject
+    end
+
+  end
+
   context "when a request to list the scenarios is received" do
 
     let(:found_scenarios) { [ HttpStub::Server::Scenario::ScenarioFixture.empty ] }
@@ -190,10 +221,35 @@ describe HttpStub::Server::Application do
 
   end
 
+  context "when a scenario activation request is received" do
+
+    let(:scenario_name)       { "Some scenario name" }
+    let(:activation_response) { instance_double(HttpStub::Server::Stub::Response::Base) }
+
+    subject { post "/http_stub/scenarios/activate", :name => scenario_name }
+
+    before(:example) { allow(scenario_controller).to receive(:activate).and_return(activation_response) }
+
+    it "activates the scenario via the scenario controller" do
+      expect(scenario_controller).to receive(:activate).with(scenario_name, anything).and_return(activation_response)
+
+      subject
+    end
+
+    it "processes the scenario controllers response via the response pipeline" do
+      expect(response_pipeline).to receive(:process).with(activation_response)
+
+      subject
+    end
+
+  end
+
   context "when a request to clear the scenarios has been received" do
 
     subject { delete "/http_stub/scenarios" }
 
+    before(:example) { allow(scenario_controller).to receive(:clear) }
+
     it "delegates clearing to the scenario controller" do
       expect(scenario_controller).to receive(:clear)
 
@@ -208,24 +264,34 @@ describe HttpStub::Server::Application do
 
   end
 
+  context "when a request for the diagnostic pages stylesheet has been received" do
+
+    subject { get "/application.css" }
+
+    it "responds without error" do
+      subject
+
+      expect(response.status).to eql(200)
+    end
+
+  end
+
   context "when another type of request is received" do
 
-    let(:request_pipeline_response) { instance_double(HttpStub::Server::Stub::Response::Base) }
+    let(:stub_response) { instance_double(HttpStub::Server::Stub::Response::Base) }
 
     subject { get "/a_path" }
 
-    before(:example) { allow(request_pipeline).to receive(:process).and_return(request_pipeline_response) }
+    before(:example) { allow(stub_controller).to receive(:replay).and_return(stub_response) }
 
-    it "determines the response via the request pipeline" do
-      expect(request_pipeline).to(
-        receive(:process).with(an_instance_of(HttpStub::Server::Request), anything)
-      )
+    it "attempts to replay a stub response via the stub controller" do
+      expect(stub_controller).to receive(:replay).with(an_instance_of(HttpStub::Server::Request), anything)
 
       subject
     end
 
     it "processes the response via the response pipeline" do
-      expect(response_pipeline).to receive(:process).with(request_pipeline_response)
+      expect(response_pipeline).to receive(:process).with(stub_response)
 
       subject
     end

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

@@ -3,9 +3,14 @@ describe HttpStub::Server::Scenario::Activator do
   let(:logger)                   { instance_double(Logger) }
   let(:stubs)                    { (1..3).map { instance_double(HttpStub::Server::Stub::Stub) } }
   let(:triggered_scenario_names) { [] }
+  let(:scenario_triggers)        do
+    triggered_scenario_names.map do |scenario_name|
+      instance_double(HttpStub::Server::Scenario::Trigger, name: scenario_name)
+    end
+  end
   let(:scenario)                 do
     instance_double(
-      HttpStub::Server::Scenario::Scenario, stubs: stubs, triggered_scenario_names: triggered_scenario_names
+      HttpStub::Server::Scenario::Scenario, stubs: stubs, triggered_scenarios: scenario_triggers
     )
   end
   let(:scenario_registry)        { instance_double(HttpStub::Server::Registry).as_null_object }
@@ -26,10 +31,10 @@ describe HttpStub::Server::Scenario::Activator do
 
     context "when the scenario contains triggered scenarios" do
 
-      let(:triggered_scenario_names) { (1..3).map { |i| "triggered_scenario_name/#{i}" } }
+      let(:triggered_scenario_names) { (1..3).map { |i| "Triggered scenario name #{i}" } }
       let(:triggered_scenarios) do
         triggered_scenario_names.map do
-          instance_double(HttpStub::Server::Scenario::Scenario, stubs: [], triggered_scenario_names: [])
+          instance_double(HttpStub::Server::Scenario::Scenario, stubs: [], triggered_scenarios: [])
         end
       end
 

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

@@ -48,15 +48,17 @@ describe HttpStub::Server::Scenario::Controller do
 
   describe "#activate" do
 
-    subject { controller.activate(request, logger) }
+    let(:scenario_name) { "Some Scenario Name" }
 
-    it "finds a scenario whose name matches the request path omitting the '/' prefix" do
-      expect(scenario_registry).to receive(:find).with("some/request/path", logger)
+    subject { controller.activate(scenario_name, logger) }
+
+    it "finds a scenario whose name matches the provided name" do
+      expect(scenario_registry).to receive(:find).with(scenario_name, logger)
 
       subject
     end
 
-    describe "when a scenario is found that matches the request" do
+    describe "when a scenario is found" do
 
       before(:example) { allow(scenario_registry).to receive(:find).and_return(scenario) }
 
@@ -72,7 +74,7 @@ describe HttpStub::Server::Scenario::Controller do
 
     end
 
-    describe "when no stub activator is activated by the request" do
+    describe "when no scenario is found" do
 
       before(:example) { allow(scenario_registry).to receive(:find).and_return(nil) }
 
@@ -82,8 +84,8 @@ describe HttpStub::Server::Scenario::Controller do
         subject
       end
 
-      it "returns an empty response" do
-        expect(subject).to eql(HttpStub::Server::Response::EMPTY)
+      it "returns a not found response" do
+        expect(subject).to eql(HttpStub::Server::Response::NOT_FOUND)
       end
 
     end

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

@@ -0,0 +1,41 @@
+describe HttpStub::Server::Scenario::Links do
+
+  let(:name) { "without_esacpe_characters" }
+
+  let(:links) { described_class.new(name) }
+
+  describe "#detail" do
+
+    subject { links.detail }
+
+    it "returns a uri starting with '/http_stub/scenarios'" do
+      expect(subject).to start_with("/http_stub/scenarios")
+    end
+
+    it "returns a uri ending with a name parameter" do
+      expect(subject).to end_with("?name=#{name}")
+    end
+
+    context "when the name contains characters requiring uri escaping" do
+
+      let(:name) { "contains characters!to?be&escaped" }
+
+      it "returns a uri with the name uri escaped" do
+        expect(subject).to end_with("?name=contains+characters%21to%3Fbe%26escaped")
+      end
+
+    end
+
+  end
+
+  describe "#activate" do
+
+    subject { links.activate }
+
+    it "returns a generic activation link" do
+      expect(subject).to eql("/http_stub/scenarios/activate")
+    end
+
+  end
+
+end

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

@@ -1,22 +1,31 @@
 describe HttpStub::Server::Scenario::Scenario do
 
-  let(:name)                     { "some_scenario_name" }
-  let(:number_of_stubs)          { 3 }
-  let(:stubs)                    { (1..number_of_stubs).map { instance_double(HttpStub::Server::Stub::Stub) } }
-  let(:triggered_scenario_names) { (1..3).map { |i| "triggered/scenario/name/#{i}" } }
+  let(:name)            { "Some scenario name" }
+  let(:number_of_stubs) { 3 }
+  let(:stubs)           { (1..number_of_stubs).map { instance_double(HttpStub::Server::Stub::Stub) } }
+
+  let(:number_of_triggered_scenario_names) { 3 }
+  let(:triggered_scenario_names)           do
+    (1..number_of_triggered_scenario_names).map { |i| "Triggered Scenario Name #{i}" }
+  end
+  let(:triggered_scenarios)                do
+    (1..number_of_triggered_scenario_names).map { instance_double(HttpStub::Server::Scenario::Trigger) }
+  end
+
   let(:args) do
-    HttpStub::ScenarioFixture.new.with_name!(name).
+    HttpStub::ScenarioFixture.new.
+      with_name!(name).
       with_stubs!(number_of_stubs).
       with_triggered_scenario_names!(triggered_scenario_names).
       server_payload
   end
 
-  let(:scenario) { HttpStub::Server::Scenario::Scenario.new(args) }
-
-  before(:example) { allow(HttpStub::Server::Stub).to receive(:create).and_return(*stubs) }
+  let(:scenario) { described_class.new(args) }
 
   describe "#constructor" do
 
+    subject { scenario }
+
     context "when many stub payloads are provided" do
 
       let(:number_of_stubs) { 3 }
@@ -24,7 +33,7 @@ describe HttpStub::Server::Scenario::Scenario do
       it "creates an underlying stub for each stub payload provided" do
         args["stubs"].each { |stub_args| expect(HttpStub::Server::Stub).to receive(:create).with(stub_args) }
 
-        scenario
+        subject
       end
 
     end
@@ -33,10 +42,36 @@ describe HttpStub::Server::Scenario::Scenario do
 
       let(:number_of_stubs) { 1 }
 
-      it "creates an underlying stub for each stub payload provided" do
+      it "creates an underlying stub for the stub payload provided" do
         expect(HttpStub::Server::Stub).to receive(:create).with(args["stubs"].first)
 
-        scenario
+        subject
+      end
+
+    end
+
+    context "when many triggered scenario names are provided" do
+
+      let(:number_of_triggered_scenario_names) { 3 }
+
+      it "creates a scenario trigger for each trigger name provided" do
+        triggered_scenario_names.each do |scenario_name|
+          expect(HttpStub::Server::Scenario::Trigger).to receive(:new).with(scenario_name)
+        end
+
+        subject
+      end
+
+    end
+
+    context "when no triggered scenario names are provided" do
+
+      let(:number_of_triggered_scenario_names) { 0 }
+
+      it "does not create a scenario trigger" do
+        expect(HttpStub::Server::Scenario::Trigger).to_not receive(:new)
+
+        subject
       end
 
     end
@@ -49,7 +84,7 @@ describe HttpStub::Server::Scenario::Scenario do
 
     subject { scenario.matches?(other_name, logger) }
 
-    describe "when the scenario's name exactly matches the provided name" do
+    describe "when the scenarios name exactly matches the provided name" do
 
       let(:other_name) { name }
 
@@ -59,9 +94,9 @@ describe HttpStub::Server::Scenario::Scenario do
 
     end
 
-    describe "when the scenario's name is a substring of the provided name" do
+    describe "when the scenarios name is a substring of the provided name" do
 
-      let(:other_name) { "#{name}_with_additional_context" }
+      let(:other_name) { "#{name} With Additional Context" }
 
       it "returns false" do
         expect(subject).to be(false)
@@ -69,9 +104,9 @@ describe HttpStub::Server::Scenario::Scenario do
 
     end
 
-    describe "when the scenario's name is completely different to the provided name" do
+    describe "when the scenarios name is completely different to the provided name" do
 
-      let(:other_name) { "completely_different_scenario_name" }
+      let(:other_name) { "Completely Different Scenario Name" }
 
       it "returns false" do
         expect(subject).to be(false)
@@ -81,36 +116,43 @@ describe HttpStub::Server::Scenario::Scenario do
 
   end
 
-  describe "#uri" do
+  describe "#links" do
 
-    it "returns the scenario's name with '/' prefixed" do
-      expect(scenario.uri).to eql("/#{name}")
-    end
+    subject { scenario.links }
 
-  end
+    before(:example) { allow(HttpStub::Server::Scenario::Links).to receive(:new) }
 
-  describe "#stubs" do
+    it "create links for the scenario name" do
+      expect(HttpStub::Server::Scenario::Links).to receive(:new).with(name)
 
-    it "returns the HttpStub::Server::Stub's constructed from the scenario's arguments" do
-      expect(scenario.stubs).to eql(stubs)
+      subject
+    end
+
+    it "returns the created links" do
+      links = instance_double(HttpStub::Server::Scenario::Links)
+      allow(HttpStub::Server::Scenario::Links).to receive(:new).and_return(links)
+
+      expect(subject).to eql(links)
     end
 
   end
 
-  describe "#triggered_scenario_names" do
+  describe "#stubs" do
+
+    before(:example) { allow(HttpStub::Server::Stub).to receive(:create).and_return(*stubs) }
 
-    it "returns the value provided in the payload" do
-      expect(scenario.triggered_scenario_names).to eql(triggered_scenario_names)
+    it "returns the HttpStub::Server::Stub's constructed from the scenario's arguments" do
+      expect(scenario.stubs).to eql(stubs)
     end
 
   end
 
   describe "#triggered_scenarios" do
 
-    it "returns an array containing the triggered scenario names and uris" do
-      expected_details = triggered_scenario_names.reduce([]) { |result, name| result << [name, "/#{name}"] }
+    before(:example) { allow(HttpStub::Server::Scenario::Trigger).to receive(:new).and_return(*triggered_scenarios) }
 
-      expect(scenario.triggered_scenarios).to eql(expected_details)
+    it "returns the triggered scenarios constructed from the scenario's arguments" do
+      expect(scenario.triggered_scenarios).to eql(triggered_scenarios)
     end
 
   end