committee_firetail 5.0.0

data/test/drivers/open_api_2/parameter_schema_builder_test.rb

@@ -0,0 +1,195 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+describe Committee::Drivers::OpenAPI2::ParameterSchemaBuilder do
+  before do
+  end
+
+  it "reflects a basic type into a schema" do
+    data = {
+      "parameters" => [
+        {
+          "name" => "limit",
+          "type" => "integer",
+        }
+      ]
+    }
+    schema, schema_data = call(data)
+
+    assert_nil schema_data
+    assert_equal ["limit"], schema.properties.keys
+    assert_equal [], schema.required
+    assert_equal ["integer"], schema.properties["limit"].type
+    assert_nil schema.properties["limit"].enum
+    assert_nil schema.properties["limit"].format
+    assert_nil schema.properties["limit"].pattern
+    assert_nil schema.properties["limit"].min_length
+    assert_nil schema.properties["limit"].max_length
+    assert_nil schema.properties["limit"].min_items
+    assert_nil schema.properties["limit"].max_items
+    assert_nil schema.properties["limit"].unique_items
+    assert_nil schema.properties["limit"].min
+    assert_nil schema.properties["limit"].min_exclusive
+    assert_nil schema.properties["limit"].max
+    assert_nil schema.properties["limit"].max_exclusive
+    assert_nil schema.properties["limit"].multiple_of
+  end
+
+  it "reflects a required property into a schema" do
+    data = {
+      "parameters" => [
+        {
+          "name" => "limit",
+          "required" => true,
+        }
+      ]
+    }
+    schema, schema_data = call(data)
+
+    assert_nil schema_data
+    assert_equal ["limit"], schema.required
+  end
+
+  it "reflects an array with an items schema into a schema" do
+    data = {
+      "parameters" => [
+        {
+          "name" => "tags",
+          "type" => "array",
+          "minItems" => 1,
+          "maxItems" => 10,
+          "uniqueItems" => true,
+          "items" => {
+            "type" => "string"
+          }
+        }
+      ]
+    }
+    schema, schema_data = call(data)
+
+    assert_nil schema_data
+    assert_equal ["array"], schema.properties["tags"].type
+    assert_equal 1, schema.properties["tags"].min_items
+    assert_equal 10, schema.properties["tags"].max_items
+    assert_equal true, schema.properties["tags"].unique_items
+    assert_equal({ "type" => "string" }, schema.properties["tags"].items)
+  end
+
+  it "reflects a enum property into a schema" do
+    data = {
+      "parameters" => [
+        {
+          "name" => "type",
+          "type" => "string",
+          "enum" => ["hoge", "fuga"]
+        }
+      ]
+    }
+    schema, schema_data = call(data)
+
+    assert_nil schema_data
+    assert_equal ["hoge", "fuga"], schema.properties["type"].enum
+  end
+
+  it "reflects string properties into a schema" do
+    data = {
+      "parameters" => [
+        {
+          "name" => "password",
+          "type" => "string",
+          "format" => "password",
+          "pattern" => "[a-zA-Z0-9]+",
+          "minLength" => 6,
+          "maxLength" => 30
+        }
+      ]
+    }
+    schema, schema_data = call(data)
+
+    assert_nil schema_data
+    assert_equal "password", schema.properties["password"].format
+    assert_equal Regexp.new("[a-zA-Z0-9]+"), schema.properties["password"].pattern
+    assert_equal 6, schema.properties["password"].min_length
+    assert_equal 30, schema.properties["password"].max_length
+  end
+
+  it "reflects number properties into a schema" do
+    data = {
+      "parameters" => [
+        {
+          "name" => "limit",
+          "type" => "integer",
+          "minimum" => 20,
+          "exclusiveMinimum" => true,
+          "maximum" => 100,
+          "exclusiveMaximum" => false,
+          "multipleOf" => 10
+        }
+      ]
+    }
+    schema, schema_data = call(data)
+
+    assert_nil schema_data
+    assert_equal 20, schema.properties["limit"].min
+    assert_equal true, schema.properties["limit"].min_exclusive
+    assert_equal 100, schema.properties["limit"].max
+    assert_equal false, schema.properties["limit"].max_exclusive
+    assert_equal 10, schema.properties["limit"].multiple_of
+  end
+
+  it "returns schema data for a body parameter" do
+    data = {
+      "parameters" => [
+        {
+          "name" => "payload",
+          "in" => "body",
+          "schema" => {
+            "$ref" => "#/definitions/foo",
+          }
+        }
+      ]
+    }
+    schema, schema_data = call(data)
+
+    assert_nil schema
+    assert_equal({ "$ref" => "#/definitions/foo" }, schema_data)
+  end
+
+  it "requires that certain fields are present" do
+    data = {
+      "parameters" => [
+        {
+        }
+      ]
+    }
+    e = assert_raises ArgumentError do
+      call(data)
+    end
+    assert_equal "Committee: no name section in link data.", e.message
+  end
+
+  it "requires that body parameters not be mixed with form parameters" do
+    data = {
+      "parameters" => [
+        {
+          "name" => "payload",
+          "in" => "body",
+        },
+        {
+          "name" => "limit",
+          "in" => "form",
+        },
+      ]
+    }
+    e = assert_raises ArgumentError do
+      call(data)
+    end
+    assert_equal "Committee: can't mix body parameter with form parameters.",
+      e.message
+  end
+
+  def call(data)
+    Committee::Drivers::OpenAPI2::ParameterSchemaBuilder.new(data).call
+  end
+end

data/test/drivers/open_api_3/driver_test.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+describe Committee::Drivers::OpenAPI3::Driver do
+  before do
+    @driver = Committee::Drivers::OpenAPI3::Driver.new
+  end
+
+  it "has a name" do
+    assert_equal :open_api_3, @driver.name
+  end
+
+  it "has a schema class" do
+    assert_equal Committee::Drivers::OpenAPI3::Schema, @driver.schema_class
+  end
+
+  it "override methods" do
+    parser = OpenAPIParser.parse(open_api_3_data, strict_reference_validation: false)
+    schema = @driver.parse(parser)
+
+    assert_kind_of Committee::Drivers::OpenAPI3::Schema, schema
+    assert_kind_of OpenAPIParser::Schemas::OpenAPI, schema.open_api
+    assert_equal @driver, schema.driver
+  end
+
+  it "defaults to coercing form parameters" do
+    assert_equal true, @driver.default_coerce_form_params
+  end
+
+  it "defaults to path parameters" do
+    assert_equal true, @driver.default_path_params
+  end
+
+  it "defaults to query parameters" do
+    assert_equal true, @driver.default_query_params
+  end
+
+  describe "Schema" do
+    describe "#operation_object" do
+      describe "path template" do
+        it "gets a normal path" do
+          obj = open_api_3_schema.operation_object("/path_template_test/no_template", "get")
+          assert_equal "/path_template_test/no_template", obj.original_path
+        end
+
+        it "gets a template path" do
+          obj = open_api_3_schema.operation_object("/path_template_test/test", "get")
+          assert_equal "/path_template_test/{template_name}", obj.original_path
+        end
+
+        it "gets a nested template path" do
+          obj = open_api_3_schema.operation_object("/path_template_test/abc/nested", "get")
+          assert_equal "/path_template_test/{template_name}/nested", obj.original_path
+          assert_equal({"template_name"=>"abc"}, obj.path_params)
+        end
+
+        it "gets a double nested template path" do
+          obj = open_api_3_schema.operation_object("/path_template_test/test/nested/abc", "get")
+          assert_equal "/path_template_test/{template_name}/nested/{nested_parameter}", obj.original_path
+          assert_equal({"template_name"=>"test", "nested_parameter" => "abc"}, obj.path_params)
+        end
+
+        it "gets a twice nested template path" do
+          obj = open_api_3_schema.operation_object("/path_template_test/test/abc", "get")
+          assert_equal "/path_template_test/{template_name}/{nested_parameter}", obj.original_path
+          assert_equal({"template_name"=>"test", "nested_parameter" => "abc"}, obj.path_params)
+        end
+
+        it "gets a twice nested concrete path" do
+          obj = open_api_3_schema.operation_object("/path_template_test/test/abc/finish", "get")
+          assert_equal "/path_template_test/{template_name}/{nested_parameter}/finish", obj.original_path
+          assert_equal({"template_name"=>"test", "nested_parameter" => "abc"}, obj.path_params)
+        end
+
+        it "gets an ambiguous path" do
+          obj = open_api_3_schema.operation_object("/ambiguous/no_template", "get")
+          assert_equal "/{ambiguous}/no_template", obj.original_path
+          assert_equal({"ambiguous"=>"ambiguous"}, obj.path_params)
+        end
+      end
+    end
+  end
+end

data/test/drivers_test.rb

@@ -0,0 +1,154 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+describe Committee::Drivers do
+  DRIVERS = [
+    :hyper_schema,
+    :open_api_2,
+    :open_api_3,
+  ].freeze
+
+  it "gets driver with .driver_from_name" do
+    DRIVERS.each do |name|
+      driver = Committee::Drivers.driver_from_name(name)
+      assert_kind_of Committee::Drivers::Driver, driver
+    end
+  end
+
+  it "raises an ArgumentError for an unknown driver with .driver_from_name" do
+    e = assert_raises(ArgumentError) do
+      Committee::Drivers.driver_from_name(:blueprint)
+    end
+    assert_equal %{Committee: unknown driver "blueprint".}, e.message
+  end
+
+  describe 'load_from_file(schema_path)' do
+    it 'loads 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 'loads 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
+
+    it 'loads OpenAPI 3' do
+      s = Committee::Drivers.load_from_file(open_api_3_schema_path, parser_options:{strict_reference_validation: true})
+      assert_kind_of Committee::Drivers::Schema, s
+      assert_kind_of Committee::Drivers::OpenAPI3::Schema, s
+    end
+
+    it 'load OpenAPI 3 (patch version 3.0.1)' do
+      s = Committee::Drivers.load_from_file(open_api_3_0_1_schema_path, parser_options:{strict_reference_validation: true})
+      assert_kind_of Committee::Drivers::Schema, s
+      assert_kind_of Committee::Drivers::OpenAPI3::Schema, s
+    end
+
+    it 'fails to load OpenAPI 3 with invalid reference' do
+      parser_options = { strict_reference_validation: true }
+      assert_raises(OpenAPIParser::MissingReferenceError) do
+        Committee::Drivers.load_from_file(open_api_3_invalid_reference_path, parser_options: parser_options)
+      end
+    end
+
+    # This test can be removed when the test above (raising on invalid reference) becomes default behavior?
+    it 'allows loading OpenAPI 3 with invalid reference as existing behavior' do
+      s = Committee::Drivers.load_from_file(open_api_3_invalid_reference_path, parser_options:{strict_reference_validation: false})
+      assert_kind_of Committee::Drivers::OpenAPI3::Schema, s
+    end
+
+    it 'errors on an unsupported file extension' do
+      e = assert_raises(StandardError) do
+        Committee::Drivers.load_from_file('test.xml', parser_options:{strict_reference_validation: true})
+      end
+      assert_equal "Committee only supports the following file extensions: '.json', '.yaml', '.yml'", e.message
+    end
+  end
+
+  describe 'load_from_json(schema_path)' do
+    it 'loads OpenAPI2' do
+      s = Committee::Drivers.load_from_json(open_api_2_schema_path, parser_options:{strict_reference_validation: true})
+      assert_kind_of Committee::Drivers::Schema, s
+      assert_kind_of Committee::Drivers::OpenAPI2::Schema, s
+    end
+
+    it 'loads Hyper-Schema' do
+      s = Committee::Drivers.load_from_json(hyper_schema_schema_path, parser_options:{strict_reference_validation: true})
+      assert_kind_of Committee::Drivers::Schema, s
+      assert_kind_of Committee::Drivers::HyperSchema::Schema, s
+    end
+  end
+
+  describe 'load_from_yaml(schema_path)' do
+    it 'loads OpenAPI3' do
+      s = Committee::Drivers.load_from_yaml(open_api_3_schema_path, parser_options:{strict_reference_validation: true})
+      assert_kind_of Committee::Drivers::Schema, s
+      assert_kind_of Committee::Drivers::OpenAPI3::Schema, s
+    end
+  end
+
+  describe 'load_from_data(schema_path)' do
+    it 'loads OpenAPI3' do
+      s = Committee::Drivers.load_from_data(open_api_3_data, parser_options:{strict_reference_validation: false})
+      assert_kind_of Committee::Drivers::Schema, s
+      assert_kind_of Committee::Drivers::OpenAPI3::Schema, s
+    end
+
+    it 'loads 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 'loads 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
+  DRIVER_METHODS = {
+    default_allow_get_body: [],
+    default_coerce_form_params: [],
+    default_path_params: [],
+    default_query_params: [],
+    name: [],
+    parse: [nil],
+    schema_class: [],
+  }
+
+  it "has a set of abstract methods" do
+    driver = Committee::Drivers::Driver.new
+    DRIVER_METHODS.each do |name, args|
+      e = assert_raises do
+        driver.send(name, *args)
+      end
+      assert_equal "needs implementation", e.message,
+        "Incorrect error message while sending #{name}: #{e.message}"
+    end
+  end
+end
+
+describe Committee::Drivers::Schema do
+  SCHEMA_METHODS = {
+    driver: [],
+    build_router: [validator_option: nil, prefix: nil]
+  }
+
+  it "has a set of abstract methods" do
+    schema = Committee::Drivers::Schema.new
+    SCHEMA_METHODS.each do |name, args|
+      e = assert_raises do
+        schema.send(name, *args)
+      end
+      assert_equal "needs implementation", e.message,
+        "Incorrect error message while sending #{name}: #{e.message}"
+    end
+  end
+end

data/test/middleware/base_test.rb

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+describe Committee::Middleware::Base do
+  include Rack::Test::Methods
+
+  def app
+    @app
+  end
+
+  it "accepts just a schema object" do
+    @app = new_rack_app(
+      schema: hyper_schema
+    )
+    params = {
+      "name" => "cloudnasium"
+    }
+    header "Content-Type", "application/json"
+    post "/apps", JSON.generate(params)
+    assert_equal 200, last_response.status
+  end
+
+  it "accepts just a OpenAPI3 schema object" do
+    @app = new_rack_app(schema: open_api_3_schema)
+    params = {
+        "name" => "cloudnasium"
+    }
+    header "Content-Type", "application/json"
+    post "/apps", JSON.generate(params)
+    assert_equal 200, last_response.status
+  end
+
+  it "doesn't accept a schema string" do
+    @app = new_rack_app(
+      schema: JSON.dump(hyper_schema_data)
+    )
+    params = {
+      "name" => "cloudnasium"
+    }
+    header "Content-Type", "application/json"
+
+    e = assert_raises(ArgumentError) do
+      post "/apps", JSON.generate(params)
+    end
+
+    assert_equal "Committee: schema expected to be an instance " +
+                     "of Committee::Drivers::Schema.", e.message
+  end
+
+  it "doesn't accept a schema hash" do
+    @app = new_rack_app(
+      schema: hyper_schema_data
+    )
+    params = {
+      "name" => "cloudnasium"
+    }
+    header "Content-Type", "application/json"
+
+    e = assert_raises(ArgumentError) do
+      post "/apps", JSON.generate(params)
+    end
+
+    assert_equal "Committee: schema expected to be an instance " +
+                     "of Committee::Drivers::Schema.", e.message
+  end
+
+  it "doesn't accept a JsonSchema::Schema object" do
+    @app = new_rack_app(
+      schema: JsonSchema.parse!(hyper_schema_data)
+    )
+    params = {
+      "name" => "cloudnasium"
+    }
+    header "Content-Type", "application/json"
+
+    e = assert_raises(ArgumentError) do
+      post "/apps", JSON.generate(params)
+    end
+
+    assert_equal "Committee: schema expected to be an instance " +
+                     "of Committee::Drivers::Schema.", e.message
+  end
+
+  it "doesn't accept other schema types" do
+    @app = new_rack_app(
+      schema: 7,
+    )
+    e = assert_raises(ArgumentError) do
+      post "/apps"
+    end
+    assert_equal "Committee: schema expected to be an instance of Committee::Drivers::Schema.", e.message
+  end
+
+  it "errors when no schema is specified" do
+    @app = new_rack_app
+    e = assert_raises(ArgumentError) do
+      post "/apps"
+    end
+
+    assert_equal "Committee: need option `schema` or `schema_path`", e.message
+  end
+
+  describe 'initialize option' do
+    it "accepts OpenAPI3 parser config of strict_reference_validation and raises" do
+      assert_raises(OpenAPIParser::MissingReferenceError) do
+        Committee::Middleware::Base.new(nil, schema_path: open_api_3_invalid_reference_path, strict_reference_validation: true)
+      end
+    end
+
+    it "does not raise by default even with invalid reference OpenAPI3 specification" do
+      b = Committee::Middleware::Base.new(nil, schema_path: open_api_3_invalid_reference_path, strict_reference_validation: false)
+      assert_kind_of Committee::Drivers::OpenAPI3::Schema, b.instance_variable_get(:@schema)
+    end
+  end
+
+  private
+
+  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 { |_|
+        [200, {}, []]
+      }
+    }
+  end
+end