committee 5.6.1 → 5.6.3

data/test/drivers/open_api_2/parameter_schema_builder_test.rb

@@ -38,20 +38,7 @@ describe Committee::Drivers::OpenAPI2::ParameterSchemaBuilder do
   end
 
   it "reflects an array with an items schema into a schema" do
-    data = {
-      "parameters" => [
-        {
-          "name" => "tags",
-          "type" => "array",
-          "minItems" => 1,
-          "maxItems" => 10,
-          "uniqueItems" => true,
-          "items" => {
-            "type" => "string"
-          }
-        }
-      ]
-    }
+    data = { "parameters" => [{ "name" => "tags", "type" => "array", "minItems" => 1, "maxItems" => 10, "uniqueItems" => true, "items" => { "type" => "string" } }] }
     schema, schema_data = call(data)
 
     assert_nil schema_data
@@ -71,18 +58,7 @@ describe Committee::Drivers::OpenAPI2::ParameterSchemaBuilder do
   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
-        }
-      ]
-    }
+    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
@@ -93,19 +69,7 @@ describe Committee::Drivers::OpenAPI2::ParameterSchemaBuilder do
   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
-        }
-      ]
-    }
+    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
@@ -117,17 +81,7 @@ describe Committee::Drivers::OpenAPI2::ParameterSchemaBuilder do
   end
 
   it "returns schema data for a body parameter" do
-    data = {
-      "parameters" => [
-        {
-          "name" => "payload",
-          "in" => "body",
-          "schema" => {
-            "$ref" => "#/definitions/foo",
-          }
-        }
-      ]
-    }
+    data = { "parameters" => [{ "name" => "payload", "in" => "body", "schema" => { "$ref" => "#/definitions/foo", } }] }
     schema, schema_data = call(data)
 
     assert_nil schema

data/test/drivers_test.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "test_helper"
+require "tmpdir"
 
 describe Committee::Drivers do
   DRIVERS = [:hyper_schema, :open_api_2, :open_api_3,].freeze
@@ -74,30 +75,51 @@ describe Committee::Drivers do
     describe 'cache behavior' do
       describe 'when loading the same file' do
         it 'returns the same object when the options are identical' do
-          assert_equal(
-            Committee::Drivers.load_from_file(open_api_3_schema_path, parser_options: { strict_reference_validation: true }).object_id,
-            Committee::Drivers.load_from_file(open_api_3_schema_path, parser_options: { strict_reference_validation: true }).object_id,
-          )
+          assert_equal(Committee::Drivers.load_from_file(open_api_3_schema_path, parser_options: { strict_reference_validation: true }).object_id, Committee::Drivers.load_from_file(open_api_3_schema_path, parser_options: { strict_reference_validation: true }).object_id,)
         end
 
         it 'returns different objects if the options are different' do
-          refute_equal(
-            Committee::Drivers.load_from_file(open_api_3_schema_path, parser_options: { strict_reference_validation: true }).object_id,
-            Committee::Drivers.load_from_file(open_api_3_schema_path, parser_options: { strict_reference_validation: false }).object_id,
-          )
+          refute_equal(Committee::Drivers.load_from_file(open_api_3_schema_path, parser_options: { strict_reference_validation: true }).object_id, Committee::Drivers.load_from_file(open_api_3_schema_path, parser_options: { strict_reference_validation: false }).object_id,)
         end
 
         it 'returns different objects if the file contents have changed' do
           object_id = Committee::Drivers.load_from_file(open_api_3_schema_path, parser_options: { strict_reference_validation: true }).object_id
           original_file_contents = File.read(open_api_3_schema_path)
           File.write(open_api_3_schema_path, original_file_contents + "\n")
-          refute_equal(
-            Committee::Drivers.load_from_file(open_api_3_schema_path, parser_options: { strict_reference_validation: true }).object_id,
-            object_id,
-          )
+          refute_equal(Committee::Drivers.load_from_file(open_api_3_schema_path, parser_options: { strict_reference_validation: true }).object_id, object_id,)
           File.write(open_api_3_schema_path, original_file_contents)
         end
       end
+
+      describe 'when loading different files with identical root schema content' do
+        it 'returns different objects because relative references are resolved from schema_path' do
+          parser_options = { strict_reference_validation: true }
+
+          Dir.mktmpdir("committee-cache-key-test") do |tmpdir|
+            first_dir = File.join(tmpdir, "first")
+            second_dir = File.join(tmpdir, "second")
+            Dir.mkdir(first_dir)
+            Dir.mkdir(second_dir)
+
+            root_schema = File.read(open_api_3_schema_path)
+            original_referee = File.read("test/data/openapi3/referee.yaml")
+            changed_referee = original_referee.sub("type: string", "type: integer")
+
+            first_root_path = File.join(first_dir, "normal.yaml")
+            second_root_path = File.join(second_dir, "normal.yaml")
+
+            File.write(first_root_path, root_schema)
+            File.write(second_root_path, root_schema)
+            File.write(File.join(first_dir, "referee.yaml"), original_referee)
+            File.write(File.join(second_dir, "referee.yaml"), changed_referee)
+
+            first_schema = Committee::Drivers.load_from_file(first_root_path, parser_options: parser_options)
+            second_schema = Committee::Drivers.load_from_file(second_root_path, parser_options: parser_options)
+
+            refute_equal(first_schema.object_id, second_schema.object_id)
+          end
+        end
+      end
     end
   end
 
@@ -152,15 +174,7 @@ describe Committee::Drivers do
 end
 
 describe Committee::Drivers::Driver do
-  DRIVER_METHODS = {
-    default_allow_get_body: [],
-    default_coerce_form_params: [],
-    default_path_params: [],
-    default_query_params: [],
-    name: [],
-    parse: [nil],
-    schema_class: [],
-  }
+  DRIVER_METHODS = { default_allow_get_body: [], default_coerce_form_params: [], default_path_params: [], default_query_params: [], name: [], parse: [nil], schema_class: [], }
 
   it "has a set of abstract methods" do
     driver = Committee::Drivers::Driver.new

data/test/middleware/options/base_test.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+describe Committee::Middleware::Options::Base do
+  describe "#initialize" do
+    it "accepts valid options with schema" do
+      options = Committee::Middleware::Options::Base.new(schema: hyper_schema)
+      assert_equal hyper_schema, options.schema
+    end
+
+    it "accepts valid options with schema_path" do
+      options = Committee::Middleware::Options::Base.new(schema_path: hyper_schema_schema_path)
+      assert_equal hyper_schema_schema_path, options.schema_path
+    end
+
+    it "raises error when neither schema nor schema_path is provided" do
+      e = assert_raises(ArgumentError) do
+        Committee::Middleware::Options::Base.new({})
+      end
+      assert_equal "Committee: need option `schema` or `schema_path`", e.message
+    end
+
+    it "raises error when error_class is not a Class" do
+      e = assert_raises(ArgumentError) do
+        Committee::Middleware::Options::Base.new(schema: hyper_schema, error_class: "not a class")
+      end
+      assert_equal "error_class must be a Class", e.message
+    end
+
+    it "raises error when accept_request_filter is not callable" do
+      e = assert_raises(ArgumentError) do
+        Committee::Middleware::Options::Base.new(schema: hyper_schema, accept_request_filter: "not callable")
+      end
+      assert_equal "accept_request_filter must respond to #call", e.message
+    end
+
+    it "uses default error_class when not provided" do
+      options = Committee::Middleware::Options::Base.new(schema: hyper_schema)
+      assert_equal Committee::ValidationError, options.error_class
+    end
+
+    it "uses provided error_class" do
+      custom_error = Class.new(StandardError)
+      options = Committee::Middleware::Options::Base.new(schema: hyper_schema, error_class: custom_error)
+      assert_equal custom_error, options.error_class
+    end
+
+    it "sets raise_error from :raise option" do
+      options = Committee::Middleware::Options::Base.new(schema: hyper_schema, raise: true)
+      assert_equal true, options.raise_error
+    end
+
+    it "sets prefix option" do
+      options = Committee::Middleware::Options::Base.new(schema: hyper_schema, prefix: "/api/v1")
+      assert_equal "/api/v1", options.prefix
+    end
+
+    it "sets accept_request_filter option" do
+      filter = ->(request) { request.path.start_with?("/api") }
+      options = Committee::Middleware::Options::Base.new(schema: hyper_schema, accept_request_filter: filter)
+      assert_equal filter, options.accept_request_filter
+    end
+
+    it "sets strict_reference_validation option" do
+      options = Committee::Middleware::Options::Base.new(schema: hyper_schema, strict_reference_validation: true)
+      assert_equal true, options.strict_reference_validation
+    end
+  end
+
+  describe "#[]" do
+    it "provides Hash-like access" do
+      options = Committee::Middleware::Options::Base.new(schema: hyper_schema, prefix: "/api")
+      assert_equal "/api", options[:prefix]
+    end
+  end
+
+  describe "#fetch" do
+    it "returns value for existing key" do
+      options = Committee::Middleware::Options::Base.new(schema: hyper_schema, prefix: "/api")
+      assert_equal "/api", options.fetch(:prefix, nil)
+    end
+
+    it "returns default for missing key" do
+      options = Committee::Middleware::Options::Base.new(schema: hyper_schema)
+      assert_equal "default", options.fetch(:nonexistent, "default")
+    end
+  end
+
+  describe "#to_h" do
+    it "returns Hash representation of options" do
+      options = Committee::Middleware::Options::Base.new(schema: hyper_schema, prefix: "/api")
+      hash = options.to_h
+      assert_kind_of Hash, hash
+      assert_equal hyper_schema, hash[:schema]
+      assert_equal "/api", hash[:prefix]
+    end
+  end
+
+  describe ".from" do
+    it "returns the same object if already an Options instance" do
+      options = Committee::Middleware::Options::Base.new(schema: hyper_schema)
+      assert_same options, Committee::Middleware::Options::Base.from(options)
+    end
+
+    it "creates new instance from Hash" do
+      hash = { schema: hyper_schema, prefix: "/api" }
+      options = Committee::Middleware::Options::Base.from(hash)
+      assert_kind_of Committee::Middleware::Options::Base, options
+      assert_equal "/api", options.prefix
+    end
+
+    it "raises error for invalid input" do
+      e = assert_raises(ArgumentError) do
+        Committee::Middleware::Options::Base.from("invalid")
+      end
+      assert_match(/options must be a Hash or/, e.message)
+    end
+  end
+end

data/test/middleware/options/request_validation_test.rb

@@ -0,0 +1,177 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+describe Committee::Middleware::Options::RequestValidation do
+  describe "#initialize" do
+    it "inherits from Base" do
+      assert Committee::Middleware::Options::RequestValidation < Committee::Middleware::Options::Base
+    end
+
+    it "accepts valid options" do
+      options = Committee::Middleware::Options::RequestValidation.new(schema: hyper_schema)
+      assert_equal hyper_schema, options.schema
+    end
+
+    it "sets strict option with default false" do
+      options = Committee::Middleware::Options::RequestValidation.new(schema: hyper_schema)
+      assert_equal false, options.strict
+    end
+
+    it "sets strict option when provided" do
+      options = Committee::Middleware::Options::RequestValidation.new(schema: hyper_schema, strict: true)
+      assert_equal true, options.strict
+    end
+
+    it "sets ignore_error option with default false" do
+      options = Committee::Middleware::Options::RequestValidation.new(schema: hyper_schema)
+      assert_equal false, options.ignore_error
+    end
+
+    it "sets ignore_error option when provided" do
+      options = Committee::Middleware::Options::RequestValidation.new(schema: hyper_schema, ignore_error: true)
+      assert_equal true, options.ignore_error
+    end
+
+    it "sets coerce_date_times option" do
+      options = Committee::Middleware::Options::RequestValidation.new(schema: hyper_schema, coerce_date_times: true)
+      assert_equal true, options.coerce_date_times
+    end
+
+    it "sets coerce_recursive option with default true" do
+      options = Committee::Middleware::Options::RequestValidation.new(schema: hyper_schema)
+      assert_equal true, options.coerce_recursive
+    end
+
+    it "sets coerce_form_params option" do
+      options = Committee::Middleware::Options::RequestValidation.new(schema: hyper_schema, coerce_form_params: true)
+      assert_equal true, options.coerce_form_params
+    end
+
+    it "sets coerce_path_params option" do
+      options = Committee::Middleware::Options::RequestValidation.new(schema: hyper_schema, coerce_path_params: true)
+      assert_equal true, options.coerce_path_params
+    end
+
+    it "sets coerce_query_params option" do
+      options = Committee::Middleware::Options::RequestValidation.new(schema: hyper_schema, coerce_query_params: true)
+      assert_equal true, options.coerce_query_params
+    end
+
+    it "sets allow_form_params option with default true" do
+      options = Committee::Middleware::Options::RequestValidation.new(schema: hyper_schema)
+      assert_equal true, options.allow_form_params
+    end
+
+    it "sets allow_query_params option with default true" do
+      options = Committee::Middleware::Options::RequestValidation.new(schema: hyper_schema)
+      assert_equal true, options.allow_query_params
+    end
+
+    it "sets allow_get_body option with default false" do
+      options = Committee::Middleware::Options::RequestValidation.new(schema: hyper_schema)
+      assert_equal false, options.allow_get_body
+    end
+
+    it "sets allow_non_get_query_params option with default false" do
+      options = Committee::Middleware::Options::RequestValidation.new(schema: hyper_schema)
+      assert_equal false, options.allow_non_get_query_params
+    end
+
+    it "sets check_content_type option with default true" do
+      options = Committee::Middleware::Options::RequestValidation.new(schema: hyper_schema)
+      assert_equal true, options.check_content_type
+    end
+
+    it "sets check_header option with default true" do
+      options = Committee::Middleware::Options::RequestValidation.new(schema: hyper_schema)
+      assert_equal true, options.check_header
+    end
+
+    it "sets optimistic_json option with default false" do
+      options = Committee::Middleware::Options::RequestValidation.new(schema: hyper_schema)
+      assert_equal false, options.optimistic_json
+    end
+
+    it "sets error_handler option" do
+      handler = ->(e, env) {}
+      options = Committee::Middleware::Options::RequestValidation.new(schema: hyper_schema, error_handler: handler)
+      assert_equal handler, options.error_handler
+    end
+
+    it "raises error when error_handler is not callable" do
+      e = assert_raises(ArgumentError) do
+        Committee::Middleware::Options::RequestValidation.new(schema: hyper_schema, error_handler: "not callable")
+      end
+      assert_equal "error_handler must respond to #call", e.message
+    end
+
+    it "sets request_body_hash_key option with default" do
+      options = Committee::Middleware::Options::RequestValidation.new(schema: hyper_schema)
+      assert_equal "committee.request_body_hash", options.request_body_hash_key
+    end
+
+    it "sets query_hash_key option with default" do
+      options = Committee::Middleware::Options::RequestValidation.new(schema: hyper_schema)
+      assert_equal "committee.query_hash", options.query_hash_key
+    end
+
+    it "sets path_hash_key option with default" do
+      options = Committee::Middleware::Options::RequestValidation.new(schema: hyper_schema)
+      assert_equal "committee.path_hash", options.path_hash_key
+    end
+
+    it "sets headers_key option with default" do
+      options = Committee::Middleware::Options::RequestValidation.new(schema: hyper_schema)
+      assert_equal "committee.headers", options.headers_key
+    end
+
+    it "sets params_key option with default" do
+      options = Committee::Middleware::Options::RequestValidation.new(schema: hyper_schema)
+      assert_equal "committee.params", options.params_key
+    end
+
+    it "sets allow_blank_structures option with default false" do
+      options = Committee::Middleware::Options::RequestValidation.new(schema: hyper_schema)
+      assert_equal false, options.allow_blank_structures
+    end
+
+    it "sets allow_empty_date_and_datetime option with default false" do
+      options = Committee::Middleware::Options::RequestValidation.new(schema: hyper_schema)
+      assert_equal false, options.allow_empty_date_and_datetime
+    end
+
+    it "sets parameter_overwrite_by_rails_rule option with default true" do
+      options = Committee::Middleware::Options::RequestValidation.new(schema: hyper_schema)
+      assert_equal true, options.parameter_overwrite_by_rails_rule
+    end
+
+    it "sets deserialize_parameters option" do
+      options = Committee::Middleware::Options::RequestValidation.new(schema: hyper_schema, deserialize_parameters: true)
+      assert_equal true, options.deserialize_parameters
+    end
+  end
+
+  describe "#to_h" do
+    it "includes RequestValidation specific options" do
+      options = Committee::Middleware::Options::RequestValidation.new(schema: hyper_schema, strict: true, coerce_date_times: true)
+      hash = options.to_h
+      assert_equal true, hash[:strict]
+      assert_equal true, hash[:coerce_date_times]
+    end
+  end
+
+  describe ".from" do
+    it "returns the same object if already an Options instance" do
+      options = Committee::Middleware::Options::RequestValidation.new(schema: hyper_schema)
+      assert_same options, Committee::Middleware::Options::RequestValidation.from(options)
+    end
+
+    it "creates new instance from Hash" do
+      hash = { schema: hyper_schema, strict: true }
+      options = Committee::Middleware::Options::RequestValidation.from(hash)
+      assert_kind_of Committee::Middleware::Options::RequestValidation, options
+      assert_equal true, options.strict
+    end
+  end
+end

data/test/middleware/options/response_validation_test.rb

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+describe Committee::Middleware::Options::ResponseValidation do
+  describe "#initialize" do
+    it "inherits from Base" do
+      assert Committee::Middleware::Options::ResponseValidation < Committee::Middleware::Options::Base
+    end
+
+    it "accepts valid options" do
+      options = Committee::Middleware::Options::ResponseValidation.new(schema: hyper_schema)
+      assert_equal hyper_schema, options.schema
+    end
+
+    it "sets strict option with default false" do
+      options = Committee::Middleware::Options::ResponseValidation.new(schema: hyper_schema)
+      assert_equal false, options.strict
+    end
+
+    it "sets strict option when provided" do
+      options = Committee::Middleware::Options::ResponseValidation.new(schema: hyper_schema, strict: true)
+      assert_equal true, options.strict
+    end
+
+    it "sets ignore_error option with default false" do
+      options = Committee::Middleware::Options::ResponseValidation.new(schema: hyper_schema)
+      assert_equal false, options.ignore_error
+    end
+
+    it "sets ignore_error option when provided" do
+      options = Committee::Middleware::Options::ResponseValidation.new(schema: hyper_schema, ignore_error: true)
+      assert_equal true, options.ignore_error
+    end
+
+    it "sets validate_success_only option with default true" do
+      options = Committee::Middleware::Options::ResponseValidation.new(schema: hyper_schema)
+      assert_equal true, options.validate_success_only
+    end
+
+    it "sets validate_success_only option when provided" do
+      options = Committee::Middleware::Options::ResponseValidation.new(schema: hyper_schema, validate_success_only: false)
+      assert_equal false, options.validate_success_only
+    end
+
+    it "sets parse_response_by_content_type option with default true" do
+      options = Committee::Middleware::Options::ResponseValidation.new(schema: hyper_schema)
+      assert_equal true, options.parse_response_by_content_type
+    end
+
+    it "sets parse_response_by_content_type option when provided" do
+      options = Committee::Middleware::Options::ResponseValidation.new(schema: hyper_schema, parse_response_by_content_type: false)
+      assert_equal false, options.parse_response_by_content_type
+    end
+
+    it "sets coerce_response_values option with default false" do
+      options = Committee::Middleware::Options::ResponseValidation.new(schema: hyper_schema)
+      assert_equal false, options.coerce_response_values
+    end
+
+    it "sets coerce_response_values option when provided" do
+      options = Committee::Middleware::Options::ResponseValidation.new(schema: hyper_schema, coerce_response_values: true)
+      assert_equal true, options.coerce_response_values
+    end
+
+    it "sets error_handler option" do
+      handler = ->(e, env) {}
+      options = Committee::Middleware::Options::ResponseValidation.new(schema: hyper_schema, error_handler: handler)
+      assert_equal handler, options.error_handler
+    end
+
+    it "raises error when error_handler is not callable" do
+      e = assert_raises(ArgumentError) do
+        Committee::Middleware::Options::ResponseValidation.new(schema: hyper_schema, error_handler: "not callable")
+      end
+      assert_equal "error_handler must respond to #call", e.message
+    end
+
+    it "sets streaming_content_parsers option with default empty hash" do
+      options = Committee::Middleware::Options::ResponseValidation.new(schema: hyper_schema)
+      assert_equal({}, options.streaming_content_parsers)
+    end
+
+    it "sets streaming_content_parsers option when provided" do
+      parser = ->(body) { JSON.parse(body) }
+      parsers = { "application/json" => parser }
+      options = Committee::Middleware::Options::ResponseValidation.new(schema: hyper_schema, streaming_content_parsers: parsers)
+      assert_equal parsers, options.streaming_content_parsers
+    end
+
+    it "raises error when streaming_content_parsers is not a Hash" do
+      e = assert_raises(ArgumentError) do
+        Committee::Middleware::Options::ResponseValidation.new(schema: hyper_schema, streaming_content_parsers: "not a hash")
+      end
+      assert_equal "streaming_content_parsers must be a Hash", e.message
+    end
+  end
+
+  describe "#to_h" do
+    it "includes ResponseValidation specific options" do
+      options = Committee::Middleware::Options::ResponseValidation.new(schema: hyper_schema, strict: true, validate_success_only: false)
+      hash = options.to_h
+      assert_equal true, hash[:strict]
+      assert_equal false, hash[:validate_success_only]
+    end
+  end
+
+  describe ".from" do
+    it "returns the same object if already an Options instance" do
+      options = Committee::Middleware::Options::ResponseValidation.new(schema: hyper_schema)
+      assert_same options, Committee::Middleware::Options::ResponseValidation.from(options)
+    end
+
+    it "creates new instance from Hash" do
+      hash = { schema: hyper_schema, strict: true }
+      options = Committee::Middleware::Options::ResponseValidation.from(hash)
+      assert_kind_of Committee::Middleware::Options::ResponseValidation, options
+      assert_equal true, options.strict
+    end
+  end
+end