http_stub 0.14.2 → 0.15.0

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

@@ -0,0 +1,205 @@
+describe HttpStub::Server::Application do
+  include Rack::Test::Methods
+
+  let(:response)      { last_response }
+  let(:response_body) { response.body.to_s }
+
+  let(:stub_registry)           { instance_double(HttpStub::Server::StubRegistry).as_null_object }
+  let(:stub_activator_registry) { instance_double(HttpStub::Server::Registry).as_null_object }
+
+  let(:stub_controller)           { instance_double(HttpStub::Server::StubController).as_null_object }
+  let(:stub_activator_controller) { instance_double(HttpStub::Server::StubActivatorController).as_null_object }
+
+  let(:response_pipeline) { instance_double(HttpStub::Server::ResponsePipeline, process: nil) }
+
+  let(:app) { HttpStub::Server::Application.new! }
+
+  before(:example) do
+    allow(HttpStub::Server::StubRegistry).to receive(:new).and_return(stub_registry)
+    allow(HttpStub::Server::Registry).to receive(:new).with("stub_activator").and_return(stub_activator_registry)
+    allow(HttpStub::Server::StubController).to receive(:new).and_return(stub_controller)
+    allow(HttpStub::Server::StubActivatorController).to receive(:new).and_return(stub_activator_controller)
+    allow(HttpStub::Server::ResponsePipeline).to receive(:new).and_return(response_pipeline)
+  end
+
+  context "when a stub insertion request is received" do
+
+    let(:stub_controller_response) { instance_double(HttpStub::Server::StubResponse::Base) }
+
+    subject do
+      post "/stubs", { uri: "/a_path", method: "a method", response: { status: 200, body: "Foo" } }.to_json
+    end
+
+    before(:example) { allow(stub_controller).to receive(:register).and_return(stub_controller_response) }
+
+    it "registers the inserted stub via the controller" do
+      expect(stub_controller).to receive(:register).and_return(stub_controller_response)
+
+      subject
+    end
+
+    it "processes the stub controllers response via the response pipeline" do
+      expect(response_pipeline).to receive(:process).with(stub_controller_response)
+
+      subject
+    end
+
+  end
+
+  context "when a request to commit the stubs to memory is received" do
+
+    subject { post "/stubs/memory" }
+
+    it "remembers the stubs in the stub registry" do
+      expect(stub_registry).to receive(:remember)
+
+      subject
+    end
+
+    it "responds with a 200 status code" do
+      subject
+
+      expect(response.status).to eql(200)
+    end
+
+  end
+
+  context "when a request to recall the stubs in memory is received" do
+
+    subject { get "/stubs/memory" }
+
+    it "recalls the stubs remembered by the stub registry" do
+      expect(stub_registry).to receive(:recall)
+
+      subject
+    end
+
+    it "responds with a 200 status code" do
+      subject
+
+      expect(response.status).to eql(200)
+    end
+
+  end
+
+  context "when a request to clear the stubs has been received" do
+
+    subject { delete "/stubs" }
+
+    it "delegates clearing to the stub controller" do
+      expect(stub_controller).to receive(:clear)
+
+      subject
+    end
+
+    it "responds with a 200 status code" do
+      subject
+
+      expect(response.status).to eql(200)
+    end
+
+  end
+
+  context "when a stub activator insertion request is received" do
+
+    let(:stub_activator_response) { instance_double(HttpStub::Server::StubResponse::Base) }
+
+    before(:example) { allow(stub_activator_controller).to receive(:register).and_return(stub_activator_response) }
+
+    subject do
+      post "/stubs/activators", {
+        activation_uri: "/an_activation_path", uri: "/a_path", method: "a method",
+        response: { status: 200, body: "Foo" }
+      }.to_json
+    end
+
+    it "registers the insertion via the stub activator controller" do
+      expect(stub_activator_controller).to receive(:register).and_return(stub_activator_response)
+
+      subject
+    end
+
+    it "processes the stub activators response via the response pipeline" do
+      expect(response_pipeline).to receive(:process).with(stub_activator_response)
+
+      subject
+    end
+
+  end
+
+  context "when a request to clear the stub activators has been received" do
+
+    subject { delete "/stubs/activators" }
+
+    it "delegates clearing to the stub activator controller" do
+      expect(stub_activator_controller).to receive(:clear)
+
+      subject
+    end
+
+    it "responds with a 200 status code" do
+      subject
+
+      expect(response.status).to eql(200)
+    end
+
+  end
+
+  context "when another type of request is received" do
+
+    let(:stub_response) { instance_double(HttpStub::Server::StubResponse::Base) }
+
+    subject { get "/a_path" }
+
+    before(:example) { allow(stub_controller).to receive(:replay).and_return(stub_response) }
+
+    context "and the stub controller replays a response" do
+
+      before(:example) { allow(stub_response).to receive(:empty?).and_return(false) }
+
+      it "processes the response via the response pipeline" do
+        expect(response_pipeline).to receive(:process).with(stub_response)
+
+        subject
+      end
+
+    end
+
+    context "and the stub controller does not replay a response" do
+
+      let(:stub_activator_response) { double(HttpStub::Server::StubResponse::Base, serve_on: nil) }
+
+      before(:example) do
+        allow(stub_response).to receive(:empty?).and_return(true)
+        allow(stub_activator_controller).to receive(:activate).and_return(stub_activator_response)
+      end
+
+      context "but the stub activator controller activates a stub" do
+
+        before(:each) { allow(stub_activator_response).to receive(:empty?).and_return(false) }
+
+        it "processes the stub activator response via the response pipeline" do
+          expect(response_pipeline).to receive(:process).with(stub_activator_response)
+
+          subject
+        end
+
+      end
+
+      context "and the stub activator controller does not activate a stub" do
+
+        before(:each) { allow(stub_activator_response).to receive(:empty?).and_return(true) }
+
+        it "processes an error response via the response pipeline" do
+          expect(response_pipeline).to receive(:process).with(HttpStub::Server::Response::ERROR)
+
+          subject
+        end
+
+      end
+
+    end
+
+  end
+
+end

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

@@ -0,0 +1,7 @@
+describe HttpStub::Server::Daemon do
+
+  let(:server) { HttpStub::Server::Daemon.new(name: :example_server_daemon, port: 8002) }
+
+  it_should_behave_like "a managed http server"
+
+end

data/spec/lib/http_stub/{server_daemon_spec.rb → server/daemon_spec.rb}

@@ -1,8 +1,8 @@
-describe HttpStub::ServerDaemon do
+describe HttpStub::Server::Daemon do
 
   let(:configurer) { nil }
 
-  let(:server_daemon) { HttpStub::ServerDaemon.new(name: :sample_server_daemon, port: 8888, configurer: configurer) }
+  let(:server_daemon) { HttpStub::Server::Daemon.new(name: :sample_server_daemon, port: 8888, configurer: configurer) }
 
   before(:example) { allow(server_daemon.logger).to receive(:info) }
 
@@ -13,7 +13,7 @@ describe HttpStub::ServerDaemon do
     after(:example) { HttpServerManager.log_dir = @original_log_dir }
 
     it "establishes the HttpServerManager log_dir" do
-      HttpStub::ServerDaemon.log_dir = "/some/log/dir"
+      HttpStub::Server::Daemon.log_dir = "/some/log/dir"
 
       expect(HttpServerManager.log_dir).to eql("/some/log/dir")
     end
@@ -27,7 +27,7 @@ describe HttpStub::ServerDaemon do
     after(:example) { HttpServerManager.pid_dir = @original_pid_dir }
 
     it "establishes the HttpServerManager pid_dir" do
-      HttpStub::ServerDaemon.pid_dir = "/some/pid/dir"
+      HttpStub::Server::Daemon.pid_dir = "/some/pid/dir"
 
       expect(HttpServerManager.pid_dir).to eql("/some/pid/dir")
     end

data/spec/lib/http_stub/{models → server}/exact_value_matcher_spec.rb

@@ -1,4 +1,4 @@
-describe HttpStub::Models::ExactValueMatcher do
+describe HttpStub::Server::ExactValueMatcher do
 
   describe ".match?" do
 
@@ -25,7 +25,7 @@ describe HttpStub::Models::ExactValueMatcher do
     end
 
     def perform_match
-      HttpStub::Models::ExactValueMatcher.match?(stub_value, actual_value)
+      HttpStub::Server::ExactValueMatcher.match?(stub_value, actual_value)
     end
 
   end

data/spec/lib/http_stub/{models → server}/hash_with_string_value_matchers_spec.rb

@@ -1,4 +1,4 @@
-describe HttpStub::Models::HashWithStringValueMatchers do
+describe HttpStub::Server::HashWithStringValueMatchers do
 
   let(:stubbed_hash) do
     (1..3).reduce({}) do |result, i|
@@ -8,13 +8,13 @@ describe HttpStub::Models::HashWithStringValueMatchers do
   end
 
   let(:value_matchers) do
-    stubbed_hash.values.map { |value| double(HttpStub::Models::StringValueMatcher, to_s: value).as_null_object }
+    stubbed_hash.values.map { |value| double(HttpStub::Server::StringValueMatcher, to_s: value).as_null_object }
   end
 
-  let(:value_matcher_hash) { HttpStub::Models::HashWithStringValueMatchers.new(stubbed_hash) }
+  let(:value_matcher_hash) { HttpStub::Server::HashWithStringValueMatchers.new(stubbed_hash) }
 
   before(:example) do
-    value_matchers.each { |value| allow(HttpStub::Models::StringValueMatcher).to receive(:new).with(value.to_s).and_return(value) }
+    value_matchers.each { |value| allow(HttpStub::Server::StringValueMatcher).to receive(:new).with(value.to_s).and_return(value) }
   end
 
   it "is a hash" do
@@ -25,7 +25,7 @@ describe HttpStub::Models::HashWithStringValueMatchers do
 
     it "creates a value matcher representation of each value in the hash" do
       value_matchers.each do |value|
-        expect(HttpStub::Models::StringValueMatcher).to receive(:new).with(value.to_s).and_return(value)
+        expect(HttpStub::Server::StringValueMatcher).to receive(:new).with(value.to_s).and_return(value)
       end
 
       expect(value_matcher_hash.values).to eql(value_matchers)

data/spec/lib/http_stub/{models → server}/headers_spec.rb

@@ -1,8 +1,8 @@
-describe HttpStub::Models::Headers do
+describe HttpStub::Server::Headers do
 
   let(:header_hash) { {} }
 
-  let(:headers) { HttpStub::Models::Headers.new(header_hash) }
+  let(:headers) { HttpStub::Server::Headers.new(header_hash) }
 
   it "is a Hash" do
     expect(headers).to be_a(Hash)

data/spec/lib/http_stub/{models → server}/omitted_value_matcher_spec.rb

@@ -1,4 +1,4 @@
-describe HttpStub::Models::OmittedValueMatcher  do
+describe HttpStub::Server::OmittedValueMatcher  do
 
   describe ".match?" do
 
@@ -50,7 +50,7 @@ describe HttpStub::Models::OmittedValueMatcher  do
     end
 
     def perform_match
-      HttpStub::Models::OmittedValueMatcher.match?(stub_value, actual_value)
+      HttpStub::Server::OmittedValueMatcher.match?(stub_value, actual_value)
     end
 
   end

data/spec/lib/http_stub/{models → server}/regexp_value_matcher_spec.rb

@@ -1,4 +1,4 @@
-describe HttpStub::Models::RegexpValueMatcher do
+describe HttpStub::Server::RegexpValueMatcher do
 
   describe ".match?" do
 
@@ -40,7 +40,7 @@ describe HttpStub::Models::RegexpValueMatcher do
     end
     
     def perform_match
-      HttpStub::Models::RegexpValueMatcher.match?(stub_value, actual_value)
+      HttpStub::Server::RegexpValueMatcher.match?(stub_value, actual_value)
     end
 
   end

data/spec/lib/http_stub/{models → server}/registry_spec.rb

@@ -1,14 +1,22 @@
-describe HttpStub::Models::Registry do
+describe HttpStub::Server::Registry do
 
   let(:logger)  { double("Logger").as_null_object }
   let(:request) { double("HttpRequest", logger: logger, inspect: "Request inspect result") }
 
-  let(:registry) { HttpStub::Models::Registry.new("a_model") }
+  let(:registry) { HttpStub::Server::Registry.new("a_model") }
+
+  shared_context "register multiple models" do
+
+    let(:models) { (1..3).map { |i| double("HttpStub::Server::Model#{i}", :satisfies? => false, :clear => nil) } }
+
+    before(:example) { models.each { |model| registry.add(model, request) } }
+
+  end
 
   describe "#add" do
 
     it "logs that the model has been registered" do
-      model = double("HttpStub::Models::Model", to_s: "Model as String")
+      model = double("HttpStub::Server::Model", to_s: "Model as String")
       expect(logger).to receive(:info).with(/Model as String/)
 
       registry.add(model, request)
@@ -20,13 +28,7 @@ describe HttpStub::Models::Registry do
 
     describe "when multiple models have been registered" do
 
-      let(:models) do
-        (1..3).map { |i| double("HttpStub::Models::Model#{i}", :satisfies? => false) }
-      end
-
-      before(:example) do
-        models.each { |model| registry.add(model, request) }
-      end
+      include_context "register multiple models"
 
       describe "and one registered model satisfies the request" do
 
@@ -52,9 +54,7 @@ describe HttpStub::Models::Registry do
 
       describe "and multiple registered models satisfy the request" do
 
-        before(:example) do
-          [0, 2].each { |i| allow(models[i]).to receive(:satisfies?).and_return(true) }
-        end
+        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])
@@ -88,83 +88,80 @@ describe HttpStub::Models::Registry do
 
   end
 
-  describe "#all" do
-
-    describe "when multiple models have been registered" do
+  describe "#last" do
 
-      let(:models) do
-        (1..3).map { |i| double("HttpStub::Models::Model#{i}", :satisfies? => false) }
-      end
+    context "when multiple models have been registered" do
 
-      before(:example) do
-        models.each { |model| registry.add(model, request) }
-      end
+      include_context "register multiple models"
 
-      it "returns the registered models in the order they were added" do
-        expect(registry.all).to eql(models.reverse)
+      it "returns the last added model" do
+        expect(registry.last).to eql(models.last)
       end
 
     end
 
-    describe "when no model has been registered" do
+    context "when a model has been registered" do
 
-      it "returns an empty list" do
-        expect(registry.all).to eql([])
+      let(:model) { double("HttpStub::Server::Model") }
+
+      before(:example) { registry.add(model, request) }
+
+      it "returns the model" do
+        expect(registry.last).to eql(model)
       end
 
     end
 
   end
 
-  describe "#copy" do
-
-    class HttpStub::Models::CopyableModel
+  describe "#all" do
 
-      attr_reader :name
+    context "when multiple models have been registered" do
 
-      def initialize(name)
-        @name = name
-      end
+      include_context "register multiple models"
 
-      def eql?(other)
-        @name = other.name
+      it "returns the registered models in the order they were added" do
+        expect(registry.all).to eql(models.reverse)
       end
 
     end
 
-    subject { registry.copy }
+    context "when no model has been registered" do
 
-    context "when multiple models have been registered" do
+      it "returns an empty list" do
+        expect(registry.all).to eql([])
+      end
 
-      let(:models) { (1..3).map { |i| HttpStub::Models::CopyableModel.new("model_#{i}") } }
+    end
 
-      before(:each) { models.each { |model| registry.add(model, request) } }
+  end
 
-      it "returns a registry containing the models" do
-        result = subject
+  describe "#clear" do
 
-        expect(result.all).to eql(models)
-      end
+    subject { registry.clear(request) }
+
+    it "logs that the models are being cleared" do
+      expect(logger).to receive(:info).with(/clearing a_model/i)
 
+      subject
     end
 
-    it "returns a registry that changes independently of the copied registry" do
-      model_to_add = HttpStub::Models::CopyableModel.new("model_to_add")
+    context "when models have been added" do
 
-      result = subject
+      include_context "register multiple models"
 
-      registry.add(model_to_add, request)
-      expect(result.all).not_to include(model_to_add)
-    end
+      it "clears each model" do
+        models.each { |model| expect(model).to receive(:clear) }
 
-  end
+        subject
+      end
 
-  describe "#clear" do
+      it "releases all knowledge of the models" do
+        subject
 
-    it "logs that the models are being cleared" do
-      expect(logger).to receive(:info).with(/clearing a_model/i)
+        expect(registry.all).to be_empty
+      end
 
-      registry.clear(request)
     end
 
   end

data/spec/lib/http_stub/{models → server}/request_header_parser_spec.rb

@@ -1,4 +1,4 @@
-describe HttpStub::Models::RequestHeaderParser do
+describe HttpStub::Server::RequestHeaderParser do
 
   let(:non_header_env_elements) do
     {
@@ -17,7 +17,7 @@ describe HttpStub::Models::RequestHeaderParser do
       let(:header_env_elements) { { "KEY_1" => "value1", "KEY_2" => "value2", "KEY_3" => "value3" } }
 
       it "returns a hash containing those entries" do
-        expect(HttpStub::Models::RequestHeaderParser.parse(request)).to eql("KEY_1" => "value1",
+        expect(HttpStub::Server::RequestHeaderParser.parse(request)).to eql("KEY_1" => "value1",
                                                                             "KEY_2" => "value2",
                                                                             "KEY_3" => "value3")
       end
@@ -29,7 +29,7 @@ describe HttpStub::Models::RequestHeaderParser do
       let(:header_env_elements) { { "HTTP_KEY_1" => "value1", "HTTP_KEY_2" => "value2", "HTTP_KEY_3" => "value3" } }
 
       it "returns a hash containing those entries with the prefix removed" do
-        expect(HttpStub::Models::RequestHeaderParser.parse(request)).to include("KEY_1" => "value1",
+        expect(HttpStub::Server::RequestHeaderParser.parse(request)).to include("KEY_1" => "value1",
                                                                                 "KEY_2" => "value2",
                                                                                 "KEY_3" => "value3")
       end
@@ -41,7 +41,7 @@ describe HttpStub::Models::RequestHeaderParser do
       let(:header_env_elements) { {} }
 
       it "returns an empty hash" do
-        expect(HttpStub::Models::RequestHeaderParser.parse(request)).to eql({})
+        expect(HttpStub::Server::RequestHeaderParser.parse(request)).to eql({})
       end
       
     end

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

@@ -0,0 +1,29 @@
+describe HttpStub::Server::ResponsePipeline do
+
+  let(:server)            { instance_double(HttpStub::Server) }
+
+  let(:response_pipeline) { HttpStub::Server::ResponsePipeline.new(server) }
+
+  describe "#process" do
+
+    let(:response) { double(HttpStub::Server::StubResponse::Base, delay_in_seconds: 5, serve_on: nil) }
+
+    before(:example) { allow(response_pipeline).to receive(:sleep) }
+
+    subject { response_pipeline.process(response) }
+
+    it "sleeps for the duration declared in the response" do
+      expect(response_pipeline).to receive(:sleep).with(5)
+
+      subject
+    end
+
+    it "serves the response via the server" do
+      expect(response).to receive(:serve_on).with(server)
+
+      subject
+    end
+
+  end
+
+end

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

@@ -0,0 +1,41 @@
+describe HttpStub::Server::Response do
+
+  describe "::SUCCESS" do
+
+    let(:response) { HttpStub::Server::Response::SUCCESS }
+
+    it "has a status of 200" do
+      expect(response.status).to eql(200)
+    end
+
+    it "has a body containing OK to visually indicate success to those interacting via a browser" do
+      expect(response.body).to match(/OK/)
+    end
+
+  end
+
+  describe "::ERROR" do
+
+    let(:response) { HttpStub::Server::Response::ERROR }
+
+    it "has a status of 404" do
+      expect(response.status).to eql(404)
+    end
+
+    it "has a body containing ERROR to visually indicate the error to those interacting via a browser" do
+      expect(response.body).to match(/ERROR/)
+    end
+
+  end
+
+  describe "::EMPTY" do
+
+    let(:response) { HttpStub::Server::Response::EMPTY }
+
+    it "is empty" do
+      expect(response.empty?).to be(true)
+    end
+
+  end
+
+end