Merge pull request #2 from MugeSo/support-external-schemas

Support external schemas

index.js

@@ -36,6 +36,12 @@ function validateResponseMiddlewareFactory(args) {
     });
   }
 
+  if (args.externalSchemas) {
+    Object.keys(args.externalSchemas).forEach(function(id) {
+      v.addSchema(args.externalSchemas[id], id);
+    });
+  }
+
   return function(req, res, next) {
     res.validateResponse = validateResponse;
     next();

test/data-driven/accept-external-references-through-local-ref.js

@@ -0,0 +1,34 @@
+module.exports = {
+    constructorArgs: {
+        responses: {
+            200: {
+                schema: {
+                    type: 'object',
+                    properties: {
+                        foo: {
+                            $ref: '#/definitions/foo'
+                        }
+                    }
+                }
+            }
+        },
+
+        definitions: {
+            foo: {
+                $ref: 'http://example.com/schema'
+            }
+        },
+
+        externalSchemas: {
+            'http://example.com/schema': {
+                type: 'string'
+            }
+        }
+    },
+
+    inputStatusCode: 200,
+    inputResponseBody: {foo: 'asdf'},
+
+    expectedValidationError: ''
+};
+

test/data-driven/accept-external-references-with-path-through-local-ref.js

@@ -0,0 +1,38 @@
+module.exports = {
+    constructorArgs: {
+        responses: {
+            200: {
+                schema: {
+                    type: 'object',
+                    properties: {
+                        foo: {
+                            $ref: '#/definitions/foo'
+                        }
+                    }
+                }
+            }
+        },
+
+        definitions: {
+            foo: {
+                $ref: 'http://example.com/schema#/definitions/foo'
+            }
+        },
+
+        externalSchemas: {
+            'http://example.com/schema': {
+                definitions: {
+                    foo: {
+                        type: 'string'
+                    }
+                }
+            }
+        }
+    },
+
+    inputStatusCode: 200,
+    inputResponseBody: {foo: 'asdf'},
+
+    expectedValidationError: ''
+};
+

test/data-driven/accept-external-references-with-path.js

@@ -0,0 +1,34 @@
+module.exports = {
+    constructorArgs: {
+        responses: {
+            200: {
+                schema: {
+                    type: 'object',
+                    properties: {
+                        foo: {
+                            $ref: 'http://example.com/schema#/definitions/foo'
+                        }
+                    }
+                }
+            }
+        },
+
+        definitions: null,
+
+        externalSchemas: {
+            'http://example.com/schema': {
+                definitions: {
+                    foo: {
+                        type: 'string'
+                    }
+                }
+            }
+        }
+    },
+
+    inputStatusCode: 200,
+    inputResponseBody: {foo: 'asdf'},
+
+    expectedValidationError: ''
+};
+

test/data-driven/accept-external-references.js

@@ -0,0 +1,30 @@
+module.exports = {
+    constructorArgs: {
+        responses: {
+            200: {
+                schema: {
+                    type: 'object',
+                    properties: {
+                        foo: {
+                            $ref: 'http://example.com/schema'
+                        }
+                    }
+                }
+            }
+        },
+
+        definitions: null,
+
+        externalSchemas: {
+            'http://example.com/schema': {
+                type: 'string'
+            }
+        }
+    },
+
+    inputStatusCode: 200,
+    inputResponseBody: {foo: 'asdf'},
+
+    expectedValidationError: ''
+};
+

test/data-driven/fail-with-external-references-through-local-ref.js

@@ -0,0 +1,44 @@
+module.exports = {
+    constructorArgs: {
+        responses: {
+            200: {
+                schema: {
+                    type: 'object',
+                    properties: {
+                        foo: {
+                            $ref: '#/definitions/foo'
+                        }
+                    }
+                }
+            }
+        },
+
+        definitions: {
+            foo: {
+                $ref: 'http://example.com/schema'
+            }
+        },
+
+        externalSchemas: {
+            'http://example.com/schema': {
+                type: 'string'
+            }
+        }
+    },
+
+    inputStatusCode: 200,
+    inputResponseBody: {foo: 2345},
+
+    expectedValidationError: {
+        status: 500,
+        message: 'The response was not valid.',
+        errors: [
+            {
+                path: 'foo',
+                errorCode: 'type.openapi.responseValidation',
+                message: 'foo is not of a type(s) string'
+            }
+        ]
+    }
+};
+

test/data-driven/fail-with-external-references-with-path-through-local-ref.js

@@ -0,0 +1,48 @@
+module.exports = {
+    constructorArgs: {
+        responses: {
+            200: {
+                schema: {
+                    type: 'object',
+                    properties: {
+                        foo: {
+                            $ref: '#/definitions/foo'
+                        }
+                    }
+                }
+            }
+        },
+
+        definitions: {
+            foo: {
+                $ref: 'http://example.com/schema#/definitions/foo'
+            }
+        },
+
+        externalSchemas: {
+            'http://example.com/schema': {
+                definitions: {
+                    foo: {
+                        type: 'string'
+                    }
+                }
+            }
+        }
+    },
+
+    inputStatusCode: 200,
+    inputResponseBody: {foo: 2345},
+
+    expectedValidationError: {
+        status: 500,
+        message: 'The response was not valid.',
+        errors: [
+            {
+                path: 'foo',
+                errorCode: 'type.openapi.responseValidation',
+                message: 'foo is not of a type(s) string'
+            }
+        ]
+    }
+};
+

test/data-driven/fail-with-external-references-with-path.js

@@ -0,0 +1,44 @@
+module.exports = {
+    constructorArgs: {
+        responses: {
+            200: {
+                schema: {
+                    type: 'object',
+                    properties: {
+                        foo: {
+                            $ref: 'http://example.com/schema#/definitions/foo'
+                        }
+                    }
+                }
+            }
+        },
+
+        definitions: null,
+
+        externalSchemas: {
+            'http://example.com/schema': {
+                definitions: {
+                    foo: {
+                        type: 'string'
+                    }
+                }
+            }
+        }
+    },
+
+    inputStatusCode: 200,
+    inputResponseBody: {foo: 2345},
+
+    expectedValidationError: {
+        status: 500,
+        message: 'The response was not valid.',
+        errors: [
+            {
+                path: 'foo',
+                errorCode: 'type.openapi.responseValidation',
+                message: 'foo is not of a type(s) string'
+            }
+        ]
+    }
+};
+

test/data-driven/fail-with-external-references.js

@@ -0,0 +1,40 @@
+module.exports = {
+    constructorArgs: {
+        responses: {
+            200: {
+                schema: {
+                    type: 'object',
+                    properties: {
+                        foo: {
+                            $ref: 'http://example.com/schema'
+                        }
+                    }
+                }
+            }
+        },
+
+        definitions: null,
+
+        externalSchemas: {
+            'http://example.com/schema': {
+                type: 'string'
+            }
+        }
+    },
+
+    inputStatusCode: 200,
+    inputResponseBody: {foo: 2345},
+
+    expectedValidationError: {
+        status: 500,
+        message: 'The response was not valid.',
+        errors: [
+            {
+                path: 'foo',
+                errorCode: 'type.openapi.responseValidation',
+                message: 'foo is not of a type(s) string'
+            }
+        ]
+    }
+};
+