openapi_first 2.1.1 → 2.2.1

data/lib/openapi_first/request.rb

@@ -11,82 +11,43 @@ module OpenapiFirst
   # This class represents one of those requests.
   class Request
     def initialize(path:, request_method:, operation_object:,
-                   parameters:, content_type:, content_schema:, required_body:,
-                   hooks:, openapi_version:)
+                   parameters:, content_type:, content_schema:, required_body:)
       @path = path
       @request_method = request_method
       @content_type = content_type
       @content_schema = content_schema
-      @required_request_body = required_body == true
       @operation = operation_object
-      @parameters = build_parameters(parameters)
       @request_parser = RequestParser.new(
-        query_parameters: @parameters[:query],
-        path_parameters: @parameters[:path],
-        header_parameters: @parameters[:header],
-        cookie_parameters: @parameters[:cookie],
+        query_parameters: parameters.query,
+        path_parameters: parameters.path,
+        header_parameters: parameters.header,
+        cookie_parameters: parameters.cookie,
         content_type:
       )
-      @validator = RequestValidator.new(self, hooks:, openapi_version:)
+      @validator = RequestValidator.new(
+        content_schema:,
+        required_request_body: required_body == true,
+        path_schema: parameters.path_schema,
+        query_schema: parameters.query_schema,
+        header_schema: parameters.header_schema,
+        cookie_schema: parameters.cookie_schema
+      )
     end
 
     attr_reader :content_type, :content_schema, :operation, :request_method, :path
 
     def validate(request, route_params:)
-      parsed_values = {}
+      parsed_request = nil
       error = catch FAILURE do
-        parsed_values = @request_parser.parse(request, route_params:)
-        @validator.call(parsed_values)
+        parsed_request = @request_parser.parse(request, route_params:)
+        @validator.call(parsed_request)
         nil
       end
-      ValidatedRequest.new(request, parsed_values:, error:, request_definition: self)
-    end
-
-    # These return a Schema instance for each type of parameters
-    %i[path query header cookie].each do |location|
-      define_method(:"#{location}_schema") do
-        build_parameters_schema(@parameters[location])
-      end
-    end
-
-    def required_request_body?
-      @required_request_body
+      ValidatedRequest.new(request, parsed_request:, error:, request_definition: self)
     end
 
     def operation_id
       @operation['operationId']
     end
-
-    private
-
-    IGNORED_HEADERS = Set['Content-Type', 'Accept', 'Authorization'].freeze
-    private_constant :IGNORED_HEADERS
-
-    def build_parameters(parameter_definitions)
-      result = {}
-      parameter_definitions&.each do |parameter|
-        (result[parameter['in'].to_sym] ||= []) << parameter
-      end
-      result[:header]&.reject! { IGNORED_HEADERS.include?(_1['name']) }
-      result
-    end
-
-    def build_parameters_schema(parameters)
-      return unless parameters
-
-      properties = {}
-      required = []
-      parameters.each do |parameter|
-        schema = parameter['schema']
-        name = parameter['name']
-        properties[name] = schema if schema
-        required << name if parameter['required']
-      end
-
-      {
-        'properties' => properties,
-        'required' => required
-      }
-    end
   end
 end

data/lib/openapi_first/request_body_parsers.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module OpenapiFirst
+  # @!visibility private
+  module RequestBodyParsers
+    DEFAULT = ->(request) { Utils.read_body(request) }
+
+    @parsers = {}
+
+    class << self
+      attr_reader :parsers
+
+      def register(pattern, parser)
+        parsers[pattern] = parser
+      end
+
+      def [](content_type)
+        key = parsers.keys.find { content_type.match?(_1) }
+        parsers.fetch(key) { DEFAULT }
+      end
+    end
+
+    # Not sure where to put this
+    module Utils
+      def self.read_body(request)
+        body = request.body&.read
+        request.body.rewind if request.body.respond_to?(:rewind)
+        body
+      end
+    end
+
+    register(/json/i, lambda do |request|
+      body = Utils.read_body(request)
+      JSON.parse(body) unless body.nil? || body.empty?
+    rescue JSON::ParserError
+      Failure.fail!(:invalid_body, message: 'Failed to parse request body as JSON')
+    end)
+
+    register('multipart/form-data', lambda { |request|
+      request.POST.transform_values do |value|
+        value.is_a?(Hash) && value[:tempfile] ? value[:tempfile].read : value
+      end
+    })
+
+    register('application/x-www-form-urlencoded', lambda(&:POST))
+  end
+end

data/lib/openapi_first/request_parser.rb

@@ -1,9 +1,11 @@
 # frozen_string_literal: true
 
 require 'openapi_parameters'
-require_relative 'body_parser'
+require_relative 'request_body_parsers'
 
 module OpenapiFirst
+  ParsedRequest = Data.define(:path, :query, :headers, :body, :cookies)
+
   # Parse a request
   class RequestParser
     def initialize(
@@ -17,19 +19,19 @@ module OpenapiFirst
       @path_parser = OpenapiParameters::Path.new(path_parameters) if path_parameters
       @headers_parser = OpenapiParameters::Header.new(header_parameters) if header_parameters
       @cookies_parser = OpenapiParameters::Cookie.new(cookie_parameters) if cookie_parameters
-      @body_parser = BodyParser.new(content_type) if content_type
+      @body_parsers = RequestBodyParsers[content_type] if content_type
     end
 
     attr_reader :query, :path, :headers, :cookies
 
     def parse(request, route_params:)
-      result = {}
-      result[:path] = @path_parser.unpack(route_params) if @path_parser
-      result[:query] = @query_parser.unpack(request.env[Rack::QUERY_STRING]) if @query_parser
-      result[:headers] = @headers_parser.unpack_env(request.env) if @headers_parser
-      result[:cookies] = @cookies_parser.unpack(request.env[Rack::HTTP_COOKIE]) if @cookies_parser
-      result[:body] = @body_parser.parse(request) if @body_parser
-      result
+      ParsedRequest.new(
+        path: @path_parser&.unpack(route_params),
+        query: @query_parser&.unpack(request.env[Rack::QUERY_STRING]),
+        headers: @headers_parser&.unpack_env(request.env),
+        cookies: @cookies_parser&.unpack(request.env[Rack::HTTP_COOKIE]),
+        body: @body_parsers&.call(request)
+      )
     end
   end
 end

data/lib/openapi_first/request_validator.rb

@@ -7,15 +7,22 @@ require_relative 'validators/request_body'
 module OpenapiFirst
   # Validates a Request against a request definition.
   class RequestValidator
-    VALIDATORS = [
-      Validators::RequestParameters,
-      Validators::RequestBody
-    ].freeze
-
-    def initialize(request_definition, openapi_version:, hooks: {})
-      @validators = VALIDATORS.filter_map do |klass|
-        klass.for(request_definition, hooks:, openapi_version:)
-      end
+    def initialize(
+      content_schema:,
+      required_request_body:,
+      path_schema:,
+      query_schema:,
+      header_schema:,
+      cookie_schema:
+    )
+      @validators = []
+      @validators << Validators::RequestBody.new(content_schema:, required_request_body:) if content_schema
+      @validators.concat Validators::RequestParameters.for(
+        path_schema:,
+        query_schema:,
+        header_schema:,
+        cookie_schema:
+      )
     end
 
     def call(parsed_request)

data/lib/openapi_first/response.rb

@@ -9,14 +9,14 @@ module OpenapiFirst
   # This is not a direct reflecton of the OpenAPI 3.X response definition, but a combination of
   # status, content type and content schema.
   class Response
-    def initialize(status:, headers:, content_type:, content_schema:, openapi_version:)
+    def initialize(status:, headers:, headers_schema:, content_type:, content_schema:)
       @status = status
       @content_type = content_type
       @content_schema = content_schema
       @headers = headers
-      @headers_schema = build_headers_schema(headers)
+      @headers_schema = headers_schema
       @parser = ResponseParser.new(headers:, content_type:)
-      @validator = ResponseValidator.new(self, openapi_version:)
+      @validator = ResponseValidator.new(self)
     end
 
     # @attr_reader [Integer] status The HTTP status code of the response definition.
@@ -35,23 +35,5 @@ module OpenapiFirst
     def parse(request)
       @parser.parse(request)
     end
-
-    def build_headers_schema(headers_object)
-      return unless headers_object&.any?
-
-      properties = {}
-      required = []
-      headers_object.each do |name, header|
-        schema = header['schema']
-        next if name.casecmp('content-type').zero?
-
-        properties[name] = schema if schema
-        required << name if header['required']
-      end
-      {
-        'properties' => properties,
-        'required' => required
-      }
-    end
   end
 end

data/lib/openapi_first/response_body_parsers.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module OpenapiFirst
+  # @visibility private
+  module ResponseBodyParsers
+    DEFAULT = ->(body) { body }
+
+    @parsers = {}
+
+    class << self
+      attr_reader :parsers
+
+      def register(pattern, parser)
+        parsers[pattern] = parser
+      end
+
+      def [](content_type)
+        key = parsers.keys.find { content_type&.match?(_1) }
+        parsers.fetch(key) { DEFAULT }
+      end
+    end
+
+    register(/json/i, lambda do |body|
+      JSON.parse(body)
+    rescue JSON::ParserError
+      Failure.fail!(:invalid_response_body, message: 'Response body is invalid: Failed to parse response body as JSON')
+    end)
+  end
+end

data/lib/openapi_first/response_parser.rb

@@ -1,40 +1,26 @@
 # frozen_string_literal: true
 
+require_relative 'response_body_parsers'
+
 module OpenapiFirst
   ParsedResponse = Data.define(:body, :headers)
 
   # Parse a response
   class ResponseParser
     def initialize(headers:, content_type:)
-      @headers = headers
-      @json = /json/i.match?(content_type)
+      @headers_parser = build_headers_parser(headers)
+      @body_parser = ResponseBodyParsers[content_type]
     end
 
     def parse(rack_response)
       ParsedResponse.new(
-        body: parse_body(read_body(rack_response)),
-        headers: parse_headers(rack_response)
+        body: @body_parser.call(read_body(rack_response)),
+        headers: @headers_parser.call(rack_response.headers)
       )
     end
 
     private
 
-    attr_reader :headers
-
-    def json? = @json
-
-    def parse_body(body)
-      return parse_json(body) if json?
-
-      body
-    end
-
-    def parse_json(body)
-      MultiJson.load(body)
-    rescue MultiJson::ParseError
-      Failure.fail!(:invalid_response_body, message: 'Response body is invalid: Failed to parse response body as JSON')
-    end
-
     def read_body(rack_response)
       buffered_body = +''
       if rack_response.body.respond_to?(:each)
@@ -44,14 +30,11 @@ module OpenapiFirst
       rack_response.body
     end
 
-    def parse_headers(rack_response)
-      return {} if headers.nil?
-
-      # TODO: memoize unpacker
-      headers_as_parameters = headers.map do |name, definition|
+    def build_headers_parser(header_definitions)
+      headers_as_parameters = header_definitions.to_a.map do |name, definition|
         definition.merge('name' => name, 'in' => 'header')
       end
-      OpenapiParameters::Header.new(headers_as_parameters).unpack(rack_response.headers)
+      OpenapiParameters::Header.new(headers_as_parameters).method(:unpack)
     end
   end
 end

data/lib/openapi_first/response_validator.rb

@@ -11,9 +11,9 @@ module OpenapiFirst
       Validators::ResponseBody
     ].freeze
 
-    def initialize(response_definition, openapi_version:)
+    def initialize(response_definition)
       @validators = VALIDATORS.filter_map do |klass|
-        klass.for(response_definition, openapi_version:)
+        klass.for(response_definition)
       end
     end
 

data/lib/openapi_first/test/methods.rb

@@ -1,20 +1,19 @@
 # frozen_string_literal: true
 
+require_relative 'minitest_helpers'
+require_relative 'plain_helpers'
+
 module OpenapiFirst
+  # Test integration
   module Test
     # Methods to use in integration tests
     module Methods
-      def assert_api_conform(status: nil, api: :default)
-        api = OpenapiFirst::Test[api]
-        request = respond_to?(:last_request) ? last_request : @request
-        response = respond_to?(:last_response) ? last_response : @response
-        if status && status != response.status
-          raise OpenapiFirst::Error,
-                "Expected status #{status}, but got #{response.status} " \
-                "from #{request.request_method.upcase} #{request.path}."
+      def self.included(base)
+        if Test.minitest?(base)
+          base.include(OpenapiFirst::Test::MinitestHelpers)
+        else
+          base.include(OpenapiFirst::Test::PlainHelpers)
         end
-        api.validate_request(request, raise_error: true)
-        api.validate_response(request, response, raise_error: true)
       end
     end
   end

data/lib/openapi_first/test/minitest_helpers.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module OpenapiFirst
+  module Test
+    # Assertion methods for Minitest
+    module MinitestHelpers
+      # :nocov:
+      def assert_api_conform(status: nil, api: :default)
+        api = OpenapiFirst::Test[api]
+        request = respond_to?(:last_request) ? last_request : @request
+        response = respond_to?(:last_response) ? last_response : @response
+
+        if status
+          assert_equal status, response.status,
+                       "Expected status #{status}, but got #{response.status} " \
+                       "from #{request.request_method.upcase} #{request.path}."
+        end
+
+        validated_request = api.validate_request(request, raise_error: false)
+        validated_response = api.validate_response(request, response, raise_error: false)
+
+        assert validated_request.valid?, validated_request.error&.exception_message
+        assert validated_response.valid?, validated_response.error&.exception_message
+      end
+      # :nocov:
+    end
+  end
+end

data/lib/openapi_first/test/plain_helpers.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module OpenapiFirst
+  module Test
+    # Assertion methods to use when no known test framework was found
+    # These methods just raise an exception if an error was found
+    module PlainHelpers
+      def assert_api_conform(status: nil, api: :default)
+        api = OpenapiFirst::Test[api]
+        # :nocov:
+        request = respond_to?(:last_request) ? last_request : @request
+        response = respond_to?(:last_response) ? last_response : @response
+        # :nocov:
+
+        if status && status != response.status
+          raise OpenapiFirst::Error,
+                "Expected status #{status}, but got #{response.status} " \
+                "from #{request.request_method.upcase} #{request.path}."
+        end
+
+        api.validate_request(request, raise_error: true)
+        api.validate_response(request, response, raise_error: true)
+      end
+    end
+  end
+end

data/lib/openapi_first/test.rb

@@ -5,6 +5,12 @@ require_relative 'test/methods'
 module OpenapiFirst
   # Test integration
   module Test
+    def self.minitest?(base)
+      base.include?(::Minitest::Assertions)
+    rescue NameError
+      false
+    end
+
     class NotRegisteredError < StandardError; end
 
     DEFINITIONS = {} # rubocop:disable Style/MutableConstant

data/lib/openapi_first/validated_request.rb

@@ -8,9 +8,9 @@ module OpenapiFirst
   class ValidatedRequest < SimpleDelegator
     extend Forwardable
 
-    def initialize(original_request, error:, parsed_values: {}, request_definition: nil)
+    def initialize(original_request, error:, parsed_request: nil, request_definition: nil)
       super(original_request)
-      @parsed_values = Hash.new({}).merge(parsed_values)
+      @parsed_request = parsed_request
       @error = error
       @request_definition = request_definition
     end
@@ -33,57 +33,41 @@ module OpenapiFirst
 
     # Parsed path parameters
     # @return [Hash<String, anything>]
-    def parsed_path_parameters
-      @parsed_values[:path]
-    end
+    def parsed_path_parameters = @parsed_request&.path || {}
 
     # Parsed query parameters. This only returns the query parameters that are defined in the OpenAPI spec.
     # @return [Hash<String, anything>]
-    def parsed_query
-      @parsed_values[:query]
-    end
+    def parsed_query = @parsed_request&.query || {}
 
     # Parsed headers. This only returns the query parameters that are defined in the OpenAPI spec.
     # @return [Hash<String, anything>]
-    def parsed_headers
-      @parsed_values[:headers]
-    end
+    def parsed_headers = @parsed_request&.headers || {}
 
     # Parsed cookies. This only returns the query parameters that are defined in the OpenAPI spec.
     # @return [Hash<String, anything>]
-    def parsed_cookies
-      @parsed_values[:cookies]
-    end
+    def parsed_cookies = @parsed_request&.cookies || {}
 
     # Parsed body. This parses the body according to the content type.
     # Note that this returns the hole body, not only the fields that are defined in the OpenAPI spec.
     # You can use JSON Schemas `additionalProperties` or `unevaluatedProperties` to
-    # returns a validation error if the body contains unknown fields.
-    # @return [Hash<String, anything>]
-    def parsed_body
-      @parsed_values[:body]
-    end
+    # return a validation error if the body contains unknown fields.
+    # @return [Hash<String, anything>, anything]
+    def parsed_body = @parsed_request&.body
 
     # Checks if the request is valid.
-    def valid?
-      error.nil?
-    end
+    def valid? = error.nil?
 
     # Checks if the request is invalid.
-    def invalid?
-      !valid?
-    end
+    def invalid? = !valid?
 
     # Returns true if the request is defined.
-    def known?
-      request_definition != nil
-    end
+    def known? = request_definition != nil
 
     # Merged path, query, body parameters.
     # Here path has the highest precedence, then query, then body.
     # @return [Hash<String, anything>]
     def parsed_params
-      @parsed_params ||= parsed_body.merge(parsed_query, parsed_path_parameters)
+      @parsed_params ||= parsed_body.to_h.merge(parsed_query, parsed_path_parameters) || {}
     end
   end
 end

data/lib/openapi_first/validators/request_body.rb

@@ -3,37 +3,23 @@
 module OpenapiFirst
   module Validators
     class RequestBody
-      def self.for(request_definition, openapi_version:, hooks: {})
-        schema = request_definition.content_schema
-        return unless schema
-
-        after_property_validation = hooks[:after_request_body_property_validation]
-
-        new(Schema.new(schema, after_property_validation:, openapi_version:),
-            required: request_definition.required_request_body?)
-      end
-
-      def initialize(schema, required:)
-        @schema = schema
-        @required = required
+      def initialize(content_schema:, required_request_body:)
+        @schema = content_schema
+        @required = required_request_body
       end
 
-      def call(request)
-        request_body = read_body(request)
-        if request_body.nil?
+      def call(parsed_request)
+        body = parsed_request.body
+        if body.nil?
           Failure.fail!(:invalid_body, message: 'Request body is not defined') if @required
           return
         end
 
-        validation = @schema.validate(request_body)
+        validation = Schema::ValidationResult.new(
+          @schema.validate(body, access_mode: 'write')
+        )
         Failure.fail!(:invalid_body, errors: validation.errors) if validation.error?
       end
-
-      private
-
-      def read_body(request)
-        request[:body]
-      end
     end
   end
 end

data/lib/openapi_first/validators/request_parameters.rb

@@ -2,31 +2,35 @@
 
 module OpenapiFirst
   module Validators
-    class RequestParameters
+    module RequestParameters
       RequestHeaders = Data.define(:schema) do
-        def call(parsed_values)
-          validation = schema.validate(parsed_values[:headers])
+        def call(parsed_request)
+          validation = schema.validate(parsed_request.headers)
+          validation = Schema::ValidationResult.new(validation.to_a)
           Failure.fail!(:invalid_header, errors: validation.errors) if validation.error?
         end
       end
 
       Path = Data.define(:schema) do
-        def call(parsed_values)
-          validation = schema.validate(parsed_values[:path])
+        def call(parsed_request)
+          validation = schema.validate(parsed_request.path)
+          validation = Schema::ValidationResult.new(validation.to_a)
           Failure.fail!(:invalid_path, errors: validation.errors) if validation.error?
         end
       end
 
       Query = Data.define(:schema) do
-        def call(parsed_values)
-          validation = schema.validate(parsed_values[:query])
+        def call(parsed_request)
+          validation = schema.validate(parsed_request.query)
+          validation = Schema::ValidationResult.new(validation.to_a)
           Failure.fail!(:invalid_query, errors: validation.errors) if validation.error?
         end
       end
 
       RequestCookies = Data.define(:schema) do
-        def call(parsed_values)
-          validation = schema.validate(parsed_values[:cookies])
+        def call(parsed_request)
+          validation = schema.validate(parsed_request.cookies)
+          validation = Schema::ValidationResult.new(validation.to_a)
           Failure.fail!(:invalid_cookie, errors: validation.errors) if validation.error?
         end
       end
@@ -38,23 +42,11 @@ module OpenapiFirst
         cookie_schema: RequestCookies
       }.freeze
 
-      def self.for(operation, openapi_version:, hooks: {})
-        after_property_validation = hooks[:after_request_parameter_property_validation]
-        validators = VALIDATORS.filter_map do |key, klass|
-          schema = operation.send(key)
-          klass.new(Schema.new(schema, after_property_validation:, openapi_version:)) if schema
+      def self.for(args)
+        VALIDATORS.filter_map do |key, klass|
+          schema = args[key]
+          klass.new(schema) if schema.value
         end
-        return if validators.empty?
-
-        new(validators)
-      end
-
-      def initialize(validators)
-        @validators = validators
-      end
-
-      def call(parsed_values)
-        @validators.each { |validator| validator.call(parsed_values) }
       end
     end
   end