committee 3.3.0 → 5.0.0

data/test/request_unpacker_test.rb

@@ -9,8 +9,18 @@ describe Committee::RequestUnpacker do
       "rack.input"   => StringIO.new('{"x":"y"}'),
     }
     request = Rack::Request.new(env)
-    params, _ = Committee::RequestUnpacker.new(request).call
-    assert_equal({ "x" => "y" }, params)
+    unpacker = Committee::RequestUnpacker.new
+    assert_equal([{ "x" => "y" }, false], unpacker.unpack_request_params(request))
+  end
+
+  it "unpacks JSON on Content-Type: application/vnd.api+json" do
+    env = {
+      "CONTENT_TYPE" => "application/vnd.api+json",
+      "rack.input"   => StringIO.new('{"x":"y"}'),
+    }
+    request = Rack::Request.new(env)
+    unpacker = Committee::RequestUnpacker.new
+    assert_equal([{ "x" => "y" }, false], unpacker.unpack_request_params(request))
   end
 
   it "unpacks JSON on no Content-Type" do
@@ -18,8 +28,18 @@ describe Committee::RequestUnpacker do
       "rack.input"   => StringIO.new('{"x":"y"}'),
     }
     request = Rack::Request.new(env)
-    params, _ = Committee::RequestUnpacker.new(request).call
-    assert_equal({ "x" => "y" }, params)
+    unpacker = Committee::RequestUnpacker.new
+    assert_equal([{ "x" => "y" }, false], unpacker.unpack_request_params(request))
+  end
+
+  it "doesn't unpack JSON on application/x-ndjson" do
+    env = {
+      "CONTENT_TYPE" => "application/x-ndjson",
+      "rack.input"   => StringIO.new('{"x":"y"}\n{"a":"b"}'),
+    }
+    request = Rack::Request.new(env)
+    unpacker = Committee::RequestUnpacker.new
+    assert_equal([{}, false], unpacker.unpack_request_params(request))
   end
 
   it "doesn't unpack JSON under other Content-Types" do
@@ -29,8 +49,8 @@ describe Committee::RequestUnpacker do
         "rack.input"   => StringIO.new('{"x":"y"}'),
       }
       request = Rack::Request.new(env)
-      params, _ = Committee::RequestUnpacker.new(request).call
-      assert_equal({}, params)
+      unpacker = Committee::RequestUnpacker.new
+      assert_equal([{}, false], unpacker.unpack_request_params(request))
     end
   end
 
@@ -41,8 +61,8 @@ describe Committee::RequestUnpacker do
         "rack.input"   => StringIO.new('{"x":"y"}'),
       }
       request = Rack::Request.new(env)
-      params, _ = Committee::RequestUnpacker.new(request, optimistic_json: true).call
-      assert_equal({ "x" => "y" }, params)
+      unpacker = Committee::RequestUnpacker.new(optimistic_json: true)
+      assert_equal([{ "x" => "y" }, false], unpacker.unpack_request_params(request))
     end
   end
 
@@ -53,8 +73,8 @@ describe Committee::RequestUnpacker do
         "rack.input"   => StringIO.new('x=y&foo=42'),
       }
       request = Rack::Request.new(env)
-      params, _ = Committee::RequestUnpacker.new(request, optimistic_json: true).call
-      assert_equal({}, params)
+      unpacker = Committee::RequestUnpacker.new(optimistic_json: true)
+      assert_equal([{}, false], unpacker.unpack_request_params(request))
     end
   end
 
@@ -64,8 +84,8 @@ describe Committee::RequestUnpacker do
       "rack.input"   => StringIO.new(""),
     }
     request = Rack::Request.new(env)
-    params, _ = Committee::RequestUnpacker.new(request).call
-    assert_equal({}, params)
+    unpacker = Committee::RequestUnpacker.new
+    assert_equal([{}, false], unpacker.unpack_request_params(request))
   end
 
   it "doesn't unpack form params" do
@@ -75,8 +95,8 @@ describe Committee::RequestUnpacker do
         "rack.input"   => StringIO.new("x=y"),
       }
       request = Rack::Request.new(env)
-      params, _ = Committee::RequestUnpacker.new(request).call
-      assert_equal({}, params)
+      unpacker = Committee::RequestUnpacker.new
+      assert_equal([{}, false], unpacker.unpack_request_params(request))
     end
   end
 
@@ -87,87 +107,8 @@ describe Committee::RequestUnpacker do
         "rack.input"   => StringIO.new("x=y"),
       }
       request = Rack::Request.new(env)
-      params, _ = Committee::RequestUnpacker.new(request, allow_form_params: true).call
-      assert_equal({ "x" => "y" }, params)
-    end
-  end
-
-  it "coerces form params with coerce_form_params and a schema" do
-    %w[application/x-www-form-urlencoded multipart/form-data].each do |content_type|
-      env = {
-          "CONTENT_TYPE" => content_type,
-          "rack.input"   => StringIO.new("x=1"),
-      }
-      request = Rack::Request.new(env)
-
-      router = hyper_schema.build_router({})
-      validator = router.build_schema_validator(request)
-
-      schema = JsonSchema::Schema.new
-      schema.properties = { "x" => JsonSchema::Schema.new }
-      schema.properties["x"].type = ["integer"]
-
-      link_class = Struct.new(:schema)
-      link_object = link_class.new(schema)
-
-      validator.instance_variable_set(:@link, link_object)
-
-      params, _ = Committee::RequestUnpacker.new(
-        request,
-        allow_form_params: true,
-        coerce_form_params: true,
-        schema_validator: validator,
-      ).call
-      assert_equal({ "x" => 1 }, params)
-    end
-  end
-
-  it "coerces form params with coerce_form_params and an OpenAPI3 schema" do
-    %w[application/x-www-form-urlencoded multipart/form-data].each do |content_type|
-      env = {
-          "CONTENT_TYPE" => content_type,
-          "rack.input"   => StringIO.new("limit=20"),
-          "PATH_INFO" => "/characters",
-          "SCRIPT_NAME" => "",
-          "REQUEST_METHOD" => "GET",
-      }
-      request = Rack::Request.new(env)
-
-      router = open_api_3_schema.build_router({})
-      validator = router.build_schema_validator(request)
-
-      params, _ = Committee::RequestUnpacker.new(
-          request,
-          allow_form_params: true,
-          coerce_form_params: true,
-          schema_validator: validator,
-          ).call
-      # openapi3 not support coerce in request unpacker
-      assert_equal({ "limit" => '20' }, params)
-    end
-  end
-
-  it "coerces error params with coerce_form_params and a OpenAPI3 schema" do
-    %w[application/x-www-form-urlencoded multipart/form-data].each do |content_type|
-      env = {
-          "CONTENT_TYPE" => content_type,
-          "rack.input"   => StringIO.new("limit=twenty"),
-          "PATH_INFO" => "/characters",
-          "SCRIPT_NAME" => "",
-          "REQUEST_METHOD" => "GET",
-      }
-      request = Rack::Request.new(env)
-
-      router = open_api_3_schema.build_router({})
-      validator = router.build_schema_validator(request)
-
-      params, _ = Committee::RequestUnpacker.new(
-          request,
-          allow_form_params: true,
-          coerce_form_params: true,
-          schema_validator: validator,
-          ).call
-      assert_equal({ "limit" => "twenty" }, params)
+      unpacker = Committee::RequestUnpacker.new(allow_form_params: true)
+      assert_equal([{ "x" => "y" }, true], unpacker.unpack_request_params(request))
     end
   end
 
@@ -179,8 +120,8 @@ describe Committee::RequestUnpacker do
         "QUERY_STRING" => "a=b"
       }
       request = Rack::Request.new(env)
-      params, _ = Committee::RequestUnpacker.new(request, allow_form_params: true, allow_query_params: true).call
-      assert_equal({ "x" => "y", "a" => "b" }, params)
+      unpacker = Committee::RequestUnpacker.new(allow_form_params: true, allow_query_params: true)
+      assert_equal([ { "x" => "y"}, true], unpacker.unpack_request_params(request))
     end
   end
 
@@ -190,8 +131,8 @@ describe Committee::RequestUnpacker do
       "QUERY_STRING" => "a=b"
     }
     request = Rack::Request.new(env)
-    params, _ = Committee::RequestUnpacker.new(request, allow_query_params: true).call
-    assert_equal({ "a" => "b" }, params)
+    unpacker = Committee::RequestUnpacker.new(allow_query_params: true)
+    assert_equal({ "a" => "b" }, unpacker.unpack_query_params(request))
   end
 
   it "errors if JSON is not an object" do
@@ -201,7 +142,7 @@ describe Committee::RequestUnpacker do
     }
     request = Rack::Request.new(env)
     assert_raises(Committee::BadRequest) do
-      Committee::RequestUnpacker.new(request).call
+      Committee::RequestUnpacker.new.unpack_request_params(request)
     end
   end
 
@@ -211,8 +152,8 @@ describe Committee::RequestUnpacker do
       "rack.input"   => StringIO.new('{"x":"y"}'),
     }
     request = Rack::Request.new(env)
-    params, _ = Committee::RequestUnpacker.new(request).call
-    assert_equal({}, params)
+    unpacker = Committee::RequestUnpacker.new
+    assert_equal([{}, false], unpacker.unpack_request_params(request))
   end
 
   # this is mostly here for line coverage
@@ -221,8 +162,8 @@ describe Committee::RequestUnpacker do
       "rack.input" => StringIO.new('{"x":[]}'),
     }
     request = Rack::Request.new(env)
-    params, _ = Committee::RequestUnpacker.new(request).call
-    assert_equal({ "x" => [] }, params)
+    unpacker = Committee::RequestUnpacker.new
+    assert_equal([{ "x" => [] }, false], unpacker.unpack_request_params(request))
   end
 
   it "unpacks http header" do
@@ -231,8 +172,8 @@ describe Committee::RequestUnpacker do
       "rack.input"   => StringIO.new(""),
     }
     request = Rack::Request.new(env)
-    _, headers = Committee::RequestUnpacker.new(request, { allow_header_params: true }).call
-    assert_equal({ "FOO-BAR" => "some header value" }, headers)
+    unpacker = Committee::RequestUnpacker.new({ allow_header_params: true })
+    assert_equal({ "FOO-BAR" => "some header value" }, unpacker.unpack_headers(request))
   end
 
   it "includes request body when`use_get_body` is true" do
@@ -242,8 +183,8 @@ describe Committee::RequestUnpacker do
         "QUERY_STRING"=>"data=value&x=aaa",
     }
     request = Rack::Request.new(env)
-    params, _ = Committee::RequestUnpacker.new(request, { allow_query_params: true, allow_get_body: true }).call
-    assert_equal({ 'data' => 'value', 'x' => 1, 'y' => 2 }, params)
+    unpacker = Committee::RequestUnpacker.new({ allow_query_params: true, allow_get_body: true })
+    assert_equal([{ 'x' => 1, 'y' => 2 }, false], unpacker.unpack_request_params(request))
   end
 
   it "doesn't include request body when `use_get_body` is false" do
@@ -253,7 +194,7 @@ describe Committee::RequestUnpacker do
         "QUERY_STRING"=>"data=value&x=aaa",
     }
     request = Rack::Request.new(env)
-    params, _ = Committee::RequestUnpacker.new(request, { allow_query_params: true, use_get_body: false }).call
-    assert_equal({ 'data' => 'value', 'x' => 'aaa' }, params)
+    unpacker = Committee::RequestUnpacker.new({ allow_query_params: true, use_get_body: false })
+    assert_equal({ 'data' => 'value', 'x' => 'aaa' }, unpacker.unpack_query_params(request))
   end
 end

data/test/schema_validator/hyper_schema/response_validator_test.rb

@@ -38,6 +38,11 @@ describe Committee::SchemaValidator::HyperSchema::ResponseValidator do
     call
   end
 
+  it "passes through a 304 Not Modified response" do
+    @status, @headers, @data = 304, {}, nil
+    call
+  end
+
   it "passes through a valid list response for for rel instances links" do
     @link = @list_link
 
@@ -91,6 +96,11 @@ describe Committee::SchemaValidator::HyperSchema::ResponseValidator do
     call
   end
 
+  it "allows no Content-Type for 304 Not Modified" do
+    @status, @headers = 304, {}
+    call
+  end
+
   it "raises errors generated by json_schema" do
     @data.merge!("name" => "%@!")
     e = assert_raises(Committee::InvalidResponse) { call }

data/test/schema_validator/hyper_schema/router_test.rb

@@ -69,6 +69,8 @@ describe Committee::SchemaValidator::HyperSchema::Router do
   end
 
   def hyper_schema_router(options = {})
+    # TODO: delete when 5.0.0 released because default value changed
+    options[:parse_response_by_content_type] = true if options[:parse_response_by_content_type] == nil
     schema = Committee::Drivers::HyperSchema::Driver.new.parse(hyper_schema_data)
     validator_option = Committee::SchemaValidator::Option.new(options, schema, :hyper_schema)
 
@@ -76,6 +78,8 @@ describe Committee::SchemaValidator::HyperSchema::Router do
   end
 
   def open_api_2_router(options = {})
+    # TODO: delete when 5.0.0 released because default value changed
+    options[:parse_response_by_content_type] = true if options[:parse_response_by_content_type] == nil
     schema = Committee::Drivers::OpenAPI2::Driver.new.parse(open_api_2_data)
     validator_option = Committee::SchemaValidator::Option.new(options, schema, :hyper_schema)
 

data/test/schema_validator/hyper_schema/string_params_coercer_test.rb

@@ -11,7 +11,7 @@ describe Committee::SchemaValidator::HyperSchema::StringParamsCoercer do
   end
 
   it "doesn't coerce params not in the schema" do
-    check_convert("onwer", "admin", "admin")
+    check_convert("owner", "admin", "admin")
   end
 
   it "skips values for string param" do

data/test/schema_validator/open_api_3/operation_wrapper_test.rb

@@ -9,7 +9,12 @@ describe Committee::SchemaValidator::OpenAPI3::OperationWrapper do
     before do
       @path = '/validate'
       @method = 'post'
-      @validator_option = Committee::SchemaValidator::Option.new({}, open_api_3_schema, :open_api_3)
+
+      # TODO: delete when 5.0.0 released because default value changed
+      options = {}
+      options[:parse_response_by_content_type] = true if options[:parse_response_by_content_type] == nil
+
+      @validator_option = Committee::SchemaValidator::Option.new(options, open_api_3_schema, :open_api_3)
     end
 
     def operation_object
@@ -27,12 +32,15 @@ describe Committee::SchemaValidator::OpenAPI3::OperationWrapper do
     ]
 
     it 'correct data' do
-      operation_object.validate_request_params(SCHEMA_PROPERTIES_PAIR.to_h, HEADER, @validator_option)
+      operation_object.validate_request_params({}, {}, SCHEMA_PROPERTIES_PAIR.to_h, HEADER, @validator_option)
       assert true
     end
 
     it 'correct object data' do
-      operation_object.validate_request_params({
+      operation_object.validate_request_params(
+                                  {},
+                                  {},
+                                  {
                                      "object_1" =>
                                          {
                                              "string_1" => nil,
@@ -49,38 +57,39 @@ describe Committee::SchemaValidator::OpenAPI3::OperationWrapper do
 
     it 'invalid params' do
       e = assert_raises(Committee::InvalidRequest) {
-        operation_object.validate_request_params({"string" => 1}, HEADER, @validator_option)
+        operation_object.validate_request_params({}, {}, {"string" => 1}, HEADER, @validator_option)
       }
 
-      # FIXME: when ruby 2.3 dropped, fix because ruby 2.3 return Fixnum, ruby 2.4 or later return Integer
-      assert_match(/expected string, but received #{1.class}: 1/i, e.message)
+      assert_match(/expected string, but received Integer: 1/i, e.message)
+      assert_kind_of(OpenAPIParser::OpenAPIError, e.original_error)
     end
 
     it 'support put method' do
       @method = "put"
-      operation_object.validate_request_params({"string" => "str"}, HEADER, @validator_option)
+      operation_object.validate_request_params({}, {}, {"string" => "str"}, HEADER, @validator_option)
 
       e = assert_raises(Committee::InvalidRequest) {
-        operation_object.validate_request_params({"string" => 1}, HEADER, @validator_option)
+        operation_object.validate_request_params({}, {}, {"string" => 1}, HEADER, @validator_option)
       }
 
-      # FIXME: when ruby 2.3 dropped, fix because ruby 2.3 return Fixnum, ruby 2.4 or later return Integer
-      assert_match(/expected string, but received #{1.class}: 1/i, e.message)
+      assert_match(/expected string, but received Integer: 1/i, e.message)
+      assert_kind_of(OpenAPIParser::OpenAPIError, e.original_error)
     end
 
     it 'support patch method' do
       @method = "patch"
-      operation_object.validate_request_params({"integer" => 1}, HEADER, @validator_option)
+      operation_object.validate_request_params({}, {}, {"integer" => 1}, HEADER, @validator_option)
 
       e = assert_raises(Committee::InvalidRequest) {
-        operation_object.validate_request_params({"integer" => "str"}, HEADER, @validator_option)
+        operation_object.validate_request_params({}, {}, {"integer" => "str"}, HEADER, @validator_option)
       }
 
-      assert_match(/expected integer, but received String: str/i, e.message)
+      assert_match(/expected integer, but received String: "str"/i, e.message)
+      assert_kind_of(OpenAPIParser::OpenAPIError, e.original_error)
     end
 
     it 'unknown param' do
-      operation_object.validate_request_params({"unknown" => 1}, HEADER, @validator_option)
+      operation_object.validate_request_params({}, {}, {"unknown" => 1}, HEADER, @validator_option)
     end
 
     describe 'support get method' do
@@ -90,13 +99,17 @@ describe Committee::SchemaValidator::OpenAPI3::OperationWrapper do
 
       it 'correct' do
         operation_object.validate_request_params(
+            {},
             {"query_string" => "query", "query_integer_list" => [1, 2]},
+            {},
             HEADER,
             @validator_option
         )
 
         operation_object.validate_request_params(
+            {},
             {"query_string" => "query", "query_integer_list" => [1, 2], "optional_integer" => 1},
+            {},
             HEADER,
             @validator_option
         )
@@ -106,23 +119,26 @@ describe Committee::SchemaValidator::OpenAPI3::OperationWrapper do
 
       it 'not exist required' do
         e = assert_raises(Committee::InvalidRequest) {
-          operation_object.validate_request_params({"query_integer_list" => [1, 2]}, HEADER, @validator_option)
+          operation_object.validate_request_params({}, {"query_integer_list" => [1, 2]}, {}, HEADER, @validator_option)
         }
 
         assert_match(/missing required parameters: query_string/i, e.message)
+        assert_kind_of(OpenAPIParser::OpenAPIError, e.original_error)
       end
 
       it 'invalid type' do
         e = assert_raises(Committee::InvalidRequest) {
           operation_object.validate_request_params(
+              {},
               {"query_string" => 1, "query_integer_list" => [1, 2], "optional_integer" => 1},
+              {},
               HEADER,
               @validator_option
           )
         }
 
-        # FIXME: when ruby 2.3 dropped, fix because ruby 2.3 return Fixnum, ruby 2.4 or later return Integer
-        assert_match(/expected string, but received #{1.class}: 1/i, e.message)
+        assert_match(/expected string, but received Integer: 1/i, e.message)
+        assert_kind_of(OpenAPIParser::OpenAPIError, e.original_error)
       end
     end
 
@@ -133,20 +149,56 @@ describe Committee::SchemaValidator::OpenAPI3::OperationWrapper do
       end
 
       it 'correct' do
-        operation_object.validate_request_params({"limit" => "1"}, HEADER, @validator_option)
+        operation_object.validate_request_params({}, {"limit" => "1"}, {}, HEADER, @validator_option)
 
         assert true
       end
 
       it 'invalid type' do
         e = assert_raises(Committee::InvalidRequest) {
-          operation_object.validate_request_params({"limit" => "a"}, HEADER, @validator_option)
+          operation_object.validate_request_params({}, {"limit" => "a"}, {}, HEADER, @validator_option)
         }
 
-        assert_match(/expected integer, but received String: a/i, e.message)
+        assert_match(/expected integer, but received String: "a"/i, e.message)
+        assert_kind_of(OpenAPIParser::OpenAPIError, e.original_error)
       end
     end
 
+    describe 'support head method' do
+      before do
+        @path = '/characters'
+        @method = 'head'
+      end
+
+      it 'correct' do
+        operation_object.validate_request_params({}, {"limit" => "1"}, {}, HEADER, @validator_option)
+
+        assert true
+      end
+
+      it 'invalid type' do
+        e = assert_raises(Committee::InvalidRequest) {
+          operation_object.validate_request_params({}, {"limit" => "a"}, {}, HEADER, @validator_option)
+        }
+
+        assert_match(/expected integer, but received String: "a"/i, e.message)
+        assert_kind_of(OpenAPIParser::OpenAPIError, e.original_error)
+      end
+    end
+
+    it 'support options method' do
+      @method = "options"
+      operation_object.validate_request_params({}, {}, {"integer" => 1}, HEADER, @validator_option)
+
+      e = assert_raises(Committee::InvalidRequest) {
+        operation_object.validate_request_params({}, {}, {"integer" => "str"}, HEADER, @validator_option)
+      }
+
+      assert_match(/expected integer, but received String: "str"/i, e.message)
+      assert_kind_of(OpenAPIParser::OpenAPIError, e.original_error)
+    end
+
+
     describe '#content_types' do
       it 'returns supported content types' do
         @path = '/validate_content_types'

data/test/schema_validator/open_api_3/request_validator_test.rb

@@ -71,7 +71,34 @@ describe Committee::SchemaValidator::OpenAPI3::RequestValidator do
       assert_equal 200, last_response.status
     end
 
+    it "skips content_type check with an empty body" do
+      @app = new_rack_app(check_content_type: true, schema: open_api_3_schema)
+      header "Content-Type", "application/x-www-form-urlencoded"
+      patch "/validate_empty_optional_body"
+      assert_equal 200, last_response.status
+    end
+    
+    it "does not mix up parameters and requestBody" do
+      @app = new_rack_app(check_content_type: true, schema: open_api_3_schema)
+      params = {
+          "last_name" => "Skywalker"
+      }
+      header "Content-Type", "application/json"
+      post "/additional_properties?first_name=Luke", JSON.generate(params)
+      assert_equal 200, last_response.status
+    end
+
+    it "error because content_type check with body" do
+      @app = new_rack_app(check_content_type: true, schema: open_api_3_schema)
+      header "Content-Type", "application/x-www-form-urlencoded"
+      patch "/validate_empty_optional_body", "{}"
+      assert_equal 400, last_response.status
+    end    
+
     def new_rack_app(options = {})
+      # TODO: delete when 5.0.0 released because default value changed
+      options[:parse_response_by_content_type] = true if options[:parse_response_by_content_type] == nil
+
       Rack::Builder.new {
         use Committee::Middleware::RequestValidation, options
         run lambda { |_|

data/test/schema_validator/open_api_3/response_validator_test.rb

@@ -12,7 +12,12 @@ describe Committee::SchemaValidator::OpenAPI3::ResponseValidator do
 
     @path = '/validate'
     @method = 'post'
-    @validator_option = Committee::SchemaValidator::Option.new({}, open_api_3_schema, :open_api_3)
+
+    # TODO: delete when 5.0.0 released because default value changed
+    options = {}
+    options[:parse_response_by_content_type] = true if options[:parse_response_by_content_type] == nil
+    
+    @validator_option = Committee::SchemaValidator::Option.new(options, open_api_3_schema, :open_api_3)
   end
 
   it "passes through a valid response" do
@@ -29,11 +34,21 @@ describe Committee::SchemaValidator::OpenAPI3::ResponseValidator do
     call_response_validator
   end
 
-  it "passes through a valid response with no registered Content-Type with strict = true" do
+  it "raises InvalidResponse when a valid response with no registered body with strict option" do
     @headers = { "Content-Type" => "application/xml" }
-    assert_raises(Committee::InvalidResponse) {
+    e = assert_raises(Committee::InvalidResponse) {
       call_response_validator(true)
     }
+    assert_kind_of(OpenAPIParser::OpenAPIError, e.original_error)
+  end
+
+  it "raises InvalidResponse when a invalid status code with strict option" do
+    @status = 201
+    e = assert_raises(Committee::InvalidResponse) {
+      call_response_validator(true)
+    }
+
+    assert_kind_of(OpenAPIParser::OpenAPIError, e.original_error)
   end
 
   it "passes through a valid response with no Content-Type" do
@@ -41,11 +56,12 @@ describe Committee::SchemaValidator::OpenAPI3::ResponseValidator do
     call_response_validator
   end
 
-  it "passes through a valid response with no Content-Type with strict option" do
+  it "raises InvalidResponse when a valid response with no Content-Type headers with strict option" do
     @headers = {}
-    assert_raises(Committee::InvalidResponse) {
+    e = assert_raises(Committee::InvalidResponse) {
       call_response_validator(true)
     }
+    assert_kind_of(OpenAPIParser::OpenAPIError, e.original_error)
   end
 
   it "passes through a valid list response" do
@@ -60,6 +76,11 @@ describe Committee::SchemaValidator::OpenAPI3::ResponseValidator do
     call_response_validator
   end
 
+  it "passes through a 304 Not Modified response" do
+    @status, @headers, @data = 304, {}, nil
+    call_response_validator
+  end
+
   private
 
   def call_response_validator(strict = false)

data/test/test/methods_new_version_test.rb

@@ -30,13 +30,16 @@ describe Committee::Test::Methods do
     @committee_schema = nil
 
     @committee_options = {schema: hyper_schema}
+
+    # TODO: delete when 5.0.0 released because default value changed
+    @committee_options[:parse_response_by_content_type] = false
   end
 
   describe "#assert_schema_conform" do
     it "passes through a valid response" do
       @app = new_rack_app(JSON.generate([ValidApp]))
       get "/apps"
-      assert_schema_conform
+      assert_schema_conform(200)
     end
 
     it "passes with prefix" do
@@ -44,30 +47,39 @@ describe Committee::Test::Methods do
 
       @app = new_rack_app(JSON.generate([ValidApp]))
       get "/v1/apps"
-      assert_schema_conform
+      assert_schema_conform(200)
     end
 
     it "detects an invalid response Content-Type" do
       @app = new_rack_app(JSON.generate([ValidApp]), 200, {})
       get "/apps"
       e = assert_raises(Committee::InvalidResponse) do
-        assert_schema_conform
+        assert_schema_conform(200)
       end
       assert_match(/response header must be set to/i, e.message)
     end
 
+    it "it detects unexpected response code" do
+      @app = new_rack_app(JSON.generate([ValidApp]), 400)
+      get "/apps"
+      e = assert_raises(Committee::InvalidResponse) do
+        assert_schema_conform(200)
+      end
+      assert_match(/Expected `200` status code, but it was `400`/i, e.message)
+    end
+
     it "detects an invalid response Content-Type but ignore because it's not success status code" do
       @committee_options.merge!(validate_success_only: true)
       @app = new_rack_app(JSON.generate([ValidApp]), 400, {})
       get "/apps"
-      assert_schema_conform
+      assert_schema_conform(400)
     end
 
     it "detects an invalid response Content-Type and check all status code" do
       @app = new_rack_app(JSON.generate([ValidApp]), 400, {})
       get "/apps"
       e = assert_raises(Committee::InvalidResponse) do
-        assert_schema_conform
+        assert_schema_conform(400)
       end
       assert_match(/response header must be set to/i, e.message)
     end