github.com/ffalor/go-swagger@v0.0.0-20231011000038-9f25265ac351/generator/enum_test.go (about) 1 // Copyright 2015 go-swagger maintainers 2 // 3 // Licensed under the Apache License, Version 2.0 (the "License"); 4 // you may not use this file except in compliance with the License. 5 // You may obtain a copy of the License at 6 // 7 // http://www.apache.org/licenses/LICENSE-2.0 8 // 9 // Unless required by applicable law or agreed to in writing, software 10 // distributed under the License is distributed on an "AS IS" BASIS, 11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 // See the License for the specific language governing permissions and 13 // limitations under the License. 14 15 package generator 16 17 import ( 18 "bytes" 19 "strings" 20 "testing" 21 22 "github.com/go-openapi/loads" 23 "github.com/stretchr/testify/assert" 24 "github.com/stretchr/testify/require" 25 ) 26 27 func TestEnum_StringThing(t *testing.T) { 28 specDoc, err := loads.Spec("../fixtures/codegen/todolist.enums.yml") 29 require.NoError(t, err) 30 31 definitions := specDoc.Spec().Definitions 32 k := "StringThing" 33 schema := definitions[k] 34 opts := opts() 35 genModel, err := makeGenDefinition(k, "models", schema, specDoc, opts) 36 require.NoError(t, err) 37 38 buf := bytes.NewBuffer(nil) 39 err = templates.MustGet("model").Execute(buf, genModel) 40 require.NoError(t, err) 41 42 ff, err := opts.LanguageOpts.FormatContent("string_thing.go", buf.Bytes()) 43 require.NoErrorf(t, err, buf.String()) 44 45 res := string(ff) 46 assertInCode(t, "var stringThingEnum []interface{}", res) 47 assertInCode(t, k+") validateStringThingEnum(path, location string, value StringThing)", res) 48 assertInCode(t, "m.validateStringThingEnum(\"\", \"body\", m)", res) 49 } 50 51 func TestEnum_ComposedThing(t *testing.T) { 52 specDoc, err := loads.Spec("../fixtures/codegen/todolist.enums.yml") 53 require.NoError(t, err) 54 55 definitions := specDoc.Spec().Definitions 56 k := "ComposedThing" 57 schema := definitions[k] 58 opts := opts() 59 genModel, err := makeGenDefinition(k, "models", schema, specDoc, opts) 60 require.NoError(t, err) 61 62 buf := bytes.NewBuffer(nil) 63 err = templates.MustGet("model").Execute(buf, genModel) 64 require.NoError(t, err) 65 66 ff, err := opts.LanguageOpts.FormatContent("composed_thing.go", buf.Bytes()) 67 require.NoErrorf(t, err, buf.String()) 68 69 res := string(ff) 70 assertInCode(t, "m.StringThing.Validate(formats)", res) 71 assertInCode(t, "var composedThingTypeNamePropEnum []interface{}", res) 72 assertInCode(t, "m.validateNameEnum(\"name\", \"body\", *m.Name)", res) 73 assertInCode(t, k+") validateNameEnum(path, location string, value string)", res) 74 } 75 76 func TestEnum_IntThing(t *testing.T) { 77 specDoc, err := loads.Spec("../fixtures/codegen/todolist.enums.yml") 78 require.NoError(t, err) 79 80 definitions := specDoc.Spec().Definitions 81 k := "IntThing" 82 schema := definitions[k] 83 opts := opts() 84 genModel, err := makeGenDefinition(k, "models", schema, specDoc, opts) 85 require.NoError(t, err) 86 87 buf := bytes.NewBuffer(nil) 88 err = templates.MustGet("model").Execute(buf, genModel) 89 require.NoError(t, err) 90 91 ff, err := opts.LanguageOpts.FormatContent("int_thing.go", buf.Bytes()) 92 require.NoErrorf(t, err, buf.String()) 93 94 res := string(ff) 95 assertInCode(t, "var intThingEnum []interface{}", res) 96 assertInCode(t, k+") validateIntThingEnum(path, location string, value IntThing)", res) 97 assertInCode(t, "m.validateIntThingEnum(\"\", \"body\", m)", res) 98 } 99 100 func TestEnum_FloatThing(t *testing.T) { 101 specDoc, err := loads.Spec("../fixtures/codegen/todolist.enums.yml") 102 require.NoError(t, err) 103 104 definitions := specDoc.Spec().Definitions 105 k := "FloatThing" 106 schema := definitions[k] 107 opts := opts() 108 genModel, err := makeGenDefinition(k, "models", schema, specDoc, opts) 109 require.NoError(t, err) 110 111 buf := bytes.NewBuffer(nil) 112 err = templates.MustGet("model").Execute(buf, genModel) 113 require.NoError(t, err) 114 115 ff, err := opts.LanguageOpts.FormatContent("float_thing.go", buf.Bytes()) 116 require.NoErrorf(t, err, buf.String()) 117 118 res := string(ff) 119 assertInCode(t, "var floatThingEnum []interface{}", res) 120 assertInCode(t, k+") validateFloatThingEnum(path, location string, value FloatThing)", res) 121 assertInCode(t, "m.validateFloatThingEnum(\"\", \"body\", m)", res) 122 } 123 124 func TestEnum_SliceThing(t *testing.T) { 125 specDoc, err := loads.Spec("../fixtures/codegen/todolist.enums.yml") 126 require.NoError(t, err) 127 128 definitions := specDoc.Spec().Definitions 129 k := "SliceThing" 130 schema := definitions[k] 131 opts := opts() 132 genModel, err := makeGenDefinition(k, "models", schema, specDoc, opts) 133 require.NoError(t, err) 134 135 buf := bytes.NewBuffer(nil) 136 err = templates.MustGet("model").Execute(buf, genModel) 137 require.NoError(t, err) 138 139 ff, err := opts.LanguageOpts.FormatContent("slice_thing.go", buf.Bytes()) 140 require.NoErrorf(t, err, buf.String()) 141 142 res := string(ff) 143 assertInCode(t, "var sliceThingEnum []interface{}", res) 144 assertInCode(t, k+") validateSliceThingEnum(path, location string, value []string)", res) 145 assertInCode(t, "m.validateSliceThingEnum(\"\", \"body\", m)", res) 146 } 147 148 func TestEnum_SliceAndItemsThing(t *testing.T) { 149 specDoc, err := loads.Spec("../fixtures/codegen/todolist.enums.yml") 150 require.NoError(t, err) 151 152 definitions := specDoc.Spec().Definitions 153 k := "SliceAndItemsThing" 154 schema := definitions[k] 155 opts := opts() 156 genModel, err := makeGenDefinition(k, "models", schema, specDoc, opts) 157 require.NoError(t, err) 158 159 buf := bytes.NewBuffer(nil) 160 err = templates.MustGet("model").Execute(buf, genModel) 161 require.NoError(t, err) 162 163 ff, err := opts.LanguageOpts.FormatContent("slice_and_items_thing.go", buf.Bytes()) 164 require.NoErrorf(t, err, buf.String()) 165 166 res := string(ff) 167 assertInCode(t, "var sliceAndItemsThingEnum []interface{}", res) 168 assertInCode(t, k+") validateSliceAndItemsThingEnum(path, location string, value []string)", res) 169 assertInCode(t, "m.validateSliceAndItemsThingEnum(\"\", \"body\", m)", res) 170 assertInCode(t, "var sliceAndItemsThingItemsEnum []interface{}", res) 171 assertInCode(t, k+") validateSliceAndItemsThingItemsEnum(path, location string, value string)", res) 172 assertInCode(t, "m.validateSliceAndItemsThingItemsEnum(strconv.Itoa(i), \"body\", m[i])", res) 173 } 174 175 func TestEnum_SliceAndAdditionalItemsThing(t *testing.T) { 176 specDoc, err := loads.Spec("../fixtures/codegen/todolist.enums.yml") 177 require.NoError(t, err) 178 179 definitions := specDoc.Spec().Definitions 180 k := "SliceAndAdditionalItemsThing" 181 schema := definitions[k] 182 opts := opts() 183 genModel, err := makeGenDefinition(k, "models", schema, specDoc, opts) 184 require.NoError(t, err) 185 186 buf := bytes.NewBuffer(nil) 187 err = templates.MustGet("model").Execute(buf, genModel) 188 require.NoError(t, err) 189 190 ff, err := opts.LanguageOpts.FormatContent("slice_and_additional_items_thing.go", buf.Bytes()) 191 require.NoErrorf(t, err, buf.String()) 192 193 res := string(ff) 194 assertInCode(t, "var sliceAndAdditionalItemsThingEnum []interface{}", res) 195 assertInCode(t, k+") validateSliceAndAdditionalItemsThingEnum(path, location string, value *SliceAndAdditionalItemsThing)", res) 196 assertInCode(t, "var sliceAndAdditionalItemsThingTypeP0PropEnum []interface{}", res) 197 assertInCode(t, k+") validateP0Enum(path, location string, value string)", res) 198 assertInCode(t, "m.validateP0Enum(\"0\", \"body\", *m.P0)", res) 199 assertInCode(t, "var sliceAndAdditionalItemsThingItemsEnum []interface{}", res) 200 assertInCode(t, k+") validateSliceAndAdditionalItemsThingItemsEnum(path, location string, value float32)", res) 201 assertInCode(t, "m.validateSliceAndAdditionalItemsThingItemsEnum(strconv.Itoa(i+1), \"body\", m.SliceAndAdditionalItemsThingItems[i])", res) 202 } 203 204 func TestEnum_MapThing(t *testing.T) { 205 specDoc, err := loads.Spec("../fixtures/codegen/todolist.enums.yml") 206 require.NoError(t, err) 207 208 definitions := specDoc.Spec().Definitions 209 k := "MapThing" 210 schema := definitions[k] 211 opts := opts() 212 genModel, err := makeGenDefinition(k, "models", schema, specDoc, opts) 213 require.NoError(t, err) 214 215 buf := bytes.NewBuffer(nil) 216 err = templates.MustGet("model").Execute(buf, genModel) 217 require.NoError(t, err) 218 219 ff, err := opts.LanguageOpts.FormatContent("map_thing.go", buf.Bytes()) 220 require.NoErrorf(t, err, buf.String()) 221 222 res := string(ff) 223 assertInCode(t, "var mapThingEnum []interface{}", res) 224 assertInCode(t, k+") validateMapThingEnum(path, location string, value MapThing)", res) 225 assertInCode(t, "m.validateMapThingEnum(\"\", \"body\", m)", res) 226 assertInCode(t, "var mapThingValueEnum []interface{}", res) 227 assertInCode(t, k+") validateMapThingValueEnum(path, location string, value string)", res) 228 assertInCode(t, "m.validateMapThingValueEnum(k, \"body\", m[k])", res) 229 } 230 231 func TestEnum_ObjectThing(t *testing.T) { 232 // verify that additionalItems render the same from an expanded and a flattened spec 233 // known issue: there are some slight differences in generated code and variables for enum, 234 // depending on how the spec has been preprocessed 235 specs := []string{ 236 "../fixtures/codegen/todolist.enums.yml", 237 "../fixtures/codegen/todolist.enums.flattened.json", // this one is the first one, after "swagger flatten" 238 } 239 k := "ObjectThing" 240 for _, fixture := range specs { 241 t.Logf("%s from spec: %s", k, fixture) 242 specDoc, err := loads.Spec(fixture) 243 require.NoError(t, err) 244 245 definitions := specDoc.Spec().Definitions 246 schema := definitions[k] 247 opts := opts() 248 genModel, err := makeGenDefinition(k, "models", schema, specDoc, opts) 249 require.NoError(t, err) 250 251 buf := bytes.NewBuffer(nil) 252 err = templates.MustGet("model").Execute(buf, genModel) 253 require.NoError(t, err) 254 255 ff, err := opts.LanguageOpts.FormatContent("object_thing.go", buf.Bytes()) 256 require.NoErrorf(t, err, buf.String()) 257 258 res := string(ff) 259 // all these remain unaffected 260 assertInCode(t, "var objectThingTypeNamePropEnum []interface{}", res) 261 assertInCode(t, "var objectThingTypeFlowerPropEnum []interface{}", res) 262 assertInCode(t, "var objectThingTypeFlourPropEnum []interface{}", res) 263 assertInCode(t, "var objectThingTypeWolvesPropEnum []interface{}", res) 264 assertInCode(t, "var objectThingWolvesValueEnum []interface{}", res) 265 assertInCode(t, "var objectThingCatsItemsEnum []interface{}", res) 266 assertInCode(t, k+") validateNameEnum(path, location string, value string)", res) 267 assertInCode(t, k+") validateFlowerEnum(path, location string, value int32)", res) 268 assertInCode(t, k+") validateFlourEnum(path, location string, value float32)", res) 269 assertInCode(t, k+") validateWolvesEnum(path, location string, value map[string]string)", res) 270 assertInCode(t, k+") validateWolvesValueEnum(path, location string, value string)", res) 271 assertInCode(t, k+") validateCatsItemsEnum(path, location string, value string)", res) 272 assertInCode(t, k+") validateCats(", res) 273 assertInCode(t, "m.validateNameEnum(\"name\", \"body\", *m.Name)", res) 274 assertInCode(t, "m.validateFlowerEnum(\"flower\", \"body\", m.Flower)", res) 275 assertInCode(t, "m.validateFlourEnum(\"flour\", \"body\", m.Flour)", res) 276 assertInCode(t, "m.validateWolvesEnum(\"wolves\", \"body\", m.Wolves)", res) 277 assertInCode(t, "m.validateWolvesValueEnum(\"wolves\"+\".\"+k, \"body\", m.Wolves[k])", res) 278 assertInCode(t, "m.validateCatsItemsEnum(\"cats\"+\".\"+strconv.Itoa(i), \"body\", m.Cats[i])", res) 279 280 // small naming differences may be found between the expand and the flatten version of spec 281 namingDifference := "Tuple0" 282 pathDifference := "P" 283 if strings.Contains(fixture, "flattened") { 284 // when expanded, all defs are in the same template for AdditionalItems 285 schema := definitions["objectThingLions"] 286 genModel, err = makeGenDefinition("ObjectThingLions", "models", schema, specDoc, opts) 287 require.NoError(t, err) 288 289 buf = bytes.NewBuffer(nil) 290 err := templates.MustGet("model").Execute(buf, genModel) 291 require.NoError(t, err) 292 293 ff, err := opts.LanguageOpts.FormatContent("object_thing_lions.go", buf.Bytes()) 294 require.NoErrorf(t, err, buf.String()) 295 296 res = string(ff) 297 namingDifference = "" 298 pathDifference = "" 299 } 300 // now common check resumes 301 assertInCode(t, "var objectThingLions"+namingDifference+"TypeP0PropEnum []interface{}", res) 302 assertInCode(t, "var objectThingLions"+namingDifference+"TypeP1PropEnum []interface{}", res) 303 assertInCode(t, "var objectThingLions"+namingDifference+"ItemsEnum []interface{}", res) 304 assertInCode(t, "m.validateP1Enum(\""+pathDifference+"1\", \"body\", *m.P1)", res) 305 assertInCode(t, "m.validateP0Enum(\""+pathDifference+"0\", \"body\", *m.P0)", res) 306 assertInCode(t, k+"Lions"+namingDifference+") validateObjectThingLions"+namingDifference+"ItemsEnum(path, location string, value float64)", res) 307 308 if namingDifference != "" { 309 assertInCode(t, "m.validateObjectThingLions"+namingDifference+"ItemsEnum(strconv.Itoa(i), \"body\", m.ObjectThingLions"+namingDifference+"Items[i])", res) 310 assertInCode(t, "var objectThingTypeLionsPropEnum []interface{}", res) 311 assertInCode(t, k+") validateLionsEnum(path, location string, value float64)", res) 312 } else { 313 assertInCode(t, "m.validateObjectThingLions"+namingDifference+"ItemsEnum(strconv.Itoa(i+2), \"body\", m.ObjectThingLions"+namingDifference+"Items[i])", res) 314 assertInCode(t, "var objectThingLionsItemsEnum []interface{}", res) 315 assertInCode(t, k+"Lions) validateObjectThingLionsItemsEnum(path, location string, value float64)", res) 316 } 317 } 318 } 319 320 func TestEnum_ComputeInstance(t *testing.T) { 321 // ensure that the enum validation for the anonymous object under the delegate property 322 // is rendered. 323 324 specDoc, err := loads.Spec("../fixtures/codegen/todolist.enums.yml") 325 require.NoError(t, err) 326 327 definitions := specDoc.Spec().Definitions 328 k := "ComputeInstance" 329 schema := definitions[k] 330 opts := opts() 331 genModel, err := makeGenDefinition(k, "models", schema, specDoc, opts) 332 require.NoError(t, err) 333 334 buf := bytes.NewBuffer(nil) 335 err = templates.MustGet("model").Execute(buf, genModel) 336 require.NoError(t, err) 337 338 ff, err := opts.LanguageOpts.FormatContent("object_thing.go", buf.Bytes()) 339 require.NoErrorf(t, err, buf.String()) 340 341 res := string(ff) 342 assertInCode(t, "Region *string `json:\"region\"`", res) 343 assertInCode(t, "var computeInstanceTypeRegionPropEnum []interface{}", res) 344 assertInCode(t, "m.validateRegionEnum(\"region\", \"body\", *m.Region)", res) 345 } 346 347 func TestEnum_Cluster(t *testing.T) { 348 // ensure that the enum validation for the anonymous object under the delegate property 349 // is rendered. 350 specDoc, err := loads.Spec("../fixtures/codegen/todolist.enums.yml") 351 require.NoError(t, err) 352 353 definitions := specDoc.Spec().Definitions 354 k := "Cluster" 355 schema := definitions[k] 356 opts := opts() 357 genModel, err := makeGenDefinition(k, "models", schema, specDoc, opts) 358 require.NoError(t, err) 359 360 buf := bytes.NewBuffer(nil) 361 err = templates.MustGet("model").Execute(buf, genModel) 362 require.NoError(t, err) 363 364 ff, err := opts.LanguageOpts.FormatContent("object_thing.go", buf.Bytes()) 365 require.NoErrorf(t, err, buf.String()) 366 367 res := string(ff) 368 assertInCode(t, "Data *ClusterData `json:\"data\"`", res) 369 assertInCode(t, `ClusterDataStatusScheduled string = "scheduled"`, res) 370 assertInCode(t, `ClusterDataStatusBuilding string = "building"`, res) 371 assertInCode(t, `ClusterDataStatusUp string = "up"`, res) 372 assertInCode(t, `ClusterDataStatusDeleting string = "deleting"`, res) 373 assertInCode(t, `ClusterDataStatusExited string = "exited"`, res) 374 assertInCode(t, `ClusterDataStatusError string = "error"`, res) 375 } 376 377 func TestEnum_NewPrototype(t *testing.T) { 378 // ensure that the enum validation for the anonymous object under the delegate property 379 // is rendered. 380 specDoc, err := loads.Spec("../fixtures/codegen/todolist.enums.yml") 381 require.NoError(t, err) 382 383 definitions := specDoc.Spec().Definitions 384 k := "NewPrototype" 385 schema := definitions[k] 386 opts := opts() 387 genModel, err := makeGenDefinition(k, "models", schema, specDoc, opts) 388 require.NoError(t, err) 389 390 buf := bytes.NewBuffer(nil) 391 err = templates.MustGet("model").Execute(buf, genModel) 392 require.NoError(t, err) 393 394 ff, err := opts.LanguageOpts.FormatContent("object_thing.go", buf.Bytes()) 395 require.NoErrorf(t, err, buf.String()) 396 397 res := string(ff) 398 assertInCode(t, "ActivatingUser *NewPrototypeActivatingUser `json:\"activating_user,omitempty\"`", res) 399 assertInCode(t, "Delegate *NewPrototypeDelegate `json:\"delegate\"`", res) 400 assertInCode(t, "Role *string `json:\"role\"`", res) 401 assertInCode(t, "var newPrototypeTypeRolePropEnum []interface{}", res) 402 assertInCode(t, "var newPrototypeDelegateTypeKindPropEnum []interface{}", res) 403 assertInCode(t, "m.validateDelegate(formats)", res) 404 assertInCode(t, "m.validateRole(formats)", res) 405 assertInCode(t, "m.validateActivatingUser(formats)", res) 406 assertInCode(t, "m.Delegate.Validate(formats)", res) 407 assertInCode(t, "m.ActivatingUser.Validate(formats)", res) 408 } 409 410 func TestEnum_Issue265(t *testing.T) { 411 specDoc, err := loads.Spec("../fixtures/codegen/sodabooth.json") 412 require.NoError(t, err) 413 414 definitions := specDoc.Spec().Definitions 415 k := "SodaBrand" 416 schema := definitions[k] 417 opts := opts() 418 genModel, err := makeGenDefinition(k, "models", schema, specDoc, opts) 419 require.NoError(t, err) 420 421 buf := bytes.NewBuffer(nil) 422 err = templates.MustGet("model").Execute(buf, genModel) 423 require.NoError(t, err) 424 425 ff, err := opts.LanguageOpts.FormatContent("soda_brand.go", buf.Bytes()) 426 require.NoErrorf(t, err, buf.String()) 427 428 res := string(ff) 429 assert.Equal(t, 1, strings.Count(res, "m.validateSodaBrandEnum")) 430 } 431 432 func TestGenerateModel_Issue303(t *testing.T) { 433 specDoc, e := loads.Spec("../fixtures/enhancements/303/swagger.yml") 434 require.NoError(t, e) 435 436 opts := opts() 437 tt := templateTest{t, templates.MustGet("model").Lookup("schema")} 438 definitions := specDoc.Spec().Definitions 439 for name, schema := range definitions { 440 genModel, err := makeGenDefinition(name, "models", schema, specDoc, opts) 441 require.NoError(t, err) 442 443 assert.Equal(t, name, genModel.Name) 444 assert.Equal(t, name, genModel.GoType) 445 assert.True(t, genModel.IsEnumCI) 446 447 extension := genModel.Extensions["x-go-enum-ci"] 448 require.NotNil(t, extension) 449 450 xGoEnumCI, ok := extension.(bool) 451 assert.True(t, ok) 452 assert.True(t, xGoEnumCI) 453 454 buf := bytes.NewBuffer(nil) 455 require.NoError(t, tt.template.Execute(buf, genModel)) 456 457 ff, err := opts.LanguageOpts.FormatContent("case_insensitive_enum_definition.go", buf.Bytes()) 458 require.NoErrorf(t, err, buf.String()) 459 460 res := string(ff) 461 assertInCode(t, `if err := validate.EnumCase(path, location, value, vegetableEnum, false); err != nil {`, res) 462 } 463 } 464 465 func TestEnum_Issue325(t *testing.T) { 466 specDoc, err := loads.Spec("../fixtures/codegen/sodabooths.json") 467 require.NoError(t, err) 468 469 definitions := specDoc.Spec().Definitions 470 k := "SodaBrand" 471 schema := definitions[k] 472 opts := opts() 473 genModel, err := makeGenDefinition(k, "models", schema, specDoc, opts) 474 require.NoError(t, err) 475 476 buf := bytes.NewBuffer(nil) 477 err = templates.MustGet("model").Execute(buf, genModel) 478 require.NoError(t, err) 479 480 ff, err := opts.LanguageOpts.FormatContent("soda_brand.go", buf.Bytes()) 481 require.NoErrorf(t, err, buf.String()) 482 483 res := string(ff) 484 assertInCode(t, "var sodaBrandEnum []interface{}", res) 485 assertInCode(t, "err := validate.EnumCase(path, location, value, sodaBrandEnum, true)", res) 486 assert.Equal(t, 1, strings.Count(res, "m.validateSodaBrandEnum")) 487 488 k = "Soda" 489 schema = definitions[k] 490 genModel, err = makeGenDefinition(k, "models", schema, specDoc, opts) 491 require.NoError(t, err) 492 493 buf = bytes.NewBuffer(nil) 494 err = templates.MustGet("model").Execute(buf, genModel) 495 require.NoError(t, err) 496 497 ff, err = opts.LanguageOpts.FormatContent("soda.go", buf.Bytes()) 498 require.NoErrorf(t, err, buf.String()) 499 500 res = string(ff) 501 assertInCode(t, "var sodaTypeBrandPropEnum []interface{}", res) 502 assertInCode(t, "err := validate.EnumCase(path, location, value, sodaTypeBrandPropEnum, true)", res) 503 assert.Equal(t, 1, strings.Count(res, "m.validateBrandEnum")) 504 } 505 506 func TestEnum_Issue352(t *testing.T) { 507 specDoc, err := loads.Spec("../fixtures/codegen/todolist.enums.yml") 508 require.NoError(t, err) 509 510 definitions := specDoc.Spec().Definitions 511 k := "slp_action_enum" 512 schema := definitions[k] 513 opts := opts() 514 genModel, err := makeGenDefinition(k, "models", schema, specDoc, opts) 515 require.NoError(t, err) 516 517 buf := bytes.NewBuffer(nil) 518 err = templates.MustGet("model").Execute(buf, genModel) 519 require.NoError(t, err) 520 521 ff, err := opts.LanguageOpts.FormatContent("slp_action_enum.go", buf.Bytes()) 522 require.NoErrorf(t, err, buf.String()) 523 524 res := string(ff) 525 assertInCode(t, ", value SlpActionEnum", res) 526 }