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

bug: parameter allowEmptyValue + required interactions (via #5142)

Browse Source 
* add failing tests
* standardize parameter keying
* validateParam test migrations
* migrate test cases to new pattern
* disambiguate name/in ordering in `body.body` test cases
* `name+in`=> `{in}.{name}`
* consider allowEmptyValue parameter inclusion in runtime validation
* use config object for all validateParam options
* drop isXml flag from validateParams
This commit is contained in:
kyle
2019-01-29 16:46:03 -06:00
committed by GitHub
parent be3500c299
commit abf34961e9
9 changed files with 719 additions and 383 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -5,7 +5,7 @@ import serializeError from "serialize-error"
import isString from "lodash/isString"
import debounce from "lodash/debounce"
import set from "lodash/set"
import { isJSONObject } from "core/utils"
import { isJSONObject, paramToValue } from "core/utils"
// Actions conform to FSA (flux-standard-actions)
// {type: string,payload: Any|Error, meta: obj, error: bool}
@@ -345,19 +345,19 @@ export const executeRequest = (req) =>
// ensure that explicitly-included params are in the request
if(op && op.parameters && op.parameters.length) {
op.parameters
.filter(param => param && param.allowEmptyValue === true)
if (operation && operation.get("parameters")) {
operation.get("parameters")
.filter(param => param && param.get("allowEmptyValue") === true)
.forEach(param => {
if (specSelectors.parameterInclusionSettingFor([pathName, method], param.name, param.in)) {
if (specSelectors.parameterInclusionSettingFor([pathName, method], param.get("name"), param.get("in"))) {
req.parameters = req.parameters || {}
const paramValue = req.parameters[param.name]
const paramValue = paramToValue(param, req.parameters)
// if the value is falsy or an empty Immutable iterable...
if(!paramValue || (paramValue && paramValue.size === 0)) {
// set it to empty string, so Swagger Client will treat it as
// present but empty.
req.parameters[param.name] = ""
req.parameters[param.get("name")] = ""
}
}
})

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

@@ -1,10 +1,12 @@
import { fromJS, List } from "immutable"
import { fromJSOrdered, validateParam } from "core/utils"
import { fromJSOrdered, validateParam, paramToValue } from "core/utils"
import win from "../../window"
// selector-in-reducer is suboptimal, but `operationWithMeta` is more of a helper
import {
operationWithMeta
specJsonWithResolvedSubtrees,
parameterValues,
parameterInclusionSettingFor,
} from "./selectors"
import {
@@ -25,6 +27,7 @@ import {
CLEAR_VALIDATE_PARAMS,
SET_SCHEME
} from "./actions"
import { paramToIdentifier } from "../../utils"
export default {
@@ -54,14 +57,7 @@ export default {
[UPDATE_PARAM]: ( state, {payload} ) => {
let { path: pathMethod, paramName, paramIn, param, value, isXml } = payload
let paramKey
// `hashCode` is an Immutable.js Map method
if(param && param.hashCode && !paramIn && !paramName) {
paramKey = `${param.get("name")}.${param.get("in")}.hash-${param.hashCode()}`
} else {
paramKey = `${paramName}.${paramIn}`
}
let paramKey = param ? paramToIdentifier(param) : `${paramIn}.${paramName}`
const valueKey = isXml ? "value_xml" : "value"
@@ -79,7 +75,7 @@ export default {
return state
}
const paramKey = `${paramName}.${paramIn}`
const paramKey = `${paramIn}.${paramName}`
return state.setIn(
["meta", "paths", ...pathMethod, "parameter_inclusions", paramKey],
@@ -88,15 +84,18 @@ export default {
},
[VALIDATE_PARAMS]: ( state, { payload: { pathMethod, isOAS3 } } ) => {
let meta = state.getIn( [ "meta", "paths", ...pathMethod ], fromJS({}) )
let isXml = /xml/i.test(meta.get("consumes_value"))
const op = operationWithMeta(state, ...pathMethod)
const op = specJsonWithResolvedSubtrees(state).getIn(["paths", ...pathMethod])
const paramValues = parameterValues(state, pathMethod).toJS()
return state.updateIn(["meta", "paths", ...pathMethod, "parameters"], fromJS({}), paramMeta => {
return op.get("parameters", List()).reduce((res, param) => {
const errors = validateParam(param, isXml, isOAS3)
return res.setIn([`${param.get("name")}.${param.get("in")}`, "errors"], fromJS(errors))
const value = paramToValue(param, paramValues)
const isEmptyValueIncluded = parameterInclusionSettingFor(state, pathMethod, param.get("name"), param.get("in"))
const errors = validateParam(param, value, {
bypassRequiredCheck: isEmptyValueIncluded,
isOAS3,
})
return res.setIn([paramToIdentifier(param), "errors"], fromJS(errors))
}, paramMeta)
})
},

11
src/core/plugins/spec/selectors.js
View File

@@ -1,6 +1,7 @@
import { createSelector } from "reselect"
import { sorters } from "core/utils"
import { fromJS, Set, Map, OrderedMap, List } from "immutable"
import { paramToIdentifier } from "../../utils"
const DEFAULT_TAG = "default"
@@ -302,11 +303,11 @@ export const parameterWithMetaByIdentity = (state, pathMethod, param) => {
const metaParams = state.getIn(["meta", "paths", ...pathMethod, "parameters"], OrderedMap())
const mergedParams = opParams.map((currentParam) => {
const nameInKeyedMeta = metaParams.get(`${param.get("name")}.${param.get("in")}`)
const hashKeyedMeta = metaParams.get(`${param.get("name")}.${param.get("in")}.hash-${param.hashCode()}`)
const inNameKeyedMeta = metaParams.get(`${param.get("in")}.${param.get("name")}`)
const hashKeyedMeta = metaParams.get(`${param.get("in")}.${param.get("name")}.hash-${param.hashCode()}`)
return OrderedMap().merge(
currentParam,
nameInKeyedMeta,
inNameKeyedMeta,
hashKeyedMeta
)
})
@@ -315,7 +316,7 @@ export const parameterWithMetaByIdentity = (state, pathMethod, param) => {
}
export const parameterInclusionSettingFor = (state, pathMethod, paramName, paramIn) => {
const paramKey = `${paramName}.${paramIn}`
const paramKey = `${paramIn}.${paramName}`
return state.getIn(["meta", "paths", ...pathMethod, "parameter_inclusions", paramKey], false)
}
@@ -364,7 +365,7 @@ export function parameterValues(state, pathMethod, isXml) {
let paramValues = operationWithMeta(state, ...pathMethod).get("parameters", List())
return paramValues.reduce( (hash, p) => {
let value = isXml && p.get("in") === "body" ? p.get("value_xml") : p.get("value")
return hash.set(`${p.get("in")}.${p.get("name")}`, value)
return hash.set(paramToIdentifier(p, { allowHashes: false }), value)
}, fromJS({}))
}

46
src/core/utils.js
View File

@@ -484,9 +484,8 @@ export const validatePattern = (val, rxPattern) => {
}
// validation of parameters before execute
export const validateParam = (param, isXml, isOAS3 = false) => {
export const validateParam = (param, value, { isOAS3 = false, bypassRequiredCheck = false } = {}) => {
let errors = []
let value = isXml && param.get("in") === "body" ? param.get("value_xml") : param.get("value")
let required = param.get("required")
let paramDetails = isOAS3 ? param.get("schema") : param
@@ -501,7 +500,6 @@ export const validateParam = (param, isXml, isOAS3 = false) => {
let minLength = paramDetails.get("minLength")
let pattern = paramDetails.get("pattern")
/*
If the parameter is required OR the parameter has a value (meaning optional, but filled in)
then we should do our validation routine.
@@ -540,7 +538,7 @@ export const validateParam = (param, isXml, isOAS3 = false) => {
const passedAnyCheck = allChecks.some(v => !!v)
if ( required && !passedAnyCheck ) {
if (required && !passedAnyCheck && !bypassRequiredCheck ) {
errors.push("Required field is not provided")
return errors
}
@@ -805,3 +803,43 @@ export function numberToString(thing) {
return thing
}
export function paramToIdentifier(param, { returnAll = false, allowHashes = true } = {}) {
if(!Im.Map.isMap(param)) {
throw new Error("paramToIdentifier: received a non-Im.Map parameter as input")
}
const paramName = param.get("name")
const paramIn = param.get("in")
let generatedIdentifiers = []
// Generate identifiers in order of most to least specificity
if (param && param.hashCode && paramIn && paramName && allowHashes) {
generatedIdentifiers.push(`${paramIn}.${paramName}.hash-${param.hashCode()}`)
}
if(paramIn && paramName) {
generatedIdentifiers.push(`${paramIn}.${paramName}`)
}
generatedIdentifiers.push(paramName)
// Return the most preferred identifier, or all if requested
return returnAll ? generatedIdentifiers : (generatedIdentifiers[0] || "")
}
export function paramToValue(param, paramValues) {
const allIdentifiers = paramToIdentifier(param, { returnAll: true })
// Map identifiers to values in the provided value hash, filter undefined values,
// and return the first value found
const values = allIdentifiers
.map(id => {
return paramValues[id]
})
.filter(value => value !== undefined)
return values[0]
}

14
test/core/plugins/spec/reducer.js
View File

@@ -130,7 +130,7 @@ describe("spec plugin - reducer", function(){
})
})
describe("SPEC_UPDATE_PARAM", function() {
it("should store parameter values by name+in", () => {
it("should store parameter values by {in}.{name}", () => {
const updateParam = reducer["spec_update_param"]
const path = "/pet/post"
@@ -140,14 +140,14 @@ describe("spec plugin - reducer", function(){
const result = updateParam(state, {
payload: {
path: [path, method],
paramName: "body",
paramName: "myBody",
paramIn: "body",
value: `{ "a": 123 }`,
isXml: false
}
})
const response = result.getIn(["meta", "paths", path, method, "parameters", "body.body", "value"])
const response = result.getIn(["meta", "paths", path, method, "parameters", "body.myBody", "value"])
expect(response).toEqual(`{ "a": 123 }`)
})
it("should store parameter values by identity", () => {
@@ -157,7 +157,7 @@ describe("spec plugin - reducer", function(){
const method = "POST"
const param = fromJS({
name: "body",
name: "myBody",
in: "body",
schema: {
type: "string"
@@ -174,12 +174,12 @@ describe("spec plugin - reducer", function(){
}
})
const value = result.getIn(["meta", "paths", path, method, "parameters", `body.body.hash-${param.hashCode()}`, "value"])
const value = result.getIn(["meta", "paths", path, method, "parameters", `body.myBody.hash-${param.hashCode()}`, "value"])
expect(value).toEqual(`{ "a": 123 }`)
})
})
describe("SPEC_UPDATE_EMPTY_PARAM_INCLUSION", function() {
it("should store parameter values by name+in", () => {
it("should store parameter values by {in}.{name}", () => {
const updateParam = reducer["spec_update_empty_param_inclusion"]
const path = "/pet/post"
@@ -196,7 +196,7 @@ describe("spec plugin - reducer", function(){
}
})
const response = result.getIn(["meta", "paths", path, method, "parameter_inclusions", "param.query"])
const response = result.getIn(["meta", "paths", path, method, "parameter_inclusions", "query.param"])
expect(response).toEqual(true)
})
})

50
test/core/plugins/spec/selectors.js
View File

@@ -497,7 +497,7 @@ describe("spec plugin - selectors", function(){
})
describe("operationWithMeta", function() {
it("should support merging in name+in keyed param metadata", function () {
it("should support merging in {in}.{name} keyed param metadata", function () {
const state = fromJS({
json: {
paths: {
@@ -505,7 +505,7 @@ describe("spec plugin - selectors", function(){
"get": {
parameters: [
{
name: "body",
name: "myBody",
in: "body"
}
]
@@ -518,7 +518,7 @@ describe("spec plugin - selectors", function(){
"/": {
"get": {
parameters: {
"body.body": {
"body.myBody": {
value: "abc123"
}
}
@@ -533,7 +533,7 @@ describe("spec plugin - selectors", function(){
expect(result.toJS()).toEqual({
parameters: [
{
name: "body",
name: "myBody",
in: "body",
value: "abc123"
}
@@ -542,7 +542,7 @@ describe("spec plugin - selectors", function(){
})
it("should support merging in hash-keyed param metadata", function () {
const bodyParam = fromJS({
name: "body",
name: "myBody",
in: "body"
})
@@ -563,7 +563,7 @@ describe("spec plugin - selectors", function(){
"/": {
"get": {
parameters: {
[`body.body.hash-${bodyParam.hashCode()}`]: {
[`body.myBody.hash-${bodyParam.hashCode()}`]: {
value: "abc123"
}
}
@@ -578,7 +578,7 @@ describe("spec plugin - selectors", function(){
expect(result.toJS()).toEqual({
parameters: [
{
name: "body",
name: "myBody",
in: "body",
value: "abc123"
}
@@ -587,7 +587,7 @@ describe("spec plugin - selectors", function(){
})
})
describe("parameterWithMeta", function() {
it("should support merging in name+in keyed param metadata", function () {
it("should support merging in {in}.{name} keyed param metadata", function () {
const state = fromJS({
json: {
paths: {
@@ -595,7 +595,7 @@ describe("spec plugin - selectors", function(){
"get": {
parameters: [
{
name: "body",
name: "myBody",
in: "body"
}
]
@@ -608,7 +608,7 @@ describe("spec plugin - selectors", function(){
"/": {
"get": {
parameters: {
"body.body": {
"body.myBody": {
value: "abc123"
}
}
@@ -618,17 +618,17 @@ describe("spec plugin - selectors", function(){
}
})
const result = parameterWithMeta(state, ["/", "get"], "body", "body")
const result = parameterWithMeta(state, ["/", "get"], "myBody", "body")
expect(result.toJS()).toEqual({
name: "body",
name: "myBody",
in: "body",
value: "abc123"
})
})
it("should give best-effort when encountering hash-keyed param metadata", function () {
const bodyParam = fromJS({
name: "body",
name: "myBody",
in: "body"
})
@@ -649,7 +649,7 @@ describe("spec plugin - selectors", function(){
"/": {
"get": {
parameters: {
[`body.body.hash-${bodyParam.hashCode()}`]: {
[`body.myBody.hash-${bodyParam.hashCode()}`]: {
value: "abc123"
}
}
@@ -659,10 +659,10 @@ describe("spec plugin - selectors", function(){
}
})
const result = parameterWithMeta(state, ["/", "get"], "body", "body")
const result = parameterWithMeta(state, ["/", "get"], "myBody", "body")
expect(result.toJS()).toEqual({
name: "body",
name: "myBody",
in: "body",
value: "abc123"
})
@@ -670,9 +670,9 @@ describe("spec plugin - selectors", function(){
})
describe("parameterWithMetaByIdentity", function() {
it("should support merging in name+in keyed param metadata", function () {
it("should support merging in {in}.{name} keyed param metadata", function () {
const bodyParam = fromJS({
name: "body",
name: "myBody",
in: "body"
})
@@ -691,7 +691,7 @@ describe("spec plugin - selectors", function(){
"/": {
"get": {
parameters: {
"body.body": {
"body.myBody": {
value: "abc123"
}
}
@@ -704,14 +704,14 @@ describe("spec plugin - selectors", function(){
const result = parameterWithMetaByIdentity(state, ["/", "get"], bodyParam)
expect(result.toJS()).toEqual({
name: "body",
name: "myBody",
in: "body",
value: "abc123"
})
})
it("should support merging in hash-keyed param metadata", function () {
const bodyParam = fromJS({
name: "body",
name: "myBody",
in: "body"
})
@@ -732,7 +732,7 @@ describe("spec plugin - selectors", function(){
"/": {
"get": {
parameters: {
[`body.body.hash-${bodyParam.hashCode()}`]: {
[`body.myBody.hash-${bodyParam.hashCode()}`]: {
value: "abc123"
}
}
@@ -745,14 +745,14 @@ describe("spec plugin - selectors", function(){
const result = parameterWithMetaByIdentity(state, ["/", "get"], bodyParam)
expect(result.toJS()).toEqual({
name: "body",
name: "myBody",
in: "body",
value: "abc123"
})
})
})
describe("parameterInclusionSettingFor", function() {
it("should support getting name+in param inclusion settings", function () {
it("should support getting {in}.{name} param inclusion settings", function () {
const param = fromJS({
name: "param",
in: "query",
@@ -776,7 +776,7 @@ describe("spec plugin - selectors", function(){
"/": {
"get": {
"parameter_inclusions": {
[`param.query`]: true
[`query.param`]: true
}
}
}

465
test/core/utils.js
View File

@@ -25,7 +25,9 @@ import {
sanitizeUrl,
extractFileNameFromContentDispositionHeader,
deeplyStripKey,
getSampleSchema
getSampleSchema,
paramToIdentifier,
paramToValue,
} from "core/utils"
import win from "core/window"
@@ -342,30 +344,33 @@ describe("utils", function() {
describe("validateParam", function() {
let param = null
let value = null
let result = null
const assertValidateParam = (param, expectedError) => {
const assertValidateParam = (param, value, expectedError) => {
// Swagger 2.0 version
result = validateParam( fromJS(param), false )
result = validateParam( fromJS(param), fromJS(value))
expect( result ).toEqual( expectedError )
// OAS3 version, using `schema` sub-object
let oas3Param = {
value: param.value,
required: param.required,
schema: {
...param,
value: undefined,
required: undefined
}
}
result = validateParam( fromJS(oas3Param), false, true )
result = validateParam( fromJS(oas3Param), fromJS(value), {
isOAS3: true
})
expect( result ).toEqual( expectedError )
}
const assertValidateOas3Param = (param, expectedError) => {
const assertValidateOas3Param = (param, value, expectedError) => {
// for cases where you _only_ want to try OAS3
result = validateParam( fromJS(param), false, true )
result = validateParam(fromJS(param), value, {
isOAS3: true
})
expect( result ).toEqual( expectedError )
}
@@ -373,10 +378,12 @@ describe("utils", function() {
// This should "skip" validation because there is no `schema` property
// and we are telling `validateParam` this is an OAS3 spec
param = fromJS({
value: "",
required: true
})
result = validateParam( param, false, true )
value = ""
result = validateParam( param, value, {
isOAS3: true
} )
expect( result ).toEqual( [] )
})
@@ -386,34 +393,34 @@ describe("utils", function() {
required: true,
schema: {
type: "object"
},
value: {
}
}
value = {
abc: 123
}
}
assertValidateOas3Param(param, [])
assertValidateOas3Param(param, value, [])
// valid object-as-string
param = {
required: true,
schema: {
type: "object"
},
value: JSON.stringify({
}
}
value = JSON.stringify({
abc: 123
})
}
assertValidateOas3Param(param, [])
assertValidateOas3Param(param, value, [])
// invalid object-as-string
param = {
required: true,
schema: {
type: "object"
},
value: "{{}"
}
assertValidateOas3Param(param, ["Parameter string value must be valid JSON"])
}
value = "{{}"
assertValidateOas3Param(param, value, ["Parameter string value must be valid JSON"])
// missing when required
param = {
@@ -422,7 +429,8 @@ describe("utils", function() {
type: "object"
},
}
assertValidateOas3Param(param, ["Required field is not provided"])
value = undefined
assertValidateOas3Param(param, value, ["Required field is not provided"])
})
it("validates optional OAS3 objects", function() {
@@ -430,32 +438,32 @@ describe("utils", function() {
param = {
schema: {
type: "object"
},
value: {
}
}
value = {
abc: 123
}
}
assertValidateOas3Param(param, [])
assertValidateOas3Param(param, value, [])
// valid object-as-string
param = {
schema: {
type: "object"
},
value: JSON.stringify({
}
}
value = JSON.stringify({
abc: 123
})
}
assertValidateOas3Param(param, [])
assertValidateOas3Param(param, value, [])
// invalid object-as-string
param = {
schema: {
type: "object"
},
value: "{{}"
}
assertValidateOas3Param(param, ["Parameter string value must be valid JSON"])
}
value = "{{}"
assertValidateOas3Param(param, value, ["Parameter string value must be valid JSON"])
// missing when not required
param = {
@@ -463,35 +471,36 @@ describe("utils", function() {
type: "object"
},
}
assertValidateOas3Param(param, [])
value = undefined
assertValidateOas3Param(param, value, [])
})
it("validates required strings", function() {
// invalid string
param = {
required: true,
type: "string",
value: ""
type: "string"
}
assertValidateParam(param, ["Required field is not provided"])
value = ""
assertValidateParam(param, value, ["Required field is not provided"])
// valid string
param = {
required: true,
type: "string",
value: "test string"
type: "string"
}
assertValidateParam(param, [])
value = "test string"
assertValidateParam(param, value, [])
// valid string with min and max length
param = {
required: true,
type: "string",
value: "test string",
maxLength: 50,
minLength: 1
}
assertValidateParam(param, [])
value = "test string"
assertValidateParam(param, value, [])
})
it("validates required strings with min and max length", function() {
@@ -499,380 +508,381 @@ describe("utils", function() {
param = {
required: true,
type: "string",
value: "test string",
maxLength: 5
}
assertValidateParam(param, ["Value must be less than MaxLength"])
value = "test string"
assertValidateParam(param, value, ["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"])
value = "test string"
assertValidateParam(param, value, ["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"])
value = "test string"
assertValidateParam(param, value, ["Value must be greater than MinLength"])
})
it("validates optional strings", function() {
// valid (empty) string
param = {
required: false,
type: "string",
value: ""
type: "string"
}
assertValidateParam(param, [])
value = ""
assertValidateParam(param, value, [])
// valid string
param = {
required: false,
type: "string",
value: "test"
type: "string"
}
assertValidateParam(param, [])
value = "test"
assertValidateParam(param, value, [])
})
it("validates required files", function() {
// invalid file
param = {
required: true,
type: "file",
value: undefined
type: "file"
}
assertValidateParam(param, ["Required field is not provided"])
value = undefined
assertValidateParam(param, value, ["Required field is not provided"])
// valid file
param = {
required: true,
type: "file",
value: new win.File()
type: "file"
}
assertValidateParam(param, [])
value = new win.File()
assertValidateParam(param, value, [])
})
it("validates optional files", function() {
// invalid file
param = {
required: false,
type: "file",
value: "not a file"
type: "file"
}
assertValidateParam(param, ["Value must be a file"])
value = "not a file"
assertValidateParam(param, value, ["Value must be a file"])
// valid (empty) file
param = {
required: false,
type: "file",
value: undefined
type: "file"
}
assertValidateParam(param, [])
value = undefined
assertValidateParam(param, value, [])
// valid file
param = {
required: false,
type: "file",
value: new win.File()
type: "file"
}
assertValidateParam(param, [])
value = new win.File()
assertValidateParam(param, value, [])
})
it("validates required arrays", function() {
// invalid (empty) array
param = {
required: true,
type: "array",
value: []
type: "array"
}
assertValidateParam(param, ["Required field is not provided"])
value = []
assertValidateParam(param, value, ["Required field is not provided"])
// invalid (not an array)
param = {
required: true,
type: "array",
value: undefined
type: "array"
}
assertValidateParam(param, ["Required field is not provided"])
value = undefined
assertValidateParam(param, value, ["Required field is not provided"])
// invalid array, items do not match correct type
param = {
required: true,
type: "array",
value: [1],
items: {
type: "string"
}
}
assertValidateParam(param, [{index: 0, error: "Value must be a string"}])
value = [1]
assertValidateParam(param, value, [{index: 0, error: "Value must be a string"}])
// valid array, with no 'type' for items
param = {
required: true,
type: "array",
value: ["1"]
type: "array"
}
assertValidateParam(param, [])
value = [1]
assertValidateParam(param, value, [])
// valid array, items match type
param = {
required: true,
type: "array",
value: ["1"],
items: {
type: "string"
}
}
assertValidateParam(param, [])
value = ["1"]
assertValidateParam(param, value, [])
})
it("validates optional arrays", function() {
// valid, empty array
param = {
required: false,
type: "array",
value: []
type: "array"
}
assertValidateParam(param, [])
value = []
assertValidateParam(param, value, [])
// invalid, items do not match correct type
param = {
required: false,
type: "array",
value: ["number"],
items: {
type: "number"
}
}
assertValidateParam(param, [{index: 0, error: "Value must be a number"}])
value = ["number"]
assertValidateParam(param, value, [{index: 0, error: "Value must be a number"}])
// valid
param = {
required: false,
type: "array",
value: ["test"],
items: {
type: "string"
}
}
assertValidateParam(param, [])
value = ["test"]
assertValidateParam(param, value, [])
})
it("validates required booleans", function() {
// invalid boolean value
param = {
required: true,
type: "boolean",
value: undefined
type: "boolean"
}
assertValidateParam(param, ["Required field is not provided"])
value = undefined
assertValidateParam(param, value, ["Required field is not provided"])
// invalid boolean value (not a boolean)
param = {
required: true,
type: "boolean",
value: "test string"
type: "boolean"
}
assertValidateParam(param, ["Value must be a boolean"])
value = "test string"
assertValidateParam(param, value, ["Value must be a boolean"])
// valid boolean value
param = {
required: true,
type: "boolean",
value: "true"
type: "boolean"
}
assertValidateParam(param, [])
value = "true"
assertValidateParam(param, value, [])
// valid boolean value
param = {
required: true,
type: "boolean",
value: false
type: "boolean"
}
assertValidateParam(param, [])
value = false
assertValidateParam(param, value, [])
})
it("validates optional booleans", function() {
// valid (empty) boolean value
param = {
required: false,
type: "boolean",
value: undefined
type: "boolean"
}
assertValidateParam(param, [])
value = undefined
assertValidateParam(param, value, [])
// invalid boolean value (not a boolean)
param = {
required: false,
type: "boolean",
value: "test string"
type: "boolean"
}
assertValidateParam(param, ["Value must be a boolean"])
value = "test string"
assertValidateParam(param, value, ["Value must be a boolean"])
// valid boolean value
param = {
required: false,
type: "boolean",
value: "true"
type: "boolean"
}
assertValidateParam(param, [])
value = "true"
assertValidateParam(param, value, [])
// valid boolean value
param = {
required: false,
type: "boolean",
value: false
type: "boolean"
}
assertValidateParam(param, [])
value = false
assertValidateParam(param, value, [])
})
it("validates required numbers", function() {
// invalid number, string instead of a number
param = {
required: true,
type: "number",
value: "test"
type: "number"
}
assertValidateParam(param, ["Value must be a number"])
value = "test"
assertValidateParam(param, value, ["Value must be a number"])
// invalid number, undefined value
param = {
required: true,
type: "number",
value: undefined
type: "number"
}
assertValidateParam(param, ["Required field is not provided"])
value = undefined
assertValidateParam(param, value, ["Required field is not provided"])
// valid number with min and max
param = {
required: true,
type: "number",
value: 10,
minimum: 5,
maximum: 99
}
assertValidateParam(param, [])
value = 10
assertValidateParam(param, value, [])
// valid negative number with min and max
param = {
required: true,
type: "number",
value: -10,
minimum: -50,
maximum: -5
}
assertValidateParam(param, [])
value = -10
assertValidateParam(param, value, [])
// invalid number with maximum:0
param = {
required: true,
type: "number",
value: 1,
maximum: 0
}
assertValidateParam(param, ["Value must be less than Maximum"])
value = 1
assertValidateParam(param, value, ["Value must be less than Maximum"])
// invalid number with minimum:0
param = {
required: true,
type: "number",
value: -10,
minimum: 0
}
assertValidateParam(param, ["Value must be greater than Minimum"])
value = -10
assertValidateParam(param, value, ["Value must be greater than Minimum"])
})
it("validates optional numbers", function() {
// invalid number, string instead of a number
param = {
required: false,
type: "number",
value: "test"
type: "number"
}
assertValidateParam(param, ["Value must be a number"])
value = "test"
assertValidateParam(param, value, ["Value must be a number"])
// valid (empty) number
param = {
required: false,
type: "number",
value: undefined
type: "number"
}
assertValidateParam(param, [])
value = undefined
assertValidateParam(param, value, [])
// valid number
param = {
required: false,
type: "number",
value: 10
type: "number"
}
assertValidateParam(param, [])
value = 10
assertValidateParam(param, value, [])
})
it("validates required integers", function() {
// invalid integer, string instead of an integer
param = {
required: true,
type: "integer",
value: "test"
type: "integer"
}
assertValidateParam(param, ["Value must be an integer"])
value = "test"
assertValidateParam(param, value, ["Value must be an integer"])
// invalid integer, undefined value
param = {
required: true,
type: "integer",
value: undefined
type: "integer"
}
assertValidateParam(param, ["Required field is not provided"])
value = undefined
assertValidateParam(param, value, ["Required field is not provided"])
// valid integer, but 0 is falsy in JS
param = {
required: true,
type: "integer",
value: 0
type: "integer"
}
assertValidateParam(param, [])
value = 0
assertValidateParam(param, value, [])
// valid integer
param = {
required: true,
type: "integer",
value: 10
type: "integer"
}
assertValidateParam(param, [])
value = 10
assertValidateParam(param, value, [])
})
it("validates optional integers", function() {
// invalid integer, string instead of an integer
param = {
required: false,
type: "integer",
value: "test"
type: "integer"
}
assertValidateParam(param, ["Value must be an integer"])
value = "test"
assertValidateParam(param, value, ["Value must be an integer"])
// valid (empty) integer
param = {
required: false,
type: "integer",
value: undefined
type: "integer"
}
assertValidateParam(param, [])
value = undefined
assertValidateParam(param, value, [])
// integers
param = {
required: false,
type: "integer",
value: 10
type: "integer"
}
assertValidateParam(param, [])
value = 10
assertValidateParam(param, value, [])
})
})
@@ -1209,6 +1219,7 @@ describe("utils", function() {
expect(sanitizeUrl({})).toEqual("")
})
})
describe("getSampleSchema", function() {
const oriDate = Date
@@ -1235,4 +1246,144 @@ describe("utils", function() {
expect(res).toEqual(new Date().toISOString())
})
})
describe("paramToIdentifier", function() {
it("should convert an Immutable parameter map to an identifier", () => {
const param = fromJS({
name: "id",
in: "query"
})
const res = paramToIdentifier(param)
expect(res).toEqual("query.id.hash-606199662")
})
it("should convert an Immutable parameter map to a set of identifiers", () => {
const param = fromJS({
name: "id",
in: "query"
})
const res = paramToIdentifier(param, { returnAll: true })
expect(res).toEqual([
"query.id.hash-606199662",
"query.id",
"id"
])
})
it("should convert an unhashable Immutable parameter map to an identifier", () => {
const param = fromJS({
name: "id",
in: "query"
})
param.hashCode = null
const res = paramToIdentifier(param)
expect(res).toEqual("query.id")
})
it("should convert an unhashable Immutable parameter map to a set of identifiers", () => {
const param = fromJS({
name: "id",
in: "query"
})
param.hashCode = null
const res = paramToIdentifier(param, { returnAll: true })
expect(res).toEqual([
"query.id",
"id"
])
})
it("should convert an Immutable parameter map lacking an `in` value to an identifier", () => {
const param = fromJS({
name: "id"
})
const res = paramToIdentifier(param)
expect(res).toEqual("id")
})
it("should convert an Immutable parameter map lacking an `in` value to an identifier", () => {
const param = fromJS({
name: "id"
})
const res = paramToIdentifier(param, { returnAll: true })
expect(res).toEqual(["id"])
})
it("should throw gracefully when given a non-Immutable parameter input", () => {
const param = {
name: "id"
}
let error = null
let res = null
try {
const res = paramToIdentifier(param)
} catch(e) {
error = e
}
expect(error).toBeA(Error)
expect(error.message).toInclude("received a non-Im.Map parameter as input")
expect(res).toEqual(null)
})
})
describe("paramToValue", function() {
it("should identify a hash-keyed value", () => {
const param = fromJS({
name: "id",
in: "query"
})
const paramValues = {
"query.id.hash-606199662": "asdf"
}
const res = paramToValue(param, paramValues)
expect(res).toEqual("asdf")
})
it("should identify a in+name value", () => {
const param = fromJS({
name: "id",
in: "query"
})
const paramValues = {
"query.id": "asdf"
}
const res = paramToValue(param, paramValues)
expect(res).toEqual("asdf")
})
it("should identify a name value", () => {
const param = fromJS({
name: "id",
in: "query"
})
const paramValues = {
"id": "asdf"
}
const res = paramToValue(param, paramValues)
expect(res).toEqual("asdf")
})
})
})

26
test/e2e-cypress/static/documents/bugs/5129.yaml Normal file
View File

@@ -0,0 +1,26 @@
openapi: "3.0.0"
paths:
/aev:
get:
parameters:
- name: param
in: query
allowEmptyValue: true
schema:
type: string
responses:
200:
description: ok
/aev/and/required:
get:
parameters:
- name: param
in: query
allowEmptyValue: true
required: true
schema:
type: string
responses:
200:
description: ok

121
test/e2e-cypress/tests/bugs/5129.js Normal file
View File

@@ -0,0 +1,121 @@
describe("#5129: parameter required + allowEmptyValue interactions", () => {
describe("allowEmptyValue parameter", () => {
const opId = "#operations-default-get_aev"
it("should omit the parameter by default", () => {
cy
.visit("/?url=/documents/bugs/5129.yaml")
.get(opId)
.click()
.get(".btn.try-out__btn")
.click()
.get(".btn.execute")
.click()
.get(".request-url pre")
.should("have.text", "http://localhost:3230/aev")
})
it("should include a value", () => {
cy
.visit("/?url=/documents/bugs/5129.yaml")
.get(opId)
.click()
.get(".btn.try-out__btn")
.click()
.get(`.parameters-col_description input[type=text]`)
.type("asdf")
.get(".btn.execute")
.click()
.get(".request-url pre")
.should("have.text", "http://localhost:3230/aev?param=asdf")
})
it("should include an empty value when empty value box is checked", () => {
cy
.visit("/?url=/documents/bugs/5129.yaml")
.get(opId)
.click()
.get(".btn.try-out__btn")
.click()
.get(`.parameters-col_description input[type=checkbox]`)
.check()
.get(".btn.execute")
.click()
.get(".request-url pre")
.should("have.text", "http://localhost:3230/aev?param=")
})
it("should include a value when empty value box is checked and then input is provided", () => {
cy
.visit("/?url=/documents/bugs/5129.yaml")
.get(opId)
.click()
.get(".btn.try-out__btn")
.click()
.get(`.parameters-col_description input[type=checkbox]`)
.check()
.get(`.parameters-col_description input[type=text]`)
.type("1234")
.get(".btn.execute")
.click()
.get(".request-url pre")
.should("have.text", "http://localhost:3230/aev?param=1234")
})
})
describe("allowEmptyValue + required parameter", () => {
const opId = "#operations-default-get_aev_and_required"
it("should refuse to execute by default", () => {
cy
.visit("/?url=/documents/bugs/5129.yaml")
.get(opId)
.click()
.get(".btn.try-out__btn")
.click()
.get(".btn.execute")
.click()
.wait(1000)
.get(".request-url pre")
.should("not.exist")
})
it("should include a value", () => {
cy
.visit("/?url=/documents/bugs/5129.yaml")
.get(opId)
.click()
.get(".btn.try-out__btn")
.click()
.get(`.parameters-col_description input[type=text]`)
.type("asdf")
.get(".btn.execute")
.click()
.get(".request-url pre")
.should("have.text", "http://localhost:3230/aev/and/required?param=asdf")
})
it("should include an empty value when empty value box is checked", () => {
cy
.visit("/?url=/documents/bugs/5129.yaml")
.get(opId)
.click()
.get(".btn.try-out__btn")
.click()
.get(`.parameters-col_description input[type=checkbox]`)
.check()
.get(".btn.execute")
.click()
.get(".request-url pre")
.should("have.text", "http://localhost:3230/aev/and/required?param=")
})
it("should include a value when empty value box is checked and then input is provided", () => {
cy
.visit("/?url=/documents/bugs/5129.yaml")
.get(opId)
.click()
.get(".btn.try-out__btn")
.click()
.get(`.parameters-col_description input[type=checkbox]`)
.check()
.get(`.parameters-col_description input[type=text]`)
.type("1234")
.get(".btn.execute")
.click()
.get(".request-url pre")
.should("have.text", "http://localhost:3230/aev/and/required?param=1234")
})
})
})