http_stub 0.1.4 → 0.2.0

data/spec/lib/http_stub/controllers/stub_controller_spec.rb

@@ -0,0 +1,74 @@
+describe HttpStub::Controllers::StubController do
+
+  let(:request_body) { "Some request body" }
+  let(:request) { double("HttpRequest", body: double("RequestBody", read: request_body)) }
+  let(:response) { double(HttpStub::Response) }
+  let(:the_stub) { double(HttpStub::Models::Stub, response: response) }
+  let(:registry) { double(HttpStub::Models::Registry).as_null_object }
+  let(:controller) { HttpStub::Controllers::StubController.new(registry) }
+
+  describe "#register" do
+
+    before(:each) do
+      HttpStub::Models::Stub.stub!(:new).and_return(the_stub)
+    end
+
+    it "should create a stub from the request body" do
+      HttpStub::Models::Stub.should_receive(:new).with(request_body).and_return(the_stub)
+
+      controller.register(request)
+    end
+
+    it "should add the stub to the stub registry" do
+      registry.should_receive(:add).with(the_stub, request)
+
+      controller.register(request)
+    end
+
+    it "should return a success response" do
+      controller.register(request).should eql(HttpStub::Response::SUCCESS)
+    end
+
+  end
+
+  describe "#replay" do
+
+    describe "when a stub has been registered that should be replayed for the request" do
+
+      before(:each) do
+        registry.stub!(:find_for).with(request).and_return(the_stub)
+      end
+
+      it "should return the stubs response" do
+        the_stub.should_receive(:response).and_return(response)
+
+        controller.replay(request).should eql(response)
+      end
+
+    end
+
+    describe "when no stub should be replayed for the request" do
+
+      before(:each) do
+        registry.stub!(:find_for).with(request).and_return(nil)
+      end
+
+      it "should return an empty response" do
+        controller.replay(request).should eql(HttpStub::Response::EMPTY)
+      end
+
+    end
+
+  end
+
+  describe "#clear" do
+
+    it "should clear the stub registry" do
+      registry.should_receive(:clear).with(request)
+
+      controller.clear(request)
+    end
+
+  end
+
+end

data/spec/lib/http_stub/models/alias_spec.rb

@@ -0,0 +1,58 @@
+describe HttpStub::Models::Alias do
+
+  let(:alias_uri) { "/some/alias/uri" }
+  let(:alias_body) do
+    { "alias_uri" => alias_uri }.to_json
+  end
+  let(:the_alias) { HttpStub::Models::Alias.new(alias_body) }
+
+  before(:each) { HttpStub::Models::Stub.stub!(:new).and_return(double(HttpStub::Models::Stub)) }
+
+  describe "#satisfies?" do
+
+    let(:request) { double("HttpRequest", path_info: request_path_info) }
+
+    describe "when the request uri exactly matches the aliases activation uri" do
+
+      let(:request_path_info) { alias_uri }
+
+      it "should return true" do
+        the_alias.satisfies?(request).should be_true
+      end
+
+    end
+
+    describe "when the alias activation uri is a substring of the request uri" do
+
+      let(:request_path_info) { "#{alias_uri}/with/additional/paths" }
+
+      it "should return false" do
+        the_alias.satisfies?(request).should be_false
+      end
+
+    end
+
+    describe "when the request uri is completely different to the aliases activation uri" do
+
+      let(:request_path_info) { "/completely/different/path" }
+
+      it "should return false" do
+        the_alias.satisfies?(request).should be_false
+      end
+
+    end
+
+  end
+
+  describe "#the_stub" do
+
+    it "should return a HttpStub::Models::Stub constructed from the request body" do
+      stub = double(HttpStub::Models::Stub)
+      HttpStub::Models::Stub.should_receive(:new).with(alias_body).and_return(stub)
+
+      the_alias.the_stub.should eql(stub)
+    end
+
+  end
+
+end

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

@@ -0,0 +1,101 @@
+describe HttpStub::Models::Registry do
+
+  let(:registry) { HttpStub::Models::Registry.new("a_model") }
+
+  let(:logger) { double("Logger").as_null_object }
+  let(:request) { double("HttpRequest", logger: logger, inspect: "Request inspect result") }
+
+  describe "#add" do
+
+    it "should log that the model has been registered" do
+      model = double("HttpStub::Models::Model", to_s: "Model as String")
+      logger.should_receive(:info).with(/Model as String/)
+
+      registry.add(model, request)
+    end
+
+  end
+
+  describe "#find_for" 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(:each) do
+        models.each { |model| registry.add(model, request) }
+      end
+
+      describe "and one registered model satisfies the request" do
+
+        let(:matching_model) { models[1] }
+
+        before(:each) { matching_model.stub!(:satisfies?).and_return(true) }
+
+        it "should return the model" do
+          registry.find_for(request).should eql(matching_model)
+        end
+
+        describe "and the registry is subsequently cleared" do
+
+          before(:each) { registry.clear(request) }
+
+          it "should return nil" do
+            registry.find_for(request).should be_nil
+          end
+
+        end
+
+      end
+
+      describe "and multiple registered models satisfy the request" do
+
+        before(:each) do
+          [0, 2].each { |i| models[i].stub!(:satisfies?).and_return(true) }
+        end
+
+        it "should support model overrides by returning the last model registered" do
+          registry.find_for(request).should eql(models[2])
+        end
+
+      end
+
+      describe "and no registered models match the request" do
+
+        it "should return nil" do
+          registry.find_for(request).should be_nil
+        end
+
+      end
+
+    end
+
+    describe "when no model has been registered" do
+
+      it "should return nil" do
+        registry.find_for(request).should be_nil
+      end
+
+    end
+
+    it "it should log model discovery diagnostics that includes the complete details of the request" do
+      logger.should_receive(:info).with(/Request inspect result/)
+
+      registry.find_for(request)
+    end
+
+  end
+
+  describe "#clear" do
+
+    it "should log that the models are being cleared" do
+      logger.should_receive(:info).with(/clearing a_model/i)
+
+      registry.clear(request)
+    end
+
+  end
+
+end

data/spec/lib/http_stub/{stub_spec.rb → models/stub_spec.rb}

@@ -1,4 +1,4 @@
-describe HttpStub::Stub do
+describe HttpStub::Models::Stub do
 
   let(:stub_uri) { "/a_path" }
   let(:stub_method) { "get" }
@@ -14,10 +14,9 @@ describe HttpStub::Stub do
         }
     }.to_json
   end
-  let(:stub_request) { double("HttpRequest", :body => double("HttpRequestBody", :read => stub_body)) }
-  let(:stub_instance) { HttpStub::Stub.new(stub_request) }
+  let(:the_stub) { HttpStub::Models::Stub.new(stub_body) }
 
-  describe "#stubs?" do
+  describe "#satisfies?" do
 
     let(:request_uri) { stub_uri }
     let(:request_method) { stub_method }
@@ -43,7 +42,7 @@ describe HttpStub::Stub do
           describe "and the request parameters are identical" do
 
             it "should return true" do
-              stub_instance.stubs?(request).should be_true
+              the_stub.satisfies?(request).should be_true
             end
 
           end
@@ -53,7 +52,7 @@ describe HttpStub::Stub do
             let(:request_parameters) { stub_parameters.merge("param4" => "value4") }
 
             it "should return true" do
-              stub_instance.stubs?(request).should be_true
+              the_stub.satisfies?(request).should be_true
             end
 
           end
@@ -69,7 +68,7 @@ describe HttpStub::Stub do
             end
 
             it "should return false" do
-              stub_instance.stubs?(request).should be_false
+              the_stub.satisfies?(request).should be_false
             end
 
           end
@@ -84,7 +83,7 @@ describe HttpStub::Stub do
             end
 
             it "should be false" do
-              stub_instance.stubs?(request).should be_false
+              the_stub.satisfies?(request).should be_false
             end
 
           end
@@ -100,7 +99,7 @@ describe HttpStub::Stub do
             end
 
             it "should be true" do
-              stub_instance.stubs?(request).should be_true
+              the_stub.satisfies?(request).should be_true
             end
 
           end
@@ -116,7 +115,7 @@ describe HttpStub::Stub do
       let(:request_uri) { "/a_different_path" }
 
       it "should return false" do
-        stub_instance.stubs?(request).should be_false
+        the_stub.satisfies?(request).should be_false
       end
 
     end
@@ -126,7 +125,7 @@ describe HttpStub::Stub do
       let(:request_method) { "post" }
 
       it "should return false" do
-        stub_instance.stubs?(request).should be_false
+        the_stub.satisfies?(request).should be_false
       end
 
     end
@@ -136,11 +135,11 @@ describe HttpStub::Stub do
   describe "#response" do
 
     it "should expose the provided response status" do
-      stub_instance.response.status.should eql(201)
+      the_stub.response.status.should eql(201)
     end
 
     it "should expose the provided response body" do
-      stub_instance.response.body.should eql("Foo")
+      the_stub.response.body.should eql("Foo")
     end
 
   end
@@ -156,26 +155,26 @@ describe HttpStub::Stub do
     end
 
     it "should return a string containing the stubbed uri" do
-      stub_instance.to_s.should match(/\/a_path/)
+      the_stub.to_s.should match(/\/a_path/)
     end
 
     it "should return a string containing the stubbed request method" do
-      stub_instance.to_s.should match(/get/)
+      the_stub.to_s.should match(/get/)
     end
 
     it "should return a string containing the stubbed parameters" do
       stub_parameters.each_pair do |key, value|
-        stub_instance.to_s.should match(/#{Regexp.escape(key)}/)
-        stub_instance.to_s.should match(/#{Regexp.escape(value)}/)
+        the_stub.to_s.should match(/#{Regexp.escape(key)}/)
+        the_stub.to_s.should match(/#{Regexp.escape(value)}/)
       end
     end
 
     it "should return a string containing the intended response code" do
-      stub_instance.to_s.should match(/201/)
+      the_stub.to_s.should match(/201/)
     end
 
     it "should return a string containing the intended response body" do
-      stub_instance.to_s.should match(/Foo/)
+      the_stub.to_s.should match(/Foo/)
     end
 
   end

data/spec/lib/http_stub/response_spec.rb

@@ -0,0 +1,73 @@
+describe HttpStub::Response do
+
+  describe "::SUCCESS" do
+
+    let(:response) { HttpStub::Response::SUCCESS }
+
+    it "should have a status of 200" do
+      response.status.should eql(200)
+    end
+
+    it "should have an empty body" do
+      response.body.should eql("")
+    end
+
+  end
+
+  describe "::ERROR" do
+
+    let(:response) { HttpStub::Response::ERROR }
+
+    it "should have a status of 404" do
+      response.status.should eql(404)
+    end
+
+    it "should have an empty body" do
+      response.body.should eql("")
+    end
+
+  end
+
+  describe "::EMPTY" do
+
+    let(:response) { HttpStub::Response::EMPTY }
+
+    it "should have a nil status" do
+      response.status.should be_nil
+    end
+
+    it "should have a nil body" do
+      response.body.should be_nil
+    end
+
+  end
+
+  describe "#empty?" do
+
+    describe "when the response is EMPTY" do
+
+      it "should return true" do
+        HttpStub::Response::EMPTY.should be_empty
+      end
+
+    end
+
+    describe "when the response is not EMPTY but contains no values" do
+
+      it "should return true" do
+        HttpStub::Response.new.should be_empty
+      end
+
+    end
+
+    describe "when the response is not EMPTY" do
+
+      it "should return false" do
+        HttpStub::Response::SUCCESS.should_not be_empty
+      end
+
+    end
+
+  end
+
+end

data/spec/lib/http_stub/server_spec.rb

@@ -1,90 +1,163 @@
 describe HttpStub::Server do
   include Rack::Test::Methods
 
+  let(:response) { last_response }
+  let(:response_body) { response.body.to_s }
+
+  let(:stub_registry) { double(HttpStub::Models::Registry).as_null_object }
+  let(:alias_registry) { double(HttpStub::Models::Registry).as_null_object }
+
+  let(:stub_controller) { double(HttpStub::Controllers::StubController).as_null_object }
+  let(:alias_controller) { double(HttpStub::Controllers::AliasController).as_null_object }
+
   let(:app) { HttpStub::Server.new }
 
-  let(:registry) { double(HttpStub::Registry).as_null_object }
-  before(:each) { HttpStub::Registry.stub!(:new).and_return(registry) }
+  before(:each) do
+    HttpStub::Models::Registry.stub!(:new).with("stub").and_return(stub_registry)
+    HttpStub::Models::Registry.stub!(:new).with("alias").and_return(alias_registry)
+    HttpStub::Controllers::StubController.stub!(:new).and_return(stub_controller)
+    HttpStub::Controllers::AliasController.stub!(:new).and_return(alias_controller)
+  end
 
-  let(:response) { last_response }
-  let(:response_body) { response.body.to_s }
+  describe "when a stub insertion is received" do
+
+    it "should register the insertion via the stub controller" do
+      stub_controller.should_receive(:register).and_return(HttpStub::Response::SUCCESS)
 
-  describe "when a stub request is received" do
+      issue_stub_request
+    end
 
-    it "should register a stub encapsulating the request" do
-      stub = double(HttpStub::Stub)
-      HttpStub::Stub.should_receive(:new).and_return(stub)
-      registry.should_receive(:add).with(stub, anything)
+    it "should respond with the response provided by the controller" do
+      stub_controller.stub!(:register).and_return(HttpStub::Response.new(status: 202, body: ""))
 
       issue_stub_request
+
+      response.status.should eql(202)
+    end
+
+    def issue_stub_request
+      post "/stubs", {
+          "uri" => "/a_path",
+          "method" => "a method",
+          "response" => {
+              "status" => 200,
+              "body" => "Foo"
+          }
+      }.to_json
+    end
+
+  end
+
+  describe "when a stub alias insertion request is received" do
+
+    it "should register the insertion via the alias controller" do
+      alias_controller.should_receive(:register).and_return(HttpStub::Response::SUCCESS)
+
+      issue_stub_alias_request
+    end
+
+    it "should respond with the response provided by the controller" do
+      alias_controller.stub!(:register).and_return(HttpStub::Response.new(status: 302, body: ""))
+
+      issue_stub_alias_request
+
+      response.status.should eql(302)
+    end
+
+    def issue_stub_alias_request
+      post "/stubs/aliases", {
+          "alias_uri" => "/an_alias_path",
+          "uri" => "/a_path",
+          "method" => "a method",
+          "response" => {
+              "status" => 200,
+              "body" => "Foo"
+          }
+      }.to_json
+    end
+
+  end
+
+  describe "when a request to clear the server has been received" do
+
+    it "should delegate clearing to the stub controller" do
+      stub_controller.should_receive(:clear)
+
+      delete "/stubs"
+    end
+
+    it "should respond with a 200 status code" do
+      delete "/stubs"
+
+      response.status.should eql(200)
     end
 
   end
 
-  describe "when a replay request is received" do
+  describe "when another type of request is received" do
 
-    describe "and the request has been stubbed" do
+    describe "and the stub controller replays a response" do
 
       before(:each) do
-        registry.stub!(:find_for).and_return(
-            double(HttpStub::Stub, response: double("StubResponse", status: 500, body: "Some text")))
+        stub_controller.stub!(:replay).and_return(HttpStub::Response.new(status: 222, body: "Some body"))
       end
 
-      it "should respond with the configured status" do
+      it "should respond with the replay status code" do
         get "/a_path"
 
-        response.status.should eql(500)
+        response.status.should eql(222)
       end
 
-      it "should respond with the configured body" do
+      it "should respond with the replay body" do
         get "/a_path"
 
-        response_body.should eql("Some text")
+        response_body.should eql("Some body")
       end
 
     end
 
-    describe "and the request has not been stubbed" do
+    describe "and the stub controller does not replay a response" do
 
       before(:each) do
-        registry.stub!(:find_for).and_return(nil)
+        stub_controller.stub!(:replay).and_return(HttpStub::Response::EMPTY)
       end
 
-      it "should respond with a 404 status code" do
-        get "/a_path"
+      describe "but the alias controller activates a stub" do
 
-        response.status.should eql(404)
-      end
+        before(:each) do
+          alias_controller.stub!(:activate).and_return(HttpStub::Response.new(status: 300, body: "A body"))
+        end
 
-    end
+        it "should respond with the activation response status code" do
+          get "/a_path"
 
-  end
+          response.status.should eql(300)
+        end
 
-  describe "when a request to clear the stub has been received" do
+        it "should respond with the activation response body" do
+          get "/a_path"
 
-    it "should clear the contents of the registry" do
-      registry.should_receive(:clear)
+          response_body.should eql("A body")
+        end
 
-      delete "/stubs"
-    end
+      end
 
-    it "should respond with a 200 status code" do
-      delete "/stubs"
+      describe "and the alias controller does not activate a stub" do
 
-      response.status.should eql(200)
-    end
+        before(:each) do
+          alias_controller.stub!(:activate).and_return(HttpStub::Response::EMPTY)
+        end
 
-  end
+        it "should respond with a 404 status code" do
+          get "/a_path"
+
+          response.status.should eql(404)
+        end
+
+      end
+
+    end
 
-  def issue_stub_request
-    post "/stub", {
-        "uri" => "/a_path",
-        "method" => "a method",
-        "response" => {
-            "status" => 200,
-            "body" => "Foo"
-        }
-    }.to_json
   end
 
 end