vendor/github.com/stretchr/testify/mock/mock_test.go

   1 package mock
   2
   3 import (
   4         "errors"
   5         "sync"
   6         "testing"
   7         "time"
   8
   9         "github.com/stretchr/testify/assert"
  10         "github.com/stretchr/testify/require"
  11 )
  12
  13 /*
  14         Test objects
  15 */
  16
  17 // ExampleInterface represents an example interface.
  18 type ExampleInterface interface {
  19         TheExampleMethod(a, b, c int) (int, error)
  20 }
  21
  22 // TestExampleImplementation is a test implementation of ExampleInterface
  23 type TestExampleImplementation struct {
  24         Mock
  25 }
  26
  27 func (i *TestExampleImplementation) TheExampleMethod(a, b, c int) (int, error) {
  28         args := i.Called(a, b, c)
  29         return args.Int(0), errors.New("Whoops")
  30 }
  31
  32 func (i *TestExampleImplementation) TheExampleMethod2(yesorno bool) {
  33         i.Called(yesorno)
  34 }
  35
  36 type ExampleType struct {
  37         ran bool
  38 }
  39
  40 func (i *TestExampleImplementation) TheExampleMethod3(et *ExampleType) error {
  41         args := i.Called(et)
  42         return args.Error(0)
  43 }
  44
  45 func (i *TestExampleImplementation) TheExampleMethodFunc(fn func(string) error) error {
  46         args := i.Called(fn)
  47         return args.Error(0)
  48 }
  49
  50 func (i *TestExampleImplementation) TheExampleMethodVariadic(a ...int) error {
  51         args := i.Called(a)
  52         return args.Error(0)
  53 }
  54
  55 func (i *TestExampleImplementation) TheExampleMethodVariadicInterface(a ...interface{}) error {
  56         args := i.Called(a)
  57         return args.Error(0)
  58 }
  59
  60 func (i *TestExampleImplementation) TheExampleMethodMixedVariadic(a int, b ...int) error {
  61         args := i.Called(a, b)
  62         return args.Error(0)
  63 }
  64
  65 type ExampleFuncType func(string) error
  66
  67 func (i *TestExampleImplementation) TheExampleMethodFuncType(fn ExampleFuncType) error {
  68         args := i.Called(fn)
  69         return args.Error(0)
  70 }
  71
  72 /*
  73         Mock
  74 */
  75
  76 func Test_Mock_TestData(t *testing.T) {
  77
  78         var mockedService = new(TestExampleImplementation)
  79
  80         if assert.NotNil(t, mockedService.TestData()) {
  81
  82                 mockedService.TestData().Set("something", 123)
  83                 assert.Equal(t, 123, mockedService.TestData().Get("something").Data())
  84         }
  85 }
  86
  87 func Test_Mock_On(t *testing.T) {
  88
  89         // make a test impl object
  90         var mockedService = new(TestExampleImplementation)
  91
  92         c := mockedService.On("TheExampleMethod")
  93         assert.Equal(t, []*Call{c}, mockedService.ExpectedCalls)
  94         assert.Equal(t, "TheExampleMethod", c.Method)
  95 }
  96
  97 func Test_Mock_Chained_On(t *testing.T) {
  98         // make a test impl object
  99         var mockedService = new(TestExampleImplementation)
 100
 101         mockedService.
 102                 On("TheExampleMethod", 1, 2, 3).
 103                 Return(0).
 104                 On("TheExampleMethod3", AnythingOfType("*mock.ExampleType")).
 105                 Return(nil)
 106
 107         expectedCalls := []*Call{
 108                 &Call{
 109                         Parent:          &mockedService.Mock,
 110                         Method:          "TheExampleMethod",
 111                         Arguments:       []interface{}{1, 2, 3},
 112                         ReturnArguments: []interface{}{0},
 113                 },
 114                 &Call{
 115                         Parent:          &mockedService.Mock,
 116                         Method:          "TheExampleMethod3",
 117                         Arguments:       []interface{}{AnythingOfType("*mock.ExampleType")},
 118                         ReturnArguments: []interface{}{nil},
 119                 },
 120         }
 121         assert.Equal(t, expectedCalls, mockedService.ExpectedCalls)
 122 }
 123
 124 func Test_Mock_On_WithArgs(t *testing.T) {
 125
 126         // make a test impl object
 127         var mockedService = new(TestExampleImplementation)
 128
 129         c := mockedService.On("TheExampleMethod", 1, 2, 3, 4)
 130
 131         assert.Equal(t, []*Call{c}, mockedService.ExpectedCalls)
 132         assert.Equal(t, "TheExampleMethod", c.Method)
 133         assert.Equal(t, Arguments{1, 2, 3, 4}, c.Arguments)
 134 }
 135
 136 func Test_Mock_On_WithFuncArg(t *testing.T) {
 137
 138         // make a test impl object
 139         var mockedService = new(TestExampleImplementation)
 140
 141         c := mockedService.
 142                 On("TheExampleMethodFunc", AnythingOfType("func(string) error")).
 143                 Return(nil)
 144
 145         assert.Equal(t, []*Call{c}, mockedService.ExpectedCalls)
 146         assert.Equal(t, "TheExampleMethodFunc", c.Method)
 147         assert.Equal(t, 1, len(c.Arguments))
 148         assert.Equal(t, AnythingOfType("func(string) error"), c.Arguments[0])
 149
 150         fn := func(string) error { return nil }
 151
 152         assert.NotPanics(t, func() {
 153                 mockedService.TheExampleMethodFunc(fn)
 154         })
 155 }
 156
 157 func Test_Mock_On_WithIntArgMatcher(t *testing.T) {
 158         var mockedService TestExampleImplementation
 159
 160         mockedService.On("TheExampleMethod",
 161                 MatchedBy(func(a int) bool {
 162                         return a == 1
 163                 }), MatchedBy(func(b int) bool {
 164                         return b == 2
 165                 }), MatchedBy(func(c int) bool {
 166                         return c == 3
 167                 })).Return(0, nil)
 168
 169         assert.Panics(t, func() {
 170                 mockedService.TheExampleMethod(1, 2, 4)
 171         })
 172         assert.Panics(t, func() {
 173                 mockedService.TheExampleMethod(2, 2, 3)
 174         })
 175         assert.NotPanics(t, func() {
 176                 mockedService.TheExampleMethod(1, 2, 3)
 177         })
 178 }
 179
 180 func Test_Mock_On_WithPtrArgMatcher(t *testing.T) {
 181         var mockedService TestExampleImplementation
 182
 183         mockedService.On("TheExampleMethod3",
 184                 MatchedBy(func(a *ExampleType) bool { return a.ran == true }),
 185         ).Return(nil)
 186
 187         mockedService.On("TheExampleMethod3",
 188                 MatchedBy(func(a *ExampleType) bool { return a.ran == false }),
 189         ).Return(errors.New("error"))
 190
 191         assert.Equal(t, mockedService.TheExampleMethod3(&ExampleType{true}), nil)
 192         assert.EqualError(t, mockedService.TheExampleMethod3(&ExampleType{false}), "error")
 193 }
 194
 195 func Test_Mock_On_WithFuncArgMatcher(t *testing.T) {
 196         var mockedService TestExampleImplementation
 197
 198         fixture1, fixture2 := errors.New("fixture1"), errors.New("fixture2")
 199
 200         mockedService.On("TheExampleMethodFunc",
 201                 MatchedBy(func(a func(string) error) bool { return a("string") == fixture1 }),
 202         ).Return(errors.New("fixture1"))
 203
 204         mockedService.On("TheExampleMethodFunc",
 205                 MatchedBy(func(a func(string) error) bool { return a("string") == fixture2 }),
 206         ).Return(errors.New("fixture2"))
 207
 208         assert.EqualError(t, mockedService.TheExampleMethodFunc(
 209                 func(string) error { return fixture1 }), "fixture1")
 210         assert.EqualError(t, mockedService.TheExampleMethodFunc(
 211                 func(string) error { return fixture2 }), "fixture2")
 212 }
 213
 214 func Test_Mock_On_WithVariadicFunc(t *testing.T) {
 215
 216         // make a test impl object
 217         var mockedService = new(TestExampleImplementation)
 218
 219         c := mockedService.
 220                 On("TheExampleMethodVariadic", []int{1, 2, 3}).
 221                 Return(nil)
 222
 223         assert.Equal(t, []*Call{c}, mockedService.ExpectedCalls)
 224         assert.Equal(t, 1, len(c.Arguments))
 225         assert.Equal(t, []int{1, 2, 3}, c.Arguments[0])
 226
 227         assert.NotPanics(t, func() {
 228                 mockedService.TheExampleMethodVariadic(1, 2, 3)
 229         })
 230         assert.Panics(t, func() {
 231                 mockedService.TheExampleMethodVariadic(1, 2)
 232         })
 233
 234 }
 235
 236 func Test_Mock_On_WithMixedVariadicFunc(t *testing.T) {
 237
 238         // make a test impl object
 239         var mockedService = new(TestExampleImplementation)
 240
 241         c := mockedService.
 242                 On("TheExampleMethodMixedVariadic", 1, []int{2, 3, 4}).
 243                 Return(nil)
 244
 245         assert.Equal(t, []*Call{c}, mockedService.ExpectedCalls)
 246         assert.Equal(t, 2, len(c.Arguments))
 247         assert.Equal(t, 1, c.Arguments[0])
 248         assert.Equal(t, []int{2, 3, 4}, c.Arguments[1])
 249
 250         assert.NotPanics(t, func() {
 251                 mockedService.TheExampleMethodMixedVariadic(1, 2, 3, 4)
 252         })
 253         assert.Panics(t, func() {
 254                 mockedService.TheExampleMethodMixedVariadic(1, 2, 3, 5)
 255         })
 256
 257 }
 258
 259 func Test_Mock_On_WithVariadicFuncWithInterface(t *testing.T) {
 260
 261         // make a test impl object
 262         var mockedService = new(TestExampleImplementation)
 263
 264         c := mockedService.On("TheExampleMethodVariadicInterface", []interface{}{1, 2, 3}).
 265                 Return(nil)
 266
 267         assert.Equal(t, []*Call{c}, mockedService.ExpectedCalls)
 268         assert.Equal(t, 1, len(c.Arguments))
 269         assert.Equal(t, []interface{}{1, 2, 3}, c.Arguments[0])
 270
 271         assert.NotPanics(t, func() {
 272                 mockedService.TheExampleMethodVariadicInterface(1, 2, 3)
 273         })
 274         assert.Panics(t, func() {
 275                 mockedService.TheExampleMethodVariadicInterface(1, 2)
 276         })
 277
 278 }
 279
 280 func Test_Mock_On_WithVariadicFuncWithEmptyInterfaceArray(t *testing.T) {
 281
 282         // make a test impl object
 283         var mockedService = new(TestExampleImplementation)
 284
 285         var expected []interface{}
 286         c := mockedService.
 287                 On("TheExampleMethodVariadicInterface", expected).
 288                 Return(nil)
 289
 290         assert.Equal(t, []*Call{c}, mockedService.ExpectedCalls)
 291         assert.Equal(t, 1, len(c.Arguments))
 292         assert.Equal(t, expected, c.Arguments[0])
 293
 294         assert.NotPanics(t, func() {
 295                 mockedService.TheExampleMethodVariadicInterface()
 296         })
 297         assert.Panics(t, func() {
 298                 mockedService.TheExampleMethodVariadicInterface(1, 2)
 299         })
 300
 301 }
 302
 303 func Test_Mock_On_WithFuncPanics(t *testing.T) {
 304         // make a test impl object
 305         var mockedService = new(TestExampleImplementation)
 306
 307         assert.Panics(t, func() {
 308                 mockedService.On("TheExampleMethodFunc", func(string) error { return nil })
 309         })
 310 }
 311
 312 func Test_Mock_On_WithFuncTypeArg(t *testing.T) {
 313
 314         // make a test impl object
 315         var mockedService = new(TestExampleImplementation)
 316
 317         c := mockedService.
 318                 On("TheExampleMethodFuncType", AnythingOfType("mock.ExampleFuncType")).
 319                 Return(nil)
 320
 321         assert.Equal(t, []*Call{c}, mockedService.ExpectedCalls)
 322         assert.Equal(t, 1, len(c.Arguments))
 323         assert.Equal(t, AnythingOfType("mock.ExampleFuncType"), c.Arguments[0])
 324
 325         fn := func(string) error { return nil }
 326         assert.NotPanics(t, func() {
 327                 mockedService.TheExampleMethodFuncType(fn)
 328         })
 329 }
 330
 331 func Test_Mock_Return(t *testing.T) {
 332
 333         // make a test impl object
 334         var mockedService = new(TestExampleImplementation)
 335
 336         c := mockedService.
 337                 On("TheExampleMethod", "A", "B", true).
 338                 Return(1, "two", true)
 339
 340         require.Equal(t, []*Call{c}, mockedService.ExpectedCalls)
 341
 342         call := mockedService.ExpectedCalls[0]
 343
 344         assert.Equal(t, "TheExampleMethod", call.Method)
 345         assert.Equal(t, "A", call.Arguments[0])
 346         assert.Equal(t, "B", call.Arguments[1])
 347         assert.Equal(t, true, call.Arguments[2])
 348         assert.Equal(t, 1, call.ReturnArguments[0])
 349         assert.Equal(t, "two", call.ReturnArguments[1])
 350         assert.Equal(t, true, call.ReturnArguments[2])
 351         assert.Equal(t, 0, call.Repeatability)
 352         assert.Nil(t, call.WaitFor)
 353 }
 354
 355 func Test_Mock_Return_WaitUntil(t *testing.T) {
 356
 357         // make a test impl object
 358         var mockedService = new(TestExampleImplementation)
 359         ch := time.After(time.Second)
 360
 361         c := mockedService.Mock.
 362                 On("TheExampleMethod", "A", "B", true).
 363                 WaitUntil(ch).
 364                 Return(1, "two", true)
 365
 366         // assert that the call was created
 367         require.Equal(t, []*Call{c}, mockedService.ExpectedCalls)
 368
 369         call := mockedService.ExpectedCalls[0]
 370
 371         assert.Equal(t, "TheExampleMethod", call.Method)
 372         assert.Equal(t, "A", call.Arguments[0])
 373         assert.Equal(t, "B", call.Arguments[1])
 374         assert.Equal(t, true, call.Arguments[2])
 375         assert.Equal(t, 1, call.ReturnArguments[0])
 376         assert.Equal(t, "two", call.ReturnArguments[1])
 377         assert.Equal(t, true, call.ReturnArguments[2])
 378         assert.Equal(t, 0, call.Repeatability)
 379         assert.Equal(t, ch, call.WaitFor)
 380 }
 381
 382 func Test_Mock_Return_After(t *testing.T) {
 383
 384         // make a test impl object
 385         var mockedService = new(TestExampleImplementation)
 386
 387         c := mockedService.Mock.
 388                 On("TheExampleMethod", "A", "B", true).
 389                 Return(1, "two", true).
 390                 After(time.Second)
 391
 392         require.Equal(t, []*Call{c}, mockedService.ExpectedCalls)
 393
 394         call := mockedService.Mock.ExpectedCalls[0]
 395
 396         assert.Equal(t, "TheExampleMethod", call.Method)
 397         assert.Equal(t, "A", call.Arguments[0])
 398         assert.Equal(t, "B", call.Arguments[1])
 399         assert.Equal(t, true, call.Arguments[2])
 400         assert.Equal(t, 1, call.ReturnArguments[0])
 401         assert.Equal(t, "two", call.ReturnArguments[1])
 402         assert.Equal(t, true, call.ReturnArguments[2])
 403         assert.Equal(t, 0, call.Repeatability)
 404         assert.NotEqual(t, nil, call.WaitFor)
 405
 406 }
 407
 408 func Test_Mock_Return_Run(t *testing.T) {
 409
 410         // make a test impl object
 411         var mockedService = new(TestExampleImplementation)
 412
 413         fn := func(args Arguments) {
 414                 arg := args.Get(0).(*ExampleType)
 415                 arg.ran = true
 416         }
 417
 418         c := mockedService.Mock.
 419                 On("TheExampleMethod3", AnythingOfType("*mock.ExampleType")).
 420                 Return(nil).
 421                 Run(fn)
 422
 423         require.Equal(t, []*Call{c}, mockedService.ExpectedCalls)
 424
 425         call := mockedService.Mock.ExpectedCalls[0]
 426
 427         assert.Equal(t, "TheExampleMethod3", call.Method)
 428         assert.Equal(t, AnythingOfType("*mock.ExampleType"), call.Arguments[0])
 429         assert.Equal(t, nil, call.ReturnArguments[0])
 430         assert.Equal(t, 0, call.Repeatability)
 431         assert.NotEqual(t, nil, call.WaitFor)
 432         assert.NotNil(t, call.Run)
 433
 434         et := ExampleType{}
 435         assert.Equal(t, false, et.ran)
 436         mockedService.TheExampleMethod3(&et)
 437         assert.Equal(t, true, et.ran)
 438 }
 439
 440 func Test_Mock_Return_Run_Out_Of_Order(t *testing.T) {
 441         // make a test impl object
 442         var mockedService = new(TestExampleImplementation)
 443         f := func(args Arguments) {
 444                 arg := args.Get(0).(*ExampleType)
 445                 arg.ran = true
 446         }
 447
 448         c := mockedService.Mock.
 449                 On("TheExampleMethod3", AnythingOfType("*mock.ExampleType")).
 450                 Run(f).
 451                 Return(nil)
 452
 453         require.Equal(t, []*Call{c}, mockedService.ExpectedCalls)
 454
 455         call := mockedService.Mock.ExpectedCalls[0]
 456
 457         assert.Equal(t, "TheExampleMethod3", call.Method)
 458         assert.Equal(t, AnythingOfType("*mock.ExampleType"), call.Arguments[0])
 459         assert.Equal(t, nil, call.ReturnArguments[0])
 460         assert.Equal(t, 0, call.Repeatability)
 461         assert.NotEqual(t, nil, call.WaitFor)
 462         assert.NotNil(t, call.Run)
 463 }
 464
 465 func Test_Mock_Return_Once(t *testing.T) {
 466
 467         // make a test impl object
 468         var mockedService = new(TestExampleImplementation)
 469
 470         c := mockedService.On("TheExampleMethod", "A", "B", true).
 471                 Return(1, "two", true).
 472                 Once()
 473
 474         require.Equal(t, []*Call{c}, mockedService.ExpectedCalls)
 475
 476         call := mockedService.ExpectedCalls[0]
 477
 478         assert.Equal(t, "TheExampleMethod", call.Method)
 479         assert.Equal(t, "A", call.Arguments[0])
 480         assert.Equal(t, "B", call.Arguments[1])
 481         assert.Equal(t, true, call.Arguments[2])
 482         assert.Equal(t, 1, call.ReturnArguments[0])
 483         assert.Equal(t, "two", call.ReturnArguments[1])
 484         assert.Equal(t, true, call.ReturnArguments[2])
 485         assert.Equal(t, 1, call.Repeatability)
 486         assert.Nil(t, call.WaitFor)
 487 }
 488
 489 func Test_Mock_Return_Twice(t *testing.T) {
 490
 491         // make a test impl object
 492         var mockedService = new(TestExampleImplementation)
 493
 494         c := mockedService.
 495                 On("TheExampleMethod", "A", "B", true).
 496                 Return(1, "two", true).
 497                 Twice()
 498
 499         require.Equal(t, []*Call{c}, mockedService.ExpectedCalls)
 500
 501         call := mockedService.ExpectedCalls[0]
 502
 503         assert.Equal(t, "TheExampleMethod", call.Method)
 504         assert.Equal(t, "A", call.Arguments[0])
 505         assert.Equal(t, "B", call.Arguments[1])
 506         assert.Equal(t, true, call.Arguments[2])
 507         assert.Equal(t, 1, call.ReturnArguments[0])
 508         assert.Equal(t, "two", call.ReturnArguments[1])
 509         assert.Equal(t, true, call.ReturnArguments[2])
 510         assert.Equal(t, 2, call.Repeatability)
 511         assert.Nil(t, call.WaitFor)
 512 }
 513
 514 func Test_Mock_Return_Times(t *testing.T) {
 515
 516         // make a test impl object
 517         var mockedService = new(TestExampleImplementation)
 518
 519         c := mockedService.
 520                 On("TheExampleMethod", "A", "B", true).
 521                 Return(1, "two", true).
 522                 Times(5)
 523
 524         require.Equal(t, []*Call{c}, mockedService.ExpectedCalls)
 525
 526         call := mockedService.ExpectedCalls[0]
 527
 528         assert.Equal(t, "TheExampleMethod", call.Method)
 529         assert.Equal(t, "A", call.Arguments[0])
 530         assert.Equal(t, "B", call.Arguments[1])
 531         assert.Equal(t, true, call.Arguments[2])
 532         assert.Equal(t, 1, call.ReturnArguments[0])
 533         assert.Equal(t, "two", call.ReturnArguments[1])
 534         assert.Equal(t, true, call.ReturnArguments[2])
 535         assert.Equal(t, 5, call.Repeatability)
 536         assert.Nil(t, call.WaitFor)
 537 }
 538
 539 func Test_Mock_Return_Nothing(t *testing.T) {
 540
 541         // make a test impl object
 542         var mockedService = new(TestExampleImplementation)
 543
 544         c := mockedService.
 545                 On("TheExampleMethod", "A", "B", true).
 546                 Return()
 547
 548         require.Equal(t, []*Call{c}, mockedService.ExpectedCalls)
 549
 550         call := mockedService.ExpectedCalls[0]
 551
 552         assert.Equal(t, "TheExampleMethod", call.Method)
 553         assert.Equal(t, "A", call.Arguments[0])
 554         assert.Equal(t, "B", call.Arguments[1])
 555         assert.Equal(t, true, call.Arguments[2])
 556         assert.Equal(t, 0, len(call.ReturnArguments))
 557 }
 558
 559 func Test_Mock_findExpectedCall(t *testing.T) {
 560
 561         m := new(Mock)
 562         m.On("One", 1).Return("one")
 563         m.On("Two", 2).Return("two")
 564         m.On("Two", 3).Return("three")
 565
 566         f, c := m.findExpectedCall("Two", 3)
 567
 568         if assert.Equal(t, 2, f) {
 569                 if assert.NotNil(t, c) {
 570                         assert.Equal(t, "Two", c.Method)
 571                         assert.Equal(t, 3, c.Arguments[0])
 572                         assert.Equal(t, "three", c.ReturnArguments[0])
 573                 }
 574         }
 575
 576 }
 577
 578 func Test_Mock_findExpectedCall_For_Unknown_Method(t *testing.T) {
 579
 580         m := new(Mock)
 581         m.On("One", 1).Return("one")
 582         m.On("Two", 2).Return("two")
 583         m.On("Two", 3).Return("three")
 584
 585         f, _ := m.findExpectedCall("Two")
 586
 587         assert.Equal(t, -1, f)
 588
 589 }
 590
 591 func Test_Mock_findExpectedCall_Respects_Repeatability(t *testing.T) {
 592
 593         m := new(Mock)
 594         m.On("One", 1).Return("one")
 595         m.On("Two", 2).Return("two").Once()
 596         m.On("Two", 3).Return("three").Twice()
 597         m.On("Two", 3).Return("three").Times(8)
 598
 599         f, c := m.findExpectedCall("Two", 3)
 600
 601         if assert.Equal(t, 2, f) {
 602                 if assert.NotNil(t, c) {
 603                         assert.Equal(t, "Two", c.Method)
 604                         assert.Equal(t, 3, c.Arguments[0])
 605                         assert.Equal(t, "three", c.ReturnArguments[0])
 606                 }
 607         }
 608
 609 }
 610
 611 func Test_callString(t *testing.T) {
 612
 613         assert.Equal(t, `Method(int,bool,string)`, callString("Method", []interface{}{1, true, "something"}, false))
 614
 615 }
 616
 617 func Test_Mock_Called(t *testing.T) {
 618
 619         var mockedService = new(TestExampleImplementation)
 620
 621         mockedService.On("Test_Mock_Called", 1, 2, 3).Return(5, "6", true)
 622
 623         returnArguments := mockedService.Called(1, 2, 3)
 624
 625         if assert.Equal(t, 1, len(mockedService.Calls)) {
 626                 assert.Equal(t, "Test_Mock_Called", mockedService.Calls[0].Method)
 627                 assert.Equal(t, 1, mockedService.Calls[0].Arguments[0])
 628                 assert.Equal(t, 2, mockedService.Calls[0].Arguments[1])
 629                 assert.Equal(t, 3, mockedService.Calls[0].Arguments[2])
 630         }
 631
 632         if assert.Equal(t, 3, len(returnArguments)) {
 633                 assert.Equal(t, 5, returnArguments[0])
 634                 assert.Equal(t, "6", returnArguments[1])
 635                 assert.Equal(t, true, returnArguments[2])
 636         }
 637
 638 }
 639
 640 func asyncCall(m *Mock, ch chan Arguments) {
 641         ch <- m.Called(1, 2, 3)
 642 }
 643
 644 func Test_Mock_Called_blocks(t *testing.T) {
 645
 646         var mockedService = new(TestExampleImplementation)
 647
 648         mockedService.Mock.On("asyncCall", 1, 2, 3).Return(5, "6", true).After(2 * time.Millisecond)
 649
 650         ch := make(chan Arguments)
 651
 652         go asyncCall(&mockedService.Mock, ch)
 653
 654         select {
 655         case <-ch:
 656                 t.Fatal("should have waited")
 657         case <-time.After(1 * time.Millisecond):
 658         }
 659
 660         returnArguments := <-ch
 661
 662         if assert.Equal(t, 1, len(mockedService.Mock.Calls)) {
 663                 assert.Equal(t, "asyncCall", mockedService.Mock.Calls[0].Method)
 664                 assert.Equal(t, 1, mockedService.Mock.Calls[0].Arguments[0])
 665                 assert.Equal(t, 2, mockedService.Mock.Calls[0].Arguments[1])
 666                 assert.Equal(t, 3, mockedService.Mock.Calls[0].Arguments[2])
 667         }
 668
 669         if assert.Equal(t, 3, len(returnArguments)) {
 670                 assert.Equal(t, 5, returnArguments[0])
 671                 assert.Equal(t, "6", returnArguments[1])
 672                 assert.Equal(t, true, returnArguments[2])
 673         }
 674
 675 }
 676
 677 func Test_Mock_Called_For_Bounded_Repeatability(t *testing.T) {
 678
 679         var mockedService = new(TestExampleImplementation)
 680
 681         mockedService.
 682                 On("Test_Mock_Called_For_Bounded_Repeatability", 1, 2, 3).
 683                 Return(5, "6", true).
 684                 Once()
 685         mockedService.
 686                 On("Test_Mock_Called_For_Bounded_Repeatability", 1, 2, 3).
 687                 Return(-1, "hi", false)
 688
 689         returnArguments1 := mockedService.Called(1, 2, 3)
 690         returnArguments2 := mockedService.Called(1, 2, 3)
 691
 692         if assert.Equal(t, 2, len(mockedService.Calls)) {
 693                 assert.Equal(t, "Test_Mock_Called_For_Bounded_Repeatability", mockedService.Calls[0].Method)
 694                 assert.Equal(t, 1, mockedService.Calls[0].Arguments[0])
 695                 assert.Equal(t, 2, mockedService.Calls[0].Arguments[1])
 696                 assert.Equal(t, 3, mockedService.Calls[0].Arguments[2])
 697
 698                 assert.Equal(t, "Test_Mock_Called_For_Bounded_Repeatability", mockedService.Calls[1].Method)
 699                 assert.Equal(t, 1, mockedService.Calls[1].Arguments[0])
 700                 assert.Equal(t, 2, mockedService.Calls[1].Arguments[1])
 701                 assert.Equal(t, 3, mockedService.Calls[1].Arguments[2])
 702         }
 703
 704         if assert.Equal(t, 3, len(returnArguments1)) {
 705                 assert.Equal(t, 5, returnArguments1[0])
 706                 assert.Equal(t, "6", returnArguments1[1])
 707                 assert.Equal(t, true, returnArguments1[2])
 708         }
 709
 710         if assert.Equal(t, 3, len(returnArguments2)) {
 711                 assert.Equal(t, -1, returnArguments2[0])
 712                 assert.Equal(t, "hi", returnArguments2[1])
 713                 assert.Equal(t, false, returnArguments2[2])
 714         }
 715
 716 }
 717
 718 func Test_Mock_Called_For_SetTime_Expectation(t *testing.T) {
 719
 720         var mockedService = new(TestExampleImplementation)
 721
 722         mockedService.On("TheExampleMethod", 1, 2, 3).Return(5, "6", true).Times(4)
 723
 724         mockedService.TheExampleMethod(1, 2, 3)
 725         mockedService.TheExampleMethod(1, 2, 3)
 726         mockedService.TheExampleMethod(1, 2, 3)
 727         mockedService.TheExampleMethod(1, 2, 3)
 728         assert.Panics(t, func() {
 729                 mockedService.TheExampleMethod(1, 2, 3)
 730         })
 731
 732 }
 733
 734 func Test_Mock_Called_Unexpected(t *testing.T) {
 735
 736         var mockedService = new(TestExampleImplementation)
 737
 738         // make sure it panics if no expectation was made
 739         assert.Panics(t, func() {
 740                 mockedService.Called(1, 2, 3)
 741         }, "Calling unexpected method should panic")
 742
 743 }
 744
 745 func Test_AssertExpectationsForObjects_Helper(t *testing.T) {
 746
 747         var mockedService1 = new(TestExampleImplementation)
 748         var mockedService2 = new(TestExampleImplementation)
 749         var mockedService3 = new(TestExampleImplementation)
 750
 751         mockedService1.On("Test_AssertExpectationsForObjects_Helper", 1).Return()
 752         mockedService2.On("Test_AssertExpectationsForObjects_Helper", 2).Return()
 753         mockedService3.On("Test_AssertExpectationsForObjects_Helper", 3).Return()
 754
 755         mockedService1.Called(1)
 756         mockedService2.Called(2)
 757         mockedService3.Called(3)
 758
 759         assert.True(t, AssertExpectationsForObjects(t, &mockedService1.Mock, &mockedService2.Mock, &mockedService3.Mock))
 760         assert.True(t, AssertExpectationsForObjects(t, mockedService1, mockedService2, mockedService3))
 761
 762 }
 763
 764 func Test_AssertExpectationsForObjects_Helper_Failed(t *testing.T) {
 765
 766         var mockedService1 = new(TestExampleImplementation)
 767         var mockedService2 = new(TestExampleImplementation)
 768         var mockedService3 = new(TestExampleImplementation)
 769
 770         mockedService1.On("Test_AssertExpectationsForObjects_Helper_Failed", 1).Return()
 771         mockedService2.On("Test_AssertExpectationsForObjects_Helper_Failed", 2).Return()
 772         mockedService3.On("Test_AssertExpectationsForObjects_Helper_Failed", 3).Return()
 773
 774         mockedService1.Called(1)
 775         mockedService3.Called(3)
 776
 777         tt := new(testing.T)
 778         assert.False(t, AssertExpectationsForObjects(tt, &mockedService1.Mock, &mockedService2.Mock, &mockedService3.Mock))
 779         assert.False(t, AssertExpectationsForObjects(tt, mockedService1, mockedService2, mockedService3))
 780
 781 }
 782
 783 func Test_Mock_AssertExpectations(t *testing.T) {
 784
 785         var mockedService = new(TestExampleImplementation)
 786
 787         mockedService.On("Test_Mock_AssertExpectations", 1, 2, 3).Return(5, 6, 7)
 788
 789         tt := new(testing.T)
 790         assert.False(t, mockedService.AssertExpectations(tt))
 791
 792         // make the call now
 793         mockedService.Called(1, 2, 3)
 794
 795         // now assert expectations
 796         assert.True(t, mockedService.AssertExpectations(tt))
 797
 798 }
 799
 800 func Test_Mock_AssertExpectations_Placeholder_NoArgs(t *testing.T) {
 801
 802         var mockedService = new(TestExampleImplementation)
 803
 804         mockedService.On("Test_Mock_AssertExpectations_Placeholder_NoArgs").Return(5, 6, 7).Once()
 805         mockedService.On("Test_Mock_AssertExpectations_Placeholder_NoArgs").Return(7, 6, 5)
 806
 807         tt := new(testing.T)
 808         assert.False(t, mockedService.AssertExpectations(tt))
 809
 810         // make the call now
 811         mockedService.Called()
 812
 813         // now assert expectations
 814         assert.True(t, mockedService.AssertExpectations(tt))
 815
 816 }
 817
 818 func Test_Mock_AssertExpectations_Placeholder(t *testing.T) {
 819
 820         var mockedService = new(TestExampleImplementation)
 821
 822         mockedService.On("Test_Mock_AssertExpectations_Placeholder", 1, 2, 3).Return(5, 6, 7).Once()
 823         mockedService.On("Test_Mock_AssertExpectations_Placeholder", 3, 2, 1).Return(7, 6, 5)
 824
 825         tt := new(testing.T)
 826         assert.False(t, mockedService.AssertExpectations(tt))
 827
 828         // make the call now
 829         mockedService.Called(1, 2, 3)
 830
 831         // now assert expectations
 832         assert.False(t, mockedService.AssertExpectations(tt))
 833
 834         // make call to the second expectation
 835         mockedService.Called(3, 2, 1)
 836
 837         // now assert expectations again
 838         assert.True(t, mockedService.AssertExpectations(tt))
 839 }
 840
 841 func Test_Mock_AssertExpectations_With_Pointers(t *testing.T) {
 842
 843         var mockedService = new(TestExampleImplementation)
 844
 845         mockedService.On("Test_Mock_AssertExpectations_With_Pointers", &struct{ Foo int }{1}).Return(1)
 846         mockedService.On("Test_Mock_AssertExpectations_With_Pointers", &struct{ Foo int }{2}).Return(2)
 847
 848         tt := new(testing.T)
 849         assert.False(t, mockedService.AssertExpectations(tt))
 850
 851         s := struct{ Foo int }{1}
 852         // make the calls now
 853         mockedService.Called(&s)
 854         s.Foo = 2
 855         mockedService.Called(&s)
 856
 857         // now assert expectations
 858         assert.True(t, mockedService.AssertExpectations(tt))
 859
 860 }
 861
 862 func Test_Mock_AssertExpectationsCustomType(t *testing.T) {
 863
 864         var mockedService = new(TestExampleImplementation)
 865
 866         mockedService.On("TheExampleMethod3", AnythingOfType("*mock.ExampleType")).Return(nil).Once()
 867
 868         tt := new(testing.T)
 869         assert.False(t, mockedService.AssertExpectations(tt))
 870
 871         // make the call now
 872         mockedService.TheExampleMethod3(&ExampleType{})
 873
 874         // now assert expectations
 875         assert.True(t, mockedService.AssertExpectations(tt))
 876
 877 }
 878
 879 func Test_Mock_AssertExpectations_With_Repeatability(t *testing.T) {
 880
 881         var mockedService = new(TestExampleImplementation)
 882
 883         mockedService.On("Test_Mock_AssertExpectations_With_Repeatability", 1, 2, 3).Return(5, 6, 7).Twice()
 884
 885         tt := new(testing.T)
 886         assert.False(t, mockedService.AssertExpectations(tt))
 887
 888         // make the call now
 889         mockedService.Called(1, 2, 3)
 890
 891         assert.False(t, mockedService.AssertExpectations(tt))
 892
 893         mockedService.Called(1, 2, 3)
 894
 895         // now assert expectations
 896         assert.True(t, mockedService.AssertExpectations(tt))
 897
 898 }
 899
 900 func Test_Mock_TwoCallsWithDifferentArguments(t *testing.T) {
 901
 902         var mockedService = new(TestExampleImplementation)
 903
 904         mockedService.On("Test_Mock_TwoCallsWithDifferentArguments", 1, 2, 3).Return(5, 6, 7)
 905         mockedService.On("Test_Mock_TwoCallsWithDifferentArguments", 4, 5, 6).Return(5, 6, 7)
 906
 907         args1 := mockedService.Called(1, 2, 3)
 908         assert.Equal(t, 5, args1.Int(0))
 909         assert.Equal(t, 6, args1.Int(1))
 910         assert.Equal(t, 7, args1.Int(2))
 911
 912         args2 := mockedService.Called(4, 5, 6)
 913         assert.Equal(t, 5, args2.Int(0))
 914         assert.Equal(t, 6, args2.Int(1))
 915         assert.Equal(t, 7, args2.Int(2))
 916
 917 }
 918
 919 func Test_Mock_AssertNumberOfCalls(t *testing.T) {
 920
 921         var mockedService = new(TestExampleImplementation)
 922
 923         mockedService.On("Test_Mock_AssertNumberOfCalls", 1, 2, 3).Return(5, 6, 7)
 924
 925         mockedService.Called(1, 2, 3)
 926         assert.True(t, mockedService.AssertNumberOfCalls(t, "Test_Mock_AssertNumberOfCalls", 1))
 927
 928         mockedService.Called(1, 2, 3)
 929         assert.True(t, mockedService.AssertNumberOfCalls(t, "Test_Mock_AssertNumberOfCalls", 2))
 930
 931 }
 932
 933 func Test_Mock_AssertCalled(t *testing.T) {
 934
 935         var mockedService = new(TestExampleImplementation)
 936
 937         mockedService.On("Test_Mock_AssertCalled", 1, 2, 3).Return(5, 6, 7)
 938
 939         mockedService.Called(1, 2, 3)
 940
 941         assert.True(t, mockedService.AssertCalled(t, "Test_Mock_AssertCalled", 1, 2, 3))
 942
 943 }
 944
 945 func Test_Mock_AssertCalled_WithAnythingOfTypeArgument(t *testing.T) {
 946
 947         var mockedService = new(TestExampleImplementation)
 948
 949         mockedService.
 950                 On("Test_Mock_AssertCalled_WithAnythingOfTypeArgument", Anything, Anything, Anything).
 951                 Return()
 952
 953         mockedService.Called(1, "two", []uint8("three"))
 954
 955         assert.True(t, mockedService.AssertCalled(t, "Test_Mock_AssertCalled_WithAnythingOfTypeArgument", AnythingOfType("int"), AnythingOfType("string"), AnythingOfType("[]uint8")))
 956
 957 }
 958
 959 func Test_Mock_AssertCalled_WithArguments(t *testing.T) {
 960
 961         var mockedService = new(TestExampleImplementation)
 962
 963         mockedService.On("Test_Mock_AssertCalled_WithArguments", 1, 2, 3).Return(5, 6, 7)
 964
 965         mockedService.Called(1, 2, 3)
 966
 967         tt := new(testing.T)
 968         assert.True(t, mockedService.AssertCalled(tt, "Test_Mock_AssertCalled_WithArguments", 1, 2, 3))
 969         assert.False(t, mockedService.AssertCalled(tt, "Test_Mock_AssertCalled_WithArguments", 2, 3, 4))
 970
 971 }
 972
 973 func Test_Mock_AssertCalled_WithArguments_With_Repeatability(t *testing.T) {
 974
 975         var mockedService = new(TestExampleImplementation)
 976
 977         mockedService.On("Test_Mock_AssertCalled_WithArguments_With_Repeatability", 1, 2, 3).Return(5, 6, 7).Once()
 978         mockedService.On("Test_Mock_AssertCalled_WithArguments_With_Repeatability", 2, 3, 4).Return(5, 6, 7).Once()
 979
 980         mockedService.Called(1, 2, 3)
 981         mockedService.Called(2, 3, 4)
 982
 983         tt := new(testing.T)
 984         assert.True(t, mockedService.AssertCalled(tt, "Test_Mock_AssertCalled_WithArguments_With_Repeatability", 1, 2, 3))
 985         assert.True(t, mockedService.AssertCalled(tt, "Test_Mock_AssertCalled_WithArguments_With_Repeatability", 2, 3, 4))
 986         assert.False(t, mockedService.AssertCalled(tt, "Test_Mock_AssertCalled_WithArguments_With_Repeatability", 3, 4, 5))
 987
 988 }
 989
 990 func Test_Mock_AssertNotCalled(t *testing.T) {
 991
 992         var mockedService = new(TestExampleImplementation)
 993
 994         mockedService.On("Test_Mock_AssertNotCalled", 1, 2, 3).Return(5, 6, 7)
 995
 996         mockedService.Called(1, 2, 3)
 997
 998         assert.True(t, mockedService.AssertNotCalled(t, "Test_Mock_NotCalled"))
 999
1000 }
1001
1002 /*
1003         Arguments helper methods
1004 */
1005 func Test_Arguments_Get(t *testing.T) {
1006
1007         var args = Arguments([]interface{}{"string", 123, true})
1008
1009         assert.Equal(t, "string", args.Get(0).(string))
1010         assert.Equal(t, 123, args.Get(1).(int))
1011         assert.Equal(t, true, args.Get(2).(bool))
1012
1013 }
1014
1015 func Test_Arguments_Is(t *testing.T) {
1016
1017         var args = Arguments([]interface{}{"string", 123, true})
1018
1019         assert.True(t, args.Is("string", 123, true))
1020         assert.False(t, args.Is("wrong", 456, false))
1021
1022 }
1023
1024 func Test_Arguments_Diff(t *testing.T) {
1025
1026         var args = Arguments([]interface{}{"Hello World", 123, true})
1027         var diff string
1028         var count int
1029         diff, count = args.Diff([]interface{}{"Hello World", 456, "false"})
1030
1031         assert.Equal(t, 2, count)
1032         assert.Contains(t, diff, `%!s(int=456) != %!s(int=123)`)
1033         assert.Contains(t, diff, `false != %!s(bool=true)`)
1034
1035 }
1036
1037 func Test_Arguments_Diff_DifferentNumberOfArgs(t *testing.T) {
1038
1039         var args = Arguments([]interface{}{"string", 123, true})
1040         var diff string
1041         var count int
1042         diff, count = args.Diff([]interface{}{"string", 456, "false", "extra"})
1043
1044         assert.Equal(t, 3, count)
1045         assert.Contains(t, diff, `extra != (Missing)`)
1046
1047 }
1048
1049 func Test_Arguments_Diff_WithAnythingArgument(t *testing.T) {
1050
1051         var args = Arguments([]interface{}{"string", 123, true})
1052         var count int
1053         _, count = args.Diff([]interface{}{"string", Anything, true})
1054
1055         assert.Equal(t, 0, count)
1056
1057 }
1058
1059 func Test_Arguments_Diff_WithAnythingArgument_InActualToo(t *testing.T) {
1060
1061         var args = Arguments([]interface{}{"string", Anything, true})
1062         var count int
1063         _, count = args.Diff([]interface{}{"string", 123, true})
1064
1065         assert.Equal(t, 0, count)
1066
1067 }
1068
1069 func Test_Arguments_Diff_WithAnythingOfTypeArgument(t *testing.T) {
1070
1071         var args = Arguments([]interface{}{"string", AnythingOfType("int"), true})
1072         var count int
1073         _, count = args.Diff([]interface{}{"string", 123, true})
1074
1075         assert.Equal(t, 0, count)
1076
1077 }
1078
1079 func Test_Arguments_Diff_WithAnythingOfTypeArgument_Failing(t *testing.T) {
1080
1081         var args = Arguments([]interface{}{"string", AnythingOfType("string"), true})
1082         var count int
1083         var diff string
1084         diff, count = args.Diff([]interface{}{"string", 123, true})
1085
1086         assert.Equal(t, 1, count)
1087         assert.Contains(t, diff, `string != type int - %!s(int=123)`)
1088
1089 }
1090
1091 func Test_Arguments_Diff_WithArgMatcher(t *testing.T) {
1092         matchFn := func(a int) bool {
1093                 return a == 123
1094         }
1095         var args = Arguments([]interface{}{"string", MatchedBy(matchFn), true})
1096
1097         diff, count := args.Diff([]interface{}{"string", 124, true})
1098         assert.Equal(t, 1, count)
1099         assert.Contains(t, diff, `%!s(int=124) not matched by func(int) bool`)
1100
1101         diff, count = args.Diff([]interface{}{"string", false, true})
1102         assert.Equal(t, 1, count)
1103         assert.Contains(t, diff, `%!s(bool=false) not matched by func(int) bool`)
1104
1105         diff, count = args.Diff([]interface{}{"string", 123, false})
1106         assert.Contains(t, diff, `%!s(int=123) matched by func(int) bool`)
1107
1108         diff, count = args.Diff([]interface{}{"string", 123, true})
1109         assert.Equal(t, 0, count)
1110         assert.Contains(t, diff, `No differences.`)
1111 }
1112
1113 func Test_Arguments_Assert(t *testing.T) {
1114
1115         var args = Arguments([]interface{}{"string", 123, true})
1116
1117         assert.True(t, args.Assert(t, "string", 123, true))
1118
1119 }
1120
1121 func Test_Arguments_String_Representation(t *testing.T) {
1122
1123         var args = Arguments([]interface{}{"string", 123, true})
1124         assert.Equal(t, `string,int,bool`, args.String())
1125
1126 }
1127
1128 func Test_Arguments_String(t *testing.T) {
1129
1130         var args = Arguments([]interface{}{"string", 123, true})
1131         assert.Equal(t, "string", args.String(0))
1132
1133 }
1134
1135 func Test_Arguments_Error(t *testing.T) {
1136
1137         var err = errors.New("An Error")
1138         var args = Arguments([]interface{}{"string", 123, true, err})
1139         assert.Equal(t, err, args.Error(3))
1140
1141 }
1142
1143 func Test_Arguments_Error_Nil(t *testing.T) {
1144
1145         var args = Arguments([]interface{}{"string", 123, true, nil})
1146         assert.Equal(t, nil, args.Error(3))
1147
1148 }
1149
1150 func Test_Arguments_Int(t *testing.T) {
1151
1152         var args = Arguments([]interface{}{"string", 123, true})
1153         assert.Equal(t, 123, args.Int(1))
1154
1155 }
1156
1157 func Test_Arguments_Bool(t *testing.T) {
1158
1159         var args = Arguments([]interface{}{"string", 123, true})
1160         assert.Equal(t, true, args.Bool(2))
1161
1162 }
1163
1164 func Test_WaitUntil_Parallel(t *testing.T) {
1165
1166         // make a test impl object
1167         var mockedService *TestExampleImplementation = new(TestExampleImplementation)
1168
1169         ch1 := make(chan time.Time)
1170         ch2 := make(chan time.Time)
1171
1172         mockedService.Mock.On("TheExampleMethod2", true).Return().WaitUntil(ch2).Run(func(args Arguments) {
1173                 ch1 <- time.Now()
1174         })
1175
1176         mockedService.Mock.On("TheExampleMethod2", false).Return().WaitUntil(ch1)
1177
1178         // Lock both goroutines on the .WaitUntil method
1179         go func() {
1180                 mockedService.TheExampleMethod2(false)
1181         }()
1182         go func() {
1183                 mockedService.TheExampleMethod2(true)
1184         }()
1185
1186         // Allow the first call to execute, so the second one executes afterwards
1187         ch2 <- time.Now()
1188 }
1189
1190 func Test_MockMethodCalled(t *testing.T) {
1191         m := new(Mock)
1192         m.On("foo", "hello").Return("world")
1193
1194         retArgs := m.MethodCalled("foo", "hello")
1195         require.True(t, len(retArgs) == 1)
1196         require.Equal(t, "world", retArgs[0])
1197         m.AssertExpectations(t)
1198 }
1199
1200 // Test to validate fix for racy concurrent call access in MethodCalled()
1201 func Test_MockReturnAndCalledConcurrent(t *testing.T) {
1202         iterations := 1000
1203         m := &Mock{}
1204         call := m.On("ConcurrencyTestMethod")
1205
1206         wg := sync.WaitGroup{}
1207         wg.Add(2)
1208
1209         go func() {
1210                 for i := 0; i < iterations; i++ {
1211                         call.Return(10)
1212                 }
1213                 wg.Done()
1214         }()
1215         go func() {
1216                 for i := 0; i < iterations; i++ {
1217                         ConcurrencyTestMethod(m)
1218                 }
1219                 wg.Done()
1220         }()
1221         wg.Wait()
1222 }
1223
1224 func ConcurrencyTestMethod(m *Mock) {
1225         m.Called()
1226 }