const (
// Anything is used in Diff and Assert when the argument being tested
// shouldn't be taken into consideration.
Anything = "mock.Anything"
)
func AssertExpectationsForObjects(t TestingT, testObjects ...interface{}) bool
AssertExpectationsForObjects asserts that everything specified with On and Return of the specified objects was in fact called as expected.
Calls may have occurred in any order.
func MatchedBy(fn interface{}) argumentMatcher
MatchedBy can be used to match a mock call based on only certain properties from a complex struct or some calculation. It takes a function that will be evaluated with the called argument and will return true when there's a match and false otherwise.
Example: m.On("Do", MatchedBy(func(req *http.Request) bool { return req.Host == "example.com" }))
|fn|, must be a function accepting a single argument (of the expected type) which returns a bool. If |fn| doesn't match the required signature, MatchedBy() panics.
AnythingOfTypeArgument contains the type of an argument for use when type checking. Used in Diff and Assert.
Deprecated: this is an implementation detail that must not be used. Use AnythingOfType instead.
type AnythingOfTypeArgument = anythingOfTypeArgument
func AnythingOfType(t string) AnythingOfTypeArgument
AnythingOfType returns a special value containing the name of the type to check for. The type name will be matched against the type name returned by reflect.Type.String.
Used in Diff and Assert.
For example:
Assert(t, AnythingOfType("string"), AnythingOfType("int"))
Arguments holds an array of method arguments or return values.
type Arguments []interface{}
func (args Arguments) Assert(t TestingT, objects ...interface{}) bool
Assert compares the arguments with the specified objects and fails if they do not exactly match.
func (args Arguments) Bool(index int) bool
Bool gets the argument at the specified index. Panics if there is no argument, or if the argument is of the wrong type.
func (args Arguments) Diff(objects []interface{}) (string, int)
Diff gets a string describing the differences between the arguments and the specified objects.
Returns the diff string and number of differences found.
func (args Arguments) Error(index int) error
Error gets the argument at the specified index. Panics if there is no argument, or if the argument is of the wrong type.
func (args Arguments) Get(index int) interface{}
Get Returns the argument at the specified index.
func (args Arguments) Int(index int) int
Int gets the argument at the specified index. Panics if there is no argument, or if the argument is of the wrong type.
func (args Arguments) Is(objects ...interface{}) bool
Is gets whether the objects match the arguments specified.
func (args Arguments) String(indexOrNil ...int) string
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.
Call represents a method call and is used for setting expectations, as well as recording activity.
type Call struct {
Parent *Mock
// The name of the method that was or will be called.
Method string
// Holds the arguments of the method.
Arguments Arguments
// Holds the arguments that should be returned when
// this method is called.
ReturnArguments Arguments
// The number of times to return the return arguments when setting
// expectations. 0 means to always return the value.
Repeatability int
// Holds a channel that will be used to block the Return until it either
// receives a message or is closed. nil means it returns immediately.
WaitFor <-chan time.Time
// Holds a handler used to manipulate arguments content that are passed by
// reference. It's useful when mocking methods such as unmarshalers or
// decoders.
RunFn func(Arguments)
// PanicMsg holds msg to be used to mock panic on the function call
// if the PanicMsg is set to a non nil string the function call will panic
// irrespective of other settings
PanicMsg *string
// contains filtered or unexported fields
}
func (c *Call) After(d time.Duration) *Call
After sets how long to block until the call returns
Mock.On("MyMethod", arg1, arg2).After(time.Second)
func (c *Call) Maybe() *Call
Maybe allows the method call to be optional. Not calling an optional method will not cause an error while asserting expectations
func (c *Call) NotBefore(calls ...*Call) *Call
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)
)
func (c *Call) On(methodName string, arguments ...interface{}) *Call
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"))
func (c *Call) Once() *Call
Once indicates that the mock should only return the value once.
Mock.On("MyMethod", arg1, arg2).Return(returnArg1, returnArg2).Once()
func (c *Call) Panic(msg string) *Call
Panic specifies if the function call should fail and the panic message
Mock.On("DoSomething").Panic("test panic")
func (c *Call) Return(returnArguments ...interface{}) *Call
Return specifies the return arguments for the expectation.
Mock.On("DoSomething").Return(errors.New("failed"))
func (c *Call) Run(fn func(args Arguments)) *Call
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"
})
func (c *Call) Times(i int) *Call
Times indicates that the mock should only return the indicated number of times.
Mock.On("MyMethod", arg1, arg2).Return(returnArg1, returnArg2).Times(5)
func (c *Call) Twice() *Call
Twice indicates that the mock should only return the value twice.
Mock.On("MyMethod", arg1, arg2).Return(returnArg1, returnArg2).Twice()
func (c *Call) Unset() *Call
Unset removes a mock handler from being called.
test.On("func", mock.Anything).Unset()
func (c *Call) WaitUntil(w <-chan time.Time) *Call
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))
FunctionalOptionsArgument is a struct that contains the type and value of an functional option argument for use when type checking.
type FunctionalOptionsArgument struct {
// contains filtered or unexported fields
}
func FunctionalOptions(value ...interface{}) *FunctionalOptionsArgument
FunctionalOptions returns an FunctionalOptionsArgument object containing the functional option type and the values to check of
For example: Assert(t, FunctionalOptions("[]foo.FunctionalOption", foo.Opt1(), foo.Opt2()))
func (f *FunctionalOptionsArgument) String() string
String returns the string representation of FunctionalOptionsArgument
IsTypeArgument is a struct that contains the type of an argument for use when type checking. This is an alternative to AnythingOfType. Used in Diff and Assert.
type IsTypeArgument struct {
// contains filtered or unexported fields
}
func IsType(t interface{}) *IsTypeArgument
IsType returns an IsTypeArgument object containing the type to check for. You can provide a zero-value of the type to check. This is an alternative to AnythingOfType. Used in Diff and Assert.
For example: Assert(t, IsType(""), IsType(0))
Mock is the workhorse used to track activity on another object. For an example of its usage, refer to the "Example Usage" section at the top of this document.
type Mock struct {
// Represents the calls that are expected of
// an object.
ExpectedCalls []*Call
// Holds the calls that were made to this mocked object.
Calls []Call
// contains filtered or unexported fields
}
func (m *Mock) AssertCalled(t TestingT, methodName string, arguments ...interface{}) bool
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.
func (m *Mock) AssertExpectations(t TestingT) bool
AssertExpectations asserts that everything specified with On and Return was in fact called as expected. Calls may have occurred in any order.
func (m *Mock) AssertNotCalled(t TestingT, methodName string, arguments ...interface{}) bool
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.
func (m *Mock) AssertNumberOfCalls(t TestingT, methodName string, expectedCalls int) bool
AssertNumberOfCalls asserts that the method was called expectedCalls times.
func (m *Mock) Called(arguments ...interface{}) Arguments
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 .On .Return() calls) If Call.WaitFor is set, blocks until the channel is closed or receives a message.
func (m *Mock) IsMethodCallable(t TestingT, methodName string, arguments ...interface{}) bool
IsMethodCallable checking that the method can be called If the method was called more than `Repeatability` return false
func (m *Mock) MethodCalled(methodName string, arguments ...interface{}) Arguments
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 .On .Return() calls) If Call.WaitFor is set, blocks until the channel is closed or receives a message.
func (m *Mock) On(methodName string, arguments ...interface{}) *Call
On starts a description of an expectation of the specified method being called.
Mock.On("MyMethod", arg1, arg2)
func (m *Mock) String() string
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.
func (m *Mock) Test(t TestingT)
Test sets the test struct variable of the mock object
func (m *Mock) TestData() objx.Map
TestData holds any data that might be useful for testing. Testify ignores this data completely allowing you to do whatever you like with it.
TestingT is an interface wrapper around *testing.T
type TestingT interface {
Logf(format string, args ...interface{})
Errorf(format string, args ...interface{})
FailNow()
}