openapi_parser 0.1.9 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: dd2a5c6292d86e914f641bf9d2e99b6ef8de9cbc46e5b3196937fc1c691541df
-  data.tar.gz: 9a6c9a5400e1fffdf12cc0e43fbc89433b7e4b917bd61dfb1c34c613bc17e9f4
+  metadata.gz: 778364824149b95c1f94de0e40d94b0cfc7d3743d85942adbc78f7796908323b
+  data.tar.gz: 9a352324f2945aab9d75298993cae3585e2577fb742efbae804826a38b5f8c7d
 SHA512:
-  metadata.gz: '0093301164855dba5aff9a87cdce0c8d99f85ac5c1c4738c011c850924704313b1fd6f9aee00f01f25e7a125b1d18c3d02659e8594eb6fa1bbd0da84e1bf3734'
-  data.tar.gz: 23b2105486befe12f39f90a9ea8f893b46a1dd36693782499b497ce1909ddef4a6b2d25da313cc62e3de8bf9a28246a5f140640fd9ff7869526ebfa05ea1a828
+  metadata.gz: 9b6899d6db1e2c7e2753e7c023e4abdb2ed99fc90f7fefad00ecd30127a127289c9330ef65e4d7f3931fcc917b07ca05f71625b13cf1d5c5610cfe48c3d767d8
+  data.tar.gz: e50ca8c2bc1e85ba4bb793615aaced3d111443348476a57e98278d6ea9492511156228b0a4648d82a92a2513f510f489e52bc7b773f1e3eb1acf39222ebf5a20

data/CHANGELOG.md

@@ -1,5 +1,8 @@
 ## Unreleased
 
+## 0.1.9 (2019-01-02)
+* support header validate (#18)
+
 ## 0.1.9 (2019-01-01)
 * add strict option (#17)
 

data/lib/openapi_parser/concern.rb

@@ -2,3 +2,4 @@ require_relative 'concerns/parser'
 require_relative 'concerns/findable'
 require_relative 'concerns/expandable'
 require_relative 'concerns/media_type_selectable'
+require_relative 'concerns/parameter_validatable'

data/lib/openapi_parser/concerns/media_type_selectable.rb

@@ -7,6 +7,7 @@ module OpenAPIParser::MediaTypeSelectable
     # @return [OpenAPIParser::Schemas::MediaType, nil]
     def select_media_type_from_content(content_type, content)
       return nil unless content_type
+      return nil unless content
 
       if (media_type = content[content_type])
         return media_type

data/lib/openapi_parser/concerns/parameter_validatable.rb

@@ -0,0 +1,56 @@
+module OpenAPIParser::ParameterValidatable
+  # @param [Hash] path_params path parameters
+  # @param [OpenAPIParser::SchemaValidator::Options] options request validator options
+  def validate_path_params(path_params, options)
+    OpenAPIParser::ParameterValidator.validate_parameter(path_parameter_hash, path_params, object_reference, options)
+  end
+
+  # @param [Hash] params parameter hash
+  # @param [Hash] headers headers hash
+  # @param [OpenAPIParser::SchemaValidator::Options] options request validator options
+  def validate_request_parameter(params, headers, options)
+    validate_header_parameter(headers, object_reference, options) if options.validate_header
+    validate_query_parameter(params, object_reference, options)
+  end
+
+  private
+
+    # @param [Hash] params query parameter hash
+    # @param [String] object_reference
+    # @param [OpenAPIParser::SchemaValidator::Options] options request validator options
+    def validate_query_parameter(params, object_reference, options)
+      OpenAPIParser::ParameterValidator.validate_parameter(query_parameter_hash, params, object_reference, options)
+    end
+
+    # @param [Hash] headers header hash
+    # @param [String] object_reference
+    # @param [OpenAPIParser::SchemaValidator::Options] options request validator options
+    def validate_header_parameter(headers, object_reference, options)
+      OpenAPIParser::ParameterValidator.validate_parameter(header_parameter_hash, headers, object_reference, options)
+    end
+
+    def header_parameter_hash
+      divided_parameter_hash['header'] || []
+    end
+
+    def path_parameter_hash
+      divided_parameter_hash['path'] || []
+    end
+
+    def query_parameter_hash
+      divided_parameter_hash['query'] || []
+    end
+
+    # @return [Hash{String => Hash{String => Parameter}}] hash[in][name] => Parameter
+    def divided_parameter_hash
+      @divided_parameter_hash ||=
+        (parameters || []).
+          group_by(&:in).
+          map { |in_type, params| # rubocop:disable Style/BlockDelimiters
+          [
+            in_type,
+            params.map { |param| [param.name, param] }.to_h,
+          ]
+        }.to_h
+    end
+end

data/lib/openapi_parser/config.rb

@@ -19,9 +19,15 @@ class OpenAPIParser::Config
     @config.fetch(:strict_response_validation, false)
   end
 
+  def validate_header
+    @config.fetch(:validate_header, true)
+  end
+
   # @return [OpenAPIParser::SchemaValidator::Options]
   def request_validator_options
-    @request_validator_options ||= OpenAPIParser::SchemaValidator::Options.new(coerce_value: coerce_value, datetime_coerce_class: datetime_coerce_class)
+    @request_validator_options ||= OpenAPIParser::SchemaValidator::Options.new(coerce_value: coerce_value,
+                                                                               datetime_coerce_class: datetime_coerce_class,
+                                                                               validate_header: validate_header)
   end
 
   alias_method :request_body_options, :request_validator_options
@@ -29,6 +35,7 @@ class OpenAPIParser::Config
 
   # @return [OpenAPIParser::SchemaValidator::ResponseValidateOptions]
   def response_validate_options
-    @response_validate_options ||= OpenAPIParser::SchemaValidator::ResponseValidateOptions.new(strict: strict_response_validation)
+    @response_validate_options ||= OpenAPIParser::SchemaValidator::ResponseValidateOptions.
+                                     new(strict: strict_response_validation, validate_header: validate_header)
   end
 end

data/lib/openapi_parser/path_item_finder.rb

@@ -7,13 +7,14 @@ class OpenAPIParser::PathItemFinder
     @paths.path.each { |path, _path_item_object| @root.register_path_node(path.split('/'), path) }
   end
 
+  # find operation object and if not exist return nil
   # @param [String, Symbol] http_method like (get, post .... allow symbol)
   # @param [String] request_path
-  # return operation_object, original_path, path_params
+  # @return [Result, nil]
   def operation_object(http_method, request_path)
     if (path_item_object = @paths.path[request_path])
       if (op = path_item_object.operation(http_method))
-        return op, request_path, {} # find no path_params path
+        return Result.new(path_item_object, op, request_path, {}) # find no path_params path
       end
     end
 
@@ -21,6 +22,26 @@ class OpenAPIParser::PathItemFinder
     parse_request_path(http_method, request_path)
   end
 
+  class Result
+    attr_reader :path_item_object, :operation_object, :original_path, :path_params
+    # @!attribute [r] path_item_object
+    #   @return [OpenAPIParser::Schemas::PathItem]
+    # @!attribute [r] operation_object
+    #   @return [OpenAPIParser::Schemas::Operation]
+    # @!attribute [r] path_params
+    #   @return [Hash{String => String}]
+    # @!attribute [r] original_path
+    #   @return [String]
+
+    def initialize(path_item_object, operation_object, original_path, path_params)
+      @path_item_object = path_item_object
+      @operation_object = operation_object
+      @original_path = original_path
+      @path_params = path_params
+    end
+  end
+
+  # path tree node
   class PathNode
     attr_accessor :full_path, :name
 
@@ -31,6 +52,8 @@ class OpenAPIParser::PathItemFinder
       @full_path = nil
     end
 
+    # @param [Array<string>] splited_path
+    # @param [String] full_path
     def register_path_node(splited_path, full_path)
       if splited_path.empty?
         @full_path = full_path
@@ -83,11 +106,12 @@ class OpenAPIParser::PathItemFinder
 
     def parse_request_path(http_method, request_path)
       original_path, path_params = @root.find_full_path(request_path.split('/'))
-      return nil, nil, {} unless original_path # # can't find
+      return nil unless original_path # # can't find
 
       path_item_object = @paths.path[original_path]
       obj = path_item_object.operation(http_method.to_s)
+      return nil unless obj
 
-      [obj, original_path, path_params]
+      Result.new(path_item_object, obj, original_path, path_params)
     end
 end

data/lib/openapi_parser/request_operation.rb

@@ -6,11 +6,10 @@ class OpenAPIParser::RequestOperation
     # @param [OpenAPIParser::PathItemFinder] path_item_finder
     # @return [OpenAPIParser::RequestOperation, nil]
     def create(http_method, request_path, path_item_finder, config)
-      operation, original_path, path_params = path_item_finder.operation_object(http_method, request_path)
+      result = path_item_finder.operation_object(http_method, request_path)
+      return nil unless result
 
-      return nil unless operation
-
-      self.new(http_method, original_path, operation, path_params, config)
+      self.new(http_method, result, config)
     end
   end
 
@@ -19,19 +18,24 @@ class OpenAPIParser::RequestOperation
   # @!attribute [r] path_params
   #   @return [Hash{String => String}]
   # @!attribute [r] config
-  #   #   @return [OpenAPIParser::Config]
+  #   @return [OpenAPIParser::Config]
   # @!attribute [r] http_method
   #   @return [String]
   # @!attribute [r] original_path
   #   @return [String]
-  attr_reader :operation_object, :path_params, :config, :http_method, :original_path
+  # @!attribute [r] path_item
+  #   @return [OpenAPIParser::Schemas::PathItem]
+  attr_reader :operation_object, :path_params, :config, :http_method, :original_path, :path_item
 
+  # @param [String] http_method
+  # @param [OpenAPIParser::PathItemFinder::Result] result
   # @param [OpenAPIParser::Config] config
-  def initialize(http_method, original_path, operation_object, path_params, config)
+  def initialize(http_method, result, config)
     @http_method = http_method.to_s
-    @original_path = original_path
-    @operation_object = operation_object
-    @path_params = path_params || {}
+    @original_path = result.original_path
+    @operation_object = result.operation_object
+    @path_params = result.path_params || {}
+    @path_item = result.path_item_object
     @config = config
   end
 
@@ -48,17 +52,34 @@ class OpenAPIParser::RequestOperation
     operation_object&.validate_request_body(content_type, params, options)
   end
 
-  # @param [String] content_type
-  # @param [Integer] status_code
-  # @param [Hash] data
+  # @param [OpenAPIParser::RequestOperation::ValidatableResponseBody] response_body
   # @param [OpenAPIParser::SchemaValidator::ResponseValidateOptions] response_validate_options
-  def validate_response_body(status_code, content_type, data, response_validate_options = nil)
+  def validate_response_body(response_body, response_validate_options = nil)
     response_validate_options ||= config.response_validate_options
-    operation_object&.validate_response_body(status_code, content_type, data, response_validate_options)
+
+    operation_object&.validate_response(response_body, response_validate_options)
   end
 
-  def validate_request_parameter(params, options = nil)
+  # @param [Hash] params parameter hash
+  # @param [Hash] headers headers hash
+  # @param [OpenAPIParser::SchemaValidator::Options] options request validator options
+  def validate_request_parameter(params, headers, options = nil)
     options ||= config.request_validator_options
-    operation_object&.validate_request_parameter(params, options)
+    path_item&.validate_request_parameter(params, headers, options)
+    operation_object&.validate_request_parameter(params, headers, options)
+  end
+
+  class ValidatableResponseBody
+    attr_reader :status_code, :response_data, :headers
+
+    def initialize(status_code, response_data, headers)
+      @status_code = status_code
+      @response_data = response_data
+      @headers = headers
+    end
+
+    def content_type
+      headers['Content-Type'].to_s.split(';').first.to_s
+    end
   end
 end

data/lib/openapi_parser/schema_validators/options.rb

@@ -4,11 +4,14 @@ class OpenAPIParser::SchemaValidator
     #   @return [Boolean] coerce value option on/off
     # @!attribute [r] datetime_coerce_class
     #   @return [Object, nil] coerce datetime string by this Object class
-    attr_reader :coerce_value, :datetime_coerce_class
+    # @!attribute [r] validate_header
+    #   @return [Boolean] validate header or not
+    attr_reader :coerce_value, :datetime_coerce_class, :validate_header
 
-    def initialize(coerce_value: nil, datetime_coerce_class: nil)
+    def initialize(coerce_value: nil, datetime_coerce_class: nil, validate_header: true)
       @coerce_value = coerce_value
       @datetime_coerce_class = datetime_coerce_class
+      @validate_header = validate_header
     end
   end
 
@@ -16,10 +19,11 @@ class OpenAPIParser::SchemaValidator
   class ResponseValidateOptions
     # @!attribute [r] strict
     #   @return [Boolean] validate by strict (when not exist definition, raise error)
-    attr_reader :strict
+    attr_reader :strict, :validate_header
 
-    def initialize(strict: false)
+    def initialize(strict: false, validate_header: true)
       @strict = strict
+      @validate_header = validate_header
     end
   end
 end

data/lib/openapi_parser/schemas.rb

@@ -13,3 +13,4 @@ require_relative 'schemas/responses'
 require_relative 'schemas/components'
 require_relative 'schemas/media_type'
 require_relative 'schemas/schema'
+require_relative 'schemas/header'

data/lib/openapi_parser/schemas/classes.rb

@@ -14,4 +14,5 @@ module OpenAPIParser::Schemas
   class MediaType < Base; end
   class Schema < Base; end
   class Components < Base; end
+  class Header < Base; end
 end

data/lib/openapi_parser/schemas/components.rb

@@ -1,5 +1,4 @@
 # TODO: examples
-# TODO: headers
 # TODO: securitySchemes
 # TODO: links
 # TODO: callbacks
@@ -21,5 +20,9 @@ module OpenAPIParser::Schemas
     # @!attribute [r] request_bodies
     #   @return [Hash{String => RequestBody}, nil]
     openapi_attr_hash_object :request_bodies, RequestBody, reference: true, schema_key: :requestBodies
+
+    # @!attribute [r] headers
+    #   @return [Hash{String => Header}, nil] header objects
+    openapi_attr_hash_object :headers, Header, reference: true
   end
 end

data/lib/openapi_parser/schemas/header.rb

@@ -0,0 +1,18 @@
+module OpenAPIParser::Schemas
+  class Header < Base
+    openapi_attr_values :description, :required, :deprecated, :style, :explode, :example
+
+    openapi_attr_value :allow_empty_value, schema_key: :allowEmptyValue
+    openapi_attr_value :allow_reserved, schema_key: :allowReserved
+
+    # @!attribute [r] schema
+    #   @return [Schema, Reference, nil]
+    openapi_attr_object :schema, Schema, reference: true
+
+    # validate by schema
+    # @param [Object] value
+    def validate(value)
+      OpenAPIParser::SchemaValidator.validate(value, schema, OpenAPIParser::SchemaValidator::Options.new)
+    end
+  end
+end

data/lib/openapi_parser/schemas/operation.rb

@@ -5,6 +5,8 @@
 
 module OpenAPIParser::Schemas
   class Operation < Base
+    include OpenAPIParser::ParameterValidatable
+
     openapi_attr_values :tags, :summary, :description, :deprecated
 
     openapi_attr_value :operation_id, schema_key: :operationId
@@ -23,37 +25,10 @@ module OpenAPIParser::Schemas
       request_body&.validate_request_body(content_type, params, options)
     end
 
-    # @param [String] content_type
-    # @param [Integer] status_code
-    # @param [Hash] data
+    # @param [OpenAPIParser::RequestOperation::ValidatableResponseBody] response_body
     # @param [OpenAPIParser::SchemaValidator::ResponseValidateOptions] response_validate_options
-    def validate_response_body(status_code, content_type, data, response_validate_options)
-      responses&.validate_response_body(status_code, content_type, data, response_validate_options)
-    end
-
-    # @param [OpenAPIParser::SchemaValidator::Options] options
-    def validate_request_parameter(params, options)
-      OpenAPIParser::ParameterValidator.validate_parameter(query_parameter_hash, params, object_reference, options)
+    def validate_response(response_body, response_validate_options)
+      responses&.validate(response_body, response_validate_options)
     end
-
-    def validate_path_params(path_params, options)
-      OpenAPIParser::ParameterValidator.validate_parameter(path_parameter_hash, path_params, object_reference, options)
-    end
-
-    private
-
-      def path_parameter_hash
-        @path_parameter_hash ||= (parameters || []).
-                                   select(&:in_path?).
-                                   map { |param| [param.name, param] }.
-                                   to_h
-      end
-
-      def query_parameter_hash
-        @query_parameter_hash ||= (parameters || []).
-                                    select(&:in_query?).
-                                    map { |param| [param.name, param] }.
-                                    to_h
-      end
   end
 end

data/lib/openapi_parser/schemas/parameter.rb

@@ -11,14 +11,6 @@ module OpenAPIParser::Schemas
     #   @return [Schema, Reference, nil]
     openapi_attr_object :schema, Schema, reference: true
 
-    def in_query?
-      self.in == 'query'
-    end
-
-    def in_path?
-      self.in == 'path'
-    end
-
     # @return [Object] coerced or original params
     # @param [OpenAPIParser::SchemaValidator::Options] options
     def validate_params(params, options)

data/lib/openapi_parser/schemas/path_item.rb

@@ -3,6 +3,8 @@
 
 module OpenAPIParser::Schemas
   class PathItem < Base
+    include OpenAPIParser::ParameterValidatable
+
     openapi_attr_values :summary, :description
 
     openapi_attr_objects :get, :put, :post, :delete, :options, :head, :patch, :trace, Operation

data/lib/openapi_parser/schemas/response.rb

@@ -1,4 +1,3 @@
-# TODO: headers
 # TODO: links
 
 module OpenAPIParser::Schemas
@@ -11,11 +10,16 @@ module OpenAPIParser::Schemas
     #   @return [Hash{String => MediaType}, nil] content_type to MediaType hash
     openapi_attr_hash_object :content, MediaType, reference: false
 
-    # @param [String] content_type
-    # @param [Hash] params
+    # @!attribute [r] headers
+    #   @return [Hash{String => Header}, nil] header string to Header
+    openapi_attr_hash_object :headers, Header, reference: true
+
+    # @param [OpenAPIParser::RequestOperation::ValidatableResponseBody] response_body
     # @param [OpenAPIParser::SchemaValidator::ResponseValidateOptions] response_validate_options
-    def validate_parameter(content_type, params, response_validate_options)
-      media_type = select_media_type(content_type)
+    def validate(response_body, response_validate_options)
+      validate_header(response_body.headers) if response_validate_options.validate_header
+
+      media_type = select_media_type(response_body.content_type)
       unless media_type
         raise ::OpenAPIParser::NotExistContentTypeDefinition, object_reference if response_validate_options.strict
 
@@ -23,7 +27,7 @@ module OpenAPIParser::Schemas
       end
 
       options = ::OpenAPIParser::SchemaValidator::Options.new # response validator not support any options
-      media_type.validate_parameter(params, options)
+      media_type.validate_parameter(response_body.response_data, options)
     end
 
     # select media type by content_type (consider wild card definition)
@@ -32,5 +36,19 @@ module OpenAPIParser::Schemas
     def select_media_type(content_type)
       select_media_type_from_content(content_type, content)
     end
+
+    private
+
+      # @param [Hash] response_headers
+      def validate_header(response_headers)
+        return unless headers
+
+        headers.each do |k, v|
+          h = response_headers[k]
+          next unless h
+
+          v.validate(h)
+        end
+      end
   end
 end

data/lib/openapi_parser/schemas/responses.rb

@@ -13,15 +13,14 @@ module OpenAPIParser::Schemas
     # validate params data by definition
     # find response object by status_code and content_type
     # https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.0.2.md#patterned-fields-1
-    # @param [Integer] status_code
-    # @param [String] content_type
-    # @param [Hash] params
+    # @param [OpenAPIParser::RequestOperation::ValidatableResponseBody] response_body
     # @param [OpenAPIParser::SchemaValidator::ResponseValidateOptions] response_validate_options
-    def validate_response_body(status_code, content_type, params, response_validate_options)
+    def validate(response_body, response_validate_options)
       return nil unless response
 
-      if (res = find_response_object(status_code))
-        return res.validate_parameter(content_type, params, response_validate_options)
+      if (res = find_response_object(response_body.status_code))
+
+        return res.validate(response_body, response_validate_options)
       end
 
       raise ::OpenAPIParser::NotExistStatusCodeDefinition, object_reference if response_validate_options.strict

data/lib/openapi_parser/version.rb

@@ -1,3 +1,3 @@
 module OpenAPIParser
-  VERSION = '0.1.9'.freeze
+  VERSION = '0.2.0'.freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: openapi_parser
 version: !ruby/object:Gem::Version
-  version: 0.1.9
+  version: 0.2.0
 platform: ruby
 authors:
 - ota42y
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-01-01 00:00:00.000000000 Z
+date: 2019-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -147,6 +147,7 @@ files:
 - lib/openapi_parser/concerns/expandable.rb
 - lib/openapi_parser/concerns/findable.rb
 - lib/openapi_parser/concerns/media_type_selectable.rb
+- lib/openapi_parser/concerns/parameter_validatable.rb
 - lib/openapi_parser/concerns/parser.rb
 - lib/openapi_parser/concerns/parser/core.rb
 - lib/openapi_parser/concerns/parser/hash.rb
@@ -185,6 +186,7 @@ files:
 - lib/openapi_parser/schemas/base.rb
 - lib/openapi_parser/schemas/classes.rb
 - lib/openapi_parser/schemas/components.rb
+- lib/openapi_parser/schemas/header.rb
 - lib/openapi_parser/schemas/media_type.rb
 - lib/openapi_parser/schemas/openapi.rb
 - lib/openapi_parser/schemas/operation.rb