committee 5.5.0 → 5.5.1

data/test/middleware/response_validation_test.rb

@@ -15,6 +15,22 @@ describe Committee::Middleware::ResponseValidation do
     assert_equal 200, last_response.status
   end
 
+  it "passes through a valid response with content-type (lower-case)" do
+    options = { schema: hyper_schema }
+    status = 200
+    headers = { 'content-type' => 'application/json' }
+    response = JSON.generate([ValidApp])
+    @app = Rack::Builder.new {
+      use Committee::Middleware::ResponseValidation, options
+      run lambda { |_|
+        [status, headers, [response]]
+      }
+    }
+
+    get "/apps"
+    assert_equal 200, last_response.status
+  end
+
   it "doesn't call error_handler (has a arg) when response is valid" do
     called = false
     pr = ->(_e) { called = true }
@@ -106,8 +122,7 @@ describe Committee::Middleware::ResponseValidation do
   end
 
   it "takes a prefix" do
-    @app = new_rack_app(JSON.generate([ValidApp]), {}, prefix: "/v1",
-      schema: hyper_schema)
+    @app = new_rack_app(JSON.generate([ValidApp]), {}, prefix: "/v1", schema: hyper_schema)
     get "/v1/apps"
     assert_equal 200, last_response.status
   end
@@ -130,30 +145,26 @@ describe Committee::Middleware::ResponseValidation do
   end
 
   it "passes through a valid response for OpenAPI" do
-    @app = new_rack_app(JSON.generate([ValidPet]), {},
-      schema: open_api_2_schema)
+    @app = new_rack_app(JSON.generate([ValidPet]), {}, schema: open_api_2_schema)
     get "/api/pets"
     assert_equal 200, last_response.status
   end
 
   it "passes through a valid response for OpenAPI when data=nil, target_schema=empty, allow_blank_structures=true" do
-    @app = new_rack_app("null", {},
-                        allow_blank_structures: true, schema: open_api_2_schema)
+    @app = new_rack_app("null", {}, allow_blank_structures: true, schema: open_api_2_schema)
     get "/api/pets/cat"
     assert_equal 200, last_response.status
   end
 
   it "invalid responses for OpenAPI when data=nil, target_schema=empty, allow_blank_structures=false" do
-    @app = new_rack_app("null", {},
-                        allow_blank_structures: false, schema: open_api_2_schema)
+    @app = new_rack_app("null", {}, allow_blank_structures: false, schema: open_api_2_schema)
     get "/api/pets/cat"
     assert_equal 500, last_response.status
     assert_match(/Invalid response/i, last_response.body)
   end
 
   it "passes through a valid response for OpenAPI when data=nil, target_schema=present, allow_blank_structures=true" do
-    @app = new_rack_app("null", {},
-                        allow_blank_structures: true, schema: open_api_2_schema)
+    @app = new_rack_app("null", {}, allow_blank_structures: true, schema: open_api_2_schema)
     get "/api/pets/dog"
     assert_equal 500, last_response.status
     assert_match(/nil is not an array/i, last_response.body)
@@ -169,8 +180,8 @@ describe Committee::Middleware::ResponseValidation do
   describe ':accept_request_filter' do
     [
       { description: 'when not specified, includes everything', accept_request_filter: nil, expected: { status: 500 } },
-      { description: 'when predicate matches, performs validation', accept_request_filter: -> (request) { request.path.start_with?('/v1/a') }, expected: { status: 500 } },
-      { description: 'when predicate does not match, skips validation', accept_request_filter: -> (request) { request.path.start_with?('/v1/x') }, expected: { status: 200 } },
+      { description: 'when predicate matches, performs validation', accept_request_filter: ->(request) { request.path.start_with?('/v1/a') }, expected: { status: 500 } },
+      { description: 'when predicate does not match, skips validation', accept_request_filter: ->(request) { request.path.start_with?('/v1/x') }, expected: { status: 200 } },
     ].each do |h|
       description = h[:description]
       accept_request_filter = h[:accept_request_filter]
@@ -188,9 +199,7 @@ describe Committee::Middleware::ResponseValidation do
   private
 
   def new_rack_app(response, headers = {}, options = {})
-    headers = {
-      "Content-Type" => "application/json"
-    }.merge(headers)
+    headers = { "Content-Type" => "application/json" }.merge(headers)
     Rack::Builder.new {
       use Committee::Middleware::ResponseValidation, options
       run lambda { |_|

data/test/middleware/stub_test.rb

@@ -27,16 +27,14 @@ describe Committee::Middleware::Stub do
     @app = new_rack_app(call: true, schema: hyper_schema)
     get "/apps/heroku-api"
     assert_equal 200, last_response.status
-    assert_equal ValidApp,
-      JSON.parse(last_response.headers["Committee-Response"])
+    assert_equal ValidApp, JSON.parse(last_response.headers["Committee-Response"])
   end
 
   it "optionally returns the application's response" do
     @app = new_rack_app(call: true, schema: hyper_schema, suppress: true)
     get "/apps/heroku-api"
     assert_equal 429, last_response.status
-    assert_equal ValidApp,
-      JSON.parse(last_response.headers["Committee-Response"])
+    assert_equal ValidApp, JSON.parse(last_response.headers["Committee-Response"])
     assert_equal "", last_response.body
   end
 
@@ -44,8 +42,7 @@ describe Committee::Middleware::Stub do
     @app = new_rack_app(call: true, schema: hyper_schema, suppress: true)
     get "/apps/heroku-api"
     assert_equal 429, last_response.status
-    assert_equal "#/definitions/app/links/2/targetSchema",
-      last_response.headers["Committee-Response-Schema"]
+    assert_equal "#/definitions/app/links/2/targetSchema", last_response.headers["Committee-Response-Schema"]
     assert_equal "", last_response.body
   end
 
@@ -122,15 +119,11 @@ describe Committee::Middleware::Stub do
 
         headers = {}
         if res = env["committee.response"]
-          headers.merge!({
-            "Committee-Response" => JSON.generate(res)
-          })
+          headers.merge!({ "Committee-Response" => JSON.generate(res) })
         end
 
         if res = env["committee.response_schema"]
-          headers.merge!({
-            "Committee-Response-Schema" => res.pointer,
-          })
+          headers.merge!({ "Committee-Response-Schema" => res.pointer, })
         end
 
         env["committee.suppress"] = suppress

data/test/request_unpacker_test.rb

@@ -4,39 +4,28 @@ require "test_helper"
 
 describe Committee::RequestUnpacker do
   it "unpacks JSON on Content-Type: application/json" do
-    env = {
-      "CONTENT_TYPE" => "application/json",
-      "rack.input"   => StringIO.new('{"x":"y"}'),
-    }
+    env = { "CONTENT_TYPE" => "application/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 Content-Type: application/vnd.api+json" do
-    env = {
-      "CONTENT_TYPE" => "application/vnd.api+json",
-      "rack.input"   => StringIO.new('{"x":"y"}'),
-    }
+    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
-    env = {
-      "rack.input"   => StringIO.new('{"x":"y"}'),
-    }
+    env = { "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 "doesn't unpack JSON on application/x-ndjson" do
-    env = {
-      "CONTENT_TYPE" => "application/x-ndjson",
-      "rack.input"   => StringIO.new('{"x":"y"}\n{"a":"b"}'),
-    }
+    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))
@@ -44,10 +33,7 @@ describe Committee::RequestUnpacker do
 
   it "doesn't unpack JSON under other Content-Types" do
     %w[application/x-www-form-urlencoded multipart/form-data].each do |content_type|
-      env = {
-        "CONTENT_TYPE" => content_type,
-        "rack.input"   => StringIO.new('{"x":"y"}'),
-      }
+      env = { "CONTENT_TYPE" => content_type, "rack.input" => StringIO.new('{"x":"y"}'), }
       request = Rack::Request.new(env)
       unpacker = Committee::RequestUnpacker.new
       assert_equal([{}, false], unpacker.unpack_request_params(request))
@@ -56,10 +42,7 @@ describe Committee::RequestUnpacker do
 
   it "unpacks JSON under other Content-Types with optimistic_json" do
     %w[application/x-www-form-urlencoded multipart/form-data].each do |content_type|
-      env = {
-        "CONTENT_TYPE" => content_type,
-        "rack.input"   => StringIO.new('{"x":"y"}'),
-      }
+      env = { "CONTENT_TYPE" => content_type, "rack.input" => StringIO.new('{"x":"y"}'), }
       request = Rack::Request.new(env)
       unpacker = Committee::RequestUnpacker.new(optimistic_json: true)
       assert_equal([{ "x" => "y" }, false], unpacker.unpack_request_params(request))
@@ -68,10 +51,7 @@ describe Committee::RequestUnpacker do
 
   it "returns {} when unpacking non-JSON with optimistic_json" do
     %w[application/x-www-form-urlencoded multipart/form-data].each do |content_type|
-      env = {
-        "CONTENT_TYPE" => content_type,
-        "rack.input"   => StringIO.new('x=y&foo=42'),
-      }
+      env = { "CONTENT_TYPE" => content_type, "rack.input" => StringIO.new('x=y&foo=42'), }
       request = Rack::Request.new(env)
       unpacker = Committee::RequestUnpacker.new(optimistic_json: true)
       assert_equal([{}, false], unpacker.unpack_request_params(request))
@@ -79,10 +59,7 @@ describe Committee::RequestUnpacker do
   end
 
   it "unpacks an empty hash on an empty request body" do
-    env = {
-      "CONTENT_TYPE" => "application/json",
-      "rack.input"   => StringIO.new(""),
-    }
+    env = { "CONTENT_TYPE" => "application/json", "rack.input" => StringIO.new(""), }
     request = Rack::Request.new(env)
     unpacker = Committee::RequestUnpacker.new
     assert_equal([{}, false], unpacker.unpack_request_params(request))
@@ -90,10 +67,7 @@ describe Committee::RequestUnpacker do
 
   it "doesn't unpack form params" do
     %w[application/x-www-form-urlencoded multipart/form-data].each do |content_type|
-      env = {
-        "CONTENT_TYPE" => content_type,
-        "rack.input"   => StringIO.new("x=y"),
-      }
+      env = { "CONTENT_TYPE" => content_type, "rack.input" => StringIO.new("x=y"), }
       request = Rack::Request.new(env)
       unpacker = Committee::RequestUnpacker.new
       assert_equal([{}, false], unpacker.unpack_request_params(request))
@@ -102,10 +76,7 @@ describe Committee::RequestUnpacker do
 
   it "unpacks form params with allow_form_params" do
     %w[application/x-www-form-urlencoded multipart/form-data].each do |content_type|
-      env = {
-        "CONTENT_TYPE" => content_type,
-        "rack.input"   => StringIO.new("x=y"),
-      }
+      env = { "CONTENT_TYPE" => content_type, "rack.input" => StringIO.new("x=y"), }
       request = Rack::Request.new(env)
       unpacker = Committee::RequestUnpacker.new(allow_form_params: true)
       assert_equal([{ "x" => "y" }, true], unpacker.unpack_request_params(request))
@@ -114,32 +85,22 @@ describe Committee::RequestUnpacker do
 
   it "unpacks form & query params with allow_form_params and allow_query_params" do
     %w[application/x-www-form-urlencoded multipart/form-data].each do |content_type|
-      env = {
-        "CONTENT_TYPE" => content_type,
-        "rack.input"   => StringIO.new("x=y"),
-        "QUERY_STRING" => "a=b"
-      }
+      env = { "CONTENT_TYPE" => content_type, "rack.input" => StringIO.new("x=y"), "QUERY_STRING" => "a=b" }
       request = Rack::Request.new(env)
       unpacker = Committee::RequestUnpacker.new(allow_form_params: true, allow_query_params: true)
-      assert_equal([ { "x" => "y"}, true], unpacker.unpack_request_params(request))
+      assert_equal([{ "x" => "y" }, true], unpacker.unpack_request_params(request))
     end
   end
 
   it "unpacks query params with allow_query_params" do
-    env = {
-      "rack.input"   => StringIO.new(""),
-      "QUERY_STRING" => "a=b"
-    }
+    env = { "rack.input" => StringIO.new(""), "QUERY_STRING" => "a=b" }
     request = Rack::Request.new(env)
     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
-    env = {
-      "CONTENT_TYPE" => "application/json",
-      "rack.input"   => StringIO.new('[2]'),
-    }
+    env = { "CONTENT_TYPE" => "application/json", "rack.input" => StringIO.new('[2]'), }
     request = Rack::Request.new(env)
     assert_raises(Committee::BadRequest) do
       Committee::RequestUnpacker.new.unpack_request_params(request)
@@ -147,10 +108,7 @@ describe Committee::RequestUnpacker do
   end
 
   it "errors on an unknown Content-Type" do
-    env = {
-      "CONTENT_TYPE" => "application/whats-this",
-      "rack.input"   => StringIO.new('{"x":"y"}'),
-    }
+    env = { "CONTENT_TYPE" => "application/whats-this", "rack.input" => StringIO.new('{"x":"y"}'), }
     request = Rack::Request.new(env)
     unpacker = Committee::RequestUnpacker.new
     assert_equal([{}, false], unpacker.unpack_request_params(request))
@@ -158,19 +116,14 @@ describe Committee::RequestUnpacker do
 
   # this is mostly here for line coverage
   it "unpacks JSON containing an array" do
-    env = {
-      "rack.input" => StringIO.new('{"x":[]}'),
-    }
+    env = { "rack.input" => StringIO.new('{"x":[]}'), }
     request = Rack::Request.new(env)
     unpacker = Committee::RequestUnpacker.new
     assert_equal([{ "x" => [] }, false], unpacker.unpack_request_params(request))
   end
 
   it "unpacks http header" do
-    env = {
-      "HTTP_FOO_BAR" => "some header value",
-      "rack.input"   => StringIO.new(""),
-    }
+    env = { "HTTP_FOO_BAR" => "some header value", "rack.input" => StringIO.new(""), }
     request = Rack::Request.new(env)
     unpacker = Committee::RequestUnpacker.new({ allow_header_params: true })
     assert_equal({ "FOO-BAR" => "some header value" }, unpacker.unpack_headers(request))
@@ -180,7 +133,7 @@ describe Committee::RequestUnpacker do
     env = {
         "rack.input" => StringIO.new('{"x":1, "y":2}'),
         "REQUEST_METHOD" => "GET",
-        "QUERY_STRING"=>"data=value&x=aaa",
+        "QUERY_STRING" => "data=value&x=aaa",
     }
     request = Rack::Request.new(env)
     unpacker = Committee::RequestUnpacker.new({ allow_query_params: true, allow_get_body: true })
@@ -191,7 +144,7 @@ describe Committee::RequestUnpacker do
     env = {
         "rack.input" => StringIO.new('{"x":1, "y":2}'),
         "REQUEST_METHOD" => "GET",
-        "QUERY_STRING"=>"data=value&x=aaa",
+        "QUERY_STRING" => "data=value&x=aaa",
     }
     request = Rack::Request.new(env)
     unpacker = Committee::RequestUnpacker.new({ allow_query_params: true, use_get_body: false })

data/test/schema_validator/hyper_schema/parameter_coercer_test.rb

@@ -11,7 +11,7 @@ describe Committee::SchemaValidator::HyperSchema::ParameterCoercer do
   end
 
   it "pass datetime string" do
-    params = { "update_time" => "2016-04-01T16:00:00.000+09:00"}
+    params = { "update_time" => "2016-04-01T16:00:00.000+09:00" }
     call(params, coerce_date_times: true)
 
     assert_kind_of DateTime, params["update_time"]
@@ -28,7 +28,7 @@ describe Committee::SchemaValidator::HyperSchema::ParameterCoercer do
 
   it "pass invalid datetime string, not convert" do
     invalid_datetime = "llmfllmf"
-    params = { "update_time" => invalid_datetime}
+    params = { "update_time" => invalid_datetime }
     call(params, coerce_date_times: true)
 
     assert_equal invalid_datetime, params["update_time"]
@@ -104,7 +104,7 @@ describe Committee::SchemaValidator::HyperSchema::ParameterCoercer do
 
   class HashLikeObject < Hash; end
 
-  def call(params, options={})
+  def call(params, options = {})
     link = Committee::Drivers::HyperSchema::Link.new(@link)
     Committee::SchemaValidator::HyperSchema::ParameterCoercer.new(params, link.schema, options).call!
   end

data/test/schema_validator/hyper_schema/request_validator_test.rb

@@ -24,9 +24,7 @@ describe Committee::SchemaValidator::HyperSchema::RequestValidator do
     end
 
     it "passes through a valid request" do
-      data = {
-        "name" => "heroku-api",
-      }
+      data = { "name" => "heroku-api", }
       call(data)
     end
 
@@ -36,9 +34,7 @@ describe Committee::SchemaValidator::HyperSchema::RequestValidator do
                             "CONTENT_TYPE" => "application/json; charset=utf-8",
                             "rack.input"   => StringIO.new("{}"),
                           })
-      data = {
-        "name" => "heroku-api",
-      }
+      data = { "name" => "heroku-api", }
       call(data)
     end
 
@@ -51,8 +47,7 @@ describe Committee::SchemaValidator::HyperSchema::RequestValidator do
                             })
         call({})
       }
-      message =
-        %{"Content-Type" request header must be set to "application/json".}
+      message = %{"Content-Type" request header must be set to "application/json".}
       assert_equal message, e.message
     end
 
@@ -87,9 +82,7 @@ describe Committee::SchemaValidator::HyperSchema::RequestValidator do
     end
 
     it "detects a parameter of the wrong pattern" do
-      data = {
-        "name" => "%@!"
-      }
+      data = { "name" => "%@!" }
       e = assert_raises(Committee::InvalidRequest) do
         call(data)
       end
@@ -99,7 +92,7 @@ describe Committee::SchemaValidator::HyperSchema::RequestValidator do
 
     private
 
-    def call(data, headers={}, options={})
+    def call(data, headers = {}, options = {})
       # hyper-schema link should be dropped into driver wrapper before it's used
       link = Committee::Drivers::HyperSchema::Link.new(@link)
       Committee::SchemaValidator::HyperSchema::RequestValidator.new(link, options).call(@request, data, headers)
@@ -117,11 +110,8 @@ describe Committee::SchemaValidator::HyperSchema::RequestValidator do
                                    })
     end
 
-
     it "passes through a valid request" do
-      headers = {
-        "AUTH-TOKEN" => "xxx"
-      }
+      headers = { "AUTH-TOKEN" => "xxx" }
       call({}, headers)
     end
 
@@ -143,7 +133,7 @@ describe Committee::SchemaValidator::HyperSchema::RequestValidator do
 
     private
 
-    def call(data, headers={}, options={})
+    def call(data, headers = {}, options = {})
       # hyper-schema link should be dropped into driver wrapper before it's used
       Committee::SchemaValidator::HyperSchema::RequestValidator.new(@link, options).call(@request, data, headers)
     end

data/test/schema_validator/hyper_schema/response_generator_test.rb

@@ -65,8 +65,8 @@ describe Committee::SchemaValidator::HyperSchema::ResponseGenerator do
     end
 
     expected = <<-eos.gsub(/\n +/, "").strip
-      At "get /apps/{(%23%2Fdefinitions%2Fapp%2Fdefinitions%2Fname)}" 
-      "#/definitions/app/properties/maintenance": no "example" attribute and 
+      At "get /apps/{(%23%2Fdefinitions%2Fapp%2Fdefinitions%2Fname)}"#{' '}
+      "#/definitions/app/properties/maintenance": no "example" attribute and#{' '}
       "null" is not allowed; don't know how to generate property.
     eos
     assert_equal expected, e.message
@@ -74,52 +74,57 @@ describe Committee::SchemaValidator::HyperSchema::ResponseGenerator do
 
   it "generates first enum value for a schema with enum" do
     link = Committee::Drivers::OpenAPI2::Link.new
-    link.target_schema = JsonSchema::Schema.new
-    link.target_schema.enum = ["foo"]
-    link.target_schema.type = ["string"]
+    target_schema = JsonSchema::Schema.new
+    target_schema.enum = ["foo"]
+    target_schema.type = ["string"]
+    link.target_schemas = { 200 => target_schema }
     data, _schema = Committee::SchemaValidator::HyperSchema::ResponseGenerator.new.call(link)
     assert_equal("foo", data)
   end
 
   it "generates basic types" do
     link = Committee::Drivers::OpenAPI2::Link.new
-    link.target_schema = JsonSchema::Schema.new
+    target_schema = JsonSchema::Schema.new
+    link.target_schemas = { 200 => target_schema }
 
-    link.target_schema.type = ["integer"]
+    target_schema.type = ["integer"]
     data, _schema = Committee::SchemaValidator::HyperSchema::ResponseGenerator.new.call(link)
     assert_equal 0, data
 
-    link.target_schema.type = ["null"]
+    target_schema.type = ["null"]
     data, _schema = Committee::SchemaValidator::HyperSchema::ResponseGenerator.new.call(link)
     assert_nil data
 
-    link.target_schema.type = ["string"]
+    target_schema.type = ["string"]
     data, _schema = Committee::SchemaValidator::HyperSchema::ResponseGenerator.new.call(link)
     assert_equal "", data
   end
 
   it "generates an empty array for an array type" do
     link = Committee::Drivers::OpenAPI2::Link.new
-    link.target_schema = JsonSchema::Schema.new
-    link.target_schema.type = ["array"]
+    target_schema = JsonSchema::Schema.new
+    link.target_schemas = { 200 => target_schema }
+    target_schema.type = ["array"]
     data, _schema = Committee::SchemaValidator::HyperSchema::ResponseGenerator.new.call(link)
     assert_equal([], data)
   end
 
   it "generates an empty object for an object with no fields" do
     link = Committee::Drivers::OpenAPI2::Link.new
-    link.target_schema = JsonSchema::Schema.new
-    link.target_schema.type = ["object"]
+    target_schema = JsonSchema::Schema.new
+    link.target_schemas = { 200 => target_schema }
+    target_schema.type = ["object"]
     data, _schema = Committee::SchemaValidator::HyperSchema::ResponseGenerator.new.call(link)
     assert_equal({}, data)
   end
 
   it "prefers an example to a built-in value" do
     link = Committee::Drivers::OpenAPI2::Link.new
-    link.target_schema = JsonSchema::Schema.new
+    target_schema = JsonSchema::Schema.new
+    link.target_schemas = { 200 => target_schema }
 
-    link.target_schema.data = { "example" => 123 }
-    link.target_schema.type = ["integer"]
+    target_schema.data = { "example" => 123 }
+    target_schema.type = ["integer"]
 
     data, _schema = Committee::SchemaValidator::HyperSchema::ResponseGenerator.new.call(link)
     assert_equal 123, data
@@ -127,9 +132,10 @@ describe Committee::SchemaValidator::HyperSchema::ResponseGenerator do
 
   it "prefers non-null types to null types" do
     link = Committee::Drivers::OpenAPI2::Link.new
-    link.target_schema = JsonSchema::Schema.new
+    target_schema = JsonSchema::Schema.new
+    link.target_schemas = { 200 => target_schema }
 
-    link.target_schema.type = ["null", "integer"]
+    target_schema.type = ["null", "integer"]
     data, _schema = Committee::SchemaValidator::HyperSchema::ResponseGenerator.new.call(link)
     assert_equal 0, data
   end

data/test/schema_validator/hyper_schema/response_validator_test.rb

@@ -5,9 +5,7 @@ require "test_helper"
 describe Committee::SchemaValidator::HyperSchema::ResponseValidator do
   before do
     @status = 200
-    @headers = {
-      "Content-Type" => "application/json"
-    }
+    @headers = { "Content-Type" => "application/json" }
     @data = ValidApp.dup
     @schema = JsonSchema.parse!(hyper_schema_data)
     @schema.expand_references!
@@ -78,16 +76,14 @@ describe Committee::SchemaValidator::HyperSchema::ResponseValidator do
   it "detects a blank response Content-Type" do
     @headers = {}
     e = assert_raises(Committee::InvalidResponse) { call }
-    message =
-      %{"Content-Type" response header must be set to "#{@link.enc_type}".}
+    message = %{"Content-Type" response header must be set to "#{@link.enc_type}".}
     assert_equal message, e.message
   end
 
   it "detects an invalid response Content-Type" do
     @headers = { "Content-Type" => "text/html" }
     e = assert_raises(Committee::InvalidResponse) { call }
-    message =
-      %{"Content-Type" response header must be set to "#{@link.enc_type}".}
+    message = %{"Content-Type" response header must be set to "#{@link.enc_type}".}
     assert_equal message, e.message
   end
 

data/test/schema_validator/hyper_schema/string_params_coercer_test.rb

@@ -121,7 +121,7 @@ describe Committee::SchemaValidator::HyperSchema::StringParamsCoercer do
   private
 
   def check_convert(key, before_value, after_value)
-    data = {key => before_value}
+    data = { key => before_value }
     call(data)
 
     if !after_value.nil?
@@ -131,7 +131,7 @@ describe Committee::SchemaValidator::HyperSchema::StringParamsCoercer do
     end
   end
 
-  def call(data, options={})
+  def call(data, options = {})
     Committee::SchemaValidator::HyperSchema::StringParamsCoercer.new(data, @link.schema, options).call!
   end
 end