github.com/braveheart12/insolar-09-08-19@v0.8.7/testutils/logic_runner_mock.go (about) 1 package testutils 2 3 /* 4 DO NOT EDIT! 5 This code was generated automatically using github.com/gojuno/minimock v1.9 6 The original interface "LogicRunner" can be found in github.com/insolar/insolar/core 7 */ 8 import ( 9 context "context" 10 "sync/atomic" 11 "time" 12 13 "github.com/gojuno/minimock" 14 core "github.com/insolar/insolar/core" 15 16 testify_assert "github.com/stretchr/testify/assert" 17 ) 18 19 //LogicRunnerMock implements github.com/insolar/insolar/core.LogicRunner 20 type LogicRunnerMock struct { 21 t minimock.Tester 22 23 ExecuteFunc func(p context.Context, p1 core.Parcel) (r core.Reply, r1 error) 24 ExecuteCounter uint64 25 ExecutePreCounter uint64 26 ExecuteMock mLogicRunnerMockExecute 27 28 HandleExecutorResultsMessageFunc func(p context.Context, p1 core.Parcel) (r core.Reply, r1 error) 29 HandleExecutorResultsMessageCounter uint64 30 HandleExecutorResultsMessagePreCounter uint64 31 HandleExecutorResultsMessageMock mLogicRunnerMockHandleExecutorResultsMessage 32 33 HandleValidateCaseBindMessageFunc func(p context.Context, p1 core.Parcel) (r core.Reply, r1 error) 34 HandleValidateCaseBindMessageCounter uint64 35 HandleValidateCaseBindMessagePreCounter uint64 36 HandleValidateCaseBindMessageMock mLogicRunnerMockHandleValidateCaseBindMessage 37 38 HandleValidationResultsMessageFunc func(p context.Context, p1 core.Parcel) (r core.Reply, r1 error) 39 HandleValidationResultsMessageCounter uint64 40 HandleValidationResultsMessagePreCounter uint64 41 HandleValidationResultsMessageMock mLogicRunnerMockHandleValidationResultsMessage 42 43 OnPulseFunc func(p context.Context, p1 core.Pulse) (r error) 44 OnPulseCounter uint64 45 OnPulsePreCounter uint64 46 OnPulseMock mLogicRunnerMockOnPulse 47 } 48 49 //NewLogicRunnerMock returns a mock for github.com/insolar/insolar/core.LogicRunner 50 func NewLogicRunnerMock(t minimock.Tester) *LogicRunnerMock { 51 m := &LogicRunnerMock{t: t} 52 53 if controller, ok := t.(minimock.MockController); ok { 54 controller.RegisterMocker(m) 55 } 56 57 m.ExecuteMock = mLogicRunnerMockExecute{mock: m} 58 m.HandleExecutorResultsMessageMock = mLogicRunnerMockHandleExecutorResultsMessage{mock: m} 59 m.HandleValidateCaseBindMessageMock = mLogicRunnerMockHandleValidateCaseBindMessage{mock: m} 60 m.HandleValidationResultsMessageMock = mLogicRunnerMockHandleValidationResultsMessage{mock: m} 61 m.OnPulseMock = mLogicRunnerMockOnPulse{mock: m} 62 63 return m 64 } 65 66 type mLogicRunnerMockExecute struct { 67 mock *LogicRunnerMock 68 mainExpectation *LogicRunnerMockExecuteExpectation 69 expectationSeries []*LogicRunnerMockExecuteExpectation 70 } 71 72 type LogicRunnerMockExecuteExpectation struct { 73 input *LogicRunnerMockExecuteInput 74 result *LogicRunnerMockExecuteResult 75 } 76 77 type LogicRunnerMockExecuteInput struct { 78 p context.Context 79 p1 core.Parcel 80 } 81 82 type LogicRunnerMockExecuteResult struct { 83 r core.Reply 84 r1 error 85 } 86 87 //Expect specifies that invocation of LogicRunner.Execute is expected from 1 to Infinity times 88 func (m *mLogicRunnerMockExecute) Expect(p context.Context, p1 core.Parcel) *mLogicRunnerMockExecute { 89 m.mock.ExecuteFunc = nil 90 m.expectationSeries = nil 91 92 if m.mainExpectation == nil { 93 m.mainExpectation = &LogicRunnerMockExecuteExpectation{} 94 } 95 m.mainExpectation.input = &LogicRunnerMockExecuteInput{p, p1} 96 return m 97 } 98 99 //Return specifies results of invocation of LogicRunner.Execute 100 func (m *mLogicRunnerMockExecute) Return(r core.Reply, r1 error) *LogicRunnerMock { 101 m.mock.ExecuteFunc = nil 102 m.expectationSeries = nil 103 104 if m.mainExpectation == nil { 105 m.mainExpectation = &LogicRunnerMockExecuteExpectation{} 106 } 107 m.mainExpectation.result = &LogicRunnerMockExecuteResult{r, r1} 108 return m.mock 109 } 110 111 //ExpectOnce specifies that invocation of LogicRunner.Execute is expected once 112 func (m *mLogicRunnerMockExecute) ExpectOnce(p context.Context, p1 core.Parcel) *LogicRunnerMockExecuteExpectation { 113 m.mock.ExecuteFunc = nil 114 m.mainExpectation = nil 115 116 expectation := &LogicRunnerMockExecuteExpectation{} 117 expectation.input = &LogicRunnerMockExecuteInput{p, p1} 118 m.expectationSeries = append(m.expectationSeries, expectation) 119 return expectation 120 } 121 122 func (e *LogicRunnerMockExecuteExpectation) Return(r core.Reply, r1 error) { 123 e.result = &LogicRunnerMockExecuteResult{r, r1} 124 } 125 126 //Set uses given function f as a mock of LogicRunner.Execute method 127 func (m *mLogicRunnerMockExecute) Set(f func(p context.Context, p1 core.Parcel) (r core.Reply, r1 error)) *LogicRunnerMock { 128 m.mainExpectation = nil 129 m.expectationSeries = nil 130 131 m.mock.ExecuteFunc = f 132 return m.mock 133 } 134 135 //Execute implements github.com/insolar/insolar/core.LogicRunner interface 136 func (m *LogicRunnerMock) Execute(p context.Context, p1 core.Parcel) (r core.Reply, r1 error) { 137 counter := atomic.AddUint64(&m.ExecutePreCounter, 1) 138 defer atomic.AddUint64(&m.ExecuteCounter, 1) 139 140 if len(m.ExecuteMock.expectationSeries) > 0 { 141 if counter > uint64(len(m.ExecuteMock.expectationSeries)) { 142 m.t.Fatalf("Unexpected call to LogicRunnerMock.Execute. %v %v", p, p1) 143 return 144 } 145 146 input := m.ExecuteMock.expectationSeries[counter-1].input 147 testify_assert.Equal(m.t, *input, LogicRunnerMockExecuteInput{p, p1}, "LogicRunner.Execute got unexpected parameters") 148 149 result := m.ExecuteMock.expectationSeries[counter-1].result 150 if result == nil { 151 m.t.Fatal("No results are set for the LogicRunnerMock.Execute") 152 return 153 } 154 155 r = result.r 156 r1 = result.r1 157 158 return 159 } 160 161 if m.ExecuteMock.mainExpectation != nil { 162 163 input := m.ExecuteMock.mainExpectation.input 164 if input != nil { 165 testify_assert.Equal(m.t, *input, LogicRunnerMockExecuteInput{p, p1}, "LogicRunner.Execute got unexpected parameters") 166 } 167 168 result := m.ExecuteMock.mainExpectation.result 169 if result == nil { 170 m.t.Fatal("No results are set for the LogicRunnerMock.Execute") 171 } 172 173 r = result.r 174 r1 = result.r1 175 176 return 177 } 178 179 if m.ExecuteFunc == nil { 180 m.t.Fatalf("Unexpected call to LogicRunnerMock.Execute. %v %v", p, p1) 181 return 182 } 183 184 return m.ExecuteFunc(p, p1) 185 } 186 187 //ExecuteMinimockCounter returns a count of LogicRunnerMock.ExecuteFunc invocations 188 func (m *LogicRunnerMock) ExecuteMinimockCounter() uint64 { 189 return atomic.LoadUint64(&m.ExecuteCounter) 190 } 191 192 //ExecuteMinimockPreCounter returns the value of LogicRunnerMock.Execute invocations 193 func (m *LogicRunnerMock) ExecuteMinimockPreCounter() uint64 { 194 return atomic.LoadUint64(&m.ExecutePreCounter) 195 } 196 197 //ExecuteFinished returns true if mock invocations count is ok 198 func (m *LogicRunnerMock) ExecuteFinished() bool { 199 // if expectation series were set then invocations count should be equal to expectations count 200 if len(m.ExecuteMock.expectationSeries) > 0 { 201 return atomic.LoadUint64(&m.ExecuteCounter) == uint64(len(m.ExecuteMock.expectationSeries)) 202 } 203 204 // if main expectation was set then invocations count should be greater than zero 205 if m.ExecuteMock.mainExpectation != nil { 206 return atomic.LoadUint64(&m.ExecuteCounter) > 0 207 } 208 209 // if func was set then invocations count should be greater than zero 210 if m.ExecuteFunc != nil { 211 return atomic.LoadUint64(&m.ExecuteCounter) > 0 212 } 213 214 return true 215 } 216 217 type mLogicRunnerMockHandleExecutorResultsMessage struct { 218 mock *LogicRunnerMock 219 mainExpectation *LogicRunnerMockHandleExecutorResultsMessageExpectation 220 expectationSeries []*LogicRunnerMockHandleExecutorResultsMessageExpectation 221 } 222 223 type LogicRunnerMockHandleExecutorResultsMessageExpectation struct { 224 input *LogicRunnerMockHandleExecutorResultsMessageInput 225 result *LogicRunnerMockHandleExecutorResultsMessageResult 226 } 227 228 type LogicRunnerMockHandleExecutorResultsMessageInput struct { 229 p context.Context 230 p1 core.Parcel 231 } 232 233 type LogicRunnerMockHandleExecutorResultsMessageResult struct { 234 r core.Reply 235 r1 error 236 } 237 238 //Expect specifies that invocation of LogicRunner.HandleExecutorResultsMessage is expected from 1 to Infinity times 239 func (m *mLogicRunnerMockHandleExecutorResultsMessage) Expect(p context.Context, p1 core.Parcel) *mLogicRunnerMockHandleExecutorResultsMessage { 240 m.mock.HandleExecutorResultsMessageFunc = nil 241 m.expectationSeries = nil 242 243 if m.mainExpectation == nil { 244 m.mainExpectation = &LogicRunnerMockHandleExecutorResultsMessageExpectation{} 245 } 246 m.mainExpectation.input = &LogicRunnerMockHandleExecutorResultsMessageInput{p, p1} 247 return m 248 } 249 250 //Return specifies results of invocation of LogicRunner.HandleExecutorResultsMessage 251 func (m *mLogicRunnerMockHandleExecutorResultsMessage) Return(r core.Reply, r1 error) *LogicRunnerMock { 252 m.mock.HandleExecutorResultsMessageFunc = nil 253 m.expectationSeries = nil 254 255 if m.mainExpectation == nil { 256 m.mainExpectation = &LogicRunnerMockHandleExecutorResultsMessageExpectation{} 257 } 258 m.mainExpectation.result = &LogicRunnerMockHandleExecutorResultsMessageResult{r, r1} 259 return m.mock 260 } 261 262 //ExpectOnce specifies that invocation of LogicRunner.HandleExecutorResultsMessage is expected once 263 func (m *mLogicRunnerMockHandleExecutorResultsMessage) ExpectOnce(p context.Context, p1 core.Parcel) *LogicRunnerMockHandleExecutorResultsMessageExpectation { 264 m.mock.HandleExecutorResultsMessageFunc = nil 265 m.mainExpectation = nil 266 267 expectation := &LogicRunnerMockHandleExecutorResultsMessageExpectation{} 268 expectation.input = &LogicRunnerMockHandleExecutorResultsMessageInput{p, p1} 269 m.expectationSeries = append(m.expectationSeries, expectation) 270 return expectation 271 } 272 273 func (e *LogicRunnerMockHandleExecutorResultsMessageExpectation) Return(r core.Reply, r1 error) { 274 e.result = &LogicRunnerMockHandleExecutorResultsMessageResult{r, r1} 275 } 276 277 //Set uses given function f as a mock of LogicRunner.HandleExecutorResultsMessage method 278 func (m *mLogicRunnerMockHandleExecutorResultsMessage) Set(f func(p context.Context, p1 core.Parcel) (r core.Reply, r1 error)) *LogicRunnerMock { 279 m.mainExpectation = nil 280 m.expectationSeries = nil 281 282 m.mock.HandleExecutorResultsMessageFunc = f 283 return m.mock 284 } 285 286 //HandleExecutorResultsMessage implements github.com/insolar/insolar/core.LogicRunner interface 287 func (m *LogicRunnerMock) HandleExecutorResultsMessage(p context.Context, p1 core.Parcel) (r core.Reply, r1 error) { 288 counter := atomic.AddUint64(&m.HandleExecutorResultsMessagePreCounter, 1) 289 defer atomic.AddUint64(&m.HandleExecutorResultsMessageCounter, 1) 290 291 if len(m.HandleExecutorResultsMessageMock.expectationSeries) > 0 { 292 if counter > uint64(len(m.HandleExecutorResultsMessageMock.expectationSeries)) { 293 m.t.Fatalf("Unexpected call to LogicRunnerMock.HandleExecutorResultsMessage. %v %v", p, p1) 294 return 295 } 296 297 input := m.HandleExecutorResultsMessageMock.expectationSeries[counter-1].input 298 testify_assert.Equal(m.t, *input, LogicRunnerMockHandleExecutorResultsMessageInput{p, p1}, "LogicRunner.HandleExecutorResultsMessage got unexpected parameters") 299 300 result := m.HandleExecutorResultsMessageMock.expectationSeries[counter-1].result 301 if result == nil { 302 m.t.Fatal("No results are set for the LogicRunnerMock.HandleExecutorResultsMessage") 303 return 304 } 305 306 r = result.r 307 r1 = result.r1 308 309 return 310 } 311 312 if m.HandleExecutorResultsMessageMock.mainExpectation != nil { 313 314 input := m.HandleExecutorResultsMessageMock.mainExpectation.input 315 if input != nil { 316 testify_assert.Equal(m.t, *input, LogicRunnerMockHandleExecutorResultsMessageInput{p, p1}, "LogicRunner.HandleExecutorResultsMessage got unexpected parameters") 317 } 318 319 result := m.HandleExecutorResultsMessageMock.mainExpectation.result 320 if result == nil { 321 m.t.Fatal("No results are set for the LogicRunnerMock.HandleExecutorResultsMessage") 322 } 323 324 r = result.r 325 r1 = result.r1 326 327 return 328 } 329 330 if m.HandleExecutorResultsMessageFunc == nil { 331 m.t.Fatalf("Unexpected call to LogicRunnerMock.HandleExecutorResultsMessage. %v %v", p, p1) 332 return 333 } 334 335 return m.HandleExecutorResultsMessageFunc(p, p1) 336 } 337 338 //HandleExecutorResultsMessageMinimockCounter returns a count of LogicRunnerMock.HandleExecutorResultsMessageFunc invocations 339 func (m *LogicRunnerMock) HandleExecutorResultsMessageMinimockCounter() uint64 { 340 return atomic.LoadUint64(&m.HandleExecutorResultsMessageCounter) 341 } 342 343 //HandleExecutorResultsMessageMinimockPreCounter returns the value of LogicRunnerMock.HandleExecutorResultsMessage invocations 344 func (m *LogicRunnerMock) HandleExecutorResultsMessageMinimockPreCounter() uint64 { 345 return atomic.LoadUint64(&m.HandleExecutorResultsMessagePreCounter) 346 } 347 348 //HandleExecutorResultsMessageFinished returns true if mock invocations count is ok 349 func (m *LogicRunnerMock) HandleExecutorResultsMessageFinished() bool { 350 // if expectation series were set then invocations count should be equal to expectations count 351 if len(m.HandleExecutorResultsMessageMock.expectationSeries) > 0 { 352 return atomic.LoadUint64(&m.HandleExecutorResultsMessageCounter) == uint64(len(m.HandleExecutorResultsMessageMock.expectationSeries)) 353 } 354 355 // if main expectation was set then invocations count should be greater than zero 356 if m.HandleExecutorResultsMessageMock.mainExpectation != nil { 357 return atomic.LoadUint64(&m.HandleExecutorResultsMessageCounter) > 0 358 } 359 360 // if func was set then invocations count should be greater than zero 361 if m.HandleExecutorResultsMessageFunc != nil { 362 return atomic.LoadUint64(&m.HandleExecutorResultsMessageCounter) > 0 363 } 364 365 return true 366 } 367 368 type mLogicRunnerMockHandleValidateCaseBindMessage struct { 369 mock *LogicRunnerMock 370 mainExpectation *LogicRunnerMockHandleValidateCaseBindMessageExpectation 371 expectationSeries []*LogicRunnerMockHandleValidateCaseBindMessageExpectation 372 } 373 374 type LogicRunnerMockHandleValidateCaseBindMessageExpectation struct { 375 input *LogicRunnerMockHandleValidateCaseBindMessageInput 376 result *LogicRunnerMockHandleValidateCaseBindMessageResult 377 } 378 379 type LogicRunnerMockHandleValidateCaseBindMessageInput struct { 380 p context.Context 381 p1 core.Parcel 382 } 383 384 type LogicRunnerMockHandleValidateCaseBindMessageResult struct { 385 r core.Reply 386 r1 error 387 } 388 389 //Expect specifies that invocation of LogicRunner.HandleValidateCaseBindMessage is expected from 1 to Infinity times 390 func (m *mLogicRunnerMockHandleValidateCaseBindMessage) Expect(p context.Context, p1 core.Parcel) *mLogicRunnerMockHandleValidateCaseBindMessage { 391 m.mock.HandleValidateCaseBindMessageFunc = nil 392 m.expectationSeries = nil 393 394 if m.mainExpectation == nil { 395 m.mainExpectation = &LogicRunnerMockHandleValidateCaseBindMessageExpectation{} 396 } 397 m.mainExpectation.input = &LogicRunnerMockHandleValidateCaseBindMessageInput{p, p1} 398 return m 399 } 400 401 //Return specifies results of invocation of LogicRunner.HandleValidateCaseBindMessage 402 func (m *mLogicRunnerMockHandleValidateCaseBindMessage) Return(r core.Reply, r1 error) *LogicRunnerMock { 403 m.mock.HandleValidateCaseBindMessageFunc = nil 404 m.expectationSeries = nil 405 406 if m.mainExpectation == nil { 407 m.mainExpectation = &LogicRunnerMockHandleValidateCaseBindMessageExpectation{} 408 } 409 m.mainExpectation.result = &LogicRunnerMockHandleValidateCaseBindMessageResult{r, r1} 410 return m.mock 411 } 412 413 //ExpectOnce specifies that invocation of LogicRunner.HandleValidateCaseBindMessage is expected once 414 func (m *mLogicRunnerMockHandleValidateCaseBindMessage) ExpectOnce(p context.Context, p1 core.Parcel) *LogicRunnerMockHandleValidateCaseBindMessageExpectation { 415 m.mock.HandleValidateCaseBindMessageFunc = nil 416 m.mainExpectation = nil 417 418 expectation := &LogicRunnerMockHandleValidateCaseBindMessageExpectation{} 419 expectation.input = &LogicRunnerMockHandleValidateCaseBindMessageInput{p, p1} 420 m.expectationSeries = append(m.expectationSeries, expectation) 421 return expectation 422 } 423 424 func (e *LogicRunnerMockHandleValidateCaseBindMessageExpectation) Return(r core.Reply, r1 error) { 425 e.result = &LogicRunnerMockHandleValidateCaseBindMessageResult{r, r1} 426 } 427 428 //Set uses given function f as a mock of LogicRunner.HandleValidateCaseBindMessage method 429 func (m *mLogicRunnerMockHandleValidateCaseBindMessage) Set(f func(p context.Context, p1 core.Parcel) (r core.Reply, r1 error)) *LogicRunnerMock { 430 m.mainExpectation = nil 431 m.expectationSeries = nil 432 433 m.mock.HandleValidateCaseBindMessageFunc = f 434 return m.mock 435 } 436 437 //HandleValidateCaseBindMessage implements github.com/insolar/insolar/core.LogicRunner interface 438 func (m *LogicRunnerMock) HandleValidateCaseBindMessage(p context.Context, p1 core.Parcel) (r core.Reply, r1 error) { 439 counter := atomic.AddUint64(&m.HandleValidateCaseBindMessagePreCounter, 1) 440 defer atomic.AddUint64(&m.HandleValidateCaseBindMessageCounter, 1) 441 442 if len(m.HandleValidateCaseBindMessageMock.expectationSeries) > 0 { 443 if counter > uint64(len(m.HandleValidateCaseBindMessageMock.expectationSeries)) { 444 m.t.Fatalf("Unexpected call to LogicRunnerMock.HandleValidateCaseBindMessage. %v %v", p, p1) 445 return 446 } 447 448 input := m.HandleValidateCaseBindMessageMock.expectationSeries[counter-1].input 449 testify_assert.Equal(m.t, *input, LogicRunnerMockHandleValidateCaseBindMessageInput{p, p1}, "LogicRunner.HandleValidateCaseBindMessage got unexpected parameters") 450 451 result := m.HandleValidateCaseBindMessageMock.expectationSeries[counter-1].result 452 if result == nil { 453 m.t.Fatal("No results are set for the LogicRunnerMock.HandleValidateCaseBindMessage") 454 return 455 } 456 457 r = result.r 458 r1 = result.r1 459 460 return 461 } 462 463 if m.HandleValidateCaseBindMessageMock.mainExpectation != nil { 464 465 input := m.HandleValidateCaseBindMessageMock.mainExpectation.input 466 if input != nil { 467 testify_assert.Equal(m.t, *input, LogicRunnerMockHandleValidateCaseBindMessageInput{p, p1}, "LogicRunner.HandleValidateCaseBindMessage got unexpected parameters") 468 } 469 470 result := m.HandleValidateCaseBindMessageMock.mainExpectation.result 471 if result == nil { 472 m.t.Fatal("No results are set for the LogicRunnerMock.HandleValidateCaseBindMessage") 473 } 474 475 r = result.r 476 r1 = result.r1 477 478 return 479 } 480 481 if m.HandleValidateCaseBindMessageFunc == nil { 482 m.t.Fatalf("Unexpected call to LogicRunnerMock.HandleValidateCaseBindMessage. %v %v", p, p1) 483 return 484 } 485 486 return m.HandleValidateCaseBindMessageFunc(p, p1) 487 } 488 489 //HandleValidateCaseBindMessageMinimockCounter returns a count of LogicRunnerMock.HandleValidateCaseBindMessageFunc invocations 490 func (m *LogicRunnerMock) HandleValidateCaseBindMessageMinimockCounter() uint64 { 491 return atomic.LoadUint64(&m.HandleValidateCaseBindMessageCounter) 492 } 493 494 //HandleValidateCaseBindMessageMinimockPreCounter returns the value of LogicRunnerMock.HandleValidateCaseBindMessage invocations 495 func (m *LogicRunnerMock) HandleValidateCaseBindMessageMinimockPreCounter() uint64 { 496 return atomic.LoadUint64(&m.HandleValidateCaseBindMessagePreCounter) 497 } 498 499 //HandleValidateCaseBindMessageFinished returns true if mock invocations count is ok 500 func (m *LogicRunnerMock) HandleValidateCaseBindMessageFinished() bool { 501 // if expectation series were set then invocations count should be equal to expectations count 502 if len(m.HandleValidateCaseBindMessageMock.expectationSeries) > 0 { 503 return atomic.LoadUint64(&m.HandleValidateCaseBindMessageCounter) == uint64(len(m.HandleValidateCaseBindMessageMock.expectationSeries)) 504 } 505 506 // if main expectation was set then invocations count should be greater than zero 507 if m.HandleValidateCaseBindMessageMock.mainExpectation != nil { 508 return atomic.LoadUint64(&m.HandleValidateCaseBindMessageCounter) > 0 509 } 510 511 // if func was set then invocations count should be greater than zero 512 if m.HandleValidateCaseBindMessageFunc != nil { 513 return atomic.LoadUint64(&m.HandleValidateCaseBindMessageCounter) > 0 514 } 515 516 return true 517 } 518 519 type mLogicRunnerMockHandleValidationResultsMessage struct { 520 mock *LogicRunnerMock 521 mainExpectation *LogicRunnerMockHandleValidationResultsMessageExpectation 522 expectationSeries []*LogicRunnerMockHandleValidationResultsMessageExpectation 523 } 524 525 type LogicRunnerMockHandleValidationResultsMessageExpectation struct { 526 input *LogicRunnerMockHandleValidationResultsMessageInput 527 result *LogicRunnerMockHandleValidationResultsMessageResult 528 } 529 530 type LogicRunnerMockHandleValidationResultsMessageInput struct { 531 p context.Context 532 p1 core.Parcel 533 } 534 535 type LogicRunnerMockHandleValidationResultsMessageResult struct { 536 r core.Reply 537 r1 error 538 } 539 540 //Expect specifies that invocation of LogicRunner.HandleValidationResultsMessage is expected from 1 to Infinity times 541 func (m *mLogicRunnerMockHandleValidationResultsMessage) Expect(p context.Context, p1 core.Parcel) *mLogicRunnerMockHandleValidationResultsMessage { 542 m.mock.HandleValidationResultsMessageFunc = nil 543 m.expectationSeries = nil 544 545 if m.mainExpectation == nil { 546 m.mainExpectation = &LogicRunnerMockHandleValidationResultsMessageExpectation{} 547 } 548 m.mainExpectation.input = &LogicRunnerMockHandleValidationResultsMessageInput{p, p1} 549 return m 550 } 551 552 //Return specifies results of invocation of LogicRunner.HandleValidationResultsMessage 553 func (m *mLogicRunnerMockHandleValidationResultsMessage) Return(r core.Reply, r1 error) *LogicRunnerMock { 554 m.mock.HandleValidationResultsMessageFunc = nil 555 m.expectationSeries = nil 556 557 if m.mainExpectation == nil { 558 m.mainExpectation = &LogicRunnerMockHandleValidationResultsMessageExpectation{} 559 } 560 m.mainExpectation.result = &LogicRunnerMockHandleValidationResultsMessageResult{r, r1} 561 return m.mock 562 } 563 564 //ExpectOnce specifies that invocation of LogicRunner.HandleValidationResultsMessage is expected once 565 func (m *mLogicRunnerMockHandleValidationResultsMessage) ExpectOnce(p context.Context, p1 core.Parcel) *LogicRunnerMockHandleValidationResultsMessageExpectation { 566 m.mock.HandleValidationResultsMessageFunc = nil 567 m.mainExpectation = nil 568 569 expectation := &LogicRunnerMockHandleValidationResultsMessageExpectation{} 570 expectation.input = &LogicRunnerMockHandleValidationResultsMessageInput{p, p1} 571 m.expectationSeries = append(m.expectationSeries, expectation) 572 return expectation 573 } 574 575 func (e *LogicRunnerMockHandleValidationResultsMessageExpectation) Return(r core.Reply, r1 error) { 576 e.result = &LogicRunnerMockHandleValidationResultsMessageResult{r, r1} 577 } 578 579 //Set uses given function f as a mock of LogicRunner.HandleValidationResultsMessage method 580 func (m *mLogicRunnerMockHandleValidationResultsMessage) Set(f func(p context.Context, p1 core.Parcel) (r core.Reply, r1 error)) *LogicRunnerMock { 581 m.mainExpectation = nil 582 m.expectationSeries = nil 583 584 m.mock.HandleValidationResultsMessageFunc = f 585 return m.mock 586 } 587 588 //HandleValidationResultsMessage implements github.com/insolar/insolar/core.LogicRunner interface 589 func (m *LogicRunnerMock) HandleValidationResultsMessage(p context.Context, p1 core.Parcel) (r core.Reply, r1 error) { 590 counter := atomic.AddUint64(&m.HandleValidationResultsMessagePreCounter, 1) 591 defer atomic.AddUint64(&m.HandleValidationResultsMessageCounter, 1) 592 593 if len(m.HandleValidationResultsMessageMock.expectationSeries) > 0 { 594 if counter > uint64(len(m.HandleValidationResultsMessageMock.expectationSeries)) { 595 m.t.Fatalf("Unexpected call to LogicRunnerMock.HandleValidationResultsMessage. %v %v", p, p1) 596 return 597 } 598 599 input := m.HandleValidationResultsMessageMock.expectationSeries[counter-1].input 600 testify_assert.Equal(m.t, *input, LogicRunnerMockHandleValidationResultsMessageInput{p, p1}, "LogicRunner.HandleValidationResultsMessage got unexpected parameters") 601 602 result := m.HandleValidationResultsMessageMock.expectationSeries[counter-1].result 603 if result == nil { 604 m.t.Fatal("No results are set for the LogicRunnerMock.HandleValidationResultsMessage") 605 return 606 } 607 608 r = result.r 609 r1 = result.r1 610 611 return 612 } 613 614 if m.HandleValidationResultsMessageMock.mainExpectation != nil { 615 616 input := m.HandleValidationResultsMessageMock.mainExpectation.input 617 if input != nil { 618 testify_assert.Equal(m.t, *input, LogicRunnerMockHandleValidationResultsMessageInput{p, p1}, "LogicRunner.HandleValidationResultsMessage got unexpected parameters") 619 } 620 621 result := m.HandleValidationResultsMessageMock.mainExpectation.result 622 if result == nil { 623 m.t.Fatal("No results are set for the LogicRunnerMock.HandleValidationResultsMessage") 624 } 625 626 r = result.r 627 r1 = result.r1 628 629 return 630 } 631 632 if m.HandleValidationResultsMessageFunc == nil { 633 m.t.Fatalf("Unexpected call to LogicRunnerMock.HandleValidationResultsMessage. %v %v", p, p1) 634 return 635 } 636 637 return m.HandleValidationResultsMessageFunc(p, p1) 638 } 639 640 //HandleValidationResultsMessageMinimockCounter returns a count of LogicRunnerMock.HandleValidationResultsMessageFunc invocations 641 func (m *LogicRunnerMock) HandleValidationResultsMessageMinimockCounter() uint64 { 642 return atomic.LoadUint64(&m.HandleValidationResultsMessageCounter) 643 } 644 645 //HandleValidationResultsMessageMinimockPreCounter returns the value of LogicRunnerMock.HandleValidationResultsMessage invocations 646 func (m *LogicRunnerMock) HandleValidationResultsMessageMinimockPreCounter() uint64 { 647 return atomic.LoadUint64(&m.HandleValidationResultsMessagePreCounter) 648 } 649 650 //HandleValidationResultsMessageFinished returns true if mock invocations count is ok 651 func (m *LogicRunnerMock) HandleValidationResultsMessageFinished() bool { 652 // if expectation series were set then invocations count should be equal to expectations count 653 if len(m.HandleValidationResultsMessageMock.expectationSeries) > 0 { 654 return atomic.LoadUint64(&m.HandleValidationResultsMessageCounter) == uint64(len(m.HandleValidationResultsMessageMock.expectationSeries)) 655 } 656 657 // if main expectation was set then invocations count should be greater than zero 658 if m.HandleValidationResultsMessageMock.mainExpectation != nil { 659 return atomic.LoadUint64(&m.HandleValidationResultsMessageCounter) > 0 660 } 661 662 // if func was set then invocations count should be greater than zero 663 if m.HandleValidationResultsMessageFunc != nil { 664 return atomic.LoadUint64(&m.HandleValidationResultsMessageCounter) > 0 665 } 666 667 return true 668 } 669 670 type mLogicRunnerMockOnPulse struct { 671 mock *LogicRunnerMock 672 mainExpectation *LogicRunnerMockOnPulseExpectation 673 expectationSeries []*LogicRunnerMockOnPulseExpectation 674 } 675 676 type LogicRunnerMockOnPulseExpectation struct { 677 input *LogicRunnerMockOnPulseInput 678 result *LogicRunnerMockOnPulseResult 679 } 680 681 type LogicRunnerMockOnPulseInput struct { 682 p context.Context 683 p1 core.Pulse 684 } 685 686 type LogicRunnerMockOnPulseResult struct { 687 r error 688 } 689 690 //Expect specifies that invocation of LogicRunner.OnPulse is expected from 1 to Infinity times 691 func (m *mLogicRunnerMockOnPulse) Expect(p context.Context, p1 core.Pulse) *mLogicRunnerMockOnPulse { 692 m.mock.OnPulseFunc = nil 693 m.expectationSeries = nil 694 695 if m.mainExpectation == nil { 696 m.mainExpectation = &LogicRunnerMockOnPulseExpectation{} 697 } 698 m.mainExpectation.input = &LogicRunnerMockOnPulseInput{p, p1} 699 return m 700 } 701 702 //Return specifies results of invocation of LogicRunner.OnPulse 703 func (m *mLogicRunnerMockOnPulse) Return(r error) *LogicRunnerMock { 704 m.mock.OnPulseFunc = nil 705 m.expectationSeries = nil 706 707 if m.mainExpectation == nil { 708 m.mainExpectation = &LogicRunnerMockOnPulseExpectation{} 709 } 710 m.mainExpectation.result = &LogicRunnerMockOnPulseResult{r} 711 return m.mock 712 } 713 714 //ExpectOnce specifies that invocation of LogicRunner.OnPulse is expected once 715 func (m *mLogicRunnerMockOnPulse) ExpectOnce(p context.Context, p1 core.Pulse) *LogicRunnerMockOnPulseExpectation { 716 m.mock.OnPulseFunc = nil 717 m.mainExpectation = nil 718 719 expectation := &LogicRunnerMockOnPulseExpectation{} 720 expectation.input = &LogicRunnerMockOnPulseInput{p, p1} 721 m.expectationSeries = append(m.expectationSeries, expectation) 722 return expectation 723 } 724 725 func (e *LogicRunnerMockOnPulseExpectation) Return(r error) { 726 e.result = &LogicRunnerMockOnPulseResult{r} 727 } 728 729 //Set uses given function f as a mock of LogicRunner.OnPulse method 730 func (m *mLogicRunnerMockOnPulse) Set(f func(p context.Context, p1 core.Pulse) (r error)) *LogicRunnerMock { 731 m.mainExpectation = nil 732 m.expectationSeries = nil 733 734 m.mock.OnPulseFunc = f 735 return m.mock 736 } 737 738 //OnPulse implements github.com/insolar/insolar/core.LogicRunner interface 739 func (m *LogicRunnerMock) OnPulse(p context.Context, p1 core.Pulse) (r error) { 740 counter := atomic.AddUint64(&m.OnPulsePreCounter, 1) 741 defer atomic.AddUint64(&m.OnPulseCounter, 1) 742 743 if len(m.OnPulseMock.expectationSeries) > 0 { 744 if counter > uint64(len(m.OnPulseMock.expectationSeries)) { 745 m.t.Fatalf("Unexpected call to LogicRunnerMock.OnPulse. %v %v", p, p1) 746 return 747 } 748 749 input := m.OnPulseMock.expectationSeries[counter-1].input 750 testify_assert.Equal(m.t, *input, LogicRunnerMockOnPulseInput{p, p1}, "LogicRunner.OnPulse got unexpected parameters") 751 752 result := m.OnPulseMock.expectationSeries[counter-1].result 753 if result == nil { 754 m.t.Fatal("No results are set for the LogicRunnerMock.OnPulse") 755 return 756 } 757 758 r = result.r 759 760 return 761 } 762 763 if m.OnPulseMock.mainExpectation != nil { 764 765 input := m.OnPulseMock.mainExpectation.input 766 if input != nil { 767 testify_assert.Equal(m.t, *input, LogicRunnerMockOnPulseInput{p, p1}, "LogicRunner.OnPulse got unexpected parameters") 768 } 769 770 result := m.OnPulseMock.mainExpectation.result 771 if result == nil { 772 m.t.Fatal("No results are set for the LogicRunnerMock.OnPulse") 773 } 774 775 r = result.r 776 777 return 778 } 779 780 if m.OnPulseFunc == nil { 781 m.t.Fatalf("Unexpected call to LogicRunnerMock.OnPulse. %v %v", p, p1) 782 return 783 } 784 785 return m.OnPulseFunc(p, p1) 786 } 787 788 //OnPulseMinimockCounter returns a count of LogicRunnerMock.OnPulseFunc invocations 789 func (m *LogicRunnerMock) OnPulseMinimockCounter() uint64 { 790 return atomic.LoadUint64(&m.OnPulseCounter) 791 } 792 793 //OnPulseMinimockPreCounter returns the value of LogicRunnerMock.OnPulse invocations 794 func (m *LogicRunnerMock) OnPulseMinimockPreCounter() uint64 { 795 return atomic.LoadUint64(&m.OnPulsePreCounter) 796 } 797 798 //OnPulseFinished returns true if mock invocations count is ok 799 func (m *LogicRunnerMock) OnPulseFinished() bool { 800 // if expectation series were set then invocations count should be equal to expectations count 801 if len(m.OnPulseMock.expectationSeries) > 0 { 802 return atomic.LoadUint64(&m.OnPulseCounter) == uint64(len(m.OnPulseMock.expectationSeries)) 803 } 804 805 // if main expectation was set then invocations count should be greater than zero 806 if m.OnPulseMock.mainExpectation != nil { 807 return atomic.LoadUint64(&m.OnPulseCounter) > 0 808 } 809 810 // if func was set then invocations count should be greater than zero 811 if m.OnPulseFunc != nil { 812 return atomic.LoadUint64(&m.OnPulseCounter) > 0 813 } 814 815 return true 816 } 817 818 //ValidateCallCounters checks that all mocked methods of the interface have been called at least once 819 //Deprecated: please use MinimockFinish method or use Finish method of minimock.Controller 820 func (m *LogicRunnerMock) ValidateCallCounters() { 821 822 if !m.ExecuteFinished() { 823 m.t.Fatal("Expected call to LogicRunnerMock.Execute") 824 } 825 826 if !m.HandleExecutorResultsMessageFinished() { 827 m.t.Fatal("Expected call to LogicRunnerMock.HandleExecutorResultsMessage") 828 } 829 830 if !m.HandleValidateCaseBindMessageFinished() { 831 m.t.Fatal("Expected call to LogicRunnerMock.HandleValidateCaseBindMessage") 832 } 833 834 if !m.HandleValidationResultsMessageFinished() { 835 m.t.Fatal("Expected call to LogicRunnerMock.HandleValidationResultsMessage") 836 } 837 838 if !m.OnPulseFinished() { 839 m.t.Fatal("Expected call to LogicRunnerMock.OnPulse") 840 } 841 842 } 843 844 //CheckMocksCalled checks that all mocked methods of the interface have been called at least once 845 //Deprecated: please use MinimockFinish method or use Finish method of minimock.Controller 846 func (m *LogicRunnerMock) CheckMocksCalled() { 847 m.Finish() 848 } 849 850 //Finish checks that all mocked methods of the interface have been called at least once 851 //Deprecated: please use MinimockFinish or use Finish method of minimock.Controller 852 func (m *LogicRunnerMock) Finish() { 853 m.MinimockFinish() 854 } 855 856 //MinimockFinish checks that all mocked methods of the interface have been called at least once 857 func (m *LogicRunnerMock) MinimockFinish() { 858 859 if !m.ExecuteFinished() { 860 m.t.Fatal("Expected call to LogicRunnerMock.Execute") 861 } 862 863 if !m.HandleExecutorResultsMessageFinished() { 864 m.t.Fatal("Expected call to LogicRunnerMock.HandleExecutorResultsMessage") 865 } 866 867 if !m.HandleValidateCaseBindMessageFinished() { 868 m.t.Fatal("Expected call to LogicRunnerMock.HandleValidateCaseBindMessage") 869 } 870 871 if !m.HandleValidationResultsMessageFinished() { 872 m.t.Fatal("Expected call to LogicRunnerMock.HandleValidationResultsMessage") 873 } 874 875 if !m.OnPulseFinished() { 876 m.t.Fatal("Expected call to LogicRunnerMock.OnPulse") 877 } 878 879 } 880 881 //Wait waits for all mocked methods to be called at least once 882 //Deprecated: please use MinimockWait or use Wait method of minimock.Controller 883 func (m *LogicRunnerMock) Wait(timeout time.Duration) { 884 m.MinimockWait(timeout) 885 } 886 887 //MinimockWait waits for all mocked methods to be called at least once 888 //this method is called by minimock.Controller 889 func (m *LogicRunnerMock) MinimockWait(timeout time.Duration) { 890 timeoutCh := time.After(timeout) 891 for { 892 ok := true 893 ok = ok && m.ExecuteFinished() 894 ok = ok && m.HandleExecutorResultsMessageFinished() 895 ok = ok && m.HandleValidateCaseBindMessageFinished() 896 ok = ok && m.HandleValidationResultsMessageFinished() 897 ok = ok && m.OnPulseFinished() 898 899 if ok { 900 return 901 } 902 903 select { 904 case <-timeoutCh: 905 906 if !m.ExecuteFinished() { 907 m.t.Error("Expected call to LogicRunnerMock.Execute") 908 } 909 910 if !m.HandleExecutorResultsMessageFinished() { 911 m.t.Error("Expected call to LogicRunnerMock.HandleExecutorResultsMessage") 912 } 913 914 if !m.HandleValidateCaseBindMessageFinished() { 915 m.t.Error("Expected call to LogicRunnerMock.HandleValidateCaseBindMessage") 916 } 917 918 if !m.HandleValidationResultsMessageFinished() { 919 m.t.Error("Expected call to LogicRunnerMock.HandleValidationResultsMessage") 920 } 921 922 if !m.OnPulseFinished() { 923 m.t.Error("Expected call to LogicRunnerMock.OnPulse") 924 } 925 926 m.t.Fatalf("Some mocks were not called on time: %s", timeout) 927 return 928 default: 929 time.Sleep(time.Millisecond) 930 } 931 } 932 } 933 934 //AllMocksCalled returns true if all mocked methods were called before the execution of AllMocksCalled, 935 //it can be used with assert/require, i.e. assert.True(mock.AllMocksCalled()) 936 func (m *LogicRunnerMock) AllMocksCalled() bool { 937 938 if !m.ExecuteFinished() { 939 return false 940 } 941 942 if !m.HandleExecutorResultsMessageFinished() { 943 return false 944 } 945 946 if !m.HandleValidateCaseBindMessageFinished() { 947 return false 948 } 949 950 if !m.HandleValidationResultsMessageFinished() { 951 return false 952 } 953 954 if !m.OnPulseFinished() { 955 return false 956 } 957 958 return true 959 }