github.com/ryanbennettvoid/go-swagger@v0.18.1-0.20190104015444-3854bbbe2392/generator/response_test.go (about) 1 // Copyright 2015 go-swagger maintainers 2 // 3 // Licensed under the Apache License, Version 2.0 (the "License"); 4 // you may not use this file except in compliance with the License. 5 // You may obtain a copy of the License at 6 // 7 // http://www.apache.org/licenses/LICENSE-2.0 8 // 9 // Unless required by applicable law or agreed to in writing, software 10 // distributed under the License is distributed on an "AS IS" BASIS, 11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 // See the License for the specific language governing permissions and 13 // limitations under the License. 14 15 package generator 16 17 import ( 18 "bytes" 19 "fmt" 20 "io/ioutil" 21 "log" 22 "os" 23 "path/filepath" 24 "testing" 25 26 "github.com/go-openapi/spec" 27 "github.com/stretchr/testify/assert" 28 ) 29 30 func TestSimpleResponseRender(t *testing.T) { 31 b, err := opBuilder("updateTask", "../fixtures/codegen/todolist.responses.yml") 32 if assert.NoError(t, err) { 33 op, err := b.MakeOperation() 34 if assert.NoError(t, err) { 35 var buf bytes.Buffer 36 opts := opts() 37 if assert.NoError(t, templates.MustGet("serverResponses").Execute(&buf, op)) { 38 ff, err := opts.LanguageOpts.FormatContent("update_task_responses.go", buf.Bytes()) 39 if assert.NoError(t, err) { 40 assertInCode(t, "o.XErrorCode", string(ff)) 41 assertInCode(t, "o.Payload", string(ff)) 42 } else { 43 fmt.Println(buf.String()) 44 } 45 } 46 } 47 } 48 } 49 50 func TestDefaultResponseRender(t *testing.T) { 51 b, err := opBuilder("getAllParameters", "../fixtures/codegen/todolist.responses.yml") 52 if assert.NoError(t, err) { 53 op, err := b.MakeOperation() 54 if assert.NoError(t, err) { 55 var buf bytes.Buffer 56 opts := opts() 57 if assert.NoError(t, templates.MustGet("clientResponse").Execute(&buf, op)) { 58 ff, err := opts.LanguageOpts.FormatContent("get_all_parameters_responses.go", buf.Bytes()) 59 if assert.NoError(t, err) { 60 res := string(ff) 61 assertInCode(t, "type GetAllParametersDefault struct", res) 62 assertInCode(t, `if response.Code()/100 == 2`, res) 63 assertNotInCode(t, `switch response.Code()`, res) 64 assertNotInCode(t, "o.Payload", res) 65 } else { 66 fmt.Println(buf.String()) 67 } 68 } 69 } 70 } 71 } 72 73 func TestSimpleResponses(t *testing.T) { 74 b, err := opBuilder("updateTask", "../fixtures/codegen/todolist.responses.yml") 75 76 if !assert.NoError(t, err) { 77 t.FailNow() 78 } 79 80 _, _, op, ok := b.Analyzed.OperationForName("updateTask") 81 if assert.True(t, ok) && assert.NotNil(t, op) && assert.NotNil(t, op.Responses) { 82 resolver := &typeResolver{ModelsPackage: b.ModelsPackage, Doc: b.Doc} 83 if assert.NotNil(t, op.Responses.Default) { 84 resp, err := spec.ResolveResponse(b.Doc.Spec(), op.Responses.Default.Ref) 85 if assert.NoError(t, err) { 86 defCtx := responseTestContext{ 87 OpID: "updateTask", 88 Name: "default", 89 } 90 res, err := b.MakeResponse("a", defCtx.Name, false, resolver, -1, *resp) 91 if assert.NoError(t, err) { 92 if defCtx.Assert(t, *resp, res) { 93 for code, response := range op.Responses.StatusCodeResponses { 94 sucCtx := responseTestContext{ 95 OpID: "updateTask", 96 Name: "success", 97 IsSuccess: code/100 == 2, 98 } 99 res, err := b.MakeResponse("a", sucCtx.Name, sucCtx.IsSuccess, resolver, code, response) 100 if assert.NoError(t, err) { 101 if !sucCtx.Assert(t, response, res) { 102 return 103 } 104 } 105 } 106 } 107 } 108 } 109 } 110 } 111 112 } 113 func TestInlinedSchemaResponses(t *testing.T) { 114 b, err := opBuilder("getTasks", "../fixtures/codegen/todolist.responses.yml") 115 116 if !assert.NoError(t, err) { 117 t.FailNow() 118 } 119 120 _, _, op, ok := b.Analyzed.OperationForName("getTasks") 121 if assert.True(t, ok) && assert.NotNil(t, op) && assert.NotNil(t, op.Responses) { 122 resolver := &typeResolver{ModelsPackage: b.ModelsPackage, Doc: b.Doc} 123 if assert.NotNil(t, op.Responses.Default) { 124 resp := *op.Responses.Default 125 defCtx := responseTestContext{ 126 OpID: "getTasks", 127 Name: "default", 128 } 129 res, err := b.MakeResponse("a", defCtx.Name, false, resolver, -1, resp) 130 if assert.NoError(t, err) { 131 if defCtx.Assert(t, resp, res) { 132 for code, response := range op.Responses.StatusCodeResponses { 133 sucCtx := responseTestContext{ 134 OpID: "getTasks", 135 Name: "success", 136 IsSuccess: code/100 == 2, 137 } 138 res, err := b.MakeResponse("a", sucCtx.Name, sucCtx.IsSuccess, resolver, code, response) 139 if assert.NoError(t, err) { 140 if !sucCtx.Assert(t, response, res) { 141 return 142 } 143 } 144 assert.Len(t, b.ExtraSchemas, 1) 145 // ExtraSchema is not a definition: it is rendered in current operations package 146 assert.Equal(t, "[]*SuccessBodyItems0", res.Schema.GoType) 147 } 148 } 149 } 150 } 151 } 152 153 } 154 155 type responseTestContext struct { 156 OpID string 157 Name string 158 IsSuccess bool 159 } 160 161 func (ctx *responseTestContext) Assert(t testing.TB, response spec.Response, res GenResponse) bool { 162 if !assert.Equal(t, ctx.IsSuccess, res.IsSuccess) { 163 return false 164 } 165 166 if !assert.Equal(t, ctx.Name, res.Name) { 167 return false 168 } 169 170 if !assert.Equal(t, response.Description, res.Description) { 171 return false 172 } 173 174 if len(response.Headers) > 0 { 175 for k, v := range response.Headers { 176 found := false 177 for _, h := range res.Headers { 178 if h.Name == k { 179 found = true 180 if k == "X-Last-Task-Id" { 181 hctx := &respHeaderTestContext{k, "swag.FormatInt64", "swag.ConvertInt64"} 182 if !hctx.Assert(t, v, h) { 183 return false 184 } 185 break 186 } 187 if k == "X-Error-Code" { 188 hctx := &respHeaderTestContext{k, "", ""} 189 if !hctx.Assert(t, v, h) { 190 return false 191 } 192 } 193 194 break 195 } 196 } 197 if !assert.True(t, found) { 198 return false 199 } 200 } 201 } 202 203 if response.Schema != nil { 204 if !assert.NotNil(t, res.Schema) { 205 return false 206 } 207 } else { 208 if !assert.Nil(t, res.Schema) { 209 return false 210 } 211 } 212 213 return true 214 } 215 216 type respHeaderTestContext struct { 217 Name string 218 Formatter string 219 Converter string 220 } 221 222 func (ctx *respHeaderTestContext) Assert(t testing.TB, header spec.Header, hdr GenHeader) bool { 223 if !assert.Equal(t, ctx.Name, hdr.Name) { 224 return false 225 } 226 if !assert.Equal(t, "a", hdr.ReceiverName) { 227 return false 228 } 229 if !assert.Equal(t, ctx.Formatter, hdr.Formatter) { 230 return false 231 } 232 if !assert.Equal(t, ctx.Converter, hdr.Converter) { 233 return false 234 } 235 if !assert.Equal(t, header.Description, hdr.Description) { 236 return false 237 } 238 if !assert.Equal(t, header.Minimum, hdr.Minimum) || !assert.Equal(t, header.ExclusiveMinimum, hdr.ExclusiveMinimum) { 239 return false 240 } 241 if !assert.Equal(t, header.Maximum, hdr.Maximum) || !assert.Equal(t, header.ExclusiveMaximum, hdr.ExclusiveMaximum) { 242 return false 243 } 244 if !assert.Equal(t, header.MinLength, hdr.MinLength) { 245 return false 246 } 247 if !assert.Equal(t, header.MaxLength, hdr.MaxLength) { 248 return false 249 } 250 if !assert.Equal(t, header.Pattern, hdr.Pattern) { 251 return false 252 } 253 if !assert.Equal(t, header.MaxItems, hdr.MaxItems) { 254 return false 255 } 256 if !assert.Equal(t, header.MinItems, hdr.MinItems) { 257 return false 258 } 259 if !assert.Equal(t, header.UniqueItems, hdr.UniqueItems) { 260 return false 261 } 262 if !assert.Equal(t, header.MultipleOf, hdr.MultipleOf) { 263 return false 264 } 265 if !assert.EqualValues(t, header.Enum, hdr.Enum) { 266 return false 267 } 268 if !assert.Equal(t, header.Type, hdr.SwaggerType) { 269 return false 270 } 271 if !assert.Equal(t, header.Format, hdr.SwaggerFormat) { 272 return false 273 } 274 return true 275 } 276 277 func TestGenResponses_Issue540(t *testing.T) { 278 b, err := opBuilder("postPet", "../fixtures/bugs/540/swagger.yml") 279 if assert.NoError(t, err) { 280 op, err := b.MakeOperation() 281 if assert.NoError(t, err) { 282 var buf bytes.Buffer 283 opts := opts() 284 if assert.NoError(t, templates.MustGet("serverResponses").Execute(&buf, op)) { 285 ff, err := opts.LanguageOpts.FormatContent("post_pet_responses.go", buf.Bytes()) 286 if assert.NoError(t, err) { 287 assertInCode(t, "func (o *PostPetOK) WithPayload(payload models.Pet) *PostPetOK {", string(ff)) 288 assertInCode(t, "func (o *PostPetOK) SetPayload(payload models.Pet) {", string(ff)) 289 } else { 290 fmt.Println(buf.String()) 291 } 292 } 293 } 294 } 295 } 296 297 func TestGenResponses_Issue718_NotRequired(t *testing.T) { 298 b, err := opBuilder("doEmpty", "../fixtures/codegen/todolist.simple.yml") 299 if assert.NoError(t, err) { 300 op, err := b.MakeOperation() 301 if assert.NoError(t, err) { 302 var buf bytes.Buffer 303 opts := opts() 304 if assert.NoError(t, templates.MustGet("serverResponses").Execute(&buf, op)) { 305 ff, err := opts.LanguageOpts.FormatContent("do_empty_responses.go", buf.Bytes()) 306 if assert.NoError(t, err) { 307 assertInCode(t, "if payload == nil", string(ff)) 308 assertInCode(t, "payload = make([]models.Foo, 0, 50)", string(ff)) 309 } else { 310 fmt.Println(buf.String()) 311 } 312 } 313 } 314 } 315 } 316 317 func TestGenResponses_Issue718_Required(t *testing.T) { 318 b, err := opBuilder("doEmpty", "../fixtures/codegen/todolist.simple.yml") 319 if assert.NoError(t, err) { 320 op, err := b.MakeOperation() 321 if assert.NoError(t, err) { 322 var buf bytes.Buffer 323 opts := opts() 324 if assert.NoError(t, templates.MustGet("serverResponses").Execute(&buf, op)) { 325 ff, err := opts.LanguageOpts.FormatContent("do_empty_responses.go", buf.Bytes()) 326 if assert.NoError(t, err) { 327 assertInCode(t, "if payload == nil", string(ff)) 328 assertInCode(t, "payload = make([]models.Foo, 0, 50)", string(ff)) 329 } else { 330 fmt.Println(buf.String()) 331 } 332 } 333 } 334 } 335 } 336 337 // Issue776 includes references that span multiple files. Flattening or Expanding is required 338 func TestGenResponses_Issue776_Spec(t *testing.T) { 339 //spec.Debug = true 340 log.SetOutput(ioutil.Discard) 341 defer func() { 342 log.SetOutput(os.Stdout) 343 //spec.Debug = false 344 }() 345 346 b, err := opBuilderWithFlatten("GetItem", "../fixtures/bugs/776/spec.yaml") 347 if assert.NoError(t, err) { 348 op, err := b.MakeOperation() 349 if assert.NoError(t, err) { 350 var buf bytes.Buffer 351 opts := opts() 352 if assert.NoError(t, templates.MustGet("serverResponses").Execute(&buf, op)) { 353 ff, err := opts.LanguageOpts.FormatContent("do_empty_responses.go", buf.Bytes()) 354 if assert.NoError(t, err) { 355 // This should be models.Item if flat works correctly 356 assertInCode(t, "Payload *models.Item", string(ff)) 357 assertNotInCode(t, "type GetItemOKBody struct", string(ff)) 358 } else { 359 fmt.Println(buf.String()) 360 } 361 } 362 } 363 } 364 } 365 366 func TestGenResponses_Issue776_SwaggerTemplate(t *testing.T) { 367 //spec.Debug = true 368 log.SetOutput(ioutil.Discard) 369 defer func() { 370 log.SetOutput(os.Stdout) 371 //spec.Debug = false 372 }() 373 374 b, err := opBuilderWithFlatten("getHealthy", "../fixtures/bugs/776/swagger-template.yml") 375 if assert.NoError(t, err) { 376 op, err := b.MakeOperation() 377 if assert.NoError(t, err) { 378 var buf bytes.Buffer 379 opts := opts() 380 if assert.NoError(t, templates.MustGet("serverResponses").Execute(&buf, op)) { 381 ff, err := opts.LanguageOpts.FormatContent("do_empty_responses.go", buf.Bytes()) 382 if assert.NoError(t, err) { 383 assertInCode(t, "Payload *models.Error", string(ff)) 384 } else { 385 fmt.Println(buf.String()) 386 } 387 } 388 } 389 } 390 } 391 392 func TestIssue846(t *testing.T) { 393 // do it 8 times, to ensure it's always in the same order 394 for i := 0; i < 8; i++ { 395 b, err := opBuilder("getFoo", "../fixtures/bugs/846/swagger.yml") 396 if assert.NoError(t, err) { 397 op, err := b.MakeOperation() 398 if assert.NoError(t, err) { 399 var buf bytes.Buffer 400 opts := opts() 401 if assert.NoError(t, templates.MustGet("clientResponse").Execute(&buf, op)) { 402 ff, err := opts.LanguageOpts.FormatContent("do_empty_responses.go", buf.Bytes()) 403 if assert.NoError(t, err) { 404 // sorted by code 405 assert.Regexp(t, "(?s)"+ 406 "GetFooOK struct.+"+ 407 "GetFooNotFound struct.+"+ 408 "GetFooInternalServerError struct", string(ff)) 409 // sorted by name 410 assert.Regexp(t, "(?s)"+ 411 "GetFooInternalServerErrorBody struct.+"+ 412 "GetFooNotFoundBody struct.+"+ 413 "GetFooOKBody struct", string(ff)) 414 } else { 415 fmt.Println(buf.String()) 416 } 417 } 418 } 419 } 420 } 421 } 422 423 func TestIssue881(t *testing.T) { 424 b, err := opBuilder("getFoo", "../fixtures/bugs/881/swagger.yml") 425 if assert.NoError(t, err) { 426 op, err := b.MakeOperation() 427 if assert.NoError(t, err) { 428 var buf bytes.Buffer 429 assert.NoError(t, templates.MustGet("serverResponses").Execute(&buf, op)) 430 } 431 } 432 } 433 434 func TestIssue881Deep(t *testing.T) { 435 b, err := opBuilder("getFoo", "../fixtures/bugs/881/deep.yml") 436 if assert.NoError(t, err) { 437 op, err := b.MakeOperation() 438 if assert.NoError(t, err) { 439 var buf bytes.Buffer 440 assert.NoError(t, templates.MustGet("serverResponses").Execute(&buf, op)) 441 } 442 } 443 } 444 445 func TestGenResponses_XGoName(t *testing.T) { 446 b, err := opBuilder("putTesting", "../fixtures/specs/response_name.json") 447 if assert.NoError(t, err) { 448 op, err := b.MakeOperation() 449 if assert.NoError(t, err) { 450 var buf bytes.Buffer 451 opts := opts() 452 if assert.NoError(t, templates.MustGet("serverResponses").Execute(&buf, op)) { 453 ff, err := opts.LanguageOpts.FormatContent("put_testing_responses.go", buf.Bytes()) 454 if assert.NoError(t, err) { 455 assertInCode(t, "const PutTestingAlternateNameCode int =", string(ff)) 456 assertInCode(t, "type PutTestingAlternateName struct {", string(ff)) 457 assertInCode(t, "func NewPutTestingAlternateName() *PutTestingAlternateName {", string(ff)) 458 assertInCode(t, "func (o *PutTestingAlternateName) WriteResponse(rw http.ResponseWriter, producer runtime.Producer) {", string(ff)) 459 } else { 460 fmt.Println(buf.String()) 461 } 462 } 463 } 464 } 465 } 466 467 func TestGenResponses_Issue892(t *testing.T) { 468 b, err := methodPathOpBuilder("get", "/media/search", "../fixtures/bugs/982/swagger.yaml") 469 if assert.NoError(t, err) { 470 op, err := b.MakeOperation() 471 if assert.NoError(t, err) { 472 var buf bytes.Buffer 473 opts := opts() 474 if assert.NoError(t, templates.MustGet("clientResponse").Execute(&buf, op)) { 475 ff, err := opts.LanguageOpts.FormatContent("get_media_search_responses.go", buf.Bytes()) 476 if assert.NoError(t, err) { 477 assertInCode(t, "o.Media = aO0", string(ff)) 478 } else { 479 fmt.Println(buf.String()) 480 } 481 } 482 } 483 } 484 } 485 486 func TestGenResponses_Issue1013(t *testing.T) { 487 b, erp := methodPathOpBuilder("get", "/test", "../fixtures/bugs/1013/fixture-1013.yaml") 488 if assert.NoError(t, erp) { 489 op, erm := b.MakeOperation() 490 if assert.NoError(t, erm) { 491 var buf bytes.Buffer 492 opts := opts() 493 if assert.NoError(t, templates.MustGet("serverResponses").Execute(&buf, op)) { 494 ff, err := opts.LanguageOpts.FormatContent("foo.go", buf.Bytes()) 495 if assert.NoError(t, err) { 496 assertInCode(t, "Payload *models.Response `json:\"body,omitempty\"`", string(ff)) 497 } else { 498 fmt.Println(buf.String()) 499 } 500 } 501 } 502 } 503 b, erp = methodPathOpBuilder("get", "/test2", "../fixtures/bugs/1013/fixture-1013.yaml") 504 if assert.NoError(t, erp) { 505 op, erm := b.MakeOperation() 506 if assert.NoError(t, erm) { 507 var buf bytes.Buffer 508 opts := opts() 509 if assert.NoError(t, templates.MustGet("serverResponses").Execute(&buf, op)) { 510 ff, err := opts.LanguageOpts.FormatContent("foo.go", buf.Bytes()) 511 if assert.NoError(t, err) { 512 assertInCode(t, "Payload *models.Response `json:\"body,omitempty\"`", string(ff)) 513 } else { 514 fmt.Println(buf.String()) 515 } 516 } 517 } 518 } 519 } 520 521 func TestGenResponse_15362_WithExpand(t *testing.T) { 522 log.SetOutput(ioutil.Discard) 523 defer func() { 524 log.SetOutput(os.Stdout) 525 }() 526 527 fixtureConfig := map[string]map[string][]string{ 528 // load expectations for parameters in operation get_nested_required_responses.go 529 "getNestedRequired": { // fixture index 530 "serverResponses": { // executed template 531 // expected code lines 532 `const GetNestedRequiredOKCode int = 200`, 533 `type GetNestedRequiredOK struct {`, 534 " Payload [][][][]*GetNestedRequiredOKBodyItems0 `json:\"body,omitempty\"`", 535 `func NewGetNestedRequiredOK() *GetNestedRequiredOK {`, 536 ` return &GetNestedRequiredOK{`, 537 `func (o *GetNestedRequiredOK) WithPayload(payload [][][][]*GetNestedRequiredOKBodyItems0) *GetNestedRequiredOK {`, 538 `func (o *GetNestedRequiredOK) SetPayload(payload [][][][]*GetNestedRequiredOKBodyItems0) {`, 539 `func (o *GetNestedRequiredOK) WriteResponse(rw http.ResponseWriter, producer runtime.Producer) {`, 540 }, 541 "serverOperation": { // executed template 542 // expected code lines 543 `type GetNestedRequiredOKBodyItems0 struct {`, 544 " Pkcs *string `json:\"pkcs\"`", 545 `func (o *GetNestedRequiredOKBodyItems0) Validate(formats strfmt.Registry) error {`, 546 ` if err := o.validatePkcs(formats); err != nil {`, 547 ` return errors.CompositeValidationError(res...`, 548 `func (o *GetNestedRequiredOKBodyItems0) validatePkcs(formats strfmt.Registry) error {`, 549 ` if err := validate.Required("pkcs", "body", o.Pkcs); err != nil {`, 550 }, 551 }, 552 } 553 554 // assertParams also works for responses 555 assertParams(t, fixtureConfig, filepath.Join("..", "fixtures", "bugs", "1536", "fixture-1536-2-responses.yaml"), true, false) 556 } 557 558 func TestGenResponse_1572(t *testing.T) { 559 log.SetOutput(ioutil.Discard) 560 defer func() { 561 log.SetOutput(os.Stdout) 562 }() 563 564 // testing fixture-1572.yaml with minimal flatten 565 // edge cases for operations schemas 566 567 /* 568 Run the following test caes and exercise the minimal flatten mode: 569 - [x] nil schema in body param / response 570 - [x] interface{} in body param /response 571 - [x] additional schema reused from model (body param and response) (with maps or arrays) 572 - [x] primitive body / response 573 - [x] $ref'ed response and param (check that minimal flatten expands it) 574 575 */ 576 577 fixtureConfig := map[string]map[string][]string{ 578 579 // load expectations for responses in operation get_interface_responses.go 580 "getInterface": { // fixture index 581 "serverResponses": { // executed template 582 // expected code lines 583 `const GetInterfaceOKCode int = 200`, 584 `type GetInterfaceOK struct {`, 585 " Payload interface{} `json:\"body,omitempty\"`", 586 `func NewGetInterfaceOK() *GetInterfaceOK {`, 587 ` return &GetInterfaceOK{`, 588 `func (o *GetInterfaceOK) WithPayload(payload interface{}) *GetInterfaceOK {`, 589 ` o.Payload = payload`, 590 ` return o`, 591 `func (o *GetInterfaceOK) SetPayload(payload interface{}) {`, 592 ` o.Payload = payload`, 593 `func (o *GetInterfaceOK) WriteResponse(rw http.ResponseWriter, producer runtime.Producer) {`, 594 ` rw.WriteHeader(200`, 595 ` payload := o.Payload`, 596 ` if err := producer.Produce(rw, payload); err != nil {`, 597 }, 598 }, 599 600 // load expectations for responses in operation get_primitive_responses.go 601 "getPrimitive": { // fixture index 602 "serverResponses": { // executed template 603 // expected code lines 604 `const GetPrimitiveOKCode int = 200`, 605 `type GetPrimitiveOK struct {`, 606 " Payload float32 `json:\"body,omitempty\"`", 607 `func NewGetPrimitiveOK() *GetPrimitiveOK {`, 608 ` return &GetPrimitiveOK{`, 609 `func (o *GetPrimitiveOK) WithPayload(payload float32) *GetPrimitiveOK {`, 610 ` o.Payload = payload`, 611 ` return o`, 612 `func (o *GetPrimitiveOK) SetPayload(payload float32) {`, 613 ` o.Payload = payload`, 614 `func (o *GetPrimitiveOK) WriteResponse(rw http.ResponseWriter, producer runtime.Producer) {`, 615 ` rw.WriteHeader(200`, 616 ` payload := o.Payload`, 617 ` if err := producer.Produce(rw, payload); err != nil {`, 618 }, 619 }, 620 621 // load expectations for responses in operation get_null_responses.go 622 "getNull": { // fixture index 623 "serverResponses": { // executed template 624 // expected code lines 625 `const GetNullOKCode int = 200`, 626 `type GetNullOK struct {`, 627 " Payload interface{} `json:\"body,omitempty\"`", 628 `func NewGetNullOK() *GetNullOK {`, 629 ` return &GetNullOK{`, 630 `func (o *GetNullOK) WithPayload(payload interface{}) *GetNullOK {`, 631 ` o.Payload = payload`, 632 ` return o`, 633 `func (o *GetNullOK) SetPayload(payload interface{}) {`, 634 ` o.Payload = payload`, 635 `func (o *GetNullOK) WriteResponse(rw http.ResponseWriter, producer runtime.Producer) {`, 636 ` rw.WriteHeader(200`, 637 ` payload := o.Payload`, 638 ` if err := producer.Produce(rw, payload); err != nil {`, 639 `const GetNullRequestProcessedCode int = 203`, 640 `/*GetNullRequestProcessed OK`, 641 `swagger:response getNullRequestProcessed`, 642 `*/`, 643 `type GetNullRequestProcessed struct {`, 644 `func NewGetNullRequestProcessed() *GetNullRequestProcessed {`, 645 ` return &GetNullRequestProcessed{`, 646 `func (o *GetNullRequestProcessed) WriteResponse(rw http.ResponseWriter, producer runtime.Producer) {`, 647 ` rw.Header().Del(runtime.HeaderContentType`, 648 ` rw.WriteHeader(203`, 649 }, 650 }, 651 652 // load expectations for responses in operation get_model_interface_responses.go 653 "getModelInterface": { // fixture index 654 "serverResponses": { // executed template 655 // expected code lines 656 `const GetModelInterfaceOKCode int = 200`, 657 `type GetModelInterfaceOK struct {`, 658 " Payload []models.ModelInterface `json:\"body,omitempty\"`", 659 `func NewGetModelInterfaceOK() *GetModelInterfaceOK {`, 660 ` return &GetModelInterfaceOK{`, 661 `func (o *GetModelInterfaceOK) WithPayload(payload []models.ModelInterface) *GetModelInterfaceOK {`, 662 ` o.Payload = payload`, 663 ` return o`, 664 `func (o *GetModelInterfaceOK) SetPayload(payload []models.ModelInterface) {`, 665 ` o.Payload = payload`, 666 `func (o *GetModelInterfaceOK) WriteResponse(rw http.ResponseWriter, producer runtime.Producer) {`, 667 ` rw.WriteHeader(200`, 668 ` payload := o.Payload`, 669 ` if payload == nil {`, 670 ` payload = make([]models.ModelInterface, 0, 50`, 671 ` if err := producer.Produce(rw, payload); err != nil {`, 672 }, 673 }, 674 } 675 676 // assertParams also works for responses 677 assertParams(t, fixtureConfig, filepath.Join("..", "fixtures", "enhancements", "1572", "fixture-1572.yaml"), true, false) 678 }