http_stub 0.15.5 → 0.16.0.pre1

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

@@ -6,7 +6,7 @@ describe HttpStub::Server::Daemon do
 
   before(:example) { allow(server_daemon.logger).to receive(:info) }
 
-  describe ".log_dir" do
+  describe "::log_dir" do
 
     before(:example) { @original_log_dir = HttpServerManager.log_dir }
 
@@ -20,7 +20,7 @@ describe HttpStub::Server::Daemon do
 
   end
 
-  describe ".pid_dir" do
+  describe "::pid_dir" do
 
     before(:example) { @original_pid_dir = HttpServerManager.pid_dir }
 

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

@@ -1,7 +1,7 @@
 describe HttpStub::Server::Registry do
 
   let(:logger)  { double("Logger").as_null_object }
-  let(:request) { double("HttpRequest", logger: logger, inspect: "Request inspect result") }
+  let(:request) { instance_double(Rack::Request, logger: logger) }
 
   let(:registry) { HttpStub::Server::Registry.new("a_model") }
 
@@ -9,35 +9,84 @@ describe HttpStub::Server::Registry do
 
     let(:models) { (1..3).map { |i| double("HttpStub::Server::Model#{i}", :satisfies? => false) } }
 
-    before(:example) { models.each { |model| registry.add(model, request) } }
+    before(:example) { registry.concat(models, request) }
 
   end
 
   describe "#add" do
 
+    let(:model_string_representation) { "some model string" }
+    let(:model)                       { double("HttpStub::Server::Model", to_s: model_string_representation) }
+
+    subject { registry.add(model, request) }
+
+    before(:example) { allow(logger).to receive(:info) }
+
     it "logs that the model has been registered" do
-      model = double("HttpStub::Server::Model", to_s: "Model as String")
-      expect(logger).to receive(:info).with(/Model as String/)
+      expect(logger).to receive(:info).with(/#{model_string_representation}/)
+
+      subject
+    end
+
+    it "adds the model" do
+      subject
 
-      registry.add(model, request)
+      expect(registry.last).to eql(model)
     end
 
   end
 
-  describe "#find_for" do
+  describe "#concat" do
+
+    let(:model_string_representations) { (1..3).map { |i| "model string ##{i}" } }
+    let(:models) do
+      model_string_representations.map do |string_representation|
+        double("HttpStub::Server::Model", to_s: string_representation)
+      end
+    end
+
+    subject { registry.concat(models, request) }
+
+    it "logs that the models have been registered" do
+      model_string_representations.each do |string_representation|
+        expect(logger).to receive(:info).with(/#{string_representation}/)
+      end
+
+      subject
+    end
+
+    it "adds the models" do
+      subject
+
+      expect(registry.all).to eql(models.reverse)
+    end
+
+  end
+
+  describe "#find" do
+
+    let(:criteria) { double("Criteria", inspect: "Criteria inspect result") }
+
+    subject { registry.find(criteria: criteria, request: request) }
 
     describe "when multiple models have been registered" do
 
       include_context "register multiple models"
 
-      describe "and one registered model satisfies the request" do
+      it "determines if the models satisfy the provided criteria" do
+        models.each { |model| expect(model).to receive(:satisfies?).with(criteria).and_return(false) }
+
+        subject
+      end
+
+      describe "and one registered model satisfies the criteria" do
 
         let(:matching_model) { models[1] }
 
         before(:example) { allow(matching_model).to receive(:satisfies?).and_return(true) }
 
         it "returns the model" do
-          expect(registry.find_for(request)).to eql(matching_model)
+          expect(subject).to eql(matching_model)
         end
 
         describe "and the registry is subsequently cleared" do
@@ -45,27 +94,27 @@ describe HttpStub::Server::Registry do
           before(:example) { registry.clear(request) }
 
           it "returns nil" do
-            expect(registry.find_for(request)).to be_nil
+            expect(subject).to be_nil
           end
 
         end
 
       end
 
-      describe "and multiple registered models satisfy the request" do
+      describe "and multiple registered models satisfy the criteria" do
 
         before(:example) { [0, 2].each { |i| allow(models[i]).to receive(:satisfies?).and_return(true) } }
 
         it "supports model overrides by returning the last model registered" do
-          expect(registry.find_for(request)).to eql(models[2])
+          expect(subject).to eql(models[2])
         end
 
       end
 
-      describe "and no registered models match the request" do
+      describe "and no registered models match the criteria" do
 
         it "returns nil" do
-          expect(registry.find_for(request)).to be_nil
+          expect(subject).to be_nil
         end
 
       end
@@ -75,15 +124,15 @@ describe HttpStub::Server::Registry do
     describe "when no model has been registered" do
 
       it "returns nil" do
-        expect(registry.find_for(request)).to be_nil
+        expect(subject).to be_nil
       end
 
     end
 
-    it "it should log model discovery diagnostics that includes the complete details of the request" do
-      expect(logger).to receive(:info).with(/Request inspect result/)
+    it "it should log model discovery diagnostics that includes the complete details of the criteria" do
+      expect(logger).to receive(:info).with(/Criteria inspect result/)
 
-      registry.find_for(request)
+      subject
     end
 
   end

data/spec/lib/http_stub/server/{request_parser_spec.rb → request_file_consolidator_spec.rb}

@@ -1,42 +1,19 @@
-describe HttpStub::Server::RequestParser do
+describe HttpStub::Server::Stub::PayloadFileConsolidator do
 
-  let(:request_parser) { HttpStub::Server::RequestParser }
+  let(:consolidator) { described_class }
 
-  describe "::parse" do
+  describe "::consolidate!" do
 
-    let(:params)    { {} }
-    let(:body_hash) { {} }
-    let(:request)   { instance_double(Rack::Request, params: params, body: StringIO.new(body_hash.to_json)) }
+    let(:params)  { {} }
+    let(:request) { instance_double(Rack::Request, params: params) }
 
-    subject { request_parser.parse(request) }
-
-    context "when the request contains a payload parameter" do
-
-      let(:payload) { HttpStub::StubFixture.new.server_payload }
-      let(:params)  { { "payload" => payload.to_json } }
-
-      it "returns the payload" do
-        expect(subject).to eql(payload)
-      end
-
-    end
-
-    context "when the request body contains the payload (for API backwards compatibility)" do
-
-      let(:body_hash) { HttpStub::StubFixture.new.server_payload }
-
-      it "returns the request body" do
-        expect(subject).to eql(body_hash)
-      end
-
-    end
+    subject { consolidator.consolidate!(payload, request) }
 
     context "when the payload contains a response file and has a corresponding file parameter" do
 
       let(:payload_fixture) { HttpStub::StubFixture.new.with_file_response! }
       let(:payload)         { payload_fixture.server_payload }
-      let(:file_params)     { { "response_file_#{payload_fixture.id}" => payload_fixture.file_parameter } }
-      let(:params)          { { "payload" => payload.to_json }.merge(file_params) }
+      let(:params)          { { "response_file_#{payload_fixture.id}" => payload_fixture.file_parameter } }
 
       it "returns the payload with a response body that contains the file parameter value" do
         expected_payload = payload.clone.tap { |hash| hash["response"]["body"] = payload_fixture.file_parameter }
@@ -54,7 +31,6 @@ describe HttpStub::Server::RequestParser do
       context "and the trigger payloads contain response text" do
 
         let(:trigger_fixtures) { (1..3).map { HttpStub::StubFixture.new.with_text_response! } }
-        let(:params)           { { "payload" => payload.to_json } }
 
         it "returns the payload unchanged" do
           expect(subject).to eql(payload)
@@ -65,12 +41,11 @@ describe HttpStub::Server::RequestParser do
       context "and the trigger payloads contain a response file with corresponding file parameters" do
 
         let(:trigger_fixtures) { (1..3).map { HttpStub::StubFixture.new.with_file_response! } }
-        let(:file_params) do
+        let(:params) do
           trigger_fixtures.reduce({}) do |result, fixture|
             result.merge("response_file_#{fixture.id}" => fixture.file_parameter)
           end
         end
-        let(:params)           { { "payload" => payload.to_json }.merge(file_params) }
 
         it "returns the payload with the trigger response bodies replaced by the files" do
           expected_payload = payload_fixture.server_payload
@@ -85,6 +60,18 @@ describe HttpStub::Server::RequestParser do
 
     end
 
+    context "when the payload does not contain a response file and has no triggers" do
+
+      let(:payload) { HttpStub::StubFixture.new.server_payload }
+
+      it "returns an unchanged payload" do
+        original_payload = payload.clone
+
+        expect(subject).to eql(original_payload)
+      end
+
+    end
+
   end
 
 end

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

@@ -6,7 +6,7 @@ describe HttpStub::Server::ResponsePipeline do
 
   describe "#process" do
 
-    let(:response) { double(HttpStub::Server::StubResponse::Base, delay_in_seconds: 5, serve_on: nil) }
+    let(:response) { double(HttpStub::Server::Stub::Response::Base, delay_in_seconds: 5, serve_on: nil) }
 
     before(:example) { allow(response_pipeline).to receive(:sleep) }
 

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

@@ -0,0 +1,106 @@
+describe HttpStub::Server::Scenario::Activator do
+
+  let(:request)                 { instance_double(Rack::Request) }
+  let(:stubs)                   { (1..3).map { instance_double(HttpStub::Server::Stub::Instance) } }
+  let(:triggered_scenario_names) { [] }
+  let(:scenario)                do
+    instance_double(
+      HttpStub::Server::Scenario::Instance, stubs: stubs, triggered_scenario_names: triggered_scenario_names
+    )
+  end
+  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_class)         { HttpStub::Server::Scenario::Activator }
+
+  let(:activator) { activator_class.new(scenario_registry, stub_registry) }
+
+  describe "#activate" do
+
+    subject { activator.activate(scenario, request) }
+
+    it "adds the scenario's stubs to the stub registry with the provided request" do
+      expect(stub_registry).to receive(:concat).with(stubs, request)
+
+      subject
+    end
+
+    context "when the scenario contains triggered scenarios" do
+
+      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::Instance, stubs: [], triggered_scenario_names: [])
+        end
+      end
+
+      before(:each) do
+        triggered_scenario_names.zip(triggered_scenarios).each do |triggered_scenario_name, triggered_scenario|
+          allow(scenario_registry).to(
+            receive(:find).with(hash_including(criteria: triggered_scenario_name)).and_return(triggered_scenario)
+          )
+        end
+      end
+
+      it "finds each triggered scenario in the scenario registry" do
+        triggered_scenario_names.zip(triggered_scenarios).each do |triggered_scenario_name, triggered_scenario|
+          expect(scenario_registry).to(
+            receive(:find).with(criteria: triggered_scenario_name, request: request).and_return(triggered_scenario)
+          )
+        end
+
+        subject
+      end
+
+      context "when the triggered scenario's are found" do
+
+        class HttpStub::Server::Scenario::ActivatorRetainingActivateArgs < HttpStub::Server::Scenario::Activator
+
+          attr_reader :activate_args
+
+          def initialize(scenario_registry, stub_registry)
+            super
+            @activate_args = []
+          end
+
+          def activate(scenario, request)
+            @activate_args << [ scenario, request ]
+            super
+          end
+
+        end
+
+        let(:activator_class) { HttpStub::Server::Scenario::ActivatorRetainingActivateArgs }
+
+        it "activates the scenario's" do
+          expected_activate_args = triggered_scenarios.reduce([ [ scenario, request ] ]) do |result, triggered_scenario|
+            result << [ triggered_scenario, request ]
+          end
+
+          subject
+
+          expect(activator.activate_args).to eql(expected_activate_args)
+        end
+
+      end
+
+      context "when a triggered scenario is not found" do
+
+        let(:scenario_name_not_found) { triggered_scenario_names[1] }
+
+        before(:example) do
+          allow(scenario_registry).to(
+            receive(:find).with(hash_including(criteria: scenario_name_not_found)).and_return(nil)
+          )
+        end
+
+        it "raises an error indicating the triggered scenario is not found" do
+          expect { subject }.to raise_error("Scenario not found with name '#{scenario_name_not_found}'")
+        end
+
+      end
+
+    end
+
+  end
+
+end

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

@@ -0,0 +1,102 @@
+describe HttpStub::Server::Scenario::Controller do
+
+  let(:request_path_info) { "/some/request/path" }
+  let(:request)           { instance_double(Rack::Request, path_info: request_path_info) }
+  let(:payload)           { HttpStub::ScenarioFixture.new.server_payload }
+  let(:stubs)             { (1..3).map { instance_double(HttpStub::Server::Stub::Instance) } }
+  let(:scenario)          { instance_double(HttpStub::Server::Scenario::Instance, 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::RequestParser).to receive(:parse).and_return(payload)
+    allow(HttpStub::Server::Scenario).to receive(:create).and_return(scenario)
+  end
+
+  describe "#register" do
+
+    subject { controller.register(request) }
+
+    it "parses the payload from the request" do
+      expect(HttpStub::Server::Scenario::RequestParser).to receive(:parse).with(request).and_return(payload)
+
+      subject
+    end
+
+    it "creates a scenario with the parsed payload" do
+      expect(HttpStub::Server::Scenario).to receive(:create).with(payload).and_return(scenario)
+
+      subject
+    end
+
+    it "adds the created scenario to the scenario registry with the provided request" do
+      expect(scenario_registry).to receive(:add).with(scenario, request)
+
+      subject
+    end
+
+    it "returns a success response" do
+      expect(subject).to eql(HttpStub::Server::Response::SUCCESS)
+    end
+
+  end
+
+  describe "#activate" do
+
+    subject { controller.activate(request) }
+
+    it "finds a scenario whose name matches the request path omitting the '/' prefix" do
+      expect(scenario_registry).to receive(:find).with(criteria: "some/request/path", request: request)
+
+      subject
+    end
+
+    describe "when a scenario is found that satisfies the request" do
+
+      before(:example) { allow(scenario_registry).to receive(:find).and_return(scenario) }
+
+      it "activates the scenario via the activator" do
+        expect(activator).to receive(:activate).with(scenario, request)
+
+        subject
+      end
+
+      it "returns a success response" do
+        expect(subject).to eql(HttpStub::Server::Response::SUCCESS)
+      end
+
+    end
+
+    describe "when no stub activator is activated by the request" do
+
+      before(:example) { allow(scenario_registry).to receive(:find).and_return(nil) }
+
+      it "does not add a stub to the registry" do
+        expect(stub_registry).not_to receive(:concat)
+
+        subject
+      end
+
+      it "returns an empty response" do
+        expect(subject).to eql(HttpStub::Server::Response::EMPTY)
+      end
+
+    end
+
+  end
+
+  describe "#clear" do
+
+    it "clears the scenario registry" do
+      expect(scenario_registry).to receive(:clear).with(request)
+
+      controller.clear(request)
+    end
+
+  end
+
+end