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