github.com/josephspurrier/go-swagger@v0.2.1-0.20221129144919-1f672a142a00/generator/client_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 "log" 19 "os" 20 "path/filepath" 21 "strconv" 22 "strings" 23 "testing" 24 25 "github.com/stretchr/testify/assert" 26 "github.com/stretchr/testify/require" 27 ) 28 29 const ( 30 basicFixture = "../fixtures/petstores/petstore.json" 31 ) 32 33 func testClientGenOpts() *GenOpts { 34 g := &GenOpts{} 35 g.Target = "." 36 g.APIPackage = defaultAPIPackage 37 g.ModelPackage = defaultModelPackage 38 g.ServerPackage = defaultServerPackage 39 g.ClientPackage = defaultClientPackage 40 g.Principal = "" 41 g.IncludeModel = true 42 g.IncludeHandler = true 43 g.IncludeParameters = true 44 g.IncludeResponses = true 45 g.IncludeSupport = true 46 g.TemplateDir = "" 47 g.DumpData = false 48 g.IsClient = true 49 if err := g.EnsureDefaults(); err != nil { 50 panic(err) 51 } 52 return g 53 } 54 55 func Test_GenerateClient(t *testing.T) { 56 t.Parallel() 57 defer discardOutput()() 58 59 // exercise safeguards 60 err := GenerateClient("test", []string{"model1"}, []string{"op1", "op2"}, nil) 61 assert.Error(t, err) 62 63 opts := testClientGenOpts() 64 opts.TemplateDir = "dir/nowhere" 65 err = GenerateClient("test", []string{"model1"}, []string{"op1", "op2"}, opts) 66 assert.Error(t, err) 67 68 opts = testClientGenOpts() 69 opts.TemplateDir = "http://nowhere.com" 70 err = GenerateClient("test", []string{"model1"}, []string{"op1", "op2"}, opts) 71 assert.Error(t, err) 72 73 opts = testClientGenOpts() 74 opts.Spec = "dir/nowhere.yaml" 75 err = GenerateClient("test", []string{"model1"}, []string{"op1", "op2"}, opts) 76 assert.Error(t, err) 77 78 opts = testClientGenOpts() 79 opts.Spec = basicFixture 80 err = GenerateClient("test", []string{"model1"}, []string{}, opts) 81 assert.Error(t, err) 82 83 opts = testClientGenOpts() 84 // bad content in spec (HTML...) 85 opts.Spec = "https://github.com/OAI/OpenAPI-Specification/blob/master/examples/v2.0/json/petstore.json" 86 err = GenerateClient("test", []string{}, []string{}, opts) 87 assert.Error(t, err) 88 89 opts = testClientGenOpts() 90 // no operations selected 91 opts.Spec = "https://raw.githubusercontent.com/OAI/OpenAPI-Specification/master/examples/v2.0/yaml/petstore.yaml" 92 err = GenerateClient("test", []string{}, []string{"wrongOperationID"}, opts) 93 assert.Error(t, err) 94 95 opts = testClientGenOpts() 96 // generate remote spec 97 opts.Spec = "https://raw.githubusercontent.com/OAI/OpenAPI-Specification/master/examples/v2.0/yaml/petstore.yaml" 98 cwd, _ := os.Getwd() 99 tft, _ := os.MkdirTemp(cwd, "generated") 100 defer func() { 101 _ = os.RemoveAll(tft) 102 }() 103 opts.Target = tft 104 opts.IsClient = true 105 DefaultSectionOpts(opts) 106 107 defer func() { 108 _ = os.RemoveAll(opts.Target) 109 }() 110 err = GenerateClient("test", []string{}, []string{}, opts) 111 assert.NoError(t, err) 112 113 // just checks this does not fail 114 origStdout := os.Stdout 115 defer func() { 116 os.Stdout = origStdout 117 }() 118 tgt, _ := os.MkdirTemp(cwd, "dumped") 119 defer func() { 120 _ = os.RemoveAll(tgt) 121 }() 122 os.Stdout, _ = os.Create(filepath.Join(tgt, "stdout")) 123 opts.DumpData = true 124 err = GenerateClient("test", []string{}, []string{}, opts) 125 assert.NoError(t, err) 126 _, err = os.Stat(filepath.Join(tgt, "stdout")) 127 assert.NoError(t, err) 128 } 129 130 func assertImports(t testing.TB, baseImport, code string) { 131 assertRegexpInCode(t, baseImport, code) 132 assertRegexpInCode(t, `"`+baseImport+`/abc_linux"`, code) 133 assertRegexpInCode(t, `"`+baseImport+`/abc_linux"`, code) 134 assertRegexpInCode(t, `"`+baseImport+`/abc_test"`, code) 135 assertRegexpInCode(t, `apiops\s+"`+baseImport+`/api"`, code) 136 assertRegexpInCode(t, `"`+baseImport+`/custom"`, code) 137 assertRegexpInCode(t, `"`+baseImport+`/hash_tag_donuts"`, code) 138 assertRegexpInCode(t, `"`+baseImport+`/nr123abc"`, code) 139 assertRegexpInCode(t, `"`+baseImport+`/nr_at_donuts"`, code) 140 assertRegexpInCode(t, `"`+baseImport+`/plus_donuts`, code) 141 assertRegexpInCode(t, `strfmtops "`+baseImport+`/strfmt`, code) 142 assertRegexpInCode(t, `"`+baseImport+`/forced`, code) 143 assertRegexpInCode(t, `"`+baseImport+`/nr12nasty`, code) 144 assertRegexpInCode(t, `"`+baseImport+`/override`, code) 145 assertRegexpInCode(t, `"`+baseImport+`/gtl`, code) 146 assertRegexpInCode(t, `"`+baseImport+`/operationsops`, code) 147 } 148 149 func TestClient(t *testing.T) { 150 t.Parallel() 151 defer discardOutput()() 152 153 base := os.Getenv("GOPATH") 154 if base == "" { 155 base = "." 156 } else { 157 base = filepath.Join(base, "src") 158 err := os.MkdirAll(base, 0755) 159 require.NoError(t, err) 160 } 161 targetdir, err := os.MkdirTemp(base, "swagger_nogo") 162 require.NoError(t, err, "Failed to create a test target directory: %v", err) 163 164 defer func() { 165 _ = os.RemoveAll(targetdir) 166 log.SetOutput(os.Stdout) 167 }() 168 169 tests := []struct { 170 name string 171 spec string 172 template string 173 wantError bool 174 prepare func(opts *GenOpts) 175 verify func(testing.TB, string) 176 }{ 177 { 178 name: "InvalidSpec", 179 wantError: true, 180 prepare: func(opts *GenOpts) { 181 opts.Spec = invalidSpecExample 182 opts.ValidateSpec = true 183 }, 184 }, 185 { 186 name: "BaseImportDisabled", 187 prepare: func(opts *GenOpts) { 188 opts.LanguageOpts.BaseImportFunc = nil 189 }, 190 wantError: false, 191 }, 192 { 193 name: "Non_existing_contributor_template", 194 template: "NonExistingContributorTemplate", 195 wantError: true, 196 }, 197 { 198 name: "Existing_contributor", 199 template: "stratoscale", 200 wantError: false, 201 }, 202 { 203 name: "packages mangling", 204 wantError: false, 205 spec: filepath.Join("..", "fixtures", "bugs", "2111", "fixture-2111.yaml"), 206 verify: func(t testing.TB, target string) { 207 require.True(t, fileExists(target, "client")) 208 209 // assert package generation based on mangled tags 210 target = filepath.Join(target, "client") 211 assert.True(t, fileExists(target, "abc_linux")) 212 assert.True(t, fileExists(target, "abc_test")) 213 assert.True(t, fileExists(target, "api")) 214 assert.True(t, fileExists(target, "custom")) 215 assert.True(t, fileExists(target, "hash_tag_donuts")) 216 assert.True(t, fileExists(target, "nr123abc")) 217 assert.True(t, fileExists(target, "nr_at_donuts")) 218 assert.True(t, fileExists(target, "operations")) 219 assert.True(t, fileExists(target, "plus_donuts")) 220 assert.True(t, fileExists(target, "strfmt")) 221 assert.True(t, fileExists(target, "forced")) 222 assert.True(t, fileExists(target, "gtl")) 223 assert.True(t, fileExists(target, "nr12nasty")) 224 assert.True(t, fileExists(target, "override")) 225 assert.True(t, fileExists(target, "operationsops")) 226 227 buf, err := os.ReadFile(filepath.Join(target, "foo_client.go")) 228 require.NoError(t, err) 229 230 // assert client import, with deconfliction 231 code := string(buf) 232 baseImport := `github.com/go-swagger/go-swagger/generator/swagger_nogo\d+/packages_mangling/client` 233 assertImports(t, baseImport, code) 234 235 assertInCode(t, `cli.Strfmt = strfmtops.New(transport, formats)`, code) 236 assertInCode(t, `cli.API = apiops.New(transport, formats)`, code) 237 assertInCode(t, `cli.Operations = operations.New(transport, formats)`, code) 238 }, 239 }, 240 { 241 name: "packages flattening", 242 wantError: false, 243 spec: filepath.Join("..", "fixtures", "bugs", "2111", "fixture-2111.yaml"), 244 prepare: func(opts *GenOpts) { 245 opts.SkipTagPackages = true 246 }, 247 verify: func(t testing.TB, target string) { 248 require.True(t, fileExists(target, "client")) 249 250 // packages are not created here 251 target = filepath.Join(target, "client") 252 assert.False(t, fileExists(target, "abc_linux")) 253 assert.False(t, fileExists(target, "abc_test")) 254 assert.False(t, fileExists(target, "api")) 255 assert.False(t, fileExists(target, "custom")) 256 assert.False(t, fileExists(target, "hash_tag_donuts")) 257 assert.False(t, fileExists(target, "nr123abc")) 258 assert.False(t, fileExists(target, "nr_at_donuts")) 259 assert.False(t, fileExists(target, "plus_donuts")) 260 assert.False(t, fileExists(target, "strfmt")) 261 assert.False(t, fileExists(target, "forced")) 262 assert.False(t, fileExists(target, "gtl")) 263 assert.False(t, fileExists(target, "nr12nasty")) 264 assert.False(t, fileExists(target, "override")) 265 assert.False(t, fileExists(target, "operationsops")) 266 267 assert.True(t, fileExists(target, "operations")) 268 }, 269 }, 270 { 271 name: "name with trailing API", 272 spec: filepath.Join("..", "fixtures", "bugs", "2278", "fixture-2278.yaml"), 273 wantError: false, 274 }, 275 } 276 277 t.Run("generate client", func(t *testing.T) { 278 for idx, toPin := range tests { 279 tt := toPin 280 i := idx 281 t.Run(tt.name, func(t *testing.T) { 282 t.Parallel() 283 opts := testClientGenOpts() 284 opts.Spec = basicFixture 285 opts.Target = filepath.Join(targetdir, opts.LanguageOpts.ManglePackageName(tt.name, "client_test"+strconv.Itoa(i))) 286 err := os.MkdirAll(opts.Target, 0755) 287 require.NoError(t, err) 288 289 if tt.spec == "" { 290 opts.Spec = basicFixture 291 } else { 292 opts.Spec = tt.spec 293 } 294 opts.Template = tt.template 295 296 if tt.prepare != nil { 297 tt.prepare(opts) 298 } 299 300 err = GenerateClient("foo", nil, nil, opts) 301 if tt.wantError { 302 require.Errorf(t, err, "expected an error for client build fixture: %s", opts.Spec) 303 } else { 304 require.NoError(t, err, "unexpected error for client build fixture: %s", opts.Spec) 305 } 306 307 if tt.verify != nil { 308 tt.verify(t, opts.Target) 309 } 310 }) 311 } 312 }) 313 } 314 315 func TestGenClient_1518(t *testing.T) { 316 t.Parallel() 317 defer discardOutput()() 318 319 // test client response handling when unexpected success response kicks in 320 321 opts := testClientGenOpts() 322 opts.Spec = filepath.Join("..", "fixtures", "bugs", "1518", "fixture-1518.yaml") 323 324 cwd, _ := os.Getwd() 325 tft, _ := os.MkdirTemp(cwd, "generated") 326 opts.Target = tft 327 328 defer func() { 329 _ = os.RemoveAll(tft) 330 }() 331 332 err := GenerateClient("client", []string{}, []string{}, opts) 333 require.NoError(t, err) 334 335 fixtureConfig := map[string][]string{ 336 "client/operations/operations_client.go": { // generated file 337 // expected code lines 338 `success, ok := result.(*GetRecords1OK)`, 339 `if ok {`, 340 `return success, nil`, 341 `msg := fmt.Sprintf(`, 342 `panic(msg)`, 343 // expected code lines 344 `success, ok := result.(*GetRecords2OK)`, 345 `if ok {`, 346 `return success, nil`, 347 `unexpectedSuccess := result.(*GetRecords2Default)`, 348 `return nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())`, 349 // expected code lines 350 `switch value := result.(type) {`, 351 `case *GetRecords3OK:`, 352 `return value, nil, nil`, 353 `case *GetRecords3Created:`, 354 `return nil, value, nil`, 355 `msg := fmt.Sprintf(`, 356 `panic(msg)`, 357 // expected code lines 358 `switch value := result.(type) {`, 359 `case *GetRecords4OK:`, 360 `return value, nil, nil`, 361 `case *GetRecords4Created:`, 362 `return nil, value, nil`, 363 `unexpectedSuccess := result.(*GetRecords4Default)`, 364 `return nil, nil, runtime.NewAPIError("unexpected success response: content available as default response in error", unexpectedSuccess, unexpectedSuccess.Code())`, 365 }, 366 } 367 368 for fileToInspect, expectedCode := range fixtureConfig { 369 code, err := os.ReadFile(filepath.Join(opts.Target, filepath.FromSlash(fileToInspect))) 370 require.NoError(t, err) 371 372 for line, codeLine := range expectedCode { 373 if !assertInCode(t, strings.TrimSpace(codeLine), string(code)) { 374 t.Logf("Code expected did not match in codegenfile %s for expected line %d: %q", fileToInspect, line, expectedCode[line]) 375 } 376 } 377 } 378 } 379 380 func TestGenClient_2471(t *testing.T) { 381 t.Parallel() 382 defer discardOutput()() 383 384 opts := testClientGenOpts() 385 opts.Spec = filepath.Join("..", "fixtures", "bugs", "2471", "fixture-2471.yaml") 386 387 cwd, _ := os.Getwd() 388 tft, _ := os.MkdirTemp(cwd, "generated") 389 opts.Target = tft 390 391 defer func() { 392 _ = os.RemoveAll(tft) 393 }() 394 395 err := GenerateClient("client", []string{}, []string{}, opts) 396 require.NoError(t, err) 397 398 fixtureConfig := map[string][]string{ 399 "client/operations/example_post_parameters.go": { // generated file 400 `func (o *ExamplePostParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error {`, 401 ` if err := r.SetTimeout(o.timeout); err != nil {`, 402 ` joinedFoo := o.bindParamFoo(reg)`, 403 ` if len(joinedFoo) > 0 {`, 404 ` if err := r.SetHeaderParam("Foo", joinedFoo[0]); err != nil {`, 405 ` joinedFooPath := o.bindParamFooPath(reg)`, 406 ` if len(joinedFooPath) > 0 {`, 407 ` if err := r.SetPathParam("FooPath", joinedFooPath[0]); err != nil {`, 408 ` joinedFooQuery := o.bindParamFooQuery(reg)`, 409 ` if err := r.SetQueryParam("FooQuery", joinedFooQuery...); err != nil {`, 410 `func (o *ExamplePostParams) bindParamFoo(formats strfmt.Registry) []string {`, 411 ` fooIR := o.Foo`, 412 ` var fooIC []string`, 413 ` for _, fooIIR := range fooIR {`, 414 ` fooIIV := fooIIR`, 415 ` fooIC = append(fooIC, fooIIV)`, 416 ` fooIS := swag.JoinByFormat(fooIC, "")`, 417 ` return fooIS`, 418 `func (o *ExamplePostParams) bindParamFooPath(formats strfmt.Registry) []string {`, 419 ` fooPathIR := o.FooPath`, 420 ` var fooPathIC []string`, 421 ` for _, fooPathIIR := range fooPathIR {`, 422 ` fooPathIIV := fooPathIIR`, 423 ` fooPathIC = append(fooPathIC, fooPathIIV)`, 424 ` fooPathIS := swag.JoinByFormat(fooPathIC, "")`, 425 ` return fooPathIS`, 426 `func (o *ExamplePostParams) bindParamFooQuery(formats strfmt.Registry) []string {`, 427 ` fooQueryIR := o.FooQuery`, 428 ` var fooQueryIC []string`, 429 ` for _, fooQueryIIR := range fooQueryIR {`, 430 ` fooQueryIIV := fooQueryIIR`, 431 ` fooQueryIC = append(fooQueryIC, fooQueryIIV)`, 432 ` fooQueryIS := swag.JoinByFormat(fooQueryIC, "")`, 433 ` return fooQueryIS`, 434 }, 435 } 436 437 for fileToInspect, expectedCode := range fixtureConfig { 438 code, err := os.ReadFile(filepath.Join(opts.Target, filepath.FromSlash(fileToInspect))) 439 require.NoError(t, err) 440 441 for line, codeLine := range expectedCode { 442 if !assertInCode(t, strings.TrimSpace(codeLine), string(code)) { 443 t.Logf("Code expected did not match in codegenfile %s for expected line %d: %q", fileToInspect, line, expectedCode[line]) 444 } 445 } 446 } 447 } 448 449 func TestGenClient_2096(t *testing.T) { 450 t.Parallel() 451 defer discardOutput()() 452 453 opts := testClientGenOpts() 454 opts.Spec = filepath.Join("..", "fixtures", "bugs", "2096", "fixture-2096.yaml") 455 456 cwd, _ := os.Getwd() 457 tft, _ := os.MkdirTemp(cwd, "generated") 458 opts.Target = tft 459 460 defer func() { 461 _ = os.RemoveAll(tft) 462 }() 463 464 err := GenerateClient("client", []string{}, []string{}, opts) 465 require.NoError(t, err) 466 467 fixtureConfig := map[string][]string{ 468 "client/operations/list_resources_parameters.go": { // generated file 469 `type ListResourcesParams struct {`, 470 ` Fields []string`, 471 `func (o *ListResourcesParams) SetDefaults() {`, 472 ` var (`, 473 ` fieldsDefault = []string{"first", "second", "third"}`, 474 ` val := ListResourcesParams{`, 475 ` Fields: fieldsDefault,`, 476 ` val.timeout = o.timeout`, 477 ` val.Context = o.Context`, 478 ` val.HTTPClient = o.HTTPClient`, 479 ` *o = val`, 480 ` joinedFields := o.bindParamFields(reg)`, 481 ` if err := r.SetQueryParam("fields", joinedFields...); err != nil {`, 482 }, 483 } 484 485 for fileToInspect, expectedCode := range fixtureConfig { 486 code, err := os.ReadFile(filepath.Join(opts.Target, filepath.FromSlash(fileToInspect))) 487 require.NoError(t, err) 488 489 for line, codeLine := range expectedCode { 490 if !assertInCode(t, strings.TrimSpace(codeLine), string(code)) { 491 t.Logf("Code expected did not match in codegenfile %s for expected line %d: %q", fileToInspect, line, expectedCode[line]) 492 } 493 } 494 } 495 } 496 497 func TestGenClient_909_3(t *testing.T) { 498 t.Parallel() 499 defer discardOutput()() 500 501 opts := testClientGenOpts() 502 opts.Spec = filepath.Join("..", "fixtures", "bugs", "909", "fixture-909-3.yaml") 503 504 cwd, _ := os.Getwd() 505 tft, _ := os.MkdirTemp(cwd, "generated") 506 opts.Target = tft 507 508 defer func() { 509 _ = os.RemoveAll(tft) 510 }() 511 512 err := GenerateClient("client", []string{}, []string{}, opts) 513 require.NoError(t, err) 514 515 fixtureConfig := map[string][]string{ 516 "client/operations/get_optional_parameters.go": { // generated file 517 `func (o *GetOptionalParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error {`, 518 ` if err := r.SetTimeout(o.timeout); err != nil {`, 519 ` if o.IsAnOption2 != nil {`, 520 ` joinedIsAnOption2 := o.bindParamIsAnOption2(reg)`, 521 ` if err := r.SetQueryParam("isAnOption2", joinedIsAnOption2...); err != nil {`, 522 ` if o.IsAnOption4 != nil {`, 523 ` joinedIsAnOption4 := o.bindParamIsAnOption4(reg)`, 524 ` if err := r.SetQueryParam("isAnOption4", joinedIsAnOption4...); err != nil {`, 525 ` if o.IsAnOptionalHeader != nil {`, 526 ` joinedIsAnOptionalHeader := o.bindParamIsAnOptionalHeader(reg)`, 527 ` if len(joinedIsAnOptionalHeader) > 0 {`, 528 ` if err := r.SetHeaderParam("isAnOptionalHeader", joinedIsAnOptionalHeader[0]); err != nil {`, 529 ` if o.NotAnOption1 != nil {`, 530 ` joinedNotAnOption1 := o.bindParamNotAnOption1(reg)`, 531 ` if err := r.SetQueryParam("notAnOption1", joinedNotAnOption1...); err != nil {`, 532 ` if o.NotAnOption3 != nil {`, 533 ` if err := r.SetBodyParam(o.NotAnOption3); err != nil {`, 534 `func (o *GetOptionalParams) bindParamIsAnOption2(formats strfmt.Registry) []string {`, 535 ` isAnOption2IR := o.IsAnOption2`, 536 ` var isAnOption2IC []string`, 537 ` for _, isAnOption2IIR := range isAnOption2IR { // explode [][]strfmt.UUID`, 538 ` var isAnOption2IIC []string`, 539 ` for _, isAnOption2IIIR := range isAnOption2IIR { // explode []strfmt.UUID`, 540 ` isAnOption2IIIV := isAnOption2IIIR.String() // strfmt.UUID as string`, 541 ` isAnOption2IIC = append(isAnOption2IIC, isAnOption2IIIV)`, 542 ` isAnOption2IIS := swag.JoinByFormat(isAnOption2IIC, "")`, 543 ` isAnOption2IIV := isAnOption2IIS[0]`, 544 ` isAnOption2IC = append(isAnOption2IC, isAnOption2IIV)`, 545 ` isAnOption2IS := swag.JoinByFormat(isAnOption2IC, "pipes")`, 546 ` return isAnOption2IS`, 547 `func (o *GetOptionalParams) bindParamIsAnOption4(formats strfmt.Registry) []string {`, 548 ` isAnOption4IR := o.IsAnOption4`, 549 ` var isAnOption4IC []string`, 550 ` for _, isAnOption4IIR := range isAnOption4IR { // explode [][][]strfmt.UUID`, 551 ` var isAnOption4IIC []string`, 552 ` for _, isAnOption4IIIR := range isAnOption4IIR { // explode [][]strfmt.UUID`, 553 ` var isAnOption4IIIC []string`, 554 ` for _, isAnOption4IIIIR := range isAnOption4IIIR { // explode []strfmt.UUID`, 555 ` isAnOption4IIIIV := isAnOption4IIIIR.String() // strfmt.UUID as string`, 556 ` isAnOption4IIIC = append(isAnOption4IIIC, isAnOption4IIIIV)`, 557 ` isAnOption4IIIS := swag.JoinByFormat(isAnOption4IIIC, "pipes")`, 558 ` isAnOption4IIIV := isAnOption4IIIS[0]`, 559 ` isAnOption4IIC = append(isAnOption4IIC, isAnOption4IIIV)`, 560 ` }`, 561 ` isAnOption4IIS := swag.JoinByFormat(isAnOption4IIC, "tsv")`, 562 ` isAnOption4IIV := isAnOption4IIS[0]`, 563 ` isAnOption4IC = append(isAnOption4IC, isAnOption4IIV)`, 564 ` isAnOption4IS := swag.JoinByFormat(isAnOption4IC, "csv")`, 565 ` return isAnOption4IS`, 566 `func (o *GetOptionalParams) bindParamIsAnOptionalHeader(formats strfmt.Registry) []string {`, 567 ` isAnOptionalHeaderIR := o.IsAnOptionalHeader`, 568 ` var isAnOptionalHeaderIC []string`, 569 ` for _, isAnOptionalHeaderIIR := range isAnOptionalHeaderIR { // explode [][]strfmt.UUID`, 570 ` var isAnOptionalHeaderIIC []string`, 571 ` for _, isAnOptionalHeaderIIIR := range isAnOptionalHeaderIIR { // explode []strfmt.UUID`, 572 ` isAnOptionalHeaderIIIV := isAnOptionalHeaderIIIR.String() // strfmt.UUID as string`, 573 ` isAnOptionalHeaderIIC = append(isAnOptionalHeaderIIC, isAnOptionalHeaderIIIV)`, 574 ` isAnOptionalHeaderIIS := swag.JoinByFormat(isAnOptionalHeaderIIC, "")`, 575 ` isAnOptionalHeaderIIV := isAnOptionalHeaderIIS[0]`, 576 ` isAnOptionalHeaderIC = append(isAnOptionalHeaderIC, isAnOptionalHeaderIIV)`, 577 ` isAnOptionalHeaderIS := swag.JoinByFormat(isAnOptionalHeaderIC, "pipes")`, 578 ` return isAnOptionalHeaderIS`, 579 `func (o *GetOptionalParams) bindParamNotAnOption1(formats strfmt.Registry) []string {`, 580 ` notAnOption1IR := o.NotAnOption1`, 581 ` var notAnOption1IC []string`, 582 ` for _, notAnOption1IIR := range notAnOption1IR { // explode [][]strfmt.DateTime`, 583 ` var notAnOption1IIC []string`, 584 ` for _, notAnOption1IIIR := range notAnOption1IIR { // explode []strfmt.DateTime`, 585 ` notAnOption1IIIV := notAnOption1IIIR.String() // strfmt.DateTime as string`, 586 ` notAnOption1IIC = append(notAnOption1IIC, notAnOption1IIIV)`, 587 ` notAnOption1IIS := swag.JoinByFormat(notAnOption1IIC, "pipes")`, 588 ` notAnOption1IIV := notAnOption1IIS[0]`, 589 ` notAnOption1IC = append(notAnOption1IC, notAnOption1IIV)`, 590 ` notAnOption1IS := swag.JoinByFormat(notAnOption1IC, "csv")`, 591 ` return notAnOption1IS`, 592 }, 593 } 594 595 for fileToInspect, expectedCode := range fixtureConfig { 596 code, err := os.ReadFile(filepath.Join(opts.Target, filepath.FromSlash(fileToInspect))) 597 require.NoError(t, err) 598 599 for line, codeLine := range expectedCode { 600 if !assertInCode(t, strings.TrimSpace(codeLine), string(code)) { 601 t.Logf("Code expected did not match in codegenfile %s for expected line %d: %q", fileToInspect, line, expectedCode[line]) 602 } 603 } 604 } 605 } 606 607 func TestGenClient_909_5(t *testing.T) { 608 t.Parallel() 609 defer discardOutput()() 610 611 opts := testClientGenOpts() 612 opts.Spec = filepath.Join("..", "fixtures", "bugs", "909", "fixture-909-5.yaml") 613 614 cwd, _ := os.Getwd() 615 tft, _ := os.MkdirTemp(cwd, "generated") 616 opts.Target = tft 617 618 defer func() { 619 _ = os.RemoveAll(tft) 620 }() 621 622 err := GenerateClient("client", []string{}, []string{}, opts) 623 require.NoError(t, err) 624 625 fixtureConfig := map[string][]string{ 626 "client/operations/get_optional_responses.go": { // generated file 627 `func NewGetOptionalOK() *GetOptionalOK {`, 628 ` var (`, 629 ` xIsAnOptionalHeader0Default = strfmt.DateTime{}`, 630 ` xIsAnOptionalHeader0PrimitiveDefault = float32(345.55)`, 631 ` xIsAnOptionalHeader0StringerDefault = strfmt.UUID("524fc6d5-66c6-46f6-90bc-34e0d0139e43")`, 632 ` xIsAnOptionalHeader1Default = make([]strfmt.DateTime, 0, 50)`, 633 ` xIsAnOptionalHeader2Default = make([][]int32, 0, 50)`, 634 ` xIsAnOptionalHeader2NoFormatDefault = make([][]int64, 0, 50)`, 635 ` xIsAnOptionalHeader3Default = make([][][]strfmt.UUID, 0, 50)`, 636 ` )`, 637 ` if err := xIsAnOptionalHeader0Default.UnmarshalText([]byte("2018-01-28T23:54:00.000Z")); err != nil {`, 638 ` msg := fmt.Sprintf("invalid default value for xIsAnOptionalHeader0: %v", err)`, 639 " if err := json.Unmarshal([]byte(`[\"2018-01-28T23:54:00.000Z\",\"2018-02-28T23:54:00.000Z\",\"2018-03-28T23:54:00.000Z\",\"2018-04-28T23:54:00.000Z\"]`), &xIsAnOptionalHeader1Default); err != nil {", 640 ` msg := fmt.Sprintf("invalid default value for xIsAnOptionalHeader1: %v", err)`, 641 " if err := json.Unmarshal([]byte(`[[21,22,23],[31,32,33]]`), &xIsAnOptionalHeader2Default); err != nil {", 642 ` msg := fmt.Sprintf("invalid default value for xIsAnOptionalHeader2: %v", err)`, 643 " if err := json.Unmarshal([]byte(`[[21,22,23],[31,32,33]]`), &xIsAnOptionalHeader2NoFormatDefault); err != nil {", 644 ` msg := fmt.Sprintf("invalid default value for xIsAnOptionalHeader2NoFormat: %v", err)`, 645 " if err := json.Unmarshal([]byte(`[[[\"524fc6d5-66c6-46f6-90bc-34e0d0139e43\",\"c8199a5f-f7ce-4fb1-b8af-082256125e89\"],[\"c8199a5f-f7ce-4fb1-b8af-082256125e89\",\"524fc6d5-66c6-46f6-90bc-34e0d0139e43\"]],[[\"c8199a5f-f7ce-4fb1-b8af-082256125e89\",\"524fc6d5-66c6-46f6-90bc-34e0d0139e43\"],[\"524fc6d5-66c6-46f6-90bc-34e0d0139e43\",\"c8199a5f-f7ce-4fb1-b8af-082256125e89\"]]]`), &xIsAnOptionalHeader3Default); err != nil {", 646 ` msg := fmt.Sprintf("invalid default value for xIsAnOptionalHeader3: %v", err)`, 647 ` return &GetOptionalOK{`, 648 ` XIsAnOptionalHeader0: xIsAnOptionalHeader0Default,`, 649 ` XIsAnOptionalHeader0Primitive: xIsAnOptionalHeader0PrimitiveDefault,`, 650 ` XIsAnOptionalHeader0Stringer: xIsAnOptionalHeader0StringerDefault,`, 651 ` XIsAnOptionalHeader1: xIsAnOptionalHeader1Default,`, 652 ` XIsAnOptionalHeader2: xIsAnOptionalHeader2Default,`, 653 ` XIsAnOptionalHeader2NoFormat: xIsAnOptionalHeader2NoFormatDefault,`, 654 ` XIsAnOptionalHeader3: xIsAnOptionalHeader3Default,`, 655 `func (o *GetOptionalOK) readResponse(response runtime.ClientResponse, consumer runtime.Consumer, formats strfmt.Registry) error {`, 656 ` hdrXIsAnOptionalHeader0 := response.GetHeader("x-isAnOptionalHeader0")`, 657 ` if hdrXIsAnOptionalHeader0 != "" {`, 658 ` valxIsAnOptionalHeader0, err := formats.Parse("date-time", hdrXIsAnOptionalHeader0)`, 659 ` if err != nil {`, 660 ` return errors.InvalidType("x-isAnOptionalHeader0", "header", "strfmt.DateTime", hdrXIsAnOptionalHeader0)`, 661 ` o.XIsAnOptionalHeader0 = *(valxIsAnOptionalHeader0.(*strfmt.DateTime))`, 662 ` hdrXIsAnOptionalHeader0DirtSimple := response.GetHeader("x-isAnOptionalHeader0DirtSimple")`, 663 ` if hdrXIsAnOptionalHeader0DirtSimple != "" {`, 664 ` o.XIsAnOptionalHeader0DirtSimple = hdrXIsAnOptionalHeader0DirtSimple`, 665 ` hdrXIsAnOptionalHeader0DirtSimpleArray := response.GetHeader("x-isAnOptionalHeader0DirtSimpleArray")`, 666 ` if hdrXIsAnOptionalHeader0DirtSimpleArray != "" {`, 667 ` valXIsAnOptionalHeader0DirtSimpleArray, err := o.bindHeaderXIsAnOptionalHeader0DirtSimpleArray(hdrXIsAnOptionalHeader0DirtSimpleArray, formats)`, 668 ` o.XIsAnOptionalHeader0DirtSimpleArray = valXIsAnOptionalHeader0DirtSimpleArray`, 669 ` hdrXIsAnOptionalHeader0DirtSimpleInteger := response.GetHeader("x-isAnOptionalHeader0DirtSimpleInteger")`, 670 ` if hdrXIsAnOptionalHeader0DirtSimpleInteger != "" {`, 671 ` valxIsAnOptionalHeader0DirtSimpleInteger, err := swag.ConvertInt64(hdrXIsAnOptionalHeader0DirtSimpleInteger)`, 672 ` return errors.InvalidType("x-isAnOptionalHeader0DirtSimpleInteger", "header", "int64", hdrXIsAnOptionalHeader0DirtSimpleInteger)`, 673 ` o.XIsAnOptionalHeader0DirtSimpleInteger = valxIsAnOptionalHeader0DirtSimpleInteger`, 674 ` hdrXIsAnOptionalHeader0Primitive := response.GetHeader("x-isAnOptionalHeader0Primitive")`, 675 ` if hdrXIsAnOptionalHeader0Primitive != "" {`, 676 ` valxIsAnOptionalHeader0Primitive, err := swag.ConvertFloat32(hdrXIsAnOptionalHeader0Primitive)`, 677 ` return errors.InvalidType("x-isAnOptionalHeader0Primitive", "header", "float32", hdrXIsAnOptionalHeader0Primitive)`, 678 ` o.XIsAnOptionalHeader0Primitive = valxIsAnOptionalHeader0Primitive`, 679 ` hdrXIsAnOptionalHeader0Stringer := response.GetHeader("x-isAnOptionalHeader0Stringer")`, 680 ` if hdrXIsAnOptionalHeader0Stringer != "" {`, 681 ` valxIsAnOptionalHeader0Stringer, err := formats.Parse("uuid", hdrXIsAnOptionalHeader0Stringer)`, 682 ` return errors.InvalidType("x-isAnOptionalHeader0Stringer", "header", "strfmt.UUID", hdrXIsAnOptionalHeader0Stringer)`, 683 ` o.XIsAnOptionalHeader0Stringer = *(valxIsAnOptionalHeader0Stringer.(*strfmt.UUID))`, 684 ` hdrXIsAnOptionalHeader1 := response.GetHeader("x-isAnOptionalHeader1")`, 685 ` if hdrXIsAnOptionalHeader1 != "" {`, 686 ` valXIsAnOptionalHeader1, err := o.bindHeaderXIsAnOptionalHeader1(hdrXIsAnOptionalHeader1, formats)`, 687 ` o.XIsAnOptionalHeader1 = valXIsAnOptionalHeader1`, 688 ` hdrXIsAnOptionalHeader2 := response.GetHeader("x-isAnOptionalHeader2")`, 689 ` if hdrXIsAnOptionalHeader2 != "" {`, 690 ` valXIsAnOptionalHeader2, err := o.bindHeaderXIsAnOptionalHeader2(hdrXIsAnOptionalHeader2, formats)`, 691 ` o.XIsAnOptionalHeader2 = valXIsAnOptionalHeader2`, 692 ` hdrXIsAnOptionalHeader2NoFormat := response.GetHeader("x-isAnOptionalHeader2NoFormat")`, 693 ` if hdrXIsAnOptionalHeader2NoFormat != "" {`, 694 ` valXIsAnOptionalHeader2NoFormat, err := o.bindHeaderXIsAnOptionalHeader2NoFormat(hdrXIsAnOptionalHeader2NoFormat, formats)`, 695 ` o.XIsAnOptionalHeader2NoFormat = valXIsAnOptionalHeader2NoFormat`, 696 ` hdrXIsAnOptionalHeader3 := response.GetHeader("x-isAnOptionalHeader3")`, 697 ` if hdrXIsAnOptionalHeader3 != "" {`, 698 ` valXIsAnOptionalHeader3, err := o.bindHeaderXIsAnOptionalHeader3(hdrXIsAnOptionalHeader3, formats)`, 699 ` o.XIsAnOptionalHeader3 = valXIsAnOptionalHeader3`, 700 ` if err := consumer.Consume(response.Body(), &o.Payload); err != nil && err != io.EOF {`, 701 `func (o *GetOptionalOK) bindHeaderXIsAnOptionalHeader0DirtSimpleArray(hdr string, formats strfmt.Registry) ([]int64, error) {`, 702 ` xIsAnOptionalHeader0DirtSimpleArrayIV := hdr`, 703 ` var (`, 704 ` xIsAnOptionalHeader0DirtSimpleArrayIC []int64`, 705 ` xIsAnOptionalHeader0DirtSimpleArrayIR := swag.SplitByFormat(xIsAnOptionalHeader0DirtSimpleArrayIV, "")`, 706 ` for i, xIsAnOptionalHeader0DirtSimpleArrayIIV := range xIsAnOptionalHeader0DirtSimpleArrayIR {`, 707 ` val, err := swag.ConvertInt64(xIsAnOptionalHeader0DirtSimpleArrayIIV)`, 708 ` return nil, errors.InvalidType(fmt.Sprintf("%s.%v", "header", i), "headeritems.", "int64", xIsAnOptionalHeader0DirtSimpleArrayIIV)`, 709 ` xIsAnOptionalHeader0DirtSimpleArrayIIC := val`, 710 ` xIsAnOptionalHeader0DirtSimpleArrayIC = append(xIsAnOptionalHeader0DirtSimpleArrayIC, xIsAnOptionalHeader0DirtSimpleArrayIIC) // roll-up int64 into []int64`, 711 ` return xIsAnOptionalHeader0DirtSimpleArrayIC, nil`, 712 `func (o *GetOptionalOK) bindHeaderXIsAnOptionalHeader1(hdr string, formats strfmt.Registry) ([]strfmt.DateTime, error) {`, 713 ` xIsAnOptionalHeader1IV := hdr`, 714 ` xIsAnOptionalHeader1IC []strfmt.DateTime`, 715 ` xIsAnOptionalHeader1IR := swag.SplitByFormat(xIsAnOptionalHeader1IV, "tsv")`, 716 ` for i, xIsAnOptionalHeader1IIV := range xIsAnOptionalHeader1IR {`, 717 ` val, err := formats.Parse("date-time", xIsAnOptionalHeader1IIV)`, 718 ` return nil, errors.InvalidType(fmt.Sprintf("%s.%v", "header", i), "headeritems.", "strfmt.DateTime", xIsAnOptionalHeader1IIV)`, 719 ` xIsAnOptionalHeader1IIC := val.(strfmt.DateTime)`, 720 ` xIsAnOptionalHeader1IC = append(xIsAnOptionalHeader1IC, xIsAnOptionalHeader1IIC) // roll-up strfmt.DateTime into []strfmt.DateTime`, 721 ` return xIsAnOptionalHeader1IC, nil`, 722 `func (o *GetOptionalOK) bindHeaderXIsAnOptionalHeader2(hdr string, formats strfmt.Registry) ([][]int32, error) {`, 723 ` xIsAnOptionalHeader2IV := hdr`, 724 ` xIsAnOptionalHeader2IC [][]int32`, 725 ` xIsAnOptionalHeader2IR := swag.SplitByFormat(xIsAnOptionalHeader2IV, "")`, 726 ` for _, xIsAnOptionalHeader2IIV := range xIsAnOptionalHeader2IR {`, 727 ` xIsAnOptionalHeader2IIC []int32`, 728 ` xIsAnOptionalHeader2IIR := swag.SplitByFormat(xIsAnOptionalHeader2IIV, "pipes")`, 729 ` for ii, xIsAnOptionalHeader2IIIV := range xIsAnOptionalHeader2IIR {`, 730 ` val, err := swag.ConvertInt32(xIsAnOptionalHeader2IIIV)`, 731 ` return nil, errors.InvalidType(fmt.Sprintf("%s.%v", "header", ii), "headeritems.items.", "int32", xIsAnOptionalHeader2IIIV)`, 732 ` xIsAnOptionalHeader2IIIC := val`, 733 ` xIsAnOptionalHeader2IIC = append(xIsAnOptionalHeader2IIC, xIsAnOptionalHeader2IIIC) // roll-up int32 into []int32`, 734 ` xIsAnOptionalHeader2IC = append(xIsAnOptionalHeader2IC, xIsAnOptionalHeader2IIC) // roll-up []int32 into [][]int32`, 735 ` return xIsAnOptionalHeader2IC, nil`, 736 `func (o *GetOptionalOK) bindHeaderXIsAnOptionalHeader2NoFormat(hdr string, formats strfmt.Registry) ([][]int64, error) {`, 737 ` xIsAnOptionalHeader2NoFormatIV := hdr`, 738 ` xIsAnOptionalHeader2NoFormatIC [][]int64`, 739 ` xIsAnOptionalHeader2NoFormatIR := swag.SplitByFormat(xIsAnOptionalHeader2NoFormatIV, "pipes")`, 740 ` for _, xIsAnOptionalHeader2NoFormatIIV := range xIsAnOptionalHeader2NoFormatIR {`, 741 ` xIsAnOptionalHeader2NoFormatIIC []int64`, 742 ` xIsAnOptionalHeader2NoFormatIIR := swag.SplitByFormat(xIsAnOptionalHeader2NoFormatIIV, "tsv")`, 743 ` for ii, xIsAnOptionalHeader2NoFormatIIIV := range xIsAnOptionalHeader2NoFormatIIR {`, 744 ` val, err := swag.ConvertInt64(xIsAnOptionalHeader2NoFormatIIIV)`, 745 ` return nil, errors.InvalidType(fmt.Sprintf("%s.%v", "header", ii), "headeritems.items.", "int64", xIsAnOptionalHeader2NoFormatIIIV)`, 746 ` xIsAnOptionalHeader2NoFormatIIIC := val`, 747 ` xIsAnOptionalHeader2NoFormatIIC = append(xIsAnOptionalHeader2NoFormatIIC, xIsAnOptionalHeader2NoFormatIIIC) // roll-up int64 into []int64`, 748 ` xIsAnOptionalHeader2NoFormatIC = append(xIsAnOptionalHeader2NoFormatIC, xIsAnOptionalHeader2NoFormatIIC) // roll-up []int64 into [][]int64`, 749 ` return xIsAnOptionalHeader2NoFormatIC, nil`, 750 `func (o *GetOptionalOK) bindHeaderXIsAnOptionalHeader3(hdr string, formats strfmt.Registry) ([][][]strfmt.UUID, error) {`, 751 ` xIsAnOptionalHeader3IV := hdr`, 752 ` xIsAnOptionalHeader3IC [][][]strfmt.UUID`, 753 ` xIsAnOptionalHeader3IR := swag.SplitByFormat(xIsAnOptionalHeader3IV, "")`, 754 ` for _, xIsAnOptionalHeader3IIV := range xIsAnOptionalHeader3IR {`, 755 ` xIsAnOptionalHeader3IIC [][]strfmt.UUID`, 756 ` xIsAnOptionalHeader3IIR := swag.SplitByFormat(xIsAnOptionalHeader3IIV, "pipes")`, 757 ` for _, xIsAnOptionalHeader3IIIV := range xIsAnOptionalHeader3IIR {`, 758 ` xIsAnOptionalHeader3IIIC []strfmt.UUID`, 759 ` xIsAnOptionalHeader3IIIR := swag.SplitByFormat(xIsAnOptionalHeader3IIIV, "")`, 760 ` for iii, xIsAnOptionalHeader3IIIIV := range xIsAnOptionalHeader3IIIR {`, 761 ` val, err := formats.Parse("uuid", xIsAnOptionalHeader3IIIIV)`, 762 ` return nil, errors.InvalidType(fmt.Sprintf("%s.%v", "header", iii), "headeritems.items.", "strfmt.UUID", xIsAnOptionalHeader3IIIIV)`, 763 ` xIsAnOptionalHeader3IIIIC := val.(strfmt.UUID)`, 764 ` xIsAnOptionalHeader3IIIC = append(xIsAnOptionalHeader3IIIC, xIsAnOptionalHeader3IIIIC) // roll-up strfmt.UUID into []strfmt.UUID`, 765 ` xIsAnOptionalHeader3IIC = append(xIsAnOptionalHeader3IIC, xIsAnOptionalHeader3IIIC) // roll-up []strfmt.UUID into [][]strfmt.UUID`, 766 ` xIsAnOptionalHeader3IC = append(xIsAnOptionalHeader3IC, xIsAnOptionalHeader3IIC) // roll-up [][]strfmt.UUID into [][][]strfmt.UUID`, 767 ` return xIsAnOptionalHeader3IC, nil`, 768 }, 769 } 770 771 for fileToInspect, expectedCode := range fixtureConfig { 772 code, err := os.ReadFile(filepath.Join(opts.Target, filepath.FromSlash(fileToInspect))) 773 require.NoError(t, err) 774 775 for line, codeLine := range expectedCode { 776 if !assertInCode(t, strings.TrimSpace(codeLine), string(code)) { 777 t.Logf("Code expected did not match in codegenfile %s for expected line %d: %q", fileToInspect, line, expectedCode[line]) 778 } 779 } 780 } 781 } 782 783 func TestGenClient_909_6(t *testing.T) { 784 t.Parallel() 785 defer discardOutput()() 786 787 opts := testClientGenOpts() 788 opts.Spec = filepath.Join("..", "fixtures", "bugs", "909", "fixture-909-6.yaml") 789 790 cwd, _ := os.Getwd() 791 tft, _ := os.MkdirTemp(cwd, "generated") 792 opts.Target = tft 793 794 defer func() { 795 _ = os.RemoveAll(tft) 796 }() 797 798 err := GenerateClient("client", []string{}, []string{}, opts) 799 require.NoError(t, err) 800 801 fixtureConfig := map[string][]string{ 802 "client/operations/get_optional_responses.go": { // generated file 803 `func NewGetOptionalOK() *GetOptionalOK {`, 804 ` var (`, 805 ` xaBoolDefault = bool(true)`, 806 ` xaBsonObjectIDDefault = strfmt.ObjectId{}`, 807 ` xaByteDefault = strfmt.Base64([]byte(nil))`, 808 ` xaCreditCardDefault = strfmt.CreditCard("4111-1111-1111-1111")`, 809 ` xaDateDefault = strfmt.Date{}`, 810 ` xaDateTimeDefault = strfmt.DateTime{}`, 811 ` xaDoubleDefault = float64(99.99)`, 812 ` xaDurationDefault = strfmt.Duration(0)`, 813 ` xaFloatDefault = float32(99.99)`, 814 ` xaHexColorDefault = strfmt.HexColor("#FFFFFF")`, 815 ` xaHostnameDefault = strfmt.Hostname("www.example.com")`, 816 ` xaInt32Default = int32(-99)`, 817 ` xaInt64Default = int64(-99)`, 818 ` xaMacDefault = strfmt.MAC("01:02:03:04:05:06")`, 819 ` xaPasswordDefault = strfmt.Password("secret")`, 820 ` xaRGBColorDefault = strfmt.RGBColor("rgb(255,255,255)")`, 821 ` xaSsnDefault = strfmt.SSN("111-11-1111")`, 822 ` xaUUIDDefault = strfmt.UUID("a8098c1a-f86e-11da-bd1a-00112444be1e")`, 823 ` xaUUID3Default = strfmt.UUID3("bcd02e22-68f0-3046-a512-327cca9def8f")`, 824 ` xaUUID4Default = strfmt.UUID4("025b0d74-00a2-4048-bf57-227c5111bb34")`, 825 ` xaUUID5Default = strfmt.UUID5("886313e1-3b8a-5372-9b90-0c9aee199e5d")`, 826 ` xaUint32Default = uint32(99)`, 827 ` xaUint64Default = uint64(99)`, 828 ` xaURIDefault = strfmt.URI("http://foo.bar/?baz=qux#quux")`, 829 ` xAnEmailDefault = strfmt.Email("fredbi@github.com")`, 830 ` xAnISBNDefault = strfmt.ISBN("0321751043")`, 831 ` xAnISBN10Default = strfmt.ISBN10("0321751043")`, 832 ` xAnISBN13Default = strfmt.ISBN13("978 3401013190")`, 833 ` xAnIPV4Default = strfmt.IPv4("192.168.224.1")`, 834 ` xAnIPV6Default = strfmt.IPv6("::1")`, 835 ` if err := xaBsonObjectIDDefault.UnmarshalText([]byte("507f1f77bcf86cd799439011")); err != nil {`, 836 ` msg := fmt.Sprintf("invalid default value for xaBsonObjectID: %v", err)`, 837 ` if err := xaByteDefault.UnmarshalText([]byte("ZWxpemFiZXRocG9zZXk=")); err != nil {`, 838 ` msg := fmt.Sprintf("invalid default value for xaByte: %v", err)`, 839 ` if err := xaDateDefault.UnmarshalText([]byte("1970-01-01")); err != nil {`, 840 ` msg := fmt.Sprintf("invalid default value for xaDate: %v", err)`, 841 ` if err := xaDateTimeDefault.UnmarshalText([]byte("1970-01-01T11:01:05.283185Z")); err != nil {`, 842 ` msg := fmt.Sprintf("invalid default value for xaDateTime: %v", err)`, 843 ` if err := xaDurationDefault.UnmarshalText([]byte("1 ms")); err != nil {`, 844 ` msg := fmt.Sprintf("invalid default value for xaDuration: %v", err)`, 845 ` return &GetOptionalOK{`, 846 ` XaBool: xaBoolDefault,`, 847 ` XaBsonObjectID: xaBsonObjectIDDefault,`, 848 ` XaByte: xaByteDefault,`, 849 ` XaCreditCard: xaCreditCardDefault,`, 850 ` XaDate: xaDateDefault,`, 851 ` XaDateTime: xaDateTimeDefault,`, 852 ` XaDouble: xaDoubleDefault,`, 853 ` XaDuration: xaDurationDefault,`, 854 ` XaFloat: xaFloatDefault,`, 855 ` XaHexColor: xaHexColorDefault,`, 856 ` XaHostname: xaHostnameDefault,`, 857 ` XaInt32: xaInt32Default,`, 858 ` XaInt64: xaInt64Default,`, 859 ` XaMac: xaMacDefault,`, 860 ` XaPassword: xaPasswordDefault,`, 861 ` XaRGBColor: xaRGBColorDefault,`, 862 ` XaSsn: xaSsnDefault,`, 863 ` XaUUID: xaUUIDDefault,`, 864 ` XaUUID3: xaUUID3Default,`, 865 ` XaUUID4: xaUUID4Default,`, 866 ` XaUUID5: xaUUID5Default,`, 867 ` XaUint32: xaUint32Default,`, 868 ` XaUint64: xaUint64Default,`, 869 ` XaURI: xaURIDefault,`, 870 ` XAnEmail: xAnEmailDefault,`, 871 ` XAnISBN: xAnISBNDefault,`, 872 ` XAnISBN10: xAnISBN10Default,`, 873 ` XAnISBN13: xAnISBN13Default,`, 874 ` XAnIPV4: xAnIPV4Default,`, 875 ` XAnIPV6: xAnIPV6Default,`, 876 `func (o *GetOptionalOK) readResponse(response runtime.ClientResponse, consumer runtime.Consumer, formats strfmt.Registry) error {`, 877 ` hdrXaBool := response.GetHeader("X-aBool")`, 878 ` if hdrXaBool != "" {`, 879 ` valxABool, err := swag.ConvertBool(hdrXaBool)`, 880 ` if err != nil {`, 881 ` return errors.InvalidType("X-aBool", "header", "bool", hdrXaBool)`, 882 ` o.XaBool = valxABool`, 883 ` hdrXaBsonObjectID := response.GetHeader("X-aBsonObjectId")`, 884 ` if hdrXaBsonObjectID != "" {`, 885 ` valxABsonObjectId, err := formats.Parse("bsonobjectid", hdrXaBsonObjectID)`, 886 ` if err != nil {`, 887 ` return errors.InvalidType("X-aBsonObjectId", "header", "strfmt.ObjectId", hdrXaBsonObjectID)`, 888 ` o.XaBsonObjectID = *(valxABsonObjectId.(*strfmt.ObjectId))`, 889 ` hdrXaByte := response.GetHeader("X-aByte")`, 890 ` if hdrXaByte != "" {`, 891 ` valxAByte, err := formats.Parse("byte", hdrXaByte)`, 892 ` if err != nil {`, 893 ` return errors.InvalidType("X-aByte", "header", "strfmt.Base64", hdrXaByte)`, 894 ` o.XaByte = *(valxAByte.(*strfmt.Base64))`, 895 ` hdrXaCreditCard := response.GetHeader("X-aCreditCard")`, 896 ` if hdrXaCreditCard != "" {`, 897 ` valxACreditCard, err := formats.Parse("creditcard", hdrXaCreditCard)`, 898 ` if err != nil {`, 899 ` return errors.InvalidType("X-aCreditCard", "header", "strfmt.CreditCard", hdrXaCreditCard)`, 900 ` o.XaCreditCard = *(valxACreditCard.(*strfmt.CreditCard))`, 901 ` hdrXaDate := response.GetHeader("X-aDate")`, 902 ` if hdrXaDate != "" {`, 903 ` valxADate, err := formats.Parse("date", hdrXaDate)`, 904 ` if err != nil {`, 905 ` return errors.InvalidType("X-aDate", "header", "strfmt.Date", hdrXaDate)`, 906 ` o.XaDate = *(valxADate.(*strfmt.Date))`, 907 ` hdrXaDateTime := response.GetHeader("X-aDateTime")`, 908 ` if hdrXaDateTime != "" {`, 909 ` valxADateTime, err := formats.Parse("date-time", hdrXaDateTime)`, 910 ` if err != nil {`, 911 ` return errors.InvalidType("X-aDateTime", "header", "strfmt.DateTime", hdrXaDateTime)`, 912 ` o.XaDateTime = *(valxADateTime.(*strfmt.DateTime))`, 913 ` hdrXaDouble := response.GetHeader("X-aDouble")`, 914 ` if hdrXaDouble != "" {`, 915 ` valxADouble, err := swag.ConvertFloat64(hdrXaDouble)`, 916 ` if err != nil {`, 917 ` return errors.InvalidType("X-aDouble", "header", "float64", hdrXaDouble)`, 918 ` o.XaDouble = valxADouble`, 919 ` hdrXaDuration := response.GetHeader("X-aDuration")`, 920 ` if hdrXaDuration != "" {`, 921 ` valxADuration, err := formats.Parse("duration", hdrXaDuration)`, 922 ` if err != nil {`, 923 ` return errors.InvalidType("X-aDuration", "header", "strfmt.Duration", hdrXaDuration)`, 924 ` o.XaDuration = *(valxADuration.(*strfmt.Duration))`, 925 ` hdrXaFloat := response.GetHeader("X-aFloat")`, 926 ` if hdrXaFloat != "" {`, 927 ` valxAFloat, err := swag.ConvertFloat32(hdrXaFloat)`, 928 ` if err != nil {`, 929 ` return errors.InvalidType("X-aFloat", "header", "float32", hdrXaFloat)`, 930 ` o.XaFloat = valxAFloat`, 931 ` hdrXaHexColor := response.GetHeader("X-aHexColor")`, 932 ` if hdrXaHexColor != "" {`, 933 ` valxAHexColor, err := formats.Parse("hexcolor", hdrXaHexColor)`, 934 ` if err != nil {`, 935 ` return errors.InvalidType("X-aHexColor", "header", "strfmt.HexColor", hdrXaHexColor)`, 936 ` o.XaHexColor = *(valxAHexColor.(*strfmt.HexColor))`, 937 ` hdrXaHostname := response.GetHeader("X-aHostname")`, 938 ` if hdrXaHostname != "" {`, 939 ` valxAHostname, err := formats.Parse("hostname", hdrXaHostname)`, 940 ` if err != nil {`, 941 ` return errors.InvalidType("X-aHostname", "header", "strfmt.Hostname", hdrXaHostname)`, 942 ` o.XaHostname = *(valxAHostname.(*strfmt.Hostname))`, 943 ` hdrXaInt32 := response.GetHeader("X-aInt32")`, 944 ` if hdrXaInt32 != "" {`, 945 ` valxAInt32, err := swag.ConvertInt32(hdrXaInt32)`, 946 ` if err != nil {`, 947 ` return errors.InvalidType("X-aInt32", "header", "int32", hdrXaInt32)`, 948 ` o.XaInt32 = valxAInt32`, 949 ` hdrXaInt64 := response.GetHeader("X-aInt64")`, 950 ` if hdrXaInt64 != "" {`, 951 ` valxAInt64, err := swag.ConvertInt64(hdrXaInt64)`, 952 ` if err != nil {`, 953 ` return errors.InvalidType("X-aInt64", "header", "int64", hdrXaInt64)`, 954 ` o.XaInt64 = valxAInt64`, 955 ` hdrXaMac := response.GetHeader("X-aMac")`, 956 ` if hdrXaMac != "" {`, 957 ` valxAMac, err := formats.Parse("mac", hdrXaMac)`, 958 ` if err != nil {`, 959 ` return errors.InvalidType("X-aMac", "header", "strfmt.MAC", hdrXaMac)`, 960 ` o.XaMac = *(valxAMac.(*strfmt.MAC))`, 961 ` hdrXaPassword := response.GetHeader("X-aPassword")`, 962 ` if hdrXaPassword != "" {`, 963 ` valxAPassword, err := formats.Parse("password", hdrXaPassword)`, 964 ` if err != nil {`, 965 ` return errors.InvalidType("X-aPassword", "header", "strfmt.Password", hdrXaPassword)`, 966 ` o.XaPassword = *(valxAPassword.(*strfmt.Password))`, 967 ` hdrXaRGBColor := response.GetHeader("X-aRGBColor")`, 968 ` if hdrXaRGBColor != "" {`, 969 ` valxARGBColor, err := formats.Parse("rgbcolor", hdrXaRGBColor)`, 970 ` if err != nil {`, 971 ` return errors.InvalidType("X-aRGBColor", "header", "strfmt.RGBColor", hdrXaRGBColor)`, 972 ` o.XaRGBColor = *(valxARGBColor.(*strfmt.RGBColor))`, 973 ` hdrXaSsn := response.GetHeader("X-aSsn")`, 974 ` if hdrXaSsn != "" {`, 975 ` valxASsn, err := formats.Parse("ssn", hdrXaSsn)`, 976 ` if err != nil {`, 977 ` return errors.InvalidType("X-aSsn", "header", "strfmt.SSN", hdrXaSsn)`, 978 ` o.XaSsn = *(valxASsn.(*strfmt.SSN))`, 979 ` hdrXaUUID := response.GetHeader("X-aUUID")`, 980 ` if hdrXaUUID != "" {`, 981 ` valxAUuid, err := formats.Parse("uuid", hdrXaUUID)`, 982 ` if err != nil {`, 983 ` return errors.InvalidType("X-aUUID", "header", "strfmt.UUID", hdrXaUUID)`, 984 ` o.XaUUID = *(valxAUuid.(*strfmt.UUID))`, 985 ` hdrXaUUID3 := response.GetHeader("X-aUUID3")`, 986 ` if hdrXaUUID3 != "" {`, 987 ` valxAUuid3, err := formats.Parse("uuid3", hdrXaUUID3)`, 988 ` if err != nil {`, 989 ` return errors.InvalidType("X-aUUID3", "header", "strfmt.UUID3", hdrXaUUID3)`, 990 ` o.XaUUID3 = *(valxAUuid3.(*strfmt.UUID3))`, 991 ` hdrXaUUID4 := response.GetHeader("X-aUUID4")`, 992 ` if hdrXaUUID4 != "" {`, 993 ` valxAUuid4, err := formats.Parse("uuid4", hdrXaUUID4)`, 994 ` if err != nil {`, 995 ` return errors.InvalidType("X-aUUID4", "header", "strfmt.UUID4", hdrXaUUID4)`, 996 ` o.XaUUID4 = *(valxAUuid4.(*strfmt.UUID4))`, 997 ` hdrXaUUID5 := response.GetHeader("X-aUUID5")`, 998 ` if hdrXaUUID5 != "" {`, 999 ` valxAUuid5, err := formats.Parse("uuid5", hdrXaUUID5)`, 1000 ` if err != nil {`, 1001 ` return errors.InvalidType("X-aUUID5", "header", "strfmt.UUID5", hdrXaUUID5)`, 1002 ` o.XaUUID5 = *(valxAUuid5.(*strfmt.UUID5))`, 1003 ` hdrXaUint32 := response.GetHeader("X-aUint32")`, 1004 ` if hdrXaUint32 != "" {`, 1005 ` valxAUint32, err := swag.ConvertUint32(hdrXaUint32)`, 1006 ` if err != nil {`, 1007 ` return errors.InvalidType("X-aUint32", "header", "uint32", hdrXaUint32)`, 1008 ` o.XaUint32 = valxAUint32`, 1009 ` hdrXaUint64 := response.GetHeader("X-aUint64")`, 1010 ` if hdrXaUint64 != "" {`, 1011 ` valxAUint64, err := swag.ConvertUint64(hdrXaUint64)`, 1012 ` if err != nil {`, 1013 ` return errors.InvalidType("X-aUint64", "header", "uint64", hdrXaUint64)`, 1014 ` o.XaUint64 = valxAUint64`, 1015 ` hdrXaURI := response.GetHeader("X-aUri")`, 1016 ` if hdrXaURI != "" {`, 1017 ` valxAUri, err := formats.Parse("uri", hdrXaURI)`, 1018 ` if err != nil {`, 1019 ` return errors.InvalidType("X-aUri", "header", "strfmt.URI", hdrXaURI)`, 1020 ` o.XaURI = *(valxAUri.(*strfmt.URI))`, 1021 ` hdrXAnEmail := response.GetHeader("X-anEmail")`, 1022 ` if hdrXAnEmail != "" {`, 1023 ` valxAnEmail, err := formats.Parse("email", hdrXAnEmail)`, 1024 ` if err != nil {`, 1025 ` return errors.InvalidType("X-anEmail", "header", "strfmt.Email", hdrXAnEmail)`, 1026 ` o.XAnEmail = *(valxAnEmail.(*strfmt.Email))`, 1027 ` hdrXAnISBN := response.GetHeader("X-anISBN")`, 1028 ` if hdrXAnISBN != "" {`, 1029 ` valxAnISBN, err := formats.Parse("isbn", hdrXAnISBN)`, 1030 ` if err != nil {`, 1031 ` return errors.InvalidType("X-anISBN", "header", "strfmt.ISBN", hdrXAnISBN)`, 1032 ` o.XAnISBN = *(valxAnISBN.(*strfmt.ISBN))`, 1033 ` hdrXAnISBN10 := response.GetHeader("X-anISBN10")`, 1034 ` if hdrXAnISBN10 != "" {`, 1035 ` valxAnISBN10, err := formats.Parse("isbn10", hdrXAnISBN10)`, 1036 ` if err != nil {`, 1037 ` return errors.InvalidType("X-anISBN10", "header", "strfmt.ISBN10", hdrXAnISBN10)`, 1038 ` o.XAnISBN10 = *(valxAnISBN10.(*strfmt.ISBN10))`, 1039 ` hdrXAnISBN13 := response.GetHeader("X-anISBN13")`, 1040 ` if hdrXAnISBN13 != "" {`, 1041 ` valxAnISBN13, err := formats.Parse("isbn13", hdrXAnISBN13)`, 1042 ` if err != nil {`, 1043 ` return errors.InvalidType("X-anISBN13", "header", "strfmt.ISBN13", hdrXAnISBN13)`, 1044 ` o.XAnISBN13 = *(valxAnISBN13.(*strfmt.ISBN13))`, 1045 ` hdrXAnIPV4 := response.GetHeader("X-anIpv4")`, 1046 ` if hdrXAnIPV4 != "" {`, 1047 ` valxAnIpv4, err := formats.Parse("ipv4", hdrXAnIPV4)`, 1048 ` if err != nil {`, 1049 ` return errors.InvalidType("X-anIpv4", "header", "strfmt.IPv4", hdrXAnIPV4)`, 1050 ` o.XAnIPV4 = *(valxAnIpv4.(*strfmt.IPv4))`, 1051 ` hdrXAnIPV6 := response.GetHeader("X-anIpv6")`, 1052 ` if hdrXAnIPV6 != "" {`, 1053 ` valxAnIpv6, err := formats.Parse("ipv6", hdrXAnIPV6)`, 1054 ` if err != nil {`, 1055 ` return errors.InvalidType("X-anIpv6", "header", "strfmt.IPv6", hdrXAnIPV6)`, 1056 ` o.XAnIPV6 = *(valxAnIpv6.(*strfmt.IPv6))`, 1057 }, 1058 } 1059 1060 for fileToInspect, expectedCode := range fixtureConfig { 1061 code, err := os.ReadFile(filepath.Join(opts.Target, filepath.FromSlash(fileToInspect))) 1062 require.NoError(t, err) 1063 1064 for line, codeLine := range expectedCode { 1065 if !assertInCode(t, strings.TrimSpace(codeLine), string(code)) { 1066 t.Logf("Code expected did not match in codegenfile %s for expected line %d: %q", fileToInspect, line, expectedCode[line]) 1067 } 1068 } 1069 } 1070 }