http_stub 0.27.0 → 0.28.0.beta1

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

@@ -42,8 +42,10 @@ describe HttpStub::Server::Registry do
 
       subject { described_class.new(model_name, models) }
 
-      it "creates a registry with the models" do
-        expect(subject.all).to eql(models)
+      it "creates a registry with the models in reverse order as the registry operates akin to a stack" do
+        registry = subject
+
+        expect(registry.all).to eql(models.reverse)
       end
 
     end
@@ -230,6 +232,59 @@ describe HttpStub::Server::Registry do
 
   end
 
+  describe "#find_all" do
+
+    subject { registry.find_all(&condition) }
+
+    context "when multiple models have been registered" do
+      include_context "register multiple models"
+
+      let(:condition) { lambda { |model| matching_models.include?(model) } }
+
+      context "when many models match the condition" do
+
+        let(:matching_models) { [ models.first, models.last ] }
+
+        it "returns the models preserving stack order" do
+          expect(subject).to eql(matching_models.reverse)
+        end
+
+      end
+
+      context "when one model matches the condition" do
+
+        let(:matching_models) { [ models[1] ] }
+
+        it "returns an array containing the model" do
+          expect(subject).to eql(matching_models)
+        end
+
+      end
+
+      context "when no model matches the condition" do
+
+        let(:matching_models) { [] }
+
+        it "returns an empty array" do
+          expect(subject).to eql([])
+        end
+
+      end
+
+    end
+
+    context "when no models have been registered" do
+
+      let(:condition) { lambda { |_| true } }
+
+      it "returns an empty array" do
+        expect(subject).to eql([])
+      end
+
+    end
+
+  end
+
   describe "#last" do
 
     context "when multiple models have been registered" do

data/spec/lib/http_stub/server/request/factory_spec.rb

@@ -1,19 +1,21 @@
 describe HttpStub::Server::Request::Factory 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_identifier_setting) { nil }
+  let(:session_registry)           { instance_double(HttpStub::Server::Session::Registry) }
+  let(:server_memory)              do
+    instance_double(HttpStub::Server::Memory::Memory, session_registry: session_registry)
+  end
 
   let(:session_identifier_strategy) { instance_double(HttpStub::Server::Session::IdentifierStrategy) }
 
-  let(:factory) { described_class.new(session_configuration, server_memory) }
+  let(:factory) { described_class.new(session_identifier_setting, server_memory) }
 
   before(:example) do
     allow(HttpStub::Server::Session::IdentifierStrategy).to receive(:new).and_return(session_identifier_strategy)
   end
 
-  it "creates a session identifier strategy based on the session configuration" do
-    expect(HttpStub::Server::Session::IdentifierStrategy).to receive(:new).with(session_configuration)
+  it "creates a session identifier strategy based on the session identifier setting" do
+    expect(HttpStub::Server::Session::IdentifierStrategy).to receive(:new).with(session_identifier_setting)
 
     factory
   end

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

@@ -7,7 +7,7 @@ describe HttpStub::Server::Response do
     end
 
     it "has a body containing OK to visually indicate success to those interacting via a browser" do
-      expect(subject.body).to include("OK")
+      expect(subject.body.to_s).to include("OK")
     end
 
   end
@@ -20,20 +20,42 @@ describe HttpStub::Server::Response do
 
     context "when options are provided" do
 
-      let(:headers) { { "response_header_key" => "response header value" } }
-      let(:body)    { "response body" }
-      let(:opts)    { { "headers" => headers, "body" => body } }
+      let(:headers)          { { response_header_key: "response header value" } }
+      let(:body)             { "response body" }
+      let(:delay_in_seconds) { "response body" }
+      let(:opts)             { { headers: headers, body: body, delay_in_seconds: delay_in_seconds } }
 
-      subject { HttpStub::Server::Response::ok(opts) }
+      subject { described_class.ok(opts) }
 
       it "establishes any headers provided" do
-        expect(subject.headers).to eql(headers)
+        expect(subject.headers.to_json).to eql(headers.to_json)
       end
 
       it "establishes any body provided" do
-        expect(subject.body).to eql(body)
+        expect(subject.body.to_s).to eql(body)
       end
 
+      it "establishes any delay provided" do
+        expect(subject.delay_in_seconds).to eql(delay_in_seconds)
+      end
+
+    end
+
+  end
+
+  describe "::invalid_request" do
+
+    let(:cause_message) { "Some error message" }
+    let(:cause)         { StandardError.new(cause_message) }
+
+    subject { described_class.invalid_request(cause) }
+
+    it "has a status of 400" do
+      expect(subject.status).to eql(400)
+    end
+
+    it "has a body containing the message of the cause" do
+      expect(subject.body.to_s).to include(cause_message)
     end
 
   end
@@ -55,7 +77,7 @@ describe HttpStub::Server::Response do
     end
 
     it "has a body containing NOT FOUND to visually indicate the response to those interacting via a browser" do
-      expect(subject.body).to include("NOT FOUND")
+      expect(subject.body.to_s).to include("NOT FOUND")
     end
 
   end
@@ -68,8 +90,8 @@ describe HttpStub::Server::Response do
       expect(subject.status).to eql(200)
     end
 
-    it "has no body" do
-      expect(subject.body.provided?).to be(false)
+    it "has an empty body" do
+      expect(subject.body.to_s).to be_empty
     end
 
   end

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

@@ -1,7 +1,7 @@
 describe HttpStub::Server::Scenario::Controller do
 
   let(:scenario_registry) { instance_double(HttpStub::Server::Registry) }
-  let(:server_memory)     { instance_double(HttpStub::Server::Memory::Memory, scenarios: scenario_registry) }
+  let(:server_memory)     { instance_double(HttpStub::Server::Memory::Memory, scenario_registry: scenario_registry) }
 
   let(:request_uri)        { "/some/request/path" }
   let(:request_parameters) { {} }
@@ -12,47 +12,12 @@ describe HttpStub::Server::Scenario::Controller do
                                                         session:    session)
   end
   let(:logger)             { instance_double(Logger) }
-  let(:payload)            { HttpStub::ScenarioFixture.new.server_payload }
   let(:stubs)              { (1..3).map { instance_double(HttpStub::Server::Stub::Stub) } }
   let(:scenario)           { instance_double(HttpStub::Server::Scenario::Scenario, stubs: stubs) }
   let(:activator)          { instance_double(HttpStub::Server::Scenario::Activator).as_null_object }
 
   let(:controller) { described_class.new(server_memory) }
 
-  describe "#register" do
-
-    subject { controller.register(request, logger) }
-
-    before(:example) do
-      allow(HttpStub::Server::Scenario::Parser).to receive(:parse).and_return(payload)
-      allow(HttpStub::Server::Scenario).to receive(:create).and_return(scenario)
-      allow(scenario_registry).to receive(:add)
-    end
-
-    it "parses the payload from the request" do
-      expect(HttpStub::Server::Scenario::Parser).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 servers scenario registry with the provided logger" do
-      expect(scenario_registry).to receive(:add).with(scenario, logger)
-
-      subject
-    end
-
-    it "returns an ok response" do
-      expect(subject).to eql(HttpStub::Server::Response::OK)
-    end
-
-  end
-
   describe "#find" do
 
     let(:name)               { URI.encode_www_form_component("Some scenario name") }
@@ -82,7 +47,7 @@ describe HttpStub::Server::Scenario::Controller do
 
   describe "#find_all" do
 
-    let(:scenarios) { (1..3).map { |i| HttpStub::Server::ScenarioFixture.create("#{4 - i}") } }
+    let(:scenarios) { (1..3).map { |i| HttpStub::Server::ScenarioFixture.create(name: "#{4 - i}") } }
 
     subject { controller.find_all }
 
@@ -123,8 +88,12 @@ describe HttpStub::Server::Scenario::Controller do
           )
         end
 
-        it "returns a not found response" do
-          expect(subject).to eql(HttpStub::Server::Response::NOT_FOUND)
+        it "returns a response indicating the request was invalid" do
+          expect(subject.status).to eql(400)
+        end
+
+        it "returns a response whose body includes the scenario name" do
+          expect(subject.body.to_s).to include(scenario_name)
         end
 
       end
@@ -156,8 +125,12 @@ describe HttpStub::Server::Scenario::Controller do
           )
         end
 
-        it "returns a not found response" do
-          expect(subject).to eql(HttpStub::Server::Response::NOT_FOUND)
+        it "returns a response indicating the request was invalid" do
+          expect(subject.status).to eql(400)
+        end
+
+        it "returns a response whose body includes the name of the not found scenario" do
+          expect(subject.body.to_s).to include(scenario_name_not_found)
         end
 
       end
@@ -178,16 +151,4 @@ describe HttpStub::Server::Scenario::Controller do
 
   end
 
-  describe "#clear" do
-
-    subject { controller.clear(logger) }
-
-    it "clears the servers scenario registry" do
-      expect(scenario_registry).to receive(:clear).with(logger)
-
-      subject
-    end
-
-  end
-
 end

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

@@ -0,0 +1,147 @@
+describe HttpStub::Server::Scenario::Registry do
+
+  let(:scenarios) { (1..3).map { HttpStub::Server::ScenarioFixture.create } }
+
+  let(:logger) { HttpStub::Server::SilentLogger }
+
+  let(:scenario_registry) { described_class.new(scenarios) }
+
+  shared_context "mocked underlying registry" do
+
+    let(:underlying_scenario_registry) { instance_double(HttpStub::Server::Registry) }
+
+    before(:example) { allow(HttpStub::Server::Registry).to receive(:new).and_return(underlying_scenario_registry) }
+
+  end
+
+  it "uses an underlying simple registry that is initialised with the provided scenarios" do
+    expect(HttpStub::Server::Registry).to receive(:new).with("scenario", scenarios)
+
+    scenario_registry
+  end
+
+  describe "#find" do
+    include_context "mocked underlying registry"
+
+    let(:name) { "some scenario name" }
+
+    let(:found_scenario) { scenarios.last }
+
+    subject { scenario_registry.find(name, logger) }
+
+    before(:example) { allow(underlying_scenario_registry).to receive(:find).and_return(found_scenario) }
+
+    it "delegates to an underlying simple registry" do
+      expect(underlying_scenario_registry).to receive(:find).with(name, logger)
+
+      subject
+    end
+
+    it "returns any found scenario" do
+      expect(subject).to eql(found_scenario)
+    end
+
+  end
+
+  describe "#find_all" do
+
+    subject { scenario_registry.find_all { |scenario| matching_scenarios.include?(scenario) } }
+
+    context "when some scenarios match" do
+
+      let(:matching_scenarios) { [ scenarios.first, scenarios.last ] }
+
+      it "returns the matching scenarios" do
+        expect(subject).to contain_exactly(*matching_scenarios)
+      end
+
+    end
+
+    context "when no scenarios match" do
+
+      let(:matching_scenarios) { [] }
+
+      it "returns an empty array" do
+        expect(subject).to eql([])
+      end
+
+    end
+
+  end
+
+  describe "#all" do
+    include_context "mocked underlying registry"
+
+    let(:all_scenarios) { (1..3).map { HttpStub::Server::ScenarioFixture.create } }
+
+    subject { scenario_registry.all }
+
+    before(:example) { allow(underlying_scenario_registry).to receive(:all).and_return(all_scenarios) }
+
+    it "delegates to an underlying simple registry" do
+      expect(underlying_scenario_registry).to receive(:all)
+
+      subject
+    end
+
+    it "returns the result from the underlying registry" do
+      expect(subject).to eql(all_scenarios)
+    end
+
+  end
+
+  describe "#stubs_activated_by" do
+
+    let(:scenario)        do
+      HttpStub::Server::ScenarioFixture.with_stubs(
+        triggered_scenario_names: scenarios_triggered_names
+      )
+    end
+    let(:other_scenarios) { (1..3).map { HttpStub::Server::ScenarioFixture.with_stubs } }
+
+    subject { scenario_registry.stubs_activated_by(scenario, logger) }
+
+    context "when the scenario has no triggers" do
+
+      let(:scenarios)                 { [ scenario ] + other_scenarios }
+      let(:scenarios_triggered_names) { [] }
+
+      it "returns the scenario's stubs" do
+        expect(subject).to eql(scenario.stubs)
+      end
+
+    end
+
+    context "when the scenario has triggers which are nested" do
+
+      let(:scenarios_triggered_names)       { (1..3).map { |i| "trigger_#{i}" } }
+      let(:nested_scenario_triggered_names) { (1..3).map { |i| (1..3).map { |j| "nested_trigger_#{i}_#{j}" } } }
+
+      let(:scenarios_triggered)             do
+        scenarios_triggered_names.each_with_index.map do |trigger_name, i|
+          HttpStub::Server::ScenarioFixture.with_stubs(
+            name:                     trigger_name,
+            triggered_scenario_names: nested_scenario_triggered_names[i]
+          )
+        end
+      end
+
+      let(:nested_scenarios_triggered) do
+        nested_scenario_triggered_names.map do |trigger_names|
+          trigger_names.map { |trigger_name| HttpStub::Server::ScenarioFixture.with_stubs(name: trigger_name) }
+        end.flatten
+      end
+
+      let(:scenarios) { [ scenario ] + other_scenarios + scenarios_triggered + nested_scenarios_triggered }
+
+      it "returns the stubs from the scenario and all triggered scenario's" do
+        active_scenarios = [ scenario, scenarios_triggered, nested_scenarios_triggered ].flatten
+
+        expect(subject).to contain_exactly(*active_scenarios.map(&:stubs).flatten)
+      end
+
+    end
+
+  end
+
+end

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

@@ -12,15 +12,15 @@ describe HttpStub::Server::Scenario::Scenario do
     (1..number_of_triggered_scenario_names).map { instance_double(HttpStub::Server::Scenario::Trigger) }
   end
 
-  let(:args) do
-    HttpStub::ScenarioFixture.new.
+  let(:scenario_hash) do
+    HttpStub::Configurator::ScenarioBuilder.new.
       with_name!(name).
       with_stubs!(number_of_stubs).
       with_triggered_scenario_names!(triggered_scenario_names).
-      server_payload
+      build_hash
   end
 
-  let(:scenario) { described_class.new(args) }
+  let(:scenario) { described_class.new(scenario_hash) }
 
   describe "#constructor" do
 
@@ -31,7 +31,7 @@ describe HttpStub::Server::Scenario::Scenario do
       let(:number_of_stubs) { 3 }
 
       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_hash[:stubs].each { |stub_args| expect(HttpStub::Server::Stub).to receive(:create).with(stub_args) }
 
         subject
       end
@@ -43,7 +43,7 @@ describe HttpStub::Server::Scenario::Scenario do
       let(:number_of_stubs) { 1 }
 
       it "creates an underlying stub for the stub payload provided" do
-        expect(HttpStub::Server::Stub).to receive(:create).with(args["stubs"].first)
+        expect(HttpStub::Server::Stub).to receive(:create).with(scenario_hash[:stubs].first)
 
         subject
       end
@@ -159,10 +159,8 @@ describe HttpStub::Server::Scenario::Scenario do
 
   describe "#to_s" do
 
-    it "returns the string representation of the activation arguments" do
-      expect(args).to receive(:to_s).and_return("scenario string representation")
-
-      expect(scenario.to_s).to eql("scenario string representation")
+    it "returns the string representation of the provided hash" do
+      expect(scenario.to_s).to eql(scenario_hash.to_s)
     end
 
   end