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