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

Update all the validateParam tests to use the assertValidateParam factory

Browse Source
This commit is contained in:
Owen Conti
2017-10-11 19:50:02 -06:00
parent 537b6d88b5
commit 18a681e231
1 changed files with 113 additions and 150 deletions
Download Patch File Download Diff File Expand all files Collapse all files

263
test/core/utils.js
View File

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