kyy/swagger-ui
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Added tests for isOAS3 in validateParam function.

Browse Source
This commit is contained in:
Owen Conti
2017-10-11 18:34:24 -06:00
parent a0f8f9a05d
commit 7344315c34
5 changed files with 465 additions and 404 deletions
Download Patch File Download Diff File Expand all files Collapse all files

7
src/core/plugins/spec/actions.js
View File

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

4
src/core/plugins/spec/reducers.js
View File

@@ -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 operation = state.getIn( [ "resolved", "paths", ...pathMethod ] )
let isXml = /xml/i.test(operation.get("consumes_value")) let isXml = /xml/i.test(operation.get("consumes_value"))
return state.updateIn( [ "resolved", "paths", ...pathMethod, "parameters" ], fromJS([]), parameters => { return state.updateIn( [ "resolved", "paths", ...pathMethod, "parameters" ], fromJS([]), parameters => {
return parameters.withMutations( parameters => { return parameters.withMutations( parameters => {
for ( let i = 0, len = parameters.count(); i < len; i++ ) { 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)) parameters.setIn([i, "errors"], fromJS(errors))
} }
}) })

4
src/core/plugins/spec/wrap-actions.js
View File

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

6
src/core/utils.js
View File

@@ -537,12 +537,12 @@ export const validateMinLength = (val, min) => {
} }
// validation of parameters before execute // validation of parameters before execute
export const validateParam = (param, isXml) => { export const validateParam = (param, isXml, isOAS3 = false) => {
let errors = [] let errors = []
let value = isXml && param.get("in") === "body" ? param.get("value_xml") : param.get("value") let value = isXml && param.get("in") === "body" ? param.get("value_xml") : param.get("value")
let required = param.get("required") let required = param.get("required")
let paramDetails = param.get("schema") || param let paramDetails = isOAS3 ? param.get("schema") : param
let maximum = paramDetails.get("maximum") let maximum = paramDetails.get("maximum")
let minimum = paramDetails.get("minimum") let minimum = paramDetails.get("minimum")
let type = paramDetails.get("type") let type = paramDetails.get("type")
@@ -618,7 +618,7 @@ export const validateParam = (param, isXml) => {
if ( !value.count() ) { return errors } if ( !value.count() ) { return errors }
itemType = param.getIn(["items", "type"]) itemType = paramDetails.getIn(["items", "type"])
value.forEach((item, index) => { value.forEach((item, index) => {
let err let err

848
test/core/utils.js
View File

@@ -274,464 +274,518 @@ describe("utils", function() {
}) })
describe("validateParam", function() { describe("validateParam", function() {
let param = null
let result = null
it("skips validation when `type` is not specified", function() { describe("OAS3 specs", function() {
// invalid type let param = null
param = fromJS({ let result = null
required: false,
type: undefined, it("should check the isOAS3 flag when validating parameters", function() {
value: "" // 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"] )
}) })
result = validateParam( param, false )
expect( result ).toEqual( [] )
}) })
it("validates required strings", function() { describe("Swagger 2.0 specs", function() {
// invalid string let param = null
param = fromJS({ let result = null
required: true,
type: "string",
value: ""
})
result = validateParam( param, false )
expect( result ).toEqual( ["Required field is not provided"] )
// valid string it("validates required strings", function() {
param = fromJS({ // invalid string
required: true, param = fromJS({
type: "string", required: true,
value: "test string" type: "string",
}) value: ""
result = validateParam( param, false ) })
expect( result ).toEqual( [] ) result = validateParam( param, false )
expect( result ).toEqual( ["Required field is not provided"] )
// valid string with min and max length // valid string
param = fromJS({ param = fromJS({
required: true, required: true,
type: "string", type: "string",
value: "test string", value: "test string"
maxLength: 50, })
minLength: 1 result = validateParam( param, false )
}) expect( result ).toEqual( [] )
result = validateParam( param, false )
expect( result ).toEqual( [] )
})
it("validates required strings with min and max length", function() { // valid string with min and max length
// invalid string with max length param = fromJS({
param = fromJS({ required: true,
required: true, type: "string",
type: "string", value: "test string",
value: "test string", maxLength: 50,
maxLength: 5 minLength: 1
})
result = validateParam( param, false )
expect( result ).toEqual( [] )
}) })
result = validateParam( param, false )
expect( result ).toEqual( ["Value must be less than MaxLength"] )
// invalid string with max length 0 it("validates required strings with min and max length", function() {
param = fromJS({ // invalid string with max length
required: true, param = fromJS({
type: "string", required: true,
value: "test string", type: "string",
maxLength: 0 value: "test string",
}) maxLength: 5
result = validateParam( param, false ) })
expect( result ).toEqual( ["Value must be less than MaxLength"] ) 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 // invalid string with min length
param = fromJS({ param = fromJS({
required: true, required: true,
type: "string", type: "string",
value: "test string", value: "test string",
minLength: 50 minLength: 50
})
result = validateParam( param, false )
expect( result ).toEqual( ["Value must be greater than MinLength"] )
}) })
result = validateParam( param, false )
expect( result ).toEqual( ["Value must be greater than MinLength"] )
})
it("validates optional strings", function() { it("validates optional strings", function() {
// valid (empty) string // valid (empty) string
param = fromJS({ param = fromJS({
required: false, required: false,
type: "string", type: "string",
value: "" value: ""
}) })
result = validateParam( param, false ) result = validateParam( param, false )
expect( result ).toEqual( [] ) expect( result ).toEqual( [] )
// valid string // valid string
param = fromJS({ param = fromJS({
required: false, required: false,
type: "string", type: "string",
value: "test" value: "test"
})
result = validateParam( param, false )
expect( result ).toEqual( [] )
}) })
result = validateParam( param, false )
expect( result ).toEqual( [] )
})
it("validates required files", function() { it("validates required files", function() {
// invalid file // invalid file
param = fromJS({ param = fromJS({
required: true, required: true,
type: "file", type: "file",
value: undefined value: undefined
}) })
result = validateParam( param, false ) result = validateParam( param, false )
expect( result ).toEqual( ["Required field is not provided"] ) expect( result ).toEqual( ["Required field is not provided"] )
// valid file // valid file
param = fromJS({ param = fromJS({
required: true, required: true,
type: "file", type: "file",
value: new win.File() value: new win.File()
})
result = validateParam( param, false )
expect( result ).toEqual( [] )
}) })
result = validateParam( param, false )
expect( result ).toEqual( [] )
})
it("validates optional files", function() { it("validates optional files", function() {
// invalid file // invalid file
param = fromJS({ param = fromJS({
required: false, required: false,
type: "file", type: "file",
value: "not a file" value: "not a file"
}) })
result = validateParam( param, false ) result = validateParam( param, false )
expect( result ).toEqual( ["Value must be a file"] ) expect( result ).toEqual( ["Value must be a file"] )
// valid (empty) file // valid (empty) file
param = fromJS({ param = fromJS({
required: false, required: false,
type: "file", type: "file",
value: undefined value: undefined
}) })
result = validateParam( param, false ) result = validateParam( param, false )
expect( result ).toEqual( [] ) expect( result ).toEqual( [] )
// valid file // valid file
param = fromJS({ param = fromJS({
required: false, required: false,
type: "file", type: "file",
value: new win.File() value: new win.File()
})
result = validateParam( param, false )
expect( result ).toEqual( [] )
}) })
result = validateParam( param, false )
expect( result ).toEqual( [] )
})
it("validates required arrays", function() { it("validates required arrays", function() {
// invalid (empty) array // invalid (empty) array
param = fromJS({ param = fromJS({
required: true, required: true,
type: "array", type: "array",
value: [] value: []
}) })
result = validateParam( param, false ) result = validateParam( param, false )
expect( result ).toEqual( ["Required field is not provided"] ) expect( result ).toEqual( ["Required field is not provided"] )
// invalid (not an array) // invalid (not an array)
param = fromJS({ param = fromJS({
required: true, required: true,
type: "array", type: "array",
value: undefined value: undefined
}) })
result = validateParam( param, false ) result = validateParam( param, false )
expect( result ).toEqual( ["Required field is not provided"] ) expect( result ).toEqual( ["Required field is not provided"] )
// invalid array, items do not match correct type // invalid array, items do not match correct type
param = fromJS({ param = fromJS({
required: true, required: true,
type: "array", type: "array",
value: [1], value: [1],
items: { items: {
type: "string" type: "string"
} }
}) })
result = validateParam( param, false ) result = validateParam( param, false )
expect( result ).toEqual( [{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 // valid array, with no 'type' for items
param = fromJS({ param = fromJS({
required: true, required: true,
type: "array", type: "array",
value: ["1"] value: ["1"]
}) })
result = validateParam( param, false ) result = validateParam( param, false )
expect( result ).toEqual( [] ) expect( result ).toEqual( [] )
// valid array, items match type // valid array, items match type
param = fromJS({ param = fromJS({
required: true, required: true,
type: "array", type: "array",
value: ["1"], value: ["1"],
items: { items: {
type: "string" type: "string"
} }
})
result = validateParam( param, false )
expect( result ).toEqual( [] )
}) })
result = validateParam( param, false )
expect( result ).toEqual( [] )
})
it("validates optional arrays", function() { it("validates optional arrays", function() {
// valid, empty array // valid, empty array
param = fromJS({ param = fromJS({
required: false, required: false,
type: "array", type: "array",
value: [] value: []
}) })
result = validateParam( param, false ) result = validateParam( param, false )
expect( result ).toEqual( [] ) expect( result ).toEqual( [] )
// invalid, items do not match correct type // invalid, items do not match correct type
param = fromJS({ param = fromJS({
required: false, required: false,
type: "array", type: "array",
value: ["number"], value: ["number"],
items: { items: {
type: "number" type: "number"
} }
}) })
result = validateParam( param, false ) result = validateParam( param, false )
expect( result ).toEqual( [{index: 0, error: "Value must be a number"}] ) expect( result ).toEqual( [{index: 0, error: "Value must be a number"}] )
// valid // valid
param = fromJS({ param = fromJS({
required: false, required: false,
type: "array", type: "array",
value: ["test"], value: ["test"],
items: { items: {
type: "string" type: "string"
} }
})
result = validateParam( param, false )
expect( result ).toEqual( [] )
}) })
result = validateParam( param, false )
expect( result ).toEqual( [] )
})
it("validates required booleans", function() { it("validates required booleans", function() {
// invalid boolean value // invalid boolean value
param = fromJS({ param = fromJS({
required: true, required: true,
type: "boolean", type: "boolean",
value: undefined value: undefined
}) })
result = validateParam( param, false ) result = validateParam( param, false )
expect( result ).toEqual( ["Required field is not provided"] ) expect( result ).toEqual( ["Required field is not provided"] )
// invalid boolean value (not a boolean) // invalid boolean value (not a boolean)
param = fromJS({ param = fromJS({
required: true, required: true,
type: "boolean", type: "boolean",
value: "test string" value: "test string"
}) })
result = validateParam( param, false ) result = validateParam( param, false )
expect( result ).toEqual( ["Required field is not provided"] ) expect( result ).toEqual( ["Required field is not provided"] )
// valid boolean value // valid boolean value
param = fromJS({ param = fromJS({
required: true, required: true,
type: "boolean", type: "boolean",
value: "true" value: "true"
}) })
result = validateParam( param, false ) result = validateParam( param, false )
expect( result ).toEqual( [] ) expect( result ).toEqual( [] )
// valid boolean value // valid boolean value
param = fromJS({ param = fromJS({
required: true, required: true,
type: "boolean", type: "boolean",
value: false value: false
})
result = validateParam( param, false )
expect( result ).toEqual( [] )
}) })
result = validateParam( param, false )
expect( result ).toEqual( [] )
})
it("validates optional booleans", function() { it("validates optional booleans", function() {
// valid (empty) boolean value // valid (empty) boolean value
param = fromJS({ param = fromJS({
required: false, required: false,
type: "boolean", type: "boolean",
value: undefined value: undefined
}) })
result = validateParam( param, false ) result = validateParam( param, false )
expect( result ).toEqual( [] ) expect( result ).toEqual( [] )
// invalid boolean value (not a boolean) // invalid boolean value (not a boolean)
param = fromJS({ param = fromJS({
required: false, required: false,
type: "boolean", type: "boolean",
value: "test string" value: "test string"
}) })
result = validateParam( param, false ) result = validateParam( param, false )
expect( result ).toEqual( ["Value must be a boolean"] ) expect( result ).toEqual( ["Value must be a boolean"] )
// valid boolean value // valid boolean value
param = fromJS({ param = fromJS({
required: false, required: false,
type: "boolean", type: "boolean",
value: "true" value: "true"
}) })
result = validateParam( param, false ) result = validateParam( param, false )
expect( result ).toEqual( [] ) expect( result ).toEqual( [] )
// valid boolean value // valid boolean value
param = fromJS({ param = fromJS({
required: false, required: false,
type: "boolean", type: "boolean",
value: false value: false
})
result = validateParam( param, false )
expect( result ).toEqual( [] )
}) })
result = validateParam( param, false )
expect( result ).toEqual( [] )
})
it("validates required numbers", function() { it("validates required numbers", function() {
// invalid number, string instead of a number // invalid number, string instead of a number
param = fromJS({ param = fromJS({
required: true, required: true,
type: "number", type: "number",
value: "test" value: "test"
}) })
result = validateParam( param, false ) result = validateParam( param, false )
expect( result ).toEqual( ["Required field is not provided"] ) expect( result ).toEqual( ["Required field is not provided"] )
// invalid number, undefined value // invalid number, undefined value
param = fromJS({ param = fromJS({
required: true, required: true,
type: "number", type: "number",
value: undefined value: undefined
}) })
result = validateParam( param, false ) result = validateParam( param, false )
expect( result ).toEqual( ["Required field is not provided"] ) expect( result ).toEqual( ["Required field is not provided"] )
// valid number with min and max // valid number with min and max
param = fromJS({ param = fromJS({
required: true, required: true,
type: "number", type: "number",
value: 10, value: 10,
minimum: 5, minimum: 5,
maximum: 99 maximum: 99
}) })
result = validateParam( param, false ) result = validateParam( param, false )
expect( result ).toEqual( [] ) expect( result ).toEqual( [] )
// valid negative number with min and max // valid negative number with min and max
param = fromJS({ param = fromJS({
required: true, required: true,
type: "number", type: "number",
value: -10, value: -10,
minimum: -50, minimum: -50,
maximum: -5 maximum: -5
}) })
result = validateParam( param, false ) result = validateParam( param, false )
expect( result ).toEqual( [] ) expect( result ).toEqual( [] )
// invalid number with maximum:0 // invalid number with maximum:0
param = fromJS({ param = fromJS({
required: true, required: true,
type: "number", type: "number",
value: 1, value: 1,
maximum: 0 maximum: 0
}) })
result = validateParam( param, false ) result = validateParam( param, false )
expect( result ).toEqual( ["Value must be less than Maximum"] ) expect( result ).toEqual( ["Value must be less than Maximum"] )
// invalid number with minimum:0 // invalid number with minimum:0
param = fromJS({ param = fromJS({
required: true, required: true,
type: "number", type: "number",
value: -10, value: -10,
minimum: 0 minimum: 0
})
result = validateParam( param, false )
expect( result ).toEqual( ["Value must be greater than Minimum"] )
}) })
result = validateParam( param, false )
expect( result ).toEqual( ["Value must be greater than Minimum"] )
})
it("validates optional numbers", function() { it("validates optional numbers", function() {
// invalid number, string instead of a number // invalid number, string instead of a number
param = fromJS({ param = fromJS({
required: false, required: false,
type: "number", type: "number",
value: "test" value: "test"
}) })
result = validateParam( param, false ) result = validateParam( param, false )
expect( result ).toEqual( ["Value must be a number"] ) expect( result ).toEqual( ["Value must be a number"] )
// valid (empty) number // valid (empty) number
param = fromJS({ param = fromJS({
required: false, required: false,
type: "number", type: "number",
value: undefined value: undefined
}) })
result = validateParam( param, false ) result = validateParam( param, false )
expect( result ).toEqual( [] ) expect( result ).toEqual( [] )
// valid number // valid number
param = fromJS({ param = fromJS({
required: false, required: false,
type: "number", type: "number",
value: 10 value: 10
})
result = validateParam( param, false )
expect( result ).toEqual( [] )
}) })
result = validateParam( param, false )
expect( result ).toEqual( [] )
})
it("validates required integers", function() { it("validates required integers", function() {
// invalid integer, string instead of an integer // invalid integer, string instead of an integer
param = fromJS({ param = fromJS({
required: true, required: true,
type: "integer", type: "integer",
value: "test" value: "test"
}) })
result = validateParam( param, false ) result = validateParam( param, false )
expect( result ).toEqual( ["Required field is not provided"] ) expect( result ).toEqual( ["Required field is not provided"] )
// invalid integer, undefined value // invalid integer, undefined value
param = fromJS({ param = fromJS({
required: true, required: true,
type: "integer", type: "integer",
value: undefined value: undefined
}) })
result = validateParam( param, false ) result = validateParam( param, false )
expect( result ).toEqual( ["Required field is not provided"] ) expect( result ).toEqual( ["Required field is not provided"] )
// valid integer // valid integer
param = fromJS({ param = fromJS({
required: true, required: true,
type: "integer", type: "integer",
value: 10 value: 10
})
result = validateParam( param, false )
expect( result ).toEqual( [] )
}) })
result = validateParam( param, false )
expect( result ).toEqual( [] )
})
it("validates optional integers", function() { it("validates optional integers", function() {
// invalid integer, string instead of an integer // invalid integer, string instead of an integer
param = fromJS({ param = fromJS({
required: false, required: false,
type: "integer", type: "integer",
value: "test" value: "test"
}) })
result = validateParam( param, false ) result = validateParam( param, false )
expect( result ).toEqual( ["Value must be an integer"] ) expect( result ).toEqual( ["Value must be an integer"] )
// valid (empty) integer // valid (empty) integer
param = fromJS({ param = fromJS({
required: false, required: false,
type: "integer", type: "integer",
value: undefined value: undefined
}) })
result = validateParam( param, false ) result = validateParam( param, false )
expect( result ).toEqual( [] ) expect( result ).toEqual( [] )
// integers // integers
param = fromJS({ param = fromJS({
required: false, required: false,
type: "integer", type: "integer",
value: 10 value: 10
})
result = validateParam( param, false )
expect( result ).toEqual( [] )
}) })
result = validateParam( param, false )
expect( result ).toEqual( [] )
}) })
}) })