mock

Assert compares the arguments with the specified objects and fails if they do not exactly match.

Bool gets the argument at the specified index. Panics if there is no argument, or if the argument is of the wrong type.

Diff gets a string describing the differences between the arguments and the specified objects.

Returns the diff string and number of differences found.

Error gets the argument at the specified index. Panics if there is no argument, or if the argument is of the wrong type.

Get Returns the argument at the specified index.

Int gets the argument at the specified index. Panics if there is no argument, or if the argument is of the wrong type.

Is gets whether the objects match the arguments specified.

String gets the argument at the specified index. Panics if there is no argument, or if the argument is of the wrong type.

If no index is provided, String() returns a complete string representation of the arguments.

After sets how long to block until the call returns

Mock.On("MyMethod", arg1, arg2).After(time.Second)

Maybe allows the method call to be optional. Not calling an optional method will not cause an error while asserting expectations

NotBefore indicates that the mock should only be called after the referenced calls have been called as expected. The referenced calls may be from the same mock instance and/or other mock instances.

Mock.On("Do").Return(nil).NotBefore(
    Mock.On("Init").Return(nil)
)

On chains a new expectation description onto the mocked interface. This allows syntax like.

Mock.
   On("MyMethod", 1).Return(nil).
   On("MyOtherMethod", 'a', 'b', 'c').Return(errors.New("Some Error"))

Once indicates that the mock should only return the value once.

Mock.On("MyMethod", arg1, arg2).Return(returnArg1, returnArg2).Once()

Panic specifies if the function call should fail and the panic message

Mock.On("DoSomething").Panic("test panic")

Return specifies the return arguments for the expectation.

Mock.On("DoSomething").Return(errors.New("failed"))

Run sets a handler to be called before returning. It can be used when mocking a method (such as an unmarshaler) that takes a pointer to a struct and sets properties in such struct

Mock.On("Unmarshal", AnythingOfType("*map[string]interface{}")).Return().Run(func(args Arguments) {
	arg := args.Get(0).(*map[string]interface{})
	arg["foo"] = "bar"
})

Times indicates that the mock should only return the indicated number of times.

Mock.On("MyMethod", arg1, arg2).Return(returnArg1, returnArg2).Times(5)

Twice indicates that the mock should only return the value twice.

Mock.On("MyMethod", arg1, arg2).Return(returnArg1, returnArg2).Twice()

Unset removes all mock handlers that satisfy the call instance arguments from being called. Only supported on call instances with static input arguments.

For example, the only handler remaining after the following would be "MyMethod(2, 2)":

Mock.
   On("MyMethod", 2, 2).Return(0).
   On("MyMethod", 3, 3).Return(0).
   On("MyMethod", Anything, Anything).Return(0)
Mock.On("MyMethod", 3, 3).Unset()

WaitUntil sets the channel that will block the mock's return until its closed or a message is received.

Mock.On("MyMethod", arg1, arg2).WaitUntil(time.After(time.Second))

String returns the string representation of FunctionalOptionsArgument

AssertCalled asserts that the method was called. It can produce a false result when an argument is a pointer type and the underlying value changed after calling the mocked method.

AssertExpectations asserts that everything specified with Mock.On was in fact called as expected. Calls may have occurred in any order.

AssertNotCalled asserts that the method was not called. It can produce a false result when an argument is a pointer type and the underlying value changed after calling the mocked method.

AssertNumberOfCalls asserts that the method was called expectedCalls times.

Called tells the mock object that a method has been called, and gets an array of arguments to return. Panics if the call is unexpected (i.e. not preceded by appropriate Mock.On calls) If Call.WaitFor is set, blocks until the channel is closed or receives a message.

IsMethodCallable returns true if given methodName and arguments have an unsatisfied expected call registered in the Mock.

MethodCalled tells the mock object that the given method has been called, and gets an array of arguments to return. Panics if the call is unexpected (i.e. not preceded by appropriate Mock.On calls) If Call.WaitFor is set, blocks until the channel is closed or receives a message.

On starts a description of an expectation of the specified method being called.

Mock.On("MyMethod", arg1, arg2)

String provides a %v format string for Mock. Note: this is used implicitly by Arguments.Diff if a Mock is passed. It exists because go's default %v formatting traverses the struct without acquiring the mutex, which is detected by go test -race.

Test sets the TestingT on which errors will be reported, otherwise errors will cause a panic. Test should not be called on an object that is going to be used in a goroutine other than the one running the test function.

TestData holds any data that might be useful for testing. Testify ignores this data completely allowing you to do whatever you like with it.