improve(validation): array schema items (swagger-api#1765)

* add failing tests

* implement cross-version array schema validation

src/plugins/validate-semantic/index.js

@@ -16,6 +16,7 @@ import * as refsOAS3ValidateActions from "./validators/oas3/refs"
 import * as refs2and3ValidateActions from "./validators/2and3/refs"
 import * as parameters2and3ValidateActions from "./validators/2and3/parameters"
 import * as paths2and3ValidateActions from "./validators/2and3/paths"
+import * as schemas2and3ValidateActions from "./validators/2and3/schemas"
 
 export default function SemanticValidatorsPlugin({getSystem}) {
 
@@ -57,7 +58,8 @@ export default function SemanticValidatorsPlugin({getSystem}) {
           ...operationsOAS3ValidateActions,
           ...refsOAS3ValidateActions,
           ...parameters2and3ValidateActions,
-          ...paths2and3ValidateActions
+          ...paths2and3ValidateActions,
+          ...schemas2and3ValidateActions
         }
       },
     }

src/plugins/validate-semantic/selectors.js

@@ -60,6 +60,10 @@ export const isOAS3RequestBody = (state, node) => (sys) => {
 }
 
 export const isParameterSchema = (state, node) => (sys) => {
+  if(sys.specSelectors.isOAS3 && sys.specSelectors.isOAS3()) {
+    // OAS3
+    return node.key === "schema" && sys.validateSelectors.isParameter(node.parent)
+  }
   // parameter.x.in != body
   if(sys.validateSelectors.isParameter(node) && node.node.in !== "body") {
     return true

src/plugins/validate-semantic/validators/2and3/schemas.js

@@ -0,0 +1,24 @@
+export const validate2And3TypeArrayRequiresItems = () => (system) => {
+  return system.validateSelectors
+    .allSchemas()
+    .then(nodes => {
+      return nodes.reduce((acc, node) => {
+        const schemaObj = node.node
+        const { type, items } = schemaObj || {}
+        if(type === "array" && typeof items === "undefined") {
+          acc.push({
+            message: "Schemas with 'type: array', require a sibling 'items: ' field",
+            path: node.path,
+            level: "error",
+          })
+        } else if(type === "array" && (typeof items !== "object" || Array.isArray(items))) {
+          acc.push({
+            message: "`items` must be an object",
+            path: [...node.path, "items"],
+            level: "error",
+          })
+        }
+        return acc
+      }, [])
+    })
+}

src/plugins/validate-semantic/validators/schema.js

@@ -33,24 +33,6 @@ export const validateMinAndMax = () => (system) => {
     })
 }
 
-export const validateTypeArrayRequiresItems = () => (system) => {
-  return system.validateSelectors
-    .allSchemas()
-    .then(nodes => {
-      return nodes.reduce((acc, node) => {
-        const schemaObj = node.node
-        if(schemaObj.type === "array" && typeof schemaObj.items === "undefined") {
-          acc.push({
-            message: "Schemas with 'type: array', require a sibling 'items: ' field",
-            path: node.path,
-            level: "error",
-          })
-        }
-        return acc
-      }, [])
-    })
-}
-
 export const validateTypeKeyShouldBeString = () => (system) => {
   return system.validateSelectors
     .allSchemas()

test/plugins/validate-semantic/2and3/schemas.js

@@ -0,0 +1,171 @@
+import expect from "expect"
+import validateHelper from "../validate-helper.js"
+
+describe(`validation plugin - semantic - 2and3 schemas`, () => {
+  describe(`array schemas must have an Object value in "items"`, () => {
+    it("should return an error for an array items value in Swagger 2", () => {
+      const spec = {
+        swagger: "2.0",
+        "paths": {
+          "/pets": {
+            "get": {
+              "parameters": [
+                {
+                  name: "myParam",
+                  in: "query",
+                  type: "array",
+                  items: [{ type: "object" }]
+                }
+              ]
+            }
+          }
+        }
+      }
+
+      return validateHelper(spec)
+      .then(system => {
+        const allErrors = system.errSelectors.allErrors().toJS()
+        const firstError = allErrors[0]
+        expect(allErrors.length).toEqual(1)
+        expect(firstError.path).toEqual(["paths", "/pets", "get", "parameters", "0", "items"])
+        expect(firstError.message).toEqual("`items` must be an object")
+      })
+    })
+    it("should return an error for an array items value in OpenAPI 3", () => {
+      const spec = {
+        openapi: "3.0.0",
+        "paths": {
+          "/pets": {
+            "get": {
+              "parameters": [
+                {
+                  name: "myParam",
+                  in: "query",
+                  schema: {
+                    type: "array",
+                    items: [{ type: "object" }]
+                  }
+                },
+              ]
+            }
+          }
+        }
+      }
+
+      return validateHelper(spec)
+      .then(system => {
+        const allErrors = system.errSelectors.allErrors().toJS()
+        const firstError = allErrors[0]
+        expect(allErrors.length).toEqual(1)
+        expect(firstError.path).toEqual(["paths", "/pets", "get", "parameters", "0", "schema", "items"])
+        expect(firstError.message).toEqual("`items` must be an object")
+      })
+    })
+    it("should return an error for a missing items value for an array schema in Swagger 2", () => {
+      const spec = {
+        swagger: "2.0",
+        "paths": {
+          "/pets": {
+            "get": {
+              "parameters": [
+                {
+                  name: "myParam",
+                  in: "query",
+                  type: "array"
+                }
+              ]
+            }
+          }
+        }
+      }
+
+      return validateHelper(spec)
+      .then(system => {
+        const allErrors = system.errSelectors.allErrors().toJS()
+        const firstError = allErrors[0]
+        expect(allErrors.length).toEqual(1)
+        expect(firstError.message).toEqual("Schemas with 'type: array', require a sibling 'items: ' field")
+        expect(firstError.path).toEqual(["paths", "/pets", "get", "parameters", "0"])
+      })
+    })
+    it("should return an error for a missing items value for an array schema in OpenAPI 3", () => {
+      const spec = {
+        openapi: "3.0.0",
+        "paths": {
+          "/pets": {
+            "get": {
+              "parameters": [
+                {
+                  name: "myParam",
+                  in: "query",
+                  schema: {
+                    type: "array"
+                  }
+                },
+              ]
+            }
+          }
+        }
+      }
+
+      return validateHelper(spec)
+      .then(system => {
+        const allErrors = system.errSelectors.allErrors().toJS()
+        const firstError = allErrors[0]
+        expect(allErrors.length).toEqual(1)
+        expect(firstError.path).toEqual(["paths", "/pets", "get", "parameters", "0", "schema"])
+        expect(firstError.message).toEqual("Schemas with 'type: array', require a sibling 'items: ' field")
+      })
+    })
+    it("should not return an error for a missing items value for a non-array schema in Swagger 2", () => {
+      const spec = {
+        swagger: "2.0",
+        "paths": {
+          "/pets": {
+            "get": {
+              "parameters": [
+                {
+                  name: "myParam",
+                  in: "query",
+                  type: "object"
+                }
+              ]
+            }
+          }
+        }
+      }
+
+      return validateHelper(spec)
+      .then(system => {
+        const allErrors = system.errSelectors.allErrors().toJS()
+        expect(allErrors.length).toEqual(0)
+      })
+    })
+    it("should not return an error for a missing items value for a non-array schema in OpenAPI 3", () => {
+      const spec = {
+        openapi: "3.0.0",
+        "paths": {
+          "/pets": {
+            "get": {
+              "parameters": [
+                {
+                  name: "myParam",
+                  in: "query",
+                  schema: {
+                    type: "object"
+                  }
+                },
+              ]
+            }
+          }
+        }
+      }
+
+      return validateHelper(spec)
+      .then(system => {
+        const allErrors = system.errSelectors.allErrors().toJS()
+        expect(allErrors.length).toEqual(0)
+      })
+    })
+  })
+})