github.com/optim-corp/cios-golang-sdk@v0.5.1/model/model_stream_request_wrapper_test.go (about) 1 package sdkmodel 2 3 import ( 4 "reflect" 5 "testing" 6 7 cnv "github.com/fcfcqloow/go-advance/convert" 8 9 "github.com/optim-corp/cios-golang-sdk/cios" 10 ) 11 12 func TestApiGetStreamRequest_Ascending(t *testing.T) { 13 type fields struct { 14 ApiService *cios.PublishSubscribeApiService 15 ChannelId string 16 PackerFormatParam *string 17 AscendingParam *bool 18 ChannelProtocolVersionParam *int32 19 LocationParam *string 20 LocationRangeParam *string 21 TimestampParam *string 22 TimestampRangeParam *string 23 LabelParam *string 24 OffsetParam *int64 25 LimitParam *int64 26 TimeoutParam *int 27 SessionIdParam *string 28 ChannelProtocolIdParam *string 29 } 30 type args struct { 31 ascending bool 32 } 33 tests := []struct { 34 name string 35 fields fields 36 args args 37 want ApiGetStreamRequest 38 }{ 39 { 40 name: "Test ascending true", 41 fields: fields{}, 42 args: args{false}, 43 want: ApiGetStreamRequest{ 44 AscendingParam: cnv.BoolPtr(false), 45 }, 46 }, 47 { 48 name: "Test ascending true", 49 fields: fields{}, 50 args: args{true}, 51 want: ApiGetStreamRequest{ 52 AscendingParam: cnv.BoolPtr(true), 53 }, 54 }, 55 } 56 for _, tt := range tests { 57 t.Run(tt.name, func(t *testing.T) { 58 r := ApiGetStreamRequest{ 59 ApiService: tt.fields.ApiService, 60 ChannelId: tt.fields.ChannelId, 61 PackerFormatParam: tt.fields.PackerFormatParam, 62 AscendingParam: tt.fields.AscendingParam, 63 ChannelProtocolVersionParam: tt.fields.ChannelProtocolVersionParam, 64 LocationParam: tt.fields.LocationParam, 65 LocationRangeParam: tt.fields.LocationRangeParam, 66 TimestampParam: tt.fields.TimestampParam, 67 TimestampRangeParam: tt.fields.TimestampRangeParam, 68 LabelParam: tt.fields.LabelParam, 69 OffsetParam: tt.fields.OffsetParam, 70 LimitParam: tt.fields.LimitParam, 71 TimeoutParam: tt.fields.TimeoutParam, 72 SessionIdParam: tt.fields.SessionIdParam, 73 ChannelProtocolIdParam: tt.fields.ChannelProtocolIdParam, 74 } 75 if got := r.Ascending(tt.args.ascending); !reflect.DeepEqual(got, tt.want) { 76 t.Errorf("Ascending() = %v, want %v", got, tt.want) 77 } 78 }) 79 } 80 } 81 82 func TestApiGetStreamRequest_ChannelProtocolId(t *testing.T) { 83 type fields struct { 84 ApiService *cios.PublishSubscribeApiService 85 ChannelId string 86 PackerFormatParam *string 87 AscendingParam *bool 88 ChannelProtocolVersionParam *int32 89 LocationParam *string 90 LocationRangeParam *string 91 TimestampParam *string 92 TimestampRangeParam *string 93 LabelParam *string 94 OffsetParam *int64 95 LimitParam *int64 96 TimeoutParam *int 97 SessionIdParam *string 98 ChannelProtocolIdParam *string 99 } 100 type args struct { 101 channelProtocolId string 102 } 103 tests := []struct { 104 name string 105 fields fields 106 args args 107 want ApiGetStreamRequest 108 }{ 109 { 110 name: "Test channelProtocolId true", 111 fields: fields{}, 112 args: args{""}, 113 want: ApiGetStreamRequest{ 114 ChannelProtocolIdParam: nil, 115 }, 116 }, 117 { 118 name: "Test channelProtocolId true", 119 fields: fields{}, 120 args: args{"test"}, 121 want: ApiGetStreamRequest{ 122 ChannelProtocolIdParam: cnv.StrPtr("test"), 123 }, 124 }, 125 } 126 for _, tt := range tests { 127 t.Run(tt.name, func(t *testing.T) { 128 r := ApiGetStreamRequest{ 129 ApiService: tt.fields.ApiService, 130 ChannelId: tt.fields.ChannelId, 131 PackerFormatParam: tt.fields.PackerFormatParam, 132 AscendingParam: tt.fields.AscendingParam, 133 ChannelProtocolVersionParam: tt.fields.ChannelProtocolVersionParam, 134 LocationParam: tt.fields.LocationParam, 135 LocationRangeParam: tt.fields.LocationRangeParam, 136 TimestampParam: tt.fields.TimestampParam, 137 TimestampRangeParam: tt.fields.TimestampRangeParam, 138 LabelParam: tt.fields.LabelParam, 139 OffsetParam: tt.fields.OffsetParam, 140 LimitParam: tt.fields.LimitParam, 141 TimeoutParam: tt.fields.TimeoutParam, 142 SessionIdParam: tt.fields.SessionIdParam, 143 ChannelProtocolIdParam: tt.fields.ChannelProtocolIdParam, 144 } 145 if got := r.ChannelProtocolId(tt.args.channelProtocolId); !reflect.DeepEqual(got, tt.want) { 146 t.Errorf("ChannelProtocolId() = %v, want %v", got, tt.want) 147 } 148 }) 149 } 150 } 151 152 func TestApiGetStreamRequest_ChannelProtocolVersion(t *testing.T) { 153 type fields struct { 154 ApiService *cios.PublishSubscribeApiService 155 ChannelId string 156 PackerFormatParam *string 157 AscendingParam *bool 158 ChannelProtocolVersionParam *int32 159 LocationParam *string 160 LocationRangeParam *string 161 TimestampParam *string 162 TimestampRangeParam *string 163 LabelParam *string 164 OffsetParam *int64 165 LimitParam *int64 166 TimeoutParam *int 167 SessionIdParam *string 168 ChannelProtocolIdParam *string 169 } 170 type args struct { 171 channelProtocolVersion int32 172 } 173 tests := []struct { 174 name string 175 fields fields 176 args args 177 want ApiGetStreamRequest 178 }{ 179 { 180 name: "Test channelProtocolVersion true", 181 fields: fields{}, 182 args: args{1}, 183 want: ApiGetStreamRequest{ 184 ChannelProtocolVersionParam: cnv.Int32Ptr(1), 185 }, 186 }, 187 { 188 name: "Test channelProtocolVersion true", 189 fields: fields{}, 190 args: args{12}, 191 want: ApiGetStreamRequest{ 192 ChannelProtocolVersionParam: cnv.Int32Ptr(12), 193 }, 194 }, 195 } 196 for _, tt := range tests { 197 t.Run(tt.name, func(t *testing.T) { 198 r := ApiGetStreamRequest{ 199 ApiService: tt.fields.ApiService, 200 ChannelId: tt.fields.ChannelId, 201 PackerFormatParam: tt.fields.PackerFormatParam, 202 AscendingParam: tt.fields.AscendingParam, 203 ChannelProtocolVersionParam: tt.fields.ChannelProtocolVersionParam, 204 LocationParam: tt.fields.LocationParam, 205 LocationRangeParam: tt.fields.LocationRangeParam, 206 TimestampParam: tt.fields.TimestampParam, 207 TimestampRangeParam: tt.fields.TimestampRangeParam, 208 LabelParam: tt.fields.LabelParam, 209 OffsetParam: tt.fields.OffsetParam, 210 LimitParam: tt.fields.LimitParam, 211 TimeoutParam: tt.fields.TimeoutParam, 212 SessionIdParam: tt.fields.SessionIdParam, 213 ChannelProtocolIdParam: tt.fields.ChannelProtocolIdParam, 214 } 215 if got := r.ChannelProtocolVersion(tt.args.channelProtocolVersion); !reflect.DeepEqual(got, tt.want) { 216 t.Errorf("ChannelProtocolVersion() = %v, want %v", got, tt.want) 217 } 218 }) 219 } 220 } 221 222 func TestApiGetStreamRequest_Label(t *testing.T) { 223 type fields struct { 224 ApiService *cios.PublishSubscribeApiService 225 ChannelId string 226 PackerFormatParam *string 227 AscendingParam *bool 228 ChannelProtocolVersionParam *int32 229 LocationParam *string 230 LocationRangeParam *string 231 TimestampParam *string 232 TimestampRangeParam *string 233 LabelParam *string 234 OffsetParam *int64 235 LimitParam *int64 236 TimeoutParam *int 237 SessionIdParam *string 238 ChannelProtocolIdParam *string 239 } 240 type args struct { 241 label string 242 } 243 tests := []struct { 244 name string 245 fields fields 246 args args 247 want ApiGetStreamRequest 248 }{ 249 { 250 name: "Test label true", 251 fields: fields{}, 252 args: args{""}, 253 want: ApiGetStreamRequest{ 254 LabelParam: nil, 255 }, 256 }, 257 { 258 name: "Test label true", 259 fields: fields{}, 260 args: args{"test"}, 261 want: ApiGetStreamRequest{ 262 LabelParam: cnv.StrPtr("test"), 263 }, 264 }, 265 } 266 for _, tt := range tests { 267 t.Run(tt.name, func(t *testing.T) { 268 r := ApiGetStreamRequest{ 269 ApiService: tt.fields.ApiService, 270 ChannelId: tt.fields.ChannelId, 271 PackerFormatParam: tt.fields.PackerFormatParam, 272 AscendingParam: tt.fields.AscendingParam, 273 ChannelProtocolVersionParam: tt.fields.ChannelProtocolVersionParam, 274 LocationParam: tt.fields.LocationParam, 275 LocationRangeParam: tt.fields.LocationRangeParam, 276 TimestampParam: tt.fields.TimestampParam, 277 TimestampRangeParam: tt.fields.TimestampRangeParam, 278 LabelParam: tt.fields.LabelParam, 279 OffsetParam: tt.fields.OffsetParam, 280 LimitParam: tt.fields.LimitParam, 281 TimeoutParam: tt.fields.TimeoutParam, 282 SessionIdParam: tt.fields.SessionIdParam, 283 ChannelProtocolIdParam: tt.fields.ChannelProtocolIdParam, 284 } 285 if got := r.Label(tt.args.label); !reflect.DeepEqual(got, tt.want) { 286 t.Errorf("Label() = %v, want %v", got, tt.want) 287 } 288 }) 289 } 290 } 291 292 func TestApiGetStreamRequest_Limit(t *testing.T) { 293 type fields struct { 294 ApiService *cios.PublishSubscribeApiService 295 ChannelId string 296 PackerFormatParam *string 297 AscendingParam *bool 298 ChannelProtocolVersionParam *int32 299 LocationParam *string 300 LocationRangeParam *string 301 TimestampParam *string 302 TimestampRangeParam *string 303 LabelParam *string 304 OffsetParam *int64 305 LimitParam *int64 306 TimeoutParam *int 307 SessionIdParam *string 308 ChannelProtocolIdParam *string 309 } 310 type args struct { 311 limit int64 312 } 313 tests := []struct { 314 name string 315 fields fields 316 args args 317 want ApiGetStreamRequest 318 }{ 319 { 320 name: "Test limit true", 321 fields: fields{}, 322 args: args{21}, 323 want: ApiGetStreamRequest{ 324 LimitParam: cnv.Int64Ptr(21), 325 }, 326 }, 327 { 328 name: "Test limit true", 329 fields: fields{}, 330 args: args{0}, 331 want: ApiGetStreamRequest{ 332 LimitParam: cnv.Int64Ptr(0), 333 }, 334 }, 335 } 336 for _, tt := range tests { 337 t.Run(tt.name, func(t *testing.T) { 338 r := ApiGetStreamRequest{ 339 ApiService: tt.fields.ApiService, 340 ChannelId: tt.fields.ChannelId, 341 PackerFormatParam: tt.fields.PackerFormatParam, 342 AscendingParam: tt.fields.AscendingParam, 343 ChannelProtocolVersionParam: tt.fields.ChannelProtocolVersionParam, 344 LocationParam: tt.fields.LocationParam, 345 LocationRangeParam: tt.fields.LocationRangeParam, 346 TimestampParam: tt.fields.TimestampParam, 347 TimestampRangeParam: tt.fields.TimestampRangeParam, 348 LabelParam: tt.fields.LabelParam, 349 OffsetParam: tt.fields.OffsetParam, 350 LimitParam: tt.fields.LimitParam, 351 TimeoutParam: tt.fields.TimeoutParam, 352 SessionIdParam: tt.fields.SessionIdParam, 353 ChannelProtocolIdParam: tt.fields.ChannelProtocolIdParam, 354 } 355 if got := r.Limit(tt.args.limit); !reflect.DeepEqual(got, tt.want) { 356 t.Errorf("Limit() = %v, want %v", got, tt.want) 357 } 358 }) 359 } 360 } 361 362 func TestApiGetStreamRequest_Location(t *testing.T) { 363 type fields struct { 364 ApiService *cios.PublishSubscribeApiService 365 ChannelId string 366 PackerFormatParam *string 367 AscendingParam *bool 368 ChannelProtocolVersionParam *int32 369 LocationParam *string 370 LocationRangeParam *string 371 TimestampParam *string 372 TimestampRangeParam *string 373 LabelParam *string 374 OffsetParam *int64 375 LimitParam *int64 376 TimeoutParam *int 377 SessionIdParam *string 378 ChannelProtocolIdParam *string 379 } 380 type args struct { 381 location string 382 } 383 tests := []struct { 384 name string 385 fields fields 386 args args 387 want ApiGetStreamRequest 388 }{ 389 { 390 name: "Test location true", 391 fields: fields{}, 392 args: args{""}, 393 want: ApiGetStreamRequest{ 394 LocationParam: nil, 395 }, 396 }, 397 { 398 name: "Test location true", 399 fields: fields{}, 400 args: args{"test"}, 401 want: ApiGetStreamRequest{ 402 LocationParam: cnv.StrPtr("test"), 403 }, 404 }, 405 } 406 for _, tt := range tests { 407 t.Run(tt.name, func(t *testing.T) { 408 r := ApiGetStreamRequest{ 409 ApiService: tt.fields.ApiService, 410 ChannelId: tt.fields.ChannelId, 411 PackerFormatParam: tt.fields.PackerFormatParam, 412 AscendingParam: tt.fields.AscendingParam, 413 ChannelProtocolVersionParam: tt.fields.ChannelProtocolVersionParam, 414 LocationParam: tt.fields.LocationParam, 415 LocationRangeParam: tt.fields.LocationRangeParam, 416 TimestampParam: tt.fields.TimestampParam, 417 TimestampRangeParam: tt.fields.TimestampRangeParam, 418 LabelParam: tt.fields.LabelParam, 419 OffsetParam: tt.fields.OffsetParam, 420 LimitParam: tt.fields.LimitParam, 421 TimeoutParam: tt.fields.TimeoutParam, 422 SessionIdParam: tt.fields.SessionIdParam, 423 ChannelProtocolIdParam: tt.fields.ChannelProtocolIdParam, 424 } 425 if got := r.Location(tt.args.location); !reflect.DeepEqual(got, tt.want) { 426 t.Errorf("Location() = %v, want %v", got, tt.want) 427 } 428 }) 429 } 430 } 431 432 func TestApiGetStreamRequest_LocationRange(t *testing.T) { 433 type fields struct { 434 ApiService *cios.PublishSubscribeApiService 435 ChannelId string 436 PackerFormatParam *string 437 AscendingParam *bool 438 ChannelProtocolVersionParam *int32 439 LocationParam *string 440 LocationRangeParam *string 441 TimestampParam *string 442 TimestampRangeParam *string 443 LabelParam *string 444 OffsetParam *int64 445 LimitParam *int64 446 TimeoutParam *int 447 SessionIdParam *string 448 ChannelProtocolIdParam *string 449 } 450 type args struct { 451 locationRange string 452 } 453 tests := []struct { 454 name string 455 fields fields 456 args args 457 want ApiGetStreamRequest 458 }{ 459 { 460 name: "Test locationRange true", 461 fields: fields{}, 462 args: args{""}, 463 want: ApiGetStreamRequest{ 464 LocationRangeParam: nil, 465 }, 466 }, 467 { 468 name: "Test locationRange true", 469 fields: fields{}, 470 args: args{"test"}, 471 want: ApiGetStreamRequest{ 472 LocationRangeParam: cnv.StrPtr("test"), 473 }, 474 }, 475 } 476 for _, tt := range tests { 477 t.Run(tt.name, func(t *testing.T) { 478 r := ApiGetStreamRequest{ 479 ApiService: tt.fields.ApiService, 480 ChannelId: tt.fields.ChannelId, 481 PackerFormatParam: tt.fields.PackerFormatParam, 482 AscendingParam: tt.fields.AscendingParam, 483 ChannelProtocolVersionParam: tt.fields.ChannelProtocolVersionParam, 484 LocationParam: tt.fields.LocationParam, 485 LocationRangeParam: tt.fields.LocationRangeParam, 486 TimestampParam: tt.fields.TimestampParam, 487 TimestampRangeParam: tt.fields.TimestampRangeParam, 488 LabelParam: tt.fields.LabelParam, 489 OffsetParam: tt.fields.OffsetParam, 490 LimitParam: tt.fields.LimitParam, 491 TimeoutParam: tt.fields.TimeoutParam, 492 SessionIdParam: tt.fields.SessionIdParam, 493 ChannelProtocolIdParam: tt.fields.ChannelProtocolIdParam, 494 } 495 if got := r.LocationRange(tt.args.locationRange); !reflect.DeepEqual(got, tt.want) { 496 t.Errorf("LocationRange() = %v, want %v", got, tt.want) 497 } 498 }) 499 } 500 } 501 502 func TestApiGetStreamRequest_Offset(t *testing.T) { 503 type fields struct { 504 ApiService *cios.PublishSubscribeApiService 505 ChannelId string 506 PackerFormatParam *string 507 AscendingParam *bool 508 ChannelProtocolVersionParam *int32 509 LocationParam *string 510 LocationRangeParam *string 511 TimestampParam *string 512 TimestampRangeParam *string 513 LabelParam *string 514 OffsetParam *int64 515 LimitParam *int64 516 TimeoutParam *int 517 SessionIdParam *string 518 ChannelProtocolIdParam *string 519 } 520 type args struct { 521 offset int64 522 } 523 tests := []struct { 524 name string 525 fields fields 526 args args 527 want ApiGetStreamRequest 528 }{ 529 { 530 name: "Test offset true", 531 fields: fields{}, 532 args: args{0}, 533 want: ApiGetStreamRequest{ 534 OffsetParam: cnv.Int64Ptr(0), 535 }, 536 }, 537 { 538 name: "Test offset true", 539 fields: fields{}, 540 args: args{21}, 541 want: ApiGetStreamRequest{ 542 OffsetParam: cnv.Int64Ptr(21), 543 }, 544 }, 545 } 546 for _, tt := range tests { 547 t.Run(tt.name, func(t *testing.T) { 548 r := ApiGetStreamRequest{ 549 ApiService: tt.fields.ApiService, 550 ChannelId: tt.fields.ChannelId, 551 PackerFormatParam: tt.fields.PackerFormatParam, 552 AscendingParam: tt.fields.AscendingParam, 553 ChannelProtocolVersionParam: tt.fields.ChannelProtocolVersionParam, 554 LocationParam: tt.fields.LocationParam, 555 LocationRangeParam: tt.fields.LocationRangeParam, 556 TimestampParam: tt.fields.TimestampParam, 557 TimestampRangeParam: tt.fields.TimestampRangeParam, 558 LabelParam: tt.fields.LabelParam, 559 OffsetParam: tt.fields.OffsetParam, 560 LimitParam: tt.fields.LimitParam, 561 TimeoutParam: tt.fields.TimeoutParam, 562 SessionIdParam: tt.fields.SessionIdParam, 563 ChannelProtocolIdParam: tt.fields.ChannelProtocolIdParam, 564 } 565 if got := r.Offset(tt.args.offset); !reflect.DeepEqual(got, tt.want) { 566 t.Errorf("Offset() = %v, want %v", got, tt.want) 567 } 568 }) 569 } 570 } 571 572 func TestApiGetStreamRequest_PackerFormat(t *testing.T) { 573 type fields struct { 574 ApiService *cios.PublishSubscribeApiService 575 ChannelId string 576 PackerFormatParam *string 577 AscendingParam *bool 578 ChannelProtocolVersionParam *int32 579 LocationParam *string 580 LocationRangeParam *string 581 TimestampParam *string 582 TimestampRangeParam *string 583 LabelParam *string 584 OffsetParam *int64 585 LimitParam *int64 586 TimeoutParam *int 587 SessionIdParam *string 588 ChannelProtocolIdParam *string 589 } 590 type args struct { 591 packerPacker string 592 } 593 tests := []struct { 594 name string 595 fields fields 596 args args 597 want ApiGetStreamRequest 598 }{ 599 { 600 name: "Test packerPacker true", 601 fields: fields{}, 602 args: args{""}, 603 want: ApiGetStreamRequest{ 604 PackerFormatParam: nil, 605 }, 606 }, 607 { 608 name: "Test packerPacker true", 609 fields: fields{}, 610 args: args{"test"}, 611 want: ApiGetStreamRequest{ 612 PackerFormatParam: cnv.StrPtr("test"), 613 }, 614 }, 615 } 616 for _, tt := range tests { 617 t.Run(tt.name, func(t *testing.T) { 618 r := ApiGetStreamRequest{ 619 ApiService: tt.fields.ApiService, 620 ChannelId: tt.fields.ChannelId, 621 PackerFormatParam: tt.fields.PackerFormatParam, 622 AscendingParam: tt.fields.AscendingParam, 623 ChannelProtocolVersionParam: tt.fields.ChannelProtocolVersionParam, 624 LocationParam: tt.fields.LocationParam, 625 LocationRangeParam: tt.fields.LocationRangeParam, 626 TimestampParam: tt.fields.TimestampParam, 627 TimestampRangeParam: tt.fields.TimestampRangeParam, 628 LabelParam: tt.fields.LabelParam, 629 OffsetParam: tt.fields.OffsetParam, 630 LimitParam: tt.fields.LimitParam, 631 TimeoutParam: tt.fields.TimeoutParam, 632 SessionIdParam: tt.fields.SessionIdParam, 633 ChannelProtocolIdParam: tt.fields.ChannelProtocolIdParam, 634 } 635 if got := r.PackerFormat(tt.args.packerPacker); !reflect.DeepEqual(got, tt.want) { 636 t.Errorf("PackerFormat() = %v, want %v", got, tt.want) 637 } 638 }) 639 } 640 } 641 642 func TestApiGetStreamRequest_SessionID(t *testing.T) { 643 type fields struct { 644 ApiService *cios.PublishSubscribeApiService 645 ChannelId string 646 PackerFormatParam *string 647 AscendingParam *bool 648 ChannelProtocolVersionParam *int32 649 LocationParam *string 650 LocationRangeParam *string 651 TimestampParam *string 652 TimestampRangeParam *string 653 LabelParam *string 654 OffsetParam *int64 655 LimitParam *int64 656 TimeoutParam *int 657 SessionIdParam *string 658 ChannelProtocolIdParam *string 659 } 660 type args struct { 661 sessionID string 662 } 663 tests := []struct { 664 name string 665 fields fields 666 args args 667 want ApiGetStreamRequest 668 }{ 669 { 670 name: "Test sessionID true", 671 fields: fields{}, 672 args: args{""}, 673 want: ApiGetStreamRequest{ 674 SessionIdParam: nil, 675 }, 676 }, 677 { 678 name: "Test sessionID true", 679 fields: fields{}, 680 args: args{"test"}, 681 want: ApiGetStreamRequest{ 682 SessionIdParam: cnv.StrPtr("test"), 683 }, 684 }, 685 } 686 for _, tt := range tests { 687 t.Run(tt.name, func(t *testing.T) { 688 r := ApiGetStreamRequest{ 689 ApiService: tt.fields.ApiService, 690 ChannelId: tt.fields.ChannelId, 691 PackerFormatParam: tt.fields.PackerFormatParam, 692 AscendingParam: tt.fields.AscendingParam, 693 ChannelProtocolVersionParam: tt.fields.ChannelProtocolVersionParam, 694 LocationParam: tt.fields.LocationParam, 695 LocationRangeParam: tt.fields.LocationRangeParam, 696 TimestampParam: tt.fields.TimestampParam, 697 TimestampRangeParam: tt.fields.TimestampRangeParam, 698 LabelParam: tt.fields.LabelParam, 699 OffsetParam: tt.fields.OffsetParam, 700 LimitParam: tt.fields.LimitParam, 701 TimeoutParam: tt.fields.TimeoutParam, 702 SessionIdParam: tt.fields.SessionIdParam, 703 ChannelProtocolIdParam: tt.fields.ChannelProtocolIdParam, 704 } 705 if got := r.SessionID(tt.args.sessionID); !reflect.DeepEqual(got, tt.want) { 706 t.Errorf("SessionID() = %v, want %v", got, tt.want) 707 } 708 }) 709 } 710 } 711 712 func TestApiGetStreamRequest_Timeout(t *testing.T) { 713 type fields struct { 714 ApiService *cios.PublishSubscribeApiService 715 ChannelId string 716 PackerFormatParam *string 717 AscendingParam *bool 718 ChannelProtocolVersionParam *int32 719 LocationParam *string 720 LocationRangeParam *string 721 TimestampParam *string 722 TimestampRangeParam *string 723 LabelParam *string 724 OffsetParam *int64 725 LimitParam *int64 726 TimeoutParam *int 727 SessionIdParam *string 728 ChannelProtocolIdParam *string 729 } 730 type args struct { 731 timeout int 732 } 733 tests := []struct { 734 name string 735 fields fields 736 args args 737 want ApiGetStreamRequest 738 }{ 739 { 740 name: "Test timeout true", 741 fields: fields{}, 742 args: args{0}, 743 want: ApiGetStreamRequest{ 744 TimeoutParam: cnv.IntPtr(0), 745 }, 746 }, 747 { 748 name: "Test timeout true", 749 fields: fields{}, 750 args: args{12}, 751 want: ApiGetStreamRequest{ 752 TimeoutParam: cnv.IntPtr(12), 753 }, 754 }, 755 } 756 for _, tt := range tests { 757 t.Run(tt.name, func(t *testing.T) { 758 r := ApiGetStreamRequest{ 759 ApiService: tt.fields.ApiService, 760 ChannelId: tt.fields.ChannelId, 761 PackerFormatParam: tt.fields.PackerFormatParam, 762 AscendingParam: tt.fields.AscendingParam, 763 ChannelProtocolVersionParam: tt.fields.ChannelProtocolVersionParam, 764 LocationParam: tt.fields.LocationParam, 765 LocationRangeParam: tt.fields.LocationRangeParam, 766 TimestampParam: tt.fields.TimestampParam, 767 TimestampRangeParam: tt.fields.TimestampRangeParam, 768 LabelParam: tt.fields.LabelParam, 769 OffsetParam: tt.fields.OffsetParam, 770 LimitParam: tt.fields.LimitParam, 771 TimeoutParam: tt.fields.TimeoutParam, 772 SessionIdParam: tt.fields.SessionIdParam, 773 ChannelProtocolIdParam: tt.fields.ChannelProtocolIdParam, 774 } 775 if got := r.Timeout(tt.args.timeout); !reflect.DeepEqual(got, tt.want) { 776 t.Errorf("Timeout() = %v, want %v", got, tt.want) 777 } 778 }) 779 } 780 } 781 782 func TestApiGetStreamRequest_Timestamp(t *testing.T) { 783 type fields struct { 784 ApiService *cios.PublishSubscribeApiService 785 ChannelId string 786 PackerFormatParam *string 787 AscendingParam *bool 788 ChannelProtocolVersionParam *int32 789 LocationParam *string 790 LocationRangeParam *string 791 TimestampParam *string 792 TimestampRangeParam *string 793 LabelParam *string 794 OffsetParam *int64 795 LimitParam *int64 796 TimeoutParam *int 797 SessionIdParam *string 798 ChannelProtocolIdParam *string 799 } 800 type args struct { 801 timestamp string 802 } 803 tests := []struct { 804 name string 805 fields fields 806 args args 807 want ApiGetStreamRequest 808 }{ 809 { 810 name: "Test timestamp true", 811 fields: fields{}, 812 args: args{""}, 813 want: ApiGetStreamRequest{ 814 TimestampParam: nil, 815 }, 816 }, 817 { 818 name: "Test timestamp true", 819 fields: fields{}, 820 args: args{"test"}, 821 want: ApiGetStreamRequest{ 822 TimestampParam: cnv.StrPtr("test"), 823 }, 824 }, 825 } 826 for _, tt := range tests { 827 t.Run(tt.name, func(t *testing.T) { 828 r := ApiGetStreamRequest{ 829 ApiService: tt.fields.ApiService, 830 ChannelId: tt.fields.ChannelId, 831 PackerFormatParam: tt.fields.PackerFormatParam, 832 AscendingParam: tt.fields.AscendingParam, 833 ChannelProtocolVersionParam: tt.fields.ChannelProtocolVersionParam, 834 LocationParam: tt.fields.LocationParam, 835 LocationRangeParam: tt.fields.LocationRangeParam, 836 TimestampParam: tt.fields.TimestampParam, 837 TimestampRangeParam: tt.fields.TimestampRangeParam, 838 LabelParam: tt.fields.LabelParam, 839 OffsetParam: tt.fields.OffsetParam, 840 LimitParam: tt.fields.LimitParam, 841 TimeoutParam: tt.fields.TimeoutParam, 842 SessionIdParam: tt.fields.SessionIdParam, 843 ChannelProtocolIdParam: tt.fields.ChannelProtocolIdParam, 844 } 845 if got := r.Timestamp(tt.args.timestamp); !reflect.DeepEqual(got, tt.want) { 846 t.Errorf("Timestamp() = %v, want %v", got, tt.want) 847 } 848 }) 849 } 850 } 851 852 func TestApiGetStreamRequest_TimestampRange(t *testing.T) { 853 type fields struct { 854 ApiService *cios.PublishSubscribeApiService 855 ChannelId string 856 PackerFormatParam *string 857 AscendingParam *bool 858 ChannelProtocolVersionParam *int32 859 LocationParam *string 860 LocationRangeParam *string 861 TimestampParam *string 862 TimestampRangeParam *string 863 LabelParam *string 864 OffsetParam *int64 865 LimitParam *int64 866 TimeoutParam *int 867 SessionIdParam *string 868 ChannelProtocolIdParam *string 869 } 870 type args struct { 871 timestampRange string 872 } 873 tests := []struct { 874 name string 875 fields fields 876 args args 877 want ApiGetStreamRequest 878 }{ 879 { 880 name: "Test timestampRange true", 881 fields: fields{}, 882 args: args{""}, 883 want: ApiGetStreamRequest{ 884 TimestampRangeParam: nil, 885 }, 886 }, 887 { 888 name: "Test timestampRange true", 889 fields: fields{}, 890 args: args{"test"}, 891 want: ApiGetStreamRequest{ 892 TimestampRangeParam: cnv.StrPtr("test"), 893 }, 894 }, 895 } 896 for _, tt := range tests { 897 t.Run(tt.name, func(t *testing.T) { 898 r := ApiGetStreamRequest{ 899 ApiService: tt.fields.ApiService, 900 ChannelId: tt.fields.ChannelId, 901 PackerFormatParam: tt.fields.PackerFormatParam, 902 AscendingParam: tt.fields.AscendingParam, 903 ChannelProtocolVersionParam: tt.fields.ChannelProtocolVersionParam, 904 LocationParam: tt.fields.LocationParam, 905 LocationRangeParam: tt.fields.LocationRangeParam, 906 TimestampParam: tt.fields.TimestampParam, 907 TimestampRangeParam: tt.fields.TimestampRangeParam, 908 LabelParam: tt.fields.LabelParam, 909 OffsetParam: tt.fields.OffsetParam, 910 LimitParam: tt.fields.LimitParam, 911 TimeoutParam: tt.fields.TimeoutParam, 912 SessionIdParam: tt.fields.SessionIdParam, 913 ChannelProtocolIdParam: tt.fields.ChannelProtocolIdParam, 914 } 915 if got := r.TimestampRange(tt.args.timestampRange); !reflect.DeepEqual(got, tt.want) { 916 t.Errorf("TimestampRange() = %v, want %v", got, tt.want) 917 } 918 }) 919 } 920 }