committee 0.4.14 → 1.0.0

data/lib/committee/validation.rb

@@ -1,83 +0,0 @@
-module Committee
-  module Validation
-    def check_format!(format, value, identifier)
-      return if !format
-      return if check_format(format, value, identifier)
-
-      description = case identifier
-      when String
-        %{Invalid format for key "#{identifier}": expected "#{value}" to be "#{format}".}
-      when Array
-        %{Invalid format at "#{identifier.join(":")}": expected "#{value}" to be "#{format}".}
-      end
-
-      raise InvalidFormat, description
-    end
-
-    def check_format(format, value, identifier)
-      case format
-      when "date-time"
-        value =~ /^(\d{4})-(\d{2})-(\d{2})T(\d{2})\:(\d{2})\:(\d{2})(\.\d{1,})?(Z|[+-](\d{2})\:(\d{2}))$/
-      when "email"
-        value =~ /^[a-z0-9._%+-]+@[a-z0-9.-]+\.[a-z]{2,4}$/i
-      when "uuid"
-        value =~ /^[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}$/
-      else
-        true
-      end
-    end
-
-    def check_type!(allowed_types, value, identifier)
-      return if check_type(allowed_types, value, identifier)
-
-      description = case identifier
-      when String
-        %{Invalid type for key "#{identifier}": expected #{value.inspect} to be #{allowed_types}.}
-      when Array
-        %{Invalid type at "#{identifier.join(":")}": expected #{value.inspect} to be #{allowed_types}.}
-      end
-
-      raise InvalidType, description
-    end
-
-    def check_type(allowed_types, value, identifier)
-      types = case value
-      when NilClass
-        ["null"]
-      when TrueClass, FalseClass
-        ["boolean"]
-      when Bignum, Fixnum
-        ["integer", "number"]
-      when Float
-        ["number"]
-      when Hash
-        ["object"]
-      when String
-        ["string"]
-      when Array
-        ["array"]
-      else
-        ["unknown"]
-      end
-
-      !(allowed_types & types).empty?
-    end
-
-    def check_pattern!(pattern, value, identifier)
-      return if check_pattern(pattern, value, identifier)
-
-      description = case identifier
-      when String
-        %{Invalid pattern for key "#{identifier}": expected #{value} to match "#{pattern}".}
-      when Array
-          %{Invalid pattern at "#{identifier.join(":")}": expected #{value} to match "#{pattern}".}
-      end
-
-      raise InvalidPattern, description
-    end
-
-    def check_pattern(pattern, value, identifier)
-      !pattern || value =~ Regexp.new(pattern)
-    end
-  end
-end

data/test/param_validator_test.rb

@@ -1,127 +0,0 @@
-require_relative "test_helper"
-
-describe Committee::ParamValidator do
-  before do
-    @schema = Committee::Schema.new(File.read("./test/data/schema.json"))
-    # POST /account/app-transfers
-    @link_schema = @schema["app-transfer"]["links"][0]
-  end
-
-  it "passes through a valid request" do
-    params = {
-      "app" => "heroku-api",
-      "recipient" => "owner@heroku.com",
-    }
-    validate(params, @schema, @link_schema)
-  end
-
-  it "detects a missing parameter" do
-    e = assert_raises(Committee::InvalidParams) do
-      validate({}, @schema, @link_schema)
-    end
-    message = "Require params: app, recipient."
-    assert_equal message, e.message
-  end
-
-  it "doesn't error on an extraneous parameter with allow_extra" do
-    params = {
-      "app" => "heroku-api",
-      "cloud" => "production",
-      "recipient" => "owner@heroku.com",
-    }
-    validate(params, @schema, @link_schema, allow_extra: true)
-  end
-
-  it "detects a parameter of the wrong type" do
-    params = {
-      "app" => "heroku-api",
-      "recipient" => 123,
-    }
-    e = assert_raises(Committee::InvalidType) do
-      validate(params, @schema, @link_schema)
-    end
-    message = %{Invalid type for key "recipient": expected 123 to be ["string"].}
-    assert_equal message, e.message
-  end
-
-  it "detects a parameter of the wrong format" do
-    params = {
-      "app" => "heroku-api",
-      "recipient" => "not-email",
-    }
-    e = assert_raises(Committee::InvalidFormat) do
-      validate(params, @schema, @link_schema)
-    end
-    message = %{Invalid format for key "recipient": expected "not-email" to be "email".}
-    assert_equal message, e.message
-  end
-
-  it "detects a parameter of the wrong pattern" do
-    params = {
-      "name" => "%@!"
-    }
-    link_schema = @schema["app"]["links"][0]
-    e = assert_raises(Committee::InvalidPattern) do
-      validate(params, @schema, link_schema)
-    end
-    message = %{Invalid pattern for key "name": expected %@! to match "(?-mix:^[a-z][a-z0-9-]{3,30}$)".}
-    assert_equal message, e.message
-  end
-
-  describe "complex arrays" do
-    it "passes an array parameter" do
-      params = {
-        "updates" => [
-          { "name" => "bamboo", "state" => "private" },
-          { "name" => "cedar", "state" => "public" },
-        ]
-      }
-      link_schema = @schema["stack"]["links"][2]
-      validate(params, @schema, link_schema)
-    end
-
-    it "detects an array item with a parameter of the wrong type" do
-      params = {
-        "updates" => [
-          { "name" => "bamboo", "state" => 123 },
-        ]
-      }
-      link_schema = @schema["stack"]["links"][2]
-      e = assert_raises(Committee::InvalidType) do
-        validate(params, @schema, link_schema)
-      end
-      message = %{Invalid type for key "state": expected 123 to be ["string"].}
-      assert_equal message, e.message
-    end
-  end
-
-  describe "simple arrays" do
-    it "passes an array parameter" do
-      params = {
-        "password" => "1234",
-        "flags" => [ "vip", "customer" ]
-      }
-      link_schema = @schema["account"]["links"][1]
-      validate(params, @schema, link_schema)
-    end
-
-    it "detects an array item with a parameter of the wrong type" do
-      params = {
-        "password" => "1234",
-        "flags" => [ "vip", "customer", 999 ]
-      }
-      link_schema = @schema["account"]["links"][1]
-      e = assert_raises(Committee::InvalidType) do
-        validate(params, @schema, link_schema)
-      end
-      message = %{Invalid type for key "flags": expected 999 to be ["string"].}
-      assert_equal message, e.message
-    end
-  end
-
-  private
-
-  def validate(params, schema, link_schema, options = {})
-    Committee::ParamValidator.new(params, schema, link_schema, options).call
-  end
-end

data/test/performance/request_validation.rb

@@ -1,55 +0,0 @@
-require "benchmark"
-require_relative "../test_helper"
-
-describe Committee::Middleware::RequestValidation do
-  include Rack::Test::Methods
-
-  def app
-    @app
-  end
-
-  N = 50000
-
-  it "is reasonably quick" do
-    params = MultiJson.encode({
-      "app" => "heroku-api",
-      "recipient" => "owner@heroku.com",
-    })
-
-    Benchmark.benchmark(Benchmark::CAPTION, 7, Benchmark::FORMAT, ">overhead:") do |x|
-      raw = x.report("raw") do
-        N.times do
-          @app = new_rack_app(raw: true)
-          header "Content-Type", "application/json"
-          post "/account/app-transfers", params
-        end
-      end
-
-      rich = x.report("rich") do
-        N.times do
-          @app = new_rack_app
-          header "Content-Type", "application/json"
-          post "/account/app-transfers", params
-        end
-      end
-
-      puts "average overhead = #{(rich.real - raw.real) / N}"
-    end
-  end
-
-  private
-
-  def new_rack_app(options = {})
-    Rack::Builder.new {
-      unless options.delete(:raw)
-        options = {
-          schema: File.read("./test/data/schema.json")
-        }.merge(options)
-        use Committee::Middleware::RequestValidation, options
-      end
-      run lambda { |_|
-        [200, {}, []]
-      }
-    }
-  end
-end

data/test/schema_test.rb

@@ -1,36 +0,0 @@
-require_relative "test_helper"
-
-describe Committee::Schema do
-  before do
-    data = File.read("./test/data/schema.json")
-    @schema = Committee::Schema.new(data)
-  end
-
-  it "is enumerable" do
-    arr = @schema.to_a
-    assert_equal "account", arr[0][0]
-    assert arr[0][1].is_a?(Hash)
-  end
-
-  it "can lookup definitions" do
-    expected = {
-      "default"     => nil,
-      "description" => "slug size in bytes of app",
-      "example"     => 0,
-      "readOnly"    => true,
-      "type"        => ["number", "null"]
-    }
-    assert_equal expected, @schema.find("#/definitions/app/definitions/slug_size")
-  end
-
-  it "raises error on a non-existent definition" do
-    assert_raises(Committee::ReferenceNotFound) do
-      @schema.find("/schema/app#/definitions/bad_field")
-    end
-  end
-
-  it "materializes regexes" do
-    definition = @schema.find("#/definitions/app/definitions/git_url")
-    assert definition["pattern"].is_a?(Regexp)
-  end
-end