committee 4.99.1 → 5.0.0.beta1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d369a9be7988a151dbd3b7d9f0065cc821ffcdc8e2543b95355b22fb1f93f6b8
-  data.tar.gz: 356fa03d1f3405544d7251302f012f48c0587c31c09b60f2509bdf7776e0c95c
+  metadata.gz: 4257522fd7e79dceca7f4ee846f35d8eea30f70a4a2a9ab1f9e99a946eb992f6
+  data.tar.gz: c71c15566465b608e72380c47ad3beceb9195d47949c234c1fbb0f99b0ebc22a
 SHA512:
-  metadata.gz: 6c821b9f35b1eb20ebea532e8cbc901295596136ccdd680c34ee6eed48da8858c2a22a754a52812cc66de43598f90515ec8642753cb4d3e46390dfd3f840b6a4
-  data.tar.gz: 6b720c3e1e2c25e7f8682ba4b8db3879d552a943ec7739d6686baa62b5c4985f609643ed43db67b135025d76e7bde7ff767629ae57b5da27b82107dc6a325629
+  metadata.gz: ca98156c131a991a05fc12f4bb149e2d740c6083befb91b96874ac27b2fdc923109e452f64d35f3e8bb0e92bd3c19575171013f8529ef95437bbd3b51335d1a4
+  data.tar.gz: a623459fca01819e67403a3ba73b4e7cf3997d01c48b6c21f71f87ca51b9f6eddf3e3e413be25678d684042cb94b991a75c5432ea85cec07af7f07696accaa94

data/lib/committee/drivers/hyper_schema/schema.rb

@@ -12,8 +12,8 @@ module Committee
 
         attr_reader :validator_option
 
-        def build_router(options, is_request)
-          @validator_option = Committee::SchemaValidator::Option.new(options, self, :hyper_schema, is_request)
+        def build_router(options)
+          @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/driver.rb

@@ -59,7 +59,7 @@ module Committee
           schema.base_path = data['basePath'] || ''
 
           # Arbitrarily choose the first media type found in these arrays. This
-          # appraoch could probably stand to be improved, but at least users will
+          # approach could probably stand to be improved, but at least users will
           # for now have the option of turning media type validation off if they so
           # choose.
           schema.consumes = data['consumes'].first

data/lib/committee/drivers/open_api_2/parameter_schema_builder.rb

@@ -62,7 +62,7 @@ module Committee
                 # And same idea: despite parameters not being schemas, the items
                 # key (if preset) is actually a schema that defines each item of an
                 # array type, so we can just reflect that directly onto our
-                # artifical schema.
+                # artificial schema.
                 if param_data["type"] == "array" && param_data["items"]
                   param_schema.items = param_data["items"]
                 end

data/lib/committee/drivers/open_api_2/schema.rb

@@ -16,8 +16,8 @@ module Committee
         attr_accessor :routes
         attr_reader :validator_option
 
-        def build_router(options, is_request)
-          @validator_option = Committee::SchemaValidator::Option.new(options, self, :hyper_schema, is_request)
+        def build_router(options)
+          @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/schema.rb

@@ -23,8 +23,8 @@ module Committee
           @driver
         end
 
-        def build_router(options, is_request)
-          @validator_option = Committee::SchemaValidator::Option.new(options, self, :open_api_3, is_request)
+        def build_router(options)
+          @validator_option = Committee::SchemaValidator::Option.new(options, self, :open_api_3)
           Committee::SchemaValidator::OpenAPI3::Router.new(self, @validator_option)
         end
 

data/lib/committee/drivers/schema.rb

@@ -10,7 +10,7 @@ module Committee
         raise "needs implementation"
       end
 
-      def build_router(options, is_request)
+      def build_router(options)
         raise "needs implementation"
       end
 

data/lib/committee/drivers.rb

@@ -20,26 +20,27 @@ module Committee
     # load and build drive from JSON file
     # @param [String] schema_path
     # @return [Committee::Driver]
-    def self.load_from_json(schema_path)
-      load_from_data(JSON.parse(File.read(schema_path)), schema_path)
+    def self.load_from_json(schema_path, parser_options: {})
+      load_from_data(JSON.parse(File.read(schema_path)), schema_path, parser_options: parser_options)
     end
 
     # load and build drive from YAML file
     # @param [String] schema_path
     # @return [Committee::Driver]
-    def self.load_from_yaml(schema_path)
-      load_from_data(YAML.load_file(schema_path), schema_path)
+    def self.load_from_yaml(schema_path, parser_options: {})
+      data = YAML.respond_to?(:unsafe_load_file) ? YAML.unsafe_load_file(schema_path) : YAML.load_file(schema_path)
+      load_from_data(data, schema_path, parser_options: parser_options)
     end
 
     # load and build drive from file
     # @param [String] schema_path
     # @return [Committee::Driver]
-    def self.load_from_file(schema_path)
+    def self.load_from_file(schema_path, parser_options: {})
       case File.extname(schema_path)
       when '.json'
-        load_from_json(schema_path)
+        load_from_json(schema_path, parser_options: parser_options)
       when '.yaml', '.yml'
-        load_from_yaml(schema_path)
+        load_from_yaml(schema_path, parser_options: parser_options)
       else
         raise "Committee only supports the following file extensions: '.json', '.yaml', '.yml'"
       end
@@ -48,9 +49,19 @@ module Committee
     # load and build drive from Hash object
     # @param [Hash] hash
     # @return [Committee::Driver]
-    def self.load_from_data(hash, schema_path = nil)
+    def self.load_from_data(hash, schema_path = nil, parser_options: {})
       if hash['openapi']&.start_with?('3.0.')
-        openapi = OpenAPIParser.parse_with_filepath(hash, schema_path)
+        # From the next major version, we want to ensure `{ strict_reference_validation: true }`
+        # as a parser option here, but since it may break existing implementations, just warn
+        # if it is not explicitly set. See: https://github.com/interagent/committee/issues/343#issuecomment-997400329
+        opts = parser_options.dup
+
+        Committee.warn_deprecated_until_6(!opts.key?(:strict_reference_validation), 'openapi_parser will default to strict reference validation ' +
+        'from next version. Pass config `strict_reference_validation: true` (or false, if you must) ' +
+        'to quiet this warning.')
+        opts[:strict_reference_validation] ||= false
+        
+        openapi = OpenAPIParser.parse_with_filepath(hash, schema_path, opts)
         return Committee::Drivers::OpenAPI3::Driver.new.parse(openapi)
       end
 
@@ -60,6 +71,7 @@ module Committee
                  Committee::Drivers::HyperSchema::Driver.new
                end
 
+      # TODO: in the future, pass `opts` here and allow optionality in other drivers?
       driver.parse(hash)
     end
   end

data/lib/committee/middleware/base.rb

@@ -13,7 +13,7 @@ module Committee
         @raise = options[:raise]
         @schema = self.class.get_schema(options)
 
-        @router = @schema.build_router(options, is_request: Committee::Middleware::RequestValidation == self.class)
+        @router = @schema.build_router(options)
         @accept_request_filter = options[:accept_request_filter] || -> (_) { true }
       end
 
@@ -30,11 +30,12 @@ module Committee
       class << self
         def get_schema(options)
           schema = options[:schema]
-          unless schema
-            schema = Committee::Drivers::load_from_file(options[:schema_path]) if options[:schema_path]
-
-            raise(ArgumentError, "Committee: need option `schema` or `schema_path`") unless schema
+          if !schema && options[:schema_path]
+            # In the future, we could have `parser_options` as an exposed config?
+            parser_options = options.key?(:strict_reference_validation) ? { strict_reference_validation: options[:strict_reference_validation] } : {}
+            schema = Committee::Drivers::load_from_file(options[:schema_path], parser_options: parser_options)
           end
+          raise(ArgumentError, "Committee: need option `schema` or `schema_path`") unless schema
 
           # Expect the type we want by now. If we don't have it, the user passed
           # something else non-standard in.

data/lib/committee/middleware/request_validation.rb

@@ -34,14 +34,7 @@ module Committee
       private
 
       def handle_exception(e, env)
-        return unless @error_handler
-
-        if @error_handler.arity > 1
-          @error_handler.call(e, env)
-        else
-          Committee.warn_deprecated('Using `error_handler.call(exception)` is deprecated and will be change to `error_handler.call(exception, request.env)` in next major version.')
-          @error_handler.call(e)
-        end
+        @error_handler.call(e, env) if @error_handler
       end
     end
   end

data/lib/committee/middleware/response_validation.rb

@@ -7,10 +7,7 @@ module Committee
 
       def initialize(app, options = {})
         super
-
-        unless options[:strict].nil?
-          Committee.warn_deprecated("Committee: Committee::Middleware::ResponseValidation doesn't support strict option now but we'll support this option. This change break backward compatibility so please remove strict option from ResponseValidation")
-        end
+        @strict = options[:strict]
         @validate_success_only = @schema.validator_option.validate_success_only
       end
 
@@ -19,7 +16,7 @@ module Committee
 
         begin
           v = build_schema_validator(request)
-          v.response_validate(status, headers, response) if v.link_exist? && self.class.validate?(status, validate_success_only)
+          v.response_validate(status, headers, response, @strict) if v.link_exist? && self.class.validate?(status, validate_success_only)
 
         rescue Committee::InvalidResponse
           handle_exception($!, request.env)
@@ -38,21 +35,23 @@ module Committee
 
       class << self
         def validate?(status, validate_success_only)
-          status != 204 && (!validate_success_only || (200...300).include?(status))
+          case status
+          when 204
+            false
+          when 200..299
+            true
+          when 304
+            false
+          else
+            !validate_success_only
+          end
         end
       end
 
       private
 
       def handle_exception(e, env)
-        return unless @error_handler
-
-        if @error_handler.arity > 1
-          @error_handler.call(e, env)
-        else
-          Committee.warn_deprecated('Using `error_handler.call(exception)` is deprecated and will be change to `error_handler.call(exception, request.env)` in next major version.')
-          @error_handler.call(e)
-        end
+        @error_handler.call(e, env) if @error_handler
       end
     end
   end

data/lib/committee/request_unpacker.rb

@@ -27,7 +27,7 @@ module Committee
       @optimistic_json    = options[:optimistic_json]
     end
 
-    # reutrn params and is_form_params
+    # return params and is_form_params
     def unpack_request_params(request)
       # if Content-Type is empty or JSON, and there was a request body, try to
       # interpret it as JSON

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

@@ -14,7 +14,7 @@ module Committee
         end
 
         def call(status, headers, data)
-          unless status == 204 # 204 No Content
+          unless [204, 304].include?(status) # 204 No Content or 304 Not Modified
             response = Rack::Response.new(data, status, headers)
             check_content_type!(response)
           end

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

@@ -39,18 +39,12 @@ module Committee
           raise Committee::InvalidResponse.new(e.message, original_error: e)
         end
 
-        def validate_request_params(params, headers, validator_option)
+        def validate_request_params(path_params, query_params, body_params, headers, validator_option)
           ret, err = case request_operation.http_method
-                when 'get'
-                  validate_get_request_params(params, headers, validator_option)
-                when 'post'
-                  validate_post_request_params(params, headers, validator_option)
-                when 'put'
-                  validate_post_request_params(params, headers, validator_option)
-                when 'patch'
-                  validate_post_request_params(params, headers, validator_option)
-                when 'delete'
-                  validate_get_request_params(params, headers, validator_option)
+                when 'get', 'delete', 'head'
+                  validate_get_request_params(path_params, query_params, headers, validator_option)
+                when 'post', 'put', 'patch', 'options'
+                  validate_post_request_params(path_params, query_params, body_params, headers, validator_option)
                 else
                   raise "Committee OpenAPI3 not support #{request_operation.http_method} method"
                 end
@@ -80,28 +74,17 @@ module Committee
         #   @return [OpenAPIParser::RequestOperation]
 
         # @return [OpenAPIParser::SchemaValidator::Options]
-        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
-          validate_header = validator_option.check_header
-          OpenAPIParser::SchemaValidator::Options.new(coerce_value: coerce_value,
-                                                      datetime_coerce_class: datetime_coerce_class,
-                                                      validate_header: validate_header)
+        def build_openapi_parser_body_option(validator_option)
+          build_openapi_parser_option(validator_option, validator_option.coerce_form_params)
         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
-          validate_header = validator_option.check_header
-          OpenAPIParser::SchemaValidator::Options.new(coerce_value: coerce_value,
-                                                      datetime_coerce_class: datetime_coerce_class,
-                                                      validate_header: validate_header)
+        def build_openapi_parser_path_option(validator_option)
+          build_openapi_parser_option(validator_option, validator_option.coerce_query_params)
         end
 
         # @return [OpenAPIParser::SchemaValidator::Options]
-        def build_openapi_parser_get_option(validator_option)
-          coerce_value = validator_option.coerce_query_params
+        def build_openapi_parser_option(validator_option, coerce_value)
           datetime_coerce_class = validator_option.coerce_date_times ? DateTime : nil
           validate_header = validator_option.check_header
           OpenAPIParser::SchemaValidator::Options.new(coerce_value: coerce_value,
@@ -109,24 +92,40 @@ module Committee
                                                       validate_header: validate_header)
         end
 
-        def validate_get_request_params(params, headers, validator_option)
+        def validate_get_request_params(path_params, query_params, headers, validator_option)
           # bad performance because when we coerce value, same check
-          request_operation.validate_request_parameter(params, headers, build_openapi_parser_get_option(validator_option))
+          validate_path_and_query_params(path_params, query_params, headers, validator_option)
         rescue OpenAPIParser::OpenAPIError => e
           raise Committee::InvalidRequest.new(e.message, original_error: e)
         end
 
-        def validate_post_request_params(params, headers, validator_option)
+        def validate_post_request_params(path_params, query_params, body_params, headers, validator_option)
           content_type = headers['Content-Type'].to_s.split(";").first.to_s
 
           # bad performance because when we coerce value, same check
-          schema_validator_options = build_openapi_parser_post_option(validator_option)
-          request_operation.validate_request_parameter(params, headers, schema_validator_options)
-          request_operation.validate_request_body(content_type, params, schema_validator_options)
+          validate_path_and_query_params(path_params, query_params, headers, validator_option)
+          request_operation.validate_request_body(content_type, body_params, build_openapi_parser_body_option(validator_option))
         rescue => e
           raise Committee::InvalidRequest.new(e.message, original_error: e)
         end
 
+        def validate_path_and_query_params(path_params, query_params, headers, validator_option)
+          # it's currently impossible to validate path params and query params separately
+          # so we have to resort to this workaround
+
+          path_keys = path_params.keys.to_set
+          query_keys = query_params.keys.to_set
+
+          merged_params = query_params.merge(path_params)
+
+          request_operation.validate_request_parameter(merged_params, headers, build_openapi_parser_path_option(validator_option))
+
+          merged_params.each do |k, v|
+            path_params[k] = v if path_keys.include?(k)
+            query_params[k] = v if query_keys.include?(k)
+          end
+        end
+
         def response_validate_options(strict, check_header)
           ::OpenAPIParser::SchemaValidator::ResponseValidateOptions.new(strict: strict, validate_header: check_header)
         end

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

@@ -11,11 +11,11 @@ module Committee
           @validator_option = validator_option
         end
 
-        def call(request, params, headers)
+        def call(request, path_params, query_params, body_params, headers)
           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, headers, @validator_option)
+          @operation_object.validate_request_params(path_params, query_params, body_params, headers, @validator_option)
         end
 
         private

data/lib/committee/schema_validator/open_api_3.rb

@@ -17,7 +17,7 @@ module Committee
         request_unpack(request)
         request_schema_validation(request)
 
-        copy_coerced_data_to_query_hash(request)
+        copy_coerced_data_to_params(request)
       end
 
       def response_validate(status, headers, response, test_method = false)
@@ -34,6 +34,7 @@ module Committee
           full_body
         end
 
+        # TODO: refactoring name
         strict = test_method
         Committee::SchemaValidator::OpenAPI3::ResponseValidator.
             new(@operation_object, validator_option).
@@ -57,7 +58,19 @@ module Committee
         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], header(request))
+        validator.call(request, path_params(request), query_params(request), body_params(request), header(request))
+      end
+
+      def path_params(request)
+        request.env[validator_option.path_hash_key]
+      end
+
+      def query_params(request)
+        request.env[validator_option.query_hash_key]
+      end
+
+      def body_params(request)
+        request.env[validator_option.request_body_hash_key]
       end
 
       def header(request)
@@ -79,30 +92,22 @@ module Committee
         request.env[validator_option.path_hash_key] = coerce_path_params
 
         query_param = unpacker.unpack_query_params(request)
+        query_param.merge!(request_param) if request.get? && validator_option.allow_get_body
+        request.env[validator_option.query_hash_key] = query_param
+      end
 
+      def copy_coerced_data_to_params(request)
         order = if validator_option.parameter_overwite_by_rails_rule
           # (high priority) path_hash_key -> query_param -> request_body_hash          
-          [request.env[validator_option.request_body_hash_key], query_param, request.env[validator_option.path_hash_key]]
+          [validator_option.request_body_hash_key, validator_option.query_hash_key, validator_option.path_hash_key]
         else
           # (high priority) path_hash_key -> request_body_hash -> query_param
-          [query_param, request.env[validator_option.request_body_hash_key], request.env[validator_option.path_hash_key]]
+          [validator_option.query_hash_key, validator_option.request_body_hash_key, validator_option.path_hash_key]
         end
 
         request.env[validator_option.params_key] = Committee::Utils.indifferent_hash
-        order.each do |param|
-          request.env[validator_option.params_key].merge!(Committee::Utils.deep_copy(param))
-        end
-      end
-
-      def copy_coerced_data_to_query_hash(request)
-        return if request.env["rack.request.query_hash"].nil? || request.env["rack.request.query_hash"].empty?
-
-        query_hash_key = @validator_option.query_hash_key
-        return unless query_hash_key
-
-        request.env[query_hash_key] = {} unless request.env[query_hash_key]
-        request.env["rack.request.query_hash"].keys.each do |k|
-          request.env[query_hash_key][k] = request.env[validator_option.params_key][k]
+        order.each do |key|
+          request.env[validator_option.params_key].merge!(Committee::Utils.deep_copy(request.env[key]))
         end
       end
     end

data/lib/committee/schema_validator/option.rb

@@ -27,16 +27,11 @@ module Committee
                   :path_hash_key,
                   :prefix
 
-      def initialize(options, schema, schema_type, is_request)
+      def initialize(options, schema, schema_type)
         # Non-boolean options
         @headers_key         = options[:headers_key]    || "committee.headers"
         @params_key          = options[:params_key]     || "committee.params"
-        @query_hash_key      = if options[:query_hash_key].nil?
-          Committee.warn_deprecated('Committee: please set query_hash_key = "rack.request.query_hash" because we\'ll change default value to "committee.query_hash" in next major version.') 
-          'rack.request.query_hash'
-        else
-          options.fetch(:query_hash_key)
-        end
+        @query_hash_key      = options[:query_hash_key] || "committee.query_hash"
         @path_hash_key      = options[:path_hash_key] || "committee.path_hash"
         @request_body_hash_key = options[:request_body_hash_key] || "committee.request_body_hash"
 
@@ -49,20 +44,8 @@ module Committee
         @check_header        = options.fetch(:check_header, true)
         @coerce_recursive    = options.fetch(:coerce_recursive, true)
         @optimistic_json     = options.fetch(:optimistic_json, false)
-        @parse_response_by_content_type = if options[:parse_response_by_content_type].nil?
-          if !is_request
-            Committee.warn_deprecated('Committee: please set parse_response_by_content_type = false because we\'ll change default value in next major version.') 
-          end
-          false
-        else
-          options.fetch(:parse_response_by_content_type)
-        end
-        @parameter_overwite_by_rails_rule      = if options[:parameter_overwite_by_rails_rule].nil?
-          Committee.warn_deprecated('Committee: please set parameter_overwite_by_rails_rule = false because we\'ll change default value to "true" in next major version.') 
-          false
-        else
-          options.fetch(:parameter_overwite_by_rails_rule)
-        end
+        @parse_response_by_content_type = options.fetch(:parse_response_by_content_type, true)
+        @parameter_overwite_by_rails_rule = options.fetch(:parameter_overwite_by_rails_rule, true)
 
         # Boolean options and have a different value by default
         @allow_get_body      = options.fetch(:allow_get_body, schema.driver.default_allow_get_body)

data/lib/committee/test/methods.rb

@@ -26,7 +26,7 @@ module Committee
         status, headers, body = response_data
 
         if expected_status.nil?
-          Committee.warn_deprecated('Pass expected response status code to check it against the corresponding schema explicitly.')
+          Committee.need_good_option('Pass expected response status code to check it against the corresponding schema explicitly.')
         elsif expected_status != status
           response = "Expected `#{expected_status}` status code, but it was `#{status}`."
           raise Committee::InvalidResponse.new(response)
@@ -61,7 +61,7 @@ module Committee
       end
 
       def router
-        @router ||= schema.build_router(committee_options, true)
+        @router ||= schema.build_router(committee_options)
       end
 
       def schema_validator
@@ -77,12 +77,7 @@ module Committee
       end
 
       def old_behavior
-        old_assert_behavior = committee_options.fetch(:old_assert_behavior, nil)
-        if old_assert_behavior.nil?
-          Committee.warn_deprecated('Now assert_schema_conform check response schema only. but we will change check request and response in future major version. so if you want to conform response only, please use assert_response_schema_confirm, or you can suppress this message and keep old behavior by setting old_assert_behavior=true.')
-          old_assert_behavior = true
-        end
-        old_assert_behavior
+        committee_options.fetch(:old_assert_behavior, false)
       end
     end
   end

data/lib/committee/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Committee
+    VERSION = '5.0.0.beta1'.freeze
+end

data/lib/committee.rb

@@ -6,6 +6,8 @@ require "json_schema"
 require "rack"
 require 'openapi_parser'
 
+require_relative "committee/version"
+
 module Committee
   def self.debug?
     ENV["COMMITTEE_DEBUG"]
@@ -15,8 +17,13 @@ module Committee
     $stderr.puts(message) if debug?
   end
 
-  def self.warn_deprecated(message)
-    warn("[DEPRECATION] #{message}")
+  def self.need_good_option(message)
+    warn(message)
+  end
+
+  def self.warn_deprecated_until_6(cond, message)
+    raise "remove deprecated!"  unless Committee::VERSION.start_with?("5")
+    warn("[DEPRECATION] #{message}") if cond
   end
 end
 

data/test/committee_test.rb

@@ -31,21 +31,47 @@ describe Committee do
     end
   end
 
+  it "warns need_good_option" do
+    old_stderr = $stderr
+    $stderr = StringIO.new
+    begin
+      Committee.need_good_option "show"
+      assert_equal "show\n", $stderr.string
+    ensure
+      $stderr = old_stderr
+    end
+  end
+
   it "warns on deprecated unless $VERBOSE is nil" do
     old_stderr = $stderr
     old_verbose = $VERBOSE
     $stderr = StringIO.new
     begin
       $VERBOSE = nil
-      Committee.warn_deprecated "blah"
+      Committee.warn_deprecated_until_6 true, "blah"
       assert_equal "", $stderr.string
 
       $VERBOSE = true
-      Committee.warn_deprecated "blah"
+      Committee.warn_deprecated_until_6 true, "blah"
       assert_equal "[DEPRECATION] blah\n", $stderr.string
     ensure
       $stderr = old_stderr
       $VERBOSE = old_verbose
     end
   end
+
+
+  it "doesn't warns on deprecated if cond is false" do
+    old_stderr = $stderr
+    old_verbose = $VERBOSE
+    $stderr = StringIO.new
+    begin
+      $VERBOSE = true
+      Committee.warn_deprecated_until_6 false, "blah"
+      assert_equal "", $stderr.string
+    ensure
+      $stderr = old_stderr
+      $VERBOSE = old_verbose
+    end
+  end
 end

data/test/drivers/open_api_3/driver_test.rb

@@ -16,7 +16,7 @@ describe Committee::Drivers::OpenAPI3::Driver do
   end
 
   it "override methods" do
-    parser = OpenAPIParser.parse(open_api_3_data)
+    parser = OpenAPIParser.parse(open_api_3_data, strict_reference_validation: false)
     schema = @driver.parse(parser)
 
     assert_kind_of Committee::Drivers::OpenAPI3::Schema, schema