committee 2.0.0.pre → 2.0.0.pre2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 5911eb64b8a07bb45eaf264399bebeb95ea2395b
-  data.tar.gz: 35d800d2dd5cd0c3d402b26813d7b156f0809006
+  metadata.gz: c27dbbfbcb3d316bd61c7056fe0a8f7fec175ab6
+  data.tar.gz: c3ad5a80a63987ae2f94988ed12b1285e71ee760
 SHA512:
-  metadata.gz: 86c361cc0bd1f4d0e340335402ab452b99a0c0d0eae814aa3296794ed0a076177f9dc3ebc772ae95a66afbe45efcbeccc77e2851ef3a0e385171fc549e31092c
-  data.tar.gz: 306a67c72463d3879dd7fb4e9aff88a17d34e54d83c209a439cabc47b912027178c5d23fc9b5270cc6b0f9d65d4957f152ec630c7e3484931bba1bda46ed4bd0
+  metadata.gz: 86f1c3e718e6dee210e3c42ba2d1a5ba0b029137adc1be572d5dac9d6048dc7c84cf4274a652360473b9e263662912f5a7a94fc27b2666daf054530f0b44c40f
+  data.tar.gz: 6dd6d2dc9165ea38e3df05a0d35915809a82447a5708728c192d22ee632692448f6e4996733c165c8f0d6f4895dff7bfa18b952c070b2a8bb1e01d21073ad7c7

data/lib/committee/bin/committee_stub.rb

@@ -6,13 +6,15 @@ module Committee
     class CommitteeStub
       # Gets a Rack app suitable for use as a stub.
       def get_app(schema, options)
+        cache = {}
+
         Rack::Builder.new {
           unless options[:tolerant]
             use Committee::Middleware::RequestValidation, schema: schema
             use Committee::Middleware::ResponseValidation, schema: schema
           end
 
-          use Committee::Middleware::Stub, schema: schema
+          use Committee::Middleware::Stub, cache: cache, schema: schema
 
           run lambda { |_|
             [404, {}, ["Not found"]]
@@ -53,9 +55,6 @@ module Committee
         end
         [options, parser]
       end
-
-      def get_schema(driver_name, data)
-      end
     end
   end
 end

data/lib/committee/drivers/open_api_2.rb

@@ -89,43 +89,54 @@ module Committee::Drivers
         self.link_data = link_data
       end
 
+      # Returns a tuple of (schema, schema_data) where only one of the two
+      # values is present. This is either a full schema that's ready to go _or_
+      # a hash of unparsed schema data.
       def call
-        link_schema = JsonSchema::Schema.new
-        link_schema.properties = {}
-        link_schema.required = []
-
         if link_data["parameters"]
-          link_data["parameters"].each do |param_data|
-            LINK_REQUIRED_FIELDS.each do |field|
-              if !param_data[field]
-                raise ArgumentError,
-                  "Committee: no #{field} section in link data."
-              end
-            end
+          body_param = link_data["parameters"].detect { |p| p["in"] == "body" }
+          if body_param
+            check_required_fields!(body_param)
 
-            param_schema = JsonSchema::Schema.new
+            if link_data["parameters"].detect { |p| p["in"] == "form" } != nil
+              raise ArgumentError, "Committee: can't mix body parameter " \
+                "with form parameters."
+            end
 
-            # We could probably use more validation here, but the formats of
-            # OpenAPI 2 are based off of what's available in JSON schema, and
-            # therefore this should map over quite well.
-            param_schema.type = [param_data["type"]]
+            schema_data = body_param["schema"]
+            [nil, schema_data]
+          else
+            link_schema = JsonSchema::Schema.new
+            link_schema.properties = {}
+            link_schema.required = []
+
+            link_data["parameters"].each do |param_data|
+              check_required_fields!(param_data)
+
+              param_schema = JsonSchema::Schema.new
+
+              # We could probably use more validation here, but the formats of
+              # OpenAPI 2 are based off of what's available in JSON schema, and
+              # therefore this should map over quite well.
+              param_schema.type = [param_data["type"]]
+
+              # And same idea: despite parameters not being schemas, the items
+              # key (if preset) is actually a schema that defines each item of an
+              # array type, so we can just reflect that directly onto our
+              # artifical schema.
+              if param_data["type"] == "array" && param_data["items"]
+                param_schema.items = param_data["items"]
+              end
 
-            # And same idea: despite parameters not being schemas, the items
-            # key (if preset) is actually a schema that defines each item of an
-            # array type, so we can just reflect that directly onto our
-            # artifical schema.
-            if param_data["type"] == "array" && param_data["items"]
-              param_schema.items = param_data["items"]
+              link_schema.properties[param_data["name"]] = param_schema
+              if param_data["required"] == true
+                link_schema.required << param_data["name"]
+              end
             end
 
-            link_schema.properties[param_data["name"]] = param_schema
-            if param_data["required"] == true
-              link_schema.required << param_data["name"]
-            end
+            [link_schema, nil]
           end
         end
-
-        link_schema
       end
 
       private
@@ -135,6 +146,15 @@ module Committee::Drivers
       ].map(&:to_s).freeze
 
       attr_accessor :link_data
+
+      def check_required_fields!(param_data)
+        LINK_REQUIRED_FIELDS.each do |field|
+          if !param_data[field]
+            raise ArgumentError,
+              "Committee: no #{field} section in link data."
+          end
+        end
+      end
     end
 
     class Schema < Committee::Drivers::Schema
@@ -219,10 +239,14 @@ module Committee::Drivers
       # all schemas into one big hash and then parse it all at the end. After
       # we parse it, go through each link and assign a proper schema object. In
       # practice this comes out to somewhere on the order of 50x faster.
+      schemas_data = { "properties" => {} }
+
+      # Exactly the same idea, but for response schemas.
       target_schemas_data = { "properties" => {} }
 
       data['paths'].each do |path, methods|
         href = schema.base_path + path
+        schemas_data["properties"][href] = { "properties" => {} }
         target_schemas_data["properties"][href] = { "properties" => {} }
 
         methods.each do |method, link_data|
@@ -236,7 +260,14 @@ module Committee::Drivers
 
           # Convert the spec's parameter pseudo-schemas into JSON schemas that
           # we can use for some basic request validation.
-          link.schema = ParameterSchemaBuilder.new(link_data).call
+          link.schema, schema_data = ParameterSchemaBuilder.new(link_data).call
+
+          # If data came back instead of a schema (this occurs when a route has
+          # a single `body` parameter instead of a collection of URL/query/form
+          # parameters), store it for later parsing.
+          if schema_data
+            schemas_data["properties"][href]["properties"][method] = schema_data
+          end
 
           # Arbitrarily pick one response for the time being. Prefers in order:
           # a 200, 201, any 3-digit numerical response, then anything at all.
@@ -263,15 +294,25 @@ module Committee::Drivers
       # #parse_definitions!, but what we're doing here is prefixing references
       # with a specialized internal URI so that they can reference definitions
       # from another document in the store.
-      target_schemas = rewrite_references(target_schemas_data)
-
-      target_schemas = JsonSchema.parse!(target_schemas)
-      target_schemas.expand_references!(store: store)
+      schemas =
+        rewrite_references_and_parse(schemas_data, store)
+      target_schemas =
+        rewrite_references_and_parse(target_schemas_data, store)
 
       # As noted above, now that we've parsed our aggregate response schema, go
       # back through each link and them their response schema.
       routes.each do |method, method_routes|
         method_routes.each do |(_, link)|
+          # request
+          #
+          # Differs slightly from responses in that the schema may already have
+          # been set for endpoints with non-body parameters, so check for nil
+          # before we set it.
+          if schema = schemas.properties[link.href].properties[method]
+            link.schema = schema
+          end
+
+          # response
           link.target_schema =
             target_schemas.properties[link.href].properties[method]
         end
@@ -280,6 +321,13 @@ module Committee::Drivers
       routes
     end
 
+    def rewrite_references_and_parse(schemas_data, store)
+      schemas = rewrite_references(schemas_data)
+      schemas = JsonSchema.parse!(schemas_data)
+      schemas.expand_references!(:store => store)
+      schemas
+    end
+
     def rewrite_references(schema)
       if schema.is_a?(Hash)
         ref = schema["$ref"]

data/test/drivers/open_api_2_test.rb

@@ -197,8 +197,9 @@ describe Committee::Drivers::OpenAPI2::ParameterSchemaBuilder do
         }
       ]
     }
-    schema = call(data)
+    schema, schema_data = call(data)
 
+    assert_equal nil, schema_data
     assert_equal ["limit"], schema.properties.keys
     assert_equal [], schema.required
     assert_equal ["integer"], schema.properties["limit"].type
@@ -213,8 +214,9 @@ describe Committee::Drivers::OpenAPI2::ParameterSchemaBuilder do
         }
       ]
     }
-    schema = call(data)
+    schema, schema_data = call(data)
 
+    assert_equal nil, schema_data
     assert_equal ["limit"], schema.required
   end
 
@@ -230,12 +232,31 @@ describe Committee::Drivers::OpenAPI2::ParameterSchemaBuilder do
         }
       ]
     }
-    schema = call(data)
+    schema, schema_data = call(data)
 
+    assert_equal nil, schema_data
     assert_equal ["array"], schema.properties["tags"].type
     assert_equal({ "type" => "string" }, schema.properties["tags"].items)
   end
 
+  it "returns schema data for a body parameter" do
+    data = {
+      "parameters" => [
+        {
+          "name" => "payload",
+          "in" => "body",
+          "schema" => {
+            "$ref" => "#/definitions/foo",
+          }
+        }
+      ]
+    }
+    schema, schema_data = call(data)
+
+    assert_equal nil, schema
+    assert_equal({ "$ref" => "#/definitions/foo" }, schema_data)
+  end
+
   it "requires that certain fields are present" do
     data = {
       "parameters" => [
@@ -249,6 +270,26 @@ describe Committee::Drivers::OpenAPI2::ParameterSchemaBuilder do
     assert_equal "Committee: no name section in link data.", e.message
   end
 
+  it "requires that body parameters not be mixed with form parameters" do
+    data = {
+      "parameters" => [
+        {
+          "name" => "payload",
+          "in" => "body",
+        },
+        {
+          "name" => "limit",
+          "in" => "form",
+        },
+      ]
+    }
+    e = assert_raises ArgumentError do
+      call(data)
+    end
+    assert_equal "Committee: can't mix body parameter with form parameters.",
+      e.message
+  end
+
   def call(data)
     Committee::Drivers::OpenAPI2::ParameterSchemaBuilder.new(data).call
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: committee
 version: !ruby/object:Gem::Version
-  version: 2.0.0.pre
+  version: 2.0.0.pre2
 platform: ruby
 authors:
 - Brandur
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-10-10 00:00:00.000000000 Z
+date: 2016-10-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: json_schema