committee 1.15.0 → 2.0.0.pre

data/test/middleware/response_validation_test.rb

@@ -8,26 +8,34 @@ describe Committee::Middleware::ResponseValidation do
   end
 
   it "passes through a valid response" do
-    @app = new_rack_app(JSON.generate([ValidApp]))
+    @app = new_rack_app(JSON.generate([ValidApp]), {}, schema: hyper_schema)
     get "/apps"
     assert_equal 200, last_response.status
   end
 
-  it "detects an invalid response" do
-    @app = new_rack_app("")
+  it "detects a response invalid due to schema" do
+    @app = new_rack_app("{}", {}, schema: hyper_schema)
+    get "/apps"
+    assert_equal 500, last_response.status
+    assert_match /{} is not an array/i, last_response.body
+  end
+
+  it "detects a response invalid due to not being JSON" do
+    @app = new_rack_app("", {}, schema: hyper_schema)
     get "/apps"
     assert_equal 500, last_response.status
     assert_match /valid JSON/i, last_response.body
   end
 
   it "ignores a non-2xx invalid response" do
-    @app = new_rack_app("[]", {}, app_status: 404)
+    @app = new_rack_app("[]", {}, app_status: 404, schema: hyper_schema)
     get "/apps"
     assert_equal 404, last_response.status
   end
 
   it "optionally validates non-2xx invalid responses" do
-    @app = new_rack_app("", {}, {app_status: 404, validate_errors: true})
+    @app = new_rack_app("", {}, app_status: 404, validate_errors: true,
+      schema: hyper_schema)
 
     get "/apps"
     assert_equal 500, last_response.status
@@ -35,48 +43,52 @@ describe Committee::Middleware::ResponseValidation do
   end
 
   it "passes through a 204 (no content) response" do
-    @app = new_rack_app("", {}, app_status: 204)
+    @app = new_rack_app("", {}, app_status: 204, schema: hyper_schema)
     get "/apps"
     assert_equal 204, last_response.status
   end
 
   it "rescues JSON errors" do
-    @app = new_rack_app("[{x:y}]")
+    @app = new_rack_app("[{x:y}]", {}, schema: hyper_schema)
     get "/apps"
     assert_equal 500, last_response.status
     assert_match /valid json/i, last_response.body
   end
 
   it "takes a prefix" do
-    @app = new_rack_app(JSON.generate([ValidApp]), {}, prefix: "/v1")
+    @app = new_rack_app(JSON.generate([ValidApp]), {}, prefix: "/v1",
+      schema: hyper_schema)
     get "/v1/apps"
     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(JSON.generate([ValidApp]), {},
-      schema: File.read("./test/data/schema.json"))
-    get "/apps"
-    assert_equal 200, last_response.status
-  end
-
   it "rescues JSON errors" do
-    @app = new_rack_app("[{x:y}]", {}, raise: true)
+    @app = new_rack_app("[{x:y}]", {}, raise: true, schema: hyper_schema)
     assert_raises(Committee::InvalidResponse) do
       get "/apps"
     end
   end
 
+  it "passes through a valid response for OpenAPI" do
+    @app = new_rack_app(JSON.generate([ValidPet]), {},
+      schema: open_api_2_schema)
+    get "/api/pets"
+    assert_equal 200, last_response.status
+  end
+
+  it "detects an invalid response for OpenAPI" do
+    @app = new_rack_app("", {}, schema: open_api_2_schema)
+    get "/api/pets"
+    assert_equal 500, last_response.status
+    assert_match /valid JSON/i, last_response.body
+  end
+
   private
 
   def new_rack_app(response, headers = {}, options = {})
     headers = {
       "Content-Type" => "application/json"
     }.merge(headers)
-    options = {
-      schema: JSON.parse(File.read("./test/data/schema.json"))
-    }.merge(options)
     Rack::Builder.new {
       use Committee::Middleware::ResponseValidation, options
       run lambda { |_|

data/test/middleware/stub_test.rb

@@ -8,7 +8,7 @@ describe Committee::Middleware::Stub do
   end
 
   it "responds with a stubbed response" do
-    @app = new_rack_app
+    @app = new_rack_app(schema: hyper_schema)
     get "/apps/heroku-api"
     assert_equal 200, last_response.status
     data = JSON.parse(last_response.body)
@@ -16,13 +16,13 @@ describe Committee::Middleware::Stub do
   end
 
   it "responds with 201 on create actions" do
-    @app = new_rack_app
+    @app = new_rack_app(schema: hyper_schema)
     post "/apps"
     assert_equal 201, last_response.status
   end
 
   it "optionally calls into application" do
-    @app = new_rack_app(call: true)
+    @app = new_rack_app(call: true, schema: hyper_schema)
     get "/apps/heroku-api"
     assert_equal 200, last_response.status
     assert_equal ValidApp,
@@ -30,37 +30,61 @@ describe Committee::Middleware::Stub do
   end
 
   it "optionally returns the application's response" do
-    @app = new_rack_app(call: true, suppress: true)
+    @app = new_rack_app(call: true, schema: hyper_schema, suppress: true)
     get "/apps/heroku-api"
     assert_equal 429, last_response.status
     assert_equal ValidApp,
       JSON.parse(last_response.headers["Committee-Response"])
-      assert_equal "", last_response.body
+    assert_equal "", last_response.body
   end
 
   it "takes a prefix" do
-    @app = new_rack_app(prefix: "/v1")
+    @app = new_rack_app(prefix: "/v1", schema: hyper_schema)
     get "/v1/apps/heroku-api"
     assert_equal 200, last_response.status
     data = JSON.parse(last_response.body)
     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"))
+  it "allows the stub's response to be replaced" do
+    response = { replaced: true }
+    @app = new_rack_app(call: true, response: response, schema: hyper_schema)
     get "/apps/heroku-api"
     assert_equal 200, last_response.status
+    assert_equal response, JSON.parse(last_response.body, symbolize_names: true)
+  end
+
+  it "responds with a stubbed response for OpenAPI" do
+    @app = new_rack_app(schema: open_api_2_schema)
+    get "/api/pets/fido"
+    assert_equal 200, last_response.status
     data = JSON.parse(last_response.body)
-    assert_equal ValidApp.keys.sort, data.keys.sort
+    assert_equal ValidPet.keys.sort, data.keys.sort
   end
 
-  it "allows the stub's response to be replaced" do
-    response = { replaced: true }
-    @app = new_rack_app(call: true, response: response)
+  it "calls into app for links that are undefined" do
+    @app = new_rack_app(call: false, schema: hyper_schema)
+    post "/foos"
+    assert_equal 429, last_response.status
+  end
+
+  it "caches the response if called multiple times" do
+    cache = {}
+    @app = new_rack_app(cache: cache, schema: hyper_schema)
+
     get "/apps/heroku-api"
     assert_equal 200, last_response.status
-    assert_equal response, JSON.parse(last_response.body, symbolize_names: true)
+
+    data = cache[cache.first[0]]
+    assert_equal ValidApp.keys.sort, data.keys.sort
+
+    # replace what we have in the cache
+    cache[cache.first[0]] = { "cached" => true }
+
+    get "/apps/heroku-api"
+    assert_equal 200, last_response.status
+    data = JSON.parse(last_response.body)
+    assert_equal({ "cached" => true }, data)
   end
 
   private
@@ -68,15 +92,22 @@ describe Committee::Middleware::Stub do
   def new_rack_app(options = {})
     response = options.delete(:response)
     suppress = options.delete(:suppress)
-    options = {
-      schema: JSON.parse(File.read("./test/data/schema.json"))
-    }.merge(options)
     Rack::Builder.new {
       use Committee::Middleware::Stub, options
       run lambda { |env|
-        env["committee.response"] = response if response
-        headers = { "Committee-Response" => JSON.generate(env["committee.response"]) }
+        if response
+          env["committee.response"] = response
+        end
+
+        headers = {}
+        if res = env["committee.response"]
+          headers.merge!({
+            "Committee-Response" => JSON.generate(res)
+          })
+        end
+
         env["committee.suppress"] = suppress
+
         [429, headers, []]
       }
     }

data/test/request_unpacker_test.rb

@@ -123,4 +123,14 @@ describe Committee::RequestUnpacker do
     params = Committee::RequestUnpacker.new(request).call
     assert_equal({}, params)
   end
+
+  # this is mostly here for line coverage
+  it "unpacks JSON containing an array" do
+    env = {
+      "rack.input" => StringIO.new('{"x":[]}'),
+    }
+    request = Rack::Request.new(env)
+    params = Committee::RequestUnpacker.new(request).call
+    assert_equal({ "x" => [] }, params)
+  end
 end

data/test/request_validator_test.rb

@@ -4,8 +4,7 @@ require "stringio"
 
 describe Committee::RequestValidator do
   before do
-    @schema =
-      JsonSchema.parse!(JSON.parse(File.read("./test/data/schema.json")))
+    @schema = JsonSchema.parse!(hyper_schema_data)
     @schema.expand_references!
     # POST /apps/:id
     @link = @link = @schema.properties["app"].links[0]
@@ -98,6 +97,8 @@ describe Committee::RequestValidator do
   private
 
   def call(data, options={})
-    Committee::RequestValidator.new(@link, options).call(@request, data)
+    # hyper-schema link should be dropped into driver wrapper before it's used
+    link = Committee::Drivers::HyperSchema::Link.new(@link)
+    Committee::RequestValidator.new(link, options).call(@request, data)
   end
 end

data/test/response_generator_test.rb

@@ -2,8 +2,7 @@ require_relative "test_helper"
 
 describe Committee::ResponseGenerator do
   before do
-    @schema =
-      JsonSchema.parse!(JSON.parse(File.read("./test/data/schema.json")))
+    @schema = JsonSchema.parse!(hyper_schema_data)
     @schema.expand_references!
     # GET /apps/:id
     @get_link = @link = @schema.properties["app"].links[2]
@@ -23,16 +22,26 @@ describe Committee::ResponseGenerator do
 
   it "wraps list data in an array" do
     @link = @list_link
+
+    @link.rel = nil
+
     data = call
     assert data.is_a?(Array)
   end
 
-  it "wraps list data in an array" do
+  it "wraps list data tagged with rel 'instances' in an array" do
     @link = @list_link
 
-    @link.rel = nil
+    # forces the link to use `parent`
+    @link.target_schema = nil
 
     data = call
+
+    # We're testing for legacy behavior here: even without a `targetSchema` as
+    # long as `rel` is set to `instances` we still wrap the the result in an
+    # array.
+    assert_equal "instances", @list_link.rel
+
     assert data.is_a?(Array)
   end
 
@@ -49,13 +58,48 @@ describe Committee::ResponseGenerator do
     end
 
     expected = <<-eos.gsub(/\n +/, "").strip
-      At "#/definitions/app/properties/maintenance": no "example" attribute and 
+      At "get /apps/{(%23%2Fdefinitions%2Fapp%2Fdefinitions%2Fname)}" 
+      "#/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
 
+  it "generates basic types" do
+    link = Committee::Drivers::OpenAPI2::Link.new
+    link.target_schema = JsonSchema::Schema.new
+
+    link.target_schema.type = ["integer"]
+    assert_equal 0, Committee::ResponseGenerator.new.call(link)
+
+    link.target_schema.type = ["null"]
+    assert_equal nil, Committee::ResponseGenerator.new.call(link)
+
+    link.target_schema.type = ["string"]
+    assert_equal "", Committee::ResponseGenerator.new.call(link)
+  end
+
+  it "prefers an example to a built-in value" do
+    link = Committee::Drivers::OpenAPI2::Link.new
+    link.target_schema = JsonSchema::Schema.new
+
+    link.target_schema.data = { "example" => 123 }
+    link.target_schema.type = ["integer"]
+
+    assert_equal 123, Committee::ResponseGenerator.new.call(link)
+  end
+
+  it "prefers non-null types to null types" do
+    link = Committee::Drivers::OpenAPI2::Link.new
+    link.target_schema = JsonSchema::Schema.new
+
+    link.target_schema.type = ["null", "integer"]
+    assert_equal 0, Committee::ResponseGenerator.new.call(link)
+  end
+
   def call
-    Committee::ResponseGenerator.new.call(@link)
+    # hyper-schema link should be dropped into driver wrapper before it's used
+    link = Committee::Drivers::HyperSchema::Link.new(@link)
+    Committee::ResponseGenerator.new.call(link)
   end
 end

data/test/response_validator_test.rb

@@ -7,8 +7,7 @@ describe Committee::ResponseValidator do
       "Content-Type" => "application/json"
     }
     @data = ValidApp.dup
-    @schema =
-      JsonSchema.parse!(JSON.parse(File.read("./test/data/schema.json")))
+    @schema = JsonSchema.parse!(hyper_schema_data)
     @schema.expand_references!
     # GET /apps/:id
     @get_link = @link = @schema.properties["app"].links[2]
@@ -37,9 +36,33 @@ describe Committee::ResponseValidator do
     call
   end
 
-  it "detects an improperly formatted list response" do
+  it "passes through a valid list response for for rel instances links" do
     @link = @list_link
+
+    # forces the link to use `parent`
     @link.target_schema = nil
+
+    # We're testing for legacy behavior here: even without a `targetSchema` as
+    # long as `rel` is set to `instances` we still wrap the the result in an
+    # array.
+    assert_equal "instances", @link.rel
+
+    @data = [@data]
+    @link = @list_link
+    call
+  end
+
+  it "detects an improperly formatted list response for rel instances link" do
+    @link = @list_link
+
+    # forces the link to use `parent`
+    @link.target_schema = nil
+
+    # We're testing for legacy behavior here: even without a `targetSchema` as
+    # long as `rel` is set to `instances` we still wrap the the result in an
+    # array.
+    assert_equal "instances", @link.rel
+
     e = assert_raises(Committee::InvalidResponse) { call }
     message = "List endpoints must return an array of objects."
     assert_equal message, e.message
@@ -76,6 +99,8 @@ describe Committee::ResponseValidator do
   private
 
   def call
-    Committee::ResponseValidator.new(@link).call(@status, @headers, @data)
+    # hyper-schema link should be dropped into driver wrapper before it's used
+    link = Committee::Drivers::HyperSchema::Link.new(@link)
+    Committee::ResponseValidator.new(link).call(@status, @headers, @data)
   end
 end

data/test/router_test.rb

@@ -2,37 +2,64 @@ require_relative "test_helper"
 
 describe Committee::Router do
   it "builds routes without parameters" do
-    refute_nil router.find_link("GET", "/apps")
+    link, _ = hyper_schema_router.find_link("GET", "/apps")
+    refute_nil link
   end
 
   it "builds routes with parameters" do
-    refute_nil router.find_link("GET", "/apps/123")
+    link, _ = hyper_schema_router.find_link("GET", "/apps/123")
+    refute_nil link
   end
 
   it "doesn't match anything on a /" do
-    assert_nil router.find_link("GET", "/")
+    link, _ = hyper_schema_router.find_link("GET", "/")
+    assert_nil link
   end
 
   it "takes a prefix" do
     # this is a sociopathic example
-    assert router(prefix: "/kpi").find_link("GET", "/kpi/apps/123")
+    link, _ = hyper_schema_router(prefix: "/kpi").find_link("GET", "/kpi/apps/123")
+    refute_nil link
   end
 
   it "includes all paths without a prefix" do
-    assert router.includes?("/")
-    assert router.includes?("/apps")
+    link, _ = hyper_schema_router.includes?("/")
+    refute_nil link
+
+    link, _ = hyper_schema_router.includes?("/apps")
+    refute_nil link
   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")
+    link, _ = hyper_schema_router(prefix: "/kpi").includes?("/")
+    assert_nil link
+
+    link, _ = hyper_schema_router(prefix: "/kpi").includes?("/kpi")
+    refute_nil link
+
+    link, _ = hyper_schema_router(prefix: "/kpi").includes?("/kpi/apps")
+    refute_nil link
+  end
+
+  it "provides named parameters" do
+    link, param_matches = open_api_2_router.find_link("GET", "/api/pets/fido")
+    refute_nil link
+    assert_equal({ "id" => "fido" }, param_matches)
+  end
+
+  it "doesn't provide named parameters where none are available" do
+    link, param_matches = open_api_2_router.find_link("GET", "/api/pets")
+    refute_nil link
+    assert_equal({}, param_matches)
+  end
+
+  def hyper_schema_router(options = {})
+    schema = Committee::Drivers::HyperSchema.new.parse(hyper_schema_data)
+    Committee::Router.new(schema, options)
   end
 
-  def router(options = {})
-    data = JSON.parse(File.read("./test/data/schema.json"))
-    schema = JsonSchema.parse!(data)
-    schema.expand_references!
+  def open_api_2_router(options = {})
+    schema = Committee::Drivers::OpenAPI2.new.parse(open_api_2_data)
     Committee::Router.new(schema, options)
   end
 end

data/test/{query_params_coercer_test.rb → string_params_coercer_test.rb}

@@ -1,9 +1,8 @@
 require_relative "test_helper"
 
-describe Committee::QueryParamsCoercer do
+describe Committee::StringParamsCoercer do
   before do
-    @schema =
-      JsonSchema.parse!(JSON.parse(File.read("./test/data/schema.json")))
+    @schema = JsonSchema.parse!(hyper_schema_data)
     @schema.expand_references!
     # GET /search/apps
     @link = @link = @schema.properties["app"].links[5]
@@ -65,6 +64,6 @@ describe Committee::QueryParamsCoercer do
   private
 
   def call(data)
-    Committee::QueryParamsCoercer.new(data, @link.schema).call
+    Committee::StringParamsCoercer.new(data, @link.schema).call
   end
 end

data/test/test/methods_test.rb

@@ -1,6 +1,6 @@
 require_relative "../test_helper"
 
-describe Committee::Middleware::Stub do
+describe Committee::Test::Methods do
   include Committee::Test::Methods
   include Rack::Test::Methods
 
@@ -8,8 +8,16 @@ describe Committee::Middleware::Stub do
     @app
   end
 
-  def schema_path
-    "./test/data/schema.json"
+  def committee_schema
+    hyper_schema
+  end
+
+  before do
+    # This is a little icky, but the test methods will cache router and schema
+    # values between tests. This makes sense in real life, but is harmful for
+    # our purposes here in testing the module.
+    @committee_router = nil
+    @committee_schema = nil
   end
 
   describe "#assert_schema_content_type" do
@@ -35,9 +43,40 @@ describe Committee::Middleware::Stub do
       assert_match /response header must be set to/i, e.message
     end
 
-    it "warns when sending a deprecated string" do
-      stub(self).schema_contents { File.read(schema_path) }
+    it "accepts schema string (legacy behavior)" do
+      mock(Committee).warn_deprecated.with_any_args
+
+      stub(self).committee_schema { nil }
+      stub(self).schema_contents { JSON.dump(hyper_schema_data) }
+
+      @app = new_rack_app(JSON.generate([ValidApp]))
+      get "/apps"
+      assert_schema_conform
+    end
+
+    it "accepts schema hash (legacy behavior)" do
       mock(Committee).warn_deprecated.with_any_args
+
+      stub(self).committee_schema { nil }
+      stub(self).schema_contents { hyper_schema_data }
+
+      @app = new_rack_app(JSON.generate([ValidApp]))
+      get "/apps"
+      assert_schema_conform
+    end
+
+    it "accepts schema JsonSchema::Schema object (legacy behavior)" do
+      # Note we don't warn here because this is a recent deprecation and
+      # passing a schema object will not be a huge performance hit. We should
+      # probably start warning on the next version.
+
+      stub(self).committee_schema { nil }
+      stub(self).schema_contents do
+        schema = JsonSchema.parse!(hyper_schema_data)
+        schema.expand_references!
+        schema
+      end
+
       @app = new_rack_app(JSON.generate([ValidApp]))
       get "/apps"
       assert_schema_conform

data/test/test_helper.rb

@@ -1,13 +1,71 @@
+if RUBY_VERSION >= '2.0.0'
+  require 'simplecov'
+
+  SimpleCov.start do
+    # We do our utmost to test our executables by modularizing them into
+    # testable pieces, but testing them to completion is nearly impossible as
+    # far as I can tell, so include them in our tests but don't calculate
+    # coverage.
+    add_filter "/bin/"
+
+    add_filter "/test/"
+
+    # This library has a pretty modest number of lines, so let's try to stick
+    # to a 100% coverage target for a while and see what happens.
+    minimum_coverage 100
+  end
+end
+
 require "minitest"
 require "minitest/spec"
 require "minitest/autorun"
-#require "pry-rescue/minitest"
 require "rack/test"
 require "rr"
 
 require_relative "../lib/committee"
 
+# The OpenAPI sample specification provided directly from the organization uses
+# a couple custom "format" values for JSON schema, namely "int32" and "int64".
+# Provide basic definitions for them here so that we don't error when trying to
+# parse the sample.
+JsonSchema.configure do |c|
+  c.register_format 'int32', ->(data) {}
+  c.register_format 'int64', ->(data) {}
+end
+
+# For our hyper-schema example.
 ValidApp = {
   "maintenance" => false,
   "name"        => "example",
 }.freeze
+
+# For our OpenAPI example.
+ValidPet = {
+  "id"   => 123,
+  "name" => "example",
+  "tag"  => "tag-123",
+}.freeze
+
+def hyper_schema
+  @hyper_schema ||= begin
+    driver = Committee::Drivers::HyperSchema.new
+    driver.parse(hyper_schema_data)
+  end
+end
+
+def open_api_2_schema
+  @open_api_2_schema ||= begin
+    driver = Committee::Drivers::OpenAPI2.new
+    driver.parse(open_api_2_data)
+  end
+end
+
+# Don't cache this because we'll often manipulate the created hash in tests.
+def hyper_schema_data
+  JSON.parse(File.read("./test/data/hyperschema/paas.json"))
+end
+
+# Don't cache this because we'll often manipulate the created hash in tests.
+def open_api_2_data
+  JSON.parse(File.read("./test/data/openapi2/petstore-expanded.json"))
+end