github.com/josephspurrier/go-swagger@v0.2.1-0.20221129144919-1f672a142a00/scan/parameters_test.go (about) 1 //go:build !go1.11 2 // +build !go1.11 3 4 // Copyright 2015 go-swagger maintainers 5 // 6 // Licensed under the Apache License, Version 2.0 (the "License"); 7 // you may not use this file except in compliance with the License. 8 // You may obtain a copy of the License at 9 // 10 // http://www.apache.org/licenses/LICENSE-2.0 11 // 12 // Unless required by applicable law or agreed to in writing, software 13 // distributed under the License is distributed on an "AS IS" BASIS, 14 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 15 // See the License for the specific language governing permissions and 16 // limitations under the License. 17 18 package scan 19 20 import ( 21 goparser "go/parser" 22 "log" 23 "testing" 24 25 "github.com/go-openapi/spec" 26 "github.com/stretchr/testify/assert" 27 ) 28 29 const ( 30 gcBadEnum = "bad_enum" 31 ) 32 33 func TestScanFileParam(t *testing.T) { 34 docFile := "../fixtures/goparsing/classification/operations/noparams.go" 35 fileTree, err := goparser.ParseFile(classificationProg.Fset, docFile, nil, goparser.ParseComments) 36 if err != nil { 37 log.Fatal(err) 38 } 39 sp := newParameterParser(classificationProg) 40 noParamOps := make(map[string]*spec.Operation) 41 err = sp.Parse(fileTree, noParamOps) 42 if err != nil { 43 log.Fatal(err) 44 } 45 assert.Len(t, noParamOps, 10) 46 47 of, ok := noParamOps["myOperation"] 48 assert.True(t, ok) 49 assert.Len(t, of.Parameters, 1) 50 fileParam := of.Parameters[0] 51 assert.Equal(t, "MyFormFile desc.", fileParam.Description) 52 assert.Equal(t, "formData", fileParam.In) 53 assert.Equal(t, "file", fileParam.Type) 54 assert.False(t, fileParam.Required) 55 56 emb, ok := noParamOps["myOtherOperation"] 57 assert.True(t, ok) 58 assert.Len(t, emb.Parameters, 2) 59 fileParam = emb.Parameters[0] 60 assert.Equal(t, "MyFormFile desc.", fileParam.Description) 61 assert.Equal(t, "formData", fileParam.In) 62 assert.Equal(t, "file", fileParam.Type) 63 assert.False(t, fileParam.Required) 64 extraParam := emb.Parameters[1] 65 assert.Equal(t, "ExtraParam desc.", extraParam.Description) 66 assert.Equal(t, "formData", extraParam.In) 67 assert.Equal(t, "integer", extraParam.Type) 68 assert.True(t, extraParam.Required) 69 70 ffp, ok := noParamOps["myFuncOperation"] 71 assert.True(t, ok) 72 assert.Len(t, ffp.Parameters, 1) 73 fileParam = ffp.Parameters[0] 74 assert.Equal(t, "MyFormFile desc.", fileParam.Description) 75 assert.Equal(t, "formData", fileParam.In) 76 assert.Equal(t, "file", fileParam.Type) 77 assert.False(t, fileParam.Required) 78 } 79 80 func TestParamsParser(t *testing.T) { 81 docFile := "../fixtures/goparsing/classification/operations/noparams.go" 82 fileTree, err := goparser.ParseFile(classificationProg.Fset, docFile, nil, goparser.ParseComments) 83 if err != nil { 84 log.Fatal(err) 85 } 86 sp := newParameterParser(classificationProg) 87 noParamOps := make(map[string]*spec.Operation) 88 err = sp.Parse(fileTree, noParamOps) 89 if err != nil { 90 log.Fatal(err) 91 } 92 assert.Len(t, noParamOps, 10) 93 94 cr, okParam := noParamOps["yetAnotherOperation"] 95 assert.True(t, okParam) 96 assert.Len(t, cr.Parameters, 8) 97 for _, param := range cr.Parameters { 98 switch param.Name { 99 case "id": 100 assert.Equal(t, "integer", param.Type) 101 assert.Equal(t, "int64", param.Format) 102 case "name": 103 assert.Equal(t, "string", param.Type) 104 assert.Equal(t, "", param.Format) 105 case "age": 106 assert.Equal(t, "integer", param.Type) 107 assert.Equal(t, "int32", param.Format) 108 case "notes": 109 assert.Equal(t, "string", param.Type) 110 assert.Equal(t, "", param.Format) 111 case "extra": 112 assert.Equal(t, "string", param.Type) 113 assert.Equal(t, "", param.Format) 114 case "createdAt": 115 assert.Equal(t, "string", param.Type) 116 assert.Equal(t, "date-time", param.Format) 117 case "informity": 118 assert.Equal(t, "string", param.Type) 119 assert.Equal(t, "formData", param.In) 120 case "NoTagName": 121 assert.Equal(t, "string", param.Type) 122 assert.Equal(t, "", param.Format) 123 default: 124 assert.Fail(t, "unknown property: "+param.Name) 125 } 126 } 127 128 ob, okParam := noParamOps["updateOrder"] 129 assert.True(t, okParam) 130 assert.Len(t, ob.Parameters, 1) 131 bodyParam := ob.Parameters[0] 132 assert.Equal(t, "The order to submit.", bodyParam.Description) 133 assert.Equal(t, "body", bodyParam.In) 134 assert.Equal(t, "#/definitions/order", bodyParam.Schema.Ref.String()) 135 assert.True(t, bodyParam.Required) 136 137 mop, okParam := noParamOps["getOrders"] 138 assert.True(t, okParam) 139 assert.Len(t, mop.Parameters, 2) 140 ordersParam := mop.Parameters[0] 141 assert.Equal(t, "The orders", ordersParam.Description) 142 assert.True(t, ordersParam.Required) 143 assert.Equal(t, "array", ordersParam.Type) 144 otherParam := mop.Parameters[1] 145 assert.Equal(t, "And another thing", otherParam.Description) 146 147 op, okParam := noParamOps["someOperation"] 148 assert.True(t, okParam) 149 assert.Len(t, op.Parameters, 10) 150 151 for _, param := range op.Parameters { 152 switch param.Name { 153 case "id": 154 assert.Equal(t, "ID of this no model instance.\nids in this application start at 11 and are smaller than 1000", param.Description) 155 assert.Equal(t, "path", param.In) 156 assert.Equal(t, "integer", param.Type) 157 assert.Equal(t, "int64", param.Format) 158 assert.True(t, param.Required) 159 assert.Equal(t, "ID", param.Extensions["x-go-name"]) 160 assert.EqualValues(t, 1000, *param.Maximum) 161 assert.True(t, param.ExclusiveMaximum) 162 assert.EqualValues(t, 10, *param.Minimum) 163 assert.True(t, param.ExclusiveMinimum) 164 assert.Equal(t, 1, param.Default, "%s default value is incorrect", param.Name) 165 166 case "score": 167 assert.Equal(t, "The Score of this model", param.Description) 168 assert.Equal(t, "query", param.In) 169 assert.Equal(t, "integer", param.Type) 170 assert.Equal(t, "int32", param.Format) 171 assert.True(t, param.Required) 172 assert.Equal(t, "Score", param.Extensions["x-go-name"]) 173 assert.EqualValues(t, 45, *param.Maximum) 174 assert.False(t, param.ExclusiveMaximum) 175 assert.EqualValues(t, 3, *param.Minimum) 176 assert.False(t, param.ExclusiveMinimum) 177 assert.Equal(t, 2, param.Default, "%s default value is incorrect", param.Name) 178 assert.Equal(t, 27, param.Example) 179 180 case "x-hdr-name": 181 assert.Equal(t, "Name of this no model instance", param.Description) 182 assert.Equal(t, "header", param.In) 183 assert.Equal(t, "string", param.Type) 184 assert.True(t, param.Required) 185 assert.Equal(t, "Name", param.Extensions["x-go-name"]) 186 assert.EqualValues(t, 4, *param.MinLength) 187 assert.EqualValues(t, 50, *param.MaxLength) 188 assert.Equal(t, "[A-Za-z0-9-.]*", param.Pattern) 189 190 case "created": 191 assert.Equal(t, "Created holds the time when this entry was created", param.Description) 192 assert.Equal(t, "query", param.In) 193 assert.Equal(t, "string", param.Type) 194 assert.Equal(t, "date-time", param.Format) 195 assert.False(t, param.Required) 196 assert.Equal(t, "Created", param.Extensions["x-go-name"]) 197 198 case "category": 199 assert.Equal(t, "The Category of this model", param.Description) 200 assert.Equal(t, "query", param.In) 201 assert.Equal(t, "string", param.Type) 202 assert.True(t, param.Required) 203 assert.Equal(t, "Category", param.Extensions["x-go-name"]) 204 assert.EqualValues(t, []interface{}{"foo", "bar", "none"}, param.Enum, "%s enum values are incorrect", param.Name) 205 assert.Equal(t, "bar", param.Default, "%s default value is incorrect", param.Name) 206 case "type": 207 assert.Equal(t, "Type of this model", param.Description) 208 assert.Equal(t, "query", param.In) 209 assert.Equal(t, "integer", param.Type) 210 assert.EqualValues(t, []interface{}{1, 3, 5}, param.Enum, "%s enum values are incorrect", param.Name) 211 case gcBadEnum: 212 assert.Equal(t, "query", param.In) 213 assert.Equal(t, "integer", param.Type) 214 assert.EqualValues(t, []interface{}{1, "rsq", "qaz"}, param.Enum, "%s enum values are incorrect", param.Name) 215 case "foo_slice": 216 assert.Equal(t, "a FooSlice has foos which are strings", param.Description) 217 assert.Equal(t, "FooSlice", param.Extensions["x-go-name"]) 218 assert.Equal(t, "query", param.In) 219 assert.Equal(t, "array", param.Type) 220 assert.False(t, param.Required) 221 assert.True(t, param.UniqueItems) 222 assert.Equal(t, "pipe", param.CollectionFormat) 223 assert.EqualValues(t, 3, *param.MinItems, "'foo_slice' should have had 3 min items") 224 assert.EqualValues(t, 10, *param.MaxItems, "'foo_slice' should have had 10 max items") 225 itprop := param.Items 226 assert.EqualValues(t, 3, *itprop.MinLength, "'foo_slice.items.minLength' should have been 3") 227 assert.EqualValues(t, 10, *itprop.MaxLength, "'foo_slice.items.maxLength' should have been 10") 228 assert.EqualValues(t, "\\w+", itprop.Pattern, "'foo_slice.items.pattern' should have \\w+") 229 assert.EqualValues(t, "bar", itprop.Default, "'foo_slice.items.default' should have bar default value") 230 231 case "items": 232 assert.Equal(t, "Items", param.Extensions["x-go-name"]) 233 assert.Equal(t, "body", param.In) 234 assert.NotNil(t, param.Schema) 235 aprop := param.Schema 236 assert.Equal(t, "array", aprop.Type[0]) 237 assert.NotNil(t, aprop.Items) 238 assert.NotNil(t, aprop.Items.Schema) 239 itprop := aprop.Items.Schema 240 assert.Len(t, itprop.Properties, 4) 241 assert.Len(t, itprop.Required, 3) 242 assertProperty(t, itprop, "integer", "id", "int32", "ID") 243 iprop, ok := itprop.Properties["id"] 244 assert.True(t, ok) 245 assert.Equal(t, "ID of this no model instance.\nids in this application start at 11 and are smaller than 1000", iprop.Description) 246 assert.EqualValues(t, 1000, *iprop.Maximum) 247 assert.True(t, iprop.ExclusiveMaximum, "'id' should have had an exclusive maximum") 248 assert.NotNil(t, iprop.Minimum) 249 assert.EqualValues(t, 10, *iprop.Minimum) 250 assert.True(t, iprop.ExclusiveMinimum, "'id' should have had an exclusive minimum") 251 assert.Equal(t, 3, iprop.Default, "Items.ID default value is incorrect") 252 253 assertRef(t, itprop, "pet", "Pet", "#/definitions/pet") 254 iprop, ok = itprop.Properties["pet"] 255 assert.True(t, ok) 256 // if itprop.Ref.String() == "" { 257 // assert.Equal(t, "The Pet to add to this NoModel items bucket.\nPets can appear more than once in the bucket", iprop.Description) 258 // } 259 260 assertProperty(t, itprop, "integer", "quantity", "int16", "Quantity") 261 iprop, ok = itprop.Properties["quantity"] 262 assert.True(t, ok) 263 assert.Equal(t, "The amount of pets to add to this bucket.", iprop.Description) 264 assert.EqualValues(t, 1, *iprop.Minimum) 265 assert.EqualValues(t, 10, *iprop.Maximum) 266 267 assertProperty(t, itprop, "string", "notes", "", "Notes") 268 iprop, ok = itprop.Properties["notes"] 269 assert.True(t, ok) 270 assert.Equal(t, "Notes to add to this item.\nThis can be used to add special instructions.", iprop.Description) 271 272 case "bar_slice": 273 assert.Equal(t, "a BarSlice has bars which are strings", param.Description) 274 assert.Equal(t, "BarSlice", param.Extensions["x-go-name"]) 275 assert.Equal(t, "query", param.In) 276 assert.Equal(t, "array", param.Type) 277 assert.False(t, param.Required) 278 assert.True(t, param.UniqueItems) 279 assert.Equal(t, "pipe", param.CollectionFormat) 280 assert.NotNil(t, param.Items, "bar_slice should have had an items property") 281 assert.EqualValues(t, 3, *param.MinItems, "'bar_slice' should have had 3 min items") 282 assert.EqualValues(t, 10, *param.MaxItems, "'bar_slice' should have had 10 max items") 283 itprop := param.Items 284 if assert.NotNil(t, itprop) { 285 assert.EqualValues(t, 4, *itprop.MinItems, "'bar_slice.items.minItems' should have been 4") 286 assert.EqualValues(t, 9, *itprop.MaxItems, "'bar_slice.items.maxItems' should have been 9") 287 itprop2 := itprop.Items 288 if assert.NotNil(t, itprop2) { 289 assert.EqualValues(t, 5, *itprop2.MinItems, "'bar_slice.items.items.minItems' should have been 5") 290 assert.EqualValues(t, 8, *itprop2.MaxItems, "'bar_slice.items.items.maxItems' should have been 8") 291 itprop3 := itprop2.Items 292 if assert.NotNil(t, itprop3) { 293 assert.EqualValues(t, 3, *itprop3.MinLength, "'bar_slice.items.items.items.minLength' should have been 3") 294 assert.EqualValues(t, 10, *itprop3.MaxLength, "'bar_slice.items.items.items.maxLength' should have been 10") 295 assert.EqualValues(t, "\\w+", itprop3.Pattern, "'bar_slice.items.items.items.pattern' should have \\w+") 296 } 297 } 298 } 299 300 default: 301 assert.Fail(t, "unknown property: "+param.Name) 302 } 303 } 304 305 // assert that the order of the parameters is maintained 306 order, ok := noParamOps["anotherOperation"] 307 assert.True(t, ok) 308 assert.Len(t, order.Parameters, 10) 309 310 for index, param := range order.Parameters { 311 switch param.Name { 312 case "id": 313 assert.Equal(t, 0, index, "%s index incorrect", param.Name) 314 case "score": 315 assert.Equal(t, 1, index, "%s index incorrect", param.Name) 316 case "x-hdr-name": 317 assert.Equal(t, 2, index, "%s index incorrect", param.Name) 318 case "created": 319 assert.Equal(t, 3, index, "%s index incorrect", param.Name) 320 case "category": 321 assert.Equal(t, 4, index, "%s index incorrect", param.Name) 322 case "type": 323 assert.Equal(t, 5, index, "%s index incorrect", param.Name) 324 case gcBadEnum: 325 assert.Equal(t, 6, index, "%s index incorrect", param.Name) 326 case "foo_slice": 327 assert.Equal(t, 7, index, "%s index incorrect", param.Name) 328 case "bar_slice": 329 assert.Equal(t, 8, index, "%s index incorrect", param.Name) 330 case "items": 331 assert.Equal(t, 9, index, "%s index incorrect", param.Name) 332 default: 333 assert.Fail(t, "unknown property: "+param.Name) 334 } 335 } 336 337 // check that aliases work correctly 338 aliasOp, ok := noParamOps["someAliasOperation"] 339 assert.True(t, ok) 340 assert.Len(t, aliasOp.Parameters, 4) 341 for _, param := range aliasOp.Parameters { 342 switch param.Name { 343 case "intAlias": 344 assert.Equal(t, "query", param.In) 345 assert.Equal(t, "integer", param.Type) 346 assert.Equal(t, "int64", param.Format) 347 assert.True(t, param.Required) 348 assert.EqualValues(t, 10, *param.Maximum) 349 assert.EqualValues(t, 1, *param.Minimum) 350 case "stringAlias": 351 assert.Equal(t, "query", param.In) 352 assert.Equal(t, "string", param.Type) 353 case "intAliasPath": 354 assert.Equal(t, "path", param.In) 355 assert.Equal(t, "integer", param.Type) 356 assert.Equal(t, "int64", param.Format) 357 case "intAliasForm": 358 assert.Equal(t, "formData", param.In) 359 assert.Equal(t, "integer", param.Type) 360 assert.Equal(t, "int64", param.Format) 361 default: 362 assert.Fail(t, "unknown property: "+param.Name) 363 } 364 } 365 }