http_stub 0.25.1 → 0.26.0

data/lib/http_stub/server/application/routes/stub.rb

@@ -0,0 +1,75 @@
+module HttpStub
+  module Server
+    module Application
+      module Routes
+
+        module Stub
+
+          def initialize
+            super()
+            @stub_controller       = HttpStub::Server::Stub::Controller.new
+            @stub_match_controller = HttpStub::Server::Stub::Match::Controller.new
+          end
+
+          def self.included(application)
+            application.instance_eval do
+
+              namespace "/http_stub/stubs" do
+
+                post do
+                  response = @stub_controller.register(http_stub_request, logger)
+                  @response_pipeline.process(response)
+                end
+
+                get do
+                  haml :stubs, {}, stubs: @stub_controller.find_all(http_stub_request)
+                end
+
+                post "/reset" do
+                  @stub_controller.reset(http_stub_request, logger)
+                  halt 200, "OK"
+                end
+
+                delete do
+                  @stub_controller.clear(http_stub_request, logger)
+                  halt 200, "OK"
+                end
+
+                namespace "/matches" do
+
+                  get do
+                    haml :stub_matches, {}, matches: @stub_match_controller.matches(http_stub_request)
+                  end
+
+                  get "/last" do
+                    response = @stub_match_controller.last_match(http_stub_request, logger)
+                    @response_pipeline.process(response)
+                  end
+
+                end
+
+                get "/misses" do
+                  haml :stub_misses, {}, misses: @stub_match_controller.misses(http_stub_request)
+                end
+
+                get "/:stub_id" do
+                  establish_http_stub_request
+                  haml :stub, {}, the_stub: @stub_controller.find(http_stub_request, logger)
+                end
+
+              end
+
+              any_request_method "*" do
+                response = @stub_controller.match(http_stub_request, logger)
+                @response_pipeline.process(response)
+              end
+
+            end
+          end
+
+        end
+
+      end
+    end
+  end
+end

data/lib/http_stub/server/application/session_uri_support.rb

@@ -0,0 +1,15 @@
+module HttpStub
+  module Server
+    module Application
+
+      module SessionUriSupport
+
+        def session_uri(uri)
+          URI.add_parameters(uri, http_stub_session_id: http_stub_request.session.id)
+        end
+
+      end
+
+    end
+  end
+end

data/lib/http_stub/server/memory/controller.rb

@@ -0,0 +1,25 @@
+module HttpStub
+  module Server
+    module Memory
+
+      class Controller
+
+        def initialize(session_configuration, server_memory)
+          @session_configuration = session_configuration
+          @server_memory         = server_memory
+        end
+
+        def find_stubs
+          @server_memory.stubs
+        end
+
+        def reset(logger)
+          @session_configuration.reset
+          @server_memory.reset(logger)
+        end
+
+      end
+
+    end
+  end
+end

data/lib/http_stub/server/memory/memory.rb

@@ -0,0 +1,32 @@
+module HttpStub
+  module Server
+    module Memory
+
+      class Memory
+
+        SESSION_ID = HttpStub::Server::Session::MEMORY_SESSION_ID
+
+        private_constant :SESSION_ID
+
+        attr_reader :scenarios, :sessions
+
+        def initialize(session_configuration)
+          @scenarios = HttpStub::Server::Registry.new("scenario")
+          @session   = HttpStub::Server::Session::Session.new(SESSION_ID, @scenarios, HttpStub::Server::Session::Empty)
+          @sessions  = HttpStub::Server::Session::Registry.new(session_configuration, @scenarios, @session)
+        end
+
+        def stubs
+          @session.stubs
+        end
+
+        def reset(logger)
+          @scenarios.clear(logger)
+          @sessions.clear(logger)
+        end
+
+      end
+
+    end
+  end
+end

data/lib/http_stub/server/registry.rb

@@ -3,18 +3,25 @@ module HttpStub
 
     class Registry
 
-      def initialize(model_name)
+      def initialize(model_name, models=[])
         @model_name = model_name
-        @models     = []
+        @models     = models
       end
 
       def add(model, logger)
         @models.unshift(model)
-        logger.info "Registered #{@model_name}: #{model}"
+        log_addition_of([ model ], logger)
       end
 
       def concat(models, logger)
-        models.each { |model| self.add(model, logger) }
+        @models.unshift(*models.reverse)
+        log_addition_of(models.reverse, logger)
+      end
+
+      def replace(models, logger)
+        log_pending_clear(logger)
+        @models.replace(models.reverse)
+        log_addition_of(models.reverse, logger)
       end
 
       def find(criteria, logger)
@@ -30,16 +37,26 @@ module HttpStub
         Array.new(@models)
       end
 
-      def rollback_to(model)
-        starting_index = @models.index(model)
-        @models = @models.slice(starting_index..-1) if starting_index
+      def delete(criteria, logger)
+        logger.info "Deleting #{@model_name} matching: #{criteria}"
+        @models.delete_if { |model| model.matches?(criteria, logger) }
       end
 
       def clear(logger)
-        logger.info "Clearing #{@model_name} registry"
+        log_pending_clear(logger)
         @models.clear
       end
 
+      private
+
+      def log_pending_clear(logger)
+        logger.info "Clearing #{@model_name} registry"
+      end
+
+      def log_addition_of(models, logger)
+        models.each { |model| logger.info "Registered #{@model_name}: #{model}" }
+      end
+
     end
 
   end

data/lib/http_stub/server/request/factory.rb

@@ -0,0 +1,23 @@
+module HttpStub
+  module Server
+    module Request
+
+      class Factory
+
+        def initialize(session_configuration, server_memory)
+          @server_memory               = server_memory
+          @session_identifier_strategy = HttpStub::Server::Session::IdentifierStrategy.new(session_configuration)
+        end
+
+        def create(rack_request, sinatra_parameters, logger)
+          sinatra_request = HttpStub::Server::Request::SinatraRequest.new(rack_request, sinatra_parameters)
+          session_id      = @session_identifier_strategy.identifier_for(sinatra_request)
+          session         = @server_memory.sessions.find_or_create(session_id, logger)
+          HttpStub::Server::Request::Request.new(sinatra_request, session_id, session)
+        end
+
+      end
+
+    end
+  end
+end

data/lib/http_stub/server/request/parameters.rb

@@ -5,8 +5,8 @@ module HttpStub
       class Parameters < ::HashWithIndifferentAccess
         include HttpStub::Extensions::Core::Hash::Formatted
 
-        def self.create(rack_request)
-          self.new(rack_request.params)
+        class << self
+          alias_method :create, :new
         end
 
         def initialize(parameter_hash={})

data/lib/http_stub/server/request/request.rb

@@ -4,19 +4,14 @@ module HttpStub
 
       class Request
 
-        attr_reader :base_uri, :uri, :method, :headers, :parameters, :body
+        delegate :base_uri, :uri, :method, :headers, :parameters, :body, :to_json, to: :@sinatra_request
 
-        def initialize(rack_request)
-          @base_uri   = rack_request.base_url
-          @uri        = rack_request.path_info
-          @method     = rack_request.request_method.downcase
-          @headers    = HttpStub::Server::Request::Headers.create(rack_request)
-          @parameters = HttpStub::Server::Request::Parameters.create(rack_request)
-          @body       = rack_request.body.read
-        end
+        attr_reader :session_id, :session
 
-        def to_json(*args)
-          { uri: @uri, method: @method, headers: @headers, parameters: @parameters, body: @body }.to_json(*args)
+        def initialize(sinatra_request, session_id, session)
+          @sinatra_request = sinatra_request
+          @session_id      = session_id
+          @session         = session
         end
 
       end

data/lib/http_stub/server/request/sinatra_request.rb

@@ -0,0 +1,26 @@
+module HttpStub
+  module Server
+    module Request
+
+      class SinatraRequest
+
+        attr_reader :base_uri, :uri, :method, :headers, :parameters, :body
+
+        def initialize(rack_request, sinatra_parameters)
+          @base_uri   = rack_request.base_url
+          @uri        = rack_request.path_info
+          @method     = rack_request.request_method.downcase
+          @headers    = HttpStub::Server::Request::Headers.create(rack_request)
+          @parameters = HttpStub::Server::Request::Parameters.create(sinatra_parameters)
+          @body       = rack_request.body.read.tap { rack_request.body.rewind }
+        end
+
+        def to_json(*args)
+          { uri: @uri, method: @method, headers: @headers, parameters: @parameters, body: @body }.to_json(*args)
+        end
+
+      end
+
+    end
+  end
+end

data/lib/http_stub/server/scenario/controller.rb

@@ -4,9 +4,8 @@ module HttpStub
 
       class Controller
 
-        def initialize(scenario_registry, stub_registry)
-          @scenario_registry  = scenario_registry
-          @scenario_activator = HttpStub::Server::Scenario::Activator.new(scenario_registry, stub_registry)
+        def initialize(server_memory)
+          @scenario_registry = server_memory.scenarios
         end
 
         def register(request, logger)
@@ -15,14 +14,20 @@ module HttpStub
           HttpStub::Server::Response::OK
         end
 
-        def activate(name, logger)
-          scenario = @scenario_registry.find(name, logger)
-          if scenario
-            @scenario_activator.activate(scenario, logger)
-            HttpStub::Server::Response::OK
-          else
-            HttpStub::Server::Response::NOT_FOUND
-          end
+        def find(request, logger)
+          @scenario_registry.find(URI.decode_www_form_component(request.parameters[:name]), logger)
+        end
+
+        def find_all
+          @scenario_registry.all.sort_by(&:name)
+        end
+
+        def activate(request, logger)
+          scenario_names = request.parameters[:name] ? [request.parameters[:name] ] : request.parameters[:names]
+          scenario_names.each { |name| request.session.activate_scenario!(name, logger) }
+          HttpStub::Server::Response::OK
+        rescue HttpStub::Server::Scenario::NotFoundError
+          HttpStub::Server::Response::NOT_FOUND
         end
 
         def clear(logger)

data/lib/http_stub/server/scenario/not_found_error.rb

@@ -0,0 +1,15 @@
+module HttpStub
+  module Server
+    module Scenario
+
+      class NotFoundError < ::StandardError
+
+        def initialize(name)
+          super("Scenario '#{name}' not found")
+        end
+
+      end
+
+    end
+  end
+end

data/lib/http_stub/server/session.rb

@@ -0,0 +1,14 @@
+module HttpStub
+  module Server
+
+    module Session
+
+      MEMORY_SESSION_ID        = "http_stub_memory".freeze
+      TRANSACTIONAL_SESSION_ID = "http_stub_transactional".freeze
+
+      ID_ATTRIBUTE_NAME = :http_stub_session_id
+
+    end
+
+  end
+end

data/lib/http_stub/server/session/configuration.rb

@@ -0,0 +1,32 @@
+module HttpStub
+  module Server
+    module Session
+
+      class Configuration
+
+        DEFAULT_CONFIGURATION = [
+          { parameter: HttpStub::Server::Session::ID_ATTRIBUTE_NAME },
+          { header:    HttpStub::Server::Session::ID_ATTRIBUTE_NAME }
+        ].freeze
+        DEFAULT_IDENTIFIER = HttpStub::Server::Session::MEMORY_SESSION_ID
+
+        private_constant :DEFAULT_CONFIGURATION, :DEFAULT_IDENTIFIER
+
+        attr_reader :identifier_configuration
+
+        attr_accessor :default_identifier
+
+        def initialize(identifier_setting)
+          @identifier_configuration = DEFAULT_CONFIGURATION + (identifier_setting ? [ identifier_setting ] : [])
+          @default_identifier       = DEFAULT_IDENTIFIER
+        end
+
+        def reset
+          @default_identifier = DEFAULT_IDENTIFIER
+        end
+
+      end
+
+    end
+  end
+end

data/lib/http_stub/server/session/controller.rb

@@ -0,0 +1,40 @@
+module HttpStub
+  module Server
+    module Session
+
+      class Controller
+
+        def initialize(session_configuration, server_memory)
+          @session_configuration = session_configuration
+          @server_memory         = server_memory
+        end
+
+        def find(request, logger)
+          @server_memory.sessions.find(request.session_id, logger)
+        end
+
+        def find_transactional(logger)
+          @server_memory.sessions.find(HttpStub::Server::Session::TRANSACTIONAL_SESSION_ID, logger)
+        end
+
+        def find_all
+          @server_memory.sessions.all
+        end
+
+        def mark_default(request)
+          @session_configuration.default_identifier = request.session_id
+        end
+
+        def delete(request, logger)
+          @server_memory.sessions.delete(request.session_id, logger)
+        end
+
+        def clear(logger)
+          @server_memory.sessions.clear(logger)
+        end
+
+      end
+
+    end
+  end
+end