committee 4.3.0 → 4.4.0.rc1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 19c70ee2e436755ddf7b0b59b213ab7c00b60e67ce52520b956b889121b24e4c
-  data.tar.gz: 06066adc6056231938d36d93a98c5d7318d9c1ff367784265d66c0eb271fb7b6
+  metadata.gz: 3a1c74892e2e3abf70f99999312c39aa6e85d0fe8323b73d534ff231c3d7f443
+  data.tar.gz: 0be5e25f5dc94b28aa1d0055f7403e2ca8e59199567d128a7ea2d459a833d4cd
 SHA512:
-  metadata.gz: bfbcc7aa85c676291125ed16b20badadda3eb8d895b6834cdc884602345c6ed3a052ecbdd381615b8bbca49815d884407cf8cc2f8cbbe05702593b5cc171f568
-  data.tar.gz: cc454350c3d04969ad3f24c1922b887a6e319cea4f0a869b647ef439dbc9f5f83f3922bde82abdeb0994a540e53d5e68345e76d7291b408e42cd2f5a4df9eec1
+  metadata.gz: 1c8f4286e8be5cd6331e8ca323963bed83c2e0e2960037a78fa0aa78e23f3d684ee931336a4f5e4ce55f4b7dd83f7cf9873ea704979ed53e5cbc47599f3ebc98
+  data.tar.gz: bc840cb4285ecc917613162d6b9837c419e88464a96724b06bf90f07236bf725cc5d099e17c8ecc5cc64f948ff5b35a513a9387ed948c56bcad664d71487313d

data/lib/committee.rb

@@ -20,6 +20,7 @@ module Committee
   end
 end
 
+require_relative "committee/utils"
 require_relative "committee/drivers"
 require_relative "committee/errors"
 require_relative "committee/middleware"

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

@@ -156,7 +156,6 @@ module Committee
 
             methods.each do |method, link_data|
               method = method.upcase
-
               link = Link.new
               link.enc_type = schema.consumes
               link.href = href

data/lib/committee/middleware/request_validation.rb

@@ -7,9 +7,6 @@ module Committee
         super
 
         @strict  = options[:strict]
-
-        # deprecated
-        @allow_extra = options[:allow_extra]
       end
 
       def handle(request)

data/lib/committee/middleware/response_validation.rb

@@ -7,6 +7,10 @@ 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
         @validate_success_only = @schema.validator_option.validate_success_only
       end
 

data/lib/committee/request_unpacker.rb

@@ -2,84 +2,82 @@
 
 module Committee
   class RequestUnpacker
-    def initialize(request, options={})
-      @request = request
+    class << self
+      # Enable string or symbol key access to the nested params hash.
+      #
+      # (Copied from Sinatra)
+      def indifferent_params(object)
+        case object
+        when Hash
+          new_hash = Committee::Utils.indifferent_hash
+          object.each { |key, value| new_hash[key] = indifferent_params(value) }
+          new_hash
+        when Array
+          object.map { |item| indifferent_params(item) }
+        else
+          object
+        end
+      end
+    end
 
+    def initialize(options={})
       @allow_form_params  = options[:allow_form_params]
       @allow_get_body     = options[:allow_get_body]
       @allow_query_params = options[:allow_query_params]
-      @coerce_form_params = options[:coerce_form_params]
       @optimistic_json    = options[:optimistic_json]
-      @schema_validator   = options[:schema_validator]
     end
 
-    def call
+    # reutrn 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
-      params = if !@request.media_type || @request.media_type =~ %r{application/(?:.*\+)?json}
-        parse_json
+      params = if !request.media_type || request.media_type =~ %r{application/(?:.*\+)?json}
+        parse_json(request)
       elsif @optimistic_json
         begin
-          parse_json
+          parse_json(request)
         rescue JSON::ParserError
           nil
         end
       end
 
-      params = if params
-        params
-      elsif @allow_form_params && %w[application/x-www-form-urlencoded multipart/form-data].include?(@request.media_type)
+      return [params, false] if params
+
+      if @allow_form_params && %w[application/x-www-form-urlencoded multipart/form-data].include?(request.media_type)
         # Actually, POST means anything in the request body, could be from
         # PUT or PATCH too. Silly Rack.
-        p = @request.POST
-
-        @schema_validator.coerce_form_params(p) if @coerce_form_params
-
-        p
-      else
-        {}
+        return [request.POST, true] if request.POST
       end
 
-      if @allow_query_params
-        [indifferent_params(@request.GET).merge(params), headers]
-      else
-        [params, headers]
-      end
+      [{}, false]
     end
 
-    private
-
-    # Creates a Hash with indifferent access.
-    #
-    # (Copied from Sinatra)
-    def indifferent_hash
-      Hash.new { |hash,key| hash[key.to_s] if Symbol === key }
+    def unpack_query_params(request)
+      @allow_query_params ? self.class.indifferent_params(request.GET) : {}
     end
 
-    # Enable string or symbol key access to the nested params hash.
-    #
-    # (Copied from Sinatra)
-    def indifferent_params(object)
-      case object
-      when Hash
-        new_hash = indifferent_hash
-        object.each { |key, value| new_hash[key] = indifferent_params(value) }
-        new_hash
-      when Array
-        object.map { |item| indifferent_params(item) }
-      else
-        object
+    def unpack_headers(request)
+      env = request.env
+      base = env.keys.grep(/HTTP_/).inject({}) do |headers, key|
+        headerized_key = key.gsub(/^HTTP_/, '').gsub(/_/, '-')
+        headers[headerized_key] = env[key]
+        headers
       end
+
+      base['Content-Type'] = env['CONTENT_TYPE'] if env['CONTENT_TYPE']
+      base
     end
 
-    def parse_json
-      return nil if @request.request_method == "GET" && !@allow_get_body
+    private
+
+    def parse_json(request)
+      return nil if request.request_method == "GET" && !@allow_get_body
 
-      body = @request.body.read
+      body = request.body.read
       # if request body is empty, we just have empty params
       return nil if body.length == 0
 
-      @request.body.rewind
+      request.body.rewind
       hash = JSON.parse(body)
       # We want a hash specifically. '42', 42, and [42] will all be
       # decoded properly, but we can't use them here.
@@ -87,19 +85,7 @@ module Committee
         raise BadRequest,
               "Invalid JSON input. Require object with parameters as keys."
       end
-      indifferent_params(hash)
-    end
-
-    def headers
-      env = @request.env
-      base = env.keys.grep(/HTTP_/).inject({}) do |headers, key|
-        headerized_key = key.gsub(/^HTTP_/, '').gsub(/_/, '-')
-        headers[headerized_key] = env[key]
-        headers
-      end
-
-      base['Content-Type'] = env['CONTENT_TYPE'] if env['CONTENT_TYPE']
-      base
+      self.class.indifferent_params(hash)
     end
   end
 end

data/lib/committee/schema_validator/hyper_schema.rb

@@ -11,18 +11,8 @@ module Committee
       end
 
       def request_validate(request)
-        # Attempts to coerce parameters that appear in a link's URL to Ruby
-        # types that can be validated with a schema.
-        param_matches_hash = validator_option.coerce_path_params ? coerce_path_params : {}
-
-        # Attempts to coerce parameters that appear in a query string to Ruby
-        # types that can be validated with a schema.
-        coerce_query_params(request) if validator_option.coerce_query_params
-
         request_unpack(request)
 
-        request.env[validator_option.params_key].merge!(param_matches_hash) if param_matches_hash
-
         request_schema_validation(request)
         parameter_coerce!(request, link, validator_option.params_key)
         parameter_coerce!(request, link, "rack.request.query_hash") if link_exist? && !request.GET.nil? && !link.schema.nil?
@@ -50,16 +40,10 @@ module Committee
         !link.nil?
       end
 
-      def coerce_form_params(parameter)
-        return unless link_exist?
-        return unless link.schema
-        Committee::SchemaValidator::HyperSchema::StringParamsCoercer.new(parameter, link.schema).call!
-      end
-
       private
 
         def coerce_path_params
-          return unless link_exist?
+          return {} unless link_exist?
 
           Committee::SchemaValidator::HyperSchema::StringParamsCoercer.new(param_matches, link.schema, coerce_recursive: validator_option.coerce_recursive).call!
           param_matches
@@ -73,15 +57,38 @@ module Committee
         end
 
         def request_unpack(request)
-          request.env[validator_option.params_key], request.env[validator_option.headers_key] = Committee::RequestUnpacker.new(
-              request,
-              allow_form_params:  validator_option.allow_form_params,
-              allow_get_body:     validator_option.allow_get_body,
-              allow_query_params: validator_option.allow_query_params,
-              coerce_form_params: validator_option.coerce_form_params,
-              optimistic_json:    validator_option.optimistic_json,
-              schema_validator:   self
-          ).call
+          unpacker = Committee::RequestUnpacker.new(
+            allow_form_params:  validator_option.allow_form_params,
+            allow_get_body:     validator_option.allow_get_body,
+            allow_query_params: validator_option.allow_query_params,
+            optimistic_json:    validator_option.optimistic_json,
+          )
+
+          request.env[validator_option.headers_key] = unpacker.unpack_headers(request)
+
+          # Attempts to coerce parameters that appear in a link's URL to Ruby
+          # types that can be validated with a schema.
+          param_matches_hash = validator_option.coerce_path_params ? coerce_path_params : {}
+
+          # Attempts to coerce parameters that appear in a query string to Ruby
+          # types that can be validated with a schema.
+          coerce_query_params(request) if validator_option.coerce_query_params
+
+          query_param = unpacker.unpack_query_params(request)
+          request_param, is_form_params = unpacker.unpack_request_params(request)
+          coerce_form_params(request_param) if validator_option.coerce_form_params && is_form_params
+          request.env[validator_option.request_body_hash_key] = request_param
+
+          request.env[validator_option.params_key] = Committee::Utils.indifferent_hash
+          request.env[validator_option.params_key].merge!(Committee::Utils.deep_copy(query_param))
+          request.env[validator_option.params_key].merge!(Committee::Utils.deep_copy(request_param))
+          request.env[validator_option.params_key].merge!(Committee::Utils.deep_copy(param_matches_hash))
+        end
+
+        def coerce_form_params(parameter)
+          return unless link_exist?
+          return unless link.schema
+          Committee::SchemaValidator::HyperSchema::StringParamsCoercer.new(parameter, link.schema).call!
         end
 
         def request_schema_validation(request)

data/lib/committee/schema_validator/open_api_3.rb

@@ -14,12 +14,7 @@ module Committee
       def request_validate(request)
         return unless link_exist?
 
-        path_params = validator_option.coerce_path_params ? coerce_path_params : {}
-
         request_unpack(request)
-
-        request.env[validator_option.params_key]&.merge!(path_params) unless path_params.empty?
-
         request_schema_validation(request)
 
         copy_coerced_data_to_query_hash(request)
@@ -49,16 +44,13 @@ module Committee
         !@operation_object.nil?
       end
 
-      def coerce_form_params(_parameter)
-        # Empty because request_schema_validation checks and coerces
-      end
-
       private
 
       attr_reader :validator_option
 
       def coerce_path_params
-        @operation_object.coerce_path_parameter(@validator_option)
+        return Committee::Utils.indifferent_hash unless validator_option.coerce_path_params
+        Committee::RequestUnpacker.indifferent_params(@operation_object.coerce_path_parameter(@validator_option))
       end
 
       def request_schema_validation(request)
@@ -73,22 +65,36 @@ module Committee
       end
 
       def request_unpack(request)
-        request.env[validator_option.params_key], request.env[validator_option.headers_key] = Committee::RequestUnpacker.new(
-            request,
-            allow_form_params:  validator_option.allow_form_params,
-            allow_get_body:     validator_option.allow_get_body,
-            allow_query_params: validator_option.allow_query_params,
-            coerce_form_params: validator_option.coerce_form_params,
-            optimistic_json:    validator_option.optimistic_json,
-            schema_validator:   self
-        ).call
+        unpacker = Committee::RequestUnpacker.new(
+          allow_form_params:  validator_option.allow_form_params,
+          allow_get_body:     validator_option.allow_get_body,
+          allow_query_params: validator_option.allow_query_params,
+          optimistic_json:    validator_option.optimistic_json,
+        )
+
+        request.env[validator_option.headers_key] = unpacker.unpack_headers(request)
+
+        request_param, is_form_params = unpacker.unpack_request_params(request)
+        request.env[validator_option.request_body_hash_key] = request_param
+        request.env[validator_option.path_hash_key] = coerce_path_params
+
+        query_param = unpacker.unpack_query_params(request)
+
+        request.env[validator_option.params_key] = Committee::Utils.indifferent_hash
+        request.env[validator_option.params_key].merge!(Committee::Utils.deep_copy(query_param))
+        request.env[validator_option.params_key].merge!(Committee::Utils.deep_copy(request.env[validator_option.request_body_hash_key]))
+        request.env[validator_option.params_key].merge!(Committee::Utils.deep_copy(request.env[validator_option.path_hash_key]))
       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["rack.request.query_hash"][k] = request.env[validator_option.params_key][k]
+          request.env[query_hash_key][k] = request.env[validator_option.params_key][k]
         end
       end
     end

data/lib/committee/schema_validator/option.rb

@@ -21,12 +21,24 @@ module Committee
       # Non-boolean options:
       attr_reader :headers_key,
                   :params_key,
+                  :query_hash_key,
+                  :request_body_hash_key,
+                  :path_hash_key,
                   :prefix
 
       def initialize(options, schema, schema_type)
         # Non-boolean options
-        @headers_key         = options[:headers_key] || "committee.headers"
-        @params_key          = options[:params_key] || "committee.params"
+        @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 in next major version.') 
+          'rack.request.query_hash'
+        else
+          options.fetch(:query_hash_key)
+        end
+        @path_hash_key      = options[:path_hash_key] || "committee.path_hash"
+        @request_body_hash_key = options[:request_body_hash_key] || "committee.request_body_hash"
+
         @prefix              = options[:prefix]
 
         # Boolean options and have a common value by default

data/lib/committee/test/methods.rb

@@ -3,9 +3,9 @@
 module Committee
   module Test
     module Methods
-      def assert_schema_conform
+      def assert_schema_conform(expected_status = nil)
         assert_request_schema_confirm unless old_behavior
-        assert_response_schema_confirm
+        assert_response_schema_confirm(expected_status)
       end
 
       def assert_request_schema_confirm
@@ -17,7 +17,7 @@ module Committee
         schema_validator.request_validate(request_object)
       end
 
-      def assert_response_schema_confirm
+      def assert_response_schema_confirm(expected_status = nil)
         unless schema_validator.link_exist?
           response = "`#{request_object.request_method} #{request_object.path_info}` undefined in schema (prefix: #{committee_options[:prefix].inspect})."
           raise Committee::InvalidResponse.new(response)
@@ -25,6 +25,13 @@ 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.')
+        elsif expected_status != status
+          response = "Expected `#{expected_status}` status code, but it was `#{status}`."
+          raise Committee::InvalidResponse.new(response)
+        end
+
         if schema_coverage
           operation_object = router.operation_object(request_object)
           schema_coverage&.update_response_coverage!(operation_object.original_path, operation_object.http_method, status)

data/lib/committee/utils.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Committee
+    module Utils
+        # Creates a Hash with indifferent access.
+        #
+        # (Copied from Sinatra)
+        def self.indifferent_hash
+            Hash.new { |hash,key| hash[key.to_s] if Symbol === key }
+        end
+
+        def self.deep_copy(from)
+            if from.is_a?(Hash)
+                h = Committee::Utils.indifferent_hash
+                from.each_pair do |k, v|
+                h[k] = deep_copy(v)
+                end
+                return h
+            end
+
+            if from.is_a?(Array)
+                return from.map{ |v| deep_copy(v) }
+            end
+
+            return from
+        end
+    end
+end

data/test/middleware/request_validation_open_api_3_test.rb

@@ -34,11 +34,27 @@ describe Committee::Middleware::RequestValidation do
     params = { "datetime_string" => "2016-04-01T16:00:00.000+09:00" }
 
     check_parameter = lambda { |env|
+      assert_equal DateTime, env['committee.query_hash']["datetime_string"].class
+      assert_equal String, env['rack.request.query_hash']["datetime_string"].class
+      [200, {}, []]
+    }
+
+    @app = new_rack_app_with_lambda(check_parameter, schema: open_api_3_schema, coerce_date_times: true, query_hash_key: "committee.query_hash")
+
+    get "/string_params_coercer", params
+    assert_equal 200, last_response.status
+  end
+
+  it "passes given a datetime and with coerce_date_times enabled on GET endpoint overwrite query_hash" do
+    params = { "datetime_string" => "2016-04-01T16:00:00.000+09:00" }
+
+    check_parameter = lambda { |env|
+      assert_equal nil, env['committee.query_hash']
       assert_equal DateTime, env['rack.request.query_hash']["datetime_string"].class
       [200, {}, []]
     }
 
-    @app = new_rack_app_with_lambda(check_parameter, schema: open_api_3_schema, coerce_date_times: true)
+    @app = new_rack_app_with_lambda(check_parameter, schema: open_api_3_schema, coerce_date_times: true, query_hash_key: "rack.request.query_hash")
 
     get "/string_params_coercer", params
     assert_equal 200, last_response.status
@@ -154,7 +170,8 @@ describe Committee::Middleware::RequestValidation do
     }
 
     check_parameter = lambda { |env|
-      hash = env['rack.request.query_hash']
+      # hash = env["committee.query_hash"] # 5.0.x-
+      hash = env["rack.request.query_hash"]
       assert_equal DateTime, hash['nested_array'].first['update_time'].class
       assert_equal 1, hash['nested_array'].first['per_page']
 
@@ -331,7 +348,7 @@ describe Committee::Middleware::RequestValidation do
       get "/coerce_path_params/#{not_an_integer}", nil
     end
 
-    assert_match(/expected integer, but received String: abc/i, e.message)
+    assert_match(/expected integer, but received String: \"abc\"/i, e.message)
   end
 
   it "optionally raises an error" do
@@ -360,7 +377,8 @@ describe Committee::Middleware::RequestValidation do
 
   it "passes through a valid request for OpenAPI3" do
     check_parameter = lambda { |env|
-      assert_equal 3, env['rack.request.query_hash']['limit']
+      # assert_equal 3, env['committee.query_hash']['limit'] #5.0.x-
+      assert_equal 3, env['rack.request.query_hash']['limit'] #5.0.x-
       [200, {}, []]
     }
 
@@ -374,7 +392,7 @@ describe Committee::Middleware::RequestValidation do
     get "/characters?limit=foo"
 
     assert_equal 400, last_response.status
-    assert_match(/expected integer, but received String: foo/i, last_response.body)
+    assert_match(/expected integer, but received String: \\"foo\\"/i, last_response.body)
   end
 
   it "ignores errors when ignore_error: true" do
@@ -394,6 +412,51 @@ describe Committee::Middleware::RequestValidation do
     get "/coerce_path_params/1"
   end
 
+  it "corce string and save path hash" do
+    @app = new_rack_app_with_lambda(lambda do |env|
+      assert_equal env['committee.params']['integer'], 21
+      assert_equal env['committee.params'][:integer], 21
+      assert_equal env['committee.path_hash']['integer'], 21
+      assert_equal env['committee.path_hash'][:integer], 21
+      [204, {}, []]
+    end, schema: open_api_3_schema)
+
+    header "Content-Type", "application/json"
+    post '/parameter_option_test/21'
+    assert_equal 204, last_response.status
+  end
+
+  it "corce string and save request body hash" do
+    @app = new_rack_app_with_lambda(lambda do |env|
+      assert_equal env['committee.params']['integer'], 21 # use path parameter
+      assert_equal env['committee.params'][:integer], 21
+      assert_equal env['committee.request_body_hash']['integer'], 42
+      assert_equal env['committee.request_body_hash'][:integer], 42
+      [204, {}, []]
+    end, schema: open_api_3_schema)
+
+    params = {integer: 42}
+
+    header "Content-Type", "application/json"
+    post '/parameter_option_test/21', JSON.generate(params)
+    assert_equal 204, last_response.status
+  end
+
+  it "unpacker test" do
+    @app = new_rack_app_with_lambda(lambda do |env|
+      assert_equal env['committee.params']['integer'], 42
+      assert_equal env['committee.params'][:integer], 42
+      # overwrite by request body...
+      assert_equal env['rack.request.query_hash']['integer'], 42
+      # assert_equal env['rack.request.query_hash'][:integer], 42
+      [204, {}, []]
+    end, schema: open_api_3_schema, raise: true)
+
+    header "Content-Type", "application/x-www-form-urlencoded"
+    post '/validate?integer=21', "integer=42"
+    assert_equal 204, last_response.status
+  end
+
   it "OpenAPI3 raise not support method" do
     @app = new_rack_app(schema: open_api_3_schema)
 
@@ -408,7 +471,7 @@ describe Committee::Middleware::RequestValidation do
     [
       { check_header: true, description: 'valid value', value: 1, expected: { status: 200 } },
       { check_header: true, description: 'missing value', value: nil, expected: { status: 400, error: 'missing required parameters: integer' } },
-      { check_header: true, description: 'invalid value', value: 'x', expected: { status: 400, error: 'expected integer, but received String: x' } },
+      { check_header: true, description: 'invalid value', value: 'x', expected: { status: 400, error: 'expected integer, but received String: \\"x\\"' } },
 
       { check_header: false, description: 'valid value', value: 1, expected: { status: 200 } },
       { check_header: false, description: 'missing value', value: nil, expected: { status: 200 } },

data/test/middleware/request_validation_test.rb

@@ -435,6 +435,19 @@ describe Committee::Middleware::RequestValidation do
     assert_equal 200, last_response.status
   end
 
+  it "corce form params" do
+    check_parameter = lambda { |env|
+      assert_equal 3, env['committee.params']['age']
+      assert_equal 3, env['committee.request_body_hash']['age']
+      [200, {}, []]
+    }
+
+    @app = new_rack_app_with_lambda(check_parameter, schema: open_api_2_form_schema, raise: true, allow_form_params: true, coerce_form_params: true)
+    header "Content-Type", "application/x-www-form-urlencoded"
+    post "/api/pets", "age=3&name=ab"
+    assert_equal 200, last_response.status
+  end
+
   it "detects an invalid request for OpenAPI" do
     @app = new_rack_app(schema: open_api_2_schema)
     get "/api/pets?limit=foo", nil, { "HTTP_AUTH_TOKEN" => "xxx" }

data/test/middleware/response_validation_open_api_3_test.rb

@@ -125,7 +125,7 @@ describe Committee::Middleware::ResponseValidation do
     [
       { check_header: true, description: 'valid value', header: { 'integer' => 1 }, expected: { status: 200 } },
       { check_header: true, description: 'missing value', header: { 'integer' => nil }, expected: { error: 'headers/integer/schema does not allow null values' } },
-      { check_header: true, description: 'invalid value', header: { 'integer' => 'x' }, expected: { error: 'headers/integer/schema expected integer, but received String: x' } },
+      { check_header: true, description: 'invalid value', header: { 'integer' => 'x' }, expected: { error: 'headers/integer/schema expected integer, but received String: "x"' } },
 
       { check_header: false, description: 'valid value', header: { 'integer' => 1 }, expected: { status: 200 } },
       { check_header: false, description: 'missing value', header: { 'integer' => nil }, expected: { status: 200 } },
@@ -177,7 +177,7 @@ describe Committee::Middleware::ResponseValidation do
         get "/characters"
       end
 
-      assert_match(/but received String: 1/i, e.message)
+      assert_match(/but received String: \"1\"/i, e.message)
     end
 
     it "detects an invalid response status code with validate_success_only=true" do

data/test/middleware/response_validation_test.rb

@@ -15,6 +15,14 @@ describe Committee::Middleware::ResponseValidation do
     assert_equal 200, last_response.status
   end
 
+  # TODO: remove 5.0.0
+  it "passes through a valid response" do
+    # will show deprecated message
+    @app = new_rack_app(JSON.generate([ValidApp]), {}, schema: hyper_schema, strict: true)
+    get "/apps"
+    assert_equal 200, last_response.status
+  end
+
   it "doesn't call error_handler (has a arg) when response is valid" do
     called = false
     pr = ->(_e) { called = true }

data/test/request_unpacker_test.rb

@@ -9,8 +9,8 @@ describe Committee::RequestUnpacker do
       "rack.input"   => StringIO.new('{"x":"y"}'),
     }
     request = Rack::Request.new(env)
-    params, _ = Committee::RequestUnpacker.new(request).call
-    assert_equal({ "x" => "y" }, params)
+    unpacker = Committee::RequestUnpacker.new
+    assert_equal([{ "x" => "y" }, false], unpacker.unpack_request_params(request))
   end
 
   it "unpacks JSON on Content-Type: application/vnd.api+json" do
@@ -19,8 +19,8 @@ describe Committee::RequestUnpacker do
       "rack.input"   => StringIO.new('{"x":"y"}'),
     }
     request = Rack::Request.new(env)
-    params, _ = Committee::RequestUnpacker.new(request).call
-    assert_equal({ "x" => "y" }, params)
+    unpacker = Committee::RequestUnpacker.new
+    assert_equal([{ "x" => "y" }, false], unpacker.unpack_request_params(request))
   end
 
   it "unpacks JSON on no Content-Type" do
@@ -28,8 +28,8 @@ describe Committee::RequestUnpacker do
       "rack.input"   => StringIO.new('{"x":"y"}'),
     }
     request = Rack::Request.new(env)
-    params, _ = Committee::RequestUnpacker.new(request).call
-    assert_equal({ "x" => "y" }, params)
+    unpacker = Committee::RequestUnpacker.new
+    assert_equal([{ "x" => "y" }, false], unpacker.unpack_request_params(request))
   end
 
   it "doesn't unpack JSON on application/x-ndjson" do
@@ -38,8 +38,8 @@ describe Committee::RequestUnpacker do
       "rack.input"   => StringIO.new('{"x":"y"}\n{"a":"b"}'),
     }
     request = Rack::Request.new(env)
-    params, _ = Committee::RequestUnpacker.new(request).call
-    assert_equal({}, params)
+    unpacker = Committee::RequestUnpacker.new
+    assert_equal([{}, false], unpacker.unpack_request_params(request))
   end
 
   it "doesn't unpack JSON under other Content-Types" do
@@ -49,8 +49,8 @@ describe Committee::RequestUnpacker do
         "rack.input"   => StringIO.new('{"x":"y"}'),
       }
       request = Rack::Request.new(env)
-      params, _ = Committee::RequestUnpacker.new(request).call
-      assert_equal({}, params)
+      unpacker = Committee::RequestUnpacker.new
+      assert_equal([{}, false], unpacker.unpack_request_params(request))
     end
   end
 
@@ -61,8 +61,8 @@ describe Committee::RequestUnpacker do
         "rack.input"   => StringIO.new('{"x":"y"}'),
       }
       request = Rack::Request.new(env)
-      params, _ = Committee::RequestUnpacker.new(request, optimistic_json: true).call
-      assert_equal({ "x" => "y" }, params)
+      unpacker = Committee::RequestUnpacker.new(optimistic_json: true)
+      assert_equal([{ "x" => "y" }, false], unpacker.unpack_request_params(request))
     end
   end
 
@@ -73,8 +73,8 @@ describe Committee::RequestUnpacker do
         "rack.input"   => StringIO.new('x=y&foo=42'),
       }
       request = Rack::Request.new(env)
-      params, _ = Committee::RequestUnpacker.new(request, optimistic_json: true).call
-      assert_equal({}, params)
+      unpacker = Committee::RequestUnpacker.new(optimistic_json: true)
+      assert_equal([{}, false], unpacker.unpack_request_params(request))
     end
   end
 
@@ -84,8 +84,8 @@ describe Committee::RequestUnpacker do
       "rack.input"   => StringIO.new(""),
     }
     request = Rack::Request.new(env)
-    params, _ = Committee::RequestUnpacker.new(request).call
-    assert_equal({}, params)
+    unpacker = Committee::RequestUnpacker.new
+    assert_equal([{}, false], unpacker.unpack_request_params(request))
   end
 
   it "doesn't unpack form params" do
@@ -95,8 +95,8 @@ describe Committee::RequestUnpacker do
         "rack.input"   => StringIO.new("x=y"),
       }
       request = Rack::Request.new(env)
-      params, _ = Committee::RequestUnpacker.new(request).call
-      assert_equal({}, params)
+      unpacker = Committee::RequestUnpacker.new
+      assert_equal([{}, false], unpacker.unpack_request_params(request))
     end
   end
 
@@ -107,96 +107,8 @@ describe Committee::RequestUnpacker do
         "rack.input"   => StringIO.new("x=y"),
       }
       request = Rack::Request.new(env)
-      params, _ = Committee::RequestUnpacker.new(request, allow_form_params: true).call
-      assert_equal({ "x" => "y" }, params)
-    end
-  end
-
-  it "coerces form params with coerce_form_params and a schema" do
-    %w[application/x-www-form-urlencoded multipart/form-data].each do |content_type|
-      env = {
-          "CONTENT_TYPE" => content_type,
-          "rack.input"   => StringIO.new("x=1"),
-      }
-      request = Rack::Request.new(env)
-
-      options = {}
-      # TODO: delete when 5.0.0 released because default value changed
-      options[:parse_response_by_content_type] = false
-      router = hyper_schema.build_router(options)
-      validator = router.build_schema_validator(request)
-
-      schema = JsonSchema::Schema.new
-      schema.properties = { "x" => JsonSchema::Schema.new }
-      schema.properties["x"].type = ["integer"]
-
-      link_class = Struct.new(:schema)
-      link_object = link_class.new(schema)
-
-      validator.instance_variable_set(:@link, link_object)
-
-      params, _ = Committee::RequestUnpacker.new(
-        request,
-        allow_form_params: true,
-        coerce_form_params: true,
-        schema_validator: validator,
-      ).call
-      assert_equal({ "x" => 1 }, params)
-    end
-  end
-
-  it "coerces form params with coerce_form_params and an OpenAPI3 schema" do
-    %w[application/x-www-form-urlencoded multipart/form-data].each do |content_type|
-      env = {
-          "CONTENT_TYPE" => content_type,
-          "rack.input"   => StringIO.new("limit=20"),
-          "PATH_INFO" => "/characters",
-          "SCRIPT_NAME" => "",
-          "REQUEST_METHOD" => "GET",
-      }
-      request = Rack::Request.new(env)
-
-      options = {}
-      # TODO: delete when 5.0.0 released because default value changed
-      options[:parse_response_by_content_type] = false
-      router = open_api_3_schema.build_router(options)
-      validator = router.build_schema_validator(request)
-
-      params, _ = Committee::RequestUnpacker.new(
-          request,
-          allow_form_params: true,
-          coerce_form_params: true,
-          schema_validator: validator,
-          ).call
-      # openapi3 not support coerce in request unpacker
-      assert_equal({ "limit" => '20' }, params)
-    end
-  end
-
-  it "coerces error params with coerce_form_params and a OpenAPI3 schema" do
-    %w[application/x-www-form-urlencoded multipart/form-data].each do |content_type|
-      env = {
-          "CONTENT_TYPE" => content_type,
-          "rack.input"   => StringIO.new("limit=twenty"),
-          "PATH_INFO" => "/characters",
-          "SCRIPT_NAME" => "",
-          "REQUEST_METHOD" => "GET",
-      }
-      request = Rack::Request.new(env)
-
-      options = {}
-      # TODO: delete when 5.0.0 released because default value changed
-      options[:parse_response_by_content_type] = false
-      router = open_api_3_schema.build_router(options)
-      validator = router.build_schema_validator(request)
-
-      params, _ = Committee::RequestUnpacker.new(
-          request,
-          allow_form_params: true,
-          coerce_form_params: true,
-          schema_validator: validator,
-          ).call
-      assert_equal({ "limit" => "twenty" }, params)
+      unpacker = Committee::RequestUnpacker.new(allow_form_params: true)
+      assert_equal([{ "x" => "y" }, true], unpacker.unpack_request_params(request))
     end
   end
 
@@ -208,8 +120,8 @@ describe Committee::RequestUnpacker do
         "QUERY_STRING" => "a=b"
       }
       request = Rack::Request.new(env)
-      params, _ = Committee::RequestUnpacker.new(request, allow_form_params: true, allow_query_params: true).call
-      assert_equal({ "x" => "y", "a" => "b" }, params)
+      unpacker = Committee::RequestUnpacker.new(allow_form_params: true, allow_query_params: true)
+      assert_equal([ { "x" => "y"}, true], unpacker.unpack_request_params(request))
     end
   end
 
@@ -219,8 +131,8 @@ describe Committee::RequestUnpacker do
       "QUERY_STRING" => "a=b"
     }
     request = Rack::Request.new(env)
-    params, _ = Committee::RequestUnpacker.new(request, allow_query_params: true).call
-    assert_equal({ "a" => "b" }, params)
+    unpacker = Committee::RequestUnpacker.new(allow_query_params: true)
+    assert_equal({ "a" => "b" }, unpacker.unpack_query_params(request))
   end
 
   it "errors if JSON is not an object" do
@@ -230,7 +142,7 @@ describe Committee::RequestUnpacker do
     }
     request = Rack::Request.new(env)
     assert_raises(Committee::BadRequest) do
-      Committee::RequestUnpacker.new(request).call
+      Committee::RequestUnpacker.new.unpack_request_params(request)
     end
   end
 
@@ -240,8 +152,8 @@ describe Committee::RequestUnpacker do
       "rack.input"   => StringIO.new('{"x":"y"}'),
     }
     request = Rack::Request.new(env)
-    params, _ = Committee::RequestUnpacker.new(request).call
-    assert_equal({}, params)
+    unpacker = Committee::RequestUnpacker.new
+    assert_equal([{}, false], unpacker.unpack_request_params(request))
   end
 
   # this is mostly here for line coverage
@@ -250,8 +162,8 @@ describe Committee::RequestUnpacker do
       "rack.input" => StringIO.new('{"x":[]}'),
     }
     request = Rack::Request.new(env)
-    params, _ = Committee::RequestUnpacker.new(request).call
-    assert_equal({ "x" => [] }, params)
+    unpacker = Committee::RequestUnpacker.new
+    assert_equal([{ "x" => [] }, false], unpacker.unpack_request_params(request))
   end
 
   it "unpacks http header" do
@@ -260,8 +172,8 @@ describe Committee::RequestUnpacker do
       "rack.input"   => StringIO.new(""),
     }
     request = Rack::Request.new(env)
-    _, headers = Committee::RequestUnpacker.new(request, { allow_header_params: true }).call
-    assert_equal({ "FOO-BAR" => "some header value" }, headers)
+    unpacker = Committee::RequestUnpacker.new({ allow_header_params: true })
+    assert_equal({ "FOO-BAR" => "some header value" }, unpacker.unpack_headers(request))
   end
 
   it "includes request body when`use_get_body` is true" do
@@ -271,8 +183,8 @@ describe Committee::RequestUnpacker do
         "QUERY_STRING"=>"data=value&x=aaa",
     }
     request = Rack::Request.new(env)
-    params, _ = Committee::RequestUnpacker.new(request, { allow_query_params: true, allow_get_body: true }).call
-    assert_equal({ 'data' => 'value', 'x' => 1, 'y' => 2 }, params)
+    unpacker = Committee::RequestUnpacker.new({ allow_query_params: true, allow_get_body: true })
+    assert_equal([{ 'x' => 1, 'y' => 2 }, false], unpacker.unpack_request_params(request))
   end
 
   it "doesn't include request body when `use_get_body` is false" do
@@ -282,7 +194,7 @@ describe Committee::RequestUnpacker do
         "QUERY_STRING"=>"data=value&x=aaa",
     }
     request = Rack::Request.new(env)
-    params, _ = Committee::RequestUnpacker.new(request, { allow_query_params: true, use_get_body: false }).call
-    assert_equal({ 'data' => 'value', 'x' => 'aaa' }, params)
+    unpacker = Committee::RequestUnpacker.new({ allow_query_params: true, use_get_body: false })
+    assert_equal({ 'data' => 'value', 'x' => 'aaa' }, unpacker.unpack_query_params(request))
   end
 end

data/test/schema_validator/open_api_3/operation_wrapper_test.rb

@@ -81,7 +81,7 @@ describe Committee::SchemaValidator::OpenAPI3::OperationWrapper do
         operation_object.validate_request_params({"integer" => "str"}, HEADER, @validator_option)
       }
 
-      assert_match(/expected integer, but received String: str/i, e.message)
+      assert_match(/expected integer, but received String: "str"/i, e.message)
       assert_kind_of(OpenAPIParser::OpenAPIError, e.original_error)
     end
 
@@ -150,7 +150,7 @@ describe Committee::SchemaValidator::OpenAPI3::OperationWrapper do
           operation_object.validate_request_params({"limit" => "a"}, HEADER, @validator_option)
         }
 
-        assert_match(/expected integer, but received String: a/i, e.message)
+        assert_match(/expected integer, but received String: "a"/i, e.message)
         assert_kind_of(OpenAPIParser::OpenAPIError, e.original_error)
       end
     end

data/test/test/methods_new_version_test.rb

@@ -39,7 +39,7 @@ describe Committee::Test::Methods do
     it "passes through a valid response" do
       @app = new_rack_app(JSON.generate([ValidApp]))
       get "/apps"
-      assert_schema_conform
+      assert_schema_conform(200)
     end
 
     it "passes with prefix" do
@@ -47,18 +47,27 @@ describe Committee::Test::Methods do
 
       @app = new_rack_app(JSON.generate([ValidApp]))
       get "/v1/apps"
-      assert_schema_conform
+      assert_schema_conform(200)
     end
 
     it "detects an invalid response Content-Type" do
       @app = new_rack_app(JSON.generate([ValidApp]), 200, {})
       get "/apps"
       e = assert_raises(Committee::InvalidResponse) do
-        assert_schema_conform
+        assert_schema_conform(200)
       end
       assert_match(/response header must be set to/i, e.message)
     end
 
+    it "it detects unexpected response code" do
+      @app = new_rack_app(JSON.generate([ValidApp]), 400)
+      get "/apps"
+      e = assert_raises(Committee::InvalidResponse) do
+        assert_schema_conform(200)
+      end
+      assert_match(/Expected `200` status code, but it was `400`/i, e.message)
+    end
+
     it "detects an invalid response Content-Type but ignore because it's not success status code" do
       @committee_options.merge!(validate_success_only: true)
       @app = new_rack_app(JSON.generate([ValidApp]), 400, {})
@@ -70,7 +79,7 @@ describe Committee::Test::Methods do
       @app = new_rack_app(JSON.generate([ValidApp]), 400, {})
       get "/apps"
       e = assert_raises(Committee::InvalidResponse) do
-        assert_schema_conform
+        assert_schema_conform(400)
       end
       assert_match(/response header must be set to/i, e.message)
     end

data/test/test/methods_test.rb

@@ -46,14 +46,14 @@ describe Committee::Test::Methods do
       it "passes through a valid response" do
         @app = new_rack_app(JSON.generate([ValidApp]))
         get "/apps"
-        assert_schema_conform
+        assert_schema_conform(200)
       end
 
       it "detects an invalid response Content-Type" do
         @app = new_rack_app(JSON.generate([ValidApp]), {})
         get "/apps"
         e = assert_raises(Committee::InvalidResponse) do
-          assert_schema_conform
+          assert_schema_conform(200)
         end
         assert_match(/response header must be set to/i, e.message)
       end
@@ -64,7 +64,8 @@ describe Committee::Test::Methods do
         _, err = capture_io do
           assert_schema_conform
         end
-        assert_match(/\[DEPRECATION\]/i, err)
+        assert_match(/\[DEPRECATION\] Now assert_schema_conform check response schema only/i, err)
+        assert_match(/\[DEPRECATION\] Pass expected response status code/i, err)
       end
     end
 
@@ -161,7 +162,8 @@ describe Committee::Test::Methods do
         _, err = capture_io do
           assert_schema_conform
         end
-        assert_match(/\[DEPRECATION\]/i, err)
+        assert_match(/\[DEPRECATION\] Now assert_schema_conform check response schema only/i, err)
+        assert_match(/\[DEPRECATION\] Pass expected response status code/i, err)
       end
     end
 

data/test/test_helper.rb

@@ -55,6 +55,10 @@ def open_api_2_schema
   @open_api_2_schema ||= Committee::Drivers.load_from_file(open_api_2_schema_path)
 end
 
+def open_api_2_form_schema
+  @open_api_2_form_schema ||= Committee::Drivers.load_from_file(open_api_2_form_schema_path)
+end
+
 def open_api_3_schema
   @open_api_3_schema ||= Committee::Drivers.load_from_file(open_api_3_schema_path)
 end
@@ -73,6 +77,10 @@ def open_api_2_data
   JSON.parse(File.read(open_api_2_schema_path))
 end
 
+def open_api_2_form_data
+  JSON.parse(File.read(open_api_2_form_schema_path))
+end
+
 def open_api_3_data
   YAML.load_file(open_api_3_schema_path)
 end
@@ -85,6 +93,10 @@ def open_api_2_schema_path
   "./test/data/openapi2/petstore-expanded.json"
 end
 
+def open_api_2_form_schema_path
+  "./test/data/openapi2/petstore-expanded-form.json"
+end
+
 def open_api_3_schema_path
   "./test/data/openapi3/normal.yaml"
 end

metadata

@@ -1,16 +1,16 @@
 --- !ruby/object:Gem::Specification
 name: committee
 version: !ruby/object:Gem::Version
-  version: 4.3.0
+  version: 4.4.0.rc1
 platform: ruby
 authors:
 - Brandur
 - geemus (Wesley Beary)
 - ota42y
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-12-23 00:00:00.000000000 Z
+date: 2021-05-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: json_schema
@@ -146,6 +146,20 @@ dependencies:
         version: '0'
 - !ruby/object:Gem::Dependency
   name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: 1.13.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: 1.13.0
+- !ruby/object:Gem::Dependency
+  name: rubocop-performance
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -159,7 +173,21 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: rubocop-performance
+  name: rubocop-minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rubocop-rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -186,7 +214,7 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-description: 
+description:
 email:
 - brandur@mutelight.org
 - geemus+github@gmail.com
@@ -239,6 +267,7 @@ files:
 - lib/committee/schema_validator/option.rb
 - lib/committee/test/methods.rb
 - lib/committee/test/schema_coverage.rb
+- lib/committee/utils.rb
 - lib/committee/validation_error.rb
 - test/bin/committee_stub_test.rb
 - test/bin_test.rb
@@ -276,7 +305,7 @@ homepage: https://github.com/interagent/committee
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -287,12 +316,12 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: 2.4.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
-rubygems_version: 3.1.2
-signing_key: 
+rubygems_version: 3.2.3
+signing_key:
 specification_version: 4
 summary: A collection of Rack middleware to support JSON Schema.
 test_files: []