committee 0.1

data/bin/committee-stub

@@ -0,0 +1,43 @@
+#!/usr/bin/env ruby
+
+require 'optparse'
+
+require_relative "../lib/committee"
+
+args = ARGV.dup
+options = { Port: 9292 }
+opt_parser = OptionParser.new do |opts|
+  opts.banner = "Usage: rackup [options] [JSON Schema file]"
+
+  opts.separator ""
+  opts.separator "Options:"
+
+  opts.on_tail("-h", "-?", "--help", "Show this message") {
+    puts opts
+    exit
+  }
+
+  opts.on("-p", "--port PORT", "use PORT (default: 9292)") { |port|
+    options[:Port] = port
+  }
+end
+opt_parser.parse!(args)
+
+unless args.count == 1
+  puts opt_parser.to_s
+  exit
+end
+
+schema = File.read(args[0])
+
+app = Rack::Builder.new {
+  use Committee::Middleware::RequestValidation, schema: schema
+  use Committee::Middleware::Stub, schema: schema
+  use Committee::Middleware::ResponseValidation, schema: schema
+  run lambda { |_|
+    [404, {}, ["Not found"]]
+  }
+}
+
+options[:app] = app
+Rack::Server.start(options)

data/lib/committee/errors.rb

@@ -0,0 +1,13 @@
+module Committee
+  class BadRequest < StandardError
+  end
+
+  class InvalidParams < StandardError
+  end
+
+  class InvalidResponse < StandardError
+  end
+
+  class ReferenceNotFound < StandardError
+  end
+end

data/lib/committee/middleware/base.rb

@@ -0,0 +1,19 @@
+module Committee::Middleware
+  class Base
+    def initialize(app, options={})
+      @app = app
+
+      @params_key = options[:params_key] || "committee.params"
+      data = options[:schema] || raise("need option `schema`")
+      @schema = Committee::Schema.new(data)
+      @router = Committee::Router.new(@schema)
+    end
+
+    private
+
+    def render_error(status, id, message)
+      [status, { "Content-Type" => "application/json" },
+        [MultiJson.encode(id: id, error: message)]]
+    end
+  end
+end

data/lib/committee/middleware/request_validation.rb

@@ -0,0 +1,19 @@
+module Committee::Middleware
+  class RequestValidation < Base
+    def call(env)
+      request = Rack::Request.new(env)
+      env[@params_key] = Committee::RequestUnpacker.new(request).call
+      link, _ = @router.routes_request?(request)
+      if link
+        Committee::ParamValidator.new(env[@params_key], @schema, link).call
+      end
+      @app.call(env)
+    rescue Committee::BadRequest
+      render_error(400, :bad_request, $!.message)
+    rescue Committee::InvalidParams
+      render_error(422, :invalid_params, $!.message)
+    rescue MultiJson::LoadError
+      render_error(400, :invalid_params, "Request body wasn't valid JSON.")
+    end
+  end
+end

data/lib/committee/middleware/response_validation.rb

@@ -0,0 +1,33 @@
+module Committee::Middleware
+  class ResponseValidation < Base
+    def call(env)
+      status, headers, response = @app.call(env)
+      request = Rack::Request.new(env)
+      link_schema, type_schema = @router.routes_request?(request)
+      if type_schema
+        check_content_type!(headers)
+        str = response.reduce("") { |str, s| str << s }
+        Committee::ResponseValidator.new(
+          MultiJson.decode(str),
+          @schema,
+          link_schema,
+          type_schema
+        ).call
+      end
+      [status, headers, response]
+    rescue Committee::InvalidResponse
+      render_error(500, :invalid_response, $!.message)
+    rescue MultiJson::LoadError
+      render_error(500, :invalid_response, "Response wasn't valid JSON.")
+    end
+
+    private
+
+    def check_content_type!(headers)
+      unless headers["Content-Type"] =~ %r{application/json}
+        raise Committee::InvalidResponse,
+          %{"Content-Type" response header must be set to "application/json".}
+      end
+    end
+  end
+end

data/lib/committee/middleware/stub.rb

@@ -0,0 +1,33 @@
+module Committee::Middleware
+  class Stub < Base
+    def initialize(app, options={})
+      super
+      @cache = {}
+    end
+
+    def call(env)
+      request = Rack::Request.new(env)
+      link_schema, type_schema = @router.routes_request?(request)
+      if type_schema
+        str = cache(link_schema["method"], link_schema["href"]) do
+          data = Committee::ResponseGenerator.new(@schema, type_schema, link_schema).call
+          MultiJson.encode(data, pretty: true)
+        end
+        [200, { "Content-Type" => "application/json" }, [str]]
+      else
+        @app.call(env)
+      end
+    end
+
+    private
+
+    def cache(method, href)
+      key = "#{method}+#{href}"
+      if @cache[key]
+        @cache[key]
+      else
+        @cache[key] = yield
+      end
+    end
+  end
+end

data/lib/committee/param_validator.rb

@@ -0,0 +1,132 @@
+module Committee
+  class ParamValidator
+    def initialize(params, schema, link_schema)
+      @params = params
+      @schema = schema
+      @link_schema = link_schema
+    end
+
+    def call
+      detect_missing!
+      detect_extra!
+      check_data!
+    end
+
+    private
+
+    def all_keys
+      properties = @link_schema["schema"] && @link_schema["schema"]["properties"]
+      properties && properties.keys || []
+    end
+
+    def check_data!
+      return if !@link_schema["schema"] || !@link_schema["schema"]["properties"]
+
+      @link_schema["schema"]["properties"].each do |key, value|
+        # don't try to check this unless it was actually specificed
+        next unless @params.key?(key)
+
+        match = false
+        definitions = find_definitions(value["$ref"])
+
+        # try to match data against any possible definition
+        definitions.each do |definition|
+          if check_type(definition["type"], @params[key], key) &&
+            check_format(definition["format"], @params[key], key) &&
+            check_pattern(definition["pattern"], @params[key], key)
+            match = true
+            next
+          end
+        end
+
+        # if nothing was matched, throw error according to first definition
+        if !match && definition = definitions.first
+          check_type!(definition["type"], @params[key], key)
+          check_format!(definition["format"], @params[key], key)
+          check_pattern!(definition["pattern"], @params[key], key)
+        end
+      end
+    end
+
+    def check_format(format, value, key)
+      case format
+      when "date-time"
+        value =~ /^(\d{4})-(\d{2})-(\d{2})T(\d{2})\:(\d{2})\:(\d{2})(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_format!(format, value, key)
+      unless check_format(format, value, key)
+        raise InvalidParams,
+          %{Invalid format for key "#{key}": expected "#{value}" to be "#{format}".}
+      end
+    end
+
+    def check_pattern(pattern, value, key)
+      !pattern || value =~ pattern
+    end
+
+    def check_pattern!(pattern, value, key)
+      unless check_pattern(pattern, value, key)
+        raise InvalidParams,
+          %{Invalid pattern for key "#{key}": expected #{value} to match "#{pattern}".}
+      end
+    end
+
+    def check_type(types, value, key)
+      type = case value
+      when NilClass
+        "null"
+      when TrueClass, FalseClass
+        "boolean"
+      when Fixnum
+        "integer"
+      when String
+        "string"
+      else
+        "unknown"
+      end
+      types.include?(type)
+    end
+
+    def check_type!(types, value, key)
+      unless check_type(types, value, key)
+        raise InvalidParams,
+          %{Invalid type for key "#{key}": expected #{value} to be #{types}.}
+      end
+    end
+
+    def detect_extra!
+      extra = @params.keys - all_keys
+      if extra.count > 0
+        raise InvalidParams.new("Unknown params: #{extra.join(', ')}.")
+      end
+    end
+
+    def detect_missing!
+      missing = required_keys - @params.keys
+      if missing.count > 0
+        raise InvalidParams.new("Require params: #{missing.join(', ')}.")
+      end
+    end
+
+    def find_definitions(ref)
+      definition = @schema.find(ref)
+      if definition["anyOf"]
+        definition["anyOf"].map { |r| @schema.find(r["$ref"]) }
+      else
+        [definition]
+      end
+    end
+
+    def required_keys
+      (@link_schema["schema"] && @link_schema["schema"]["required"]) || []
+    end
+  end
+end

data/lib/committee/request_unpacker.rb

@@ -0,0 +1,59 @@
+module Committee
+  class RequestUnpacker
+    def initialize(request)
+      @request = request
+    end
+
+    def call
+      if !@request.content_type || @request.content_type =~ %r{application/json}
+        # if Content-Type is empty or JSON, and there was a request body, try
+        # to interpret it as JSON
+        if (body = @request.body.read).length != 0
+          @request.body.rewind
+          hash = MultiJson.decode(body)
+          # We want a hash specifically. '42', 42, and [42] will all be
+          # decoded properly, but we can't use them here.
+          if !hash.is_a?(Hash)
+            raise BadRequest,
+              "Invalid JSON input. Require object with parameters as keys."
+          end
+          indifferent_params(hash)
+        # if request body is empty, we just have empty params
+        else
+          {}
+        end
+      elsif @request.content_type == "application/x-www-form-urlencoded"
+        # Actually, POST means anything in the request body, could be from
+        # PUT or PATCH too. Silly Rack.
+        indifferent_params(@request.POST)
+      else
+        raise BadRequest, "Unsupported Content-Type: #{@request.content_type}."
+      end
+    end
+
+    private
+
+    # Creates a Hash with indifferent access.
+    #
+    # (Copied from Sinatra)
+    def indifferent_hash
+      Hash.new { |hash,key| hash[key.to_s] if Symbol === key }
+    end
+
+    # Enable string or symbol key access to the nested params hash.
+    #
+    # (Copied from Sinatra)
+    def indifferent_params(object)
+      case object
+      when Hash
+        new_hash = indifferent_hash
+        object.each { |key, value| new_hash[key] = indifferent_params(value) }
+        new_hash
+      when Array
+        object.map { |item| indifferent_params(item) }
+      else
+        object
+      end
+    end
+  end
+end

data/lib/committee/response_generator.rb

@@ -0,0 +1,30 @@
+module Committee
+  class ResponseGenerator
+    def initialize(schema, type_schema, link_schema)
+      @schema = schema
+      @type_schema = type_schema
+      @link_schema = link_schema
+    end
+
+    def call
+      generate_properties(@type_schema)
+    end
+
+    private
+
+    def generate_properties(schema)
+      data = {}
+      schema["properties"].each do |name, value|
+        data[name] = if value["properties"]
+          generate_properties(value)
+        else
+          definition = @schema.find(value["$ref"])
+          definition["example"]
+        end
+      end
+      # list is a special case; wrap data in an array
+      data = [data] if @link_schema["title"] == "List"
+      data
+    end
+  end
+end

data/lib/committee/response_validator.rb

@@ -0,0 +1,127 @@
+module Committee
+  class ResponseValidator
+    def initialize(data, schema, link_schema, type_schema)
+      @data = data
+      @schema = schema
+      @link_schema = link_schema
+      @type_schema = type_schema
+    end
+
+    def call
+      data = if @link_schema["title"] == "List"
+        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
+        @data[0]
+      else
+        @data
+      end
+
+      data_keys = build_data_keys(data)
+      schema_keys = build_schema_keys
+
+      extra = data_keys - schema_keys
+      missing = schema_keys - data_keys
+
+      errors = []
+
+      if extra.count > 0
+        errors << "Extra keys in response: #{extra.join(', ')}."
+      end
+
+      if missing.count > 0
+        errors << "Missing keys in response: #{missing.join(', ')}."
+      end
+
+      unless errors.empty?
+        raise InvalidResponse, ["`#{@link_schema['method']} #{@link_schema['href']}` deviates from schema.", *errors].join(' ')
+      end
+
+      check_data!(@type_schema, data, [])
+    end
+
+    def check_data!(schema, data, path)
+      schema["properties"].each do |key, value|
+        if value["properties"]
+          check_data!(value, data[key], path + [key])
+        else
+          definition = @schema.find(value["$ref"])
+          check_type!(definition["type"], data[key], path + [key])
+          check_format!(definition["format"], data[key], path + [key])
+          check_pattern!(definition["pattern"], data[key], path + [key])
+        end
+      end
+    end
+
+    def check_format!(format, value, path)
+      return if !format
+      valid = case format
+      when "date-time"
+        value =~ /^(\d{4})-(\d{2})-(\d{2})T(\d{2})\:(\d{2})\:(\d{2})(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
+      unless valid
+        raise InvalidResponse,
+          %{Invalid format at "#{path.join(":")}": expected "#{value}" to be "#{format}".}
+      end
+    end
+
+    def check_pattern!(pattern, value, path)
+      if pattern && !(value =~ pattern)
+        raise InvalidResponse,
+          %{Invalid pattern at "#{path.join(":")}": expected #{value} to match "#{pattern}".}
+      end
+    end
+
+    def check_type!(types, value, path)
+      type = case value
+      when NilClass
+        "null"
+      when TrueClass, FalseClass
+        "boolean"
+      when Fixnum
+        "integer"
+      when String
+        "string"
+      else
+        "unknown"
+      end
+      unless types.include?(type)
+        raise InvalidResponse,
+          %{Invalid type at "#{path.join(":")}": expected #{value} to be #{types} (was: #{type}).}
+      end
+    end
+
+    private
+
+    def build_data_keys(data)
+      keys = []
+      data.each do |key, value|
+        if value.is_a?(Hash)
+          keys += value.keys.map { |k| "#{key}:#{k}" }
+        else
+          keys << key
+        end
+      end
+      keys
+    end
+
+    def build_schema_keys
+      keys = []
+      @type_schema["properties"].each do |key, info|
+        if info["properties"]
+          keys += info["properties"].keys.map { |k| "#{key}:#{k}" }
+        else
+          keys << key
+        end
+      end
+      keys
+    end
+  end
+end

data/lib/committee/router.rb

@@ -0,0 +1,38 @@
+module Committee
+  class Router
+    def initialize(schema)
+      @routes = build_routes(schema)
+    end
+
+    def routes?(method, path)
+      if method_routes = @routes[method]
+        method_routes.each do |pattern, link, schema|
+          if path =~ pattern
+            return link, schema
+          end
+        end
+      end
+      [nil, nil]
+    end
+
+    def routes_request?(request)
+      routes?(request.request_method, request.path_info)
+    end
+
+    private
+
+    def build_routes(schema)
+      routes = {}
+      schema.each do |_, type_schema|
+        type_schema["links"].each do |link|
+          routes[link["method"]] ||= []
+          # /apps/{id} --> /apps/([^/]+)
+          pattern = link["href"].gsub(/\{(.*?)\}/, "[^/]+")
+          routes[link["method"]] <<
+            [Regexp.new(pattern), link, type_schema]
+        end
+      end
+      routes
+    end
+  end
+end

data/lib/committee/schema.rb

@@ -0,0 +1,55 @@
+module Committee
+  class Schema
+    include Enumerable
+
+    def initialize(data)
+      @cache = {}
+      @schema = MultiJson.decode(data)
+      manifest_regex
+    end
+
+    def [](type)
+      @schema["definitions"][type]
+    end
+
+    def each
+      @schema["definitions"].each do |type, type_schema|
+        yield(type, type_schema)
+      end
+    end
+
+    def find(ref)
+      cache(ref) do
+        parts = ref.split("/")
+        parts.shift if parts.first == "#"
+        pointer = @schema
+        parts.each do |p|
+          next unless pointer
+          pointer = pointer[p]
+        end
+        raise ReferenceNotFound, "Reference not found: #{ref}." if !pointer
+        pointer
+      end
+    end
+
+    private
+
+    def cache(key)
+      if @cache[key]
+        @cache[key]
+      else
+        @cache[key] = yield
+      end
+    end
+
+    def manifest_regex
+      @schema["definitions"].each do |_, type_schema|
+        type_schema["definitions"].each do |_, property_schema|
+          if pattern = property_schema["pattern"]
+            property_schema["pattern"] = Regexp.new(pattern)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/committee.rb

@@ -0,0 +1,15 @@
+require "multi_json"
+require "rack"
+
+require_relative "committee/errors"
+require_relative "committee/param_validator"
+require_relative "committee/request_unpacker"
+require_relative "committee/response_generator"
+require_relative "committee/response_validator"
+require_relative "committee/router"
+require_relative "committee/schema"
+
+require_relative "committee/middleware/base"
+require_relative "committee/middleware/request_validation"
+require_relative "committee/middleware/response_validation"
+require_relative "committee/middleware/stub"

data/test/middleware/request_validation_test.rb

@@ -0,0 +1,59 @@
+require_relative "../test_helper"
+
+describe Committee::Middleware::RequestValidation do
+  include Rack::Test::Methods
+
+  StubApp = Rack::Builder.new {
+    use Committee::Middleware::RequestValidation,
+      schema: File.read("./test/data/schema.json")
+    run lambda { |_|
+      [200, {}, []]
+    }
+  }
+
+  def app
+    StubApp
+  end
+
+  before do
+    header "Content-Type", "application/json"
+  end
+
+  it "detects an invalid Content-Type" do
+    header "Content-Type", "application/whats-this"
+    post "/account/app-transfers", "{}"
+    assert_equal 400, last_response.status
+  end
+
+  it "passes through a valid request" do
+    params = {
+      "app" => "heroku-api",
+      "recipient" => "owner@heroku.com",
+    }
+    post "/account/app-transfers", MultiJson.encode(params)
+    assert_equal 200, last_response.status
+  end
+
+  it "detects a missing parameter" do
+    post "/account/app-transfers", "{}"
+    assert_equal 422, last_response.status
+    assert_match /require params/i, last_response.body
+  end
+
+  it "detects an extra parameter" do
+    params = {
+      "app" => "heroku-api",
+      "cloud" => "production",
+      "recipient" => "owner@heroku.com",
+    }
+    post "/account/app-transfers", MultiJson.encode(params)
+    assert_equal 422, last_response.status
+    assert_match /unknown params/i, last_response.body
+  end
+
+  it "rescues JSON errors" do
+    post "/account/app-transfers", "{x:y}"
+    assert_equal 400, last_response.status
+    assert_match /valid json/i, last_response.body
+  end
+end

data/test/middleware/response_validation_test.rb

@@ -0,0 +1,64 @@
+require_relative "../test_helper"
+
+describe Committee::Middleware::ResponseValidation do
+  include Rack::Test::Methods
+
+  def app
+    @app
+  end
+
+  it "passes through a valid response" do
+    @app = new_rack_app(MultiJson.encode([ValidApp]))
+    get "/apps"
+    assert_equal 200, last_response.status
+  end
+
+  it "detects an invalid response Content-Type" do
+    @app = new_rack_app(MultiJson.encode([ValidApp]), {})
+    get "/apps"
+    assert_equal 500, last_response.status
+    assert_match /response header must be set to/i, last_response.body
+  end
+
+  it "detects an invalid response" do
+    @app = new_rack_app("")
+    get "/apps"
+    assert_equal 500, last_response.status
+    assert_match /valid JSON/i, last_response.body
+  end
+
+  it "detects missing keys in response" do
+    data = ValidApp.dup
+    data.delete("name")
+    @app = new_rack_app(MultiJson.encode([data]))
+    get "/apps"
+    assert_equal 500, last_response.status
+    assert_match /missing keys/i, last_response.body
+  end
+
+  it "detects extra keys in response" do
+    data = ValidApp.dup
+    data.merge!("tier" => "important")
+    @app = new_rack_app(MultiJson.encode([data]))
+    get "/apps"
+    assert_equal 500, last_response.status
+    assert_match /extra keys/i, last_response.body
+  end
+
+  it "rescues JSON errors" do
+    @app = new_rack_app("[{x:y}]")
+    get "/apps"
+    assert_equal 500, last_response.status
+    assert_match /valid json/i, last_response.body
+  end
+
+  def new_rack_app(response, headers={ "Content-Type" => "application/json" })
+    Rack::Builder.new {
+      use Committee::Middleware::ResponseValidation,
+        schema: File.read("./test/data/schema.json")
+      run lambda { |_|
+        [200, headers, [response]]
+      }
+    }
+  end
+end

data/test/middleware/stub_test.rb

@@ -0,0 +1,24 @@
+require_relative "../test_helper"
+
+describe Committee::Middleware::Stub do
+  include Rack::Test::Methods
+
+  ParamValidationApp = Rack::Builder.new {
+    use Committee::Middleware::Stub,
+      schema: File.read("./test/data/schema.json")
+    run lambda { |_|
+      [200, {}, []]
+    }
+  }
+
+  def app
+    ParamValidationApp
+  end
+
+  it "responds with a stubbed response" do
+    get "/apps/heroku-api"
+    assert_equal 200, last_response.status
+    data = MultiJson.decode(last_response.body)
+    assert_equal ValidApp.keys.sort, data.keys.sort
+  end
+end

data/test/param_validator_test.rb

@@ -0,0 +1,74 @@
+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",
+    }
+    Committee::ParamValidator.new(params, @schema, @link_schema).call
+  end
+
+  it "detects a missing parameter" do
+    e = assert_raises(Committee::InvalidParams) do
+      Committee::ParamValidator.new({}, @schema, @link_schema).call
+    end
+    message = "Require params: app, recipient."
+    assert_equal message, e.message
+  end
+
+  it "detects an extraneous parameter" do
+    params = {
+      "app" => "heroku-api",
+      "cloud" => "production",
+      "recipient" => "owner@heroku.com",
+    }
+    e = assert_raises(Committee::InvalidParams) do
+      Committee::ParamValidator.new(params, @schema, @link_schema).call
+    end
+    message = "Unknown params: cloud."
+    assert_equal message, e.message
+  end
+
+  it "detects a parameter of the wrong type" do
+    params = {
+      "app" => "heroku-api",
+      "recipient" => 123,
+    }
+    e = assert_raises(Committee::InvalidParams) do
+      Committee::ParamValidator.new(params, @schema, @link_schema).call
+    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::InvalidParams) do
+      Committee::ParamValidator.new(params, @schema, @link_schema).call
+    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::InvalidParams) do
+      Committee::ParamValidator.new(params, @schema, link_schema).call
+    end
+    message = %{Invalid pattern for key "name": expected %@! to match "(?-mix:^[a-z][a-z0-9-]{3,30}$)".}
+    assert_equal message, e.message
+  end
+end

data/test/request_unpacker_test.rb

@@ -0,0 +1,66 @@
+require_relative "test_helper"
+
+require "stringio"
+
+describe Committee::RequestUnpacker do
+  it "unpacks JSON on Content-Type: application/json" do
+    env = {
+      "CONTENT_TYPE" => "application/json",
+      "rack.input"   => StringIO.new('{"x":"y"}'),
+    }
+    request = Rack::Request.new(env)
+    params = Committee::RequestUnpacker.new(request).call
+    assert_equal({ "x" => "y" }, params)
+  end
+
+  it "unpacks JSON on no Content-Type" do
+    env = {
+      "rack.input"   => StringIO.new('{"x":"y"}'),
+    }
+    request = Rack::Request.new(env)
+    params = Committee::RequestUnpacker.new(request).call
+    assert_equal({ "x" => "y" }, params)
+  end
+
+  it "unpacks an empty hash on an empty request body" do
+    env = {
+      "CONTENT_TYPE" => "application/json",
+      "rack.input"   => StringIO.new(""),
+    }
+    request = Rack::Request.new(env)
+    params = Committee::RequestUnpacker.new(request).call
+    assert_equal({}, params)
+  end
+
+  it "unpacks params on Content-Type: application/x-www-form-urlencoded" do
+    env = {
+      "CONTENT_TYPE" => "application/x-www-form-urlencoded",
+      "rack.input"   => StringIO.new("x=y"),
+    }
+    request = Rack::Request.new(env)
+    params = Committee::RequestUnpacker.new(request).call
+    assert_equal({ "x" => "y" }, params)
+  end
+
+  it "errors if JSON is not an object" do
+    env = {
+      "CONTENT_TYPE" => "application/json",
+      "rack.input"   => StringIO.new('[2]'),
+    }
+    request = Rack::Request.new(env)
+    assert_raises(Committee::BadRequest) do
+      Committee::RequestUnpacker.new(request).call
+    end
+  end
+
+  it "errors on an unknown Content-Type" do
+    env = {
+      "CONTENT_TYPE" => "application/whats-this",
+      "rack.input"   => StringIO.new('{"x":"y"}'),
+    }
+    request = Rack::Request.new(env)
+    assert_raises(Committee::BadRequest) do
+      Committee::RequestUnpacker.new(request).call
+    end
+  end
+end

data/test/response_generator_test.rb

@@ -0,0 +1,32 @@
+require_relative "test_helper"
+
+describe Committee::ResponseGenerator do
+  before do
+    @schema = Committee::Schema.new(File.read("./test/data/schema.json"))
+    @generator = Committee::ResponseGenerator.new(
+      @schema,
+      @schema["app"],
+      @schema["app"]["links"][0]
+    )
+  end
+
+  it "generates string properties" do
+    data = @generator.call
+    assert data["name"].is_a?(String)
+  end
+
+  it "generates non-string properties" do
+    data = @generator.call
+    assert [FalseClass, TrueClass].include?(data["maintenance"].class)
+  end
+
+  it "wraps list data in an array" do
+    @generator = Committee::ResponseGenerator.new(
+      @schema,
+      @schema["app"],
+      @schema["app"]["links"][3]
+    )
+    data = @generator.call
+    assert data.is_a?(Array)
+  end
+end

data/test/response_validator_test.rb

@@ -0,0 +1,75 @@
+require_relative "test_helper"
+
+describe Committee::ResponseValidator do
+  before do
+    @data = ValidApp.dup
+    @schema = Committee::Schema.new(File.read("./test/data/schema.json"))
+    # GET /apps/:id
+    @link_schema = @schema["app"]["links"][2]
+  end
+
+  it "passes through a valid response" do
+    call
+  end
+
+  it "passes through a valid list response" do
+    @data = [@data]
+    # GET /apps
+    @link_schema = @schema["app"]["links"][3]
+    call
+  end
+
+  it "detects an improperly formatted list response" do
+    # GET /apps
+    @link_schema = @schema["app"]["links"][3]
+    e = assert_raises(Committee::InvalidResponse) { call }
+    message = "List endpoints must return an array of objects."
+    assert_equal message, e.message
+  end
+
+  it "detects missing keys in response" do
+    @data.delete("name")
+    e = assert_raises(Committee::InvalidResponse) { call }
+    message = %r{Missing keys in response: name.}
+    assert_match message, e.message
+  end
+
+  it "detects extra keys in response" do
+    @data.merge!("tier" => "important")
+    e = assert_raises(Committee::InvalidResponse) { call }
+    message = %r{Extra keys in response: tier.}
+    assert_match message, e.message
+  end
+
+  it "detects mismatched types" do
+    @data.merge!("maintenance" => "not-bool")
+    e = assert_raises(Committee::InvalidResponse) { call }
+    message = %{Invalid type at "maintenance": expected not-bool to be ["boolean"] (was: string).}
+    assert_equal message, e.message
+  end
+
+  it "detects bad formats" do
+    @data.merge!("id" => "123")
+    e = assert_raises(Committee::InvalidResponse) { call }
+    message = %{Invalid format at "id": expected "123" to be "uuid".}
+    assert_equal message, e.message
+  end
+
+  it "detects bad patterns" do
+    @data.merge!("name" => "%@!")
+    e = assert_raises(Committee::InvalidResponse) { call }
+    message = %{Invalid pattern at "name": expected %@! to match "(?-mix:^[a-z][a-z0-9-]{3,30}$)".}
+    assert_equal message, e.message
+  end
+
+  private
+
+  def call
+    Committee::ResponseValidator.new(
+      @data,
+      @schema,
+      @link_schema,
+      @schema["app"]
+    ).call
+  end
+end

data/test/router_test.rb

@@ -0,0 +1,17 @@
+require_relative "test_helper"
+
+describe Committee::Router do
+  before do
+    data = File.read("./test/data/schema.json")
+    schema = Committee::Schema.new(data)
+    @router = Committee::Router.new(schema)
+  end
+
+  it "builds routes without parameters" do
+    assert @router.routes?("GET", "/apps")
+  end
+
+  it "builds routes with parameters" do
+    assert @router.routes?("GET", "/apps/123")
+  end
+end

data/test/schema_test.rb

@@ -0,0 +1,36 @@
+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"        => ["integer", "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

data/test/test_helper.rb

@@ -0,0 +1,36 @@
+require "minitest"
+require "minitest/spec"
+require 'minitest/pride'
+require "minitest/autorun"
+
+require "bundler/setup"
+Bundler.require(:development)
+
+require_relative "../lib/committee"
+
+ValidApp = {
+  "archived_at"                    => "2012-01-01T12:00:00Z",
+  "buildpack_provided_description" => "Ruby/Rack",
+  "created_at"                     => "2012-01-01T12:00:00Z",
+  "git_url"                        => "git@heroku.com/example.git",
+  "id"                             => "01234567-89ab-cdef-0123-456789abcdef",
+  "maintenance"                    => false,
+  "name"                           => "example",
+  "owner"                          => {
+    "email"                        => "username@example.com",
+    "id"                           => "01234567-89ab-cdef-0123-456789abcdef"
+  },
+  "region"                         => {
+    "id"                           => "01234567-89ab-cdef-0123-456789abcdef",
+    "name"                         => "us"
+  },
+  "released_at"                    => "2012-01-01T12:00:00Z",
+  "repo_size"                      => 0,
+  "slug_size"                      => 0,
+  "stack"                          => {
+    "id"                           => "01234567-89ab-cdef-0123-456789abcdef",
+    "name"                         => "cedar"
+  },
+  "updated_at"                     => "2012-01-01T12:00:00Z",
+  "web_url"                        => "http://example.herokuapp.com"
+}.freeze

metadata

@@ -0,0 +1,149 @@
+--- !ruby/object:Gem::Specification
+name: committee
+version: !ruby/object:Gem::Version
+  version: '0.1'
+  prerelease: 
+platform: ruby
+authors:
+- Brandur
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-12-18 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: multi_json
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>'
+      - !ruby/object:Gem::Version
+        version: '0.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>'
+      - !ruby/object:Gem::Version
+        version: '0.0'
+- !ruby/object:Gem::Dependency
+  name: rack
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>'
+      - !ruby/object:Gem::Version
+        version: '0.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>'
+      - !ruby/object:Gem::Version
+        version: '0.0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rack-test
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: 
+email: brandur@mutelight.org
+executables:
+- committee-stub
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/committee/errors.rb
+- lib/committee/middleware/base.rb
+- lib/committee/middleware/request_validation.rb
+- lib/committee/middleware/response_validation.rb
+- lib/committee/middleware/stub.rb
+- lib/committee/param_validator.rb
+- lib/committee/request_unpacker.rb
+- lib/committee/response_generator.rb
+- lib/committee/response_validator.rb
+- lib/committee/router.rb
+- lib/committee/schema.rb
+- lib/committee.rb
+- test/middleware/request_validation_test.rb
+- test/middleware/response_validation_test.rb
+- test/middleware/stub_test.rb
+- test/param_validator_test.rb
+- test/request_unpacker_test.rb
+- test/response_generator_test.rb
+- test/response_validator_test.rb
+- test/router_test.rb
+- test/schema_test.rb
+- test/test_helper.rb
+- bin/committee-stub
+homepage: https://github.com/brandur/rack-committee
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: A collection of middleware to support JSON Schema.
+test_files: []