http_stub 0.1.4 → 0.2.0

data/lib/http_stub.rb

@@ -7,7 +7,11 @@ require 'immutable_struct'
 require 'net/http'
 require 'json'
 
-require File.expand_path('../http_stub/stub', __FILE__)
-require File.expand_path('../http_stub/registry', __FILE__)
+require File.expand_path('../http_stub/response', __FILE__)
+require File.expand_path('../http_stub/models/stub', __FILE__)
+require File.expand_path('../http_stub/models/alias', __FILE__)
+require File.expand_path('../http_stub/models/registry', __FILE__)
+require File.expand_path('../http_stub/controllers/stub_controller', __FILE__)
+require File.expand_path('../http_stub/controllers/alias_controller', __FILE__)
 require File.expand_path('../http_stub/server', __FILE__)
-require File.expand_path('../http_stub/client', __FILE__)
+require File.expand_path('../http_stub/configurer', __FILE__)

data/lib/http_stub/configurer.rb

@@ -0,0 +1,75 @@
+module HttpStub
+
+  module Configurer
+
+    def self.included(mod)
+      mod.extend(HttpStub::Configurer::ClassMethods)
+      mod.send(:include, HttpStub::Configurer::InstanceMethods)
+    end
+
+    module ClassMethods
+
+      def host(host)
+        @host = host
+      end
+
+      def port(port)
+        @port = port
+      end
+
+      def stub_alias(alias_uri, stub_uri, options)
+        response_options = options[:response]
+        request = Net::HTTP::Post.new("/stubs/aliases")
+        request.content_type = "application/json"
+        request.body = {
+            "alias_uri" => alias_uri,
+            "uri" => stub_uri,
+            "method" => options[:method],
+            "parameters" => options[:parameters] || {},
+            "response" => {
+                "status" => response_options[:status] || "200",
+                "body" => response_options[:body]
+            }
+        }.to_json
+        response = submit(request)
+        raise "Unable to establish stub alias: #{response.message}" unless response.code == "200"
+      end
+
+      def submit(request)
+        Net::HTTP.new(@host, @port).start { |http| http.request(request) }
+      end
+
+    end
+
+    module InstanceMethods
+
+      def stub!(uri, options)
+        response_options = options[:response]
+        request = Net::HTTP::Post.new("/stubs")
+        request.content_type = "application/json"
+        request.body = {
+            "uri" => uri,
+            "method" => options[:method],
+            "parameters" => options[:parameters] || {},
+            "response" => {
+                "status" => response_options[:status] || "200",
+                "body" => response_options[:body]
+            }
+        }.to_json
+        response = self.class.submit(request)
+        raise "Unable to establish stub: #{response.message}" unless response.code == "200"
+      end
+
+      alias_method :stub_response!, :stub!
+
+      def clear!
+        request = Net::HTTP::Delete.new("/stubs")
+        response = self.class.submit(request)
+        raise "Unable to clear stubs: #{response.message}" unless response.code == "200"
+      end
+
+    end
+
+  end
+
+end

data/lib/http_stub/controllers/alias_controller.rb

@@ -0,0 +1,29 @@
+module HttpStub
+  module Controllers
+
+    class AliasController
+
+      def initialize(alias_registry, stub_registry)
+        @alias_registry = alias_registry
+        @stub_registry = stub_registry
+      end
+
+      def register(request)
+        @alias_registry.add(HttpStub::Models::Alias.new(request.body.read), request)
+        HttpStub::Response::SUCCESS
+      end
+
+      def activate(request)
+        the_alias = @alias_registry.find_for(request)
+        if the_alias
+          @stub_registry.add(the_alias.the_stub, request)
+          HttpStub::Response::SUCCESS
+        else
+          HttpStub::Response::EMPTY
+        end
+      end
+
+    end
+
+  end
+end

data/lib/http_stub/controllers/stub_controller.rb

@@ -0,0 +1,27 @@
+module HttpStub
+  module Controllers
+
+    class StubController
+
+      def initialize(registry)
+        @registry = registry
+      end
+
+      def register(request)
+        @registry.add(HttpStub::Models::Stub.new(request.body.read), request)
+        HttpStub::Response::SUCCESS
+      end
+
+      def replay(request)
+        stub = @registry.find_for(request)
+        stub ? stub.response : HttpStub::Response::EMPTY
+      end
+
+      def clear(request)
+        @registry.clear(request)
+      end
+
+    end
+
+  end
+end

data/lib/http_stub/models/alias.rb

@@ -0,0 +1,22 @@
+module HttpStub
+  module Models
+
+    class Alias
+
+      def initialize(request_body)
+        @data = JSON.parse(request_body)
+        @stub = HttpStub::Models::Stub.new(request_body)
+      end
+
+      def satisfies?(request)
+        @data["alias_uri"] == request.path_info
+      end
+
+      def the_stub
+        @stub
+      end
+
+    end
+
+  end
+end

data/lib/http_stub/models/registry.rb

@@ -0,0 +1,29 @@
+module HttpStub
+  module Models
+
+    class Registry
+
+      def initialize(model_name)
+        @model_name = model_name
+        @models = []
+      end
+
+      def add(model, request)
+        @models.unshift(model)
+        request.logger.info "Registered #{@model_name}: #{model}"
+      end
+
+      def find_for(request)
+        request.logger.info "Finding #{@model_name} satisfying: #{request.inspect}"
+        @models.find { |model| model.satisfies?(request) }
+      end
+
+      def clear(request)
+        request.logger.info "Clearing #{@model_name} registry"
+        @models.clear
+      end
+
+    end
+
+  end
+end

data/lib/http_stub/models/stub.rb

@@ -0,0 +1,35 @@
+module HttpStub
+  module Models
+
+    class Stub
+
+      attr_reader :response
+
+      def initialize(request_body)
+        @data = JSON.parse(request_body)
+        @response = HttpStub::Response.new(status: @data["response"]["status"], body: @data["response"]["body"])
+      end
+
+      def satisfies?(request)
+        @data["uri"] == request.path_info &&
+            @data["method"].downcase == request.request_method.downcase &&
+            parameters_match?(request)
+      end
+
+      def to_s
+        @data.to_s
+      end
+
+      private
+
+      def parameters_match?(request)
+        parameters = @data["parameters"]
+        parameters.nil? || parameters.reduce(true) do |result, parameter|
+          result && (request.params[parameter[0]] == parameter[1])
+        end
+      end
+
+    end
+
+  end
+end

data/lib/http_stub/response.rb

@@ -0,0 +1,14 @@
+module HttpStub
+
+  class Response < ImmutableStruct.new(:status, :body)
+    SUCCESS = HttpStub::Response.new(status: 200, body: "")
+    ERROR = HttpStub::Response.new(status: 404, body: "")
+    EMPTY = HttpStub::Response.new()
+
+    def empty?
+      self == HttpStub::Response::EMPTY
+    end
+
+  end
+
+end

data/lib/http_stub/server.rb

@@ -6,7 +6,10 @@ module HttpStub
 
     def initialize
       super()
-      @registry = HttpStub::Registry.new
+      @stub_registry = HttpStub::Models::Registry.new("stub")
+      @alias_registry = HttpStub::Models::Registry.new("alias")
+      @stub_controller = HttpStub::Controllers::StubController.new(@stub_registry)
+      @alias_controller = HttpStub::Controllers::AliasController.new(@alias_registry, @stub_registry)
     end
 
     private
@@ -32,23 +35,35 @@ module HttpStub
     #     "body": "Hello World"
     #   }
     # }
-    post "/stub" do
-      @registry.add(HttpStub::Stub.new(request), request)
-      halt 200
+    post "/stubs" do
+      response = @stub_controller.register(request)
+      halt(response.status, response.body)
+    end
+
+    # Sample request body:
+    # {
+    #   "alias_uri": "/some/path",
+    #   ... see /stub ...
+    # }
+    post "/stubs/aliases" do
+      response = @alias_controller.register(request)
+      halt(response.status, response.body)
     end
 
     delete "/stubs" do
-      @registry.clear(request)
+      @stub_controller.clear(request)
       halt 200
     end
 
-    any_request_type(//) { handle_stub_request }
+    any_request_type(//) { handle_request }
 
     private
 
-    def handle_stub_request
-      stub = @registry.find_for(request)
-      stub ? halt(stub.response.status, stub.response.body) : halt(404)
+    def handle_request
+      response = @stub_controller.replay(request)
+      response = @alias_controller.activate(request) if response.empty?
+      response = HttpStub::Response::ERROR if response.empty?
+      halt(response.status, response.body)
     end
 
   end

data/lib/http_stub/start_server_rake_task.rb

@@ -1,5 +1,5 @@
 require File.expand_path('../../http_stub', __FILE__)
-require 'rake/tasklib' unless defined?(::Rake::TaskLib)
+require 'rake/tasklib' unless defined? (::Rake::TaskLib)
 
 module HttpStub
 

data/lib/http_stub/version.rb

@@ -1,3 +1,3 @@
 module HttpStub
-  VERSION = "0.1.4"
+  VERSION = "0.2.0"
 end

data/spec/lib/http_stub/configurer_integration_spec.rb

@@ -0,0 +1,119 @@
+describe HttpStub::Configurer do
+  include_context "server integration"
+
+  before(:all) do
+    class TestConfigurer
+      include HttpStub::Configurer
+
+      host "localhost"
+      port 8001
+
+      stub_alias "/an_alias", "/path1", method: :get, response: { status: 200, body: "Stub alias body" }
+    end
+  end
+
+  let(:configurer) { TestConfigurer.new }
+
+  after(:each) { configurer.clear! }
+
+  describe "when a stub alias is activated" do
+
+    before(:each) { Net::HTTP.get_response("localhost", "/an_alias", 8001) }
+
+    describe "and the stub request is made" do
+
+      let(:response) { Net::HTTP.get_response("localhost", "/path1", 8001) }
+
+      it "should replay the stubbed response" do
+        response.code.should eql("200")
+        response.body.should eql("Stub alias body")
+      end
+
+    end
+
+  end
+
+  describe "when a stub alias is not activated" do
+
+    describe "and the stub request is made" do
+
+      let(:response) { Net::HTTP.get_response("localhost", "/path1", 8001) }
+
+      it "should respond with a 404 status code" do
+        response.code.should eql("404")
+      end
+
+    end
+
+  end
+
+  describe "when a response for a request is stubbed" do
+
+    describe "that contains no parameters" do
+
+      before(:each) do
+        configurer.stub_response!("/path2", method: :get, response: { status: 201, body: "Stub body" })
+      end
+
+      describe "and that request is made" do
+
+        let(:response) { Net::HTTP.get_response("localhost", "/path2", 8001) }
+
+        it "should replay the stubbed response" do
+          response.code.should eql("201")
+          response.body.should eql("Stub body")
+        end
+
+      end
+
+      describe "and the stub is cleared" do
+
+        before(:each) { configurer.clear! }
+
+        describe "and the original request is made" do
+
+          let(:response) { Net::HTTP.get_response("localhost", "/path2", 8001) }
+
+          it "should respond with a 404 status code" do
+            response.code.should eql("404")
+          end
+
+        end
+
+      end
+
+    end
+
+    describe "that contains parameters" do
+
+      before(:each) do
+        configurer.stub_response!("/path3", method: :get, parameters: { key: "value" },
+                                                          response: { status: 202, body: "Another stub body" })
+      end
+
+      describe "and that request is made" do
+
+        let(:response) { Net::HTTP.get_response("localhost", "/path3?key=value", 8001) }
+
+        it "should replay the stubbed response" do
+          response.code.should eql("202")
+          response.body.should eql("Another stub body")
+        end
+
+      end
+
+      describe "and a request with different parameters is made" do
+
+        let(:response) { Net::HTTP.get_response("localhost", "/path3?key=another_value", 8001) }
+
+        it "should respond with a 404 status code" do
+          response.code.should eql("404")
+        end
+
+      end
+
+    end
+
+  end
+
+end

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

@@ -0,0 +1,75 @@
+describe HttpStub::Controllers::AliasController do
+
+  let(:request_body) { "Some request body" }
+  let(:request) { double("HttpRequest", body: double("RequestBody", read: request_body)) }
+  let(:the_stub) { double(HttpStub::Models::Stub) }
+  let(:stub_alias) { double(HttpStub::Models::Alias, the_stub: the_stub) }
+  let(:alias_registry) { double("HttpStub::Models::AliasRegistry").as_null_object }
+  let(:stub_registry) { double("HttpStub::Models::StubRegistry").as_null_object }
+  let(:controller) { HttpStub::Controllers::AliasController.new(alias_registry, stub_registry) }
+
+  describe "#register" do
+
+    before(:each) do
+      HttpStub::Models::Alias.stub!(:new).and_return(stub_alias)
+    end
+
+    it "should create an alias from the request body" do
+      HttpStub::Models::Alias.should_receive(:new).with(request_body).and_return(stub_alias)
+
+      controller.register(request)
+    end
+
+    it "should add the created alias to the alias registry" do
+      alias_registry.should_receive(:add).with(stub_alias, request)
+
+      controller.register(request)
+    end
+
+    it "should return a success response" do
+      controller.register(request).should eql(HttpStub::Response::SUCCESS)
+    end
+
+  end
+
+  describe "#activate" do
+
+    describe "when an alias has been registered that is activated by the request" do
+
+      before(:each) do
+        alias_registry.stub!(:find_for).with(request).and_return(stub_alias)
+      end
+
+      it "should add the aliases stub to the stub registry" do
+        stub_registry.should_receive(:add).with(the_stub, request)
+
+        controller.activate(request)
+      end
+
+      it "should return a success response" do
+        controller.activate(request).should eql(HttpStub::Response::SUCCESS)
+      end
+
+    end
+
+    describe "when no alias is activated by the request" do
+
+      before(:each) do
+        alias_registry.stub!(:find_for).with(request).and_return(nil)
+      end
+
+      it "should not add a stub to the registry" do
+        stub_registry.should_not_receive(:add)
+
+        controller.activate(request)
+      end
+
+      it "should return an empty response" do
+        controller.activate(request).should eql(HttpStub::Response::EMPTY)
+      end
+
+    end
+
+  end
+
+end