http_stub 0.15.5 → 0.16.0.pre1

data/spec/lib/http_stub/configurer/request/controllable_value_spec.rb

@@ -1,6 +1,6 @@
 describe HttpStub::Configurer::Request::ControllableValue do
 
-  describe ".format" do
+  describe "::format" do
 
     let(:value) { "some value" }
 

data/spec/lib/http_stub/configurer/request/http/factory_spec.rb

@@ -23,19 +23,19 @@ describe HttpStub::Configurer::Request::Http::Factory do
 
   end
 
-  describe "::stub_activator" do
+  describe "::scenario" do
 
-    let(:model)             { instance_double(HttpStub::Configurer::Request::StubActivator) }
+    let(:model)             { instance_double(HttpStub::Configurer::Request::Scenario) }
     let(:multipart_request) { instance_double(HttpStub::Configurer::Request::Http::Multipart) }
 
-    subject { HttpStub::Configurer::Request::Http::Factory.stub_activator(model) }
+    subject { HttpStub::Configurer::Request::Http::Factory.scenario(model) }
 
     before(:example) do
       allow(HttpStub::Configurer::Request::Http::Multipart).to receive(:new).and_return(multipart_request)
     end
 
-    it "creates a multipart request for the stub activators endpoint with the provided model" do
-      expect(HttpStub::Configurer::Request::Http::Multipart).to receive(:new).with("/stubs/activators", model)
+    it "creates a multipart request for the stub scenarios endpoint with the provided model" do
+      expect(HttpStub::Configurer::Request::Http::Multipart).to receive(:new).with("/stubs/scenarios", model)
 
       subject
     end
@@ -46,6 +46,47 @@ describe HttpStub::Configurer::Request::Http::Factory do
 
   end
 
+  describe "::activate" do
+
+    let(:uri)           { "some/activate/uri" }
+    let(:basic_request) { instance_double(HttpStub::Configurer::Request::Http::Basic) }
+
+    subject { HttpStub::Configurer::Request::Http::Factory.activate(uri) }
+
+    before(:example) do
+      allow(HttpStub::Configurer::Request::Http::Factory).to receive(:get).and_return(basic_request)
+    end
+
+    context "when the uri is not prefixed with '/'" do
+
+      let(:uri) { "uri/not/prefixed/with/forward/slash" }
+
+      it "creates a get request with the uri prefixed with '/'" do
+        expect(HttpStub::Configurer::Request::Http::Factory).to receive(:get).with("/#{uri}")
+
+        subject
+      end
+
+    end
+
+    context "when the uri is prefixed with '/'" do
+
+      let(:uri) { "/uri/prefixed/with/forward/slash" }
+
+      it "creates a get request with the provided uri" do
+        expect(HttpStub::Configurer::Request::Http::Factory).to receive(:get).with(uri)
+
+        subject
+      end
+
+    end
+
+    it "returns the created request" do
+      expect(subject).to eql(basic_request)
+    end
+
+  end
+
   describe "::get" do
 
     let(:path)          { "some/get/path" }

data/spec/lib/http_stub/configurer/request/omittable_spec.rb

@@ -1,6 +1,6 @@
 describe HttpStub::Configurer::Request::Omittable do
 
-  describe ".format" do
+  describe "::format" do
 
     context "when the value is a hash" do
 

data/spec/lib/http_stub/configurer/request/scenario_spec.rb

@@ -0,0 +1,69 @@
+describe HttpStub::Configurer::Request::Scenario do
+
+  let(:name)                     { "some/scenario/name" }
+  let(:stubs)                    { (1..3).map { instance_double(HttpStub::Configurer::Request::Stub) } }
+  let(:triggered_scenario_names) { (1..3).map { |i| "triggered/scenario/name/#{i}" } }
+
+  let(:scenario) do
+    HttpStub::Configurer::Request::Scenario.new(
+      name: name, stubs: stubs, triggered_scenario_names: triggered_scenario_names
+    )
+  end
+
+  describe "#payload" do
+
+    let(:stub_payloads) { stubs.each_with_index.map { |_stub, i| { stub_payload_key: "stub payload value #{i}" } } }
+
+    subject { scenario.payload }
+
+    before(:example) do
+      stubs.zip(stub_payloads).each { |stub, payload| allow(stub).to receive(:payload).and_return(payload) }
+    end
+
+    it "returns a hash containing the scenario's name" do
+      expect(subject).to include(name: name)
+    end
+
+    it "returns a hash containing the stub payloads" do
+      expect(subject).to include(stubs: stub_payloads)
+    end
+
+    it "returns a hash containing the uris to activate" do
+      expect(subject).to include(triggered_scenario_names: triggered_scenario_names)
+    end
+
+  end
+
+  describe "#response_files" do
+
+    let(:stub_response_files) do
+      stubs.map { (1..3).map { instance_double(HttpStub::Configurer::Request::StubResponseFile) } }
+    end
+
+    subject { scenario.response_files }
+
+    before(:example) do
+      stubs.zip(stub_response_files).each { |stub, files| allow(stub).to receive(:response_files).and_return(files) }
+    end
+
+    it "delegates to the stubs" do
+      stubs.zip(stub_response_files).each { |stub, files| expect(stub).to receive(:response_files).and_return(files) }
+
+      subject
+    end
+
+    it "returns the accummulation of all stub files" do
+      expect(subject).to eql(stub_response_files.flatten)
+    end
+
+  end
+
+  describe "#to_s" do
+
+    it "returns the scenario's name" do
+      expect(scenario.to_s).to eql(name)
+    end
+
+  end
+
+end

data/spec/lib/http_stub/configurer/request/stub_spec.rb

@@ -19,7 +19,7 @@ describe HttpStub::Configurer::Request::Stub do
                       payload: trigger_payload, response_files: trigger_files)
     end
     let(:trigger_builders) do
-      [ instance_double(HttpStub::Configurer::Request::StubBuilder, build: trigger) ]
+      [ instance_double(HttpStub::Configurer::DSL::StubBuilder, build: trigger) ]
     end
 
   end
@@ -35,7 +35,7 @@ describe HttpStub::Configurer::Request::Stub do
     end
     let(:trigger_builders) do
       triggers.map do |trigger|
-        instance_double(HttpStub::Configurer::Request::StubBuilder, build: trigger)
+        instance_double(HttpStub::Configurer::DSL::StubBuilder, build: trigger)
       end
     end
 

data/spec/lib/http_stub/configurer/server/facade_spec.rb

@@ -52,26 +52,26 @@ describe HttpStub::Configurer::Server::Facade do
 
   end
 
-  describe "#stub_activator" do
+  describe "#define_scenario" do
 
     let(:model_description) { "some model description" }
-    let(:model)             { instance_double(HttpStub::Configurer::Request::StubActivator, to_s: model_description) }
+    let(:model)             { instance_double(HttpStub::Configurer::Request::Scenario, to_s: model_description) }
     let(:request)           { instance_double(HttpStub::Configurer::Request::Http::Multipart) }
 
-    subject { facade.stub_activator(model) }
+    subject { facade.define_scenario(model) }
 
     before(:example) do
       allow(request_processor).to receive(:submit)
-      allow(HttpStub::Configurer::Request::Http::Factory).to receive(:stub_activator).and_return(request)
+      allow(HttpStub::Configurer::Request::Http::Factory).to receive(:scenario).and_return(request)
     end
 
-    it "creates a stub activator request with the provided model" do
-      expect(HttpStub::Configurer::Request::Http::Factory).to receive(:stub_activator).with(model)
+    it "creates a scenario request with the provided model" do
+      expect(HttpStub::Configurer::Request::Http::Factory).to receive(:scenario).with(model)
 
       subject
     end
 
-    it "submits the stub activator request via the request processor" do
+    it "submits the scenario request via the request processor" do
       expect(request_processor).to receive(:submit).with(hash_including(request: request))
 
       subject
@@ -79,7 +79,7 @@ describe HttpStub::Configurer::Server::Facade do
 
     it "describes the model via its string representation" do
       expect(request_processor).to(
-        receive(:submit).with(hash_including(description: "registering activator '#{model_description}'"))
+        receive(:submit).with(hash_including(description: "registering scenario '#{model_description}'"))
       )
 
       subject
@@ -95,12 +95,12 @@ describe HttpStub::Configurer::Server::Facade do
     subject { facade.activate(uri) }
 
     before(:example) do
-      allow(HttpStub::Configurer::Request::Http::Factory).to receive(:get).and_return(request)
+      allow(HttpStub::Configurer::Request::Http::Factory).to receive(:activate).and_return(request)
       allow(request_processor).to receive(:submit)
     end
 
-    it "creates a GET request for the uri" do
-      expect(HttpStub::Configurer::Request::Http::Factory).to receive(:get).with(uri).and_return(request)
+    it "creates an activation request for the uri" do
+      expect(HttpStub::Configurer::Request::Http::Factory).to receive(:activate).with(uri).and_return(request)
 
       subject
     end
@@ -212,20 +212,20 @@ describe HttpStub::Configurer::Server::Facade do
 
   end
 
-  describe "#clear_activators" do
+  describe "#clear_scenarios" do
 
     let(:request) { instance_double(HttpStub::Configurer::Request::Http::Basic) }
 
-    subject { facade.clear_activators }
+    subject { facade.clear_scenarios }
 
     before(:example) do
       allow(HttpStub::Configurer::Request::Http::Factory).to receive(:delete).and_return(request)
       allow(request_processor).to receive(:submit)
     end
 
-    it "creates a DELETE request for the /stubs/activators endpoint" do
+    it "creates a DELETE request for the /stubs/scenarios endpoint" do
       expect(HttpStub::Configurer::Request::Http::Factory).to(
-        receive(:delete).with("/stubs/activators").and_return(request)
+        receive(:delete).with("/stubs/scenarios").and_return(request)
       )
 
       subject
@@ -237,8 +237,8 @@ describe HttpStub::Configurer::Server::Facade do
       subject
     end
 
-    it "describes the request as clearing the server stub activators" do
-      expect(request_processor).to receive(:submit).with(hash_including(description: "clearing activators"))
+    it "describes the request as clearing the server scenarios" do
+      expect(request_processor).to receive(:submit).with(hash_including(description: "clearing scenarios"))
 
       subject
     end

data/spec/lib/http_stub/configurer_spec.rb

@@ -7,7 +7,7 @@ describe HttpStub::Configurer do
     port "8888"
   end
 
-  describe ".get_base_uri" do
+  describe "::get_base_uri" do
 
     it "returns a uri that combines the provided host and port" do
       expect(TestableConfigurer.get_base_uri).to include("some_host:8888")

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

@@ -32,10 +32,10 @@ describe HttpStub::Server::Application, "when the server is running" do
 
   end
 
-  describe "and a configurer with multiple stub activators is initialized" do
+  describe "and a configurer with multiple scenarios is initialized" do
 
     before(:context) do
-      configurer = HttpStub::Examples::ConfigurerWithClassActivators
+      configurer = HttpStub::Examples::ConfigurerWithExhaustiveScenarios
       configurer.host(server_host)
       configurer.port(server_port)
       configurer.initialize!
@@ -70,7 +70,7 @@ describe HttpStub::Server::Application, "when the server is running" do
       it "returns a response whose body contains the request headers of each stub trigger" do
         (1..3).each do |stub_number|
           (1..3).each do |trigger_number|
-            expected_header_key = "request_header_#{stub_number}_trigger_#{trigger_number}"
+            expected_header_key   = "request_header_#{stub_number}_trigger_#{trigger_number}"
             expected_header_value = "request_header_value_#{stub_number}_trigger_#{trigger_number}"
             expect(response.body).to match(/#{expected_header_key}:#{expected_header_value}/)
           end
@@ -86,7 +86,7 @@ describe HttpStub::Server::Application, "when the server is running" do
       it "returns a response whose body contains the parameters of each stub trigger" do
         (1..3).each do |stub_number|
           (1..3).each do |trigger_number|
-            expected_parameter_key = "parameter_#{stub_number}_trigger_#{trigger_number}"
+            expected_parameter_key   = "parameter_#{stub_number}_trigger_#{trigger_number}"
             expected_parameter_value = "parameter_value_#{stub_number}_trigger_#{trigger_number}"
             expect(response.body).to match(/#{expected_parameter_key}=#{expected_parameter_value}/)
           end
@@ -107,7 +107,7 @@ describe HttpStub::Server::Application, "when the server is running" do
 
       it "returns a response whose body contains the response headers of each stub" do
         (1..3).each do |stub_number|
-          expected_header_key = "response_header_#{stub_number}"
+          expected_header_key   = "response_header_#{stub_number}"
           expected_header_value = "response_header_value_#{stub_number}"
           expect(response.body).to match(/#{expected_header_key}:#{expected_header_value}/)
         end
@@ -116,7 +116,7 @@ describe HttpStub::Server::Application, "when the server is running" do
       it "returns a response whose body contains the response headers of each stub trigger" do
         (1..3).each do |stub_number|
           (1..3).each do |trigger_number|
-            expected_header_key = "response_header_#{stub_number}_trigger_#{trigger_number}"
+            expected_header_key   = "response_header_#{stub_number}_trigger_#{trigger_number}"
             expected_header_value = "response_header_value_#{stub_number}_trigger_#{trigger_number}"
             expect(response.body).to match(/#{expected_header_key}:#{expected_header_value}/)
           end
@@ -139,7 +139,7 @@ describe HttpStub::Server::Application, "when the server is running" do
       it "returns a response whose body contains the response body of each stub trigger" do
         (1..3).each do |stub_number|
           (1..3).each do |trigger_number|
-            expect(response.body).to match(/Body of activator #{stub_number}_trigger_#{trigger_number}/)
+            expect(response.body).to match(/Body of scenario stub #{stub_number}_trigger_#{trigger_number}/)
           end
         end
       end
@@ -158,13 +158,23 @@ describe HttpStub::Server::Application, "when the server is running" do
 
     end
 
-    describe "GET /stubs/activators" do
+    describe "GET /stubs/scenarios" do
 
-      let(:response) { HTTParty.get("#{server_uri}/stubs/activators") }
+      let(:response) { HTTParty.get("#{server_uri}/stubs/scenarios") }
 
-      it "returns response whose body contains links to each activator in alphabetical order" do
-        response_document.css("a.activator").each_with_index do |link, i|
-          expect(link['href']).to eql("/activator_#{i + 1}")
+      it "returns a response whose body contains links to each scenario in alphabetical order" do
+        expected_scenario_links = %w{ nested_scenario scenario }.map do |scenario_name_prefix|
+          (1..3).map { |i| "/#{scenario_name_prefix}_#{i}" }
+        end.flatten
+
+        scenario_links = response_document.css("a.scenario").map { |link| link['href'] }
+
+        expect(scenario_links).to eql(expected_scenario_links)
+      end
+
+      it "returns a response whose body contains links to the scenarios triggered by each scenario" do
+        response_document.css("a.triggered_scenario").each_with_index do |link, i|
+          expect(link['href']).to eql("/nested_scenario_#{i + 1}")
         end
       end
 
@@ -176,7 +186,7 @@ describe HttpStub::Server::Application, "when the server is running" do
 
       describe "when multiple stubs are configured" do
 
-        before(:context) { (1..3).each { |i| HTTParty.get("#{server_uri}/activator_#{i}") } }
+        before(:context) { (1..3).each { |i| HTTParty.get("#{server_uri}/scenario_#{i}") } }
 
         let(:response) { HTTParty.get("#{server_uri}/stubs") }
 

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

@@ -4,42 +4,42 @@ describe HttpStub::Server::Application do
   let(:response)      { last_response }
   let(:response_body) { response.body.to_s }
 
-  let(:stub_registry)           { instance_double(HttpStub::Server::StubRegistry).as_null_object }
-  let(:stub_activator_registry) { instance_double(HttpStub::Server::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(:stub_controller)           { instance_double(HttpStub::Server::StubController).as_null_object }
-  let(:stub_activator_controller) { instance_double(HttpStub::Server::StubActivatorController).as_null_object }
+  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(:response_pipeline) { instance_double(HttpStub::Server::ResponsePipeline, process: nil) }
 
   let(:app) { HttpStub::Server::Application.new! }
 
   before(:example) do
-    allow(HttpStub::Server::StubRegistry).to receive(:new).and_return(stub_registry)
-    allow(HttpStub::Server::Registry).to receive(:new).with("stub_activator").and_return(stub_activator_registry)
-    allow(HttpStub::Server::StubController).to receive(:new).and_return(stub_controller)
-    allow(HttpStub::Server::StubActivatorController).to receive(:new).and_return(stub_activator_controller)
+    allow(HttpStub::Server::Stub::Registry).to receive(:new).and_return(stub_registry)
+    allow(HttpStub::Server::Registry).to receive(:new).with("scenario").and_return(scenario_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::ResponsePipeline).to receive(:new).and_return(response_pipeline)
   end
 
-  context "when a stub insertion request is received" do
+  context "when a stub registration request is received" do
 
-    let(:stub_controller_response) { instance_double(HttpStub::Server::StubResponse::Base) }
+    let(:registration_response) { instance_double(HttpStub::Server::Stub::Response::Base) }
 
     subject do
       post "/stubs", { uri: "/a_path", method: "a method", response: { status: 200, body: "Foo" } }.to_json
     end
 
-    before(:example) { allow(stub_controller).to receive(:register).and_return(stub_controller_response) }
+    before(:example) { allow(stub_controller).to receive(:register).and_return(registration_response) }
 
-    it "registers the inserted stub via the controller" do
-      expect(stub_controller).to receive(:register).and_return(stub_controller_response)
+    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(stub_controller_response)
+      expect(response_pipeline).to receive(:process).with(registration_response)
 
       subject
     end
@@ -100,39 +100,41 @@ describe HttpStub::Server::Application do
 
   end
 
-  context "when a stub activator insertion request is received" do
+  context "when a scenario registration request is received" do
 
-    let(:stub_activator_response) { instance_double(HttpStub::Server::StubResponse::Base) }
+    let(:registration_response) { instance_double(HttpStub::Server::Stub::Response::Base) }
 
-    before(:example) { allow(stub_activator_controller).to receive(:register).and_return(stub_activator_response) }
+    before(:example) { allow(scenario_controller).to receive(:register).and_return(registration_response) }
 
     subject do
-      post "/stubs/activators", {
-        activation_uri: "/an_activation_path", uri: "/a_path", method: "a method",
-        response: { status: 200, body: "Foo" }
-      }.to_json
+      post "/stubs/scenarios",
+           {
+             uri: "/a_scenario_path",
+             stubs: [ { uri: "/a_path", method: "a method", response: { status: 200, body: "Foo" } } ],
+             triggered_scenario_names: [ "some/uri/to/activate" ]
+           }.to_json
     end
 
-    it "registers the insertion via the stub activator controller" do
-      expect(stub_activator_controller).to receive(:register).and_return(stub_activator_response)
+    it "registers the scenario via the scenario controller" do
+      expect(scenario_controller).to receive(:register).and_return(registration_response)
 
       subject
     end
 
-    it "processes the stub activators response via the response pipeline" do
-      expect(response_pipeline).to receive(:process).with(stub_activator_response)
+    it "processes the scenarion controllers response via the response pipeline" do
+      expect(response_pipeline).to receive(:process).with(registration_response)
 
       subject
     end
 
   end
 
-  context "when a request to clear the stub activators has been received" do
+  context "when a request to clear the scenarios has been received" do
 
-    subject { delete "/stubs/activators" }
+    subject { delete "/stubs/scenarios" }
 
-    it "delegates clearing to the stub activator controller" do
-      expect(stub_activator_controller).to receive(:clear)
+    it "delegates clearing to the scenario controller" do
+      expect(scenario_controller).to receive(:clear)
 
       subject
     end
@@ -147,7 +149,7 @@ describe HttpStub::Server::Application do
 
   context "when another type of request is received" do
 
-    let(:stub_response) { instance_double(HttpStub::Server::StubResponse::Base) }
+    let(:stub_response) { instance_double(HttpStub::Server::Stub::Response::Base) }
 
     subject { get "/a_path" }
 
@@ -167,28 +169,28 @@ describe HttpStub::Server::Application do
 
     context "and the stub controller does not replay a response" do
 
-      let(:stub_activator_response) { double(HttpStub::Server::StubResponse::Base, serve_on: nil) }
+      let(:scenario_response) { double(HttpStub::Server::Stub::Response::Base, serve_on: nil) }
 
       before(:example) do
         allow(stub_response).to receive(:empty?).and_return(true)
-        allow(stub_activator_controller).to receive(:activate).and_return(stub_activator_response)
+        allow(scenario_controller).to receive(:activate).and_return(scenario_response)
       end
 
-      context "but the stub activator controller activates a stub" do
+      context "but the scenario controller activates a scenario" do
 
-        before(:each) { allow(stub_activator_response).to receive(:empty?).and_return(false) }
+        before(:each) { allow(scenario_response).to receive(:empty?).and_return(false) }
 
-        it "processes the stub activator response via the response pipeline" do
-          expect(response_pipeline).to receive(:process).with(stub_activator_response)
+        it "processes the scenario response via the response pipeline" do
+          expect(response_pipeline).to receive(:process).with(scenario_response)
 
           subject
         end
 
       end
 
-      context "and the stub activator controller does not activate a stub" do
+      context "and the scenario controller does not activate a scenario" do
 
-        before(:each) { allow(stub_activator_response).to receive(:empty?).and_return(true) }
+        before(:each) { allow(scenario_response).to receive(:empty?).and_return(true) }
 
         it "processes an error response via the response pipeline" do
           expect(response_pipeline).to receive(:process).with(HttpStub::Server::Response::ERROR)