openapi_parser 2.3.1 → 2.5.0

data/lib/openapi_parser/spec_validator/rules/dynamic_ref_in_30.rb

@@ -0,0 +1,25 @@
+module OpenAPIParser
+  class SpecValidator
+    module Rules
+      # `$dynamicRef` is a JSON Schema 2020-12 referencing mechanism that
+      # 3.1 adopted. 3.0 does not recognize it. The parse layer keeps the
+      # value as raw schema data; this rule reports the version mismatch.
+      class DynamicRefIn30 < Rule
+        def check(root)
+          return [] unless version_before?('3.1')
+
+          violations = []
+          each_schema(root) do |schema|
+            next unless schema.raw_schema.is_a?(Hash) && schema.raw_schema.key?('$dynamicRef')
+
+            violations << violation(
+              path: schema.object_reference,
+              message: '`$dynamicRef` is a 3.1 addition (from JSON Schema 2020-12); 3.0 only knows `$ref`',
+            )
+          end
+          violations
+        end
+      end
+    end
+  end
+end

data/lib/openapi_parser/spec_validator/rules/example_singular_deprecation.rb

@@ -0,0 +1,25 @@
+module OpenAPIParser
+  class SpecValidator
+    module Rules
+      # In 3.1 the singular `example` keyword on a Schema is deprecated in
+      # favor of the JSON Schema `examples` array. The field is still
+      # allowed but discouraged, so we report it as a violation.
+      class ExampleSingularDeprecation < Rule
+        def check(root)
+          return [] unless version_at_least?('3.1')
+
+          violations = []
+          each_schema(root) do |schema|
+            next unless schema.raw_schema.is_a?(Hash) && schema.raw_schema.key?('example')
+
+            violations << violation(
+              path: schema.object_reference,
+              message: 'singular `example` on a Schema is deprecated in 3.1; use the `examples` array',
+            )
+          end
+          violations
+        end
+      end
+    end
+  end
+end

data/lib/openapi_parser/spec_validator/rules/exclusive_maximum.rb

@@ -0,0 +1,32 @@
+module OpenAPIParser
+  class SpecValidator
+    module Rules
+      class ExclusiveMaximum < Rule
+        def check(root)
+          return [] if version.nil?
+
+          violations = []
+          each_schema(root) do |schema|
+            value = schema.exclusiveMaximum
+            next if value.nil?
+
+            if version_before?('3.1')
+              if value.is_a?(Numeric)
+                violations << violation(
+                  path: schema.object_reference,
+                  message: 'numeric exclusiveMaximum is a 3.1-only form; in 3.0 use a Boolean modifier paired with `maximum`',
+                )
+              end
+            elsif value == true || value == false
+              violations << violation(
+                path: schema.object_reference,
+                message: 'Boolean exclusiveMaximum is a 3.0-only form; in 3.1 use a standalone numeric bound',
+              )
+            end
+          end
+          violations
+        end
+      end
+    end
+  end
+end

data/lib/openapi_parser/spec_validator/rules/exclusive_minimum.rb

@@ -0,0 +1,32 @@
+module OpenAPIParser
+  class SpecValidator
+    module Rules
+      class ExclusiveMinimum < Rule
+        def check(root)
+          return [] if version.nil?
+
+          violations = []
+          each_schema(root) do |schema|
+            value = schema.exclusiveMinimum
+            next if value.nil?
+
+            if version_before?('3.1')
+              if value.is_a?(Numeric)
+                violations << violation(
+                  path: schema.object_reference,
+                  message: 'numeric exclusiveMinimum is a 3.1-only form; in 3.0 use a Boolean modifier paired with `minimum`',
+                )
+              end
+            elsif value == true || value == false
+              violations << violation(
+                path: schema.object_reference,
+                message: 'Boolean exclusiveMinimum is a 3.0-only form; in 3.1 use a standalone numeric bound',
+              )
+            end
+          end
+          violations
+        end
+      end
+    end
+  end
+end

data/lib/openapi_parser/spec_validator/rules/json_schema_dialect_in_30.rb

@@ -0,0 +1,19 @@
+module OpenAPIParser
+  class SpecValidator
+    module Rules
+      # `jsonSchemaDialect` is a 3.1 root-level addition; 3.0 has no
+      # equivalent.
+      class JsonSchemaDialectIn30 < Rule
+        def check(root)
+          return [] unless version_before?('3.1')
+          return [] unless root.raw_schema.is_a?(Hash) && root.raw_schema.key?('jsonSchemaDialect')
+
+          [violation(
+            path: '#/jsonSchemaDialect',
+            message: '`jsonSchemaDialect` is a 3.1 root-level addition; 3.0 documents have no such field',
+          )]
+        end
+      end
+    end
+  end
+end

data/lib/openapi_parser/spec_validator/rules/nullable_deprecation.rb

@@ -0,0 +1,25 @@
+module OpenAPIParser
+  class SpecValidator
+    module Rules
+      # `nullable` is a 3.0 keyword that 3.1 removed in favor of
+      # `type: [..., "null"]`. The field's mere presence on a 3.1 document
+      # is a spec violation, regardless of true/false.
+      class NullableDeprecation < Rule
+        def check(root)
+          return [] unless version_at_least?('3.1')
+
+          violations = []
+          each_schema(root) do |schema|
+            next unless schema.raw_schema.is_a?(Hash) && schema.raw_schema.key?('nullable')
+
+            violations << violation(
+              path: schema.object_reference,
+              message: '`nullable` was removed in 3.1; use `type: [..., "null"]` instead',
+            )
+          end
+          violations
+        end
+      end
+    end
+  end
+end

data/lib/openapi_parser/spec_validator/rules/path_items_in_30.rb

@@ -0,0 +1,25 @@
+module OpenAPIParser
+  class SpecValidator
+    module Rules
+      # `components.pathItems` is a 3.1 addition. The parse layer accepts it
+      # in 3.0 documents permissively; this rule reports the version
+      # mismatch.
+      class PathItemsIn30 < Rule
+        def check(root)
+          return [] unless version_before?('3.1')
+
+          components = root.components
+          return [] unless components
+
+          raw = components.raw_schema
+          return [] unless raw.is_a?(Hash) && raw.key?('pathItems')
+
+          [violation(
+            path: "#{components.object_reference}/pathItems",
+            message: '`components.pathItems` is a 3.1 addition; 3.0 documents should not declare it',
+          )]
+        end
+      end
+    end
+  end
+end

data/lib/openapi_parser/spec_validator/rules/prefix_items_in_30.rb

@@ -0,0 +1,25 @@
+module OpenAPIParser
+  class SpecValidator
+    module Rules
+      # `prefixItems` is JSON Schema 2020-12's positional tuple keyword.
+      # 3.1 adopts it; 3.0 has no equivalent and parsing it is a spec
+      # mismatch the validator should report.
+      class PrefixItemsIn30 < Rule
+        def check(root)
+          return [] unless version_before?('3.1')
+
+          violations = []
+          each_schema(root) do |schema|
+            next unless schema.raw_schema.is_a?(Hash) && schema.raw_schema.key?('prefixItems')
+
+            violations << violation(
+              path: schema.object_reference,
+              message: '`prefixItems` is a 3.1 addition (from JSON Schema 2020-12); 3.0 has no equivalent',
+            )
+          end
+          violations
+        end
+      end
+    end
+  end
+end

data/lib/openapi_parser/spec_validator/rules/self_before_32.rb

@@ -0,0 +1,20 @@
+module OpenAPIParser
+  class SpecValidator
+    module Rules
+      # `$self` is a 3.2 root-level addition declaring the document's own
+      # URI for reference resolution. The parse layer accepts it
+      # permissively; this rule reports the version mismatch.
+      class SelfBefore32 < Rule
+        def check(root)
+          return [] unless version_before?('3.2')
+          return [] unless root.raw_schema.is_a?(Hash) && root.raw_schema.key?('$self')
+
+          [violation(
+            path: '#/$self',
+            message: '`$self` is a 3.2 root-level addition; earlier documents have no such field',
+          )]
+        end
+      end
+    end
+  end
+end

data/lib/openapi_parser/spec_validator/rules/type_array_in_30.rb

@@ -0,0 +1,25 @@
+module OpenAPIParser
+  class SpecValidator
+    module Rules
+      # 3.1 lets `type` be an Array of primitive type names (e.g.
+      # `["string", "null"]`). 3.0 only allowed a single String, so the
+      # array form on a 3.0 document is a spec violation.
+      class TypeArrayIn30 < Rule
+        def check(root)
+          return [] unless version_before?('3.1')
+
+          violations = []
+          each_schema(root) do |schema|
+            next unless schema.type.is_a?(Array)
+
+            violations << violation(
+              path: schema.object_reference,
+              message: '`type` as an Array of primitive names is a 3.1 addition; 3.0 expects a single type String',
+            )
+          end
+          violations
+        end
+      end
+    end
+  end
+end

data/lib/openapi_parser/spec_validator/rules/type_null_in_30.rb

@@ -0,0 +1,26 @@
+module OpenAPIParser
+  class SpecValidator
+    module Rules
+      # `type: "null"` was added by 3.1; 3.0 only allowed the original six
+      # primitive type names. The parse layer accepts the literal anyway,
+      # so we report the mismatch here. Array-form types like
+      # `["string", "null"]` are covered by a separate rule.
+      class TypeNullIn30 < Rule
+        def check(root)
+          return [] unless version_before?('3.1')
+
+          violations = []
+          each_schema(root) do |schema|
+            next unless schema.type == 'null'
+
+            violations << violation(
+              path: schema.object_reference,
+              message: '`type: "null"` is a 3.1 addition; 3.0 documents have no such primitive',
+            )
+          end
+          violations
+        end
+      end
+    end
+  end
+end

data/lib/openapi_parser/spec_validator/rules/webhooks_in_30.rb

@@ -0,0 +1,18 @@
+module OpenAPIParser
+  class SpecValidator
+    module Rules
+      # `webhooks` is a 3.1 root-level addition; 3.0 has no equivalent.
+      class WebhooksIn30 < Rule
+        def check(root)
+          return [] unless version_before?('3.1')
+          return [] unless root.raw_schema.is_a?(Hash) && root.raw_schema.key?('webhooks')
+
+          [violation(
+            path: '#/webhooks',
+            message: '`webhooks` is a 3.1 root-level addition; 3.0 documents have no such field',
+          )]
+        end
+      end
+    end
+  end
+end

data/lib/openapi_parser/spec_validator/spec_violation.rb

@@ -0,0 +1,11 @@
+module OpenAPIParser
+  class SpecValidator
+    SpecViolation = Struct.new(:message, :path, :rule_name, keyword_init: true) do
+      def to_s
+        "[#{rule_name}] #{path}: #{message}"
+      end
+    end
+  end
+
+  SpecViolation = SpecValidator::SpecViolation
+end

data/lib/openapi_parser/spec_validator.rb

@@ -0,0 +1,89 @@
+require_relative 'spec_validator/spec_violation'
+require_relative 'spec_validator/rule'
+require_relative 'spec_validator/rules/exclusive_minimum'
+require_relative 'spec_validator/rules/exclusive_maximum'
+require_relative 'spec_validator/rules/content_encoding_in_30'
+require_relative 'spec_validator/rules/content_media_type_in_30'
+require_relative 'spec_validator/rules/prefix_items_in_30'
+require_relative 'spec_validator/rules/boolean_schema_in_30'
+require_relative 'spec_validator/rules/json_schema_dialect_in_30'
+require_relative 'spec_validator/rules/type_array_in_30'
+require_relative 'spec_validator/rules/path_items_in_30'
+require_relative 'spec_validator/rules/nullable_deprecation'
+require_relative 'spec_validator/rules/example_singular_deprecation'
+require_relative 'spec_validator/rules/type_null_in_30'
+require_relative 'spec_validator/rules/webhooks_in_30'
+require_relative 'spec_validator/rules/const_in_30'
+require_relative 'spec_validator/rules/dynamic_ref_in_30'
+require_relative 'spec_validator/rules/dynamic_anchor_in_30'
+require_relative 'spec_validator/rules/content_schema_in_30'
+require_relative 'spec_validator/rules/self_before_32'
+
+module OpenAPIParser
+  class SpecViolationError < OpenAPIError
+    attr_reader :violations
+
+    def initialize(violations)
+      @violations = violations
+      super(nil)
+    end
+
+    def message
+      @violations.map(&:to_s).join("\n")
+    end
+  end
+
+  class SpecValidator
+    def self.run(root)
+      new(root).run
+    end
+
+    def self.run!(root, policy:)
+      return if policy == :silent
+
+      violations = run(root)
+      return if violations.empty?
+
+      case policy
+      when :warn
+        violations.each { |v| warn(v.to_s) }
+      when :raise
+        raise OpenAPIParser::SpecViolationError.new(violations)
+      end
+    end
+
+    def initialize(root)
+      @root = root
+      @version = root.openapi_version
+    end
+
+    def run
+      rules.flat_map { |klass| klass.new(@version).check(@root) }
+    end
+
+    private
+
+      def rules
+        [
+          Rules::ExclusiveMinimum,
+          Rules::ExclusiveMaximum,
+          Rules::ContentEncodingIn30,
+          Rules::ContentMediaTypeIn30,
+          Rules::PrefixItemsIn30,
+          Rules::BooleanSchemaIn30,
+          Rules::JsonSchemaDialectIn30,
+          Rules::TypeArrayIn30,
+          Rules::PathItemsIn30,
+          Rules::NullableDeprecation,
+          Rules::ExampleSingularDeprecation,
+          Rules::TypeNullIn30,
+          Rules::WebhooksIn30,
+          Rules::ConstIn30,
+          Rules::DynamicRefIn30,
+          Rules::DynamicAnchorIn30,
+          Rules::ContentSchemaIn30,
+          Rules::SelfBefore32,
+        ]
+      end
+  end
+end

data/lib/openapi_parser/version.rb

@@ -1,3 +1,3 @@
 module OpenAPIParser
-  VERSION = '2.3.1'.freeze
+  VERSION = '2.5.0'.freeze
 end

data/lib/openapi_parser.rb

@@ -15,6 +15,7 @@ require 'openapi_parser/request_operation'
 require 'openapi_parser/schema_validator'
 require 'openapi_parser/parameter_validator'
 require 'openapi_parser/reference_expander'
+require 'openapi_parser/spec_validator'
 
 module OpenAPIParser
   class << self
@@ -99,6 +100,8 @@ module OpenAPIParser
           path_item.set_path_item_to_operation
         end
 
+        OpenAPIParser::SpecValidator.run!(root, policy: config.strict_specification_version)
+
         root
       end
   end

data/sig/openapi_parser/config.rbs

@@ -15,6 +15,8 @@ module OpenAPIParser
     def expand_reference: -> bool
     def strict_response_validation: -> bool
     def strict_reference_validation: -> bool
+    KNOWN_STRICT_SPECIFICATION_VERSION_VALUES: Array[Symbol]
+    def strict_specification_version: -> (:silent | :warn | :raise)
     def validate_header: -> bool
     def request_validator_options: -> OpenAPIParser::SchemaValidator::Options
     def response_validate_options: -> OpenAPIParser::SchemaValidator::ResponseValidateOptions

data/sig/openapi_parser/schema_validator.rbs

@@ -27,6 +27,9 @@ module OpenAPIParser
 
     private
     def validator: (Object value, OpenAPIParser::Schemas::Schema schema) -> [OpenAPIParser::SchemaValidator::Base, OpenAPIParser::validate_error]
+    def validator_for_type: (String? type) -> OpenAPIParser::SchemaValidator::Base
+    def coerce_into_type_array?: (Object value, OpenAPIParser::Schemas::Schema schema) -> bool
+    def coerce_into_type_array: (Object value, OpenAPIParser::Schemas::Schema schema, **untyped) -> [Object, OpenAPIParser::validate_error]
     def string_validator: -> OpenAPIParser::SchemaValidator::StringValidator
     def integer_validator: -> OpenAPIParser::SchemaValidator::IntegerValidator
     def float_validator: -> OpenAPIParser::SchemaValidator::FloatValidator

data/sig/openapi_parser/spec_validator.rbs

@@ -0,0 +1,117 @@
+module OpenAPIParser
+  class SpecViolationError < OpenAPIError
+    @violations: Array[OpenAPIParser::SpecValidator::SpecViolation]
+    attr_reader violations: Array[OpenAPIParser::SpecValidator::SpecViolation]
+
+    def initialize: (Array[OpenAPIParser::SpecValidator::SpecViolation] violations) -> void
+    def message: () -> String
+  end
+
+  class SpecValidator
+    @root: OpenAPIParser::Schemas::OpenAPI
+    @version: Gem::Version?
+
+    def self.run: (OpenAPIParser::Schemas::OpenAPI root) -> Array[SpecViolation]
+    def self.run!: (OpenAPIParser::Schemas::OpenAPI root, policy: (:silent | :warn | :raise)) -> void
+    def initialize: (OpenAPIParser::Schemas::OpenAPI root) -> void
+    def run: () -> Array[SpecViolation]
+    private def rules: () -> Array[singleton(Rule)]
+
+    class SpecViolation < ::Struct[untyped]
+      attr_accessor message: String
+      attr_accessor path: String
+      attr_accessor rule_name: Symbol
+      def to_s: () -> String
+    end
+
+    class Rule
+      @version: Gem::Version?
+      attr_reader version: Gem::Version?
+
+      def self.rule_name: () -> Symbol
+      def initialize: (Gem::Version? version) -> void
+      def check: (OpenAPIParser::Schemas::OpenAPI root) -> Array[SpecViolation]
+      def version_before?: (String boundary) -> bool
+      def version_at_least?: (String boundary) -> bool
+      private def violation: (path: String, message: String) -> SpecViolation
+      private def each_schema: (untyped root) ?{ (untyped) -> void } -> untyped
+      private def walk: (untyped node, Hash[Integer, bool] visited) { (untyped) -> void } -> void
+    end
+
+    module Rules
+      class ExclusiveMinimum < Rule
+        def check: (OpenAPIParser::Schemas::OpenAPI root) -> Array[SpecValidator::SpecViolation]
+      end
+
+      class ExclusiveMaximum < Rule
+        def check: (OpenAPIParser::Schemas::OpenAPI root) -> Array[SpecValidator::SpecViolation]
+      end
+
+      class ContentEncodingIn30 < Rule
+        def check: (OpenAPIParser::Schemas::OpenAPI root) -> Array[SpecValidator::SpecViolation]
+      end
+
+      class ContentMediaTypeIn30 < Rule
+        def check: (OpenAPIParser::Schemas::OpenAPI root) -> Array[SpecValidator::SpecViolation]
+      end
+
+      class PrefixItemsIn30 < Rule
+        def check: (OpenAPIParser::Schemas::OpenAPI root) -> Array[SpecValidator::SpecViolation]
+      end
+
+      class BooleanSchemaIn30 < Rule
+        def check: (OpenAPIParser::Schemas::OpenAPI root) -> Array[SpecValidator::SpecViolation]
+      end
+
+      class JsonSchemaDialectIn30 < Rule
+        def check: (OpenAPIParser::Schemas::OpenAPI root) -> Array[SpecValidator::SpecViolation]
+      end
+
+      class TypeArrayIn30 < Rule
+        def check: (OpenAPIParser::Schemas::OpenAPI root) -> Array[SpecValidator::SpecViolation]
+      end
+
+      class PathItemsIn30 < Rule
+        def check: (OpenAPIParser::Schemas::OpenAPI root) -> Array[SpecValidator::SpecViolation]
+      end
+
+      class NullableDeprecation < Rule
+        def check: (OpenAPIParser::Schemas::OpenAPI root) -> Array[SpecValidator::SpecViolation]
+      end
+
+      class ExampleSingularDeprecation < Rule
+        def check: (OpenAPIParser::Schemas::OpenAPI root) -> Array[SpecValidator::SpecViolation]
+      end
+
+      class TypeNullIn30 < Rule
+        def check: (OpenAPIParser::Schemas::OpenAPI root) -> Array[SpecValidator::SpecViolation]
+      end
+
+      class WebhooksIn30 < Rule
+        def check: (OpenAPIParser::Schemas::OpenAPI root) -> Array[SpecValidator::SpecViolation]
+      end
+
+      class ConstIn30 < Rule
+        def check: (OpenAPIParser::Schemas::OpenAPI root) -> Array[SpecValidator::SpecViolation]
+      end
+
+      class DynamicRefIn30 < Rule
+        def check: (OpenAPIParser::Schemas::OpenAPI root) -> Array[SpecValidator::SpecViolation]
+      end
+
+      class DynamicAnchorIn30 < Rule
+        def check: (OpenAPIParser::Schemas::OpenAPI root) -> Array[SpecValidator::SpecViolation]
+      end
+
+      class ContentSchemaIn30 < Rule
+        def check: (OpenAPIParser::Schemas::OpenAPI root) -> Array[SpecValidator::SpecViolation]
+      end
+
+      class SelfBefore32 < Rule
+        def check: (OpenAPIParser::Schemas::OpenAPI root) -> Array[SpecValidator::SpecViolation]
+      end
+    end
+  end
+
+  SpecViolation: singleton(SpecValidator::SpecViolation)
+end

data/sig/openapi_parser.rbs

@@ -14,6 +14,8 @@ module OpenAPIParser
   module Schemas
     class OpenAPI
       def initialize: (Hash[bot, bot] hash, untyped config, uri: OpenAPIParser::readable_uri?, schema_registry: Hash[bot, bot]) -> OpenAPIParser::Schemas::OpenAPI
+      def openapi: () -> String?
+      def openapi_version: () -> Gem::Version?
     end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: openapi_parser
 version: !ruby/object:Gem::Version
-  version: 2.3.1
+  version: 2.5.0
 platform: ruby
 authors:
 - ota42y
@@ -188,6 +188,7 @@ files:
 - lib/openapi_parser/schema_validator/options.rb
 - lib/openapi_parser/schema_validator/properties_number.rb
 - lib/openapi_parser/schema_validator/string_validator.rb
+- lib/openapi_parser/schema_validator/type_mismatch_validator.rb
 - lib/openapi_parser/schema_validator/unspecified_type_validator.rb
 - lib/openapi_parser/schemas.rb
 - lib/openapi_parser/schemas/base.rb
@@ -207,6 +208,27 @@ files:
 - lib/openapi_parser/schemas/response.rb
 - lib/openapi_parser/schemas/responses.rb
 - lib/openapi_parser/schemas/schema.rb
+- lib/openapi_parser/spec_validator.rb
+- lib/openapi_parser/spec_validator/rule.rb
+- lib/openapi_parser/spec_validator/rules/boolean_schema_in_30.rb
+- lib/openapi_parser/spec_validator/rules/const_in_30.rb
+- lib/openapi_parser/spec_validator/rules/content_encoding_in_30.rb
+- lib/openapi_parser/spec_validator/rules/content_media_type_in_30.rb
+- lib/openapi_parser/spec_validator/rules/content_schema_in_30.rb
+- lib/openapi_parser/spec_validator/rules/dynamic_anchor_in_30.rb
+- lib/openapi_parser/spec_validator/rules/dynamic_ref_in_30.rb
+- lib/openapi_parser/spec_validator/rules/example_singular_deprecation.rb
+- lib/openapi_parser/spec_validator/rules/exclusive_maximum.rb
+- lib/openapi_parser/spec_validator/rules/exclusive_minimum.rb
+- lib/openapi_parser/spec_validator/rules/json_schema_dialect_in_30.rb
+- lib/openapi_parser/spec_validator/rules/nullable_deprecation.rb
+- lib/openapi_parser/spec_validator/rules/path_items_in_30.rb
+- lib/openapi_parser/spec_validator/rules/prefix_items_in_30.rb
+- lib/openapi_parser/spec_validator/rules/self_before_32.rb
+- lib/openapi_parser/spec_validator/rules/type_array_in_30.rb
+- lib/openapi_parser/spec_validator/rules/type_null_in_30.rb
+- lib/openapi_parser/spec_validator/rules/webhooks_in_30.rb
+- lib/openapi_parser/spec_validator/spec_violation.rb
 - lib/openapi_parser/version.rb
 - openapi_parser.gemspec
 - sig/openapi_parser.rbs
@@ -217,6 +239,7 @@ files:
 - sig/openapi_parser/schema_validators/base.rbs
 - sig/openapi_parser/schema_validators/options.rbs
 - sig/openapi_parser/schemas/base.rbs
+- sig/openapi_parser/spec_validator.rbs
 - sig/openapi_parser/version.rbs
 - sig/types.rbs
 - sig/wip_types.rbs
@@ -238,7 +261,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.9
+rubygems_version: 4.0.3
 specification_version: 4
 summary: OpenAPI3 parser
 test_files: []