fix(semval): add $ref location existential validator (#1705)

* tests: add failing cases
* fix(semval): add $ref location existential validator
* meta: words are hard
* tests: add control-case tests for remote references

Author: shockey

package.json

@@ -48,6 +48,7 @@
     "immutable": "^3.x.x",
     "js-yaml": "^3.5.5",
     "json-beautify": "^1.0.1",
+    "json-refs": "^3.0.4",
     "prop-types": "15.6.0",
     "react": "^15.6.2",
     "react-addons-css-transition-group": "^15.4.2",

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

@@ -1,5 +1,6 @@
 import get from "lodash/get"
 import { escapeJsonPointerToken } from "../../../refs-util"
+import { pathFromPtr } from "json-refs"
 
 export const validate2And3RefHasNoSiblings = () => system => {
   return system.validateSelectors.all$refs()
@@ -66,7 +67,6 @@ export const validate2And3RefPathFormatting = () => (system) => {
 
         if(refPath && refPath[0] !== "/") {
           errors.push({
-            // $ref instead of $$ref
             path: [...node.path.slice(0, -1), "$ref"],
             message: "$ref paths must begin with `#/`",
             level: "error"
@@ -78,3 +78,29 @@ export const validate2And3RefPathFormatting = () => (system) => {
     return errors
   })
 }
+
+export const validate2And3RefPointersExist = () => (system) => {
+  const json = system.specSelectors.specJson()
+  return system.validateSelectors.all$refs()
+  .then((refs) => {
+    const errors = []
+
+    refs.forEach((node) => {
+      const value = node.node
+      if(typeof value === "string" && value[0] === "#") {
+        // if pointer starts with "#", it is a local ref
+        const path = pathFromPtr(value)
+
+        if(json.getIn(path) === undefined) {
+          errors.push({
+            path: [...node.path.slice(0, -1), "$ref"],
+            message: "$refs must reference a valid location in the document",
+            level: "error"
+          })
+        }
+      }
+    })
+
+    return errors
+  })
+}

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

@@ -342,4 +342,147 @@ describe("validation plugin - semantic - 2and3 refs", function() {
     })
 
   })
+  describe("Nonexistent $ref pointers", () => {
+    it("should return an error when a local JSON pointer does not exist in Swagger 2", () => {
+      const spec = {
+        swagger: "2.0",
+        paths: {
+          "/CoolPath": {
+            $ref: "#/myObj/DoesNotExist"
+          }
+        },
+        myObj: {
+          abc: {
+            type: "string"
+          }
+        }
+      }
+
+      return validateHelper(spec)
+      .then(system => {
+        const allErrors = system.errSelectors.allErrors().toJS()
+        expect(allErrors.length).toEqual(1)
+        const firstError = allErrors[0]
+        expect(firstError.message).toMatch("$refs must reference a valid location in the document")
+        expect(firstError.level).toEqual("error")
+        expect(firstError.path).toEqual(["paths", "/CoolPath", "$ref"])
+      })
+    })
+    it("should return an error when a local JSON pointer does not exist in OpenAPI 3", () => {
+      const spec = {
+        openapi: "3.0.0",
+        paths: {
+          "/CoolPath": {
+            $ref: "#/myObj/DoesNotExist"
+          }
+        },
+        myObj: {
+          abc: {
+            type: "string"
+          }
+        }
+      }
+
+      return validateHelper(spec)
+      .then(system => {
+        const allErrors = system.errSelectors.allErrors().toJS()
+        expect(allErrors.length).toEqual(1)
+        const firstError = allErrors[0]
+        expect(firstError.message).toMatch("$refs must reference a valid location in the document")
+        expect(firstError.level).toEqual("error")
+        expect(firstError.path).toEqual(["paths", "/CoolPath", "$ref"])
+      })
+    })
+    it("should return no errors when a JSON pointer exists in Swagger 2", () => {
+      const spec = {
+        swagger: "2.0",
+        paths: {
+          "/CoolPath": {
+            $ref: "#/myObj/abc"
+          },
+        },
+        myObj: {
+          abc: {
+            type: "string"
+          }
+        }
+      }
+
+      return validateHelper(spec)
+      .then(system => {
+        const allSemanticErrors = system.errSelectors.allErrors().toJS()
+          .filter(err => err.source !== "resolver")
+        expect(allSemanticErrors).toEqual([])
+      })
+    })
+    it("should return no errors when a JSON pointer exists in OpenAPI 3", () => {
+      const spec = {
+        openapi: "3.0.0",
+        paths: {
+          "/CoolPath": {
+            $ref: "#/myObj/abc"
+          },
+        },
+        myObj: {
+          abc: {
+            type: "string",
+            properties: {
+              $ref: "http://google.com/MyRegularURLReference"
+            }
+          }
+        }
+      }
+
+      return validateHelper(spec)
+      .then(system => {
+        const allSemanticErrors = system.errSelectors.allErrors().toJS()
+          .filter(err => err.source !== "resolver")
+        expect(allSemanticErrors).toEqual([])
+      })
+    })
+    it("should return no errors when a JSON pointer is a remote reference in Swagger 2", () => {
+      const spec = {
+        swagger: "2.0",
+        paths: {
+          "/CoolPath": {
+            $ref: "http://google.com#/myObj/abc"
+          },
+        },
+        myObj: {
+          abc: {
+            type: "string"
+          }
+        }
+      }
+
+      return validateHelper(spec)
+      .then(system => {
+        const allSemanticErrors = system.errSelectors.allErrors().toJS()
+          .filter(err => err.source !== "resolver")
+        expect(allSemanticErrors).toEqual([])
+      })
+    })
+    it("should return no errors when a JSON pointer is a remote reference in OpenAPI 3", () => {
+      const spec = {
+        openapi: "3.0.0",
+        paths: {
+          "/CoolPath": {
+            $ref: "http://google.com#/myObj/abc"
+          },
+        },
+        myObj: {
+          abc: {
+            type: "string"
+          }
+        }
+      }
+
+      return validateHelper(spec)
+      .then(system => {
+        const allSemanticErrors = system.errSelectors.allErrors().toJS()
+          .filter(err => err.source !== "resolver")
+        expect(allSemanticErrors).toEqual([])
+      })
+    })
+  })
 })