From a0f8f9a05db8405bd9e15a3bcc4d298493513f4d Mon Sep 17 00:00:00 2001
From: Owen Conti <owen@ohseemedia.com>
Date: Wed, 11 Oct 2017 17:46:38 -0600
Subject: [PATCH 1/5] Fixes #3747 Update `validateParam` to handle OAS3
 parameters.

---
 src/core/utils.js | 14 ++++++++------
 1 file changed, 8 insertions(+), 6 deletions(-)

diff --git a/src/core/utils.js b/src/core/utils.js
index 8cd8eff6..f913afc9 100644
--- a/src/core/utils.js
+++ b/src/core/utils.js
@@ -541,12 +541,14 @@ export const validateParam = (param, isXml) => {
   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 type = param.get("type")
-  let format = param.get("format")
-  let maxLength = param.get("maxLength")
-  let minLength = param.get("minLength")
+
+  let paramDetails = param.get("schema") || param
+  let maximum = paramDetails.get("maximum")
+  let minimum = paramDetails.get("minimum")
+  let type = paramDetails.get("type")
+  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)

From 7344315c34f5dbe3f8191900fb89e37ced26a510 Mon Sep 17 00:00:00 2001
From: Owen Conti <owen@ohseemedia.com>
Date: Wed, 11 Oct 2017 18:34:24 -0600
Subject: [PATCH 2/5] Added tests for isOAS3 in validateParam function.

---
 src/core/plugins/spec/actions.js      |   7 +-
 src/core/plugins/spec/reducers.js     |   4 +-
 src/core/plugins/spec/wrap-actions.js |   4 +
 src/core/utils.js                     |   6 +-
 test/core/utils.js                    | 966 ++++++++++++++------------
 5 files changed, 524 insertions(+), 463 deletions(-)

diff --git a/src/core/plugins/spec/actions.js b/src/core/plugins/spec/actions.js
index 31d942b9..54895679 100644
--- a/src/core/plugins/spec/actions.js
+++ b/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
+    }
   }
 }
 
diff --git a/src/core/plugins/spec/reducers.js b/src/core/plugins/spec/reducers.js
index 0c436183..4711b23e 100644
--- a/src/core/plugins/spec/reducers.js
+++ b/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))
         }
       })
diff --git a/src/core/plugins/spec/wrap-actions.js b/src/core/plugins/spec/wrap-actions.js
index 71dc1c12..a9c73f22 100644
--- a/src/core/plugins/spec/wrap-actions.js
+++ b/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())
+}
\ No newline at end of file
diff --git a/src/core/utils.js b/src/core/utils.js
index f913afc9..0f247b52 100644
--- a/src/core/utils.js
+++ b/src/core/utils.js
@@ -537,12 +537,12 @@ 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 paramDetails = param.get("schema") || param
+  let paramDetails = isOAS3 ? param.get("schema") : param
   let maximum = paramDetails.get("maximum")
   let minimum = paramDetails.get("minimum")
   let type = paramDetails.get("type")
@@ -618,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
diff --git a/test/core/utils.js b/test/core/utils.js
index e506ef29..7cb7927a 100644
--- a/test/core/utils.js
+++ b/test/core/utils.js
@@ -274,464 +274,518 @@ describe("utils", function() {
    })
 
   describe("validateParam", function() {
-    let param = null
-    let result = null
-
-    it("skips validation when `type` is not specified", function() {
-      // invalid type
-      param = fromJS({
-        required: false,
-        type: undefined,
-        value: ""
-      })
-      result = validateParam( param, false )
-      expect( result ).toEqual( [] )
-    })
-
-    it("validates required strings", function() {
-      // invalid string
-      param = fromJS({
-        required: true,
-        type: "string",
-        value: ""
-      })
-      result = validateParam( param, false )
-      expect( result ).toEqual( ["Required field is not provided"] )
-
-      // valid string
-      param = fromJS({
-        required: true,
-        type: "string",
-        value: "test string"
-      })
-      result = validateParam( param, false )
-      expect( result ).toEqual( [] )
-
-      // valid string with min and max length
-      param = fromJS({
-        required: true,
-        type: "string",
-        value: "test string",
-        maxLength: 50,
-        minLength: 1
-      })
-      result = validateParam( param, false )
-      expect( result ).toEqual( [] )
-    })
-
-    it("validates required strings with min and max length", function() {
-      // invalid string with max length
-      param = fromJS({
-        required: true,
-        type: "string",
-        value: "test string",
-        maxLength: 5
-      })
-      result = validateParam( param, false )
-      expect( result ).toEqual( ["Value must be less than MaxLength"] )
-
-      // invalid string with max length 0
-      param = fromJS({
-        required: true,
-        type: "string",
-        value: "test string",
-        maxLength: 0
-      })
-      result = validateParam( param, false )
-      expect( result ).toEqual( ["Value must be less than MaxLength"] )
-
-
-      // invalid string with min length
-      param = fromJS({
-        required: true,
-        type: "string",
-        value: "test string",
-        minLength: 50
-      })
-      result = validateParam( param, false )
-      expect( result ).toEqual( ["Value must be greater than MinLength"] )
-    })
-
-    it("validates optional strings", function() {
-      // valid (empty) string
-      param = fromJS({
-        required: false,
-        type: "string",
-        value: ""
-      })
-      result = validateParam( param, false )
-      expect( result ).toEqual( [] )
-
-      // valid string
-      param = fromJS({
-        required: false,
-        type: "string",
-        value: "test"
-      })
-      result = validateParam( param, false )
-      expect( result ).toEqual( [] )
-    })
-
-    it("validates required files", function() {
-      // invalid file
-      param = fromJS({
-        required: true,
-        type: "file",
-        value: undefined
-      })
-      result = validateParam( param, false )
-      expect( result ).toEqual( ["Required field is not provided"] )
-
-      // valid file
-      param = fromJS({
-        required: true,
-        type: "file",
-        value: new win.File()
-      })
-      result = validateParam( param, false )
-      expect( result ).toEqual( [] )
-    })
-
-    it("validates optional files", function() {
-      // invalid file
-      param = fromJS({
-        required: false,
-        type: "file",
-        value: "not a file"
-      })
-      result = validateParam( param, false )
-      expect( result ).toEqual( ["Value must be a file"] )
-
-      // valid (empty) file
-      param = fromJS({
-        required: false,
-        type: "file",
-        value: undefined
-      })
-      result = validateParam( param, false )
-      expect( result ).toEqual( [] )
-
-      // valid file
-      param = fromJS({
-        required: false,
-        type: "file",
-        value: new win.File()
-      })
-      result = validateParam( param, false )
-      expect( result ).toEqual( [] )
-    })
-
-    it("validates required arrays", function() {
-      // invalid (empty) array
-      param = fromJS({
-        required: true,
-        type: "array",
-        value: []
-      })
-      result = validateParam( param, false )
-      expect( result ).toEqual( ["Required field is not provided"] )
-
-      // invalid (not an array)
-      param = fromJS({
-        required: true,
-        type: "array",
-        value: undefined
-      })
-      result = validateParam( param, false )
-      expect( result ).toEqual( ["Required field is not provided"] )
-
-      // invalid array, items do not match correct type
-      param = fromJS({
-        required: true,
-        type: "array",
-        value: [1],
-        items: {
-          type: "string"
-        }
-      })
-      result = validateParam( param, false )
-      expect( result ).toEqual( [{index: 0, error: "Value must be a string"}] )
-
-      // valid array, with no 'type' for items
-      param = fromJS({
-        required: true,
-        type: "array",
-        value: ["1"]
-      })
-      result = validateParam( param, false )
-      expect( result ).toEqual( [] )
-
-      // valid array, items match type
-      param = fromJS({
-        required: true,
-        type: "array",
-        value: ["1"],
-        items: {
-          type: "string"
-        }
-      })
-      result = validateParam( param, false )
-      expect( result ).toEqual( [] )
-    })
-
-    it("validates optional arrays", function() {
-      // valid, empty array
-      param = fromJS({
-        required: false,
-        type: "array",
-        value: []
-      })
-      result = validateParam( param, false )
-      expect( result ).toEqual( [] )
-
-      // invalid, items do not match correct type
-      param = fromJS({
-        required: false,
-        type: "array",
-        value: ["number"],
-        items: {
-          type: "number"
-        }
-      })
-      result = validateParam( param, false )
-      expect( result ).toEqual( [{index: 0, error: "Value must be a number"}] )
-
-      // valid
-      param = fromJS({
-        required: false,
-        type: "array",
-        value: ["test"],
-        items: {
-          type: "string"
-        }
-      })
-      result = validateParam( param, false )
-      expect( result ).toEqual( [] )
-    })
 
-    it("validates required booleans", function() {
-      // invalid boolean value
-      param = fromJS({
-        required: true,
-        type: "boolean",
-        value: undefined
-      })
-      result = validateParam( param, false )
-      expect( result ).toEqual( ["Required field is not provided"] )
-
-      // invalid boolean value (not a boolean)
-      param = fromJS({
-        required: true,
-        type: "boolean",
-        value: "test string"
-      })
-      result = validateParam( param, false )
-      expect( result ).toEqual( ["Required field is not provided"] )
-
-      // valid boolean value
-      param = fromJS({
-        required: true,
-        type: "boolean",
-        value: "true"
-      })
-      result = validateParam( param, false )
-      expect( result ).toEqual( [] )
-
-      // valid boolean value
-      param = fromJS({
-        required: true,
-        type: "boolean",
-        value: false
-      })
-      result = validateParam( param, false )
-      expect( result ).toEqual( [] )
-    })
-
-    it("validates optional booleans", function() {
-      // valid (empty) boolean value
-      param = fromJS({
-        required: false,
-        type: "boolean",
-        value: undefined
-      })
-      result = validateParam( param, false )
-      expect( result ).toEqual( [] )
-
-      // invalid boolean value (not a boolean)
-      param = fromJS({
-        required: false,
-        type: "boolean",
-        value: "test string"
-      })
-      result = validateParam( param, false )
-      expect( result ).toEqual( ["Value must be a boolean"] )
-
-      // valid boolean value
-      param = fromJS({
-        required: false,
-        type: "boolean",
-        value: "true"
-      })
-      result = validateParam( param, false )
-      expect( result ).toEqual( [] )
-
-      // valid boolean value
-      param = fromJS({
-        required: false,
-        type: "boolean",
-        value: false
-      })
-      result = validateParam( param, false )
-      expect( result ).toEqual( [] )
-    })
-
-    it("validates required numbers", function() {
-      // invalid number, string instead of a number
-      param = fromJS({
-        required: true,
-        type: "number",
-        value: "test"
-      })
-      result = validateParam( param, false )
-      expect( result ).toEqual( ["Required field is not provided"] )
-
-      // invalid number, undefined value
-      param = fromJS({
-        required: true,
-        type: "number",
-        value: undefined
-      })
-      result = validateParam( param, false )
-      expect( result ).toEqual( ["Required field is not provided"] )
-
-      // valid number with min and max
-      param = fromJS({
-        required: true,
-        type: "number",
-        value: 10,
-        minimum: 5,
-        maximum: 99
-      })
-      result = validateParam( param, false )
-      expect( result ).toEqual( [] )
-
-      // valid negative number with min and max
-      param = fromJS({
-        required: true,
-        type: "number",
-        value: -10,
-        minimum: -50,
-        maximum: -5
-      })
-      result = validateParam( param, false )
-      expect( result ).toEqual( [] )
-
-      // invalid number with maximum:0
-      param = fromJS({
-        required: true,
-        type: "number",
-        value: 1,
-        maximum: 0
-      })
-      result = validateParam( param, false )
-      expect( result ).toEqual( ["Value must be less than Maximum"] )
-
-      // invalid number with minimum:0
-      param = fromJS({
-        required: true,
-        type: "number",
-        value: -10,
-        minimum: 0
-      })
-      result = validateParam( param, false )
-      expect( result ).toEqual( ["Value must be greater than Minimum"] )
-    })
-
-    it("validates optional numbers", function() {
-      // invalid number, string instead of a number
-      param = fromJS({
-        required: false,
-        type: "number",
-        value: "test"
-      })
-      result = validateParam( param, false )
-      expect( result ).toEqual( ["Value must be a number"] )
-
-      // valid (empty) number
-      param = fromJS({
-        required: false,
-        type: "number",
-        value: undefined
-      })
-      result = validateParam( param, false )
-      expect( result ).toEqual( [] )
-
-      // valid number
-      param = fromJS({
-        required: false,
-        type: "number",
-        value: 10
-      })
-      result = validateParam( param, false )
-      expect( result ).toEqual( [] )
-    })
-
-    it("validates required integers", function() {
-      // invalid integer, string instead of an integer
-      param = fromJS({
-        required: true,
-        type: "integer",
-        value: "test"
-      })
-      result = validateParam( param, false )
-      expect( result ).toEqual( ["Required field is not provided"] )
-
-      // invalid integer, undefined value
-      param = fromJS({
-        required: true,
-        type: "integer",
-        value: undefined
-      })
-      result = validateParam( param, false )
-      expect( result ).toEqual( ["Required field is not provided"] )
-
-      // valid integer
-      param = fromJS({
-        required: true,
-        type: "integer",
-        value: 10
-      })
-      result = validateParam( param, false )
-      expect( result ).toEqual( [] )
-    })
-
-    it("validates optional integers", function() {
-      // invalid integer, string instead of an integer
-      param = fromJS({
-        required: false,
-        type: "integer",
-        value: "test"
-      })
-      result = validateParam( param, false )
-      expect( result ).toEqual( ["Value must be an integer"] )
-
-      // valid (empty) integer
-      param = fromJS({
-        required: false,
-        type: "integer",
-        value: undefined
-      })
-      result = validateParam( param, false )
-      expect( result ).toEqual( [] )
-
-      // integers
-      param = fromJS({
-        required: false,
-        type: "integer",
-        value: 10
+    describe("OAS3 specs", function() {
+      let param = null
+      let result = null
+
+      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({
+          value: "",
+          required: true,
+          schema: {
+            notTheTypeProperty: "string"
+          }
+        })
+        result = validateParam( param, false, true )
+        expect( result ).toEqual( [] )
+      })
+
+      // Test a couple examples of validateParam()
+      it("validates required strings", function() {
+        // invalid string
+        param = fromJS({
+          value: "",
+          required: true,
+          schema: {
+            type: "string"
+          }
+        })
+        result = validateParam( param, false, true )
+        expect( result ).toEqual( ["Required field is not provided"] )
+      })
+
+      it("validates required arrays", function() {
+        // invalid array, items do not match correct type
+        param = fromJS({
+          required: true,
+          value: [1],
+          schema: {
+            type: "array",
+            items: {
+              type: "string"
+            }
+          }
+        })
+        result = validateParam( param, false, true )
+        expect( result ).toEqual( [{index: 0, error: "Value must be a string"}] )
+      })
+
+      it("validates required numbers", function() {
+        // invalid number, string instead of a number
+        param = fromJS({
+          required: true,
+          value: "test",
+          schema: {
+            type: "number"
+          }
+        })
+        result = validateParam( param, false, true )
+        expect( result ).toEqual( ["Required field is not provided"] )
+      })
+    })
+
+    describe("Swagger 2.0 specs", function() {
+      let param = null
+      let result = null
+
+      it("validates required strings", function() {
+        // invalid string
+        param = fromJS({
+          required: true,
+          type: "string",
+          value: ""
+        })
+        result = validateParam( param, false )
+        expect( result ).toEqual( ["Required field is not provided"] )
+
+        // valid string
+        param = fromJS({
+          required: true,
+          type: "string",
+          value: "test string"
+        })
+        result = validateParam( param, false )
+        expect( result ).toEqual( [] )
+
+        // valid string with min and max length
+        param = fromJS({
+          required: true,
+          type: "string",
+          value: "test string",
+          maxLength: 50,
+          minLength: 1
+        })
+        result = validateParam( param, false )
+        expect( result ).toEqual( [] )
+      })
+
+      it("validates required strings with min and max length", function() {
+        // invalid string with max length
+        param = fromJS({
+          required: true,
+          type: "string",
+          value: "test string",
+          maxLength: 5
+        })
+        result = validateParam( param, false )
+        expect( result ).toEqual( ["Value must be less than MaxLength"] )
+
+        // invalid string with max length 0
+        param = fromJS({
+          required: true,
+          type: "string",
+          value: "test string",
+          maxLength: 0
+        })
+        result = validateParam( param, false )
+        expect( result ).toEqual( ["Value must be less than MaxLength"] )
+
+
+        // invalid string with min length
+        param = fromJS({
+          required: true,
+          type: "string",
+          value: "test string",
+          minLength: 50
+        })
+        result = validateParam( param, false )
+        expect( result ).toEqual( ["Value must be greater than MinLength"] )
+      })
+
+      it("validates optional strings", function() {
+        // valid (empty) string
+        param = fromJS({
+          required: false,
+          type: "string",
+          value: ""
+        })
+        result = validateParam( param, false )
+        expect( result ).toEqual( [] )
+
+        // valid string
+        param = fromJS({
+          required: false,
+          type: "string",
+          value: "test"
+        })
+        result = validateParam( param, false )
+        expect( result ).toEqual( [] )
+      })
+
+      it("validates required files", function() {
+        // invalid file
+        param = fromJS({
+          required: true,
+          type: "file",
+          value: undefined
+        })
+        result = validateParam( param, false )
+        expect( result ).toEqual( ["Required field is not provided"] )
+
+        // valid file
+        param = fromJS({
+          required: true,
+          type: "file",
+          value: new win.File()
+        })
+        result = validateParam( param, false )
+        expect( result ).toEqual( [] )
+      })
+
+      it("validates optional files", function() {
+        // invalid file
+        param = fromJS({
+          required: false,
+          type: "file",
+          value: "not a file"
+        })
+        result = validateParam( param, false )
+        expect( result ).toEqual( ["Value must be a file"] )
+
+        // valid (empty) file
+        param = fromJS({
+          required: false,
+          type: "file",
+          value: undefined
+        })
+        result = validateParam( param, false )
+        expect( result ).toEqual( [] )
+
+        // valid file
+        param = fromJS({
+          required: false,
+          type: "file",
+          value: new win.File()
+        })
+        result = validateParam( param, false )
+        expect( result ).toEqual( [] )
+      })
+
+      it("validates required arrays", function() {
+        // invalid (empty) array
+        param = fromJS({
+          required: true,
+          type: "array",
+          value: []
+        })
+        result = validateParam( param, false )
+        expect( result ).toEqual( ["Required field is not provided"] )
+
+        // invalid (not an array)
+        param = fromJS({
+          required: true,
+          type: "array",
+          value: undefined
+        })
+        result = validateParam( param, false )
+        expect( result ).toEqual( ["Required field is not provided"] )
+
+        // invalid array, items do not match correct type
+        param = fromJS({
+          required: true,
+          type: "array",
+          value: [1],
+          items: {
+            type: "string"
+          }
+        })
+        result = validateParam( param, false )
+        expect( result ).toEqual( [{index: 0, error: "Value must be a string"}] )
+
+        // valid array, with no 'type' for items
+        param = fromJS({
+          required: true,
+          type: "array",
+          value: ["1"]
+        })
+        result = validateParam( param, false )
+        expect( result ).toEqual( [] )
+
+        // valid array, items match type
+        param = fromJS({
+          required: true,
+          type: "array",
+          value: ["1"],
+          items: {
+            type: "string"
+          }
+        })
+        result = validateParam( param, false )
+        expect( result ).toEqual( [] )
+      })
+
+      it("validates optional arrays", function() {
+        // valid, empty array
+        param = fromJS({
+          required: false,
+          type: "array",
+          value: []
+        })
+        result = validateParam( param, false )
+        expect( result ).toEqual( [] )
+
+        // invalid, items do not match correct type
+        param = fromJS({
+          required: false,
+          type: "array",
+          value: ["number"],
+          items: {
+            type: "number"
+          }
+        })
+        result = validateParam( param, false )
+        expect( result ).toEqual( [{index: 0, error: "Value must be a number"}] )
+
+        // valid
+        param = fromJS({
+          required: false,
+          type: "array",
+          value: ["test"],
+          items: {
+            type: "string"
+          }
+        })
+        result = validateParam( param, false )
+        expect( result ).toEqual( [] )
+      })
+
+      it("validates required booleans", function() {
+        // invalid boolean value
+        param = fromJS({
+          required: true,
+          type: "boolean",
+          value: undefined
+        })
+        result = validateParam( param, false )
+        expect( result ).toEqual( ["Required field is not provided"] )
+
+        // invalid boolean value (not a boolean)
+        param = fromJS({
+          required: true,
+          type: "boolean",
+          value: "test string"
+        })
+        result = validateParam( param, false )
+        expect( result ).toEqual( ["Required field is not provided"] )
+
+        // valid boolean value
+        param = fromJS({
+          required: true,
+          type: "boolean",
+          value: "true"
+        })
+        result = validateParam( param, false )
+        expect( result ).toEqual( [] )
+
+        // valid boolean value
+        param = fromJS({
+          required: true,
+          type: "boolean",
+          value: false
+        })
+        result = validateParam( param, false )
+        expect( result ).toEqual( [] )
+      })
+
+      it("validates optional booleans", function() {
+        // valid (empty) boolean value
+        param = fromJS({
+          required: false,
+          type: "boolean",
+          value: undefined
+        })
+        result = validateParam( param, false )
+        expect( result ).toEqual( [] )
+
+        // invalid boolean value (not a boolean)
+        param = fromJS({
+          required: false,
+          type: "boolean",
+          value: "test string"
+        })
+        result = validateParam( param, false )
+        expect( result ).toEqual( ["Value must be a boolean"] )
+
+        // valid boolean value
+        param = fromJS({
+          required: false,
+          type: "boolean",
+          value: "true"
+        })
+        result = validateParam( param, false )
+        expect( result ).toEqual( [] )
+
+        // valid boolean value
+        param = fromJS({
+          required: false,
+          type: "boolean",
+          value: false
+        })
+        result = validateParam( param, false )
+        expect( result ).toEqual( [] )
+      })
+
+      it("validates required numbers", function() {
+        // invalid number, string instead of a number
+        param = fromJS({
+          required: true,
+          type: "number",
+          value: "test"
+        })
+        result = validateParam( param, false )
+        expect( result ).toEqual( ["Required field is not provided"] )
+
+        // invalid number, undefined value
+        param = fromJS({
+          required: true,
+          type: "number",
+          value: undefined
+        })
+        result = validateParam( param, false )
+        expect( result ).toEqual( ["Required field is not provided"] )
+
+        // valid number with min and max
+        param = fromJS({
+          required: true,
+          type: "number",
+          value: 10,
+          minimum: 5,
+          maximum: 99
+        })
+        result = validateParam( param, false )
+        expect( result ).toEqual( [] )
+
+        // valid negative number with min and max
+        param = fromJS({
+          required: true,
+          type: "number",
+          value: -10,
+          minimum: -50,
+          maximum: -5
+        })
+        result = validateParam( param, false )
+        expect( result ).toEqual( [] )
+
+        // invalid number with maximum:0
+        param = fromJS({
+          required: true,
+          type: "number",
+          value: 1,
+          maximum: 0
+        })
+        result = validateParam( param, false )
+        expect( result ).toEqual( ["Value must be less than Maximum"] )
+
+        // invalid number with minimum:0
+        param = fromJS({
+          required: true,
+          type: "number",
+          value: -10,
+          minimum: 0
+        })
+        result = validateParam( param, false )
+        expect( result ).toEqual( ["Value must be greater than Minimum"] )
+      })
+
+      it("validates optional numbers", function() {
+        // invalid number, string instead of a number
+        param = fromJS({
+          required: false,
+          type: "number",
+          value: "test"
+        })
+        result = validateParam( param, false )
+        expect( result ).toEqual( ["Value must be a number"] )
+
+        // valid (empty) number
+        param = fromJS({
+          required: false,
+          type: "number",
+          value: undefined
+        })
+        result = validateParam( param, false )
+        expect( result ).toEqual( [] )
+
+        // valid number
+        param = fromJS({
+          required: false,
+          type: "number",
+          value: 10
+        })
+        result = validateParam( param, false )
+        expect( result ).toEqual( [] )
+      })
+
+      it("validates required integers", function() {
+        // invalid integer, string instead of an integer
+        param = fromJS({
+          required: true,
+          type: "integer",
+          value: "test"
+        })
+        result = validateParam( param, false )
+        expect( result ).toEqual( ["Required field is not provided"] )
+
+        // invalid integer, undefined value
+        param = fromJS({
+          required: true,
+          type: "integer",
+          value: undefined
+        })
+        result = validateParam( param, false )
+        expect( result ).toEqual( ["Required field is not provided"] )
+
+        // valid integer
+        param = fromJS({
+          required: true,
+          type: "integer",
+          value: 10
+        })
+        result = validateParam( param, false )
+        expect( result ).toEqual( [] )
+      })
+
+      it("validates optional integers", function() {
+        // invalid integer, string instead of an integer
+        param = fromJS({
+          required: false,
+          type: "integer",
+          value: "test"
+        })
+        result = validateParam( param, false )
+        expect( result ).toEqual( ["Value must be an integer"] )
+
+        // valid (empty) integer
+        param = fromJS({
+          required: false,
+          type: "integer",
+          value: undefined
+        })
+        result = validateParam( param, false )
+        expect( result ).toEqual( [] )
+
+        // integers
+        param = fromJS({
+          required: false,
+          type: "integer",
+          value: 10
+        })
+        result = validateParam( param, false )
+        expect( result ).toEqual( [] )
       })
-      result = validateParam( param, false )
-      expect( result ).toEqual( [] )
     })
   })
 

From 7c8942e61c9ccb11bf7204f6964c5e579eebd58a Mon Sep 17 00:00:00 2001
From: Owen Conti <owen@ohseemedia.com>
Date: Wed, 11 Oct 2017 19:19:24 -0600
Subject: [PATCH 3/5] Update to utils.js to use a common method for asserting
 the validateParam function.

---
 test/core/utils.js | 980 ++++++++++++++++++++++-----------------------
 1 file changed, 470 insertions(+), 510 deletions(-)

diff --git a/test/core/utils.js b/test/core/utils.js
index 7cb7927a..d97de2cf 100644
--- a/test/core/utils.js
+++ b/test/core/utils.js
@@ -274,518 +274,478 @@ describe("utils", function() {
    })
 
   describe("validateParam", function() {
+    let param = null
+    let result = null
+
+    const assertValidateParam = (param, expectedError) => {
+      // Swagger 2.0 version
+      result = validateParam( fromJS(param), false )
+      expect( result ).toEqual( expectedError )
+
+      // OAS3 version, using `schema` sub-object
+      let oas3Param = {
+        value: param.value || null,
+        required: param.required || null,
+        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({
+        value: "",
+        required: true,
+        schema: {
+          notTheTypeProperty: "string"
+        }
+      })
+      result = validateParam( param, false, true )
+      expect( result ).toEqual( [] )
+    })
 
-    describe("OAS3 specs", function() {
-      let param = null
-      let result = null
-
-      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({
-          value: "",
-          required: true,
-          schema: {
-            notTheTypeProperty: "string"
-          }
-        })
-        result = validateParam( param, false, true )
-        expect( result ).toEqual( [] )
-      })
-
-      // Test a couple examples of validateParam()
-      it("validates required strings", function() {
-        // invalid string
-        param = fromJS({
-          value: "",
-          required: true,
-          schema: {
-            type: "string"
-          }
-        })
-        result = validateParam( param, false, true )
-        expect( result ).toEqual( ["Required field is not provided"] )
-      })
-
-      it("validates required arrays", function() {
-        // invalid array, items do not match correct type
-        param = fromJS({
-          required: true,
-          value: [1],
-          schema: {
-            type: "array",
-            items: {
-              type: "string"
-            }
-          }
-        })
-        result = validateParam( param, false, true )
-        expect( result ).toEqual( [{index: 0, error: "Value must be a string"}] )
-      })
-
-      it("validates required numbers", function() {
-        // invalid number, string instead of a number
-        param = fromJS({
-          required: true,
-          value: "test",
-          schema: {
-            type: "number"
-          }
-        })
-        result = validateParam( param, false, true )
-        expect( result ).toEqual( ["Required field is not provided"] )
-      })
-    })
-
-    describe("Swagger 2.0 specs", function() {
-      let param = null
-      let result = null
-
-      it("validates required strings", function() {
-        // invalid string
-        param = fromJS({
-          required: true,
-          type: "string",
-          value: ""
-        })
-        result = validateParam( param, false )
-        expect( result ).toEqual( ["Required field is not provided"] )
-
-        // valid string
-        param = fromJS({
-          required: true,
-          type: "string",
-          value: "test string"
-        })
-        result = validateParam( param, false )
-        expect( result ).toEqual( [] )
-
-        // valid string with min and max length
-        param = fromJS({
-          required: true,
-          type: "string",
-          value: "test string",
-          maxLength: 50,
-          minLength: 1
-        })
-        result = validateParam( param, false )
-        expect( result ).toEqual( [] )
-      })
-
-      it("validates required strings with min and max length", function() {
-        // invalid string with max length
-        param = fromJS({
-          required: true,
-          type: "string",
-          value: "test string",
-          maxLength: 5
-        })
-        result = validateParam( param, false )
-        expect( result ).toEqual( ["Value must be less than MaxLength"] )
-
-        // invalid string with max length 0
-        param = fromJS({
-          required: true,
-          type: "string",
-          value: "test string",
-          maxLength: 0
-        })
-        result = validateParam( param, false )
-        expect( result ).toEqual( ["Value must be less than MaxLength"] )
-
-
-        // invalid string with min length
-        param = fromJS({
-          required: true,
-          type: "string",
-          value: "test string",
-          minLength: 50
-        })
-        result = validateParam( param, false )
-        expect( result ).toEqual( ["Value must be greater than MinLength"] )
-      })
-
-      it("validates optional strings", function() {
-        // valid (empty) string
-        param = fromJS({
-          required: false,
-          type: "string",
-          value: ""
-        })
-        result = validateParam( param, false )
-        expect( result ).toEqual( [] )
-
-        // valid string
-        param = fromJS({
-          required: false,
-          type: "string",
-          value: "test"
-        })
-        result = validateParam( param, false )
-        expect( result ).toEqual( [] )
-      })
-
-      it("validates required files", function() {
-        // invalid file
-        param = fromJS({
-          required: true,
-          type: "file",
-          value: undefined
-        })
-        result = validateParam( param, false )
-        expect( result ).toEqual( ["Required field is not provided"] )
-
-        // valid file
-        param = fromJS({
-          required: true,
-          type: "file",
-          value: new win.File()
-        })
-        result = validateParam( param, false )
-        expect( result ).toEqual( [] )
-      })
-
-      it("validates optional files", function() {
-        // invalid file
-        param = fromJS({
-          required: false,
-          type: "file",
-          value: "not a file"
-        })
-        result = validateParam( param, false )
-        expect( result ).toEqual( ["Value must be a file"] )
-
-        // valid (empty) file
-        param = fromJS({
-          required: false,
-          type: "file",
-          value: undefined
-        })
-        result = validateParam( param, false )
-        expect( result ).toEqual( [] )
-
-        // valid file
-        param = fromJS({
-          required: false,
-          type: "file",
-          value: new win.File()
-        })
-        result = validateParam( param, false )
-        expect( result ).toEqual( [] )
-      })
-
-      it("validates required arrays", function() {
-        // invalid (empty) array
-        param = fromJS({
-          required: true,
-          type: "array",
-          value: []
-        })
-        result = validateParam( param, false )
-        expect( result ).toEqual( ["Required field is not provided"] )
-
-        // invalid (not an array)
-        param = fromJS({
-          required: true,
-          type: "array",
-          value: undefined
-        })
-        result = validateParam( param, false )
-        expect( result ).toEqual( ["Required field is not provided"] )
-
-        // invalid array, items do not match correct type
-        param = fromJS({
-          required: true,
-          type: "array",
-          value: [1],
-          items: {
-            type: "string"
-          }
-        })
-        result = validateParam( param, false )
-        expect( result ).toEqual( [{index: 0, error: "Value must be a string"}] )
-
-        // valid array, with no 'type' for items
-        param = fromJS({
-          required: true,
-          type: "array",
-          value: ["1"]
-        })
-        result = validateParam( param, false )
-        expect( result ).toEqual( [] )
-
-        // valid array, items match type
-        param = fromJS({
-          required: true,
-          type: "array",
-          value: ["1"],
-          items: {
-            type: "string"
-          }
-        })
-        result = validateParam( param, false )
-        expect( result ).toEqual( [] )
-      })
-
-      it("validates optional arrays", function() {
-        // valid, empty array
-        param = fromJS({
-          required: false,
-          type: "array",
-          value: []
-        })
-        result = validateParam( param, false )
-        expect( result ).toEqual( [] )
-
-        // invalid, items do not match correct type
-        param = fromJS({
-          required: false,
-          type: "array",
-          value: ["number"],
-          items: {
-            type: "number"
-          }
-        })
-        result = validateParam( param, false )
-        expect( result ).toEqual( [{index: 0, error: "Value must be a number"}] )
-
-        // valid
-        param = fromJS({
-          required: false,
-          type: "array",
-          value: ["test"],
-          items: {
-            type: "string"
-          }
-        })
-        result = validateParam( param, false )
-        expect( result ).toEqual( [] )
-      })
-
-      it("validates required booleans", function() {
-        // invalid boolean value
-        param = fromJS({
-          required: true,
-          type: "boolean",
-          value: undefined
-        })
-        result = validateParam( param, false )
-        expect( result ).toEqual( ["Required field is not provided"] )
-
-        // invalid boolean value (not a boolean)
-        param = fromJS({
-          required: true,
-          type: "boolean",
-          value: "test string"
-        })
-        result = validateParam( param, false )
-        expect( result ).toEqual( ["Required field is not provided"] )
-
-        // valid boolean value
-        param = fromJS({
-          required: true,
-          type: "boolean",
-          value: "true"
-        })
-        result = validateParam( param, false )
-        expect( result ).toEqual( [] )
-
-        // valid boolean value
-        param = fromJS({
-          required: true,
-          type: "boolean",
-          value: false
-        })
-        result = validateParam( param, false )
-        expect( result ).toEqual( [] )
-      })
-
-      it("validates optional booleans", function() {
-        // valid (empty) boolean value
-        param = fromJS({
-          required: false,
-          type: "boolean",
-          value: undefined
-        })
-        result = validateParam( param, false )
-        expect( result ).toEqual( [] )
-
-        // invalid boolean value (not a boolean)
-        param = fromJS({
-          required: false,
-          type: "boolean",
-          value: "test string"
-        })
-        result = validateParam( param, false )
-        expect( result ).toEqual( ["Value must be a boolean"] )
-
-        // valid boolean value
-        param = fromJS({
-          required: false,
-          type: "boolean",
-          value: "true"
-        })
-        result = validateParam( param, false )
-        expect( result ).toEqual( [] )
-
-        // valid boolean value
-        param = fromJS({
-          required: false,
-          type: "boolean",
-          value: false
-        })
-        result = validateParam( param, false )
-        expect( result ).toEqual( [] )
-      })
-
-      it("validates required numbers", function() {
-        // invalid number, string instead of a number
-        param = fromJS({
-          required: true,
-          type: "number",
-          value: "test"
-        })
-        result = validateParam( param, false )
-        expect( result ).toEqual( ["Required field is not provided"] )
-
-        // invalid number, undefined value
-        param = fromJS({
-          required: true,
-          type: "number",
-          value: undefined
-        })
-        result = validateParam( param, false )
-        expect( result ).toEqual( ["Required field is not provided"] )
-
-        // valid number with min and max
-        param = fromJS({
-          required: true,
-          type: "number",
-          value: 10,
-          minimum: 5,
-          maximum: 99
-        })
-        result = validateParam( param, false )
-        expect( result ).toEqual( [] )
-
-        // valid negative number with min and max
-        param = fromJS({
-          required: true,
-          type: "number",
-          value: -10,
-          minimum: -50,
-          maximum: -5
-        })
-        result = validateParam( param, false )
-        expect( result ).toEqual( [] )
-
-        // invalid number with maximum:0
-        param = fromJS({
-          required: true,
-          type: "number",
-          value: 1,
-          maximum: 0
-        })
-        result = validateParam( param, false )
-        expect( result ).toEqual( ["Value must be less than Maximum"] )
-
-        // invalid number with minimum:0
-        param = fromJS({
-          required: true,
-          type: "number",
-          value: -10,
-          minimum: 0
-        })
-        result = validateParam( param, false )
-        expect( result ).toEqual( ["Value must be greater than Minimum"] )
-      })
-
-      it("validates optional numbers", function() {
-        // invalid number, string instead of a number
-        param = fromJS({
-          required: false,
-          type: "number",
-          value: "test"
-        })
-        result = validateParam( param, false )
-        expect( result ).toEqual( ["Value must be a number"] )
-
-        // valid (empty) number
-        param = fromJS({
-          required: false,
-          type: "number",
-          value: undefined
-        })
-        result = validateParam( param, false )
-        expect( result ).toEqual( [] )
-
-        // valid number
-        param = fromJS({
-          required: false,
-          type: "number",
-          value: 10
-        })
-        result = validateParam( param, false )
-        expect( result ).toEqual( [] )
-      })
-
-      it("validates required integers", function() {
-        // invalid integer, string instead of an integer
-        param = fromJS({
-          required: true,
-          type: "integer",
-          value: "test"
-        })
-        result = validateParam( param, false )
-        expect( result ).toEqual( ["Required field is not provided"] )
-
-        // invalid integer, undefined value
-        param = fromJS({
-          required: true,
-          type: "integer",
-          value: undefined
-        })
-        result = validateParam( param, false )
-        expect( result ).toEqual( ["Required field is not provided"] )
-
-        // valid integer
-        param = fromJS({
-          required: true,
-          type: "integer",
-          value: 10
-        })
-        result = validateParam( param, false )
-        expect( result ).toEqual( [] )
-      })
-
-      it("validates optional integers", function() {
-        // invalid integer, string instead of an integer
-        param = fromJS({
-          required: false,
-          type: "integer",
-          value: "test"
-        })
-        result = validateParam( param, false )
-        expect( result ).toEqual( ["Value must be an integer"] )
-
-        // valid (empty) integer
-        param = fromJS({
-          required: false,
-          type: "integer",
-          value: undefined
-        })
-        result = validateParam( param, false )
-        expect( result ).toEqual( [] )
-
-        // integers
-        param = fromJS({
-          required: false,
-          type: "integer",
-          value: 10
-        })
-        result = validateParam( param, false )
-        expect( result ).toEqual( [] )
+    it("validates required strings", function() {
+      // invalid string
+      param = {
+        required: true,
+        type: "string",
+        value: ""
+      }
+      assertValidateParam(param, ["Required field is not provided"])
+
+      // valid string
+      param = {
+        required: true,
+        type: "string",
+        value: "test string"
+      }
+      assertValidateParam(param, [])
+
+      // valid string with min and max length
+      param = {
+        required: true,
+        type: "string",
+        value: "test string",
+        maxLength: 50,
+        minLength: 1
+      }
+      assertValidateParam(param, [])
+    })
+
+    it("validates required strings with min and max length", function() {
+      // invalid string with max length
+      param = {
+        required: true,
+        type: "string",
+        value: "test string",
+        maxLength: 5
+      }
+      assertValidateParam(param, ["Value must be less than MaxLength"])
+
+      // invalid string with max length 0
+      param = {
+        required: true,
+        type: "string",
+        value: "test string",
+        maxLength: 0
+      }
+      assertValidateParam(param, ["Value must be less than MaxLength"])
+
+      // invalid string with min length
+      param = {
+        required: true,
+        type: "string",
+        value: "test string",
+        minLength: 50
+      }
+      assertValidateParam(param, ["Value must be greater than MinLength"])
+    })
+
+    it("validates optional strings", function() {
+      // valid (empty) string
+      param = {
+        required: false,
+        type: "string",
+        value: ""
+      }
+      assertValidateParam(param, [])
+
+      // valid string
+      param = fromJS({
+        required: false,
+        type: "string",
+        value: "test"
+      })
+      result = validateParam( param, false )
+      expect( result ).toEqual( [] )
+    })
+
+    it("validates required files", function() {
+      // invalid file
+      param = fromJS({
+        required: true,
+        type: "file",
+        value: undefined
+      })
+      result = validateParam( param, false )
+      expect( result ).toEqual( ["Required field is not provided"] )
+
+      // valid file
+      param = fromJS({
+        required: true,
+        type: "file",
+        value: new win.File()
+      })
+      result = validateParam( param, false )
+      expect( result ).toEqual( [] )
+    })
+
+    it("validates optional files", function() {
+      // invalid file
+      param = fromJS({
+        required: false,
+        type: "file",
+        value: "not a file"
+      })
+      result = validateParam( param, false )
+      expect( result ).toEqual( ["Value must be a file"] )
+
+      // valid (empty) file
+      param = fromJS({
+        required: false,
+        type: "file",
+        value: undefined
+      })
+      result = validateParam( param, false )
+      expect( result ).toEqual( [] )
+
+      // valid file
+      param = fromJS({
+        required: false,
+        type: "file",
+        value: new win.File()
+      })
+      result = validateParam( param, false )
+      expect( result ).toEqual( [] )
+    })
+
+    it("validates required arrays", function() {
+      // invalid (empty) array
+      param = fromJS({
+        required: true,
+        type: "array",
+        value: []
+      })
+      result = validateParam( param, false )
+      expect( result ).toEqual( ["Required field is not provided"] )
+
+      // invalid (not an array)
+      param = fromJS({
+        required: true,
+        type: "array",
+        value: undefined
+      })
+      result = validateParam( param, false )
+      expect( result ).toEqual( ["Required field is not provided"] )
+
+      // invalid array, items do not match correct type
+      param = fromJS({
+        required: true,
+        type: "array",
+        value: [1],
+        items: {
+          type: "string"
+        }
+      })
+      result = validateParam( param, false )
+      expect( result ).toEqual( [{index: 0, error: "Value must be a string"}] )
+
+      // valid array, with no 'type' for items
+      param = fromJS({
+        required: true,
+        type: "array",
+        value: ["1"]
+      })
+      result = validateParam( param, false )
+      expect( result ).toEqual( [] )
+
+      // valid array, items match type
+      param = fromJS({
+        required: true,
+        type: "array",
+        value: ["1"],
+        items: {
+          type: "string"
+        }
+      })
+      result = validateParam( param, false )
+      expect( result ).toEqual( [] )
+    })
+
+    it("validates optional arrays", function() {
+      // valid, empty array
+      param = fromJS({
+        required: false,
+        type: "array",
+        value: []
+      })
+      result = validateParam( param, false )
+      expect( result ).toEqual( [] )
+
+      // invalid, items do not match correct type
+      param = fromJS({
+        required: false,
+        type: "array",
+        value: ["number"],
+        items: {
+          type: "number"
+        }
+      })
+      result = validateParam( param, false )
+      expect( result ).toEqual( [{index: 0, error: "Value must be a number"}] )
+
+      // valid
+      param = fromJS({
+        required: false,
+        type: "array",
+        value: ["test"],
+        items: {
+          type: "string"
+        }
+      })
+      result = validateParam( param, false )
+      expect( result ).toEqual( [] )
+    })
+
+    it("validates required booleans", function() {
+      // invalid boolean value
+      param = fromJS({
+        required: true,
+        type: "boolean",
+        value: undefined
+      })
+      result = validateParam( param, false )
+      expect( result ).toEqual( ["Required field is not provided"] )
+
+      // invalid boolean value (not a boolean)
+      param = fromJS({
+        required: true,
+        type: "boolean",
+        value: "test string"
+      })
+      result = validateParam( param, false )
+      expect( result ).toEqual( ["Required field is not provided"] )
+
+      // valid boolean value
+      param = fromJS({
+        required: true,
+        type: "boolean",
+        value: "true"
+      })
+      result = validateParam( param, false )
+      expect( result ).toEqual( [] )
+
+      // valid boolean value
+      param = fromJS({
+        required: true,
+        type: "boolean",
+        value: false
+      })
+      result = validateParam( param, false )
+      expect( result ).toEqual( [] )
+    })
+
+    it("validates optional booleans", function() {
+      // valid (empty) boolean value
+      param = fromJS({
+        required: false,
+        type: "boolean",
+        value: undefined
+      })
+      result = validateParam( param, false )
+      expect( result ).toEqual( [] )
+
+      // invalid boolean value (not a boolean)
+      param = fromJS({
+        required: false,
+        type: "boolean",
+        value: "test string"
+      })
+      result = validateParam( param, false )
+      expect( result ).toEqual( ["Value must be a boolean"] )
+
+      // valid boolean value
+      param = fromJS({
+        required: false,
+        type: "boolean",
+        value: "true"
+      })
+      result = validateParam( param, false )
+      expect( result ).toEqual( [] )
+
+      // valid boolean value
+      param = fromJS({
+        required: false,
+        type: "boolean",
+        value: false
+      })
+      result = validateParam( param, false )
+      expect( result ).toEqual( [] )
+    })
+
+    it("validates required numbers", function() {
+      // invalid number, string instead of a number
+      param = fromJS({
+        required: true,
+        type: "number",
+        value: "test"
+      })
+      result = validateParam( param, false )
+      expect( result ).toEqual( ["Required field is not provided"] )
+
+      // invalid number, undefined value
+      param = fromJS({
+        required: true,
+        type: "number",
+        value: undefined
+      })
+      result = validateParam( param, false )
+      expect( result ).toEqual( ["Required field is not provided"] )
+
+      // valid number with min and max
+      param = fromJS({
+        required: true,
+        type: "number",
+        value: 10,
+        minimum: 5,
+        maximum: 99
+      })
+      result = validateParam( param, false )
+      expect( result ).toEqual( [] )
+
+      // valid negative number with min and max
+      param = fromJS({
+        required: true,
+        type: "number",
+        value: -10,
+        minimum: -50,
+        maximum: -5
+      })
+      result = validateParam( param, false )
+      expect( result ).toEqual( [] )
+
+      // invalid number with maximum:0
+      param = fromJS({
+        required: true,
+        type: "number",
+        value: 1,
+        maximum: 0
+      })
+      result = validateParam( param, false )
+      expect( result ).toEqual( ["Value must be less than Maximum"] )
+
+      // invalid number with minimum:0
+      param = fromJS({
+        required: true,
+        type: "number",
+        value: -10,
+        minimum: 0
+      })
+      result = validateParam( param, false )
+      expect( result ).toEqual( ["Value must be greater than Minimum"] )
+    })
+
+    it("validates optional numbers", function() {
+      // invalid number, string instead of a number
+      param = fromJS({
+        required: false,
+        type: "number",
+        value: "test"
+      })
+      result = validateParam( param, false )
+      expect( result ).toEqual( ["Value must be a number"] )
+
+      // valid (empty) number
+      param = fromJS({
+        required: false,
+        type: "number",
+        value: undefined
+      })
+      result = validateParam( param, false )
+      expect( result ).toEqual( [] )
+
+      // valid number
+      param = fromJS({
+        required: false,
+        type: "number",
+        value: 10
+      })
+      result = validateParam( param, false )
+      expect( result ).toEqual( [] )
+    })
+
+    it("validates required integers", function() {
+      // invalid integer, string instead of an integer
+      param = fromJS({
+        required: true,
+        type: "integer",
+        value: "test"
+      })
+      result = validateParam( param, false )
+      expect( result ).toEqual( ["Required field is not provided"] )
+
+      // invalid integer, undefined value
+      param = fromJS({
+        required: true,
+        type: "integer",
+        value: undefined
+      })
+      result = validateParam( param, false )
+      expect( result ).toEqual( ["Required field is not provided"] )
+
+      // valid integer
+      param = fromJS({
+        required: true,
+        type: "integer",
+        value: 10
+      })
+      result = validateParam( param, false )
+      expect( result ).toEqual( [] )
+    })
+
+    it("validates optional integers", function() {
+      // invalid integer, string instead of an integer
+      param = fromJS({
+        required: false,
+        type: "integer",
+        value: "test"
+      })
+      result = validateParam( param, false )
+      expect( result ).toEqual( ["Value must be an integer"] )
+
+      // valid (empty) integer
+      param = fromJS({
+        required: false,
+        type: "integer",
+        value: undefined
+      })
+      result = validateParam( param, false )
+      expect( result ).toEqual( [] )
+
+      // integers
+      param = fromJS({
+        required: false,
+        type: "integer",
+        value: 10
       })
+      result = validateParam( param, false )
+      expect( result ).toEqual( [] )
     })
   })
 

From 18a681e231ca2fa0243fc70fabeab9ddee93e6b5 Mon Sep 17 00:00:00 2001
From: Owen Conti <owen@ohseemedia.com>
Date: Wed, 11 Oct 2017 19:50:02 -0600
Subject: [PATCH 4/5] Update all the validateParam tests to use the
 assertValidateParam factory

---
 test/core/utils.js | 263 +++++++++++++++++++--------------------------
 1 file changed, 113 insertions(+), 150 deletions(-)

diff --git a/test/core/utils.js b/test/core/utils.js
index d97de2cf..dd37a518 100644
--- a/test/core/utils.js
+++ b/test/core/utils.js
@@ -284,8 +284,8 @@ describe("utils", function() {
 
       // OAS3 version, using `schema` sub-object
       let oas3Param = {
-        value: param.value || null,
-        required: param.required || null,
+        value: param.value,
+        required: param.required,
         schema: {
           ...param,
           value: undefined,
@@ -377,375 +377,338 @@ describe("utils", function() {
       assertValidateParam(param, [])
 
       // valid string
-      param = fromJS({
+      param = {
         required: false,
         type: "string",
         value: "test"
-      })
-      result = validateParam( param, false )
-      expect( result ).toEqual( [] )
+      }
+      assertValidateParam(param, [])
     })
 
     it("validates required files", function() {
       // invalid file
-      param = fromJS({
+      param = {
         required: true,
         type: "file",
         value: undefined
-      })
-      result = validateParam( param, false )
-      expect( result ).toEqual( ["Required field is not provided"] )
+      }
+      assertValidateParam(param, ["Required field is not provided"])
 
       // valid file
-      param = fromJS({
+      param = {
         required: true,
         type: "file",
         value: new win.File()
-      })
-      result = validateParam( param, false )
-      expect( result ).toEqual( [] )
+      }
+      assertValidateParam(param, [])
     })
 
     it("validates optional files", function() {
       // invalid file
-      param = fromJS({
+      param = {
         required: false,
         type: "file",
         value: "not a file"
-      })
-      result = validateParam( param, false )
-      expect( result ).toEqual( ["Value must be a file"] )
+      }
+      assertValidateParam(param, ["Value must be a file"])
 
       // valid (empty) file
-      param = fromJS({
+      param = {
         required: false,
         type: "file",
         value: undefined
-      })
-      result = validateParam( param, false )
-      expect( result ).toEqual( [] )
+      }
+      assertValidateParam(param, [])
 
       // valid file
-      param = fromJS({
+      param = {
         required: false,
         type: "file",
         value: new win.File()
-      })
-      result = validateParam( param, false )
-      expect( result ).toEqual( [] )
+      }
+      assertValidateParam(param, [])
     })
 
     it("validates required arrays", function() {
       // invalid (empty) array
-      param = fromJS({
+      param = {
         required: true,
         type: "array",
         value: []
-      })
-      result = validateParam( param, false )
-      expect( result ).toEqual( ["Required field is not provided"] )
+      }
+      assertValidateParam(param, ["Required field is not provided"])
 
       // invalid (not an array)
-      param = fromJS({
+      param = {
         required: true,
         type: "array",
         value: undefined
-      })
-      result = validateParam( param, false )
-      expect( result ).toEqual( ["Required field is not provided"] )
+      }
+      assertValidateParam(param, ["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 )
-      expect( result ).toEqual( [{index: 0, error: "Value must be a string"}] )
+      }
+      assertValidateParam(param, [{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 )
-      expect( result ).toEqual( [] )
+      }
+      assertValidateParam(param, [])
 
       // valid array, items match type
-      param = fromJS({
+      param = {
         required: true,
         type: "array",
         value: ["1"],
         items: {
           type: "string"
         }
-      })
-      result = validateParam( param, false )
-      expect( result ).toEqual( [] )
+      }
+      assertValidateParam(param, [])
     })
 
     it("validates optional arrays", function() {
       // valid, empty array
-      param = fromJS({
+      param = {
         required: false,
         type: "array",
         value: []
-      })
-      result = validateParam( param, false )
-      expect( result ).toEqual( [] )
+      }
+      assertValidateParam(param, [])
 
       // invalid, items do not match correct type
-      param = fromJS({
+      param = {
         required: false,
         type: "array",
         value: ["number"],
         items: {
           type: "number"
         }
-      })
-      result = validateParam( param, false )
-      expect( result ).toEqual( [{index: 0, error: "Value must be a number"}] )
+      }
+      assertValidateParam(param, [{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 )
-      expect( result ).toEqual( [] )
+      }
+      assertValidateParam(param, [])
     })
 
     it("validates required booleans", function() {
       // invalid boolean value
-      param = fromJS({
+      param = {
         required: true,
         type: "boolean",
         value: undefined
-      })
-      result = validateParam( param, false )
-      expect( result ).toEqual( ["Required field is not provided"] )
+      }
+      assertValidateParam(param, ["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 )
-      expect( result ).toEqual( ["Required field is not provided"] )
+      }
+      assertValidateParam(param, ["Required field is not provided"])
 
       // valid boolean value
-      param = fromJS({
+      param = {
         required: true,
         type: "boolean",
         value: "true"
-      })
-      result = validateParam( param, false )
-      expect( result ).toEqual( [] )
+      }
+      assertValidateParam(param, [])
 
       // valid boolean value
-      param = fromJS({
+      param = {
         required: true,
         type: "boolean",
         value: false
-      })
-      result = validateParam( param, false )
-      expect( result ).toEqual( [] )
+      }
+      assertValidateParam(param, [])
     })
 
     it("validates optional booleans", function() {
       // valid (empty) boolean value
-      param = fromJS({
+      param = {
         required: false,
         type: "boolean",
         value: undefined
-      })
-      result = validateParam( param, false )
-      expect( result ).toEqual( [] )
+      }
+      assertValidateParam(param, [])
 
       // invalid boolean value (not a boolean)
-      param = fromJS({
+      param = {
         required: false,
         type: "boolean",
         value: "test string"
-      })
-      result = validateParam( param, false )
-      expect( result ).toEqual( ["Value must be a boolean"] )
+      }
+      assertValidateParam(param, ["Value must be a boolean"])
 
       // valid boolean value
-      param = fromJS({
+      param = {
         required: false,
         type: "boolean",
         value: "true"
-      })
-      result = validateParam( param, false )
-      expect( result ).toEqual( [] )
+      }
+      assertValidateParam(param, [])
 
       // valid boolean value
-      param = fromJS({
+      param = {
         required: false,
         type: "boolean",
         value: false
-      })
-      result = validateParam( param, false )
-      expect( result ).toEqual( [] )
+      }
+      assertValidateParam(param, [])
     })
 
     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 )
-      expect( result ).toEqual( ["Required field is not provided"] )
+      }
+      assertValidateParam(param, ["Required field is not provided"])
 
       // invalid number, undefined value
-      param = fromJS({
+      param = {
         required: true,
         type: "number",
         value: undefined
-      })
-      result = validateParam( param, false )
-      expect( result ).toEqual( ["Required field is not provided"] )
+      }
+      assertValidateParam(param, ["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 )
-      expect( result ).toEqual( [] )
+      }
+      assertValidateParam(param, [])
 
       // valid negative number with min and max
-      param = fromJS({
+      param = {
         required: true,
         type: "number",
         value: -10,
         minimum: -50,
         maximum: -5
-      })
-      result = validateParam( param, false )
-      expect( result ).toEqual( [] )
+      }
+      assertValidateParam(param, [])
 
       // invalid number with maximum:0
-      param = fromJS({
+      param = {
         required: true,
         type: "number",
         value: 1,
         maximum: 0
-      })
-      result = validateParam( param, false )
-      expect( result ).toEqual( ["Value must be less than Maximum"] )
+      }
+      assertValidateParam(param, ["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 )
-      expect( result ).toEqual( ["Value must be greater than Minimum"] )
+      }
+      assertValidateParam(param, ["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 )
-      expect( result ).toEqual( ["Value must be a number"] )
+      }
+      assertValidateParam(param, ["Value must be a number"])
 
       // valid (empty) number
-      param = fromJS({
+      param = {
         required: false,
         type: "number",
         value: undefined
-      })
-      result = validateParam( param, false )
-      expect( result ).toEqual( [] )
+      }
+      assertValidateParam(param, [])
 
       // valid number
-      param = fromJS({
+      param = {
         required: false,
         type: "number",
         value: 10
-      })
-      result = validateParam( param, false )
-      expect( result ).toEqual( [] )
+      }
+      assertValidateParam(param, [])
     })
 
     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 )
-      expect( result ).toEqual( ["Required field is not provided"] )
+      }
+      assertValidateParam(param, ["Required field is not provided"])
 
       // invalid integer, undefined value
-      param = fromJS({
+      param = {
         required: true,
         type: "integer",
         value: undefined
-      })
-      result = validateParam( param, false )
-      expect( result ).toEqual( ["Required field is not provided"] )
+      }
+      assertValidateParam(param, ["Required field is not provided"])
 
       // valid integer
-      param = fromJS({
+      param = {
         required: true,
         type: "integer",
         value: 10
-      })
-      result = validateParam( param, false )
-      expect( result ).toEqual( [] )
+      }
+      assertValidateParam(param, [])
     })
 
     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 )
-      expect( result ).toEqual( ["Value must be an integer"] )
+      }
+      assertValidateParam(param, ["Value must be an integer"])
 
       // valid (empty) integer
-      param = fromJS({
+      param = {
         required: false,
         type: "integer",
         value: undefined
-      })
-      result = validateParam( param, false )
-      expect( result ).toEqual( [] )
+      }
+      assertValidateParam(param, [])
 
       // integers
-      param = fromJS({
+      param = {
         required: false,
         type: "integer",
         value: 10
-      })
-      result = validateParam( param, false )
-      expect( result ).toEqual( [] )
+      }
+      assertValidateParam(param, [])
     })
   })
 

From 4705502efb5498424db0fd502fa22048a45a01f2 Mon Sep 17 00:00:00 2001
From: kyle <shockey@users.noreply.github.com>
Date: Thu, 12 Oct 2017 13:43:33 -0700
Subject: [PATCH 5/5] `Good first contribution` -> `Good first issue`

---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index ad54344f..81dcd63c 100644
--- a/README.md
+++ b/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.