committee 3.0.0.alpha → 3.0.0.beta

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 2643d1595d38c9d9197a11c43ca05bb9a2da9c09
-  data.tar.gz: ebb69b45502334c6ad97d9d64a05d8f6855c5748
+SHA256:
+  metadata.gz: 5019abacff975df04498c8e2f04d04601dd6a99d1f3a621acafa6cf0873170fa
+  data.tar.gz: 0a08b6be4a680675cd985abf1fad733e55eee9a47368f852148cf732de5f68ff
 SHA512:
-  metadata.gz: f22b717d735d46455064a996423961f27c5115c15634f053397649d114c6759b229b5ce2eea09086c9f7733f270cfc342faf3bf1f77d6740130cb66b39e5f22e
-  data.tar.gz: c1bc25f4841bfb2e10567e9b20a18f51daadb7f8c2c55068c8954f31692f8b90e02fac5beec1ed91c813e8db77e4e44a8bd7afbbc73b902d243990f6b54cae18
+  metadata.gz: 179c89e72e306d1b79317a98ac7d3a1284edbecaaf13a04f9c7ab168724381988dfde7b4d45287c5f44d54f62d02296e959621f56038a55492e841e0d772021c
+  data.tar.gz: 9668d280fa56807e4101ac150dd04fdc280c0e0db4e04d17bbad26a031dca914388320f1dc7aaaefaeb6d4e41e11a01b51eb0f50254181a298df275eb6e50063

data/lib/committee/drivers/hyper_schema.rb

@@ -21,6 +21,10 @@ module Committee::Drivers
       false
     end
 
+    def default_validate_success_only
+      true
+    end
+
     def name
       :hyper_schema
     end
@@ -119,9 +123,11 @@ module Committee::Drivers
 
       attr_accessor :routes
 
+      attr_reader :validator_option
+
       def build_router(options)
-        validator_option = Committee::SchemaValidator::Option.new(options, self, :hyper_schema)
-        Committee::SchemaValidator::HyperSchema::Router.new(self, validator_option)
+        @validator_option = Committee::SchemaValidator::Option.new(options, self, :hyper_schema)
+        Committee::SchemaValidator::HyperSchema::Router.new(self, @validator_option)
       end
     end
 

data/lib/committee/drivers/open_api_2.rb

@@ -21,6 +21,10 @@ module Committee::Drivers
       false
     end
 
+    def default_validate_success_only
+      true
+    end
+
     def name
       :open_api_2
     end
@@ -208,10 +212,11 @@ module Committee::Drivers
       attr_accessor :definitions
       attr_accessor :produces
       attr_accessor :routes
+      attr_reader :validator_option
 
       def build_router(options)
-        validator_option = Committee::SchemaValidator::Option.new(options, self, :hyper_schema)
-        Committee::SchemaValidator::HyperSchema::Router.new(self, validator_option)
+        @validator_option = Committee::SchemaValidator::Option.new(options, self, :hyper_schema)
+        Committee::SchemaValidator::HyperSchema::Router.new(self, @validator_option)
       end
     end
 

data/lib/committee/drivers/open_api_3.rb

@@ -21,21 +21,26 @@ module Committee::Drivers
       true
     end
 
+    def default_validate_success_only
+      false
+    end
+
     def name
       :open_api_3
     end
 
-    # TODO: check it's need?
     def schema_class
       Committee::Drivers::OpenAPI3::Schema
     end
 
+    # @return [Committee::Drivers::OpenAPI3::Schema]
     def parse(open_api)
-      Schema.new(self, open_api)
+      schema_class.new(self, open_api)
     end
 
     class Schema < Committee::Drivers::Schema
       attr_reader :open_api
+      attr_reader :validator_option
 
       # @!attribute [r] open_api
       #   @return [OpenAPIParser::Schemas::OpenAPI]
@@ -54,8 +59,8 @@ module Committee::Drivers
       end
 
       def build_router(options)
-        validator_option = Committee::SchemaValidator::Option.new(options, self, :open_api_3)
-        Committee::SchemaValidator::OpenAPI3::Router.new(self, validator_option)
+        @validator_option = Committee::SchemaValidator::Option.new(options, self, :open_api_3)
+        Committee::SchemaValidator::OpenAPI3::Router.new(self, @validator_option)
       end
 
       # OpenAPI3 only

data/lib/committee/drivers.rb

@@ -15,6 +15,52 @@ module Committee
       end
     end
 
+    # load and build drive from JSON file
+    # @param [String] filepath
+    # @return [Committee::Driver]
+    def self.load_from_json(filepath)
+      load_from_data(JSON.parse(File.read(filepath)))
+    end
+
+    # load and build drive from YAML file
+    # @param [String] filepath
+    # @return [Committee::Driver]
+    def self.load_from_yaml(filepath)
+      load_from_data(YAML.load_file(filepath))
+    end
+
+    # load and build drive from file
+    # @param [String] filepath
+    # @return [Committee::Driver]
+    def self.load_from_file(filepath)
+      case File.extname(filepath)
+      when '.json'
+        load_from_json(filepath)
+      when '.yaml', '.yml'
+        load_from_yaml(filepath)
+      else
+        raise "committee filepath option support '.yaml', '.yml', '.json' files only"
+      end
+    end
+
+    # load and build drive from Hash object
+    # @param [Hash] hash
+    # @return [Committee::Driver]
+    def self.load_from_data(hash)
+      if hash['openapi'] == '3.0.0'
+        parser = OpenAPIParser.parse(hash)
+        return Committee::Drivers::OpenAPI3.new.parse(parser)
+      end
+
+      driver = if hash['swagger'] == '2.0'
+                 Committee::Drivers::OpenAPI2.new
+               else
+                 Committee::Drivers::HyperSchema.new
+               end
+
+      driver.parse(hash)
+    end
+
     # Driver is a base class for driver implementations.
     class Driver
       # Whether parameters that were form-encoded will be coerced by default.

data/lib/committee/middleware/base.rb

@@ -23,22 +23,20 @@ module Committee::Middleware
 
     class << self
       def get_schema(options)
-        open_api_3 = options[:open_api_3]
-        return open_api_3 if open_api_3
-
         schema = options[:schema]
+        unless schema
+          schema = Committee::Drivers::load_from_file(options[:filepath]) if options[:filepath]
 
-        if schema
-          # Expect the type we want by now. If we don't have it, the user passed
-          # something else non-standard in.
-          if !schema.is_a?(Committee::Drivers::Schema)
-            raise ArgumentError, "Committee: schema expected to be an instance of Committee::Drivers::Schema."
-          end
+          raise(ArgumentError, "Committee: need option `schema` or `filepath`") unless schema
+        end
 
-          return schema
+        # Expect the type we want by now. If we don't have it, the user passed
+        # something else non-standard in.
+        if !schema.is_a?(Committee::Drivers::Schema)
+          raise ArgumentError, "Committee: schema expected to be an instance of Committee::Drivers::Schema."
         end
 
-        raise(ArgumentError, "Committee: need option `schema` or `open_api_3`")
+        return schema
       end
     end
 

data/lib/committee/middleware/response_validation.rb

@@ -1,10 +1,11 @@
 module Committee::Middleware
   class ResponseValidation < Base
-    attr_reader :validate_errors
+    attr_reader :validate_success_only
 
     def initialize(app, options = {})
       super
-      @validate_errors = options[:validate_errors]
+      @validate_success_only = @schema.validator_option.validate_success_only
+
       @error_handler = options[:error_handler]
     end
 
@@ -12,7 +13,7 @@ module Committee::Middleware
       status, headers, response = @app.call(request.env)
 
       v = build_schema_validator(request)
-      v.response_validate(status, headers, response) if v.link_exist? && validate?(status)
+      v.response_validate(status, headers, response) if v.link_exist? && self.class.validate?(status, validate_success_only)
 
       [status, headers, response]
     rescue Committee::InvalidResponse
@@ -25,8 +26,10 @@ module Committee::Middleware
       @error_class.new(500, :invalid_response, "Response wasn't valid JSON.").render
     end
 
-    def validate?(status)
-      status != 204 and validate_errors || (200...300).include?(status)
+    class << self
+      def validate?(status, validate_success_only)
+        status != 204 && (!validate_success_only || (200...300).include?(status))
+      end
     end
   end
 end

data/lib/committee/request_unpacker.rb

@@ -88,11 +88,14 @@ module Committee
 
     def headers
       env = @request.env
-      env.keys.grep(/HTTP_/).inject({}) do |headers, key|
+      base = env.keys.grep(/HTTP_/).inject({}) do |headers, key|
         headerized_key = key.gsub(/^HTTP_/, '').gsub(/_/, '-')
         headers[headerized_key] = env[key]
         headers
       end
+
+      base.merge!('Content-Type' => env['CONTENT_TYPE']) if env['CONTENT_TYPE']
+      base
     end
   end
 end

data/lib/committee/{parameter_coercer.rb → schema_validator/hyper_schema/parameter_coercer.rb}

@@ -1,6 +1,5 @@
-# TODO: Support OpenAPI3
 module Committee
-  class ParameterCoercer
+  class SchemaValidator::HyperSchema::ParameterCoercer
     def initialize(params, schema, options = {})
       @params = params
       @schema = schema

data/lib/committee/schema_validator/hyper_schema/request_validator.rb

@@ -27,12 +27,8 @@ module Committee
 
     private
 
-    def request_media_type(request)
-      request.content_type.to_s.split(";").first.to_s
-    end
-
     def check_content_type!(request, data)
-      content_type = request_media_type(request)
+      content_type = ::Committee::SchemaValidator.request_media_type(request)
       if content_type && @link.enc_type && !empty_request?(request)
         unless Rack::Mime.match?(content_type, @link.enc_type)
           raise Committee::InvalidRequest,

data/lib/committee/schema_validator/hyper_schema/response_validator.rb

@@ -1,20 +1,14 @@
 module Committee
   class SchemaValidator::HyperSchema::ResponseValidator
-    attr_reader :validate_errors
+    attr_reader :validate_success_only
 
     def initialize(link, options = {})
       @link = link
-      @validate_errors = options[:validate_errors]
+      @validate_success_only = options[:validate_success_only]
 
       @validator = JsonSchema::Validator.new(target_schema(link))
     end
 
-    def self.validate?(status, options = {})
-      validate_errors = options[:validate_errors]
-
-      status != 204 and validate_errors || (200...300).include?(status)
-    end
-
     def call(status, headers, data)
       unless status == 204 # 204 No Content
         response = Rack::Response.new(data, status, headers)
@@ -41,7 +35,7 @@ module Committee
         return if data == nil
       end
 
-      if self.class.validate?(status, validate_errors: validate_errors) && !@validator.validate(data)
+      if Committee::Middleware::ResponseValidation.validate?(status, validate_success_only) && !@validator.validate(data)
         errors = JsonSchema::SchemaError.aggregate(@validator.errors).join("\n")
         raise InvalidResponse, "Invalid response.\n\n#{errors}"
       end

data/lib/committee/schema_validator/hyper_schema/router.rb

@@ -25,7 +25,7 @@ module Committee
         else
           nil
         end
-      end.compact.sort.first
+      end.compact.sort_by(&:first).first
       link_with_matches.nil? ? nil : link_with_matches.slice(1, 2)
     end
 

data/lib/committee/schema_validator/hyper_schema.rb

@@ -25,15 +25,15 @@ class Committee::SchemaValidator
       parameter_coerce!(request, link, "rack.request.query_hash") if link_exist? && !request.GET.nil? && !link.schema.nil?
     end
 
-    def response_validate(status, headers, response)
+    def response_validate(status, headers, response, _test_method = false)
       return unless link_exist?
 
       full_body = ""
       response.each do |chunk|
         full_body << chunk
       end
-      data = JSON.parse(full_body)
-      Committee::SchemaValidator::HyperSchema::ResponseValidator.new(link, validate_errors: validator_option.validate_errors).call(status, headers, data)
+      data = full_body.empty? ? {} : JSON.parse(full_body)
+      Committee::SchemaValidator::HyperSchema::ResponseValidator.new(link, validate_success_only: validator_option.validate_success_only).call(status, headers, data)
     end
 
     def link_exist?
@@ -41,6 +41,7 @@ class Committee::SchemaValidator
     end
 
     def coerce_form_params(parameter)
+      return unless link_exist?
       return unless link.schema
       Committee::SchemaValidator::HyperSchema::StringParamsCoercer.new(parameter, link.schema).call!
     end
@@ -81,7 +82,7 @@ class Committee::SchemaValidator
       def parameter_coerce!(request, link, coerce_key)
         return unless link_exist?
 
-        Committee::ParameterCoercer.
+        Committee::SchemaValidator::HyperSchema::ParameterCoercer.
             new(request.env[coerce_key],
                 link.schema,
                 coerce_date_times: validator_option.coerce_date_times,

data/lib/committee/schema_validator/open_api_3/operation_wrapper.rb

@@ -20,31 +20,34 @@ module Committee
       request_operation.validate_path_params(options)
     end
 
-    def coerce_request_parameter(params, validator_option)
+    def coerce_request_parameter(params, headers, validator_option)
       options = build_openapi_parser_get_option(validator_option)
       return unless options.coerce_value
 
-      request_operation.validate_request_parameter(params, options)
+      request_operation.validate_request_parameter(params, headers, options)
     end
 
-    def validate_response_params(status_code, content_type, params)
-      return request_operation.validate_response_body(status_code, content_type, params)
+    # @param [Boolean] strict when not content_type or status code definition, raise error
+    def validate_response_params(status_code, headers, response_data, strict, check_header)
+      request_body = OpenAPIParser::RequestOperation::ValidatableResponseBody.new(status_code, response_data, headers)
+
+      return request_operation.validate_response_body(request_body, response_validate_options(strict, check_header))
     rescue OpenAPIParser::OpenAPIError => e
-      raise Committee::InvalidRequest.new(e.message)
+      raise Committee::InvalidResponse.new(e.message)
     end
 
-    def validate_request_params(params, validator_option)
+    def validate_request_params(params, headers, validator_option)
       ret, err = case request_operation.http_method
             when 'get'
-              validate_get_request_params(params, validator_option)
+              validate_get_request_params(params, headers, validator_option)
             when 'post'
-              validate_post_request_params(params, validator_option)
+              validate_post_request_params(params, headers, validator_option)
             when 'put'
-              validate_post_request_params(params, validator_option)
+              validate_post_request_params(params, headers, validator_option)
             when 'patch'
-              validate_post_request_params(params, validator_option)
+              validate_post_request_params(params, headers, validator_option)
             when 'delete'
-              validate_get_request_params(params, validator_option)
+              validate_get_request_params(params, headers, validator_option)
             else
               raise "Committee OpenAPI3 not support #{request_operation.http_method} method"
             end
@@ -52,6 +55,16 @@ module Committee
       ret
     end
 
+    def valid_request_content_type?(content_type)
+      if (request_body = request_operation.operation_object&.request_body)
+        !request_body.select_media_type(content_type).nil?
+      else
+        # if not exist request body object, all content_type allow.
+        # because request body object required content field so when it exists there're content type definition.
+        true
+      end
+    end
+
     private
 
     attr_reader :request_operation
@@ -63,36 +76,50 @@ module Committee
     def build_openapi_parser_path_option(validator_option)
       coerce_value = validator_option.coerce_path_params
       datetime_coerce_class = validator_option.coerce_date_times ? DateTime : nil
-      OpenAPIParser::SchemaValidator::Options.new(coerce_value: coerce_value,datetime_coerce_class: datetime_coerce_class)
+      validate_header = validator_option.check_header
+      OpenAPIParser::SchemaValidator::Options.new(coerce_value: coerce_value,
+                                                  datetime_coerce_class: datetime_coerce_class,
+                                                  validate_header: validate_header)
     end
 
     # @return [OpenAPIParser::SchemaValidator::Options]
     def build_openapi_parser_post_option(validator_option)
       coerce_value = validator_option.coerce_form_params
       datetime_coerce_class = validator_option.coerce_date_times ? DateTime : nil
-      OpenAPIParser::SchemaValidator::Options.new(coerce_value: coerce_value,datetime_coerce_class: datetime_coerce_class)
+      validate_header = validator_option.check_header
+      OpenAPIParser::SchemaValidator::Options.new(coerce_value: coerce_value,
+                                                  datetime_coerce_class: datetime_coerce_class,
+                                                  validate_header: validate_header)
     end
 
     # @return [OpenAPIParser::SchemaValidator::Options]
     def build_openapi_parser_get_option(validator_option)
       coerce_value = validator_option.coerce_query_params
       datetime_coerce_class = validator_option.coerce_date_times ? DateTime : nil
-      OpenAPIParser::SchemaValidator::Options.new(coerce_value: coerce_value,datetime_coerce_class: datetime_coerce_class)
+      validate_header = validator_option.check_header
+      OpenAPIParser::SchemaValidator::Options.new(coerce_value: coerce_value,
+                                                  datetime_coerce_class: datetime_coerce_class,
+                                                  validate_header: validate_header)
     end
 
-    def validate_get_request_params(params, validator_option)
+    def validate_get_request_params(params, headers, validator_option)
       # bad performance because when we coerce value, same check
-      request_operation.validate_request_parameter(params, build_openapi_parser_get_option(validator_option))
+      request_operation.validate_request_parameter(params, headers, build_openapi_parser_get_option(validator_option))
     rescue OpenAPIParser::OpenAPIError => e
       raise Committee::InvalidRequest.new(e.message)
     end
 
-    def validate_post_request_params(params, validator_option)
+    def validate_post_request_params(params, headers, validator_option)
+      content_type = headers['Content-Type'].to_s.split(";").first.to_s
+
       # bad performance because when we coerce value, same check
-      # TODO: support other content type
-        return request_operation.validate_request_body('application/json', params, build_openapi_parser_post_option(validator_option))
+      return request_operation.validate_request_body(content_type, params, build_openapi_parser_post_option(validator_option))
     rescue => e
       raise Committee::InvalidRequest.new(e.message)
     end
+
+    def response_validate_options(strict, check_header)
+      ::OpenAPIParser::SchemaValidator::ResponseValidateOptions.new(strict: strict, validate_header: check_header)
+    end
   end
 end

data/lib/committee/schema_validator/open_api_3/request_validator.rb

@@ -1,17 +1,27 @@
 module Committee
   class SchemaValidator::OpenAPI3::RequestValidator
+    # @param [SchemaValidator::OpenAPI3::OperationWrapper] operation_object
+    # @param [Committee::SchemaValidator::Option] validator_option
     def initialize(operation_object, validator_option:)
       @operation_object = operation_object
       @validator_option = validator_option
     end
 
     def call(request, params, headers)
-      # TODO: support @check_content_type
-      # check_content_type!(request, params) if @check_content_type
+      content_type = ::Committee::SchemaValidator.request_media_type(request)
+      check_content_type(request, content_type) if @validator_option.check_content_type
 
-      @operation_object.validate_request_params(params, @validator_option)
+      @operation_object.validate_request_params(params, headers, @validator_option)
+    end
+
+    private
+
+    def check_content_type(request, content_type)
+      # support post, put, patch only
+      return true unless request.post? || request.put? || request.patch?
+      return true if @operation_object.valid_request_content_type?(content_type)
 
-      # TODO: support header
+      raise Committee::InvalidRequest, %{"Content-Type" request header must be set to "#{@operation_object}".}
     end
   end
 end

data/lib/committee/schema_validator/open_api_3/response_validator.rb

@@ -1,35 +1,24 @@
 module Committee
   class SchemaValidator::OpenAPI3::ResponseValidator
-    attr_reader :validate_errors
+    attr_reader :validate_success_only
 
+    # @param [Committee::SchemaValidator::Options] validator_option
     # @param [Committee::SchemaValidator::OpenAPI3::OperationWrapper] operation_wrapper
     def initialize(operation_wrapper, validator_option)
       @operation_wrapper = operation_wrapper
-      @validate_errors = validator_option.validate_errors
+      @validate_success_only = validator_option.validate_success_only
+      @check_header = validator_option.check_header
     end
 
-    def self.validate?(status, options = {})
-      validate_errors = options[:validate_errors]
+    def call(status, headers, response_data, strict)
+      return unless Committee::Middleware::ResponseValidation.validate?(status, validate_success_only)
 
-      status != 204 && (validate_errors || (200...300).include?(status))
-    end
-
-    def call(status, headers, data)
-      return unless self.class.validate?(status, validate_errors: validate_errors)
-
-      content_type = headers['Content-Type'].to_s.split(";").first.to_s
-      operation_wrapper.validate_response_params(status, content_type, data)
+      #content_type = headers['Content-Type'].to_s.split(";").first.to_s
+      operation_wrapper.validate_response_params(status, headers, response_data, strict, check_header)
     end
 
     private
 
-    # @return [Committee::SchemaValidator::OpenAPI3::OperationWrapper]
-    attr_reader :operation_wrapper
-
-    def check_content_type!(response)
-      # TODO: fix
-      # OpenAPI3 support multi content type definitions, so we should get OperationObject by content type and this function don't need
-      # We should support if content exist and not exist content-type definition, raise error (if not exist content, we don't raise error)
-    end
+    attr_reader :operation_wrapper, :check_header
   end
 end

data/lib/committee/schema_validator/open_api_3/router.rb

@@ -1,15 +1,16 @@
 module Committee
   class SchemaValidator::OpenAPI3::Router
+    # @param [Committee::SchemaValidator::Option] validator_option
     def initialize(schema, validator_option)
       @schema = schema
-      @prefix = validator_option.prefix
+      @prefix_regexp = ::Committee::SchemaValidator.build_prefix_regexp(validator_option.prefix)
       @validator_option = validator_option
     end
 
     def includes_request?(request)
-      return true unless @prefix
-      #path = request.path
-      #path.start_with?(@prefix)
+      return true unless @prefix_regexp
+
+      prefix_request?(request)
     end
 
     def build_schema_validator(request)
@@ -18,9 +19,19 @@ module Committee
 
     def operation_object(request)
       path = request.path
+      path = path.gsub(@prefix_regexp, '') if prefix_request?(request)
+
       request_method = request.request_method.downcase
 
       @schema.operation_object(path, request_method)
     end
+
+    private
+
+    def prefix_request?(request)
+      return false unless @prefix_regexp
+
+      request.path =~ @prefix_regexp
+    end
   end
 end

data/lib/committee/schema_validator/open_api_3.rb

@@ -1,5 +1,6 @@
 class Committee::SchemaValidator
   class OpenAPI3
+    # @param [Committee::SchemaValidator::Option] validator_option
     def initialize(router, request, validator_option)
       @router = router
       @request = request
@@ -17,16 +18,20 @@ class Committee::SchemaValidator
 
       request_schema_validation(request)
 
-      @operation_object&.coerce_request_parameter(request.env["rack.request.query_hash"], validator_option) if !request.GET.nil? && !request.env["rack.request.query_hash"].empty?
+      @operation_object&.coerce_request_parameter(request.env["rack.request.query_hash"], header(request), validator_option) if !request.GET.nil? && !request.env["rack.request.query_hash"].empty?
     end
 
-    def response_validate(status, headers, response)
+    def response_validate(status, headers, response, test_method = false)
       full_body = ""
       response.each do |chunk|
         full_body << chunk
       end
-      data = JSON.parse(full_body)
-      Committee::SchemaValidator::OpenAPI3::ResponseValidator.new(@operation_object, validator_option).call(status, headers, data)
+      data = full_body.empty? ? {} : JSON.parse(full_body)
+
+      strict = test_method
+      Committee::SchemaValidator::OpenAPI3::ResponseValidator.
+          new(@operation_object, validator_option).
+          call(status, headers, data, strict)
     end
 
     def link_exist?
@@ -50,7 +55,11 @@ class Committee::SchemaValidator
       return unless @operation_object
 
       validator = Committee::SchemaValidator::OpenAPI3::RequestValidator.new(@operation_object, validator_option: validator_option)
-      validator.call(request, request.env[validator_option.params_key], request.env[validator_option.headers_key])
+      validator.call(request, request.env[validator_option.params_key], header(request))
+    end
+
+    def header(request)
+      request.env[validator_option.headers_key]
     end
 
     def request_unpack(request)

data/lib/committee/schema_validator/option.rb

@@ -1,6 +1,6 @@
 class Committee::SchemaValidator
   class Option
-    attr_reader :coerce_recursive, :params_key, :allow_form_params, :allow_query_params, :optimistic_json, :coerce_form_params, :headers_key, :coerce_query_params, :coerce_path_params, :check_content_type, :check_header, :coerce_date_times, :validate_errors, :prefix
+    attr_reader :coerce_recursive, :params_key, :allow_form_params, :allow_query_params, :optimistic_json, :coerce_form_params, :headers_key, :coerce_query_params, :coerce_path_params, :check_content_type, :check_header, :coerce_date_times, :prefix, :validate_success_only
 
     def initialize(options, schema, schema_type)
       @headers_key         = options[:headers_key] || "committee.headers"
@@ -9,7 +9,7 @@ class Committee::SchemaValidator
       @prefix              = options[:prefix]
 
       # response option
-      @validate_errors     = options[:validate_errors]
+      @validate_success_only = options.fetch(:validate_success_only, schema.driver.default_validate_success_only)
 
       @coerce_recursive    = options.fetch(:coerce_recursive, true)
       @allow_form_params   = options.fetch(:allow_form_params, true)
@@ -21,10 +21,7 @@ class Committee::SchemaValidator
       @coerce_query_params = options.fetch(:coerce_query_params, schema.driver.default_query_params)
       @coerce_path_params  = options.fetch(:coerce_path_params, schema.driver.default_path_params)
 
-      raise 'OpenAPI3 not support @check_content_type option' if schema_type == :open_api_3 && options[:check_content_type]
       @check_content_type  = options.fetch(:check_content_type, true)
-
-      raise 'OpenAPI3 not support @check_header option' if schema_type == :open_api_3 && options[:check_header]
       @check_header        = options.fetch(:check_header, true)
     end
   end