http_stub 0.13.5 → 0.14.0.rc1

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

@@ -0,0 +1,253 @@
+describe HttpStub::Configurer::Server::Facade do
+
+  let(:configurer)        { double(HttpStub::Configurer) }
+  let(:request_processor) { instance_double(HttpStub::Configurer::Server::RequestProcessor) }
+
+  let(:facade) { HttpStub::Configurer::Server::Facade.new(configurer) }
+
+  before(:example) do
+    allow(HttpStub::Configurer::Server::RequestProcessor).to receive(:new).and_return(request_processor)
+  end
+  
+  describe "constructor" do
+
+    it "creates a request processor with the provided configurer" do
+      expect(HttpStub::Configurer::Server::RequestProcessor).to receive(:new).with(configurer)
+      
+      facade
+    end
+
+  end
+
+  describe "#stub_response" do
+
+    let(:stub_uri) { "/some/stub/uri" }
+    let(:request)  { instance_double(HttpStub::Configurer::Request::Stub, stub_uri: stub_uri) }
+
+    subject { facade.stub_response(request) }
+
+    before(:example) { allow(request_processor).to receive(:submit) }
+
+    it "submits the stub request via the request processor" do
+      expect(request_processor).to receive(:submit).with(hash_including(request: request))
+
+      subject
+    end
+
+    it "describes the stub via its stub uri" do
+      expect(request_processor).to receive(:submit).with(hash_including(description: "stubbing '#{stub_uri}'"))
+
+      subject
+    end
+
+  end
+
+  describe "#stub_activator" do
+
+    let(:activation_uri) { "/some/activation/uri" }
+    let(:request) { instance_double(HttpStub::Configurer::Request::StubActivator, activation_uri: activation_uri) }
+
+    subject { facade.stub_activator(request) }
+
+    before(:example) { allow(request_processor).to receive(:submit) }
+
+    it "submits the stub request via the request processor" do
+      expect(request_processor).to receive(:submit).with(hash_including(request: request))
+
+      subject
+    end
+
+    it "describes the stub via its activation uri" do
+      expect(request_processor).to(
+        receive(:submit).with(hash_including(description: "registering activator '#{activation_uri}'"))
+      )
+
+      subject
+    end
+
+  end
+
+  describe "#activate" do
+
+    let(:uri)     { "/some/activation/uri" }
+    let(:request) { instance_double(Net::HTTP::Get) }
+
+    subject { facade.activate(uri) }
+
+    before(:example) do
+      allow(Net::HTTP::Get).to receive(:new).and_return(request)
+      allow(request_processor).to receive(:submit)
+    end
+
+    it "creates a GET request for the uri" do
+      expect(Net::HTTP::Get).to receive(:new).with(uri).and_return(request)
+
+      subject
+    end
+
+    it "submits the GET request via the request processor" do
+      expect(request_processor).to receive(:submit).with(hash_including(request: request))
+
+      subject
+    end
+
+    it "describes the activation request via the provided uri" do
+      expect(request_processor).to receive(:submit).with(hash_including(description: "activating '#{uri}'"))
+
+      subject
+    end
+
+  end
+
+  describe "#remember_stubs" do
+
+    let(:request) { instance_double(Net::HTTP::Post) }
+
+    subject { facade.remember_stubs }
+
+    before(:example) do
+      allow(Net::HTTP::Post).to receive(:new).and_return(request)
+      allow(request).to receive(:body=)
+      allow(request_processor).to receive(:submit)
+    end
+
+    it "creates a POST request for /stubs/memory endpoint" do
+      expect(Net::HTTP::Post).to receive(:new).with("/stubs/memory").and_return(request)
+
+      subject
+    end
+
+    it "establishes an empty body on the POST request" do
+      expect(request).to receive(:body=).with("")
+
+      subject
+    end
+
+    it "submits the POST request via the request processor" do
+      expect(request_processor).to receive(:submit).with(hash_including(request: request))
+
+      subject
+    end
+
+    it "describes the request as committing the servers stubs to memory" do
+      expect(request_processor).to receive(:submit).with(hash_including(description: "committing stubs to memory"))
+
+      subject
+    end
+
+  end
+
+  describe "#recall_stubs" do
+
+    let(:request) { instance_double(Net::HTTP::Get) }
+
+    subject { facade.recall_stubs }
+
+    before(:example) do
+      allow(Net::HTTP::Get).to receive(:new).and_return(request)
+      allow(request_processor).to receive(:submit)
+    end
+
+    it "creates a POST request for /stubs/memory endpoint" do
+      expect(Net::HTTP::Get).to receive(:new).with("/stubs/memory").and_return(request)
+
+      subject
+    end
+
+    it "submits the GET request via the request processor" do
+      expect(request_processor).to receive(:submit).with(hash_including(request: request))
+
+      subject
+    end
+
+    it "describes the request as recalling the servers stubs in memory" do
+      expect(request_processor).to receive(:submit).with(hash_including(description: "recalling stubs in memory"))
+
+      subject
+    end
+
+  end
+
+  describe "#clear_stubs" do
+
+    let(:request) { instance_double(Net::HTTP::Delete) }
+
+    subject { facade.clear_stubs }
+
+    before(:example) do
+      allow(Net::HTTP::Delete).to receive(:new).and_return(request)
+      allow(request_processor).to receive(:submit)
+    end
+
+    it "creates a DELETE request for the /stubs endpoint" do
+      expect(Net::HTTP::Delete).to receive(:new).with("/stubs").and_return(request)
+
+      subject
+    end
+
+    it "adds the DELETE request to the server state" do
+      expect(request_processor).to receive(:submit).with(hash_including(request: request))
+
+      subject
+    end
+
+    it "describes the request as clearing the server stubs" do
+      expect(request_processor).to receive(:submit).with(hash_including(description: "clearing stubs"))
+
+      subject
+    end
+
+  end
+
+  describe "#clear_activators" do
+
+    let(:request) { instance_double(Net::HTTP::Delete) }
+
+    subject { facade.clear_activators }
+
+    before(:example) do
+      allow(Net::HTTP::Delete).to receive(:new).and_return(request)
+      allow(request_processor).to receive(:submit)
+    end
+
+    it "creates a DELETE request for the /stubs/activators endpoint" do
+      expect(Net::HTTP::Delete).to receive(:new).with("/stubs/activators").and_return(request)
+
+      subject
+    end
+
+    it "adds the DELETE request to the server state" do
+      expect(request_processor).to receive(:submit).with(hash_including(request: request))
+
+      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"))
+
+      subject
+    end
+
+  end
+
+  describe "#server_has_started" do
+
+    it "informs the request processor to disable buffering requests" do
+      expect(request_processor).to receive(:disable_buffering!)
+
+      facade.server_has_started
+    end
+
+  end
+
+  describe "#flush_requests" do
+
+    it "informs the request processor to flush it's requests" do
+      expect(request_processor).to receive(:flush!)
+
+      facade.flush_requests
+    end
+
+  end
+
+end

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

@@ -0,0 +1,99 @@
+describe HttpStub::Configurer::Server::RequestProcessor do
+
+  let(:configurer)        { double(HttpStub::Configurer) }
+  let(:command_processor) { instance_double(HttpStub::Configurer::Server::CommandProcessor) }
+  let(:buffered_command_processor)  { instance_double(HttpStub::Configurer::Server::BufferedCommandProcessor) }
+
+  let(:request_processor)     { HttpStub::Configurer::Server::RequestProcessor.new(configurer) }
+
+  before(:example) do
+    allow(HttpStub::Configurer::Server::CommandProcessor).to receive(:new).and_return(command_processor)
+    allow(HttpStub::Configurer::Server::BufferedCommandProcessor).to(
+      receive(:new).and_return(buffered_command_processor)
+    )
+  end
+
+  describe "constructor" do
+
+    it "creates a command processor for the configurer" do
+      expect(HttpStub::Configurer::Server::CommandProcessor).to receive(:new).with(configurer)
+
+      request_processor
+    end
+    
+    it "creates a buffered command processor that flushes via the command processor" do
+      expect(HttpStub::Configurer::Server::BufferedCommandProcessor).to receive(:new).with(command_processor)
+
+      request_processor
+    end
+
+  end
+
+  describe "#submit" do
+
+    let(:args) { { some_arg_key: "some arg value" } }
+
+    subject { request_processor.submit(args) }
+
+    shared_examples_for "submitting a request to the server" do |processor_description|
+
+      let(:command) { instance_double(HttpStub::Configurer::Server::Command) }
+
+      before(:each) { allow(active_command_processor).to receive(:process) }
+
+      it "creates a command for the provided arguments" do
+        expect(HttpStub::Configurer::Server::Command).to receive(:new).with(hash_including(args)).and_return(command)
+
+        subject
+      end
+
+      it "processes the command via the #{processor_description}" do
+        allow(HttpStub::Configurer::Server::Command).to receive(:new).and_return(command)
+        expect(active_command_processor).to receive(:process).with(command)
+
+        subject
+      end
+
+    end
+
+    context "when request buffering is enabled" do
+
+      let(:active_command_processor) { buffered_command_processor }
+
+      it_behaves_like "submitting a request to the server", "buffered command processor"
+
+    end
+
+    context "when request buffering is disabled" do
+
+      let(:active_command_processor) { command_processor }
+
+      before(:example) { request_processor.disable_buffering! }
+
+      it_behaves_like "submitting a request to the server", "command processor"
+
+    end
+
+  end
+
+  describe "#flush!" do
+
+    subject { request_processor.flush! }
+
+    before(:example) { allow(buffered_command_processor).to receive(:flush) }
+
+    it "delegates to the buffered command processor" do
+      expect(buffered_command_processor).to receive(:flush)
+
+      subject
+    end
+
+    it "disables request buffering" do
+      expect(request_processor).to receive(:disable_buffering!)
+
+      subject
+    end
+
+  end
+
+end

data/spec/lib/http_stub/configurer_integration_spec.rb

@@ -1,16 +1,17 @@
 describe HttpStub::Configurer, "when the server is running" do
   include_context "server integration"
 
-  let(:configurer) { HttpStub::Examples::ConfigurerWithClassActivator.new }
+  let(:configurer)  { HttpStub::Examples::ConfigurerWithClassActivator.new }
+  let(:stub_server) { configurer.stub_server }
 
-  after(:each) do
+  after(:example) do
     configurer.clear_stubs!
     configurer.class.clear_activators!
   end
 
   context "and the configurer is initialized" do
 
-    before(:each) do
+    before(:example) do
       configurer.class.host(server_host)
       configurer.class.port(server_port)
       configurer.class.initialize!
@@ -18,15 +19,15 @@ describe HttpStub::Configurer, "when the server is running" do
 
     context "and a stub is activated" do
 
-      before(:each) { configurer.activate!("/an_activator") }
+      before(:example) { configurer.activate!("/an_activator") }
 
       context "and the stub request is made" do
 
         let(:response) { Net::HTTP.get_response(server_host, "/stub_path", server_port) }
 
-        it "should replay the stubbed response" do
-          response.code.should eql("200")
-          response.body.should eql("Stub activator body")
+        it "replays the stubbed response" do
+          expect(response.code).to eql("200")
+          expect(response.body).to eql("Stub activator body")
         end
 
       end
@@ -39,8 +40,8 @@ describe HttpStub::Configurer, "when the server is running" do
 
         let(:response) { Net::HTTP.get_response(server_host, "/stub_path", server_port) }
 
-        it "should respond with a 404 status code" do
-          response.code.should eql("404")
+        it "responds with a 404 status code" do
+          expect(response.code).to eql("404")
         end
 
       end
@@ -51,28 +52,28 @@ describe HttpStub::Configurer, "when the server is running" do
 
       let(:configurer) { HttpStub::Examples::ConfigurerWithClassStub.new }
 
-      it "should register the stub" do
+      it "registers the stub" do
         response = Net::HTTP.get_response(server_host, "/a_class_stub", server_port)
 
-        response.code.should eql("201")
-        response.body.should eql("Class stub body")
+        expect(response.code).to eql("201")
+        expect(response.body).to eql("Class stub body")
       end
 
       context "and the stub is overridden" do
 
-        before(:each) do
+        before(:example) do
           configurer.stub_response!("/a_class_stub", method: :get, response: { body: "Other class stub body" })
         end
 
         context "and the configurer is re-initialized" do
 
-          before(:each) { configurer.class.initialize! }
+          before(:example) { configurer.class.initialize! }
 
-          it "should re-establish the class stub as having priority" do
+          it "re-establishes the class stub as having priority" do
             response = Net::HTTP.get_response(server_host, "/a_class_stub", server_port)
 
-            response.code.should eql("201")
-            response.body.should eql("Class stub body")
+            expect(response.code).to eql("201")
+            expect(response.body).to eql("Class stub body")
           end
 
         end
@@ -85,48 +86,48 @@ describe HttpStub::Configurer, "when the server is running" do
 
       let(:configurer) { HttpStub::Examples::ConfigurerWithComplexInitializer.new }
 
-      it "should register the activated activator" do
+      it "registers the activated activator" do
         response = Net::HTTP.get_response(server_host, "/activated_during_initialization_stub_path", server_port)
 
-        response.code.should eql("200")
-        response.body.should eql("Activated during initialization body")
+        expect(response.code).to eql("200")
+        expect(response.body).to eql("Activated during initialization body")
       end
 
-      it "should register the stub" do
+      it "registers the stub" do
         response = Net::HTTP.get_response(server_host, "/stubbed_during_initialization_path", server_port)
 
-        response.code.should eql("200")
-        response.body.should eql("Stubbed during initialization body")
+        expect(response.code).to eql("200")
+        expect(response.body).to eql("Stubbed during initialization body")
       end
 
       context "and another stub is registered" do
 
-        before(:each) do
+        before(:example) do
           configurer.stub_response!("/another_stub", method: :get, response: { body: "Another stub body" })
         end
 
-        context "and the configurer is reset" do
+        context "and the servers remembered stubs are recalled" do
 
-          before(:each) { configurer.reset! }
+          before(:example) { configurer.recall_stubs! }
 
-          it "should remove the stub registered post-initialization" do
+          it "removes the stub registered post-initialization" do
             response = Net::HTTP.get_response(server_host, "/another_stub", server_port)
 
-            response.code.should eql("404")
+            expect(response.code).to eql("404")
           end
 
-          it "should retain the activated activator during initialization" do
+          it "retains the activated activator during initialization" do
             response = Net::HTTP.get_response(server_host, "/activated_during_initialization_stub_path", server_port)
 
-            response.code.should eql("200")
-            response.body.should eql("Activated during initialization body")
+            expect(response.code).to eql("200")
+            expect(response.body).to eql("Activated during initialization body")
           end
 
-          it "should retain the stub registered during initialization" do
+          it "retains the stub registered during initialization" do
             response = Net::HTTP.get_response(server_host, "/stubbed_during_initialization_path", server_port)
 
-            response.code.should eql("200")
-            response.body.should eql("Stubbed during initialization body")
+            expect(response.code).to eql("200")
+            expect(response.body).to eql("Stubbed during initialization body")
           end
 
         end
@@ -135,13 +136,13 @@ describe HttpStub::Configurer, "when the server is running" do
 
     end
 
-    context "and a response for a request is stubbed" do
+    context "and a stub is submitted" do
 
       context "that contains no headers or parameters" do
 
         context "and contains a response status" do
 
-          before(:each) do
+          before(:example) do
             configurer.stub_response!("/stub_with_status", method: :get, response: { status: 201, body: "Stub body" })
           end
 
@@ -149,26 +150,26 @@ describe HttpStub::Configurer, "when the server is running" do
 
             let(:response) { Net::HTTP.get_response(server_host, "/stub_with_status", server_port) }
 
-            it "should respond with the stubbed status" do
-              response.code.should eql("201")
+            it "responds with the stubbed status" do
+              expect(response.code).to eql("201")
             end
 
-            it "should replay the stubbed body" do
-              response.body.should eql("Stub body")
+            it "replays the stubbed body" do
+              expect(response.body).to eql("Stub body")
             end
 
           end
 
-          context "and the stub is cleared" do
+          context "and stubs are cleared" do
 
-            before(:each) { configurer.clear! }
+            before(:example) { configurer.clear_stubs! }
 
             context "and the original request is made" do
 
               let(:response) { Net::HTTP.get_response(server_host, "/stub_with_status", server_port) }
 
-              it "should respond with a 404 status code" do
-                response.code.should eql("404")
+              it "responds with a 404 status code" do
+                expect(response.code).to eql("404")
               end
 
             end
@@ -179,7 +180,7 @@ describe HttpStub::Configurer, "when the server is running" do
 
         context "and does not contain a response status" do
 
-          before(:each) do
+          before(:example) do
             configurer.stub_response!("/stub_without_status", method: :get, response: { body: "Stub body" })
           end
 
@@ -187,15 +188,15 @@ describe HttpStub::Configurer, "when the server is running" do
 
             let(:response) { Net::HTTP.get_response(server_host, "/stub_without_status", server_port) }
 
-            it "should respond with the stubbed body" do
-              response.body.should eql("Stub body")
+            it "responds with the stubbed body" do
+              expect(response.body).to eql("Stub body")
             end
 
           end
 
           context "and the stub uri is regular expression containing meta characters" do
 
-            before(:each) do
+            before(:example) do
               configurer.stub_response!(/\/stub\/regexp\/\$key=value/, method: :get, response: { body: "Stub body" })
             end
 
@@ -203,8 +204,8 @@ describe HttpStub::Configurer, "when the server is running" do
 
               let(:response) { Net::HTTP.get_response(server_host, "/match/stub/regexp/$key=value", server_port) }
 
-              it "should respond with the stubbed body" do
-                response.body.should eql("Stub body")
+              it "responds with the stubbed body" do
+                expect(response.body).to eql("Stub body")
               end
 
             end
@@ -213,8 +214,8 @@ describe HttpStub::Configurer, "when the server is running" do
 
               let(:response) { Net::HTTP.get_response(server_host, "/stub/no_match/regexp", server_port) }
 
-              it "should respond with a 404 status code" do
-                response.code.should eql("404")
+              it "responds with a 404 status code" do
+                expect(response.code).to eql("404")
               end
 
             end
@@ -230,7 +231,7 @@ describe HttpStub::Configurer, "when the server is running" do
 
         context "whose values are strings" do
 
-          before(:each) do
+          before(:example) do
             configurer.stub_response!(
               "/stub_with_headers", method: :get, headers: { key: "value" },
               response: { status: 202, body: "Another stub body" }
@@ -241,9 +242,9 @@ describe HttpStub::Configurer, "when the server is running" do
 
             let(:response) { HTTParty.get("#{server_uri}/stub_with_headers", headers: { "key" => "value" }) }
 
-            it "should replay the stubbed response" do
-              response.code.should eql(202)
-              response.body.should eql("Another stub body")
+            it "replays the stubbed response" do
+              expect(response.code).to eql(202)
+              expect(response.body).to eql("Another stub body")
             end
 
           end
@@ -252,8 +253,8 @@ describe HttpStub::Configurer, "when the server is running" do
 
             let(:response) { HTTParty.get("#{server_uri}/stub_with_headers", headers: { "key" => "other_value" }) }
 
-            it "should respond with a 404 status code" do
-              response.code.should eql(404)
+            it "responds with a 404 status code" do
+              expect(response.code).to eql(404)
             end
 
           end
@@ -262,7 +263,7 @@ describe HttpStub::Configurer, "when the server is running" do
 
         context "whose values are regular expressions" do
 
-          before(:each) do
+          before(:example) do
             configurer.stub_response!(
               "/stub_with_headers", method: :get, headers: { key: /^match.*/ },
               response: { status: 202, body: "Another stub body" }
@@ -275,9 +276,9 @@ describe HttpStub::Configurer, "when the server is running" do
               HTTParty.get("#{server_uri}/stub_with_headers", headers: { "key" => "matching_value" })
             end
 
-            it "should replay the stubbed response" do
-              response.code.should eql(202)
-              response.body.should eql("Another stub body")
+            it "replays the stubbed response" do
+              expect(response.code).to eql(202)
+              expect(response.body).to eql("Another stub body")
             end
 
           end
@@ -288,8 +289,8 @@ describe HttpStub::Configurer, "when the server is running" do
               HTTParty.get("#{server_uri}/stub_with_headers", headers: { "key" => "does_not_match_value" })
             end
 
-            it "should respond with a 404 status code" do
-              response.code.should eql(404)
+            it "responds with a 404 status code" do
+              expect(response.code).to eql(404)
             end
 
           end
@@ -302,7 +303,7 @@ describe HttpStub::Configurer, "when the server is running" do
 
         context "whose values are strings" do
 
-          before(:each) do
+          before(:example) do
             configurer.stub_response!("/stub_with_parameters", method: :get, parameters: { key: "value" },
                                       response: { status: 202, body: "Another stub body" })
           end
@@ -311,9 +312,9 @@ describe HttpStub::Configurer, "when the server is running" do
 
             let(:response) { Net::HTTP.get_response(server_host, "/stub_with_parameters?key=value", server_port) }
 
-            it "should replay the stubbed response" do
-              response.code.should eql("202")
-              response.body.should eql("Another stub body")
+            it "replays the stubbed response" do
+              expect(response.code).to eql("202")
+              expect(response.body).to eql("Another stub body")
             end
 
           end
@@ -324,8 +325,8 @@ describe HttpStub::Configurer, "when the server is running" do
               Net::HTTP.get_response(server_host, "/stub_with_parameters?key=another_value", server_port)
             end
 
-            it "should respond with a 404 status code" do
-              response.code.should eql("404")
+            it "responds with a 404 status code" do
+              expect(response.code).to eql("404")
             end
 
           end
@@ -334,7 +335,7 @@ describe HttpStub::Configurer, "when the server is running" do
 
         context "whose values are regular expressions" do
 
-          before(:each) do
+          before(:example) do
             configurer.stub_response!(
               "/stub_with_parameters", method: :get, parameters: { key: /^match.*/ },
               response: { status: 202, body: "Another stub body" }
@@ -347,9 +348,9 @@ describe HttpStub::Configurer, "when the server is running" do
               Net::HTTP.get_response(server_host, "/stub_with_parameters?key=matching_value", server_port)
             end
 
-            it "should replay the stubbed response" do
-              response.code.should eql("202")
-              response.body.should eql("Another stub body")
+            it "replays the stubbed response" do
+              expect(response.code).to eql("202")
+              expect(response.body).to eql("Another stub body")
             end
 
           end
@@ -360,8 +361,8 @@ describe HttpStub::Configurer, "when the server is running" do
               Net::HTTP.get_response(server_host, "/stub_with_parameters?key=does_not_match_value", server_port)
             end
 
-            it "should respond with a 404 status code" do
-              response.code.should eql("404")
+            it "responds with a 404 status code" do
+              expect(response.code).to eql("404")
             end
 
           end
@@ -370,7 +371,7 @@ describe HttpStub::Configurer, "when the server is running" do
 
         context "whose values indicate the parameters must be omitted" do
 
-          before(:each) do
+          before(:example) do
             configurer.stub_response!(
               "/stub_with_omitted_parameters", method: :get, parameters: { key: :omitted },
               response: { status: 202, body: "Omitted parameter stub body" }
@@ -381,9 +382,9 @@ describe HttpStub::Configurer, "when the server is running" do
 
             let(:response) { Net::HTTP.get_response(server_host, "/stub_with_omitted_parameters", server_port) }
 
-            it "should replay the stubbed response" do
-              response.code.should eql("202")
-              response.body.should eql("Omitted parameter stub body")
+            it "replays the stubbed response" do
+              expect(response.code).to eql("202")
+              expect(response.body).to eql("Omitted parameter stub body")
             end
 
           end
@@ -394,8 +395,8 @@ describe HttpStub::Configurer, "when the server is running" do
               Net::HTTP.get_response(server_host, "/stub_with_omitted_parameters?key=must_be_omitted", server_port)
             end
 
-            it "should respond with a 404 status code" do
-              response.code.should eql("404")
+            it "responds with a 404 status code" do
+              expect(response.code).to eql("404")
             end
 
           end
@@ -404,7 +405,7 @@ describe HttpStub::Configurer, "when the server is running" do
 
         context "whose values are numbers" do
 
-          before(:each) do
+          before(:example) do
             configurer.stub_response!("/stub_with_parameters", method: :get, parameters: { key: 88 },
                                       response: { status: 203, body: "Body for parameter number" })
           end
@@ -413,9 +414,9 @@ describe HttpStub::Configurer, "when the server is running" do
 
             let(:response) { Net::HTTP.get_response(server_host, "/stub_with_parameters?key=88", server_port) }
 
-            it "should replay the stubbed response" do
-              response.code.should eql("203")
-              response.body.should eql("Body for parameter number")
+            it "replays the stubbed response" do
+              expect(response.code).to eql("203")
+              expect(response.body).to eql("Body for parameter number")
             end
 
           end
@@ -424,7 +425,7 @@ describe HttpStub::Configurer, "when the server is running" do
 
         context "whose values are regular expressions" do
 
-          before(:each) do
+          before(:example) do
             configurer.stub_response!(
               "/stub_with_parameters", method: :get, parameters: { key: /^match.*/ },
               response: { status: 202, body: "Another stub body" }
@@ -437,9 +438,9 @@ describe HttpStub::Configurer, "when the server is running" do
               Net::HTTP.get_response(server_host, "/stub_with_parameters?key=matching_value", server_port)
             end
 
-            it "should replay the stubbed response" do
-              response.code.should eql("202")
-              response.body.should eql("Another stub body")
+            it "replays the stubbed response" do
+              expect(response.code).to eql("202")
+              expect(response.body).to eql("Another stub body")
             end
 
           end
@@ -450,8 +451,8 @@ describe HttpStub::Configurer, "when the server is running" do
               Net::HTTP.get_response(server_host, "/stub_with_parameters?key=does_not_match_value", server_port)
             end
 
-            it "should respond with a 404 status code" do
-              response.code.should eql("404")
+            it "responds with a 404 status code" do
+              expect(response.code).to eql("404")
             end
 
           end
@@ -460,7 +461,7 @@ describe HttpStub::Configurer, "when the server is running" do
 
         context "whose values indicate the parameters must be omitted" do
 
-          before(:each) do
+          before(:example) do
             configurer.stub_response!(
               "/stub_with_omitted_parameters", method: :get, parameters: { key: :omitted },
               response: { status: 202, body: "Omitted parameter stub body" }
@@ -471,9 +472,9 @@ describe HttpStub::Configurer, "when the server is running" do
 
             let(:response) { Net::HTTP.get_response(server_host, "/stub_with_omitted_parameters", server_port) }
 
-            it "should replay the stubbed response" do
-              response.code.should eql("202")
-              response.body.should eql("Omitted parameter stub body")
+            it "replays the stubbed response" do
+              expect(response.code).to eql("202")
+              expect(response.body).to eql("Omitted parameter stub body")
             end
 
           end
@@ -484,8 +485,57 @@ describe HttpStub::Configurer, "when the server is running" do
               Net::HTTP.get_response(server_host, "/stub_with_omitted_parameters?key=must_be_omitted", server_port)
             end
 
-            it "should respond with a 404 status code" do
-              response.code.should eql("404")
+            it "responds with a 404 status code" do
+              expect(response.code).to eql("404")
+            end
+
+          end
+
+        end
+
+      end
+
+      context "that contains triggers" do
+
+        let(:triggers) do
+          (1..3).map do |trigger_number|
+            stub_server.build_stub do |stub|
+              stub.match_request("/triggered_stub_#{trigger_number}", method: :get)
+              stub.with_response(status: 200 + trigger_number, body: "Triggered stub body #{trigger_number}")
+            end
+          end
+        end
+
+        before(:example) do
+          stub_server.add_stub! do |stub|
+            stub.match_request("/stub_with_triggers", method: :get)
+            stub.with_response(body: "Trigger stub body")
+            triggers.each { |trigger| stub.and_add_stub(trigger) }
+          end
+        end
+
+        context "and a request is made matching the stub" do
+
+          before(:example) do
+            @stub_with_triggers_response = Net::HTTP.get_response(server_host, "/stub_with_triggers", server_port)
+          end
+
+          it "replays the stubbed response" do
+            expect(@stub_with_triggers_response.code).to eql("200")
+            expect(@stub_with_triggers_response.body).to eql("Trigger stub body")
+          end
+
+          (1..3).each do |trigger_number|
+
+            context "and then a request matching triggered stub ##{trigger_number} is made" do
+
+              let(:response) { Net::HTTP.get_response(server_host, "/triggered_stub_#{trigger_number}", server_port) }
+
+              it "replays the triggered response" do
+                expect(response.code).to eql("20#{trigger_number}")
+                expect(response.body).to eql("Triggered stub body #{trigger_number}")
+              end
+
             end
 
           end
@@ -500,11 +550,11 @@ describe HttpStub::Configurer, "when the server is running" do
 
       let(:configurer) { HttpStub::Examples::ConfigurerWithInitializeCallback.new }
 
-      it "should execute the callback" do
+      it "executes the callback" do
         response = Net::HTTP.get_response(server_host, "/stubbed_on_initialize_path", server_port)
 
-        response.code.should eql("200")
-        response.body.should eql("Stubbed on initialize body")
+        expect(response.code).to eql("200")
+        expect(response.body).to eql("Stubbed on initialize body")
       end
 
     end
@@ -515,61 +565,61 @@ describe HttpStub::Configurer, "when the server is running" do
 
     context "and the configurer is informed that the server has started" do
 
-      before(:each) { configurer.server_has_started! }
+      before(:example) { configurer.server_has_started! }
 
-      it "should not initialize the configurer" do
+      it "does not initialize the configurer" do
         activation_lambda = lambda { configurer.activate!("/an_activator") }
 
-        activation_lambda.should raise_error(/error occurred activating '\/an_activator'/i)
+        expect(activation_lambda).to raise_error(/error occurred activating '\/an_activator'/i)
       end
 
       context "and an attempt is made to register a stub" do
 
-        before(:each) do
+        before(:example) do
           configurer.stub_response!("/some_stub_path", method: :get, response: { body: "Some stub body"})
         end
 
-        it "should register the stub" do
+        it "registers the stub" do
           response = Net::HTTP.get_response(server_host, "/some_stub_path", server_port)
 
-          response.code.should eql("200")
-          response.body.should eql("Some stub body")
+          expect(response.code).to eql("200")
+          expect(response.body).to eql("Some stub body")
         end
 
       end
 
       context "and an attempt is made to register a stub with a timeout" do
 
-        before(:each) do
+        before(:example) do
           configurer.stub_response!("/some_stub_path", method: :get, response: {:delay_in_seconds => 2})
         end
 
-        it "should delegate to request pipeline" do
+        it "delegates to request pipeline" do
           before = Time.new
 
           response = Net::HTTP.get_response(server_host, "/some_stub_path", server_port)
-          response.code.should eql("200")
+          expect(response.code).to eql("200")
 
           after = Time.now
 
-          (after - before).round().should be >= 2
+          expect((after - before).round()).to be >= 2
         end
 
       end
 
       describe "and an attempt is made to register a response with a content type header" do
 
-        before(:each) do
+        before(:example) do
           configurer.stub_response!(
             "/some_stub_path", method: :get, response: { body: "Some stub body",
                                                          headers: { "content-type" => "application/xhtml" } }
           )
         end
 
-        it "should register the stub" do
+        it "registers the stub" do
           response = Net::HTTP.get_response("localhost", "/some_stub_path", 8001)
 
-          response.content_type.should eql("application/xhtml")
+          expect(response.content_type).to eql("application/xhtml")
         end
 
       end
@@ -584,16 +634,16 @@ describe HttpStub::Configurer, "when the server is running" do
           }
         end
 
-        before(:each) do
+        before(:example) do
           configurer.stub_response!(
             "/some_stub_path", method: :get, response: { body: "Some stub body", headers: response_headers }
           )
         end
 
-        it "should register the stub" do
+        it "registers the stub" do
           response = Net::HTTP.get_response("localhost", "/some_stub_path", 8001)
 
-          response_headers.each { |key, value| response[key].should eql(value) }
+          response_headers.each { |key, value| expect(response[key]).to eql(value) }
         end
 
       end
@@ -604,10 +654,10 @@ describe HttpStub::Configurer, "when the server is running" do
 
       context "and an attempt is made to activate a stub" do
 
-        it "should raise an exception indicating an error occurred during activation" do
+        it "raises an exception indicating an error occurred during activation" do
           activation_lambda = lambda { configurer.activate!("/an_activator") }
 
-          activation_lambda.should raise_error(/error occurred activating '\/an_activator'/i)
+          expect(activation_lambda).to raise_error(/error occurred activating '\/an_activator'/i)
         end
 
       end
@@ -618,10 +668,10 @@ describe HttpStub::Configurer, "when the server is running" do
 
       let(:configurer) { HttpStub::Examples::ConfigurerWithInitializeCallback.new }
 
-      it "should not execute the callback" do
+      it "does not execute the callback" do
         response = Net::HTTP.get_response(server_host, "/stubbed_on_initialize_path", server_port)
 
-        response.code.should eql("404")
+        expect(response.code).to eql("404")
       end
 
     end