committee 0.4.14 → 1.0.0

data/bin/committee-stub

@@ -32,8 +32,8 @@ 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
+  use Committee::Middleware::Stub, schema: schema
   run lambda { |_|
     [404, {}, ["Not found"]]
   }

data/lib/committee/errors.rb

@@ -5,16 +5,7 @@ module Committee
   class BadRequest < Error
   end
 
-  class InvalidPattern < Error
-  end
-
-  class InvalidFormat < Error
-  end
-
-  class InvalidType < Error
-  end
-
-  class InvalidParams < Error
+  class InvalidRequest < Error
   end
 
   class InvalidResponse < Error

data/lib/committee/middleware/base.rb

@@ -5,7 +5,11 @@ module Committee::Middleware
 
       @params_key = options[:params_key] || "committee.params"
       data = options[:schema] || raise("need option `schema`")
-      @schema = Committee::Schema.new(data)
+      if data.is_a?(String)
+        warn_string_deprecated
+        data = MultiJson.decode(data)
+      end
+      @schema = JsonSchema.parse!(data)
       @router = Committee::Router.new(@schema)
     end
 
@@ -15,5 +19,9 @@ module Committee::Middleware
       [status, { "Content-Type" => "application/json" },
         [MultiJson.encode({ id: id, error: message }, pretty: true)]]
     end
+
+    def warn_string_deprecated
+      Committee.warn_deprecated("Committee: passing a string to `schema` option is deprecated; please send a deserialized hash instead.")
+    end
   end
 end

data/lib/committee/middleware/request_validation.rb

@@ -2,21 +2,17 @@ module Committee::Middleware
   class RequestValidation < Base
     def initialize(app, options={})
       super
-      @allow_extra = options[:allow_extra]
       @prefix = options[:prefix]
+
+      # deprecated
+      @allow_extra = options[:allow_extra]
     end
 
     def call(env)
       request = Rack::Request.new(env)
       env[@params_key] = Committee::RequestUnpacker.new(request).call
-      link, _ = @router.routes_request?(request, prefix: @prefix)
-      if link
-        Committee::ParamValidator.new(
-          env[@params_key],
-          @schema,
-          link,
-          allow_extra: @allow_extra
-        ).call
+      if link = @router.routes_request?(request, prefix: @prefix)
+        Committee::RequestValidator.new.call(link, env[@params_key])
       end
       @app.call(env)
     rescue Committee::BadRequest

data/lib/committee/middleware/response_validation.rb

@@ -8,17 +8,10 @@ module Committee::Middleware
     def call(env)
       status, headers, response = @app.call(env)
       request = Rack::Request.new(env)
-      link_schema, type_schema =
-        @router.routes_request?(request, prefix: @prefix)
-      if type_schema
-        check_content_type!(headers)
+      if link = @router.routes_request?(request, prefix: @prefix)
         str = response.reduce("") { |str, s| str << s }
-        Committee::ResponseValidator.new(
-          MultiJson.decode(str),
-          @schema,
-          link_schema,
-          type_schema
-        ).call
+        data = MultiJson.decode(str)
+        Committee::ResponseValidator.new(link).call(headers, data)
       end
       [status, headers, response]
     rescue Committee::InvalidResponse
@@ -26,14 +19,5 @@ module Committee::Middleware
     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

@@ -9,11 +9,10 @@ module Committee::Middleware
 
     def call(env)
       request = Rack::Request.new(env)
-      link_schema, type_schema = @router.routes_request?(request, prefix: @prefix)
-      if type_schema
+      if link = @router.routes_request?(request, prefix: @prefix)
         headers = { "Content-Type" => "application/json" }
-        data = cache(link_schema["method"], link_schema["href"]) do
-          Committee::ResponseGenerator.new(@schema, type_schema, link_schema).call
+        data = cache(link.method, link.href) do
+          Committee::ResponseGenerator.new.call(link)
         end
         if @call
           env["committee.response"] = data
@@ -28,7 +27,7 @@ module Committee::Middleware
           # made, and stub normally
           headers.merge!(call_headers)
         end
-        status = link_schema["rel"] == "create" ? 201 : 200
+        status = link.rel == "create" ? 201 : 200
         [status, headers, [MultiJson.encode(data, pretty: true)]]
       else
         @app.call(env)

data/lib/committee/request_validator.rb

@@ -0,0 +1,28 @@
+module Committee
+  class RequestValidator
+    def initialize(options = {})
+    end
+
+    def call(link, params)
+      if link.schema
+        valid, errors = link.schema.validate(params)
+        if !valid
+          errors = error_messages(errors).join("\n")
+          raise InvalidRequest, "Invalid request.\n\n#{errors}"
+        end
+      end
+    end
+
+    private
+
+    def error_messages(errors)
+      errors.map do |error|
+        if error.schema
+          %{At "#{error.schema.uri}": #{error.message}}
+        else
+          error.message
+        end
+      end
+    end
+  end
+end

data/lib/committee/response_generator.rb

@@ -1,29 +1,35 @@
 module Committee
   class ResponseGenerator
-    def initialize(schema, type_schema, link_schema)
-      @schema = schema
-      @type_schema = type_schema
-      @link_schema = link_schema
-    end
+    def call(link)
+      data = generate_properties(link.parent)
+
+      # list is a special case; wrap data in an array
+      data = [data] if link.rel == "instances"
 
-    def call
-      generate_properties(@type_schema)
+      data
     end
 
     private
 
     def generate_properties(schema)
       data = {}
-      schema["properties"].each do |name, value|
-        data[name] = if value["properties"]
+      schema.properties.each do |key, value|
+        data[key] = if !value.properties.empty?
           generate_properties(value)
         else
-          definition = @schema.find(value["$ref"])
-          definition["example"]
+          # special example attribute was included; use its value
+          if !value.data["example"].nil?
+            value.data["example"]
+          # null is allowed; use that
+          elsif value.type.include?("null")
+            nil
+          # otherwise we don't know what to do (we could eventually generate
+          # random data based on type/format
+          else
+            raise(%{At "#{schema.id}"/"#{key}": no "example" attribute and "null" is not allowed; don't know how to generate property.})
+          end
         end
       end
-      # list is a special case; wrap data in an array
-      data = [data] if @link_schema["title"] == "List"
       data
     end
   end

data/lib/committee/response_validator.rb

@@ -1,111 +1,44 @@
 module Committee
   class ResponseValidator
-    include Validation
-
-    def initialize(data, schema, link_schema, type_schema)
-
-      @data = data
-      @schema = schema
-      @link_schema = link_schema
-      @type_schema = type_schema
+    def initialize(link)
+      @link = link
+      @validator = JsonSchema::Validator.new(link.parent)
     end
 
-    def call
-      data = if @link_schema["rel"] == "instances"
-        if !@data.is_a?(Array)
+    def call(headers, data)
+      check_content_type!(headers)
+
+      if @link.rel == "instances"
+        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(', ')}."
+        data = data[0]
       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])
-        elsif value["type"] == ["array"]
-          definition = @schema.find(value["items"]["$ref"])
-          data[key].each do |datum|
-            check_type!(definition["type"], datum, path + [key])
-            check_data!(definition, datum, path + [key]) if definition["type"] == ["object"]
-            unless definition["type"].include?("null") && datum.nil?
-              check_format!(definition["format"], datum, path + [key])
-              check_pattern!(definition["pattern"], datum, path + [key])
-            end
-          end
-
-        else
-          definition = @schema.find(value["$ref"])
-          check_type!(definition["type"], data[key], path + [key])
-          unless definition["type"].include?("null") && data[key].nil?
-            check_format!(definition["format"], data[key], path + [key])
-            check_pattern!(definition["pattern"], data[key], path + [key])
-          end
-        end
+      if !@validator.validate(data)
+        errors = error_messages(@validator.errors).join("\n")
+        raise InvalidResponse, "Invalid response.\n\n#{errors}"
       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
+    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
-      keys
     end
 
-    def build_schema_keys
-      keys = []
-      @type_schema["properties"].each do |key, info|
-        data = if info["properties"]
-          info
-        elsif info["type"] == ["array"]
-          array_schema = @schema.find(info["items"]["$ref"])
-          unless array_schema["type"] == ["object"]
-            array_schema
-          else
-            {} # satisfy data['properties'] check below
-          end
-        elsif info["$ref"]
-          @schema.find(info["$ref"])
-        end
-        if data["properties"]
-          keys += data["properties"].keys.map { |k| "#{key}:#{k}" }
+    def error_messages(errors)
+      errors.map do |error|
+        if error.schema
+          %{At "#{error.schema.uri}": #{error.message}}
         else
-          keys << key
+          error.message
         end
       end
-      keys
     end
   end
 end

data/lib/committee/router.rb

@@ -7,13 +7,13 @@ module Committee
     def routes?(method, path, options = {})
       path = path.gsub(/^#{options[:prefix]}/, "") if options[:prefix]
       if method_routes = @routes[method]
-        method_routes.each do |pattern, link, schema|
+        method_routes.each do |pattern, link|
           if path =~ pattern
-            return link, schema
+            return link
           end
         end
       end
-      [nil, nil]
+      nil
     end
 
     def routes_request?(request, options = {})
@@ -24,13 +24,14 @@ module Committee
 
     def build_routes(schema)
       routes = {}
-      schema.each do |_, type_schema|
-        type_schema["links"].each do |link|
-          routes[link["method"]] ||= []
+      # realistically, we should be examining links recursively at all levels
+      schema.properties.each do |_, type_schema|
+        type_schema.links.each do |link|
+          method = link.method.to_s.upcase
+          routes[method] ||= []
           # /apps/{id} --> /apps/([^/]+)
-          href = link["href"].gsub(/\{(.*?)\}/, "[^/]+")
-          routes[link["method"]] <<
-            [%r{^#{href}$}, link, type_schema]
+          href = link.href.gsub(/\{(.*?)\}/, "[^/]+")
+          routes[method] << [%r{^#{href}$}, link]
         end
       end
       routes

data/lib/committee/test/methods.rb

@@ -1,48 +1,46 @@
 module Committee::Test
   module Methods
     def assert_schema_conform
-      assert_schema_content_type
+      if (data = schema_contents).is_a?(String)
+        warn_string_deprecated
+        data = MultiJson.decode(data)
+      end
 
-      @schema ||= Committee::Schema.new(schema_contents)
+      @schema ||= JsonSchema.parse!(data)
       @router ||= Committee::Router.new(@schema)
 
-      link_schema, type_schema =
+      link =
         @router.routes_request?(last_request, prefix: schema_url_prefix)
-
-      unless link_schema
+      unless link
         response = "`#{last_request.request_method} #{last_request.path_info}` undefined in schema."
         raise Committee::InvalidResponse.new(response)
       end
 
       data = MultiJson.decode(last_response.body)
-      Committee::ResponseValidator.new(
-        data,
-        @schema,
-        link_schema,
-        type_schema
-      ).call
+      Committee::ResponseValidator.new(link).call(last_response.headers, data)
     end
 
     def assert_schema_content_type
-      unless last_response.headers["Content-Type"] =~ %r{application/json}
-        raise Committee::InvalidResponse,
-          %{"Content-Type" response header must be set to "application/json".}
-      end
+      Committee.warn_deprecated("Use of #assert_schema_content_type is deprecated; use #assert_schema_conform instead.")
     end
 
     # can be overridden alternatively to #schema_path in case the schema is
     # easier to access as a string
     # blob
     def schema_contents
-      File.read(schema_path)
+      MultiJson.decode(File.read(schema_path))
     end
 
     def schema_path
-      raise "Please override #schema_path."
+      raise "Please override #schema_contents or #schema_path."
     end
 
     def schema_url_prefix
       nil
     end
+
+    def warn_string_deprecated
+      Committee.warn_deprecated("Committee: returning a string from `#schema_contents` is deprecated; please return a deserialized hash instead.")
+    end
   end
 end

data/lib/committee.rb

@@ -1,14 +1,13 @@
+require "json_schema"
 require "multi_json"
 require "rack"
 
 require_relative "committee/errors"
-require_relative "committee/validation"
-require_relative "committee/param_validator"
 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/schema"
 
 require_relative "committee/middleware/base"
 require_relative "committee/middleware/request_validation"
@@ -16,3 +15,11 @@ require_relative "committee/middleware/response_validation"
 require_relative "committee/middleware/stub"
 
 require_relative "committee/test/methods"
+
+module Committee
+  def self.warn_deprecated(message)
+    if !$VERBOSE.nil?
+      $stderr.puts(message)
+    end
+  end
+end

data/test/middleware/request_validation_test.rb

@@ -7,61 +7,31 @@ describe Committee::Middleware::RequestValidation do
     @app
   end
 
-  it "detects an invalid Content-Type" do
-    @app = new_rack_app
-    header "Content-Type", "application/whats-this"
-    post "/account/app-transfers", "{}"
-    assert_equal 400, last_response.status
-  end
-
   it "passes through a valid request" do
     @app = new_rack_app
     params = {
-      "app" => "heroku-api",
-      "recipient" => "owner@heroku.com",
+      "name" => "cloudnasium"
     }
     header "Content-Type", "application/json"
-    post "/account/app-transfers", MultiJson.encode(params)
+    post "/apps", MultiJson.encode(params)
     assert_equal 200, last_response.status
   end
 
-  it "detects a missing parameter" do
-    @app = new_rack_app
-    header "Content-Type", "application/json"
-    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
+  it "detects an invalid Content-Type" do
     @app = new_rack_app
+    header "Content-Type", "application/whats-this"
     params = {
-      "app" => "heroku-api",
-      "cloud" => "production",
-      "recipient" => "owner@heroku.com",
-    }
-    header "Content-Type", "application/json"
-    post "/account/app-transfers", MultiJson.encode(params)
-    assert_equal 422, last_response.status
-    assert_match /unknown params/i, last_response.body
-  end
-
-  it "doesn't error on an extra parameter with allow_extra" do
-    @app = new_rack_app(allow_extra: true)
-    params = {
-      "app" => "heroku-api",
-      "cloud" => "production",
-      "recipient" => "owner@heroku.com",
+      "name" => "cloudnasium"
     }
-    header "Content-Type", "application/json"
-    post "/account/app-transfers", MultiJson.encode(params)
-    assert_equal 200, last_response.status
+    post "/apps", MultiJson.encode(params)
+    assert_equal 400, last_response.status
+    assert_match /unsupported content-type/i, last_response.body
   end
 
   it "rescues JSON errors" do
     @app = new_rack_app
     header "Content-Type", "application/json"
-    post "/account/app-transfers", "{x:y}"
+    post "/apps", "{x:y}"
     assert_equal 400, last_response.status
     assert_match /valid json/i, last_response.body
   end
@@ -69,11 +39,21 @@ describe Committee::Middleware::RequestValidation do
   it "takes a prefix" do
     @app = new_rack_app(prefix: "/v1")
     params = {
-      "app" => "heroku-api",
-      "recipient" => "owner@heroku.com",
+      "name" => "cloudnasium"
+    }
+    header "Content-Type", "application/json"
+    post "/v1/apps", MultiJson.encode(params)
+    assert_equal 200, last_response.status
+  end
+
+  it "warns when sending a deprecated string" do
+    mock(Committee).warn_deprecated.with_any_args
+    @app = new_rack_app(schema: File.read("./test/data/schema.json"))
+    params = {
+      "name" => "cloudnasium"
     }
     header "Content-Type", "application/json"
-    post "/v1/account/app-transfers", MultiJson.encode(params)
+    post "/apps", MultiJson.encode(params)
     assert_equal 200, last_response.status
   end
 
@@ -81,7 +61,7 @@ describe Committee::Middleware::RequestValidation do
 
   def new_rack_app(options = {})
     options = {
-      schema: File.read("./test/data/schema.json")
+      schema: MultiJson.decode(File.read("./test/data/schema.json"))
     }.merge(options)
     Rack::Builder.new {
       use Committee::Middleware::RequestValidation, options

data/test/middleware/response_validation_test.rb

@@ -13,14 +13,6 @@ describe Committee::Middleware::ResponseValidation do
     assert_equal 200, last_response.status
   end
 
-  it "detects an invalid response Content-Type" do
-    @app = new_rack_app(MultiJson.encode([ValidApp]),
-      { "Content-Type" => "application/xml" })
-    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"
@@ -28,24 +20,6 @@ describe Committee::Middleware::ResponseValidation do
     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"
@@ -59,6 +33,14 @@ describe Committee::Middleware::ResponseValidation do
     assert_equal 200, last_response.status
   end
 
+  it "warns when sending a deprecated string" do
+    mock(Committee).warn_deprecated.with_any_args
+    @app = new_rack_app(MultiJson.encode([ValidApp]), {},
+      schema: File.read("./test/data/schema.json"))
+    get "/apps"
+    assert_equal 200, last_response.status
+  end
+
   private
 
   def new_rack_app(response, headers = {}, options = {})
@@ -66,7 +48,7 @@ describe Committee::Middleware::ResponseValidation do
       "Content-Type" => "application/json"
     }.merge(headers)
     options = {
-      schema: File.read("./test/data/schema.json")
+      schema: MultiJson.decode(File.read("./test/data/schema.json"))
     }.merge(options)
     Rack::Builder.new {
       use Committee::Middleware::ResponseValidation, options

data/test/middleware/stub_test.rb

@@ -46,12 +46,21 @@ describe Committee::Middleware::Stub do
     assert_equal ValidApp.keys.sort, data.keys.sort
   end
 
+  it "warns when sending a deprecated string" do
+    mock(Committee).warn_deprecated.with_any_args
+    @app = new_rack_app(schema: File.read("./test/data/schema.json"))
+    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
+
   private
 
   def new_rack_app(options = {})
     suppress = options.delete(:suppress)
     options = {
-      schema: File.read("./test/data/schema.json")
+      schema: MultiJson.decode(File.read("./test/data/schema.json"))
     }.merge(options)
     Rack::Builder.new {
       use Committee::Middleware::Stub, options