committee 1.15.0 → 5.0.0

data/lib/committee/schema_validator/option.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module Committee
+  module SchemaValidator
+    class Option
+      # Boolean Options
+      attr_reader :allow_form_params,
+                  :allow_get_body,
+                  :allow_query_params,
+                  :check_content_type,
+                  :check_header,
+                  :coerce_date_times,
+                  :coerce_form_params,
+                  :coerce_path_params,
+                  :coerce_query_params,
+                  :coerce_recursive,
+                  :optimistic_json,
+                  :validate_success_only,
+                  :parse_response_by_content_type,
+                  :parameter_overwite_by_rails_rule
+
+      # Non-boolean options:
+      attr_reader :headers_key,
+                  :params_key,
+                  :query_hash_key,
+                  :request_body_hash_key,
+                  :path_hash_key,
+                  :prefix
+
+      def initialize(options, schema, schema_type)
+        # Non-boolean options
+        @headers_key         = options[:headers_key]    || "committee.headers"
+        @params_key          = options[:params_key]     || "committee.params"
+        @query_hash_key      = options[:query_hash_key] || "committee.query_hash"
+        @path_hash_key      = options[:path_hash_key] || "committee.path_hash"
+        @request_body_hash_key = options[:request_body_hash_key] || "committee.request_body_hash"
+
+        @prefix              = options[:prefix]
+
+        # Boolean options and have a common value by default
+        @allow_form_params   = options.fetch(:allow_form_params, true)
+        @allow_query_params  = options.fetch(:allow_query_params, true)
+        @check_content_type  = options.fetch(:check_content_type, true)
+        @check_header        = options.fetch(:check_header, true)
+        @coerce_recursive    = options.fetch(:coerce_recursive, true)
+        @optimistic_json     = options.fetch(:optimistic_json, false)
+        @parse_response_by_content_type = options.fetch(:parse_response_by_content_type, true)
+        @parameter_overwite_by_rails_rule = options.fetch(:parameter_overwite_by_rails_rule, true)
+
+        # Boolean options and have a different value by default
+        @allow_get_body      = options.fetch(:allow_get_body, schema.driver.default_allow_get_body)
+        @coerce_date_times   = options.fetch(:coerce_date_times, schema.driver.default_coerce_date_times)
+        @coerce_form_params  = options.fetch(:coerce_form_params, schema.driver.default_coerce_form_params)
+        @coerce_path_params  = options.fetch(:coerce_path_params, schema.driver.default_path_params)
+        @coerce_query_params = options.fetch(:coerce_query_params, schema.driver.default_query_params)
+        @validate_success_only = options.fetch(:validate_success_only, schema.driver.default_validate_success_only)
+      end
+    end
+  end
+end

data/lib/committee/schema_validator.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Committee
+  module SchemaValidator
+    class << self
+      def request_media_type(request)
+        request.media_type.to_s
+      end
+
+      # @param [String] prefix
+      # @return [Regexp]
+      def build_prefix_regexp(prefix)
+        return nil unless prefix
+
+        /\A#{Regexp.escape(prefix)}/.freeze
+      end
+    end
+  end
+end
+
+require_relative "schema_validator/hyper_schema"
+require_relative "schema_validator/open_api_3"
+require_relative "schema_validator/option"

data/lib/committee/test/methods.rb

@@ -1,54 +1,84 @@
-module Committee::Test
-  module Methods
-    def assert_schema_conform
-      if (data = schema_contents).is_a?(String)
-        warn_string_deprecated
-        data = JSON.parse(data)
+# frozen_string_literal: true
+
+module Committee
+  module Test
+    module Methods
+      def assert_schema_conform(expected_status = nil)
+        assert_request_schema_confirm unless old_behavior
+        assert_response_schema_confirm(expected_status)
       end
 
-      @schema ||= begin
-        schema = JsonSchema.parse!(data)
-        schema.expand_references!
-        schema
+      def assert_request_schema_confirm
+        unless schema_validator.link_exist?
+          request = "`#{request_object.request_method} #{request_object.path_info}` undefined in schema (prefix: #{committee_options[:prefix].inspect})."
+          raise Committee::InvalidRequest.new(request)
+        end
+
+        schema_validator.request_validate(request_object)
       end
-      @router ||= Committee::Router.new(@schema, prefix: schema_url_prefix)
 
-      unless link = @router.find_request_link(last_request)
-        response = "`#{last_request.request_method} #{last_request.path_info}` undefined in schema."
-        raise Committee::InvalidResponse.new(response)
+      def assert_response_schema_confirm(expected_status = nil)
+        unless schema_validator.link_exist?
+          response = "`#{request_object.request_method} #{request_object.path_info}` undefined in schema (prefix: #{committee_options[:prefix].inspect})."
+          raise Committee::InvalidResponse.new(response)
+        end
+
+        status, headers, body = response_data
+
+        if expected_status.nil?
+          Committee.need_good_option('Pass expected response status code to check it against the corresponding schema explicitly.')
+        elsif expected_status != status
+          response = "Expected `#{expected_status}` status code, but it was `#{status}`."
+          raise Committee::InvalidResponse.new(response)
+        end
+
+        if schema_coverage
+          operation_object = router.operation_object(request_object)
+          schema_coverage&.update_response_coverage!(operation_object.original_path, operation_object.http_method, status)
+        end
+
+        schema_validator.response_validate(status, headers, [body], true) if validate_response?(status)
       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)
+      def committee_options
+        raise "please set options"
       end
-    end
 
-    def assert_schema_content_type
-      Committee.warn_deprecated("Committee: use of #assert_schema_content_type is deprecated; use #assert_schema_conform instead.")
-    end
+      def request_object
+        raise "please set object like 'last_request'"
+      end
 
-    # can be overridden alternatively to #schema_path in case the schema is
-    # easier to access as a string
-    # blob
-    def schema_contents
-      JSON.parse(File.read(schema_path))
-    end
+      def response_data
+        raise "please set response data like 'last_response.status, last_response.headers, last_response.body'"
+      end
 
-    def schema_path
-      raise "Please override #schema_contents or #schema_path."
-    end
+      def validate_response?(status)
+        Committee::Middleware::ResponseValidation.validate?(status, committee_options.fetch(:validate_success_only, false))
+      end
 
-    def schema_url_prefix
-      nil
-    end
+      def schema
+        @schema ||= Committee::Middleware::Base.get_schema(committee_options)
+      end
 
-    def warn_string_deprecated
-      Committee.warn_deprecated("Committee: returning a string from `#schema_contents` is deprecated; please return a deserialized hash instead.")
-    end
+      def router
+        @router ||= schema.build_router(committee_options)
+      end
+
+      def schema_validator
+        @schema_validator ||= router.build_schema_validator(request_object)
+      end
+
+      def schema_coverage
+        return nil unless schema.is_a?(Committee::Drivers::OpenAPI3::Schema)
+
+        coverage = committee_options.fetch(:schema_coverage, nil)
 
-    def validate_response?(status)
-      Committee::ResponseValidator.validate?(status)
+        coverage.is_a?(SchemaCoverage) ? coverage : nil
+      end
+
+      def old_behavior
+        committee_options.fetch(:old_assert_behavior, false)
+      end
     end
   end
 end

data/lib/committee/test/schema_coverage.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+module Committee
+  module Test
+    class SchemaCoverage
+      attr_reader :schema
+
+      class << self
+        def merge_report(first, second)
+          report = first.dup
+          second.each do |k, v|
+            if v.is_a?(Hash)
+              if report[k].nil?
+                report[k] = v
+              else
+                report[k] = merge_report(report[k], v)
+              end
+            else
+              report[k] ||= v
+            end
+          end
+          report
+        end
+
+        def flatten_report(report)
+          responses = []
+          report.each do |path_name, path_coverage|
+            path_coverage.each do |method, method_coverage|
+              responses_coverage = method_coverage['responses']
+              responses_coverage.each do |response_status, is_covered|
+                responses << {
+                  path: path_name,
+                  method: method,
+                  status: response_status,
+                  is_covered: is_covered,
+                }
+              end
+            end
+          end
+          {
+            responses: responses,
+          }
+        end
+      end
+
+      def initialize(schema)
+        raise 'Unsupported schema' unless schema.is_a?(Committee::Drivers::OpenAPI3::Schema)
+
+        @schema = schema
+        @covered = {}
+      end
+
+      def update_response_coverage!(path, method, response_status)
+        method = method.to_s.downcase
+        response_status = response_status.to_s
+
+        @covered[path] ||= {}
+        @covered[path][method] ||= {}
+        @covered[path][method]['responses'] ||= {}
+        @covered[path][method]['responses'][response_status] = true
+      end
+
+      def report
+        report = {}
+
+        schema.open_api.paths.path.each do |path_name, path_item|
+          report[path_name] = {}
+          path_item._openapi_all_child_objects.each do |object_name, object|
+            next unless object.is_a?(OpenAPIParser::Schemas::Operation)
+
+            method = object_name.split('/').last&.downcase
+            next unless method
+
+            report[path_name][method] ||= {}
+
+            # TODO: check coverage on request params/body as well?
+
+            report[path_name][method]['responses'] ||= {}
+            object.responses.response.each do |response_status, _|
+              is_covered = @covered.dig(path_name, method, 'responses', response_status) || false
+              report[path_name][method]['responses'][response_status] = is_covered
+            end
+            if object.responses.default
+              is_default_covered = (@covered.dig(path_name, method, 'responses') || {}).any? do |status, is_covered|
+                is_covered && !object.responses.response.key?(status)
+              end
+              report[path_name][method]['responses']['default'] = is_default_covered
+            end
+          end
+        end
+
+        report
+      end
+
+      def report_flatten
+        self.class.flatten_report(report)
+      end
+    end
+  end
+end
+

data/lib/committee/utils.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Committee
+    module Utils
+        # Creates a Hash with indifferent access.
+        #
+        # (Copied from Sinatra)
+        def self.indifferent_hash
+            Hash.new { |hash,key| hash[key.to_s] if Symbol === key }
+        end
+
+        def self.deep_copy(from)
+            if from.is_a?(Hash)
+                h = Committee::Utils.indifferent_hash
+                from.each_pair do |k, v|
+                h[k] = deep_copy(v)
+                end
+                return h
+            end
+
+            if from.is_a?(Array)
+                return from.map{ |v| deep_copy(v) }
+            end
+
+            return from
+        end
+    end
+end

data/lib/committee/validation_error.rb

@@ -1,11 +1,14 @@
+# frozen_string_literal: true
+
 module Committee
   class ValidationError
-    attr_reader :id, :message, :status
+    attr_reader :id, :message, :status, :request
 
-    def initialize(status, id, message)
+    def initialize(status, id, message, request = nil)
       @status = status
       @id = id
       @message = message
+      @request = request
     end
 
     def error_body

data/lib/committee/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Committee
+    VERSION = '5.0.0'.freeze
+end

data/lib/committee.rb

@@ -1,27 +1,40 @@
+# frozen_string_literal: true
+
 require "json"
+require "yaml"
 require "json_schema"
 require "rack"
+require 'openapi_parser'
 
-require_relative "committee/errors"
-require_relative "committee/query_params_coercer"
-require_relative "committee/request_unpacker"
-require_relative "committee/request_validator"
-require_relative "committee/response_generator"
-require_relative "committee/response_validator"
-require_relative "committee/router"
-require_relative "committee/validation_error"
+require_relative "committee/version"
 
-require_relative "committee/middleware/base"
-require_relative "committee/middleware/request_validation"
-require_relative "committee/middleware/response_validation"
-require_relative "committee/middleware/stub"
+module Committee
+  def self.debug?
+    ENV["COMMITTEE_DEBUG"]
+  end
 
-require_relative "committee/test/methods"
+  def self.log_debug(message)
+    $stderr.puts(message) if debug?
+  end
 
-module Committee
-  def self.warn_deprecated(message)
-    if !$VERBOSE.nil?
-      $stderr.puts(message)
-    end
+  def self.need_good_option(message)
+    warn(message)
+  end
+
+  def self.warn_deprecated_until_6(cond, message)
+    raise "remove deprecated!"  unless Committee::VERSION.start_with?("5")
+    warn("[DEPRECATION] #{message}") if cond
   end
 end
+
+require_relative "committee/utils"
+require_relative "committee/drivers"
+require_relative "committee/errors"
+require_relative "committee/middleware"
+require_relative "committee/request_unpacker"
+require_relative "committee/schema_validator"
+require_relative "committee/validation_error"
+
+require_relative "committee/bin/committee_stub"
+require_relative "committee/test/methods"
+require_relative "committee/test/schema_coverage"

data/test/bin/committee_stub_test.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+describe Committee::Bin::CommitteeStub do
+  before do
+    @bin = Committee::Bin::CommitteeStub.new
+  end
+
+  it "produces a Rack app" do
+    app = @bin.get_app(hyper_schema, {})
+    assert_kind_of Rack::Builder, app
+  end
+
+  it "parses command line options" do
+    options, parser = @bin.get_options_parser
+
+    parser.parse!(["--help"])
+    assert_equal true, options[:help]
+
+    parser.parse!([
+      "--driver", "open_api_2",
+      "--tolerant", "true",
+      "--port", "1234"
+    ])
+    assert_equal :open_api_2, options[:driver]
+    assert_equal true, options[:tolerant]
+    assert_equal "1234", options[:port]
+  end
+
+  it "is not supported in OpenAPI 3" do
+    assert_raises(Committee::OpenAPI3Unsupported) do
+      @bin.get_app(open_api_3_schema, {})
+    end
+  end
+end
+
+describe Committee::Bin::CommitteeStub, "app" do
+  include Rack::Test::Methods
+
+  before do
+    @bin = Committee::Bin::CommitteeStub.new
+  end
+
+  def app
+    options = {}
+    # TODO: delete when 5.0.0 released because default value changed
+    options[:parse_response_by_content_type] = false
+
+    @bin.get_app(hyper_schema, options)
+  end
+
+  it "defaults to a 404" do
+    get "/foos"
+    assert_equal 404, last_response.status
+  end
+end

data/test/bin_test.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+#
+# The purpose of this sets of tests is just to include our Ruby executables
+# where possible so that we can get very basic sanity checks on their syntax
+# (which is something that of course Ruby can't do by default).
+#
+# We can do this without actually executing them because they're gated by `if
+# $0 == __FILE__` statements.
+#
+
+describe "executables in bin/" do
+  before do
+    @bin_dir = File.expand_path("../../bin", __FILE__)
+    ARGV[0] = '-h'
+  end
+
+  it "has roughly valid Ruby structure for committee-stub" do
+    assert_output(%r{Usage: rackup \[options\] \[JSON Schema file\]}) do
+      load File.join(@bin_dir, "committee-stub")
+    end
+  end
+end

data/test/committee_test.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+describe Committee do
+  it "debugs based off env" do
+    old = ENV["COMMITTEE_DEBUG"]
+    begin
+      ENV["COMMITTEE_DEBUG"] = nil
+      refute Committee.debug?
+      ENV["COMMITTEE_DEBUG"] = "true"
+      assert Committee.debug?
+    ensure
+      ENV["COMMITTEE_DEBUG"] = old
+    end
+  end
+
+  it "logs debug messages to stderr" do
+    old_stderr = $stderr
+    $stderr = StringIO.new
+    begin
+      stub(Committee).debug? { false }
+      Committee.log_debug "blah"
+      assert_equal "", $stderr.string
+
+      stub(Committee).debug? { true }
+      Committee.log_debug "blah"
+      assert_equal "blah\n", $stderr.string
+    ensure
+      $stderr = old_stderr
+    end
+  end
+
+  it "warns need_good_option" do
+    old_stderr = $stderr
+    $stderr = StringIO.new
+    begin
+      Committee.need_good_option "show"
+      assert_equal "show\n", $stderr.string
+    ensure
+      $stderr = old_stderr
+    end
+  end
+
+  it "warns on deprecated unless $VERBOSE is nil" do
+    old_stderr = $stderr
+    old_verbose = $VERBOSE
+    $stderr = StringIO.new
+    begin
+      $VERBOSE = nil
+      Committee.warn_deprecated_until_6 true, "blah"
+      assert_equal "", $stderr.string
+
+      $VERBOSE = true
+      Committee.warn_deprecated_until_6 true, "blah"
+      assert_equal "[DEPRECATION] blah\n", $stderr.string
+    ensure
+      $stderr = old_stderr
+      $VERBOSE = old_verbose
+    end
+  end
+
+
+  it "doesn't warns on deprecated if cond is false" do
+    old_stderr = $stderr
+    old_verbose = $VERBOSE
+    $stderr = StringIO.new
+    begin
+      $VERBOSE = true
+      Committee.warn_deprecated_until_6 false, "blah"
+      assert_equal "", $stderr.string
+    ensure
+      $stderr = old_stderr
+      $VERBOSE = old_verbose
+    end
+  end
+end

data/test/drivers/hyper_schema/driver_test.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+describe Committee::Drivers::HyperSchema::Driver do
+  before do
+    @driver = Committee::Drivers::HyperSchema::Driver.new
+  end
+
+  it "has a name" do
+    assert_equal :hyper_schema, @driver.name
+  end
+
+  it "has a schema class" do
+    assert_equal Committee::Drivers::HyperSchema::Schema, @driver.schema_class
+  end
+
+  it "parses a hyper-schema and builds routes" do
+    schema = @driver.parse(hyper_schema_data)
+    assert_kind_of Committee::Drivers::HyperSchema::Schema, schema
+    assert_equal @driver, schema.driver
+
+    assert_kind_of Hash, schema.routes
+    refute schema.routes.empty?
+    assert(schema.routes.keys.all? { |m|
+      ["DELETE", "GET", "PATCH", "POST", "PUT"].include?(m)
+    })
+
+    schema.routes.each do |(_, method_routes)|
+      method_routes.each do |regex, link|
+        assert_kind_of Regexp, regex
+        assert_kind_of Committee::Drivers::HyperSchema::Link, link
+      end
+    end
+  end
+
+  it "defaults to not coercing form parameters" do
+    assert_equal false, @driver.default_coerce_form_params
+  end
+
+  it "defaults to no path parameters" do
+    assert_equal false, @driver.default_path_params
+  end
+
+  it "defaults to no query parameters" do
+    assert_equal false, @driver.default_query_params
+  end
+end
+