committee 2.3.0 → 2.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: c93972246b5dbf788152e0b307564f19bf9fd2ac
-  data.tar.gz: b56949031b0ddff186b158b4346a71743de8c607
+SHA256:
+  metadata.gz: eac1e86868d4ca6f8b7ef27f62ec87131ba1399985f48b0e7846a5ceda6d81cc
+  data.tar.gz: a0e76eea124800b0d8d328657ffb30efc3c683bbfd47707ce9c148500fc79307
 SHA512:
-  metadata.gz: 76b74624c59f7af781abe8359df8db12ded7cc697ccea6cc9c73eb03be7e07813eec6c32b0436f54c2902c5fd4e995bc3d729ebc502c43745b7c59750dbc0919
-  data.tar.gz: e82213545cd8918152a748d6637563fc2acd589f9e48b3f76d8b73d12b8f15f80a93f6ded6706a1d8383eaadd7cb14d0661ecf35dec1dde2cc9660387c0f43e5
+  metadata.gz: dcaa28428558ae7b9f6ce8679e826e62bdc0640228e35fb41a0998a1ccbbab4d505bc6e23ad052b907a45be6d2003152ab9803e132907a3c68b1a2fbf7fc5292
+  data.tar.gz: 0a1d640b9305e12a2ac6b7436b2971a8a1568322aa1d75a25f8ec4a25aed50229c5bd5c99e317c9c243d22099c1855ea93fbf17cc0692488a35a8f1ee03f8959

data/lib/committee/drivers.rb

@@ -13,6 +13,34 @@ module Committee
       end
     end
 
+    # load and build drive from JSON file
+    # @param [String] schema_path
+    # @return [Committee::Driver]
+    def self.load_from_json(schema_path)
+      json = JSON.parse(File.read(schema_path))
+      load_from_data(json)
+    end
+
+    # load and build drive from Hash object
+    # @param [Hash] hash
+    # @return [Committee::Driver]
+    def self.load_from_data(hash)
+      driver = if hash['swagger'] == '2.0'
+                 Committee::Drivers::OpenAPI2.new
+               else
+                 Committee::Drivers::HyperSchema.new
+               end
+
+      driver.parse(hash)
+    end
+
+    # load and build drive from file
+    # @param [String] schema_path
+    # @return [Committee::Driver]
+    def self.load_from_file(schema_path)
+      load_from_json(schema_path)
+    end
+
     # Driver is a base class for driver implementations.
     class Driver
       # Whether parameters that were form-encoded will be coerced by default.

data/lib/committee/middleware/base.rb

@@ -7,8 +7,7 @@ module Committee::Middleware
       @params_key = options[:params_key] || "committee.params"
       @headers_key = options[:headers_key] || "committee.headers"
       @raise = options[:raise]
-      @schema = get_schema(options[:schema] ||
-        raise(ArgumentError, "Committee: need option `schema`"))
+      @schema = get_schema(options)
 
       @router = Committee::Router.new(@schema,
         prefix: options[:prefix]
@@ -36,7 +35,14 @@ module Committee::Middleware
     # input to be a string, a data hash, or a JsonSchema::Schema. In the former
     # two cases we just parse as if we were sent hyper-schema. In the latter,
     # we have the hyper-schema driver wrap it in a new Committee object.
-    def get_schema(schema)
+    def get_schema(options)
+      schema = options[:schema]
+      unless schema
+        schema = Committee::Drivers::load_from_file(options[:schema_path]) if options[:schema_path]
+
+        raise(ArgumentError, "Committee: need option `schema` or schema_path") unless schema
+      end
+
       # These are in a separately conditional ladder so that we only show the
       # user one warning.
       if schema.is_a?(String)
@@ -62,8 +68,8 @@ module Committee::Middleware
       # Expect the type we want by now. If we don't have it, the user passed
       # something else non-standard in.
       if !schema.is_a?(Committee::Drivers::Schema)
-        raise ArgumentError, "Committee: schema expected to be a hash or " \
-          "an instance of Committee::Drivers::Schema."
+        raise ArgumentError, "Committee: schema expected to be an instance of " \
+          "Committee::Drivers::Schema."
       end
 
       schema
@@ -71,17 +77,17 @@ module Committee::Middleware
 
     def warn_json_schema_deprecated
       Committee.warn_deprecated("Committee: passing a JsonSchema::Schema to schema " \
-        "option is deprecated; please send a driver object instead.")
+        "option is deprecated; please send an instance of Committee::Drivers::Schema instead.")
     end
 
     def warn_hash_deprecated
       Committee.warn_deprecated("Committee: passing a hash to schema " \
-        "option is deprecated; please send a driver object instead.")
+        "option is deprecated; please send an instance of Committee::Drivers::Schema instead.")
     end
 
     def warn_string_deprecated
       Committee.warn_deprecated("Committee: passing a string to schema " \
-        "option is deprecated; please send a driver object instead.")
+        "option is deprecated; please send an instance of Committee::Drivers::Schema instead.")
     end
   end
 end

data/lib/committee/middleware/request_validation.rb

@@ -46,6 +46,7 @@ module Committee::Middleware
         allow_query_params: @allow_query_params,
         coerce_form_params: @coerce_form_params,
         optimistic_json:    @optimistic_json,
+        coerce_recursive:   @coerce_recursive,
         schema:             link ? link.schema : nil
       ).call
 

data/lib/committee/middleware/response_validation.rb

@@ -1,10 +1,18 @@
 module Committee::Middleware
   class ResponseValidation < Base
-    attr_reader :validate_errors
+    attr_reader :validate_success_only
 
     def initialize(app, options = {})
       super
-      @validate_errors = options[:validate_errors]
+      @validate_success_only = options.fetch(:validate_success_only, true)
+
+      unless options[:validate_errors].nil?
+        @validate_success_only = !options[:validate_errors]
+        Committee.warn_deprecated("Committee: validate_errors option is deprecated; " \
+        "please use validate_success_only=#{@validate_success_only}.")
+      end
+
+      @error_handler = options[:error_handler]
     end
 
     def handle(request)
@@ -16,21 +24,23 @@ module Committee::Middleware
         response.each do |chunk|
           full_body << chunk
         end
-        data = JSON.parse(full_body)
-        Committee::ResponseValidator.new(link, validate_errors: validate_errors).call(status, headers, data)
+        data = full_body.empty? ? {} : JSON.parse(full_body)
+        Committee::ResponseValidator.new(link, validate_success_only: validate_success_only).call(status, headers, data)
       end
 
       [status, headers, response]
     rescue Committee::InvalidResponse
+      @error_handler.call($!) if @error_handler
       raise if @raise
       @error_class.new(500, :invalid_response, $!.message).render
     rescue JSON::ParserError
+      @error_handler.call($!) if @error_handler
       raise Committee::InvalidResponse if @raise
       @error_class.new(500, :invalid_response, "Response wasn't valid JSON.").render
     end
 
     def validate?(status)
-      Committee::ResponseValidator.validate?(status, validate_errors: validate_errors)
+      Committee::ResponseValidator.validate?(status, validate_success_only: validate_success_only)
     end
   end
 end

data/lib/committee/request_unpacker.rb

@@ -7,6 +7,7 @@ module Committee
       @allow_query_params = options[:allow_query_params]
       @coerce_form_params = options[:coerce_form_params]
       @optimistic_json    = options[:optimistic_json]
+      @coerce_recursive   = options[:coerce_recursive]
       @schema             = options[:schema]
     end
 
@@ -31,7 +32,7 @@ module Committee
         p = @request.POST
 
         if @coerce_form_params && @schema
-          Committee::StringParamsCoercer.new(p, @schema).call!
+          Committee::StringParamsCoercer.new(p, @schema, coerce_recursive: @coerce_recursive).call!
         end
 
         p

data/lib/committee/response_validator.rb

@@ -1,18 +1,18 @@
 module Committee
   class ResponseValidator
-    attr_reader :validate_errors
+    attr_reader :validate_success_only
 
     def initialize(link, options = {})
       @link = link
-      @validate_errors = options[:validate_errors]
+      @validate_success_only = options[:validate_success_only]
 
       @validator = JsonSchema::Validator.new(target_schema(link))
     end
 
     def self.validate?(status, options = {})
-      validate_errors = options[:validate_errors]
+      validate_success_only = options[:validate_success_only]
 
-      status != 204 and validate_errors || (200...300).include?(status)
+      status != 204 and !validate_success_only || (200...300).include?(status)
     end
 
     def call(status, headers, data)
@@ -41,7 +41,7 @@ module Committee
         return if data == nil
       end
 
-      if self.class.validate?(status, validate_errors: validate_errors) && !@validator.validate(data)
+      if self.class.validate?(status, validate_success_only: validate_success_only) && !@validator.validate(data)
         errors = JsonSchema::SchemaError.aggregate(@validator.errors).join("\n")
         raise InvalidResponse, "Invalid response.\n\n#{errors}"
       end

data/lib/committee/router.rb

@@ -16,15 +16,15 @@ module Committee
 
     def find_link(method, path)
       path = path.gsub(@prefix_regexp, "") if @prefix
-      if method_routes = @schema.routes[method]
-        method_routes.each do |pattern, link|
-          if matches = pattern.match(path)
-            hash = Hash[matches.names.zip(matches.captures)]
-            return link, hash
-          end
+      link_with_matches = (@schema.routes[method] || []).map do |pattern, link|
+        if matches = pattern.match(path)
+          # prefer path which has fewer matches (eg. `/pets/dog` than `/pets/{uuid}` for path `/pets/dog` )
+          [matches.captures.size, link, Hash[matches.names.zip(matches.captures)]]
+        else
+          nil
         end
-      end
-      nil
+      end.compact.sort_by(&:first).first
+      link_with_matches.nil? ? nil : link_with_matches.slice(1, 2)
     end
 
     def find_request_link(request)

data/lib/committee/test/methods.rb

@@ -35,25 +35,49 @@ module Committee::Test
       @committee_router ||= Committee::Router.new(@committee_schema,
         prefix: schema_url_prefix)
 
-      link, _ = @committee_router.find_request_link(last_request)
+      link, _ = @committee_router.find_request_link(request_object)
       unless link
-        response = "`#{last_request.request_method} #{last_request.path_info}` undefined in schema."
+        response = "`#{request_object.request_method} #{request_object.path_info}` undefined in schema."
         raise Committee::InvalidResponse.new(response)
       end
 
-      if validate_response?(last_response.status)
-        data = JSON.parse(last_response.body)
-        Committee::ResponseValidator.new(link).call(last_response.status, last_response.headers, data)
+      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
+    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
 
@@ -61,14 +85,26 @@ module Committee::Test
     # 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
     end
 
@@ -85,7 +121,19 @@ module Committee::Test
     end
 
     def validate_response?(status)
-      Committee::ResponseValidator.validate?(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)
     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/drivers_test.rb

@@ -19,6 +19,48 @@ describe Committee::Drivers do
     end
     assert_equal %{Committee: unknown driver "blueprint".}, e.message
   end
+
+  describe 'load_from_file(schema_path)' do
+    it 'load OpenAPI2' do
+      s = Committee::Drivers.load_from_file(open_api_2_schema_path)
+      assert_kind_of Committee::Drivers::Schema, s
+      assert_kind_of Committee::Drivers::OpenAPI2::Schema, s
+    end
+
+    it 'load Hyper-Schema' do
+      s = Committee::Drivers.load_from_file(hyper_schema_schema_path)
+      assert_kind_of Committee::Drivers::Schema, s
+      assert_kind_of Committee::Drivers::HyperSchema::Schema, s
+    end
+  end
+
+  describe 'load_from_json(schema_path)' do
+    it 'load OpenAPI2' do
+      s = Committee::Drivers.load_from_json(open_api_2_schema_path)
+      assert_kind_of Committee::Drivers::Schema, s
+      assert_kind_of Committee::Drivers::OpenAPI2::Schema, s
+    end
+
+    it 'load Hyper-Schema' do
+      s = Committee::Drivers.load_from_json(hyper_schema_schema_path)
+      assert_kind_of Committee::Drivers::Schema, s
+      assert_kind_of Committee::Drivers::HyperSchema::Schema, s
+    end
+  end
+
+  describe 'load_from_data(schema_path)' do
+    it 'load OpenAPI2' do
+      s = Committee::Drivers.load_from_data(open_api_2_data)
+      assert_kind_of Committee::Drivers::Schema, s
+      assert_kind_of Committee::Drivers::OpenAPI2::Schema, s
+    end
+
+    it 'load Hyper-Schema' do
+      s = Committee::Drivers.load_from_data(hyper_schema_data)
+      assert_kind_of Committee::Drivers::Schema, s
+      assert_kind_of Committee::Drivers::HyperSchema::Schema, s
+    end
+  end
 end
 
 describe Committee::Drivers::Driver do

data/test/middleware/base_test.rb

@@ -65,8 +65,19 @@ describe Committee::Middleware::Base do
     e = assert_raises(ArgumentError) do
       post "/apps"
     end
-    assert_equal "Committee: schema expected to be a hash or an instance " +
-      "of Committee::Drivers::Schema.", e.message
+    assert_equal "Committee: schema expected to be an instance of Committee::Drivers::Schema.", e.message
+  end
+
+  describe 'initialize option' do
+    it "schema_path option with hyper-schema" do
+      b = Committee::Middleware::Base.new(nil, schema_path: hyper_schema_schema_path)
+      assert_kind_of Committee::Drivers::HyperSchema::Schema, b.instance_variable_get(:@schema)
+    end
+
+    it "schema_path option with OpenAPI2" do
+      b = Committee::Middleware::Base.new(nil, schema_path: open_api_2_schema_path)
+      assert_kind_of Committee::Drivers::OpenAPI2::Schema, b.instance_variable_get(:@schema)
+    end
   end
 
   private

data/test/middleware/response_validation_test.rb

@@ -13,6 +13,14 @@ describe Committee::Middleware::ResponseValidation do
     assert_equal 200, last_response.status
   end
 
+  it "doesn't call error_handler when response is valid" do
+    called = false
+    pr = ->(_e) { called = true }
+    @app = new_rack_app(JSON.generate([ValidApp]), {}, schema: hyper_schema, error_handler: pr)
+    get "/apps"
+    assert !called, "error_handler is called"
+  end
+
   it "detects a response invalid due to schema" do
     @app = new_rack_app("{}", {}, schema: hyper_schema)
     get "/apps"
@@ -21,7 +29,7 @@ describe Committee::Middleware::ResponseValidation do
   end
 
   it "detects a response invalid due to not being JSON" do
-    @app = new_rack_app("", {}, schema: hyper_schema)
+    @app = new_rack_app("{_}", {}, schema: hyper_schema)
     get "/apps"
     assert_equal 500, last_response.status
     assert_match(/valid JSON/i, last_response.body)
@@ -33,10 +41,26 @@ describe Committee::Middleware::ResponseValidation do
     assert_equal 404, last_response.status
   end
 
+  it "optionally validates non-2xx invalid responses and deprecated option" do
+    mock(Committee).warn_deprecated.with_any_args
+
+    @app = new_rack_app("{_}", {}, app_status: 404, validate_errors: true,
+                        schema: hyper_schema)
+
+    get "/apps"
+    assert_equal 500, last_response.status
+    assert_match(/valid JSON/i, last_response.body)
+  end
+
   it "optionally validates non-2xx invalid responses" do
-    @app = new_rack_app("", {}, app_status: 404, validate_errors: true,
-      schema: hyper_schema)
+    @app = new_rack_app("", {}, app_status: 404, validate_success_only: false, schema: hyper_schema)
+    get "/apps"
+    assert_equal 500, last_response.status
+    assert_match(/Invalid response/i, last_response.body)
+  end
 
+  it "optionally validates non-2xx invalid responses with invalid json" do
+    @app = new_rack_app("{_}", {}, app_status: 404, validate_success_only: false, schema: hyper_schema)
     get "/apps"
     assert_equal 500, last_response.status
     assert_match(/valid JSON/i, last_response.body)
@@ -48,13 +72,28 @@ describe Committee::Middleware::ResponseValidation do
     assert_equal 204, last_response.status
   end
 
+  it "skip validation when 4xx" do
+    @app = new_rack_app("[{x:y}]", {}, schema: hyper_schema, validate_success_only: true, app_status: 400)
+    get "/apps"
+    assert_equal 400, last_response.status
+    assert_match("[{x:y}]", last_response.body)
+  end
+
   it "rescues JSON errors" do
-    @app = new_rack_app("[{x:y}]", {}, schema: hyper_schema)
+    @app = new_rack_app("[{x:y}]", {}, schema: hyper_schema, validate_success_only: false)
     get "/apps"
     assert_equal 500, last_response.status
     assert_match(/valid json/i, last_response.body)
   end
 
+  it "calls error_handler when it rescues JSON errors" do
+    called_err = nil
+    pr = ->(e) { called_err = e }
+    @app = new_rack_app("[{x:y}]", {}, schema: hyper_schema, error_handler: pr)
+    get "/apps"
+    assert_kind_of JSON::ParserError, called_err
+  end
+
   it "takes a prefix" do
     @app = new_rack_app(JSON.generate([ValidApp]), {}, prefix: "/v1",
       schema: hyper_schema)
@@ -69,6 +108,16 @@ describe Committee::Middleware::ResponseValidation do
     end
   end
 
+  it "calls error_handler when it rescues JSON errors" do
+    called_err = nil
+    pr = ->(e) { called_err = e }
+    @app = new_rack_app("[{x:y}]", {}, raise: true, schema: hyper_schema, error_handler: pr)
+    assert_raises(Committee::InvalidResponse) do
+      get "/apps"
+      assert_kind_of JSON::ParserError, called_err
+    end
+  end
+
   it "passes through a valid response for OpenAPI" do
     @app = new_rack_app(JSON.generate([ValidPet]), {},
       schema: open_api_2_schema)
@@ -77,7 +126,7 @@ describe Committee::Middleware::ResponseValidation do
   end
 
   it "detects an invalid response for OpenAPI" do
-    @app = new_rack_app("", {}, schema: open_api_2_schema)
+    @app = new_rack_app("{_}", {}, schema: open_api_2_schema)
     get "/api/pets"
     assert_equal 500, last_response.status
     assert_match(/valid JSON/i, last_response.body)

data/test/request_unpacker_test.rb

@@ -113,6 +113,30 @@ describe Committee::RequestUnpacker do
     end
   end
 
+  it "coerces form params with coerce_form_params, coerce_recursive and a schema" do
+    %w[application/x-www-form-urlencoded multipart/form-data].each do |content_type|
+      schema = JsonSchema::Schema.new
+      schema.properties = { "x" => JsonSchema::Schema.new }
+      schema.properties["x"].type = ["object"]
+      schema.properties["x"].properties = { "y" => JsonSchema::Schema.new }
+      schema.properties["x"].properties["y"].type = ["integer"]
+
+      env = {
+        "CONTENT_TYPE" => content_type,
+        "rack.input"   => StringIO.new("x[y]=1"),
+      }
+      request = Rack::Request.new(env)
+      params, _ = Committee::RequestUnpacker.new(
+        request,
+        allow_form_params: true,
+        coerce_form_params: true,
+        coerce_recursive: true,
+        schema: schema
+      ).call
+      assert_equal({ "x" => { "y" => 1 } }, params)
+    end
+  end
+
   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 = {

data/test/router_test.rb

@@ -44,6 +44,7 @@ describe Committee::Router do
   it "provides named parameters" do
     link, param_matches = open_api_2_router.find_link("GET", "/api/pets/fido")
     refute_nil link
+    assert_equal '/api/pets/{id}', link.href
     assert_equal({ "id" => "fido" }, param_matches)
   end
 
@@ -53,6 +54,18 @@ describe Committee::Router do
     assert_equal({}, param_matches)
   end
 
+  it "finds a path which has fewer matches" do
+    link, _ = open_api_2_router.find_link("GET", "/api/pets/dog")
+    refute_nil link
+    assert_equal '/api/pets/dog', link.href
+  end
+
+  it "fewer match not support in HyperSchema" do
+    link, _ = hyper_schema_router.find_link("GET", "/apps/abc")
+    refute_nil link
+    assert_equal '/apps/{(%23%2Fdefinitions%2Fapp%2Fdefinitions%2Fname)}', link.href
+  end
+
   def hyper_schema_router(options = {})
     schema = Committee::Drivers::HyperSchema.new.parse(hyper_schema_data)
     Committee::Router.new(schema, options)

data/test/test/methods_new_version_test.rb

@@ -0,0 +1,76 @@
+require_relative "../test_helper"
+
+describe Committee::Test::Methods do
+  include Committee::Test::Methods
+  include Rack::Test::Methods
+
+  def app
+    @app
+  end
+
+  def committee_options
+    @committee_options
+  end
+
+  before do
+    # This is a little icky, but the test methods will cache router and schema
+    # values between tests. This makes sense in real life, but is harmful for
+    # our purposes here in testing the module.
+    @committee_router = nil
+    @committee_schema = nil
+
+    @committee_options = {schema: hyper_schema}
+  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
+    end
+
+    it "passes with prefix" do
+      @committee_options.merge!(prefix: "/v1")
+
+      @app = new_rack_app(JSON.generate([ValidApp]))
+      get "/v1/apps"
+      assert_schema_conform
+    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
+      end
+      assert_match(/response header must be set to/i, e.message)
+    end
+
+    it "detects an invalid response Content-Type but ignore because it's not success status code" do
+      @app = new_rack_app(JSON.generate([ValidApp]), 400, {})
+      get "/apps"
+      assert_schema_conform
+    end
+
+    it "detects an invalid response Content-Type and check all status code" do
+      @committee_options.merge!(validate_success_only: false)
+
+      @app = new_rack_app(JSON.generate([ValidApp]), 400, {})
+      get "/apps"
+      e = assert_raises(Committee::InvalidResponse) do
+        assert_schema_conform
+      end
+      assert_match(/response header must be set to/i, e.message)
+    end
+  end
+
+  private
+
+  def new_rack_app(response, status=200, headers={ "Content-Type" => "application/json" })
+    Rack::Builder.new {
+      run lambda { |_|
+        [status, headers, [response]]
+      }
+    }
+  end
+end

data/test/test/methods_test.rb

@@ -29,12 +29,16 @@ describe Committee::Test::Methods do
 
   describe "#assert_schema_conform" do
     it "passes through a valid response" do
+      mock(Committee).warn_deprecated.with_any_args.times(2)
+
       @app = new_rack_app(JSON.generate([ValidApp]))
       get "/apps"
       assert_schema_conform
     end
 
     it "detects an invalid response Content-Type" do
+      mock(Committee).warn_deprecated.with_any_args.times(2)
+
       @app = new_rack_app(JSON.generate([ValidApp]), {})
       get "/apps"
       e = assert_raises(Committee::InvalidResponse) do
@@ -44,7 +48,7 @@ describe Committee::Test::Methods do
     end
 
     it "accepts schema string (legacy behavior)" do
-      mock(Committee).warn_deprecated.with_any_args
+      mock(Committee).warn_deprecated.with_any_args.times(3)
 
       stub(self).committee_schema { nil }
       stub(self).schema_contents { JSON.dump(hyper_schema_data) }
@@ -55,7 +59,7 @@ describe Committee::Test::Methods do
     end
 
     it "accepts schema hash (legacy behavior)" do
-      mock(Committee).warn_deprecated.with_any_args
+      mock(Committee).warn_deprecated.with_any_args.times(3)
 
       stub(self).committee_schema { nil }
       stub(self).schema_contents { hyper_schema_data }
@@ -69,6 +73,7 @@ describe Committee::Test::Methods do
       # Note we don't warn here because this is a recent deprecation and
       # passing a schema object will not be a huge performance hit. We should
       # probably start warning on the next version.
+      mock(Committee).warn_deprecated.with_any_args.times(2)
 
       stub(self).committee_schema { nil }
       stub(self).schema_contents do

data/test/test_helper.rb

@@ -47,25 +47,27 @@ ValidPet = {
 }.freeze
 
 def hyper_schema
-  @hyper_schema ||= begin
-    driver = Committee::Drivers::HyperSchema.new
-    driver.parse(hyper_schema_data)
-  end
+  @hyper_schema ||= Committee::Drivers.load_from_file(hyper_schema_schema_path)
 end
 
 def open_api_2_schema
-  @open_api_2_schema ||= begin
-    driver = Committee::Drivers::OpenAPI2.new
-    driver.parse(open_api_2_data)
-  end
+  @open_api_2_schema ||= Committee::Drivers.load_from_data(open_api_2_data)
 end
 
 # Don't cache this because we'll often manipulate the created hash in tests.
 def hyper_schema_data
-  JSON.parse(File.read("./test/data/hyperschema/paas.json"))
+  JSON.parse(File.read(hyper_schema_schema_path))
 end
 
 # Don't cache this because we'll often manipulate the created hash in tests.
 def open_api_2_data
-  JSON.parse(File.read("./test/data/openapi2/petstore-expanded.json"))
+  JSON.parse(File.read(open_api_2_schema_path))
+end
+
+def hyper_schema_schema_path
+  "./test/data/hyperschema/paas.json"
+end
+
+def open_api_2_schema_path
+  "./test/data/openapi2/petstore-expanded.json"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: committee
 version: !ruby/object:Gem::Version
-  version: 2.3.0
+  version: 2.4.0
 platform: ruby
 authors:
 - Brandur
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-11-15 00:00:00.000000000 Z
+date: 2019-01-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: json_schema
@@ -189,6 +189,7 @@ files:
 - test/response_validator_test.rb
 - test/router_test.rb
 - test/string_params_coercer_test.rb
+- test/test/methods_new_version_test.rb
 - test/test/methods_test.rb
 - test/test_helper.rb
 - test/validation_error_test.rb
@@ -212,7 +213,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.14
+rubygems_version: 2.7.3
 signing_key: 
 specification_version: 4
 summary: A collection of Rack middleware to support JSON Schema.