http_stub 0.27.0 → 0.28.0.beta1

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

@@ -6,8 +6,7 @@ module HttpStub
         class RegexpValueMatcher
 
           def self.match?(stub_value, actual_value)
-            match_data = stub_value.match(/^regexp:(.*)/)
-            match_data && !!Regexp.new(match_data[1]).match(actual_value)
+            stub_value.is_a?(Regexp) && !!stub_value.match(actual_value)
           end
 
         end

data/lib/http_stub/server/stub/match/rule/body.rb

@@ -6,36 +6,14 @@ module HttpStub
 
           class Body
 
-            SCHEMA_PROPERTIES = %w{ type definition }.freeze
-
-            private_constant :SCHEMA_PROPERTIES
-
-            class << self
-
-              def create(body)
-                matcher = create_schema_body(body["schema"]) if body.is_a?(Hash) && body["schema"]
-                matcher ||= HttpStub::Server::Stub::Match::Rule::SimpleBody.new(body) if body.present?
-                matcher || HttpStub::Server::Stub::Match::Rule::Truthy
+            def self.create(body)
+              if body.is_a?(Hash)
+                HttpStub::Server::Stub::Match::Rule::SchemaBody.create(body.with_indifferent_access[:schema])
+              elsif body.present?
+                HttpStub::Server::Stub::Match::Rule::SimpleBody.new(body)
+              else
+                HttpStub::Server::Stub::Match::Rule::Truthy
               end
-
-              private
-
-              def create_schema_body(schema)
-                validate_schema_properties(schema)
-                begin
-                  body_class = HttpStub::Server::Stub::Match::Rule.const_get("#{schema["type"].capitalize}Body")
-                  body_class.new(schema["definition"])
-                rescue NameError
-                  raise "Stub request body schema #{schema} is invalid: #{schema["type"]} schema is not supported"
-                end
-              end
-
-              def validate_schema_properties(schema)
-                SCHEMA_PROPERTIES.each do |property|
-                  raise "Stub request body schema #{schema} is invalid: #{property} expected" unless schema[property]
-                end
-              end
-
             end
 
           end

data/lib/http_stub/server/stub/match/rule/{json_body.rb → json_schema_body.rb}

@@ -4,7 +4,7 @@ module HttpStub
       module Match
         module Rule
 
-          class JsonBody
+          class JsonSchemaBody
 
             def initialize(schema_definition)
               @schema_definition = schema_definition

data/lib/http_stub/server/stub/match/rule/method.rb

@@ -7,7 +7,7 @@ module HttpStub
           class Method
 
             def initialize(method)
-              @method = method
+              @method = method.try(:to_s).try(:upcase)
             end
 
             def matches?(request, _logger)

data/lib/http_stub/server/stub/match/rule/schema_body.rb

@@ -0,0 +1,39 @@
+module HttpStub
+  module Server
+    module Stub
+      module Match
+        module Rule
+
+          class SchemaBody
+
+            MANDATORY_ELEMENT_NAMES = %i{ type definition }.freeze
+
+            private_constant :MANDATORY_ELEMENT_NAMES
+
+            class << self
+
+              def create(schema)
+                validate(schema)
+                begin
+                  body_class = HttpStub::Server::Stub::Match::Rule.const_get("#{schema[:type].capitalize}SchemaBody")
+                  body_class.new(schema[:definition])
+                rescue NameError
+                  raise "Stub request body schema #{schema} is invalid: #{schema[:type]} schema is not supported"
+                end
+              end
+
+              def validate(schema)
+                MANDATORY_ELEMENT_NAMES.each do |name|
+                  raise "Stub request body schema #{schema} is invalid: #{name} expected" unless schema[name]
+                end
+              end
+
+            end
+
+          end
+
+        end
+      end
+    end
+  end
+end

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

@@ -8,14 +8,14 @@ module HttpStub
           attr_reader :uri, :method, :headers, :parameters, :body
 
           def initialize(args)
-            @uri        = HttpStub::Server::Stub::Match::Rule::Uri.new(args["uri"])
-            @method     = HttpStub::Server::Stub::Match::Rule::Method.new(args["method"])
-            @headers    = HttpStub::Server::Stub::Match::Rule::Headers.new(args["headers"])
-            @parameters = HttpStub::Server::Stub::Match::Rule::Parameters.new(args["parameters"])
-            @body       = HttpStub::Server::Stub::Match::Rule::Body.create(args["body"])
+            @uri        = HttpStub::Server::Stub::Match::Rule::Uri.new(args[:uri])
+            @method     = HttpStub::Server::Stub::Match::Rule::Method.new(args[:method])
+            @headers    = HttpStub::Server::Stub::Match::Rule::Headers.new(args[:headers])
+            @parameters = HttpStub::Server::Stub::Match::Rule::Parameters.new(args[:parameters])
+            @body       = HttpStub::Server::Stub::Match::Rule::Body.create(args[:body])
           end
 
-          EMPTY = self.new("uri" => "", "method" => "", "headers" => {}, "parameters" => {}, "body" => "").freeze
+          EMPTY = self.new(uri: "", method: "", headers: {}, parameters: {}, body: "").freeze
 
           def matches?(request, logger)
             [ @uri, @method, @headers, @parameters, @body ].all? { |matcher| matcher.matches?(request, logger) }

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

@@ -12,8 +12,7 @@ module HttpStub
           private_constant :MATCHERS
 
           def self.match?(stub_value, actual_value)
-            stub_match_value = stub_value ? stub_value.to_s : stub_value
-            !!MATCHERS.find { |matcher| matcher.match?(stub_match_value, actual_value) }
+            !!MATCHERS.find { |matcher| matcher.match?(stub_value, actual_value) }
           end
 
         end

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

@@ -8,13 +8,13 @@ module HttpStub
 
         alias_method :match, :find
 
-        def initialize(memory_session)
-          @memory_session = memory_session
-          @stub_registry  = HttpStub::Server::Registry.new("stub", memory_session.stubs)
+        def initialize(initial_stubs)
+          @initial_stubs = initial_stubs
+          @stub_registry = HttpStub::Server::Registry.new("stub", initial_stubs)
         end
 
         def reset(logger)
-          @stub_registry.replace(@memory_session.stubs, logger)
+          @stub_registry.replace(@initial_stubs, logger)
         end
 
       end

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

@@ -4,12 +4,8 @@ module HttpStub
 
       module Response
 
-        def self.create(args)
-          if args["body"].is_a?(Hash)
-            HttpStub::Server::Stub::Response::File.new(args)
-          else
-            HttpStub::Server::Stub::Response::Text.new(args)
-          end
+        def self.create(args={})
+          HttpStub::Server::Stub::Response::Response.new(args)
         end
 
       end

data/lib/http_stub/server/stub/response/blocks.rb

@@ -0,0 +1,33 @@
+module HttpStub
+  module Server
+    module Stub
+      module Response
+
+        class Blocks
+
+          delegate :each, to: :@blocks
+
+          def initialize(blocks)
+            @blocks = blocks || []
+          end
+
+          def evaluate_with(request)
+            @blocks.reduce({}) { |result, block| result.deep_merge(call_block(block, request)) }
+          end
+
+          def to_array
+            @blocks.map(&:source)
+          end
+
+          private
+
+          def call_block(block, request)
+            block.arity.zero? ? block.call : block.call(request)
+          end
+
+        end
+
+      end
+    end
+  end
+end

data/lib/http_stub/server/stub/response/body.rb

@@ -0,0 +1,21 @@
+module HttpStub
+  module Server
+    module Stub
+      module Response
+
+        class Body
+
+          def self.create(args)
+            if args[:body].is_a?(Hash)
+              HttpStub::Server::Stub::Response::FileBody.new(args[:body])
+            else
+              HttpStub::Server::Stub::Response::TextBody.new(args)
+            end
+          end
+
+        end
+
+      end
+    end
+  end
+end

data/lib/http_stub/server/stub/response/file_body.rb

@@ -0,0 +1,46 @@
+module HttpStub
+  module Server
+    module Stub
+      module Response
+
+        class FileBody
+
+          DEFAULT_HEADERS = { "content-type" => "application/octet-stream" }.freeze
+
+          private_constant :DEFAULT_HEADERS
+
+          attr_reader :uri
+
+          def initialize(hash)
+            @path = hash.dig(:file, :path)
+            @uri  = "file://#{@path}"
+          end
+
+          def headers
+            DEFAULT_HEADERS
+          end
+
+          def serve(application, response)
+            application.send_file(@path, send_options(response))
+          end
+
+          def to_s
+            @uri
+          end
+
+          private
+
+          def send_options(response)
+            headers = response.headers
+            { type: headers["content-type"] }.tap do |options|
+              options[:last_modified] = headers["last-modified"]       if headers["last-modified"]
+              options[:disposition]   = headers["content-disposition"] if headers["content-disposition"]
+            end
+          end
+
+        end
+
+      end
+    end
+  end
+end

data/lib/http_stub/server/stub/response/headers.rb

@@ -0,0 +1,24 @@
+module HttpStub
+  module Server
+    module Stub
+      module Response
+
+        class Headers < ::HashWithIndifferentAccess
+          include HttpStub::Extensions::Core::Hash::Formatted
+
+          def self.create(hash, body)
+            self.new(body.headers.merge(hash || {}))
+          end
+
+          private
+
+          def initialize(hash)
+            super(hash.stringify_keys, ":")
+          end
+
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,52 @@
+module HttpStub
+  module Server
+    module Stub
+      module Response
+
+        class Response
+
+          DEFAULT_ARGS = { status: 200, delay_in_seconds: 0 }.with_indifferent_access.freeze
+
+          private_constant :DEFAULT_ARGS
+
+          attr_reader :status, :body, :headers, :delay_in_seconds, :blocks
+
+          def initialize(args)
+            @original_args    = args
+            resolved_args     = DEFAULT_ARGS.merge(args)
+            @status           = resolved_args[:status]
+            @body             = HttpStub::Server::Stub::Response::Body.create(resolved_args)
+            @headers          = HttpStub::Server::Stub::Response::Headers.create(resolved_args[:headers], @body)
+            @delay_in_seconds = resolved_args[:delay_in_seconds]
+            @blocks           = HttpStub::Server::Stub::Response::Blocks.new(resolved_args[:blocks])
+          end
+
+          def with_values_from(request)
+            self.class.new(@original_args.merge(blocks: []).deep_merge(@blocks.evaluate_with(request)))
+          end
+
+          def serve_on(application)
+            sleep @delay_in_seconds
+            @body.serve(application, self)
+          end
+
+          def to_hash
+            {
+              status:           @status,
+              headers:          @headers,
+              body:             @body,
+              delay_in_seconds: @delay_in_seconds,
+              blocks:           @blocks.to_array
+            }
+          end
+
+          def to_json(*args)
+            self.to_hash.to_json(*args)
+          end
+
+        end
+
+      end
+    end
+  end
+end

data/lib/http_stub/server/stub/response/text_body.rb

@@ -0,0 +1,32 @@
+module HttpStub
+  module Server
+    module Stub
+      module Response
+
+        class TextBody
+
+          JSON_HEADERS = { "content-type" => "application/json" }.freeze
+
+          private_constant :JSON_HEADERS
+
+          attr_reader :headers, :text
+
+          def initialize(args={})
+            @headers = args[:json] ? JSON_HEADERS : {}
+            @text    = args[:json].try(:to_json) || args[:body] || ""
+          end
+
+          def serve(application, response)
+            application.halt(response.status, response.headers, @text)
+          end
+
+          def to_s
+            @text
+          end
+
+        end
+
+      end
+    end
+  end
+end

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

@@ -4,19 +4,19 @@ module HttpStub
 
       class Stub
 
-        attr_reader :uri, :match_rules, :response, :triggers
-
-        def initialize(args)
-          @id          = args["id"] || SecureRandom.uuid
-          @uri         = "#{args["base_uri"]}/http_stub/stubs/#{@id}"
-          @match_rules = HttpStub::Server::Stub::Match::Rules.new(args)
-          @response    = HttpStub::Server::Stub::Response.create(args["response"])
-          @triggers    = HttpStub::Server::Stub::Triggers.new(args["triggers"])
-          @description = args.to_s
+        attr_reader :stub_id, :uri, :match_rules, :response, :triggers
+
+        def initialize(hash)
+          @stub_id      = hash[:id]
+          @uri          = "/http_stub/stubs/#{@stub_id}"
+          @match_rules  = HttpStub::Server::Stub::Match::Rules.new(hash[:match_rules])
+          @response     = HttpStub::Server::Stub::Response.create(hash[:response])
+          @triggers     = HttpStub::Server::Stub::Triggers.new(hash[:triggers])
+          @description  = hash.to_s
         end
 
         def matches?(criteria, logger)
-          criteria.is_a?(String) ? criteria == @id : @match_rules.matches?(criteria, logger)
+          criteria.is_a?(String) ? criteria == @stub_id : @match_rules.matches?(criteria, logger)
         end
 
         def response_for(request)
@@ -24,7 +24,13 @@ module HttpStub
         end
 
         def to_json(*args)
-          { id: @id, uri: @uri, match_rules: @match_rules, response: @response, triggers: @triggers }.to_json(*args)
+          {
+            id:          @stub_id,
+            uri:         @uri,
+            match_rules: @match_rules,
+            response:    @response,
+            triggers:    @triggers
+          }.to_json(*args)
         end
 
         def to_s