committee 1.15.0 → 5.0.0

data/lib/committee/query_params_coercer.rb

@@ -1,45 +0,0 @@
-# Attempts to coerce params given in the query hash (which are all strings) into
-# the types specified by the schema.
-# Currently supported types: null, integer, number and boolean.
-# +call+ returns a hash of all params which could be coerced - coercion errors
-# are simply ignored and expected to be handled later by schema validation.
-module Committee
-  class QueryParamsCoercer
-    def initialize(query_hash, schema)
-      @query_hash = query_hash
-      @schema = schema
-    end
-
-    def call
-      coerced = {}
-      @schema.properties.each do |k, s|
-        original_val = @query_hash[k]
-        unless original_val.nil?
-          s.type.each do |to_type|
-            case to_type
-            when "null"
-              coerced[k] = nil if original_val.empty?
-            when "integer"
-              begin
-                coerced[k] = Integer(original_val)
-              rescue ArgumentError => e
-                raise e unless e.message =~ /invalid value for Integer/
-              end
-            when "number"
-              begin
-                coerced[k] = Float(original_val)
-              rescue ArgumentError => e
-                raise e unless e.message =~ /invalid value for Float/
-              end
-            when "boolean"
-              coerced[k] = true if original_val == "true"
-              coerced[k] = false if original_val == "false"
-            end
-            break if coerced.key?(k)
-          end
-        end
-      end
-      coerced
-    end
-  end
-end

data/lib/committee/request_validator.rb

@@ -1,44 +0,0 @@
-module Committee
-  class RequestValidator
-    def initialize(link, options = {})
-      @link = link
-      @check_content_type = options.fetch(:check_content_type, true)
-    end
-
-    def call(request, data)
-      check_content_type!(request, data) if @check_content_type
-      if @link.schema
-        valid, errors = @link.schema.validate(data)
-        if !valid
-          errors = JsonSchema::SchemaError.aggregate(errors).join("\n")
-          raise InvalidRequest, "Invalid request.\n\n#{errors}"
-        end
-      end
-    end
-
-    private
-
-    def request_media_type(request)
-      request.content_type.to_s.split(";").first.to_s
-    end
-
-    def check_content_type!(request, data)
-      content_type = request_media_type(request)
-      if content_type && !empty_request?(request)
-        unless Rack::Mime.match?(content_type, @link.enc_type)
-          raise Committee::InvalidRequest,
-            %{"Content-Type" request header must be set to "#{@link.enc_type}".}
-        end
-      end
-    end
-
-    def empty_request?(request)
-      # small optimization: assume GET and DELETE don't have bodies
-      return true if request.get? || request.delete? || !request.body
-
-      data = request.body.read
-      request.body.rewind
-      data.empty?
-    end
-  end
-end

data/lib/committee/response_generator.rb

@@ -1,35 +0,0 @@
-module Committee
-  class ResponseGenerator
-    def call(link)
-      data = generate_properties(link.target_schema || link.parent)
-
-      # list is a special case; wrap data in an array
-      data = [data] if link.rel == "instances"
-
-      data
-    end
-
-    private
-
-    def generate_properties(schema)
-      # special example attribute was included; use its value
-      if !schema.data["example"].nil?
-        schema.data["example"]
-      # null is allowed; use that
-      elsif schema.type.include?("null")
-        nil
-      elsif schema.type.include?("array") && !schema.items.nil?
-        [generate_properties(schema.items)]
-      elsif !schema.properties.empty?
-        data = {}
-        schema.properties.map do |key, value|
-          data[key] = generate_properties(value)
-        end
-        data
-      else
-        raise(%{At "#{schema.pointer}": no "example" attribute and "null" } +
-          %{is not allowed; don't know how to generate property.})
-      end
-    end
-  end
-end

data/lib/committee/response_validator.rb

@@ -1,59 +0,0 @@
-module Committee
-  class ResponseValidator
-    attr_reader :validate_errors
-
-    def initialize(link, options = {})
-      @link = link
-      @validate_errors = options[:validate_errors]
-
-      # we should eventually move off of validating against parent schema too
-      # ... this is a Herokuism and not in the specification
-      schema = link.target_schema || link.parent
-      @validator = JsonSchema::Validator.new(schema)
-    end
-
-    def self.validate?(status, options = {})
-      validate_errors = options[:validate_errors]
-
-      status != 204 and validate_errors || (200...300).include?(status)
-    end
-
-    def call(status, headers, data)
-      unless status == 204 # 204 No Content
-        response = Rack::Response.new(data, status, headers)
-        check_content_type!(response)
-      end
-
-      if @link.rel == "instances" && !@link.target_schema
-        if !data.is_a?(Array)
-          raise InvalidResponse, "List endpoints must return an array of objects."
-        end
-
-        # only consider the first object during the validation from here on
-        # (but only in cases where `targetSchema` is not set)
-        data = data[0]
-
-        # if the array was empty, allow it through
-        return if data == nil
-      end
-
-      if self.class.validate?(status, validate_errors: validate_errors) && !@validator.validate(data)
-        errors = JsonSchema::SchemaError.aggregate(@validator.errors).join("\n")
-        raise InvalidResponse, "Invalid response.\n\n#{errors}"
-      end
-    end
-
-    private
-
-    def response_media_type(response)
-      response.content_type.to_s.split(";").first.to_s
-    end
-
-    def check_content_type!(response)
-      unless Rack::Mime.match?(response_media_type(response), @link.media_type)
-        raise Committee::InvalidResponse,
-          %{"Content-Type" response header must be set to "#{@link.media_type}".}
-      end
-    end
-  end
-end

data/lib/committee/router.rb

@@ -1,62 +0,0 @@
-module Committee
-  class Router
-    def initialize(schema, options = {})
-      @routes = build_routes(schema)
-      @prefix = options[:prefix]
-      @prefix_regexp = /\A#{Regexp.escape(@prefix)}/.freeze if @prefix
-    end
-
-    def includes?(path)
-      !@prefix || path =~ @prefix_regexp
-    end
-
-    def includes_request?(request)
-      includes?(request.path)
-    end
-
-    def find_link(method, path)
-      path = path.gsub(@prefix_regexp, "") if @prefix
-      if method_routes = @routes[method]
-        method_routes.each do |pattern, link|
-          if path =~ pattern
-            return link
-          end
-        end
-      end
-      nil
-    end
-
-    def find_request_link(request)
-      find_link(request.request_method, request.path_info)
-    end
-
-    private
-
-    def build_routes(schema)
-      routes = {}
-
-      schema.links.each do |link|
-        method, href = parse_link(link)
-        next unless method
-        routes[method] ||= []
-        routes[method] << [%r{^#{href}$}, link]
-      end
-
-      # recursively iterate through all `properties` subschemas to build a
-      # complete routing table
-      schema.properties.each do |_, subschema|
-        routes.merge!(build_routes(subschema)) { |_, r1, r2| r1 + r2 }
-      end
-
-      routes
-    end
-
-    def parse_link(link)
-      return nil, nil if !link.method || !link.href
-      method = link.method.to_s.upcase
-      # /apps/{id} --> /apps/([^/]+)
-      href = link.href.gsub(/\{(.*?)\}/, "[^/]+")
-      [method, href]
-    end
-  end
-end

data/test/query_params_coercer_test.rb

@@ -1,70 +0,0 @@
-require_relative "test_helper"
-
-describe Committee::QueryParamsCoercer do
-  before do
-    @schema =
-      JsonSchema.parse!(JSON.parse(File.read("./test/data/schema.json")))
-    @schema.expand_references!
-    # GET /search/apps
-    @link = @link = @schema.properties["app"].links[5]
-  end
-
-  it "doesn't coerce params not in the schema" do
-    data = {"owner" => "admin"}
-    assert_equal({}, call(data))
-  end
-
-  it "skips values for string param" do
-    data = {"name" => "foo"}
-    assert_equal({}, call(data))
-  end
-
-  it "coerces valid values for boolean param" do
-    data = {"deleted" => "true"}
-    assert_equal({"deleted" => true}, call(data))
-    data = {"deleted" => "false"}
-    assert_equal({"deleted" => false}, call(data))
-  end
-
-  it "skips invalid values for boolean param" do
-    data = {"deleted" => "foo"}
-    assert_equal({}, call(data))
-  end
-
-  it "coerces valid values for integer param" do
-    data = {"per_page" => "3"}
-    assert_equal({"per_page" => 3}, call(data))
-  end
-
-  it "skips invalid values for integer param" do
-    data = {"per_page" => "3.5"}
-    assert_equal({}, call(data))
-    data = {"per_page" => "false"}
-    assert_equal({}, call(data))
-    data = {"per_page" => ""}
-    assert_equal({}, call(data))
-  end
-
-  it "coerces valid values for number param" do
-    data = {"threshold" => "3"}
-    assert_equal({"threshold" => 3.0}, call(data))
-    data = {"threshold" => "3.5"}
-    assert_equal({"threshold" => 3.5}, call(data))
-  end
-
-  it "skips invalid values for number param" do
-    data = {"threshold" => "false"}
-    assert_equal({}, call(data))
-  end
-
-  it "coerces valid values for null param" do
-    data = {"threshold" => ""}
-    assert_equal({"threshold" => nil}, call(data))
-  end
-
-  private
-
-  def call(data)
-    Committee::QueryParamsCoercer.new(data, @link.schema).call
-  end
-end

data/test/request_validator_test.rb

@@ -1,103 +0,0 @@
-require_relative "test_helper"
-
-require "stringio"
-
-describe Committee::RequestValidator do
-  before do
-    @schema =
-      JsonSchema.parse!(JSON.parse(File.read("./test/data/schema.json")))
-    @schema.expand_references!
-    # POST /apps/:id
-    @link = @link = @schema.properties["app"].links[0]
-    @request = Rack::Request.new({
-      "CONTENT_TYPE"   => "application/json",
-      "rack.input"     => StringIO.new("{}"),
-      "REQUEST_METHOD" => "POST"
-    })
-  end
-
-  it "passes through a valid request with Content-Type options" do
-    @headers = { "Content-Type" => "application/json; charset=utf-8" }
-    call({})
-  end
-
-  it "passes through a valid request" do
-    data = {
-      "name" => "heroku-api",
-    }
-    call(data)
-  end
-
-  it "passes through a valid request with Content-Type options" do
-    @request =
-      Rack::Request.new({
-      "CONTENT_TYPE" => "application/json; charset=utf-8",
-      "rack.input"   => StringIO.new("{}"),
-    })
-    data = {
-      "name" => "heroku-api",
-    }
-    call(data)
-  end
-
-  it "detects an invalid request Content-Type" do
-    e = assert_raises(Committee::InvalidRequest) {
-      @request =
-        Rack::Request.new({
-          "CONTENT_TYPE" => "application/x-www-form-urlencoded",
-          "rack.input"   => StringIO.new("{}"),
-        })
-      call({})
-    }
-    message =
-      %{"Content-Type" request header must be set to "application/json".}
-    assert_equal message, e.message
-  end
-
-  it "allows skipping content_type check" do
-    @request =
-      Rack::Request.new({
-        "CONTENT_TYPE" => "application/x-www-form-urlencoded",
-        "rack.input"   => StringIO.new("{}"),
-      })
-    call({}, check_content_type: false)
-  end
-
-  it "detects an missing parameter in GET requests" do
-    # GET /apps/search?query=...
-    @link = @link = @schema.properties["app"].links[5]
-    @request = Rack::Request.new({})
-    e = assert_raises(Committee::InvalidRequest) do
-      call({})
-    end
-    message =
-      %{Invalid request.\n\n#: failed schema #/definitions/app/links/5/schema: "query" wasn't supplied.}
-    assert_equal message, e.message
-  end
-
-  it "allows an invalid Content-Type with an empty body" do
-    @request =
-      Rack::Request.new({
-        "CONTENT_TYPE" => "application/x-www-form-urlencoded",
-        "rack.input"   => StringIO.new(""),
-      })
-    call({})
-  end
-
-  it "detects a parameter of the wrong pattern" do
-    data = {
-      "name" => "%@!"
-    }
-    e = assert_raises(Committee::InvalidRequest) do
-      call(data)
-    end
-    message = %{Invalid request.\n\n#/name: failed schema #/definitions/app/links/0/schema/properties/name: %@! does not match /^[a-z][a-z0-9-]{3,30}$/.}
-    assert_equal message, e.message
-  end
-
-  private
-
-  def call(data, options={})
-    Committee::RequestValidator.new(@link, options).call(@request, data)
-  end
-end

data/test/response_generator_test.rb

@@ -1,61 +0,0 @@
-require_relative "test_helper"
-
-describe Committee::ResponseGenerator do
-  before do
-    @schema =
-      JsonSchema.parse!(JSON.parse(File.read("./test/data/schema.json")))
-    @schema.expand_references!
-    # GET /apps/:id
-    @get_link = @link = @schema.properties["app"].links[2]
-    # GET /apps
-    @list_link = @schema.properties["app"].links[3]
-  end
-
-  it "generates string properties" do
-    data = call
-    assert data["name"].is_a?(String)
-  end
-
-  it "generates non-string properties" do
-    data = call
-    assert_includes [FalseClass, TrueClass], data["maintenance"].class
-  end
-
-  it "wraps list data in an array" do
-    @link = @list_link
-    data = call
-    assert data.is_a?(Array)
-  end
-
-  it "wraps list data in an array" do
-    @link = @list_link
-
-    @link.rel = nil
-
-    data = call
-    assert data.is_a?(Array)
-  end
-
-  it "errors with no known route for generation" do
-    @link = @get_link
-
-    # tweak the schema so that it can't be generated
-    property = @schema.properties["app"].properties["maintenance"]
-    property.data["example"] = nil
-    property.type = []
-
-    e = assert_raises(RuntimeError) do
-      call
-    end
-
-    expected = <<-eos.gsub(/\n +/, "").strip
-      At "#/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
-  end
-
-  def call
-    Committee::ResponseGenerator.new.call(@link)
-  end
-end

data/test/router_test.rb

@@ -1,38 +0,0 @@
-require_relative "test_helper"
-
-describe Committee::Router do
-  it "builds routes without parameters" do
-    refute_nil router.find_link("GET", "/apps")
-  end
-
-  it "builds routes with parameters" do
-    refute_nil router.find_link("GET", "/apps/123")
-  end
-
-  it "doesn't match anything on a /" do
-    assert_nil router.find_link("GET", "/")
-  end
-
-  it "takes a prefix" do
-    # this is a sociopathic example
-    assert router(prefix: "/kpi").find_link("GET", "/kpi/apps/123")
-  end
-
-  it "includes all paths without a prefix" do
-    assert router.includes?("/")
-    assert router.includes?("/apps")
-  end
-
-  it "only includes the prefix path with a prefix" do
-    refute router(prefix: "/kpi").includes?("/")
-    assert router(prefix: "/kpi").includes?("/kpi")
-    assert router(prefix: "/kpi").includes?("/kpi/apps")
-  end
-
-  def router(options = {})
-    data = JSON.parse(File.read("./test/data/schema.json"))
-    schema = JsonSchema.parse!(data)
-    schema.expand_references!
-    Committee::Router.new(schema, options)
-  end
-end