openapi_first 1.0.0.beta6 → 1.0.0

data/lib/openapi_first/response_validation.rb

@@ -1,113 +0,0 @@
-# frozen_string_literal: true
-
-require 'multi_json'
-require_relative 'use_router'
-
-module OpenapiFirst
-  class ResponseValidation
-    prepend UseRouter
-
-    def initialize(app, _options = {})
-      @app = app
-    end
-
-    def call(env)
-      operation = env[OPERATION]
-      return @app.call(env) unless operation
-
-      response = @app.call(env)
-      validate(response, operation)
-      response
-    end
-
-    def validate(response, operation)
-      status, headers, body = response.to_a
-      response_definition = response_for(operation, status)
-
-      validate_response_headers(response_definition.headers, headers, openapi_version: operation.openapi_version)
-
-      return if no_content?(response_definition)
-
-      content_type = Rack::Response[status, headers, body].content_type
-      raise ResponseInvalid, "Response has no content-type for '#{operation.name}'" unless content_type
-
-      response_schema = response_definition.schema_for(content_type)
-      unless response_schema
-        message = "Response content type not found '#{content_type}' for '#{operation.name}'"
-        raise ResponseContentTypeNotFoundError, message
-      end
-      validate_response_body(response_schema, body)
-    end
-
-    private
-
-    def no_content?(response_definition)
-      response_definition.status == 204 || !response_definition.content?
-    end
-
-    def response_for(operation, status)
-      response = operation.response_for(status)
-      return response if response
-
-      message = "Response status code or default not found: #{status} for '#{operation.name}'"
-      raise OpenapiFirst::ResponseCodeNotFoundError, message
-    end
-
-    def validate_status_only(operation, status)
-      response_for(operation, status)
-    end
-
-    def validate_response_body(schema, response)
-      full_body = +''
-      response.each { |chunk| full_body << chunk }
-      data = full_body.empty? ? {} : load_json(full_body)
-      validation = schema.validate(data)
-      raise ResponseBodyInvalidError, validation.message if validation.error?
-    end
-
-    def validate_response_headers(response_header_definitions, response_headers, openapi_version:)
-      return unless response_header_definitions
-
-      unpacked_headers = unpack_response_headers(response_header_definitions, response_headers)
-      response_header_definitions.each do |name, definition|
-        next if name == 'Content-Type'
-
-        validate_response_header(name, definition, unpacked_headers, openapi_version:)
-      end
-    end
-
-    def validate_response_header(name, definition, unpacked_headers, openapi_version:)
-      unless unpacked_headers.key?(name)
-        raise ResponseHeaderInvalidError, "Required response header '#{name}' is missing" if definition['required']
-
-        return
-      end
-
-      return unless definition.key?('schema')
-
-      validation = Schema.new(definition['schema'], openapi_version:)
-      value = unpacked_headers[name]
-      schema_validation = validation.validate(value)
-      raise ResponseHeaderInvalidError, schema_validation.message if schema_validation.error?
-    end
-
-    def unpack_response_headers(response_header_definitions, response_headers)
-      headers_as_parameters = response_header_definitions.map do |name, definition|
-        definition.merge('name' => name, 'in' => 'header')
-      end
-      OpenapiParameters::Header.new(headers_as_parameters).unpack(response_headers)
-    end
-
-    def format_response_error(error)
-      return "Write-only field appears in response: #{error['data_pointer']}" if error['type'] == 'writeOnly'
-
-      JSONSchemer::Errors.pretty(error)
-    end
-
-    def load_json(string)
-      MultiJson.load(string)
-    rescue MultiJson::ParseError
-      string
-    end
-  end
-end

data/lib/openapi_first/response_validator.rb

@@ -1,21 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'response_validation'
-require_relative 'router'
-
-module OpenapiFirst
-  # A class to run manual response validation
-  class ResponseValidator
-    def initialize(spec)
-      @spec = spec
-      @router = Router.new(->(_env) {}, spec:, raise_error: true)
-      @response_validation = ResponseValidation.new(->(response) { response.to_a })
-    end
-
-    def validate(request, response)
-      env = request.env.dup
-      @router.call(env)
-      @response_validation.validate(response, env[OPERATION])
-    end
-  end
-end

data/lib/openapi_first/router.rb

@@ -1,68 +0,0 @@
-# frozen_string_literal: true
-
-require 'rack'
-require 'multi_json'
-require 'mustermann'
-require_relative 'body_parser'
-
-module OpenapiFirst
-  class Router
-    # The unconverted path parameters before they are converted to the types defined in the API description
-    RAW_PATH_PARAMS = 'openapi.raw_path_params'
-
-    NOT_FOUND = Rack::Response.new('Not Found', 404).finish.freeze
-    METHOD_NOT_ALLOWED = Rack::Response.new('Method Not Allowed', 405).finish.freeze
-
-    def initialize(
-      app,
-      options
-    )
-      @app = app
-      @raise = options.fetch(:raise_error, false)
-      @not_found = options.fetch(:not_found, :halt)
-      @error_response_class = options.fetch(:error_response, Config.default_options.error_response)
-      spec = options.fetch(:spec)
-      raise "You have to pass spec: when initializing #{self.class}" unless spec
-
-      @definition = spec.is_a?(Definition) ? spec : OpenapiFirst.load(spec)
-      @filepath = @definition.filepath
-    end
-
-    def call(env)
-      env[OPERATION] = nil
-      request = Rack::Request.new(env)
-      path_item, path_params = @definition.find_path_item_and_params(request.path)
-      operation = path_item&.find_operation(request.request_method.downcase)
-
-      env[OPERATION] = operation
-      env[RAW_PATH_PARAMS] = path_params
-
-      if operation.nil?
-        raise_error(env) if @raise
-        return @app.call(env) if @not_found == :continue
-      end
-
-      return NOT_FOUND unless path_item
-      return METHOD_NOT_ALLOWED unless operation
-
-      @app.call(env)
-    end
-
-    ORIGINAL_PATH = 'openapi_first.path_info'
-    private_constant :ORIGINAL_PATH
-
-    ROUTER_PARSED_BODY = 'router.parsed_body'
-    private_constant :ROUTER_PARSED_BODY
-
-    private
-
-    def raise_error(env)
-      req = Rack::Request.new(env)
-      msg =
-        "Could not find definition for #{req.request_method} '#{
-          req.path
-        }' in API description #{@filepath}"
-      raise NotFoundError, msg
-    end
-  end
-end

data/lib/openapi_first/use_router.rb

@@ -1,18 +0,0 @@
-# frozen_string_literal: true
-
-module OpenapiFirst
-  module UseRouter
-    def initialize(app, options = {})
-      @app = app
-      @options = options
-      super
-    end
-
-    def call(env)
-      return super if env.key?(OPERATION)
-
-      @router ||= Router.new(->(e) { super(e) }, @options)
-      @router.call(env)
-    end
-  end
-end