http_stub 0.27.0 → 0.28.0.beta1

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

@@ -4,34 +4,13 @@ module HttpStub
 
       class Memory
 
-        DEFAULT_STATUS     = "Started".freeze
-        INITIALIZED_STATUS = "Initialized".freeze
+        attr_reader :scenario_registry, :stubs, :session_registry
 
-        SESSION_ID = HttpStub::Server::Session::MEMORY_SESSION_ID
-
-        private_constant :DEFAULT_STATUS, :INITIALIZED_STATUS, :SESSION_ID
-
-        attr_reader :status, :scenarios, :sessions
-
-        def initialize(session_configuration)
-          @status    = DEFAULT_STATUS
-          @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 initialized!
-          @status = INITIALIZED_STATUS
-        end
-
-        def stubs
-          @session.stubs
-        end
-
-        def reset(logger)
-          @scenarios.clear(logger)
-          @sessions.clear(logger)
-          @status = DEFAULT_STATUS
+        def initialize(configurator_state)
+          initial_state = HttpStub::Server::Memory::InitialState.new(configurator_state)
+          @scenario_registry = HttpStub::Server::Scenario::Registry.new(initial_state.load_scenarios)
+          @stubs             = initial_state.load_stubs(@scenario_registry)
+          @session_registry  = HttpStub::Server::Session::Registry.new(@scenario_registry, @stubs)
         end
 
       end

data/lib/http_stub/server/registry.rb

@@ -3,9 +3,11 @@ module HttpStub
 
     class Registry
 
+      delegate :find_all, to: :@models
+
       def initialize(model_name, models=[])
         @model_name = model_name
-        @models     = models
+        @models     = models.reverse
       end
 
       def add(model, logger)

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

@@ -4,15 +4,15 @@ module HttpStub
 
       class Factory
 
-        def initialize(session_configuration, server_memory)
+        def initialize(session_identifier_setting, server_memory)
+          @session_identifier_strategy = HttpStub::Server::Session::IdentifierStrategy.new(session_identifier_setting)
           @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)
+          session         = @server_memory.session_registry.find_or_create(session_id, logger)
           HttpStub::Server::Request::Request.new(sinatra_request, session_id, session)
         end
 

data/lib/http_stub/server/response.rb

@@ -3,15 +3,21 @@ module HttpStub
 
     class Response
 
-      def self.ok(opts={})
-        HttpStub::Server::Stub::Response::Text.new(
-          { "headers" => {}, "body" => "OK" }.merge(opts).merge("status" => 200)
-        )
+      class << self
+
+        def ok(opts={})
+          HttpStub::Server::Stub::Response.create({ body: "OK" }.merge(opts).merge(status: 200))
+        end
+
+        def invalid_request(cause)
+          HttpStub::Server::Stub::Response.create(status: 400, body: cause.to_s)
+        end
+
       end
 
       OK        = ok.freeze
-      NOT_FOUND = HttpStub::Server::Stub::Response::Text.new("status" => 404, "body" => "NOT FOUND").freeze
-      EMPTY     = HttpStub::Server::Stub::Response::Text.new.freeze
+      NOT_FOUND = HttpStub::Server::Stub::Response.create(status: 404, body: "NOT FOUND").freeze
+      EMPTY     = HttpStub::Server::Stub::Response.create.freeze
 
     end
 

data/lib/http_stub/server/scenario.rb

@@ -3,8 +3,8 @@ module HttpStub
 
     module Scenario
 
-      def self.create(args)
-        HttpStub::Server::Scenario::Scenario.new(args)
+      def self.create(hash)
+        HttpStub::Server::Scenario::Scenario.new(hash)
       end
 
     end

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

@@ -5,13 +5,7 @@ module HttpStub
       class Controller
 
         def initialize(server_memory)
-          @scenario_registry = server_memory.scenarios
-        end
-
-        def register(request, logger)
-          scenario = HttpStub::Server::Scenario.create(HttpStub::Server::Scenario::Parser.parse(request))
-          @scenario_registry.add(scenario, logger)
-          HttpStub::Server::Response::OK
+          @scenario_registry = server_memory.scenario_registry
         end
 
         def find(request, logger)
@@ -26,12 +20,8 @@ module HttpStub
           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)
-          @scenario_registry.clear(logger)
+        rescue HttpStub::Server::Scenario::NotFoundError => error
+          HttpStub::Server::Response.invalid_request(error)
         end
 
       end

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

@@ -0,0 +1,25 @@
+module HttpStub
+  module Server
+    module Scenario
+
+      class Registry
+
+        delegate :find, :find_all, :all, to: :@scenario_registry
+
+        def initialize(scenarios)
+          @scenario_registry = HttpStub::Server::Registry.new("scenario", scenarios)
+        end
+
+        def stubs_activated_by(scenario, logger)
+          scenario.stubs + scenario.triggered_scenarios.map(&:name).map do |triggered_scenario_name|
+            triggered_scenario = @scenario_registry.find(triggered_scenario_name, logger)
+            raise HttpStub::Server::Scenario::NotFoundError, triggered_scenario_name unless triggered_scenario
+            stubs_activated_by(triggered_scenario, logger)
+          end.flatten
+        end
+
+      end
+
+    end
+  end
+end

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

@@ -6,12 +6,17 @@ module HttpStub
 
         attr_reader :name, :links, :stubs, :triggered_scenarios
 
-        def initialize(args)
-          @args                = args
-          @name                = args["name"]
-          @links               = HttpStub::Server::Scenario::Links.new(@name)
-          @stubs               = create_stubs(args["stubs"])
-          @triggered_scenarios = create_triggers(args["triggered_scenario_names"])
+        def initialize(hash)
+          @args                     = hash
+          @name                     = hash[:name]
+          @links                    = HttpStub::Server::Scenario::Links.new(@name)
+          @initially_activated_flag = hash[:activated]
+          @stubs                    = create_stubs(hash[:stubs])
+          @triggered_scenarios      = create_triggers(hash[:triggered_scenario_names])
+        end
+
+        def initially_activated?
+          !!@initially_activated_flag
         end
 
         def matches?(name, _logger)
@@ -24,8 +29,8 @@ module HttpStub
 
         private
 
-        def create_stubs(stubs_args)
-          stubs_args.map { |stub_args| HttpStub::Server::Stub.create(stub_args) }
+        def create_stubs(stub_hashes)
+          stub_hashes.map { |hash| HttpStub::Server::Stub.create(hash) }
         end
 
         def create_triggers(scenario_names)

data/lib/http_stub/server/session.rb

@@ -3,7 +3,6 @@ module HttpStub
 
     module Session
 
-      MEMORY_SESSION_ID        = "http_stub_memory".freeze
       TRANSACTIONAL_SESSION_ID = "http_stub_transactional".freeze
 
       ID_ATTRIBUTE_NAME = :http_stub_session_id

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

@@ -4,29 +4,28 @@ module HttpStub
 
       class Controller
 
-        def initialize(session_configuration, server_memory)
-          @session_configuration = session_configuration
-          @server_memory         = server_memory
+        def initialize(server_memory)
+          @server_memory = server_memory
         end
 
         def find(request, logger)
-          @server_memory.sessions.find(request.session_id, logger)
+          @server_memory.session_registry.find(request.session_id, logger)
         end
 
         def find_transactional(logger)
-          @server_memory.sessions.find(HttpStub::Server::Session::TRANSACTIONAL_SESSION_ID, logger)
+          @server_memory.session_registry.find(HttpStub::Server::Session::TRANSACTIONAL_SESSION_ID, logger)
         end
 
         def find_all
-          @server_memory.sessions.all
+          @server_memory.session_registry.all
         end
 
         def delete(request, logger)
-          @server_memory.sessions.delete(request.session_id, logger)
+          @server_memory.session_registry.delete(request.session_id, logger)
         end
 
         def clear(logger)
-          @server_memory.sessions.clear(logger)
+          @server_memory.session_registry.clear(logger)
         end
 
       end

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

@@ -4,8 +4,15 @@ module HttpStub
 
       class IdentifierStrategy
 
-        def initialize(session_configuration)
-          @identifier_configuration = session_configuration.identifier_configuration
+        DEFAULT_CONFIGURATION = [
+          { parameter: HttpStub::Server::Session::ID_ATTRIBUTE_NAME },
+          { header:    HttpStub::Server::Session::ID_ATTRIBUTE_NAME }
+        ].freeze
+
+        private_constant :DEFAULT_CONFIGURATION
+
+        def initialize(identifier_setting)
+          @identifier_configuration = DEFAULT_CONFIGURATION + (identifier_setting ? [ identifier_setting ] : [])
         end
 
         def identifier_for(sinatra_request)

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

@@ -4,29 +4,23 @@ module HttpStub
 
       class Registry
 
-        delegate :find, :all, :delete, to: :@session_registry
+        delegate :find, :all, :delete, :clear, to: :@session_registry
 
-        def initialize(session_configuration, scenario_registry, memory_session)
-          @session_configuration = session_configuration
-          @scenario_registry     = scenario_registry
-          @memory_session        = memory_session
-          @session_registry      = HttpStub::Server::Registry.new("session", [ memory_session ])
+        def initialize(scenario_registry, initial_stubs)
+          @scenario_registry = scenario_registry
+          @initial_stubs     = initial_stubs
+          @session_registry  = HttpStub::Server::Registry.new("session")
         end
 
         def find_or_create(session_id, logger)
-          effective_session_id = session_id || @session_configuration.default_identifier
+          effective_session_id = session_id || HttpStub::Server::Session::TRANSACTIONAL_SESSION_ID
           @session_registry.find(effective_session_id, logger) || create(effective_session_id, logger)
         end
 
-        def clear(logger)
-          @memory_session.clear(logger)
-          @session_registry.replace([ @memory_session ], logger)
-        end
-
         private
 
         def create(session_id, logger)
-          HttpStub::Server::Session::Session.new(session_id, @scenario_registry, @memory_session).tap do |session|
+          HttpStub::Server::Session::Session.new(session_id, @scenario_registry, @initial_stubs).tap do |session|
             @session_registry.add(session, logger)
           end
         end

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

@@ -6,10 +6,10 @@ module HttpStub
 
         attr_reader :id
 
-        def initialize(id, scenario_registry, memory_session)
+        def initialize(id, scenario_registry, initial_stubs)
           @id                  = id
           @scenario_registry   = scenario_registry
-          @stub_registry       = HttpStub::Server::Stub::Registry.new(memory_session)
+          @stub_registry       = HttpStub::Server::Stub::Registry.new(initial_stubs)
           @stub_match_registry = HttpStub::Server::Registry.new("stub match")
           @stub_miss_registry  = HttpStub::Server::Registry.new("stub miss")
         end
@@ -21,8 +21,8 @@ module HttpStub
         def activate_scenario!(name, logger)
           found_scenario = @scenario_registry.find(name, logger)
           raise HttpStub::Server::Scenario::NotFoundError, name unless found_scenario
-          @stub_registry.concat(found_scenario.stubs, logger)
-          found_scenario.triggered_scenarios.each { |scenario| activate_scenario!(scenario.name, logger) }
+          activated_stubs = @scenario_registry.stubs_activated_by(found_scenario, logger)
+          @stub_registry.concat(activated_stubs, logger)
         end
 
         def add_stub(stub, logger)
@@ -69,10 +69,6 @@ module HttpStub
           @stub_registry.reset(logger)
         end
 
-        def clear(logger)
-          [ @stub_miss_registry, @stub_match_registry, @stub_registry ].each { |registry| registry.clear(logger) }
-        end
-
       end
 
     end

data/lib/http_stub/server/stdout_logger.rb

@@ -0,0 +1,13 @@
+module HttpStub
+  module Server
+
+    class StdoutLogger
+
+      def self.info(message)
+        puts message
+      end
+
+    end
+
+  end
+end

data/lib/http_stub/server/stub.rb

@@ -3,10 +3,11 @@ module HttpStub
 
     module Stub
 
-      def self.create(args)
-        HttpStub::Server::Stub::Stub.new(args)
+      def self.create(hash)
+        HttpStub::Server::Stub::Stub.new(hash)
       end
 
     end
+
   end
 end

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

@@ -4,12 +4,6 @@ module HttpStub
 
       class Controller
 
-        def register(request, logger)
-          stub = HttpStub::Server::Stub.create(HttpStub::Server::Stub::Parser.parse(request))
-          request.session.add_stub(stub, logger)
-          HttpStub::Server::Response.ok("headers" => { "location" => stub.uri })
-        end
-
         def match(request, logger)
           stub = request.session.match(request, logger)
           response = stub ? stub.response_for(request) : HttpStub::Server::Response::NOT_FOUND
@@ -30,10 +24,6 @@ module HttpStub
           request.session.reset(logger)
         end
 
-        def clear(request, logger)
-          request.session.clear(logger)
-        end
-
       end
 
     end

data/lib/http_stub/server/stub/empty.rb

@@ -7,6 +7,7 @@ module HttpStub
         private
 
         def initialize
+          @stub_id     = ""
           @uri         = ""
           @match_rules = HttpStub::Server::Stub::Match::Rules::EMPTY
           @response    = HttpStub::Server::Response::EMPTY
@@ -15,7 +16,7 @@ module HttpStub
 
         public
 
-        attr_reader :uri, :match_rules, :response, :triggers
+        attr_reader :stub_id, :uri, :match_rules, :response, :triggers
 
         def matches?(_criteria, _logger)
           false

data/lib/http_stub/server/stub/match/controller.rb

@@ -7,7 +7,7 @@ module HttpStub
 
           def last_match(request, logger)
             result = request.session.last_match(request.parameters.slice(:method, :uri), logger)
-            result ? HttpStub::Server::Response.ok("body" => result.to_json) : HttpStub::Server::Response::NOT_FOUND
+            result ? HttpStub::Server::Response.ok(body: result.to_json) : HttpStub::Server::Response::NOT_FOUND
           end
 
           def matches(request)

data/lib/http_stub/server/stub/match/exact_value_matcher.rb

@@ -6,7 +6,8 @@ module HttpStub
         class ExactValueMatcher
 
           def self.match?(stub_value, actual_value)
-            stub_value == actual_value
+            stub_match_value = stub_value && !stub_value.is_a?(Symbol) ? stub_value.to_s : stub_value
+            stub_match_value == actual_value
           end
 
         end

data/lib/http_stub/server/stub/match/omitted_value_matcher.rb

@@ -5,7 +5,7 @@ module HttpStub
 
         class OmittedValueMatcher
 
-          OMITTED_CONTROL_VALUE = "control:omitted".freeze
+          OMITTED_CONTROL_VALUE = :omitted
 
           private_constant :OMITTED_CONTROL_VALUE