committee 2.5.1 → 3.0.0.alpha

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

@@ -0,0 +1,17 @@
+module Committee
+  class SchemaValidator::OpenAPI3::RequestValidator
+    def initialize(operation_object, validator_option:)
+      @operation_object = operation_object
+      @validator_option = validator_option
+    end
+
+    def call(request, params, headers)
+      # TODO: support @check_content_type
+      # check_content_type!(request, params) if @check_content_type
+
+      @operation_object.validate_request_params(params, @validator_option)
+
+      # TODO: support header
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+module Committee
+  class SchemaValidator::OpenAPI3::ResponseValidator
+    attr_reader :validate_errors
+
+    # @param [Committee::SchemaValidator::OpenAPI3::OperationWrapper] operation_wrapper
+    def initialize(operation_wrapper, validator_option)
+      @operation_wrapper = operation_wrapper
+      @validate_errors = validator_option.validate_errors
+    end
+
+    def self.validate?(status, options = {})
+      validate_errors = options[:validate_errors]
+
+      status != 204 && (validate_errors || (200...300).include?(status))
+    end
+
+    def call(status, headers, data)
+      return unless self.class.validate?(status, validate_errors: validate_errors)
+
+      content_type = headers['Content-Type'].to_s.split(";").first.to_s
+      operation_wrapper.validate_response_params(status, content_type, data)
+    end
+
+    private
+
+    # @return [Committee::SchemaValidator::OpenAPI3::OperationWrapper]
+    attr_reader :operation_wrapper
+
+    def check_content_type!(response)
+      # TODO: fix
+      # OpenAPI3 support multi content type definitions, so we should get OperationObject by content type and this function don't need
+      # We should support if content exist and not exist content-type definition, raise error (if not exist content, we don't raise error)
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+module Committee
+  class SchemaValidator::OpenAPI3::Router
+    def initialize(schema, validator_option)
+      @schema = schema
+      @prefix = validator_option.prefix
+      @validator_option = validator_option
+    end
+
+    def includes_request?(request)
+      return true unless @prefix
+      #path = request.path
+      #path.start_with?(@prefix)
+    end
+
+    def build_schema_validator(request)
+      Committee::SchemaValidator::OpenAPI3.new(self, request, @validator_option)
+    end
+
+    def operation_object(request)
+      path = request.path
+      request_method = request.request_method.downcase
+
+      @schema.operation_object(path, request_method)
+    end
+  end
+end

data/lib/committee/schema_validator/option.rb

@@ -0,0 +1,31 @@
+class Committee::SchemaValidator
+  class Option
+    attr_reader :coerce_recursive, :params_key, :allow_form_params, :allow_query_params, :optimistic_json, :coerce_form_params, :headers_key, :coerce_query_params, :coerce_path_params, :check_content_type, :check_header, :coerce_date_times, :validate_errors, :prefix
+
+    def initialize(options, schema, schema_type)
+      @headers_key         = options[:headers_key] || "committee.headers"
+      @params_key          = options[:params_key] || "committee.params"
+
+      @prefix              = options[:prefix]
+
+      # response option
+      @validate_errors     = options[:validate_errors]
+
+      @coerce_recursive    = options.fetch(:coerce_recursive, true)
+      @allow_form_params   = options.fetch(:allow_form_params, true)
+      @allow_query_params  = options.fetch(:allow_query_params, true)
+      @optimistic_json     = options.fetch(:optimistic_json, false)
+
+      @coerce_form_params  = options.fetch(:coerce_form_params, schema.driver.default_coerce_form_params)
+      @coerce_date_times   = options.fetch(:coerce_date_times, schema.driver.default_coerce_date_times)
+      @coerce_query_params = options.fetch(:coerce_query_params, schema.driver.default_query_params)
+      @coerce_path_params  = options.fetch(:coerce_path_params, schema.driver.default_path_params)
+
+      raise 'OpenAPI3 not support @check_content_type option' if schema_type == :open_api_3 && options[:check_content_type]
+      @check_content_type  = options.fetch(:check_content_type, true)
+
+      raise 'OpenAPI3 not support @check_header option' if schema_type == :open_api_3 && options[:check_header]
+      @check_header        = options.fetch(:check_header, true)
+    end
+  end
+end

data/lib/committee/test/methods.rb

@@ -1,139 +1,36 @@
 module Committee::Test
   module Methods
     def assert_schema_conform
-      @committee_schema ||= begin
-        # The preferred option. The user has already parsed a schema elsewhere
-        # and we therefore don't have to worry about any performance
-        # implications of having to do it for every single test suite.
-        if committee_schema
-          committee_schema
-        else
-          schema = schema_contents
+      @schema ||= Committee::Middleware::Base.get_schema(committee_options)
+      @router ||= @schema.build_router(committee_options)
+      @validate_errors ||= committee_options[:validate_errors]
 
-          if schema.is_a?(String)
-            warn_string_deprecated
-          elsif schema.is_a?(Hash)
-            warn_hash_deprecated
-          end
+      v = @router.build_schema_validator(request_object)
 
-          if schema.is_a?(String)
-            schema = JSON.parse(schema)
-          end
-
-          if schema.is_a?(Hash) || schema.is_a?(JsonSchema::Schema)
-            driver = Committee::Drivers::HyperSchema.new
-
-            # The driver itself has its own special cases to be able to parse
-            # either a hash or JsonSchema::Schema object.
-            schema = driver.parse(schema)
-          end
-
-          schema
-        end
-      end
-
-      @committee_router ||= Committee::Router.new(@committee_schema,
-        prefix: schema_url_prefix)
-
-      link, _ = @committee_router.find_request_link(request_object)
-      unless link
+      unless v.link_exist?
         response = "`#{request_object.request_method} #{request_object.path_info}` undefined in schema."
         raise Committee::InvalidResponse.new(response)
       end
 
       status, headers, body = response_data
-      if validate?(status)
-        data = JSON.parse(body)
-        Committee::ResponseValidator.new(link).call(status, headers, data)
-      end
-    end
-
-    def request_object
-      last_request
+      v.response_validate(status, headers, [body]) if validate?(status)
     end
 
-    def response_data
-      [last_response.status, last_response.headers, last_response.body]
-    end
-
-    def assert_schema_content_type
-      Committee.warn_deprecated("Committee: use of #assert_schema_content_type is deprecated; use #assert_schema_conform instead.")
-    end
-
-    # we use this method 3.0 or later
     def committee_options
-      unless defined?(@call_committee_options_deprecated)
-        @call_committee_options_deprecated = true
-        Committee.warn_deprecated("Committee: committee 3.0 require overwrite committee options so please use this method.")
-      end
-
-      {}
-    end
-
-    # Can be overridden with a different driver name for other API definition
-    # formats.
-    def committee_schema
-      schema = committee_options[:schema]
-      return schema if schema
-
-      Committee.warn_deprecated("Committee: we'll remove committee_schema method in committee 3.0;" \
-        "please use committee_options.")
-      nil
-    end
-
-    # can be overridden alternatively to #schema_path in case the schema is
-    # easier to access as a string
-    # blob
-    def schema_contents
-      Committee.warn_deprecated("Committee: we'll remove schema_contents method in committee 3.0;" \
-        "please use committee_options.")
-      JSON.parse(File.read(schema_path))
-    end
-
-    def schema_path
-      Committee.warn_deprecated("Committee: we'll remove schema_path method in committee 3.0;" \
-        "please use committee_options.")
-      raise "Please override #committee_schema."
-    end
-
-    def schema_url_prefix
-      prefix = committee_options[:prefix]
-      return prefix if prefix
-
-      schema = committee_options[:schema]
-      return nil if schema # committee_options set so we don't show warn message
-
-      Committee.warn_deprecated("Committee: we'll remove schema_url_prefix method in committee 3.0;" \
-        "please use committee_options.")
-      nil
+      raise "please set options"
     end
 
-    def warn_hash_deprecated
-      Committee.warn_deprecated("Committee: returning a hash from " \
-        "#schema_contents and using #schema_path is deprecated; please " \
-        "override #committee_schema instead.")
+    def request_object
+      raise "please set object like 'last_request'"
     end
 
-    def warn_string_deprecated
-      Committee.warn_deprecated("Committee: returning a string from " \
-        "#schema_contents is deprecated; please override #committee_schema " \
-        "instead.")
+    def response_data
+      raise "please set response data like 'last_response.status, last_response.headers, last_response.body'"
     end
 
-    def validate_response?(status)
-      Committee.warn_deprecated("Committee: w'll remove validate_response? method in committee 3.0")
-
-      Committee::ResponseValidator.validate?(status, validate_success_only: validate_success_only)
+    # TODO: refactoring
+    def validate?(status)
+      status != 204 and @validate_errors || (200...300).include?(status)
     end
-
-    private
-
-      def validate_success_only
-        committee_options.fetch(:validate_success_only, true)
-      end
-
-      def validate?(status)
-        Committee::ResponseValidator.validate?(status, validate_success_only: validate_success_only)
-      end
   end
 end

data/test/bin/committee_stub_test.rb

@@ -25,6 +25,12 @@ describe Committee::Bin::CommitteeStub do
     assert_equal true, options[:tolerant]
     assert_equal "1234", options[:port]
   end
+
+  it "OpenAPI3 not support Stub" do
+    assert_raises(Committee::NotSupportOpenAPI3) do
+      @bin.get_app(open_api_3_schema, {})
+    end
+  end
 end
 
 describe Committee::Bin::CommitteeStub, "app" do

data/test/drivers/open_api_2_test.rb

@@ -219,19 +219,6 @@ describe Committee::Drivers::OpenAPI2::ParameterSchemaBuilder do
     assert_equal ["limit"], schema.properties.keys
     assert_equal [], schema.required
     assert_equal ["integer"], schema.properties["limit"].type
-    assert_nil schema.properties["limit"].enum
-    assert_nil schema.properties["limit"].format
-    assert_nil schema.properties["limit"].pattern
-    assert_nil schema.properties["limit"].min_length
-    assert_nil schema.properties["limit"].max_length
-    assert_nil schema.properties["limit"].min_items
-    assert_nil schema.properties["limit"].max_items
-    assert_nil schema.properties["limit"].unique_items
-    assert_nil schema.properties["limit"].min
-    assert_nil schema.properties["limit"].min_exclusive
-    assert_nil schema.properties["limit"].max
-    assert_nil schema.properties["limit"].max_exclusive
-    assert_nil schema.properties["limit"].multiple_of
   end
 
   it "reflects a required property into a schema" do
@@ -255,9 +242,6 @@ describe Committee::Drivers::OpenAPI2::ParameterSchemaBuilder do
         {
           "name" => "tags",
           "type" => "array",
-          "minItems" => 1,
-          "maxItems" => 10,
-          "uniqueItems" => true,
           "items" => {
             "type" => "string"
           }
@@ -268,74 +252,9 @@ describe Committee::Drivers::OpenAPI2::ParameterSchemaBuilder do
 
     assert_nil schema_data
     assert_equal ["array"], schema.properties["tags"].type
-    assert_equal 1, schema.properties["tags"].min_items
-    assert_equal 10, schema.properties["tags"].max_items
-    assert_equal true, schema.properties["tags"].unique_items
     assert_equal({ "type" => "string" }, schema.properties["tags"].items)
   end
 
-  it "reflects a enum property into a schema" do
-    data = {
-      "parameters" => [
-        {
-          "name" => "type",
-          "type" => "string",
-          "enum" => ["hoge", "fuga"]
-        }
-      ]
-    }
-    schema, schema_data = call(data)
-
-    assert_nil schema_data
-    assert_equal ["hoge", "fuga"], schema.properties["type"].enum
-  end
-
-  it "reflects string properties into a schema" do
-    data = {
-      "parameters" => [
-        {
-          "name" => "password",
-          "type" => "string",
-          "format" => "password",
-          "pattern" => "[a-zA-Z0-9]+",
-          "minLength" => 6,
-          "maxLength" => 30
-        }
-      ]
-    }
-    schema, schema_data = call(data)
-
-    assert_nil schema_data
-    assert_equal "password", schema.properties["password"].format
-    assert_equal Regexp.new("[a-zA-Z0-9]+"), schema.properties["password"].pattern
-    assert_equal 6, schema.properties["password"].min_length
-    assert_equal 30, schema.properties["password"].max_length
-  end
-
-  it "reflects number properties into a schema" do
-    data = {
-      "parameters" => [
-        {
-          "name" => "limit",
-          "type" => "integer",
-          "minimum" => 20,
-          "exclusiveMinimum" => true,
-          "maximum" => 100,
-          "exclusiveMaximum" => false,
-          "multipleOf" => 10
-        }
-      ]
-    }
-    schema, schema_data = call(data)
-
-    assert_nil schema_data
-    assert_equal 20, schema.properties["limit"].min
-    assert_equal true, schema.properties["limit"].min_exclusive
-    assert_equal 100, schema.properties["limit"].max
-    assert_equal false, schema.properties["limit"].max_exclusive
-    assert_equal 10, schema.properties["limit"].multiple_of
-  end
-
   it "returns schema data for a body parameter" do
     data = {
       "parameters" => [

data/test/drivers/open_api_3_test.rb

@@ -0,0 +1,81 @@
+require_relative "../test_helper"
+
+describe Committee::Drivers::OpenAPI3 do
+  before do
+    @driver = Committee::Drivers::OpenAPI3.new
+  end
+
+  it "has a name" do
+    assert_equal :open_api_3, @driver.name
+  end
+
+  it "has a schema class" do
+    assert_equal Committee::Drivers::OpenAPI3::Schema, @driver.schema_class
+  end
+
+  it "override methods" do
+    schema = @driver.parse(open_api_3_data)
+
+    assert_kind_of Committee::Drivers::OpenAPI3::Schema, schema
+    assert_kind_of OpenAPIParser::Schemas::OpenAPI, schema.open_api
+    assert_equal @driver, schema.driver
+  end
+
+  it "defaults to coercing form parameters" do
+    assert_equal true, @driver.default_coerce_form_params
+  end
+
+  it "defaults to path parameters" do
+    assert_equal true, @driver.default_path_params
+  end
+
+  it "defaults to query parameters" do
+    assert_equal true, @driver.default_query_params
+  end
+
+  describe "Schema" do
+    describe "#operation_object" do
+      describe "path template" do
+        it "get normal path" do
+          obj = open_api_3_schema.operation_object("/path_template_test/no_template", "get")
+          assert_equal "/path_template_test/no_template", obj.original_path
+        end
+
+        it "get template path" do
+          obj = open_api_3_schema.operation_object("/path_template_test/test", "get")
+          assert_equal "/path_template_test/{template_name}", obj.original_path
+        end
+
+        it "get nested template path" do
+          obj = open_api_3_schema.operation_object("/path_template_test/abc/nested", "get")
+          assert_equal "/path_template_test/{template_name}/nested", obj.original_path
+          assert_equal({"template_name"=>"abc"}, obj.path_params)
+        end
+
+        it "get double nested template path" do
+          obj = open_api_3_schema.operation_object("/path_template_test/test/nested/abc", "get")
+          assert_equal "/path_template_test/{template_name}/nested/{nested_parameter}", obj.original_path
+          assert_equal({"template_name"=>"test", "nested_parameter" => "abc"}, obj.path_params)
+        end
+
+        it "get twice nested template path" do
+          obj = open_api_3_schema.operation_object("/path_template_test/test/abc", "get")
+          assert_equal "/path_template_test/{template_name}/{nested_parameter}", obj.original_path
+          assert_equal({"template_name"=>"test", "nested_parameter" => "abc"}, obj.path_params)
+        end
+
+        it "get twice nested concrete path" do
+          obj = open_api_3_schema.operation_object("/path_template_test/test/abc/finish", "get")
+          assert_equal "/path_template_test/{template_name}/{nested_parameter}/finish", obj.original_path
+          assert_equal({"template_name"=>"test", "nested_parameter" => "abc"}, obj.path_params)
+        end
+
+        it "get ambiguous path" do
+          obj = open_api_3_schema.operation_object("/ambiguous/no_template", "get")
+          assert_equal "/{ambiguous}/no_template", obj.original_path
+          assert_equal({"ambiguous"=>"ambiguous"}, obj.path_params)
+        end
+      end
+    end
+  end
+end