Merge branch 'master' into bug/auth-display-regression

README.md

@@ -6,7 +6,7 @@
 
 **This is the new version of swagger-ui, 3.x. Want to learn more? Check out our [FAQ](http://swagger.io/new-ui-faq/).**
 
-**👉🏼 Want to score an easy open-source contribution?** Check out our [Good first contribution](https://github.com/swagger-api/swagger-ui/issues?q=is%3Aissue+is%3Aopen+label%3A%22Good+first+contribution%22) label.
+**👉🏼 Want to score an easy open-source contribution?** Check out our [Good first issue](https://github.com/swagger-api/swagger-ui/issues?q=is%3Aissue+is%3Aopen+label%3A%22Good+first+issue%22) label.
 
 As a brand new version, written from the ground up, there are some known issues and unimplemented features. Check out the [Known Issues](#known-issues) section for more details.
 

src/core/plugins/spec/actions.js

@@ -137,10 +137,13 @@ export function changeParam( path, paramName, paramIn, value, isXml ){
   }
 }
 
-export function validateParams( payload ){
+export const validateParams = ( payload, isOAS3 ) =>{
   return {
     type: VALIDATE_PARAMS,
-    payload:{ pathMethod: payload }
+    payload:{ 
+      pathMethod: payload,
+      isOAS3
+    }
   }
 }
 

src/core/plugins/spec/reducers.js

@@ -51,14 +51,14 @@ export default {
     })
   },
 
-  [VALIDATE_PARAMS]: ( state, { payload:  { pathMethod } } ) => {
+  [VALIDATE_PARAMS]: ( state, { payload: { pathMethod, isOAS3 } } ) => {
     let operation = state.getIn( [ "resolved", "paths", ...pathMethod ] )
     let isXml = /xml/i.test(operation.get("consumes_value"))
 
     return state.updateIn( [ "resolved", "paths", ...pathMethod, "parameters" ], fromJS([]), parameters => {
       return parameters.withMutations( parameters => {
         for ( let i = 0, len = parameters.count(); i < len; i++ ) {
-          let errors = validateParam(parameters.get(i), isXml)
+          let errors = validateParam(parameters.get(i), isXml, isOAS3)
           parameters.setIn([i, "errors"], fromJS(errors))
         }
       })

src/core/plugins/spec/wrap-actions.js

@@ -13,3 +13,7 @@ export const executeRequest = (ori, { specActions }) => (req) => {
   specActions.logRequest(req)
   return ori(req)
 }
+
+export const validateParams = (ori, { specSelectors }) => (req) => {
+  return ori(req, specSelectors.isOAS3())
+}

src/core/utils.js

@@ -537,16 +537,18 @@ export const validateMinLength = (val, min) => {
 }
 
 // validation of parameters before execute
-export const validateParam = (param, isXml) => {
+export const validateParam = (param, isXml, isOAS3 = false) => {
   let errors = []
   let value = isXml && param.get("in") === "body" ? param.get("value_xml") : param.get("value")
   let required = param.get("required")
-  let maximum = param.get("maximum")
+
-  let minimum = param.get("minimum")
+  let paramDetails = isOAS3 ? param.get("schema") : param
-  let type = param.get("type")
+  let maximum = paramDetails.get("maximum")
-  let format = param.get("format")
+  let minimum = paramDetails.get("minimum")
-  let maxLength = param.get("maxLength")
+  let type = paramDetails.get("type")
-  let minLength = param.get("minLength")
+  let format = paramDetails.get("format")
+  let maxLength = paramDetails.get("maxLength")
+  let minLength = paramDetails.get("minLength")
 
   /*
     If the parameter is required OR the parameter has a value (meaning optional, but filled in)
@@ -616,7 +618,7 @@ export const validateParam = (param, isXml) => {
 
       if ( !value.count() ) { return errors }
 
-      itemType = param.getIn(["items", "type"])
+      itemType = paramDetails.getIn(["items", "type"])
 
       value.forEach((item, index) => {
         let err

test/core/utils.js

@@ -277,461 +277,438 @@ describe("utils", function() {
     let param = null
     let result = null
 
-    it("skips validation when `type` is not specified", function() {
+    const assertValidateParam = (param, expectedError) => {
-      // invalid type
+      // Swagger 2.0 version
+      result = validateParam( fromJS(param), false )
+      expect( result ).toEqual( expectedError )
+
+      // OAS3 version, using `schema` sub-object
+      let oas3Param = {
+        value: param.value,
+        required: param.required,
+        schema: {
+          ...param,
+          value: undefined,
+          required: undefined
+        }
+      }
+      result = validateParam( fromJS(oas3Param), false, true )
+      expect( result ).toEqual( expectedError )
+    }
+
+    it("should check the isOAS3 flag when validating parameters", function() {
+      // This should "skip" validation because there is no `schema.type` property
+      // and we are telling `validateParam` this is an OAS3 spec
       param = fromJS({
-        required: false,
+        value: "",
-        type: undefined,
+        required: true,
-        value: ""
+        schema: {
+          notTheTypeProperty: "string"
+        }
       })
-      result = validateParam( param, false )
+      result = validateParam( param, false, true )
       expect( result ).toEqual( [] )
     })
 
     it("validates required strings", function() {
       // invalid string
-      param = fromJS({
+      param = {
         required: true,
         type: "string",
         value: ""
-      })
+      }
-      result = validateParam( param, false )
+      assertValidateParam(param, ["Required field is not provided"])
-      expect( result ).toEqual( ["Required field is not provided"] )
 
       // valid string
-      param = fromJS({
+      param = {
         required: true,
         type: "string",
         value: "test string"
-      })
+      }
-      result = validateParam( param, false )
+      assertValidateParam(param, [])
-      expect( result ).toEqual( [] )
 
       // valid string with min and max length
-      param = fromJS({
+      param = {
         required: true,
         type: "string",
         value: "test string",
         maxLength: 50,
         minLength: 1
-      })
+      }
-      result = validateParam( param, false )
+      assertValidateParam(param, [])
-      expect( result ).toEqual( [] )
     })
 
     it("validates required strings with min and max length", function() {
       // invalid string with max length
-      param = fromJS({
+      param = {
         required: true,
         type: "string",
         value: "test string",
         maxLength: 5
-      })
+      }
-      result = validateParam( param, false )
+      assertValidateParam(param, ["Value must be less than MaxLength"])
-      expect( result ).toEqual( ["Value must be less than MaxLength"] )
 
       // invalid string with max length 0
-      param = fromJS({
+      param = {
         required: true,
         type: "string",
         value: "test string",
         maxLength: 0
-      })
+      }
-      result = validateParam( param, false )
+      assertValidateParam(param, ["Value must be less than MaxLength"])
-      expect( result ).toEqual( ["Value must be less than MaxLength"] )
-
 
       // invalid string with min length
-      param = fromJS({
+      param = {
         required: true,
         type: "string",
         value: "test string",
         minLength: 50
-      })
+      }
-      result = validateParam( param, false )
+      assertValidateParam(param, ["Value must be greater than MinLength"])
-      expect( result ).toEqual( ["Value must be greater than MinLength"] )
     })
 
     it("validates optional strings", function() {
       // valid (empty) string
-      param = fromJS({
+      param = {
         required: false,
         type: "string",
         value: ""
-      })
+      }
-      result = validateParam( param, false )
+      assertValidateParam(param, [])
-      expect( result ).toEqual( [] )
 
       // valid string
-      param = fromJS({
+      param = {
         required: false,
         type: "string",
         value: "test"
-      })
+      }
-      result = validateParam( param, false )
+      assertValidateParam(param, [])
-      expect( result ).toEqual( [] )
     })
 
     it("validates required files", function() {
       // invalid file
-      param = fromJS({
+      param = {
         required: true,
         type: "file",
         value: undefined
-      })
+      }
-      result = validateParam( param, false )
+      assertValidateParam(param, ["Required field is not provided"])
-      expect( result ).toEqual( ["Required field is not provided"] )
 
       // valid file
-      param = fromJS({
+      param = {
         required: true,
         type: "file",
         value: new win.File()
-      })
+      }
-      result = validateParam( param, false )
+      assertValidateParam(param, [])
-      expect( result ).toEqual( [] )
     })
 
     it("validates optional files", function() {
       // invalid file
-      param = fromJS({
+      param = {
         required: false,
         type: "file",
         value: "not a file"
-      })
+      }
-      result = validateParam( param, false )
+      assertValidateParam(param, ["Value must be a file"])
-      expect( result ).toEqual( ["Value must be a file"] )
 
       // valid (empty) file
-      param = fromJS({
+      param = {
         required: false,
         type: "file",
         value: undefined
-      })
+      }
-      result = validateParam( param, false )
+      assertValidateParam(param, [])
-      expect( result ).toEqual( [] )
 
       // valid file
-      param = fromJS({
+      param = {
         required: false,
         type: "file",
         value: new win.File()
-      })
+      }
-      result = validateParam( param, false )
+      assertValidateParam(param, [])
-      expect( result ).toEqual( [] )
     })
 
     it("validates required arrays", function() {
       // invalid (empty) array
-      param = fromJS({
+      param = {
         required: true,
         type: "array",
         value: []
-      })
+      }
-      result = validateParam( param, false )
+      assertValidateParam(param, ["Required field is not provided"])
-      expect( result ).toEqual( ["Required field is not provided"] )
 
       // invalid (not an array)
-      param = fromJS({
+      param = {
         required: true,
         type: "array",
         value: undefined
-      })
+      }
-      result = validateParam( param, false )
+      assertValidateParam(param, ["Required field is not provided"])
-      expect( result ).toEqual( ["Required field is not provided"] )
 
       // invalid array, items do not match correct type
-      param = fromJS({
+      param = {
         required: true,
         type: "array",
         value: [1],
         items: {
           type: "string"
         }
-      })
+      }
-      result = validateParam( param, false )
+      assertValidateParam(param, [{index: 0, error: "Value must be a string"}])
-      expect( result ).toEqual( [{index: 0, error: "Value must be a string"}] )
 
       // valid array, with no 'type' for items
-      param = fromJS({
+      param = {
         required: true,
         type: "array",
         value: ["1"]
-      })
+      }
-      result = validateParam( param, false )
+      assertValidateParam(param, [])
-      expect( result ).toEqual( [] )
 
       // valid array, items match type
-      param = fromJS({
+      param = {
         required: true,
         type: "array",
         value: ["1"],
         items: {
           type: "string"
         }
-      })
+      }
-      result = validateParam( param, false )
+      assertValidateParam(param, [])
-      expect( result ).toEqual( [] )
     })
 
     it("validates optional arrays", function() {
       // valid, empty array
-      param = fromJS({
+      param = {
         required: false,
         type: "array",
         value: []
-      })
+      }
-      result = validateParam( param, false )
+      assertValidateParam(param, [])
-      expect( result ).toEqual( [] )
 
       // invalid, items do not match correct type
-      param = fromJS({
+      param = {
         required: false,
         type: "array",
         value: ["number"],
         items: {
           type: "number"
         }
-      })
+      }
-      result = validateParam( param, false )
+      assertValidateParam(param, [{index: 0, error: "Value must be a number"}])
-      expect( result ).toEqual( [{index: 0, error: "Value must be a number"}] )
 
       // valid
-      param = fromJS({
+      param = {
         required: false,
         type: "array",
         value: ["test"],
         items: {
           type: "string"
         }
-      })
+      }
-      result = validateParam( param, false )
+      assertValidateParam(param, [])
-      expect( result ).toEqual( [] )
     })
 
     it("validates required booleans", function() {
       // invalid boolean value
-      param = fromJS({
+      param = {
         required: true,
         type: "boolean",
         value: undefined
-      })
+      }
-      result = validateParam( param, false )
+      assertValidateParam(param, ["Required field is not provided"])
-      expect( result ).toEqual( ["Required field is not provided"] )
 
       // invalid boolean value (not a boolean)
-      param = fromJS({
+      param = {
         required: true,
         type: "boolean",
         value: "test string"
-      })
+      }
-      result = validateParam( param, false )
+      assertValidateParam(param, ["Required field is not provided"])
-      expect( result ).toEqual( ["Required field is not provided"] )
 
       // valid boolean value
-      param = fromJS({
+      param = {
         required: true,
         type: "boolean",
         value: "true"
-      })
+      }
-      result = validateParam( param, false )
+      assertValidateParam(param, [])
-      expect( result ).toEqual( [] )
 
       // valid boolean value
-      param = fromJS({
+      param = {
         required: true,
         type: "boolean",
         value: false
-      })
+      }
-      result = validateParam( param, false )
+      assertValidateParam(param, [])
-      expect( result ).toEqual( [] )
     })
 
     it("validates optional booleans", function() {
       // valid (empty) boolean value
-      param = fromJS({
+      param = {
         required: false,
         type: "boolean",
         value: undefined
-      })
+      }
-      result = validateParam( param, false )
+      assertValidateParam(param, [])
-      expect( result ).toEqual( [] )
 
       // invalid boolean value (not a boolean)
-      param = fromJS({
+      param = {
         required: false,
         type: "boolean",
         value: "test string"
-      })
+      }
-      result = validateParam( param, false )
+      assertValidateParam(param, ["Value must be a boolean"])
-      expect( result ).toEqual( ["Value must be a boolean"] )
 
       // valid boolean value
-      param = fromJS({
+      param = {
         required: false,
         type: "boolean",
         value: "true"
-      })
+      }
-      result = validateParam( param, false )
+      assertValidateParam(param, [])
-      expect( result ).toEqual( [] )
 
       // valid boolean value
-      param = fromJS({
+      param = {
         required: false,
         type: "boolean",
         value: false
-      })
+      }
-      result = validateParam( param, false )
+      assertValidateParam(param, [])
-      expect( result ).toEqual( [] )
     })
 
     it("validates required numbers", function() {
       // invalid number, string instead of a number
-      param = fromJS({
+      param = {
         required: true,
         type: "number",
         value: "test"
-      })
+      }
-      result = validateParam( param, false )
+      assertValidateParam(param, ["Required field is not provided"])
-      expect( result ).toEqual( ["Required field is not provided"] )
 
       // invalid number, undefined value
-      param = fromJS({
+      param = {
         required: true,
         type: "number",
         value: undefined
-      })
+      }
-      result = validateParam( param, false )
+      assertValidateParam(param, ["Required field is not provided"])
-      expect( result ).toEqual( ["Required field is not provided"] )
 
       // valid number with min and max
-      param = fromJS({
+      param = {
         required: true,
         type: "number",
         value: 10,
         minimum: 5,
         maximum: 99
-      })
+      }
-      result = validateParam( param, false )
+      assertValidateParam(param, [])
-      expect( result ).toEqual( [] )
 
       // valid negative number with min and max
-      param = fromJS({
+      param = {
         required: true,
         type: "number",
         value: -10,
         minimum: -50,
         maximum: -5
-      })
+      }
-      result = validateParam( param, false )
+      assertValidateParam(param, [])
-      expect( result ).toEqual( [] )
 
       // invalid number with maximum:0
-      param = fromJS({
+      param = {
         required: true,
         type: "number",
         value: 1,
         maximum: 0
-      })
+      }
-      result = validateParam( param, false )
+      assertValidateParam(param, ["Value must be less than Maximum"])
-      expect( result ).toEqual( ["Value must be less than Maximum"] )
 
       // invalid number with minimum:0
-      param = fromJS({
+      param = {
         required: true,
         type: "number",
         value: -10,
         minimum: 0
-      })
+      }
-      result = validateParam( param, false )
+      assertValidateParam(param, ["Value must be greater than Minimum"])
-      expect( result ).toEqual( ["Value must be greater than Minimum"] )
     })
 
     it("validates optional numbers", function() {
       // invalid number, string instead of a number
-      param = fromJS({
+      param = {
         required: false,
         type: "number",
         value: "test"
-      })
+      }
-      result = validateParam( param, false )
+      assertValidateParam(param, ["Value must be a number"])
-      expect( result ).toEqual( ["Value must be a number"] )
 
       // valid (empty) number
-      param = fromJS({
+      param = {
         required: false,
         type: "number",
         value: undefined
-      })
+      }
-      result = validateParam( param, false )
+      assertValidateParam(param, [])
-      expect( result ).toEqual( [] )
 
       // valid number
-      param = fromJS({
+      param = {
         required: false,
         type: "number",
         value: 10
-      })
+      }
-      result = validateParam( param, false )
+      assertValidateParam(param, [])
-      expect( result ).toEqual( [] )
     })
 
     it("validates required integers", function() {
       // invalid integer, string instead of an integer
-      param = fromJS({
+      param = {
         required: true,
         type: "integer",
         value: "test"
-      })
+      }
-      result = validateParam( param, false )
+      assertValidateParam(param, ["Required field is not provided"])
-      expect( result ).toEqual( ["Required field is not provided"] )
 
       // invalid integer, undefined value
-      param = fromJS({
+      param = {
         required: true,
         type: "integer",
         value: undefined
-      })
+      }
-      result = validateParam( param, false )
+      assertValidateParam(param, ["Required field is not provided"])
-      expect( result ).toEqual( ["Required field is not provided"] )
 
       // valid integer
-      param = fromJS({
+      param = {
         required: true,
         type: "integer",
         value: 10
-      })
+      }
-      result = validateParam( param, false )
+      assertValidateParam(param, [])
-      expect( result ).toEqual( [] )
     })
 
     it("validates optional integers", function() {
       // invalid integer, string instead of an integer
-      param = fromJS({
+      param = {
         required: false,
         type: "integer",
         value: "test"
-      })
+      }
-      result = validateParam( param, false )
+      assertValidateParam(param, ["Value must be an integer"])
-      expect( result ).toEqual( ["Value must be an integer"] )
 
       // valid (empty) integer
-      param = fromJS({
+      param = {
         required: false,
         type: "integer",
         value: undefined
-      })
+      }
-      result = validateParam( param, false )
+      assertValidateParam(param, [])
-      expect( result ).toEqual( [] )
 
       // integers
-      param = fromJS({
+      param = {
         required: false,
         type: "integer",
         value: 10
-      })
+      }
-      result = validateParam( param, false )
+      assertValidateParam(param, [])
-      expect( result ).toEqual( [] )
     })
   })