committee 0.4.2 → 0.4.3

data/lib/committee/errors.rb

@@ -2,6 +2,15 @@ module Committee
   class BadRequest < StandardError
   end
 
+  class InvalidPattern < StandardError
+  end
+
+  class InvalidFormat < StandardError
+  end
+
+  class InvalidType < StandardError
+  end
+
   class InvalidParams < StandardError
   end
 

data/lib/committee/param_validator.rb

@@ -1,5 +1,7 @@
 module Committee
   class ParamValidator
+    include Validation
+
     def initialize(params, schema, link_schema)
       @params = params
       @schema = schema
@@ -31,79 +33,27 @@ module Committee
           try_match(key, @params[key], definitions)
         else
           # only assume one possible array definition for now
-          array_definition = find_definitions(value["items"]["$ref"])[0]
+          definitions = find_definitions(value["items"]["$ref"])
+          array_definition = definitions[0]
           @params[key].each do |item|
-            array_definition["properties"].each do |array_key, array_value|
-              return unless item.key?(array_key)
-
-              # @todo: this should really be recursive; only one array level is
-              # supported for now
-              definitions = find_definitions(array_value["$ref"])
-              try_match(array_key, item[array_key], definitions)
+            # separate logic for a complex object that includes properties
+            if array_definition.key?("properties")
+              array_definition["properties"].each do |array_key, array_value|
+                return unless item.key?(array_key)
+
+                # @todo: this should really be recursive; only one array level is
+                # supported for now
+                item_definitions = find_definitions(array_value["$ref"])
+                try_match(array_key, item[array_key], item_definitions)
+              end
+            else
+              try_match(key, item, definitions)
             end
           end
         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(allowed_types, value, key)
-      types = case value
-      when NilClass
-        ["null"]
-      when TrueClass, FalseClass
-        ["boolean"]
-      when Bignum, Fixnum
-        ["integer", "number"]
-      when Float
-        ["number"]
-      when Hash
-        ["object"]
-      when String
-        ["string"]
-      else
-        ["unknown"]
-      end
-      !(allowed_types & types).empty?
-    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

data/lib/committee/response_validator.rb

@@ -1,6 +1,9 @@
 module Committee
   class ResponseValidator
+    include Validation
+
     def initialize(data, schema, link_schema, type_schema)
+
       @data = data
       @schema = schema
       @link_schema = link_schema
@@ -8,7 +11,7 @@ module Committee
     end
 
     def call
-      data = if @link_schema["title"] == "List"
+      data = if @link_schema["rel"] == "instances"
         if !@data.is_a?(Array)
           raise InvalidResponse, "List endpoints must return an array of objects."
         end
@@ -45,6 +48,16 @@ module Committee
       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])
+            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])
@@ -56,54 +69,6 @@ module Committee
       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!(allowed_types, value, path)
-      types = case value
-      when NilClass
-        ["null"]
-      when TrueClass, FalseClass
-        ["boolean"]
-      when Bignum, Fixnum
-        ["integer", "number"]
-      when Float
-        ["number"]
-      when Hash
-        ["object"]
-      when String
-        ["string"]
-      else
-        ["unknown"]
-      end
-      if (allowed_types & types).empty?
-        raise InvalidResponse,
-          %{Invalid type at "#{path.join(":")}": expected #{value} to be #{allowed_types} (was: #{types}).}
-      end
-    end
-
     private
 
     def build_data_keys(data)
@@ -123,6 +88,8 @@ module Committee
       @type_schema["properties"].each do |key, info|
         data = if info["properties"]
           info
+        elsif info["type"] == ["array"]
+          @schema.find(info["items"]["$ref"])
         elsif info["$ref"]
           @schema.find(info["$ref"])
         end

data/lib/committee/test/methods.rb

@@ -0,0 +1,36 @@
+module Committee::Test
+  module Methods
+    def assert_schema_conform
+      assert_schema_content_type
+
+      @schema ||= Committee::Schema.new(File.read(schema_path))
+      @router ||= Committee::Router.new(@schema)
+
+      link_schema, type_schema = @router.routes_request?(last_request)
+
+      unless link_schema
+        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
+    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
+    end
+
+    def schema_path
+      raise "Please override #schema_path."
+    end
+  end
+end

data/lib/committee/validation.rb

@@ -0,0 +1,81 @@
+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} to be #{allowed_types}.}
+      when Array
+        %{Invalid type at "#{identifier.join(":")}": expected #{value} 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"]
+      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 =~ pattern
+    end
+  end
+end

data/lib/committee.rb

@@ -2,6 +2,7 @@ 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/response_generator"
@@ -13,3 +14,5 @@ require_relative "committee/middleware/base"
 require_relative "committee/middleware/request_validation"
 require_relative "committee/middleware/response_validation"
 require_relative "committee/middleware/stub"
+
+require_relative "committee/test/methods"

data/test/param_validator_test.rb

@@ -41,7 +41,7 @@ describe Committee::ParamValidator do
       "app" => "heroku-api",
       "recipient" => 123,
     }
-    e = assert_raises(Committee::InvalidParams) do
+    e = assert_raises(Committee::InvalidType) do
       Committee::ParamValidator.new(params, @schema, @link_schema).call
     end
     message = %{Invalid type for key "recipient": expected 123 to be ["string"].}
@@ -53,7 +53,7 @@ describe Committee::ParamValidator do
       "app" => "heroku-api",
       "recipient" => "not-email",
     }
-    e = assert_raises(Committee::InvalidParams) do
+    e = assert_raises(Committee::InvalidFormat) do
       Committee::ParamValidator.new(params, @schema, @link_schema).call
     end
     message = %{Invalid format for key "recipient": expected "not-email" to be "email".}
@@ -65,35 +65,61 @@ describe Committee::ParamValidator do
       "name" => "%@!"
     }
     link_schema = @schema["app"]["links"][0]
-    e = assert_raises(Committee::InvalidParams) do
+    e = assert_raises(Committee::InvalidPattern) 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
 
-  it "passes an array parameter" do
-    params = {
-      "updates" => [
-        { "name" => "bamboo", "state" => "private" },
-        { "name" => "cedar", "state" => "public" },
-      ]
-    }
-    link_schema = @schema["stack"]["links"][2]
-    Committee::ParamValidator.new(params, @schema, link_schema).call
+  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]
+      Committee::ParamValidator.new(params, @schema, link_schema).call
+    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
+        Committee::ParamValidator.new(params, @schema, link_schema).call
+      end
+      message = %{Invalid type for key "state": expected 123 to be ["string"].}
+      assert_equal message, e.message
+    end
   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::InvalidParams) do
+  describe "simple arrays" do
+    it "passes an array parameter" do
+      params = {
+        "password" => "1234",
+        "flags" => [ "vip", "customer" ]
+      }
+      link_schema = @schema["account"]["links"][1]
       Committee::ParamValidator.new(params, @schema, link_schema).call
     end
-    message = %{Invalid type for key "state": expected 123 to be ["string"].}
-    assert_equal message, e.message
+
+    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
+        Committee::ParamValidator.new(params, @schema, link_schema).call
+      end
+      message = %{Invalid type for key "flags": expected 999 to be ["string"].}
+      assert_equal message, e.message
+    end
   end
 end

data/test/response_validator_test.rb

@@ -6,6 +6,7 @@ describe Committee::ResponseValidator do
     @schema = Committee::Schema.new(File.read("./test/data/schema.json"))
     # GET /apps/:id
     @link_schema = @schema["app"]["links"][2]
+    @type_schema = @schema["app"]
   end
 
   it "passes through a valid response" do
@@ -19,6 +20,12 @@ describe Committee::ResponseValidator do
     call
   end
 
+  it "passes through a valid list response with non-default title" do
+    @data = [@data]
+    @link_schema = @schema["app"]["links"][4]
+    call
+  end
+
   it "detects an improperly formatted list response" do
     # GET /apps
     @link_schema = @schema["app"]["links"][3]
@@ -43,25 +50,68 @@ describe Committee::ResponseValidator do
 
   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"]).}
+    e = assert_raises(Committee::InvalidType) { call }
+    message = %{Invalid type at "maintenance": expected not-bool to be ["boolean"].}
     assert_equal message, e.message
   end
 
   it "detects bad formats" do
     @data.merge!("id" => "123")
-    e = assert_raises(Committee::InvalidResponse) { call }
+    e = assert_raises(Committee::InvalidFormat) { 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 }
+    e = assert_raises(Committee::InvalidPattern) { call }
     message = %{Invalid pattern at "name": expected %@! to match "(?-mix:^[a-z][a-z0-9-]{3,30}$)".}
     assert_equal message, e.message
   end
 
+  it "accepts date-time format without milliseconds" do
+    validator = Committee::ResponseValidator.new(
+      @data,
+      @schema,
+      @link_schema,
+      @schema["app"])
+
+    value = "2014-03-10T00:00:00Z"
+    assert_nil validator.check_format!("date-time", value, ["example"])
+  end
+
+  it "accepts date-time format with milliseconds" do
+    validator = Committee::ResponseValidator.new(
+      @data,
+      @schema,
+      @link_schema,
+      @schema["app"])
+
+    value = "2014-03-10T00:00:00.123Z"
+    assert_nil validator.check_format!("date-time", value, ["example"])
+  end
+
+  it "accepts a simple array" do
+    @data = ValidAccount.dup
+    @data["flags"] = @data["flags"].dup
+    @link_schema = @schema["account"]["links"][1]
+    @type_schema = @schema["account"]
+
+    call
+  end
+
+  it "detects a simple array with an item of the wrong type" do
+    @data = ValidAccount.dup
+    @data["flags"] = @data["flags"].dup
+    @data["flags"] << false
+    @link_schema = @schema["account"]["links"][1]
+    @type_schema = @schema["account"]
+
+    e = assert_raises(Committee::InvalidType) { call }
+    message = %{Invalid type at "flags": expected false to be ["string"].}
+    assert_equal message, e.message
+  end
+
   private
 
   def call
@@ -69,7 +119,7 @@ describe Committee::ResponseValidator do
       @data,
       @schema,
       @link_schema,
-      @schema["app"]
+      @type_schema
     ).call
   end
 end

data/test/test/methods_test.rb

@@ -0,0 +1,69 @@
+require_relative "../test_helper"
+
+describe Committee::Middleware::Stub do
+  include Committee::Test::Methods
+  include Rack::Test::Methods
+
+  def app
+    @app
+  end
+
+  def schema_path
+    "./test/data/schema.json"
+  end
+
+  describe "#assert_schema_content_type" do
+    it "passes through a valid response" do
+      @app = new_rack_app(MultiJson.encode([ValidApp]))
+      get "/apps"
+      assert_schema_content_type
+    end
+
+    it "detects an invalid response Content-Type" do
+      @app = new_rack_app(MultiJson.encode([ValidApp]), {})
+      get "/apps"
+      e = assert_raises(Committee::InvalidResponse) do
+        assert_schema_content_type
+      end
+      assert_match /response header must be set to/i, e.message
+    end
+  end
+
+  describe "#assert_schema_conform" do
+    it "passes through a valid response" do
+      @app = new_rack_app(MultiJson.encode([ValidApp]))
+      get "/apps"
+      assert_schema_conform
+    end
+
+    it "detects an invalid response Content-Type" do
+      @app = new_rack_app(MultiJson.encode([ValidApp]), {})
+      get "/apps"
+      e = assert_raises(Committee::InvalidResponse) do
+        assert_schema_conform
+      end
+      assert_match /response header must be set to/i, e.message
+    end
+
+    it "detects missing keys in response" do
+      data = ValidApp.dup
+      data.delete("name")
+      @app = new_rack_app(MultiJson.encode([data]))
+      get "/apps"
+      e = assert_raises(Committee::InvalidResponse) do
+        assert_schema_conform
+      end
+      assert_match /missing keys/i, e.message
+    end
+  end
+
+  private
+
+  def new_rack_app(response, headers={ "Content-Type" => "application/json" })
+    Rack::Builder.new {
+      run lambda { |_|
+        [200, headers, [response]]
+      }
+    }
+  end
+end

data/test/test_helper.rb

@@ -34,3 +34,15 @@ ValidApp = {
   "updated_at"                     => "2012-01-01T12:00:00Z",
   "web_url"                        => "http://example.herokuapp.com"
 }.freeze
+
+ValidAccount = {
+  "allow_tracking" => true,
+  "beta"           => true,
+  "created_at"     => "2012-01-01T12:00:00Z",
+  "email"          => "username@example.com",
+  "id"             => "01234567-89ab-cdef-0123-456789abcdef",
+  "last_login"     => "2012-01-01T12:00:00Z",
+  "updated_at"     => "2012-01-01T12:00:00Z",
+  "verified"       => true,
+  "flags"          => ["foo", "bar"]
+}.freeze

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: committee
 version: !ruby/object:Gem::Version
-  version: 0.4.2
+  version: 0.4.3
   prerelease: 
 platform: ruby
 authors:
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-02-06 00:00:00.000000000 Z
+date: 2014-04-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: multi_json
@@ -112,6 +112,8 @@ files:
 - lib/committee/response_validator.rb
 - lib/committee/router.rb
 - lib/committee/schema.rb
+- lib/committee/test/methods.rb
+- lib/committee/validation.rb
 - lib/committee.rb
 - test/middleware/request_validation_test.rb
 - test/middleware/response_validation_test.rb
@@ -122,6 +124,7 @@ files:
 - test/response_validator_test.rb
 - test/router_test.rb
 - test/schema_test.rb
+- test/test/methods_test.rb
 - test/test_helper.rb
 - bin/committee-stub
 homepage: https://github.com/heroku/rack-committee