http_stub 0.25.1 → 0.26.0

data/spec/lib/http_stub/server/stub/empty_spec.rb

@@ -20,8 +20,8 @@ describe HttpStub::Server::Stub::Empty do
 
   describe "#triggers" do
 
-    it "is an empty array" do
-      expect(empty_stub.triggers).to eql([])
+    it "is empty" do
+      expect(empty_stub.triggers).to eql(HttpStub::Server::Stub::Triggers::EMPTY)
     end
 
   end

data/spec/lib/http_stub/server/stub/match/controller_spec.rb

@@ -1,33 +1,36 @@
 describe HttpStub::Server::Stub::Match::Controller do
 
-  let(:registry) { instance_double(HttpStub::Server::Registry) }
+  let(:request_parameters) { {} }
+  let(:session)            { instance_double(HttpStub::Server::Session::Session) }
+  let(:request)            do
+    instance_double(HttpStub::Server::Request::Request, parameters: request_parameters, session: session)
+  end
 
-  let(:controller) { described_class.new(registry) }
+  let(:controller) { described_class.new }
 
-  describe "#find_last" do
+  describe "#last_match" do
 
-    let(:uri)        { "/some/endpoint/uri" }
-    let(:method)     { "PATCH" }
-    let(:parameters) { { uri: uri, method: method } }
-    let(:request)    { instance_double(HttpStub::Server::Request::Request, parameters: parameters) }
-    let(:logger)     { instance_double(Logger) }
+    let(:uri)                { "/some/endpoint/uri" }
+    let(:method)             { "PATCH" }
+    let(:request_parameters) { { uri: uri, method: method } }
+    let(:logger)             { instance_double(Logger) }
 
-    subject { controller.find_last(request, logger) }
+    subject { controller.last_match(request, logger) }
 
-    it "finds the match in the registry with the uri requested" do
-      expect(registry).to receive(:find).with(hash_including(uri: uri), anything)
+    it "finds the match in the users session having the uri requested" do
+      expect(session).to receive(:last_match).with(hash_including(uri: uri), anything)
 
       subject
     end
 
-    it "finds the match in the registry with the HTTP method requested" do
-      expect(registry).to receive(:find).with(hash_including(method: method), anything)
+    it "finds the match in the users session having the HTTP method requested" do
+      expect(session).to receive(:last_match).with(hash_including(method: method), anything)
 
       subject
     end
 
     it "finds the match using the provided logger for diagnostics" do
-      expect(registry).to receive(:find).with(anything, logger)
+      expect(session).to receive(:last_match).with(anything, logger)
 
       subject
     end
@@ -37,7 +40,7 @@ describe HttpStub::Server::Stub::Match::Controller do
       let(:match_json) { "some match JSON" }
       let(:match)      { instance_double(HttpStub::Server::Stub::Match::Match, to_json: match_json) }
 
-      before(:example) { allow(registry).to receive(:find).and_return(match) }
+      before(:example) { allow(session).to receive(:last_match).and_return(match) }
 
       it "creates an ok response containing the JSON representation of the match" do
         expect(HttpStub::Server::Response).to receive(:ok).with("body" => match_json)
@@ -56,7 +59,7 @@ describe HttpStub::Server::Stub::Match::Controller do
 
     context "when a match is not found" do
 
-      before(:example) { allow(registry).to receive(:find).and_return(nil) }
+      before(:example) { allow(session).to receive(:last_match).and_return(nil) }
 
       it "returns a not found response" do
         expect(subject).to eql(HttpStub::Server::Response::NOT_FOUND)
@@ -66,4 +69,44 @@ describe HttpStub::Server::Stub::Match::Controller do
 
   end
 
+  describe "#matches" do
+
+    let(:matches) { (1..3).map { instance_double(HttpStub::Server::Stub::Match::Match) } }
+
+    subject { controller.matches(request) }
+
+    before(:example) { allow(session).to receive(:matches).and_return(matches) }
+
+    it "retrieves all matches from the users session" do
+      expect(session).to receive(:matches)
+
+      subject
+    end
+
+    it "returns the matches" do
+      expect(subject).to eql(matches)
+    end
+
+  end
+
+  describe "#matches" do
+
+    let(:misses) { (1..3).map { instance_double(HttpStub::Server::Stub::Match::Miss) } }
+
+    subject { controller.misses(request) }
+
+    before(:example) { allow(session).to receive(:misses).and_return(misses) }
+
+    it "retrieves all misses from the users session" do
+      expect(session).to receive(:misses)
+
+      subject
+    end
+
+    it "returns the misses" do
+      expect(subject).to eql(misses)
+    end
+
+  end
+
 end

data/spec/lib/http_stub/server/stub/payload/response_body_modifier_spec.rb

@@ -1,7 +1,5 @@
 describe HttpStub::Server::Stub::Payload::ResponseBodyModifier do
 
-  let(:modifier) { described_class }
-
   describe "::modify!" do
 
     let(:parameters) { {} }
@@ -9,7 +7,7 @@ describe HttpStub::Server::Stub::Payload::ResponseBodyModifier do
 
     let!(:original_payload) { payload.clone }
 
-    subject { modifier.modify!(payload, request) }
+    subject { described_class.modify!(payload, request) }
 
     context "when the payload contains a response file and has a corresponding file parameter" do
 
@@ -27,9 +25,9 @@ describe HttpStub::Server::Stub::Payload::ResponseBodyModifier do
 
     end
 
-    context "when the payload contains triggers" do
+    context "when the payload contains triggered stubs" do
 
-      let(:payload_fixture) { HttpStub::StubFixture.new.with_triggers!(trigger_fixtures) }
+      let(:payload_fixture) { HttpStub::StubFixture.new.with_triggered_stubs!(trigger_fixtures) }
       let(:payload)         { payload_fixture.server_payload }
 
       context "and the trigger payloads contain response text" do
@@ -47,6 +45,7 @@ describe HttpStub::Server::Stub::Payload::ResponseBodyModifier 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_parameters)  { trigger_fixtures.map(&:file_parameter) }
         let(:parameters) do
           trigger_fixtures.reduce({}) do |result, fixture|
             result.merge("response_file_#{fixture.id}" => fixture.file_parameter)
@@ -55,8 +54,8 @@ describe HttpStub::Server::Stub::Payload::ResponseBodyModifier do
 
         it "modifies the payload to have trigger response bodies replaced by the files" do
           expected_payload = payload.clone
-          expected_payload["triggers"].zip(trigger_fixtures.map(&:file_parameter)).each do |trigger, file_param|
-            trigger["response"]["body"] = file_param
+          expected_payload["triggers"]["stubs"].zip(file_parameters).each do |trigger, file_parameter|
+            trigger["response"]["body"] = file_parameter
           end
 
           subject
@@ -68,7 +67,7 @@ describe HttpStub::Server::Stub::Payload::ResponseBodyModifier do
 
     end
 
-    context "when the payload does not contain a response file and has no triggers" do
+    context "when the payload does not contain a response file and has no triggered stubs" do
 
       let(:payload) { HttpStub::StubFixture.new.server_payload }
 

data/spec/lib/http_stub/server/stub/registry_integration_spec.rb

@@ -1,35 +1,59 @@
 describe HttpStub::Server::Stub::Registry, "integrating with real stubs" do
 
+  let(:memory_session) { HttpStub::Server::SessionFixture.memory }
+
   let(:logger) { instance_double(Logger, info: nil) }
 
-  let(:stub_registry) { HttpStub::Server::Stub::Registry.new }
+  let(:stub_registry) { HttpStub::Server::Stub::Registry.new(memory_session) }
+
+  shared_context "a stub is added" do
+
+    let(:added_stub) { create_stub(4) }
+
+    before(:example) { stub_registry.add(added_stub, logger) }
 
-  describe "#recall" do
+  end
+
+  describe "#reset" do
 
-    subject { stub_registry.recall }
+    subject { stub_registry.reset(logger) }
 
-    context "when stubs have been added" do
+    context "when stubs have been added to the servers memory" do
 
       let(:stubs) { (1..3).map { |i| create_stub(i) } }
 
-      before(:example) { stubs.each { |stub| stub_registry.add(stub, logger) } }
+      before(:example) { stubs.each { |stub| memory_session.add_stub(stub, logger) } }
 
-      context "and remembered" do
+      context "and a stub is subsequently added" do
 
-        before(:example) { stub_registry.remember }
+        include_context "a stub is added"
 
-        context "and a stub subsequently added" do
+        it "retains stubs added to the servers memory" do
+          subject
+
+          expect(stub_registry.all).to eql(stubs)
+        end
+
+        it "rejects stubs not added to the servers memory" do
+          subject
+
+          expect(stub_registry.all).not_to include(added_stub)
+        end
+
+      end
+
+    end
 
-          let(:stub_to_add) { create_stub(4) }
+    context "when no stubs have been added to the servers memory" do
 
-          before(:example) { stub_registry.add(stub_to_add, logger) }
+      context "and a stub is subsequently added" do
 
-          it "should restore all known stubs to the remembered state" do
-            subject
+        include_context "a stub is added"
 
-            expect(stub_registry.all).not_to include(stub_to_add)
-          end
+        it "clears the stubs" do
+          subject
 
+          expect(stub_registry.all).to eql([])
         end
 
       end
@@ -48,7 +72,10 @@ describe HttpStub::Server::Stub::Registry, "integrating with real stubs" do
         "status" => 200 + number,
         "body" => "Body #{number}"
       },
-      "triggers" => []
+      "triggers" => {
+        "scenario_names" => [],
+        "stubs"          => []
+      }
     )
   end
 

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

@@ -1,13 +1,21 @@
 describe HttpStub::Server::Stub::Registry do
 
-  let(:underlying_stub_registry) { instance_double(HttpStub::Server::Registry) }
+  let(:stubs_in_memory) { (1..3).map { instance_double(HttpStub::Server::Stub::Stub) } }
+  let(:memory_session)  { instance_double(HttpStub::Server::Session::Session, stubs: stubs_in_memory) }
 
-  let(:logger) { instance_double(Logger) }
+  let(:underlying_stub_registry) { instance_double(HttpStub::Server::Registry) }
+  let(:logger)                   { instance_double(Logger) }
 
-  let(:stub_registry) { HttpStub::Server::Stub::Registry.new }
+  let(:stub_registry) { described_class.new(memory_session) }
 
   before(:example) { allow(HttpStub::Server::Registry).to receive(:new).and_return(underlying_stub_registry) }
 
+  it "uses an underlying simple registry that is initialised with the memory sessions stubs" do
+    expect(HttpStub::Server::Registry).to receive(:new).with("stub", stubs_in_memory)
+
+    stub_registry
+  end
+
   describe "#add" do
 
     let(:stub) { instance_double(HttpStub::Server::Stub::Stub) }
@@ -24,7 +32,7 @@ describe HttpStub::Server::Stub::Registry do
 
   describe "#concat" do
 
-    let(:stubs)  { (1..3).map { instance_double(HttpStub::Server::Stub::Stub) } }
+    let(:stubs) { (1..3).map { instance_double(HttpStub::Server::Stub::Stub) } }
 
     subject { stub_registry.concat(stubs, logger) }
 
@@ -40,58 +48,42 @@ describe HttpStub::Server::Stub::Registry do
 
     let(:id) { SecureRandom.uuid }
 
+    let(:found_stub) { instance_double(HttpStub::Server::Stub::Stub) }
+
     subject { stub_registry.find(id, logger) }
 
+    before(:example) { allow(underlying_stub_registry).to receive(:find).and_return(found_stub) }
+
     it "delegates to an underlying simple registry" do
       expect(underlying_stub_registry).to receive(:find).with(id, logger)
 
       subject
     end
 
+    it "returns any found stub" do
+      expect(subject).to eql(found_stub)
+    end
+
   end
 
   describe "#match" do
 
-    let(:request)  { HttpStub::Server::RequestFixture.create }
+    let(:request) { instance_double(HttpStub::Server::Request::Request) }
 
-    let(:triggers)     { instance_double(HttpStub::Server::Stub::Triggers, add_to: nil) }
-    let(:stub)         { instance_double(HttpStub::Server::Stub::Stub, triggers: triggers) }
-    let(:found_stub)   { nil }
+    let(:matched_stub) { instance_double(HttpStub::Server::Stub::Stub) }
 
-    subject { stub_registry.match(request, logger) }
+    subject { stub_registry.find(request, logger) }
 
-    before(:example) { allow(underlying_stub_registry).to receive(:find).and_return(found_stub) }
+    before(:example) { allow(underlying_stub_registry).to receive(:find).and_return(matched_stub) }
 
-    it "finds a matching stub in the underlying simple registry based on the request" do
+    it "finds a matching stub in an underlying simple registry" do
       expect(underlying_stub_registry).to receive(:find).with(request, logger)
 
       subject
     end
 
-    context "when a stub is found" do
-
-      let(:found_stub) { stub }
-
-      it "adds the stubs triggers to the underlying stub registry" do
-        expect(triggers).to receive(:add_to).with(stub_registry, logger)
-
-        subject
-      end
-
-      it "returns the stub found in the underlying stub registry" do
-        expect(subject).to eql(stub)
-      end
-
-    end
-
-    context "when a stub is not found" do
-
-      let(:found_stub) { nil }
-
-      it "returns nil" do
-        expect(subject).to eql(nil)
-      end
-
+    it "returns any found stub" do
+      expect(subject).to eql(matched_stub)
     end
 
   end
@@ -102,6 +94,8 @@ describe HttpStub::Server::Stub::Registry do
 
     subject { stub_registry.all }
 
+    before(:example) { allow(underlying_stub_registry).to receive(:all).and_return(stubs) }
+
     it "delegates to an underlying simple registry" do
       expect(underlying_stub_registry).to receive(:all)
 
@@ -109,42 +103,27 @@ describe HttpStub::Server::Stub::Registry do
     end
 
     it "returns the result from the underlying registry" do
-      allow(underlying_stub_registry).to receive(:all).and_return(stubs)
-
       expect(subject).to eql(stubs)
     end
 
   end
 
-  describe "#recall" do
+  describe "#reset" do
 
-    subject { stub_registry.recall }
+    subject { stub_registry.reset(logger) }
 
-    context "when the state of the registry has been remembered" do
+    before(:example) { allow(underlying_stub_registry).to receive(:replace) }
 
-      let(:last_stub_remembered) { instance_double(HttpStub::Server::Stub::Stub) }
-
-      before(:example) do
-        allow(underlying_stub_registry).to receive(:last).and_return(last_stub_remembered)
-        stub_registry.remember
-      end
-
-      it "causes the underlying registry to rollback to the last stub added before the state was remembered" do
-        expect(underlying_stub_registry).to receive(:rollback_to).with(last_stub_remembered)
-
-        subject
-      end
+    it "retrieves the stubs in the memory session" do
+      expect(memory_session).to receive(:stubs)
 
+      subject
     end
 
-    context "when the state of the registry has not been remembered" do
-
-      it "does not rollback the underlying registry" do
-        expect(underlying_stub_registry).to_not receive(:rollback_to)
-
-        subject
-      end
+    it "replaces the stubs in the underlying registry with those in the memory session" do
+      expect(underlying_stub_registry).to receive(:replace).with(stubs_in_memory, logger)
 
+      subject
     end
 
   end

data/spec/lib/http_stub/server/stub/triggers_spec.rb

@@ -1,79 +1,138 @@
 describe HttpStub::Server::Stub::Triggers do
 
-  let(:trigger_bodies)     { (1..3).map { |i| "trigger body #{i}" } }
-  let(:stubs_for_triggers) { (1..trigger_bodies.length).map { instance_double(HttpStub::Server::Stub::Stub) } }
-  let(:stub_triggers)      { HttpStub::Server::Stub::Triggers.new(trigger_bodies) }
+  let(:scenario_names) { (1..3).map { |i| "Scenario trigger #{i}" } }
+  let(:stub_payloads)  { (1..3).map { |i| "Stub trigger payload #{i}" } }
+  let(:args)           { { "scenario_names" => scenario_names, "stubs" => stub_payloads } }
 
-  before(:example) { allow(HttpStub::Server::Stub).to receive(:create).and_return(*stubs_for_triggers) }
+  let(:stubs) { (1..stub_payloads.length).map { instance_double(HttpStub::Server::Stub::Stub) } }
+
+  let(:triggers) { described_class.new(args) }
+
+  before(:example) { allow(HttpStub::Server::Stub).to receive(:create).and_return(*stubs) }
+
+  describe "::EMPTY" do
+
+    subject { HttpStub::Server::Stub::Triggers::EMPTY }
+
+    it "returns triggers with empty scenario names" do
+      expect(subject.scenario_names).to eql([])
+    end
+
+    it "returns triggers with empty stubs" do
+      expect(subject.stubs).to eql([])
+    end
+
+  end
 
   describe "constructor" do
 
-    it "creates a stub for each provided trigger" do
-      trigger_bodies.zip(stubs_for_triggers).each do |body, stub|
-        expect(HttpStub::Server::Stub).to receive(:create).with(body).and_return(stub)
+    subject { described_class.new(args) }
+
+    context "when scenario names are provided" do
+
+      let(:args) { { "scenario_names" => scenario_names } }
+
+      it "establishes the scenario names" do
+        expect(subject.scenario_names).to eql(scenario_names)
       end
 
-      stub_triggers
     end
 
-  end
+    context "when scenario names are not provided" do
 
-  describe "#add_to" do
+      let(:args) { {} }
 
-    let(:registry) { instance_double(HttpStub::Server::Stub::Registry) }
-    let(:logger)   { instance_double(Logger) }
+      it "establishes an empty scenario name array" do
+        expect(subject.scenario_names).to eql([])
+      end
+
+    end
 
-    it "adds each stub to the provided registry" do
-      stubs_for_triggers.each { |stub_for_trigger| expect(registry).to receive(:add).with(stub_for_trigger, logger) }
+    context "when stubs are provided" do
+
+      let(:args) { { "stubs" => stub_payloads } }
+
+      it "creates a stub for each provided stub payload" do
+        stub_payloads.each { |payload| expect(HttpStub::Server::Stub).to receive(:create).with(payload) }
+
+        subject
+      end
+
+      it "estalishes the created stubs" do
+        expect(subject.stubs).to eql(stubs)
+      end
 
-      stub_triggers.add_to(registry, logger)
     end
 
-  end
+    context "when stubs are not provided" do
+
+      let(:args) { {} }
 
-  describe "#each" do
+      it "establishes an empty stub array" do
+        expect(subject.stubs).to eql([])
+      end
+
+    end
 
-    it "yields to the stubs for each trigger" do
-      yielded_stubs = stub_triggers.each.map.to_a
+    context "when nil args are provided" do
+
+      let(:args) { nil }
+
+      it "establishes an empty scenario name array" do
+        expect(subject.scenario_names).to eql([])
+      end
+
+      it "establishes an empty stub array" do
+        expect(subject.stubs).to eql([])
+      end
 
-      expect(yielded_stubs).to eql(stubs_for_triggers)
     end
 
   end
 
   describe "#to_json" do
 
-    let(:json_for_stubs)        { (1..stubs_for_triggers.length).map { |i| "stub #{i} json" } }
+    let(:json_for_stubs)        { stubs.each_with_index.map { |i| "stub #{i} JSON" } }
     let(:quoted_json_for_stubs) { json_for_stubs.map(&:to_json) }
 
-    subject { stub_triggers.to_json }
+    subject { triggers.to_json }
 
     before(:example) do
-      stubs_for_triggers.zip(quoted_json_for_stubs).each do |stub, json|
-        allow(stub).to receive(:to_json).and_return(json)
-      end
+      stubs.zip(quoted_json_for_stubs).each { |stub, json| allow(stub).to receive(:to_json).and_return(json) }
+    end
+
+    it "contains the scenario names" do
+      expect(subject).to include_in_json(scenario_names: scenario_names)
     end
 
-    it "returns a JSON array containing the JSON representation of each stub" do
-      expect(subject).to eql(json_for_stubs.to_json)
+    it "contains the JSON representation of each stub" do
+      expect(subject).to include_in_json(stubs: json_for_stubs)
     end
 
   end
 
   describe "#to_s" do
 
-    let(:trigger_strings) { (1..stubs_for_triggers.length).map { |i| "trigger string ##{i}" } }
+    subject { triggers.to_s }
 
-    before(:example) do
-      stubs_for_triggers.zip(trigger_strings).each do |stub_for_trigger, string|
-        allow(stub_for_trigger).to receive(:to_s).and_return(string)
+    context "when scenario names and stubs are provided" do
+
+      let(:args) { { "scenario_names" => scenario_names, "stubs" => stubs } }
+
+      it "returns a string representation of the arguments provided to the triggers" do
+        expect(subject).to eql(args.to_s)
       end
+
     end
 
-    it "should contain a string representation of each trigger" do
-      result = stub_triggers.to_s
+    context "when scenario names and stubs are not provided" do
+
+      let(:args) { {} }
+
+      it "returns a string indicating the scenario names and stub are empty" do
+        expect(subject).to eql({ "scenario_names" => [], "stubs" => [] }.to_s)
+      end
 
-      trigger_strings.each { |trigger_string| expect(result).to include(trigger_string) }
     end
 
   end