github.com/vipernet-xyz/tm@v0.34.24/abci/client/mocks/client.go (about) 1 // Code generated by mockery v1.1.1. DO NOT EDIT. 2 3 package mocks 4 5 import ( 6 abcicli "github.com/vipernet-xyz/tm/abci/client" 7 log "github.com/vipernet-xyz/tm/libs/log" 8 9 mock "github.com/stretchr/testify/mock" 10 11 types "github.com/vipernet-xyz/tm/abci/types" 12 ) 13 14 // Client is an autogenerated mock type for the Client type 15 type Client struct { 16 mock.Mock 17 } 18 19 // ApplySnapshotChunkAsync provides a mock function with given fields: _a0 20 func (_m *Client) ApplySnapshotChunkAsync(_a0 types.RequestApplySnapshotChunk) *abcicli.ReqRes { 21 ret := _m.Called(_a0) 22 23 var r0 *abcicli.ReqRes 24 if rf, ok := ret.Get(0).(func(types.RequestApplySnapshotChunk) *abcicli.ReqRes); ok { 25 r0 = rf(_a0) 26 } else { 27 if ret.Get(0) != nil { 28 r0 = ret.Get(0).(*abcicli.ReqRes) 29 } 30 } 31 32 return r0 33 } 34 35 // ApplySnapshotChunkSync provides a mock function with given fields: _a0 36 func (_m *Client) ApplySnapshotChunkSync(_a0 types.RequestApplySnapshotChunk) (*types.ResponseApplySnapshotChunk, error) { 37 ret := _m.Called(_a0) 38 39 var r0 *types.ResponseApplySnapshotChunk 40 if rf, ok := ret.Get(0).(func(types.RequestApplySnapshotChunk) *types.ResponseApplySnapshotChunk); ok { 41 r0 = rf(_a0) 42 } else { 43 if ret.Get(0) != nil { 44 r0 = ret.Get(0).(*types.ResponseApplySnapshotChunk) 45 } 46 } 47 48 var r1 error 49 if rf, ok := ret.Get(1).(func(types.RequestApplySnapshotChunk) error); ok { 50 r1 = rf(_a0) 51 } else { 52 r1 = ret.Error(1) 53 } 54 55 return r0, r1 56 } 57 58 // BeginBlockAsync provides a mock function with given fields: _a0 59 func (_m *Client) BeginBlockAsync(_a0 types.RequestBeginBlock) *abcicli.ReqRes { 60 ret := _m.Called(_a0) 61 62 var r0 *abcicli.ReqRes 63 if rf, ok := ret.Get(0).(func(types.RequestBeginBlock) *abcicli.ReqRes); ok { 64 r0 = rf(_a0) 65 } else { 66 if ret.Get(0) != nil { 67 r0 = ret.Get(0).(*abcicli.ReqRes) 68 } 69 } 70 71 return r0 72 } 73 74 // BeginBlockSync provides a mock function with given fields: _a0 75 func (_m *Client) BeginBlockSync(_a0 types.RequestBeginBlock) (*types.ResponseBeginBlock, error) { 76 ret := _m.Called(_a0) 77 78 var r0 *types.ResponseBeginBlock 79 if rf, ok := ret.Get(0).(func(types.RequestBeginBlock) *types.ResponseBeginBlock); ok { 80 r0 = rf(_a0) 81 } else { 82 if ret.Get(0) != nil { 83 r0 = ret.Get(0).(*types.ResponseBeginBlock) 84 } 85 } 86 87 var r1 error 88 if rf, ok := ret.Get(1).(func(types.RequestBeginBlock) error); ok { 89 r1 = rf(_a0) 90 } else { 91 r1 = ret.Error(1) 92 } 93 94 return r0, r1 95 } 96 97 // CheckTxAsync provides a mock function with given fields: _a0 98 func (_m *Client) CheckTxAsync(_a0 types.RequestCheckTx) *abcicli.ReqRes { 99 ret := _m.Called(_a0) 100 101 var r0 *abcicli.ReqRes 102 if rf, ok := ret.Get(0).(func(types.RequestCheckTx) *abcicli.ReqRes); ok { 103 r0 = rf(_a0) 104 } else { 105 if ret.Get(0) != nil { 106 r0 = ret.Get(0).(*abcicli.ReqRes) 107 } 108 } 109 110 return r0 111 } 112 113 // CheckTxSync provides a mock function with given fields: _a0 114 func (_m *Client) CheckTxSync(_a0 types.RequestCheckTx) (*types.ResponseCheckTx, error) { 115 ret := _m.Called(_a0) 116 117 var r0 *types.ResponseCheckTx 118 if rf, ok := ret.Get(0).(func(types.RequestCheckTx) *types.ResponseCheckTx); ok { 119 r0 = rf(_a0) 120 } else { 121 if ret.Get(0) != nil { 122 r0 = ret.Get(0).(*types.ResponseCheckTx) 123 } 124 } 125 126 var r1 error 127 if rf, ok := ret.Get(1).(func(types.RequestCheckTx) error); ok { 128 r1 = rf(_a0) 129 } else { 130 r1 = ret.Error(1) 131 } 132 133 return r0, r1 134 } 135 136 // CommitAsync provides a mock function with given fields: 137 func (_m *Client) CommitAsync() *abcicli.ReqRes { 138 ret := _m.Called() 139 140 var r0 *abcicli.ReqRes 141 if rf, ok := ret.Get(0).(func() *abcicli.ReqRes); ok { 142 r0 = rf() 143 } else { 144 if ret.Get(0) != nil { 145 r0 = ret.Get(0).(*abcicli.ReqRes) 146 } 147 } 148 149 return r0 150 } 151 152 // CommitSync provides a mock function with given fields: 153 func (_m *Client) CommitSync() (*types.ResponseCommit, error) { 154 ret := _m.Called() 155 156 var r0 *types.ResponseCommit 157 if rf, ok := ret.Get(0).(func() *types.ResponseCommit); ok { 158 r0 = rf() 159 } else { 160 if ret.Get(0) != nil { 161 r0 = ret.Get(0).(*types.ResponseCommit) 162 } 163 } 164 165 var r1 error 166 if rf, ok := ret.Get(1).(func() error); ok { 167 r1 = rf() 168 } else { 169 r1 = ret.Error(1) 170 } 171 172 return r0, r1 173 } 174 175 // DeliverTxAsync provides a mock function with given fields: _a0 176 func (_m *Client) DeliverTxAsync(_a0 types.RequestDeliverTx) *abcicli.ReqRes { 177 ret := _m.Called(_a0) 178 179 var r0 *abcicli.ReqRes 180 if rf, ok := ret.Get(0).(func(types.RequestDeliverTx) *abcicli.ReqRes); ok { 181 r0 = rf(_a0) 182 } else { 183 if ret.Get(0) != nil { 184 r0 = ret.Get(0).(*abcicli.ReqRes) 185 } 186 } 187 188 return r0 189 } 190 191 // DeliverTxSync provides a mock function with given fields: _a0 192 func (_m *Client) DeliverTxSync(_a0 types.RequestDeliverTx) (*types.ResponseDeliverTx, error) { 193 ret := _m.Called(_a0) 194 195 var r0 *types.ResponseDeliverTx 196 if rf, ok := ret.Get(0).(func(types.RequestDeliverTx) *types.ResponseDeliverTx); ok { 197 r0 = rf(_a0) 198 } else { 199 if ret.Get(0) != nil { 200 r0 = ret.Get(0).(*types.ResponseDeliverTx) 201 } 202 } 203 204 var r1 error 205 if rf, ok := ret.Get(1).(func(types.RequestDeliverTx) error); ok { 206 r1 = rf(_a0) 207 } else { 208 r1 = ret.Error(1) 209 } 210 211 return r0, r1 212 } 213 214 // EchoAsync provides a mock function with given fields: msg 215 func (_m *Client) EchoAsync(msg string) *abcicli.ReqRes { 216 ret := _m.Called(msg) 217 218 var r0 *abcicli.ReqRes 219 if rf, ok := ret.Get(0).(func(string) *abcicli.ReqRes); ok { 220 r0 = rf(msg) 221 } else { 222 if ret.Get(0) != nil { 223 r0 = ret.Get(0).(*abcicli.ReqRes) 224 } 225 } 226 227 return r0 228 } 229 230 // EchoSync provides a mock function with given fields: msg 231 func (_m *Client) EchoSync(msg string) (*types.ResponseEcho, error) { 232 ret := _m.Called(msg) 233 234 var r0 *types.ResponseEcho 235 if rf, ok := ret.Get(0).(func(string) *types.ResponseEcho); ok { 236 r0 = rf(msg) 237 } else { 238 if ret.Get(0) != nil { 239 r0 = ret.Get(0).(*types.ResponseEcho) 240 } 241 } 242 243 var r1 error 244 if rf, ok := ret.Get(1).(func(string) error); ok { 245 r1 = rf(msg) 246 } else { 247 r1 = ret.Error(1) 248 } 249 250 return r0, r1 251 } 252 253 // EndBlockAsync provides a mock function with given fields: _a0 254 func (_m *Client) EndBlockAsync(_a0 types.RequestEndBlock) *abcicli.ReqRes { 255 ret := _m.Called(_a0) 256 257 var r0 *abcicli.ReqRes 258 if rf, ok := ret.Get(0).(func(types.RequestEndBlock) *abcicli.ReqRes); ok { 259 r0 = rf(_a0) 260 } else { 261 if ret.Get(0) != nil { 262 r0 = ret.Get(0).(*abcicli.ReqRes) 263 } 264 } 265 266 return r0 267 } 268 269 // EndBlockSync provides a mock function with given fields: _a0 270 func (_m *Client) EndBlockSync(_a0 types.RequestEndBlock) (*types.ResponseEndBlock, error) { 271 ret := _m.Called(_a0) 272 273 var r0 *types.ResponseEndBlock 274 if rf, ok := ret.Get(0).(func(types.RequestEndBlock) *types.ResponseEndBlock); ok { 275 r0 = rf(_a0) 276 } else { 277 if ret.Get(0) != nil { 278 r0 = ret.Get(0).(*types.ResponseEndBlock) 279 } 280 } 281 282 var r1 error 283 if rf, ok := ret.Get(1).(func(types.RequestEndBlock) error); ok { 284 r1 = rf(_a0) 285 } else { 286 r1 = ret.Error(1) 287 } 288 289 return r0, r1 290 } 291 292 // Error provides a mock function with given fields: 293 func (_m *Client) Error() error { 294 ret := _m.Called() 295 296 var r0 error 297 if rf, ok := ret.Get(0).(func() error); ok { 298 r0 = rf() 299 } else { 300 r0 = ret.Error(0) 301 } 302 303 return r0 304 } 305 306 // FlushAsync provides a mock function with given fields: 307 func (_m *Client) FlushAsync() *abcicli.ReqRes { 308 ret := _m.Called() 309 310 var r0 *abcicli.ReqRes 311 if rf, ok := ret.Get(0).(func() *abcicli.ReqRes); ok { 312 r0 = rf() 313 } else { 314 if ret.Get(0) != nil { 315 r0 = ret.Get(0).(*abcicli.ReqRes) 316 } 317 } 318 319 return r0 320 } 321 322 // FlushSync provides a mock function with given fields: 323 func (_m *Client) FlushSync() error { 324 ret := _m.Called() 325 326 var r0 error 327 if rf, ok := ret.Get(0).(func() error); ok { 328 r0 = rf() 329 } else { 330 r0 = ret.Error(0) 331 } 332 333 return r0 334 } 335 336 // InfoAsync provides a mock function with given fields: _a0 337 func (_m *Client) InfoAsync(_a0 types.RequestInfo) *abcicli.ReqRes { 338 ret := _m.Called(_a0) 339 340 var r0 *abcicli.ReqRes 341 if rf, ok := ret.Get(0).(func(types.RequestInfo) *abcicli.ReqRes); ok { 342 r0 = rf(_a0) 343 } else { 344 if ret.Get(0) != nil { 345 r0 = ret.Get(0).(*abcicli.ReqRes) 346 } 347 } 348 349 return r0 350 } 351 352 // InfoSync provides a mock function with given fields: _a0 353 func (_m *Client) InfoSync(_a0 types.RequestInfo) (*types.ResponseInfo, error) { 354 ret := _m.Called(_a0) 355 356 var r0 *types.ResponseInfo 357 if rf, ok := ret.Get(0).(func(types.RequestInfo) *types.ResponseInfo); ok { 358 r0 = rf(_a0) 359 } else { 360 if ret.Get(0) != nil { 361 r0 = ret.Get(0).(*types.ResponseInfo) 362 } 363 } 364 365 var r1 error 366 if rf, ok := ret.Get(1).(func(types.RequestInfo) error); ok { 367 r1 = rf(_a0) 368 } else { 369 r1 = ret.Error(1) 370 } 371 372 return r0, r1 373 } 374 375 // InitChainAsync provides a mock function with given fields: _a0 376 func (_m *Client) InitChainAsync(_a0 types.RequestInitChain) *abcicli.ReqRes { 377 ret := _m.Called(_a0) 378 379 var r0 *abcicli.ReqRes 380 if rf, ok := ret.Get(0).(func(types.RequestInitChain) *abcicli.ReqRes); ok { 381 r0 = rf(_a0) 382 } else { 383 if ret.Get(0) != nil { 384 r0 = ret.Get(0).(*abcicli.ReqRes) 385 } 386 } 387 388 return r0 389 } 390 391 // InitChainSync provides a mock function with given fields: _a0 392 func (_m *Client) InitChainSync(_a0 types.RequestInitChain) (*types.ResponseInitChain, error) { 393 ret := _m.Called(_a0) 394 395 var r0 *types.ResponseInitChain 396 if rf, ok := ret.Get(0).(func(types.RequestInitChain) *types.ResponseInitChain); ok { 397 r0 = rf(_a0) 398 } else { 399 if ret.Get(0) != nil { 400 r0 = ret.Get(0).(*types.ResponseInitChain) 401 } 402 } 403 404 var r1 error 405 if rf, ok := ret.Get(1).(func(types.RequestInitChain) error); ok { 406 r1 = rf(_a0) 407 } else { 408 r1 = ret.Error(1) 409 } 410 411 return r0, r1 412 } 413 414 // IsRunning provides a mock function with given fields: 415 func (_m *Client) IsRunning() bool { 416 ret := _m.Called() 417 418 var r0 bool 419 if rf, ok := ret.Get(0).(func() bool); ok { 420 r0 = rf() 421 } else { 422 r0 = ret.Get(0).(bool) 423 } 424 425 return r0 426 } 427 428 // ListSnapshotsAsync provides a mock function with given fields: _a0 429 func (_m *Client) ListSnapshotsAsync(_a0 types.RequestListSnapshots) *abcicli.ReqRes { 430 ret := _m.Called(_a0) 431 432 var r0 *abcicli.ReqRes 433 if rf, ok := ret.Get(0).(func(types.RequestListSnapshots) *abcicli.ReqRes); ok { 434 r0 = rf(_a0) 435 } else { 436 if ret.Get(0) != nil { 437 r0 = ret.Get(0).(*abcicli.ReqRes) 438 } 439 } 440 441 return r0 442 } 443 444 // ListSnapshotsSync provides a mock function with given fields: _a0 445 func (_m *Client) ListSnapshotsSync(_a0 types.RequestListSnapshots) (*types.ResponseListSnapshots, error) { 446 ret := _m.Called(_a0) 447 448 var r0 *types.ResponseListSnapshots 449 if rf, ok := ret.Get(0).(func(types.RequestListSnapshots) *types.ResponseListSnapshots); ok { 450 r0 = rf(_a0) 451 } else { 452 if ret.Get(0) != nil { 453 r0 = ret.Get(0).(*types.ResponseListSnapshots) 454 } 455 } 456 457 var r1 error 458 if rf, ok := ret.Get(1).(func(types.RequestListSnapshots) error); ok { 459 r1 = rf(_a0) 460 } else { 461 r1 = ret.Error(1) 462 } 463 464 return r0, r1 465 } 466 467 // LoadSnapshotChunkAsync provides a mock function with given fields: _a0 468 func (_m *Client) LoadSnapshotChunkAsync(_a0 types.RequestLoadSnapshotChunk) *abcicli.ReqRes { 469 ret := _m.Called(_a0) 470 471 var r0 *abcicli.ReqRes 472 if rf, ok := ret.Get(0).(func(types.RequestLoadSnapshotChunk) *abcicli.ReqRes); ok { 473 r0 = rf(_a0) 474 } else { 475 if ret.Get(0) != nil { 476 r0 = ret.Get(0).(*abcicli.ReqRes) 477 } 478 } 479 480 return r0 481 } 482 483 // LoadSnapshotChunkSync provides a mock function with given fields: _a0 484 func (_m *Client) LoadSnapshotChunkSync(_a0 types.RequestLoadSnapshotChunk) (*types.ResponseLoadSnapshotChunk, error) { 485 ret := _m.Called(_a0) 486 487 var r0 *types.ResponseLoadSnapshotChunk 488 if rf, ok := ret.Get(0).(func(types.RequestLoadSnapshotChunk) *types.ResponseLoadSnapshotChunk); ok { 489 r0 = rf(_a0) 490 } else { 491 if ret.Get(0) != nil { 492 r0 = ret.Get(0).(*types.ResponseLoadSnapshotChunk) 493 } 494 } 495 496 var r1 error 497 if rf, ok := ret.Get(1).(func(types.RequestLoadSnapshotChunk) error); ok { 498 r1 = rf(_a0) 499 } else { 500 r1 = ret.Error(1) 501 } 502 503 return r0, r1 504 } 505 506 // OfferSnapshotAsync provides a mock function with given fields: _a0 507 func (_m *Client) OfferSnapshotAsync(_a0 types.RequestOfferSnapshot) *abcicli.ReqRes { 508 ret := _m.Called(_a0) 509 510 var r0 *abcicli.ReqRes 511 if rf, ok := ret.Get(0).(func(types.RequestOfferSnapshot) *abcicli.ReqRes); ok { 512 r0 = rf(_a0) 513 } else { 514 if ret.Get(0) != nil { 515 r0 = ret.Get(0).(*abcicli.ReqRes) 516 } 517 } 518 519 return r0 520 } 521 522 // OfferSnapshotSync provides a mock function with given fields: _a0 523 func (_m *Client) OfferSnapshotSync(_a0 types.RequestOfferSnapshot) (*types.ResponseOfferSnapshot, error) { 524 ret := _m.Called(_a0) 525 526 var r0 *types.ResponseOfferSnapshot 527 if rf, ok := ret.Get(0).(func(types.RequestOfferSnapshot) *types.ResponseOfferSnapshot); ok { 528 r0 = rf(_a0) 529 } else { 530 if ret.Get(0) != nil { 531 r0 = ret.Get(0).(*types.ResponseOfferSnapshot) 532 } 533 } 534 535 var r1 error 536 if rf, ok := ret.Get(1).(func(types.RequestOfferSnapshot) error); ok { 537 r1 = rf(_a0) 538 } else { 539 r1 = ret.Error(1) 540 } 541 542 return r0, r1 543 } 544 545 // OnReset provides a mock function with given fields: 546 func (_m *Client) OnReset() error { 547 ret := _m.Called() 548 549 var r0 error 550 if rf, ok := ret.Get(0).(func() error); ok { 551 r0 = rf() 552 } else { 553 r0 = ret.Error(0) 554 } 555 556 return r0 557 } 558 559 // OnStart provides a mock function with given fields: 560 func (_m *Client) OnStart() error { 561 ret := _m.Called() 562 563 var r0 error 564 if rf, ok := ret.Get(0).(func() error); ok { 565 r0 = rf() 566 } else { 567 r0 = ret.Error(0) 568 } 569 570 return r0 571 } 572 573 // OnStop provides a mock function with given fields: 574 func (_m *Client) OnStop() { 575 _m.Called() 576 } 577 578 // QueryAsync provides a mock function with given fields: _a0 579 func (_m *Client) QueryAsync(_a0 types.RequestQuery) *abcicli.ReqRes { 580 ret := _m.Called(_a0) 581 582 var r0 *abcicli.ReqRes 583 if rf, ok := ret.Get(0).(func(types.RequestQuery) *abcicli.ReqRes); ok { 584 r0 = rf(_a0) 585 } else { 586 if ret.Get(0) != nil { 587 r0 = ret.Get(0).(*abcicli.ReqRes) 588 } 589 } 590 591 return r0 592 } 593 594 // QuerySync provides a mock function with given fields: _a0 595 func (_m *Client) QuerySync(_a0 types.RequestQuery) (*types.ResponseQuery, error) { 596 ret := _m.Called(_a0) 597 598 var r0 *types.ResponseQuery 599 if rf, ok := ret.Get(0).(func(types.RequestQuery) *types.ResponseQuery); ok { 600 r0 = rf(_a0) 601 } else { 602 if ret.Get(0) != nil { 603 r0 = ret.Get(0).(*types.ResponseQuery) 604 } 605 } 606 607 var r1 error 608 if rf, ok := ret.Get(1).(func(types.RequestQuery) error); ok { 609 r1 = rf(_a0) 610 } else { 611 r1 = ret.Error(1) 612 } 613 614 return r0, r1 615 } 616 617 // Quit provides a mock function with given fields: 618 func (_m *Client) Quit() <-chan struct{} { 619 ret := _m.Called() 620 621 var r0 <-chan struct{} 622 if rf, ok := ret.Get(0).(func() <-chan struct{}); ok { 623 r0 = rf() 624 } else { 625 if ret.Get(0) != nil { 626 r0 = ret.Get(0).(<-chan struct{}) 627 } 628 } 629 630 return r0 631 } 632 633 // Reset provides a mock function with given fields: 634 func (_m *Client) Reset() error { 635 ret := _m.Called() 636 637 var r0 error 638 if rf, ok := ret.Get(0).(func() error); ok { 639 r0 = rf() 640 } else { 641 r0 = ret.Error(0) 642 } 643 644 return r0 645 } 646 647 // SetLogger provides a mock function with given fields: _a0 648 func (_m *Client) SetLogger(_a0 log.Logger) { 649 _m.Called(_a0) 650 } 651 652 // SetOptionAsync provides a mock function with given fields: _a0 653 func (_m *Client) SetOptionAsync(_a0 types.RequestSetOption) *abcicli.ReqRes { 654 ret := _m.Called(_a0) 655 656 var r0 *abcicli.ReqRes 657 if rf, ok := ret.Get(0).(func(types.RequestSetOption) *abcicli.ReqRes); ok { 658 r0 = rf(_a0) 659 } else { 660 if ret.Get(0) != nil { 661 r0 = ret.Get(0).(*abcicli.ReqRes) 662 } 663 } 664 665 return r0 666 } 667 668 // SetOptionSync provides a mock function with given fields: _a0 669 func (_m *Client) SetOptionSync(_a0 types.RequestSetOption) (*types.ResponseSetOption, error) { 670 ret := _m.Called(_a0) 671 672 var r0 *types.ResponseSetOption 673 if rf, ok := ret.Get(0).(func(types.RequestSetOption) *types.ResponseSetOption); ok { 674 r0 = rf(_a0) 675 } else { 676 if ret.Get(0) != nil { 677 r0 = ret.Get(0).(*types.ResponseSetOption) 678 } 679 } 680 681 var r1 error 682 if rf, ok := ret.Get(1).(func(types.RequestSetOption) error); ok { 683 r1 = rf(_a0) 684 } else { 685 r1 = ret.Error(1) 686 } 687 688 return r0, r1 689 } 690 691 // SetResponseCallback provides a mock function with given fields: _a0 692 func (_m *Client) SetResponseCallback(_a0 abcicli.Callback) { 693 _m.Called(_a0) 694 } 695 696 // Start provides a mock function with given fields: 697 func (_m *Client) Start() error { 698 ret := _m.Called() 699 700 var r0 error 701 if rf, ok := ret.Get(0).(func() error); ok { 702 r0 = rf() 703 } else { 704 r0 = ret.Error(0) 705 } 706 707 return r0 708 } 709 710 // Stop provides a mock function with given fields: 711 func (_m *Client) Stop() error { 712 ret := _m.Called() 713 714 var r0 error 715 if rf, ok := ret.Get(0).(func() error); ok { 716 r0 = rf() 717 } else { 718 r0 = ret.Error(0) 719 } 720 721 return r0 722 } 723 724 // String provides a mock function with given fields: 725 func (_m *Client) String() string { 726 ret := _m.Called() 727 728 var r0 string 729 if rf, ok := ret.Get(0).(func() string); ok { 730 r0 = rf() 731 } else { 732 r0 = ret.Get(0).(string) 733 } 734 735 return r0 736 }