openapi_first 0.11.0 → 0.12.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3a7011597803fb49d100073027c9545634d497971b34ac49c2eeb0916258f424
-  data.tar.gz: 1f552e13bd915d41d39e2fffcc7a026b5abd3ba5c19ed4f726e3538c68a893df
+  metadata.gz: 689e572886b7ca556ffb00c89368195e129d954a03a3899f3d7d8401bd724196
+  data.tar.gz: e2669f12188188ac232d0c52b8a371e221ce65e589f2bd06dc6b7547fd0cafc2
 SHA512:
-  metadata.gz: 50053573288bde3ce62df411c706dc9fe64a4395b7110a539cf4e1b685b1953140cdbc8d9ad7e7d8b0eee4d9b4211243f7c3e85ef6b79a44720f9b56ae316c3f
-  data.tar.gz: 017b082c94490f45cc0cb90935c0f5a463958740d858b56f2d6baf1b2e579f9e5820acda5cc5f53c0d9fe50cc261600a1f8c93c498f165997f026f68617c888f
+  metadata.gz: c3409b992b56a09eb9e4bc75d20e6711a4ebda0bd93c0422316343ea48b4f8816394f1506b675c56e42f3dad339a0b7aa9c4834f0372045815a81888724ad45e
+  data.tar.gz: 2893535646d84f3ca6db6efc63c5334961929b9f6e561b8d36f771ca4ad0b9e25af5c5b06292ae9745610fa6dd229516c4aa4b42c01c52fc176294a1713b8767

data/CHANGELOG.md

@@ -1,5 +1,23 @@
 # Changelog
 
+## 0.12.2
+- Allow response to have no media type object specified
+
+## 0.12.1
+- Fix response when handler returns 404 or 405
+- Don't validate the response content if status is 205 (no content)
+
+## 0.12.0
+- Change `ResponseValidator` to raise an exception if it found a problem
+- Params have symbolized keys now
+- Remove `not_found` option from Router. Return 405 if HTTP verb is not allowed (via Hanami::Router)
+- Add `raise_error` option to OpenapiFirst.app (false by default)
+- Add ResponseValidation to OpenapiFirst.app if raise_error option is true
+- Rename `raise` option to `raise_error`
+- Add `raise_error` option to RequestValidation middleware
+- Raise error if handler could not be found by Responder
+- Add `Operation#name` that returns a human readable name for an operation
+
 ## 0.11.0
 - Raise error if you forgot to add the Router middleware
 - Make OpenapiFirst.app raise an error in test env when request path is not specified

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    openapi_first (0.11.0)
+    openapi_first (0.12.2)
       deep_merge (>= 1.2.1)
       hanami-router (~> 2.0.alpha3)
       hanami-utils (~> 2.0.alpha1)
@@ -13,7 +13,7 @@ PATH
 GEM
   remote: https://rubygems.org/
   specs:
-    activesupport (6.0.3.1)
+    activesupport (6.0.3.2)
       concurrent-ruby (~> 1.0, >= 1.0.2)
       i18n (>= 0.7, < 2)
       minitest (~> 5.1)
@@ -21,12 +21,12 @@ GEM
       zeitwerk (~> 2.2, >= 2.2.2)
     addressable (2.7.0)
       public_suffix (>= 2.0.2, < 5.0)
-    ast (2.4.0)
+    ast (2.4.1)
     builder (3.2.4)
     coderay (1.1.3)
     concurrent-ruby (1.1.6)
     deep_merge (1.2.1)
-    diff-lcs (1.3)
+    diff-lcs (1.4.2)
     ecma-re-validator (0.2.1)
       regexp_parser (~> 1.2)
     hana (1.3.6)
@@ -39,7 +39,7 @@ GEM
       transproc (~> 1.0)
     hansi (0.2.0)
     hash-deep-merge (0.1.1)
-    i18n (1.8.2)
+    i18n (1.8.3)
       concurrent-ruby (~> 1.0)
     json_schemer (0.2.11)
       ecma-re-validator (~> 0.2)
@@ -57,7 +57,7 @@ GEM
       mustermann (= 1.1.1)
     nokogiri (1.10.9)
       mini_portile2 (~> 2.4.0)
-    oas_parser (0.25.1)
+    oas_parser (0.25.2)
       activesupport (>= 4.0.0)
       addressable (~> 2.3)
       builder (~> 3.2.3)
@@ -65,19 +65,19 @@ GEM
       hash-deep-merge
       mustermann-contrib (~> 1.1.1)
       nokogiri
-    parallel (1.19.1)
-    parser (2.7.1.3)
-      ast (~> 2.4.0)
+    parallel (1.19.2)
+    parser (2.7.1.4)
+      ast (~> 2.4.1)
     pry (0.13.1)
       coderay (~> 1.1)
       method_source (~> 1.0)
     public_suffix (4.0.5)
-    rack (2.2.2)
+    rack (2.2.3)
     rack-test (1.1.0)
       rack (>= 1.0, < 3)
     rainbow (3.0.0)
     rake (13.0.1)
-    regexp_parser (1.7.0)
+    regexp_parser (1.7.1)
     rexml (3.2.4)
     rspec (3.9.0)
       rspec-core (~> 3.9.0)
@@ -92,13 +92,13 @@ GEM
       diff-lcs (>= 1.2.0, < 2.0)
       rspec-support (~> 3.9.0)
     rspec-support (3.9.3)
-    rubocop (0.85.0)
+    rubocop (0.86.0)
       parallel (~> 1.10)
       parser (>= 2.7.0.1)
       rainbow (>= 2.2.2, < 4.0)
       regexp_parser (>= 1.7)
       rexml
-      rubocop-ast (>= 0.0.3)
+      rubocop-ast (>= 0.0.3, < 1.0)
       ruby-progressbar (~> 1.7)
       unicode-display_width (>= 1.4.0, < 2.0)
     rubocop-ast (0.0.3)

data/README.md

@@ -8,6 +8,12 @@ Start with writing an OpenAPI file that describes the API, which you are about t
 
 You can use OpenapiFirst via its [Rack middlewares](#rack-middlewares) or in [standalone mode](#standalone-usage).
 
+## Alternatives
+
+This gem is inspired by [committee](https://github.com/interagent/committee) (Ruby) and [connexion](https://github.com/zalando/connexion) (Python).
+
+Here's a [comparison between committee and openapi_first](https://gist.github.com/ahx/1538c31f0652f459861713b5259e366a).
+
 ## Rack middlewares
 OpenapiFirst consists of these Rack middlewares:
 
@@ -30,8 +36,7 @@ Options and their defaults:
 | Name | Possible values | Description | Default
 |:---|---|---|---|
 |`spec:`| | The spec loaded via `OpenapiFirst.load` ||
-| `not_found:` |`nil`, `:continue`, `Proc`| Specifies what to do if the path was not found in the API description. `nil` (default) returns a 404 response. `:continue` does nothing an calls the next app. `Proc` (or something that responds to `call`) to customize the response. | `nil` (return 404)
-| `raise:` |`false`, `true` | If set to true the middleware raises `OpenapiFirst::NotFoundError` when a path or method was not found in the API description. This is useful during testing to spot an incomplete API description. | `false` (don't raise an exception)
+| `raise_error:` |`false`, `true` | If set to true the middleware raises `OpenapiFirst::NotFoundError` when a path or method was not found in the API description. This is useful during testing to spot an incomplete API description. | `false` (don't raise an exception)
 
 ## OpenapiFirst::RequestValidation
 
@@ -41,6 +46,13 @@ This middleware returns a 400 status code with a body that describes the error i
 use OpenapiFirst::RequestValidation
 ```
 
+
+Options and their defaults:
+
+| Name | Possible values | Description | Default
+|:---|---|---|---|
+| `raise_error:` |`false`, `true` | If set to true the middleware raises `OpenapiFirst::RequestInvalidError` instead of returning 4xx. | `false` (don't raise an exception)
+
 The error responses conform with [JSON:API](https://jsonapi.org).
 
 Here's an example response body for a missing query parameter "search":
@@ -117,7 +129,7 @@ There are two ways to set the response body:
 - Returning a value which will get converted to JSON
 
 ## OpenapiFirst::ResponseValidation
-This middleware is especially useful when testing. It raises an error if the response is not valid.
+This middleware is especially useful when testing. It *always* raises an error if the response is not valid.
 
 ```ruby
 use OpenapiFirst::ResponseValidation if ENV['RACK_ENV'] == 'test'
@@ -130,7 +142,7 @@ Instead of composing these middlewares yourself you can use `OpenapiFirst.app`.
 module Pets
   def self.find_pet(params, res)
     {
-      id: params['id'],
+      id: params[:id],
       name: 'Oscar'
     }
   end
@@ -177,7 +189,7 @@ OpenapiFirst uses [`multi_json`](https://rubygems.org/gems/multi_json).
 
 ## Manual response validation
 
-Response validation is useful to make sure your app responds as described in your API description. You usually do this in your tests using [rack-test](https://github.com/rack-test/rack-test).
+Instead of using the ResponseValidation middleware you can validate the response in your test manually via [rack-test](https://github.com/rack-test/rack-test) and ResponseValidator.
 
 ```ruby
 # In your test (rspec example):
@@ -185,7 +197,8 @@ require 'openapi_first'
 spec = OpenapiFirst.load('petstore.yaml')
 validator = OpenapiFirst::ResponseValidator.new(spec)
 
-expect(validator.validate(last_request, last_response).errors).to be_empty
+# This will raise an exception if it found an error
+validator.validate(last_request, last_response)
 ```
 
 ## Handling only certain paths
@@ -236,10 +249,6 @@ end
 
 Out of scope. Use [Prism](https://github.com/stoplightio/prism) or [fakeit](https://github.com/JustinFeng/fakeit).
 
-## Alternatives
-
-This gem is inspired by [committee](https://github.com/interagent/committee) (Ruby) and [connexion](https://github.com/zalando/connexion) (Python).
-
 ## Development
 
 Run `bin/setup` to install dependencies.

data/benchmarks/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: ..
   specs:
-    openapi_first (0.11.0)
+    openapi_first (0.12.2)
       deep_merge (>= 1.2.1)
       hanami-router (~> 2.0.alpha3)
       hanami-utils (~> 2.0.alpha1)
@@ -13,7 +13,7 @@ PATH
 GEM
   remote: https://rubygems.org/
   specs:
-    activesupport (6.0.3.1)
+    activesupport (6.0.3.2)
       concurrent-ruby (~> 1.0, >= 1.0.2)
       i18n (>= 0.7, < 2)
       minitest (~> 5.1)
@@ -31,7 +31,7 @@ GEM
       rack (>= 1.5)
     concurrent-ruby (1.1.6)
     deep_merge (1.2.1)
-    dry-configurable (0.11.5)
+    dry-configurable (0.11.6)
       concurrent-ruby (~> 1.0)
       dry-core (~> 0.4, >= 0.4.7)
       dry-equalizer (~> 0.2)
@@ -72,9 +72,9 @@ GEM
       transproc (~> 1.0)
     hansi (0.2.0)
     hash-deep-merge (0.1.1)
-    i18n (1.8.2)
+    i18n (1.8.3)
       concurrent-ruby (~> 1.0)
-    json_schema (0.20.8)
+    json_schema (0.20.9)
     json_schemer (0.2.11)
       ecma-re-validator (~> 0.2)
       hana (~> 1.3)
@@ -93,7 +93,7 @@ GEM
       mustermann (>= 1.0.0)
     nokogiri (1.10.9)
       mini_portile2 (~> 2.4.0)
-    oas_parser (0.25.1)
+    oas_parser (0.25.2)
       activesupport (>= 4.0.0)
       addressable (~> 2.3)
       builder (~> 3.2.3)
@@ -103,12 +103,12 @@ GEM
       nokogiri
     openapi_parser (0.11.2)
     public_suffix (4.0.5)
-    rack (2.2.2)
+    rack (2.2.3)
     rack-accept (0.4.5)
       rack (>= 0.4)
     rack-protection (2.0.8.1)
       rack
-    regexp_parser (1.7.0)
+    regexp_parser (1.7.1)
     ruby2_keywords (0.0.2)
     seg (1.2.0)
     sinatra (2.0.8.1)

data/benchmarks/apps/openapi_first.ru

@@ -5,7 +5,7 @@ require 'openapi_first'
 
 namespace = Module.new do
   def self.find_thing(params, _res)
-    { hello: 'world', id: params.fetch('id') }
+    { hello: 'world', id: params.fetch(:id) }
   end
 
   def self.find_things(_params, _res)

data/examples/app.rb

@@ -13,4 +13,9 @@ module Web
 end
 
 oas_path = File.absolute_path('./openapi.yaml', __dir__)
-App = OpenapiFirst.app(oas_path, namespace: Web)
+
+App = OpenapiFirst.app(
+  oas_path,
+  namespace: Web,
+  raise_error: OpenapiFirst.env == 'test'
+)

data/lib/openapi_first.rb

@@ -19,6 +19,10 @@ module OpenapiFirst
   INBOX = 'openapi_first.inbox'
   HANDLER = 'openapi_first.handler'
 
+  def self.env
+    ENV['RACK_ENV'] || ENV['HANAMI_ENV'] || ENV['RAILS_ENV']
+  end
+
   def self.load(spec_path, only: nil)
     content = YAML.load_file(spec_path)
     raw = OasParser::Parser.new(spec_path, content).resolve
@@ -27,15 +31,14 @@ module OpenapiFirst
     Definition.new(parsed)
   end
 
-  def self.app(spec, namespace:)
+  def self.app(spec, namespace:, raise_error: false)
     spec = OpenapiFirst.load(spec) if spec.is_a?(String)
-    test = ENV['RACK_ENV'] == 'test'
-    App.new(nil, spec, namespace: namespace, router_raise: test)
+    App.new(nil, spec, namespace: namespace, raise_error: raise_error)
   end
 
-  def self.middleware(spec, namespace:)
+  def self.middleware(spec, namespace:, raise_error: false)
     spec = OpenapiFirst.load(spec) if spec.is_a?(String)
-    AppWithOptions.new(spec, namespace: namespace, router_raise: false)
+    AppWithOptions.new(spec, namespace: namespace, raise_error: raise_error)
   end
 
   class AppWithOptions
@@ -51,7 +54,41 @@ module OpenapiFirst
 
   class Error < StandardError; end
   class NotFoundError < Error; end
-  class ResponseCodeNotFoundError < Error; end
-  class ResponseMediaTypeNotFoundError < Error; end
-  class ResponseBodyInvalidError < Error; end
+  class NotImplementedError < RuntimeError; end
+  class ResponseInvalid < Error; end
+  class ResponseCodeNotFoundError < ResponseInvalid; end
+  class ResponseContentTypeNotFoundError < ResponseInvalid; end
+  class ResponseBodyInvalidError < ResponseInvalid; end
+
+  class RequestInvalidError < Error
+    def initialize(serialized_errors)
+      message = error_message(serialized_errors)
+      super message
+    end
+
+    private
+
+    def error_message(errors)
+      errors.map do |error|
+        [human_source(error), human_error(error)].compact.join(' ')
+      end.join(', ')
+    end
+
+    def human_source(error)
+      return unless error[:source]
+
+      source_key = error[:source].keys.first
+      source = {
+        pointer: 'Request body invalid:',
+        parameter: 'Query parameter invalid:'
+      }.fetch(source_key, source_key)
+      name = error[:source].values.first
+      source += " #{name}" unless name.nil? || name.empty?
+      source
+    end
+
+    def human_error(error)
+      error[:title]
+    end
+  end
 end

data/lib/openapi_first/app.rb

@@ -5,11 +5,12 @@ require 'logger'
 
 module OpenapiFirst
   class App
-    def initialize(parent_app, spec, namespace:, router_raise:)
+    def initialize(parent_app, spec, namespace:, raise_error:)
       @stack = Rack::Builder.app do
         freeze_app
-        use OpenapiFirst::Router, spec: spec, raise: router_raise, parent_app: parent_app
-        use OpenapiFirst::RequestValidation
+        use OpenapiFirst::Router, spec: spec, raise_error: raise_error, parent_app: parent_app
+        use OpenapiFirst::RequestValidation, raise_error: raise_error
+        use OpenapiFirst::ResponseValidation if raise_error
         run OpenapiFirst::Responder.new(
           spec: spec,
           namespace: namespace

data/lib/openapi_first/definition.rb

@@ -14,17 +14,5 @@ module OpenapiFirst
     def operations
       @spec.endpoints.map { |e| Operation.new(e) }
     end
-
-    def find_operation!(request)
-      @spec
-        .path_by_path(request.path)
-        .endpoint_by_method(request.request_method.downcase)
-    end
-
-    def find_operation(request)
-      find_operation!(request)
-    rescue OasParser::PathNotFound, OasParser::MethodNotFound
-      nil
-    end
   end
 end

data/lib/openapi_first/find_handler.rb

@@ -5,14 +5,10 @@ require_relative 'utils'
 module OpenapiFirst
   class FindHandler
     def initialize(spec, namespace)
-      @spec = spec
       @namespace = namespace
-    end
-
-    def all
-      @spec.operations.each_with_object({}) do |operation, hash|
+      @handlers = spec.operations.each_with_object({}) do |operation, hash|
         operation_id = operation.operation_id
-        handler = find_by_operation_id(operation_id)
+        handler = find_handler(operation_id)
         if handler.nil?
           warn "#{self.class.name} cannot not find handler for '#{operation.operation_id}' (#{operation.method} #{operation.path}). This operation will be ignored." # rubocop:disable Layout/LineLength
           next
@@ -21,22 +17,17 @@ module OpenapiFirst
       end
     end
 
-    def find_by_operation_id(operation_id) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+    def [](operation_id)
+      @handlers[operation_id]
+    end
+
+    def find_handler(operation_id)
       name = operation_id.match(/:*(.*)/)&.to_a&.at(1)
       return if name.nil?
 
-      if name.include?('.')
-        module_name, method_name = name.split('.')
-        klass = find_const(@namespace, module_name)
-        return klass&.method(Utils.underscore(method_name))
-      end
-      if name.include?('#')
-        module_name, klass_name = name.split('#')
-        const = find_const(@namespace, module_name)
-        klass = find_const(const, klass_name)
-        return ->(params, res) { klass.new.call(params, res) } if klass.instance_method(:initialize).arity.zero?
-
-        return ->(params, res) { klass.new(params.env).call(params, res) }
+      catch :halt do
+        return find_class_method_handler(name) if name.include?('.')
+        return find_instance_method_handler(name) if name.include?('#')
       end
       method_name = Utils.underscore(name)
       return unless @namespace.respond_to?(method_name)
@@ -44,11 +35,24 @@ module OpenapiFirst
       @namespace.method(method_name)
     end
 
-    private
+    def find_class_method_handler(name)
+      module_name, method_name = name.split('.')
+      klass = find_const(@namespace, module_name)
+      klass.method(Utils.underscore(method_name))
+    end
+
+    def find_instance_method_handler(name)
+      module_name, klass_name = name.split('#')
+      const = find_const(@namespace, module_name)
+      klass = find_const(const, klass_name)
+      return ->(params, res) { klass.new.call(params, res) } if klass.instance_method(:initialize).arity.zero?
+
+      ->(params, res) { klass.new(params.env).call(params, res) }
+    end
 
     def find_const(parent, name)
       name = Utils.classify(name)
-      return unless parent.const_defined?(name, false)
+      throw :halt unless parent.const_defined?(name, false)
 
       parent.const_get(name, false)
     end

data/lib/openapi_first/operation.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require 'forwardable'
+require 'json_schemer'
 require_relative 'utils'
 require_relative 'response_object'
 
@@ -25,6 +26,10 @@ module OpenapiFirst
       @parameters_json_schema ||= build_parameters_json_schema
     end
 
+    def parameters_schema
+      @parameters_schema ||= parameters_json_schema && JSONSchemer.schema(parameters_json_schema)
+    end
+
     def content_type_for(status)
       content = response_for(status)['content']
       content.keys[0] if content
@@ -34,10 +39,12 @@ module OpenapiFirst
       content = response_for(status)['content']
       return if content.nil? || content.empty?
 
+      raise ResponseInvalid, "Response has no content-type for '#{name}'" unless content_type
+
       media_type = content[content_type]
       unless media_type
-        message = "Response media type found: '#{content_type}' for '#{operation_name}'"
-        raise ResponseMediaTypeNotFoundError, message
+        message = "Response content type not found '#{content_type}' for '#{name}'"
+        raise ResponseContentTypeNotFoundError, message
       end
       media_type['schema']
     end
@@ -45,16 +52,16 @@ module OpenapiFirst
     def response_for(status)
       @operation.response_by_code(status.to_s, use_default: true).raw
     rescue OasParser::ResponseCodeNotFound
-      message = "Response status code or default not found: #{status} for '#{operation_name}'"
+      message = "Response status code or default not found: #{status} for '#{name}'"
       raise OpenapiFirst::ResponseCodeNotFoundError, message
     end
 
-    private
-
-    def operation_name
-      "#{method.upcase} #{path}"
+    def name
+      "#{method.upcase} #{path} (#{operation_id})"
     end
 
+    private
+
     def build_parameters_json_schema
       return unless @operation.parameters&.any?
 

data/lib/openapi_first/request_validation.rb

@@ -11,8 +11,9 @@ module OpenapiFirst
   class RequestValidation # rubocop:disable Metrics/ClassLength
     prepend RouterRequired
 
-    def initialize(app)
+    def initialize(app, raise_error: false)
       @app = app
+      @raise = raise_error
     end
 
     def call(env) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
@@ -49,32 +50,32 @@ module OpenapiFirst
 
       parsed_request_body = parse_request_body!(body)
       errors = validate_json_schema(schema, parsed_request_body)
-      halt(error_response(400, serialize_request_body_errors(errors))) if errors.any?
+      halt_with_error(400, serialize_request_body_errors(errors)) if errors.any?
       env[INBOX].merge! env[REQUEST_BODY] = parsed_request_body
     end
 
     def parse_request_body!(body)
-      MultiJson.load(body)
+      MultiJson.load(body, symbolize_keys: true)
     rescue MultiJson::ParseError => e
       err = { title: 'Failed to parse body as JSON' }
       err[:detail] = e.cause unless ENV['RACK_ENV'] == 'production'
-      halt(error_response(400, [err]))
+      halt_with_error(400, [err])
     end
 
     def validate_request_content_type!(content_type, operation)
       return if operation.request_body.content[content_type]
 
-      halt(error_response(415))
+      halt_with_error(415)
     end
 
     def validate_request_body_presence!(body, operation)
       return unless operation.request_body.required && body.empty?
 
-      halt(error_response(415, 'Request body is required'))
+      halt_with_error(415, 'Request body is required')
     end
 
     def validate_json_schema(schema, object)
-      JSONSchemer.schema(schema).validate(object)
+      schema.validate(Utils.deep_stringify(object))
     end
 
     def default_error(status, title = Rack::Utils::HTTP_STATUS_CODES[status])
@@ -84,8 +85,10 @@ module OpenapiFirst
       }
     end
 
-    def error_response(status, errors = [default_error(status)])
-      Rack::Response.new(
+    def halt_with_error(status, errors = [default_error(status)])
+      raise RequestInvalidError, errors if @raise
+
+      halt Rack::Response.new(
         MultiJson.dump(errors: errors),
         status,
         Rack::CONTENT_TYPE => 'application/vnd.api+json'
@@ -95,7 +98,8 @@ module OpenapiFirst
     def request_body_schema(content_type, operation)
       return unless operation
 
-      operation.request_body.content[content_type]&.fetch('schema')
+      schema = operation.request_body.content[content_type]&.fetch('schema')
+      JSONSchemer.schema(schema) if schema
     end
 
     def serialize_request_body_errors(validation_errors)
@@ -113,8 +117,11 @@ module OpenapiFirst
       return unless json_schema
 
       params = filtered_params(json_schema, params)
-      errors = JSONSchemer.schema(json_schema).validate(params)
-      halt error_response(400, serialize_query_parameter_errors(errors)) if errors.any?
+      errors = validate_json_schema(
+        operation.parameters_schema,
+        params
+      )
+      halt_with_error(400, serialize_query_parameter_errors(errors)) if errors.any?
       env[PARAMETERS] = params
       env[INBOX].merge! params
     end
@@ -122,7 +129,8 @@ module OpenapiFirst
     def filtered_params(json_schema, params)
       json_schema['properties']
         .each_with_object({}) do |key_value, result|
-          parameter_name, schema = key_value
+          parameter_name = key_value[0].to_sym
+          schema = key_value[1]
           next unless params.key?(parameter_name)
 
           value = params[parameter_name]

data/lib/openapi_first/responder.rb

@@ -6,15 +6,15 @@ require_relative 'find_handler'
 
 module OpenapiFirst
   class Responder
-    def initialize(spec:, namespace:)
-      @handlers = FindHandler.new(spec, namespace).all
+    def initialize(spec:, namespace:, resolver: FindHandler.new(spec, namespace))
+      @resolver = resolver
       @namespace = namespace
     end
 
     def call(env)
       operation = env[OpenapiFirst::OPERATION]
       res = Rack::Response.new
-      handler = @handlers[operation.operation_id]
+      handler = find_handler(operation)
       result = handler.call(env[INBOX], res)
       res.write serialize(result) if result && res.body.empty?
       res[Rack::CONTENT_TYPE] ||= operation.content_type_for(res.status)
@@ -23,6 +23,13 @@ module OpenapiFirst
 
     private
 
+    def find_handler(operation)
+      handler = @resolver[operation.operation_id]
+      raise NotImplementedError, "Could not find handler for #{operation.name}" unless handler
+
+      handler
+    end
+
     def serialize(result)
       return result if result.is_a?(String)
 

data/lib/openapi_first/response_validation.rb

@@ -17,45 +17,45 @@ module OpenapiFirst
       operation = env[OPERATION]
       return @app.call(env) unless operation
 
-      status, headers, body = @app.call(env)
+      response = @app.call(env)
+      validate(response, operation)
+      response
+    end
+
+    def validate(response, operation)
+      status, headers, body = response.to_a
+      return validate_status_only(operation, status) if status == 204
+
       content_type = headers[Rack::CONTENT_TYPE]
       response_schema = operation.response_schema_for(status, content_type)
       validate_response_body(response_schema, body) if response_schema
-
-      [status, headers, body]
     end
 
     private
 
-    def halt(status, body = '')
-      throw :halt, [status, {}, body]
-    end
-
-    def error(message)
-      { title: message }
-    end
-
-    def error_response(status, errors)
-      Rack::Response.new(
-        MultiJson.dump(errors: errors),
-        status,
-        Rack::CONTENT_TYPE => 'application/vnd.api+json'
-      ).finish
+    def validate_status_only(operation, status)
+      operation.response_for(status)
     end
 
     def validate_response_body(schema, response)
       full_body = +''
       response.each { |chunk| full_body << chunk }
-      data = full_body.empty? ? {} : MultiJson.load(full_body)
+      data = full_body.empty? ? {} : load_json(full_body)
       errors = JSONSchemer.schema(schema).validate(data).to_a.map do |error|
-        format_error(error)
+        error_message_for(error)
       end
       raise ResponseBodyInvalidError, errors.join(', ') if errors.any?
     end
 
-    def format_error(error)
+    def load_json(string)
+      MultiJson.load(string)
+    rescue MultiJson::ParseError
+      string
+    end
+
+    def error_message_for(error)
       err = ValidationFormat.error_details(error)
-      [err[:title], 'at', error['data_pointer'], err[:detail]].compact.join(' ')
+      [err[:title], error['data_pointer'], err[:detail]].compact.join(' ')
     end
   end
 end

data/lib/openapi_first/response_validator.rb

@@ -3,61 +3,20 @@
 require 'json_schemer'
 require 'multi_json'
 require_relative 'validation'
+require_relative 'router'
 
 module OpenapiFirst
   class ResponseValidator
     def initialize(spec)
       @spec = spec
+      @router = Router.new(->(_env) {}, spec: spec, raise_error: true)
+      @response_validation = ResponseValidation.new(->(response) { response.to_a })
     end
 
     def validate(request, response)
-      errors = validation_errors(request, response)
-      Validation.new(errors || [])
-    rescue OasParser::ResponseCodeNotFound, OasParser::MethodNotFound => e
-      Validation.new([e.message])
-    end
-
-    def validate_operation(request, response)
-      errors = validation_errors(request, response)
-      Validation.new(errors || [])
-    rescue OasParser::ResponseCodeNotFound, OasParser::MethodNotFound => e
-      Validation.new([e.message])
-    end
-
-    private
-
-    def validation_errors(request, response)
-      content = response_for(request, response)&.content
-      return unless content
-
-      content_type = content[response.content_type]
-      return ["Content type not found: '#{response.content_type}'"] unless content_type
-
-      response_schema = content_type['schema']
-      return unless response_schema
-
-      response_data = MultiJson.load(response.body)
-      validate_json_schema(response_schema, response_data)
-    end
-
-    def validate_json_schema(schema, data)
-      JSONSchemer.schema(schema).validate(data).to_a.map do |error|
-        format_error(error)
-      end
-    end
-
-    def format_error(error)
-      ValidationFormat.error_details(error)
-                      .merge!(
-                        data_pointer: error['data_pointer'],
-                        schema_pointer: error['schema_pointer']
-                      )
-    end
-
-    def response_for(request, response)
-      @spec
-        .find_operation!(request)
-        &.response_by_code(response.status.to_s, use_default: true)
+      env = request.env.dup
+      @router.call(env)
+      @response_validation.validate(response, env[OPERATION])
     end
   end
 end

data/lib/openapi_first/router.rb

@@ -6,53 +6,47 @@ require_relative 'utils'
 
 module OpenapiFirst
   class Router
-    NOT_FOUND = Rack::Response.new('', 404).finish.freeze
-    DEFAULT_NOT_FOUND_APP = ->(_env) { NOT_FOUND }
-
-    def initialize(app, options) # rubocop:disable Metrics/MethodLength
+    def initialize(
+      app,
+      spec:,
+      raise_error: false,
+      parent_app: nil
+    )
       @app = app
-      @parent_app = options.fetch(:parent_app, nil)
-      @raise = options.fetch(:raise, false)
-      @failure_app = find_failure_app(options[:not_found])
-      if @failure_app.nil?
-        raise ArgumentError,
-              'not_found must be nil, :continue or must respond to call'
-      end
-      spec = options.fetch(:spec)
+      @parent_app = parent_app
+      @raise = raise_error
       @filepath = spec.filepath
       @router = build_router(spec.operations)
     end
 
     def call(env)
       env[OPERATION] = nil
-      endpoint = find_endpoint(env)
-      return endpoint.call(env) if endpoint
+      response = call_router(env)
+      if env[OPERATION].nil?
+        return @parent_app.call(env) if @parent_app # This should only happen if used via OpenapiFirst.middlware
 
-      if @raise
-        req = Rack::Request.new(env)
-        msg = "Could not find definition for #{req.request_method} '#{req.path}' in API description #{@filepath}"
-        raise NotFoundError, msg
+        raise_error(env) if @raise
       end
-      return @parent_app.call(env) if @parent_app
-
-      @failure_app.call(env)
+      response
     end
 
-    private
+    ORIGINAL_PATH = 'openapi_first.path_info'
 
-    def find_failure_app(option)
-      return DEFAULT_NOT_FOUND_APP if option.nil?
-      return @app if option == :continue
+    private
 
-      option if option.respond_to?(:call)
+    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
 
-    def find_endpoint(env)
-      original_path_info = env[Rack::PATH_INFO]
+    def call_router(env)
+      # Changing and restoring PATH_INFO is needed, because Hanami::Router does not respect existing script_path
+      env[ORIGINAL_PATH] = env[Rack::PATH_INFO]
       env[Rack::PATH_INFO] = Rack::Request.new(env).path
-      @router.recognize(env).endpoint
+      @router.call(env)
     ensure
-      env[Rack::PATH_INFO] = original_path_info
+      env[Rack::PATH_INFO] = env.delete(ORIGINAL_PATH) if env[ORIGINAL_PATH]
     end
 
     def build_router(operations) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
@@ -68,7 +62,8 @@ module OpenapiFirst
           normalized_path,
           to: lambda do |env|
             env[OPERATION] = operation
-            env[PARAMETERS] = Utils.deep_stringify(env['router.params'])
+            env[PARAMETERS] = env['router.params']
+            env[Rack::PATH_INFO] = env.delete(ORIGINAL_PATH)
             @app.call(env)
           end
         )

data/lib/openapi_first/validation_format.rb

@@ -5,6 +5,7 @@ module OpenapiFirst
     SIMPLE_TYPES = %w[string integer].freeze
 
     # rubocop:disable Metrics/MethodLength
+    # rubocop:disable Metrics/AbcSize
     def self.error_details(error)
       if error['type'] == 'pattern'
         {
@@ -23,9 +24,10 @@ module OpenapiFirst
       elsif error['schema'] == false
         { title: 'unknown fields are not allowed' }
       else
-        { title: 'is not valid' }
+        { title: "is not valid: #{error['data'].inspect}" }
       end
     end
     # rubocop:enable Metrics/MethodLength
+    # rubocop:enable Metrics/AbcSize
   end
 end

data/lib/openapi_first/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module OpenapiFirst
-  VERSION = '0.11.0'
+  VERSION = '0.12.2'
 end

data/openapi_first.gemspec

@@ -32,13 +32,13 @@ Gem::Specification.new do |spec|
   spec.bindir        = 'exe'
   spec.require_paths = ['lib']
 
-  spec.add_dependency 'deep_merge', '>= 1.2.1'
-  spec.add_dependency 'hanami-router', '~> 2.0.alpha3'
-  spec.add_dependency 'hanami-utils', '~> 2.0.alpha1'
-  spec.add_dependency 'json_schemer', '~> 0.2'
-  spec.add_dependency 'multi_json', '~> 1.14'
-  spec.add_dependency 'oas_parser', '~> 0.25.1'
-  spec.add_dependency 'rack', '~> 2.2'
+  spec.add_runtime_dependency 'deep_merge', '>= 1.2.1'
+  spec.add_runtime_dependency 'hanami-router', '~> 2.0.alpha3'
+  spec.add_runtime_dependency 'hanami-utils', '~> 2.0.alpha1'
+  spec.add_runtime_dependency 'json_schemer', '~> 0.2'
+  spec.add_runtime_dependency 'multi_json', '~> 1.14'
+  spec.add_runtime_dependency 'oas_parser', '~> 0.25.1'
+  spec.add_runtime_dependency 'rack', '~> 2.2'
 
   spec.add_development_dependency 'bundler', '~> 2'
   spec.add_development_dependency 'rack-test', '~> 1'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: openapi_first
 version: !ruby/object:Gem::Version
-  version: 0.11.0
+  version: 0.12.2
 platform: ruby
 authors:
 - Andreas Haller
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-06-03 00:00:00.000000000 Z
+date: 2020-06-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: deep_merge