openapi_parser 0.2.7 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2dd37ca24b93c63b4ccb98a693c9200f1850fca3349b5e70931aa40771bb31dc
-  data.tar.gz: c7d4e29d589c610554a8873a601d8eba674560267ccdb28a951ec120debbb0a0
+  metadata.gz: cc1cad9d7c07f7d5ce382429089820959ac182353a6b8daf545fc6408384af85
+  data.tar.gz: 00bef8afe01fbfddf5feceec03ef7bd1daba208ea0efce36b1413bbd2be28e32
 SHA512:
-  metadata.gz: a8c5ce03e3a6399403b3018f3fb5b6d3b0ff304989ac83a1c4aedb1a83709285f2a80abf90b25ac99ea5623474f7070239e62a918535f8798de2c73d1527c0fe
-  data.tar.gz: 85dda1a6fff6458ca87f462ede780a933448e05188e4d514c415abee3e36a365ba956e57684748c65103a83321a1760f5433ef9f909fcb5fc2178def664eccc9
+  metadata.gz: e9888a1912dc0ea3bace51771ee7524492bbb152a765b5c312c39bb94af3bfe17b108899c567377a1e1e51fc426804c94beb0bd0156d14561e9c1e7dc0229fe0
+  data.tar.gz: 95111afc9c980cc707cc81cfe4551ade4aadd0e24e69c9bb951d92c293806b63983e535a0ba7ea5d16f1c6bf8decb053f114c98b7114b00108c494972868e9cb

data/CHANGELOG.md

@@ -1,5 +1,14 @@
 ## Unreleased
 
+## 0.3.0 (2019-06-01)
+
+### features
+* Perform a strict check on object properties (#33)
+
+### Bugfix
+* Support discriminator without mapping (#35)
+* Fix upper case request param validation (#38)
+
 ## 0.2.7 (2019-05-20)
 * Fix for release miss
 

data/lib/openapi_parser/errors.rb

@@ -43,14 +43,25 @@ module OpenAPIParser
     end
   end
 
-  class NotExistDiscriminatorMappingTarget < OpenAPIError
-    def initialize(key, reference)
+  class NotExistPropertyDefinition < OpenAPIError
+    def initialize(keys, reference)
+      super(reference)
+      @keys = keys
+    end
+
+    def message
+      "properties #{@keys.join(",")} are not defined in #{@reference}"
+    end
+  end
+
+  class NotExistDiscriminatorMappedSchema < OpenAPIError
+    def initialize(mapped_schema_reference, reference)
       super(reference)
-      @key = key
+      @mapped_schema_reference = mapped_schema_reference
     end
 
     def message
-      "discriminator mapping key #{@key} does not exist in #{@reference}"
+      "discriminator mapped schema #{@mapped_schema_reference} does not exist in #{@reference}"
     end
   end
 

data/lib/openapi_parser/parameter_validator.rb

@@ -8,9 +8,9 @@ class OpenAPIParser::ParameterValidator
     def validate_parameter(parameters_hash, params, object_reference, options, is_header = false)
       no_exist_required_key = []
 
-      params_key_converted = params.keys.map { |k| [(is_header ? k&.downcase : k), k] }.to_h
+      params_key_converted = params.keys.map { |k| [convert_key(k, is_header), k] }.to_h
       parameters_hash.each do |k, v|
-        key = params_key_converted[k.downcase]
+        key = params_key_converted[convert_key(k, is_header)]
         if params.include?(key)
           coerced = v.validate_params(params[key], options)
           params[key] = coerced if options.coerce_value
@@ -23,5 +23,11 @@ class OpenAPIParser::ParameterValidator
 
       params
     end
+
+    private
+
+    def convert_key(k, is_header)
+      is_header ? k&.downcase : k
+    end
   end
 end

data/lib/openapi_parser/schema_validator.rb

@@ -18,7 +18,7 @@ class OpenAPIParser::SchemaValidator
   # @param [Object] value
   # @param [OpenAPIParser::Schemas::Schema] schema
   module Validatable
-    def validate_schema(value, schema)
+    def validate_schema(value, schema, **keyword_args)
       raise 'implement'
     end
 
@@ -66,11 +66,15 @@ class OpenAPIParser::SchemaValidator
   # validate value eby schema
   # @param [Object] value
   # @param [OpenAPIParser::Schemas::Schema] schema
-  def validate_schema(value, schema)
+  def validate_schema(value, schema, **keyword_args)
     return [value, nil] unless schema
 
     if (v = validator(value, schema))
-      return v.coerce_and_validate(value, schema)
+      if keyword_args.empty?
+        return v.coerce_and_validate(value, schema)
+      else
+        return v.coerce_and_validate(value, schema, **keyword_args)
+      end
     end
 
     # unknown return error

data/lib/openapi_parser/schema_validators/all_of_validator.rb

@@ -4,12 +4,31 @@ class OpenAPIParser::SchemaValidator
     # coerce and validate value
     # @param [Object] value
     # @param [OpenAPIParser::Schemas::Schema] schema
-    def coerce_and_validate(value, schema)
+    def coerce_and_validate(value, schema, **_keyword_args)
       # if any schema return error, it's not valida all of value
+      remaining_keys               = value.kind_of?(Hash) ? value.keys : []
+      nested_additional_properties = false
       schema.all_of.each do |s|
-        _coerced, err = validatable.validate_schema(value, s)
+        # We need to store the reference to all of, so we can perform strict check on allowed properties
+        _coerced, err = validatable.validate_schema(value, s, :parent_all_of => true)
+
+        if s.type == "object"
+          remaining_keys               -= (s.properties || {}).keys
+          nested_additional_properties = true if s.additional_properties
+        else
+          # If this is not allOf having array of objects inside, but e.g. having another anyOf/oneOf nested
+          remaining_keys.clear
+        end
+
         return [nil, err] if err
       end
+
+      # If there are nested additionalProperites, we allow not defined extra properties and lean on the specific
+      # additionalProperties validation
+      if !nested_additional_properties && !remaining_keys.empty?
+        return [nil, OpenAPIParser::NotExistPropertyDefinition.new(remaining_keys, schema.object_reference)]
+      end
+
       [value, nil]
     end
   end

data/lib/openapi_parser/schema_validators/any_of_validator.rb

@@ -2,7 +2,7 @@ class OpenAPIParser::SchemaValidator
   class AnyOfValidator < Base
     # @param [Object] value
     # @param [OpenAPIParser::Schemas::Schema] schema
-    def coerce_and_validate(value, schema)
+    def coerce_and_validate(value, schema, **_keyword_args)
       if schema.discriminator
         return validate_discriminator_schema(schema.discriminator, value)
       end

data/lib/openapi_parser/schema_validators/array_validator.rb

@@ -2,7 +2,7 @@ class OpenAPIParser::SchemaValidator
   class ArrayValidator < Base
     # @param [Array] value
     # @param [OpenAPIParser::Schemas::Schema] schema
-    def coerce_and_validate(value, schema)
+    def coerce_and_validate(value, schema, **_keyword_args)
       return OpenAPIParser::ValidateError.build_error_result(value, schema) unless value.kind_of?(Array)
 
       # array type have an schema in items property

data/lib/openapi_parser/schema_validators/base.rb

@@ -14,7 +14,7 @@ class OpenAPIParser::SchemaValidator
     # need override
     # @param [Array] _value
     # @param [OpenAPIParser::Schemas::Schema] _schema
-    def coerce_and_validate(_value, _schema)
+    def coerce_and_validate(_value, _schema, **_keyword_args)
       raise 'need implement'
     end
 
@@ -24,16 +24,17 @@ class OpenAPIParser::SchemaValidator
       end
       mapping_key = value[discriminator.property_name]
 
-      # TODO: it's allowed to have discriminator without mapping, then we need to lookup discriminator.property_name
+      # it's allowed to have discriminator without mapping, then we need to lookup discriminator.property_name
       # but the format is not the full path, just model name in the components
-      mapping_target = discriminator.mapping[mapping_key]
-      unless mapping_target
-        return [nil, OpenAPIParser::NotExistDiscriminatorMappingTarget.new(mapping_key, discriminator.object_reference)]
-      end
+      mapping_target = discriminator.mapping&.[](mapping_key) || "#/components/schemas/#{mapping_key}"
 
       # Find object does O(n) search at worst, then caches the result, so this is ok for repeated search
       resolved_schema = discriminator.root.find_object(mapping_target)
-      validatable.validate_schema(value, resolved_schema)
+
+      unless resolved_schema
+        return [nil, OpenAPIParser::NotExistDiscriminatorMappedSchema.new(mapping_target, discriminator.object_reference)]
+      end
+      validatable.validate_schema(value, resolved_schema, {discriminator_property_name: discriminator.property_name})
     end
   end
 end

data/lib/openapi_parser/schema_validators/boolean_validator.rb

@@ -3,7 +3,7 @@ class OpenAPIParser::SchemaValidator
     TRUE_VALUES = ['true', '1'].freeze
     FALSE_VALUES = ['false', '0'].freeze
 
-    def coerce_and_validate(value, schema)
+    def coerce_and_validate(value, schema, **_keyword_args)
       value = coerce(value) if @coerce_value
 
       return OpenAPIParser::ValidateError.build_error_result(value, schema) unless value.kind_of?(TrueClass) || value.kind_of?(FalseClass)

data/lib/openapi_parser/schema_validators/float_validator.rb

@@ -5,7 +5,7 @@ class OpenAPIParser::SchemaValidator
     # validate float value by schema
     # @param [Object] value
     # @param [OpenAPIParser::Schemas::Schema] schema
-    def coerce_and_validate(value, schema)
+    def coerce_and_validate(value, schema, **_keyword_args)
       value = coerce(value) if @coerce_value
 
       return validatable.validate_integer(value, schema) if value.kind_of?(Integer)

data/lib/openapi_parser/schema_validators/integer_validator.rb

@@ -5,7 +5,7 @@ class OpenAPIParser::SchemaValidator
     # validate integer value by schema
     # @param [Object] value
     # @param [OpenAPIParser::Schemas::Schema] schema
-    def coerce_and_validate(value, schema)
+    def coerce_and_validate(value, schema, **_keyword_args)
       value = coerce(value) if @coerce_value
 
       return OpenAPIParser::ValidateError.build_error_result(value, schema) unless value.kind_of?(Integer)

data/lib/openapi_parser/schema_validators/nil_validator.rb

@@ -2,7 +2,7 @@ class OpenAPIParser::SchemaValidator
   class NilValidator < Base
     # @param [Object] value
     # @param [OpenAPIParser::Schemas::Schema] schema
-    def coerce_and_validate(value, schema)
+    def coerce_and_validate(value, schema, **_keyword_args)
       return [value, nil] if schema.nullable
 
       [nil, OpenAPIParser::NotNullError.new(schema.object_reference)]

data/lib/openapi_parser/schema_validators/object_validator.rb

@@ -2,22 +2,40 @@ class OpenAPIParser::SchemaValidator
   class ObjectValidator < Base
     # @param [Hash] value
     # @param [OpenAPIParser::Schemas::Schema] schema
-    def coerce_and_validate(value, schema)
+    # @param [Boolean] parent_all_of true if component is nested under allOf
+    # @param [String, nil] discriminator_property_name discriminator.property_name to ignore checking additional_properties
+    def coerce_and_validate(value, schema, parent_all_of: false, discriminator_property_name: nil)
       return OpenAPIParser::ValidateError.build_error_result(value, schema) unless value.kind_of?(Hash)
 
       return [value, nil] unless schema.properties
 
       required_set = schema.required ? schema.required.to_set : Set.new
+      remaining_keys = value.keys
 
       coerced_values = value.map do |name, v|
         s = schema.properties[name]
-        coerced, err = validatable.validate_schema(v, s)
+        coerced, err = if s
+                         remaining_keys.delete(name)
+                         validatable.validate_schema(v, s)
+                       else
+                         # TODO: we need to perform a validation based on schema.additional_properties here, if
+                         # additionalProperties are defined
+                         [v, nil]
+                       end
+
         return [nil, err] if err
 
         required_set.delete(name)
         [name, coerced]
       end
 
+      remaining_keys.delete(discriminator_property_name) if discriminator_property_name
+
+      if !remaining_keys.empty? && !parent_all_of && !schema.additional_properties
+        # If object is nested in all of, the validation is already done in allOf validator. Or if
+        # additionalProperties are defined, we will validate using that
+        return [nil, OpenAPIParser::NotExistPropertyDefinition.new(remaining_keys, schema.object_reference)]
+      end
       return [nil, OpenAPIParser::NotExistRequiredKey.new(required_set.to_a, schema.object_reference)] unless required_set.empty?
 
       value.merge!(coerced_values.to_h) if @coerce_value

data/lib/openapi_parser/schema_validators/one_of_validator.rb

@@ -2,7 +2,7 @@ class OpenAPIParser::SchemaValidator
   class OneOfValidator < Base
     # @param [Object] value
     # @param [OpenAPIParser::Schemas::Schema] schema
-    def coerce_and_validate(value, schema)
+    def coerce_and_validate(value, schema, **_keyword_args)
       if schema.discriminator
         return validate_discriminator_schema(schema.discriminator, value)
       end

data/lib/openapi_parser/schema_validators/string_validator.rb

@@ -7,7 +7,7 @@ class OpenAPIParser::SchemaValidator
       @datetime_coerce_class = datetime_coerce_class
     end
 
-    def coerce_and_validate(value, schema)
+    def coerce_and_validate(value, schema, **_keyword_args)
       return OpenAPIParser::ValidateError.build_error_result(value, schema) unless value.kind_of?(String)
 
       value, err = check_enum_include(value, schema)

data/lib/openapi_parser/version.rb

@@ -1,3 +1,3 @@
 module OpenAPIParser
-  VERSION = '0.2.7'.freeze
+  VERSION = '0.3.0'.freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: openapi_parser
 version: !ruby/object:Gem::Version
-  version: 0.2.7
+  version: 0.3.0
 platform: ruby
 authors:
 - ota42y
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-05-20 00:00:00.000000000 Z
+date: 2019-06-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler