Documentation
¶
Overview ¶
Provides a system by which it is possible to mock your objects and verify calls are happening as expected.
Example Usage ¶
The mock package provides an object, Mock, that tracks activity on another object. It is usually embedded into a test object as shown below:
type MyTestObject struct {
// add a Mock object instance
mock.Mock
// other fields go here as normal
}
When implementing the methods of an interface, you wire your functions up to call the Mock.Called(args...) method, and return the appropriate values.
For example, to mock a method that saves the name and age of a person and returns the year of their birth or an error, you might write this:
func (o *MyTestObject) SavePersonDetails(firstname, lastname string, age int) (int, error) {
args := o.Called(firstname, lastname, age)
return args.Int(0), args.Error(1)
}
The Int, Error and Bool methods are examples of strongly typed getters that take the argument index position. Given this argument list:
(12, true, "Something")
You could read them out strongly typed like this:
args.Int(0)
args.Bool(1)
args.String(2)
For objects of your own type, use the generic Arguments.Get(index) method and make a type assertion:
return args.Get(0).(*MyObject), args.Get(1).(*AnotherObjectOfMine)
This may cause a panic if the object you are getting is nil (the type assertion will fail), in those cases you should check for nil first.
Index ¶
- Constants
- func AssertExpectationsForObjects(t TestingT, testObjects ...interface{}) bool
- type AnythingOfTypeArgument
- type Arguments
- func (args Arguments) Assert(t TestingT, objects ...interface{}) bool
- func (args Arguments) Bool(index int) bool
- func (args Arguments) Diff(objects []interface{}) (string, int)
- func (args Arguments) Error(index int) error
- func (args Arguments) Get(index int) interface{}
- func (args Arguments) Int(index int) int
- func (args Arguments) Is(objects ...interface{}) bool
- func (args Arguments) String(indexOrNil ...int) string
- type Call
- type Mock
- func (m *Mock) AssertCalled(t TestingT, methodName string, arguments ...interface{}) bool
- func (m *Mock) AssertExpectations(t TestingT) bool
- func (m *Mock) AssertNotCalled(t TestingT, methodName string, arguments ...interface{}) bool
- func (m *Mock) AssertNumberOfCalls(t TestingT, methodName string, expectedCalls int) bool
- func (m *Mock) Called(arguments ...interface{}) Arguments
- func (m *Mock) On(methodName string, arguments ...interface{}) *Mock
- func (m *Mock) Once()
- func (m *Mock) Return(returnArguments ...interface{}) *Mock
- func (m *Mock) TestData() objx.Map
- func (m *Mock) Times(i int)
- func (m *Mock) Twice()
- type TestingT
Constants ¶
const (
// The "any" argument. Used in Diff and Assert when
// the argument being tested shouldn't be taken into consideration.
Anything string = "mock.Anything"
)
Variables ¶
This section is empty.
Functions ¶
func AssertExpectationsForObjects ¶
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.
Types ¶
type AnythingOfTypeArgument ¶
type AnythingOfTypeArgument string
AnythingOfTypeArgument is a string that contains the type of an argument for use when type checking. Used in Diff and Assert.
func AnythingOfType ¶
func AnythingOfType(t string) AnythingOfTypeArgument
AnythingOfType returns an AnythingOfTypeArgument object containing the name of the type to check for. Used in Diff and Assert.
For example:
Assert(t, AnythingOfType("string"), AnythingOfType("int"))
type Arguments ¶
type Arguments []interface{}
Arguments holds an array of method arguments or return values.
func (Arguments) Assert ¶
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 (Arguments) Bool ¶
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 (Arguments) Diff ¶
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 (Arguments) Error ¶
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 (Arguments) Get ¶
func (args Arguments) Get(index int) interface{}
Get Returns the argument at the specified index.
func (Arguments) Int ¶
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.
type Call ¶
type Call struct {
// 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
}
Call represents a method call and is used for setting expectations, as well as recording activity.
type Mock ¶
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
}
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.
func (*Mock) AssertCalled ¶
func (m *Mock) AssertCalled(t TestingT, methodName string, arguments ...interface{}) bool
AssertCalled asserts that the method was called.
func (*Mock) AssertExpectations ¶
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 (*Mock) AssertNotCalled ¶
func (m *Mock) AssertNotCalled(t TestingT, methodName string, arguments ...interface{}) bool
AssertNotCalled asserts that the method was not called.
func (*Mock) AssertNumberOfCalls ¶
func (m *Mock) AssertNumberOfCalls(t TestingT, methodName string, expectedCalls int) bool
AssertNumberOfCalls asserts that the method was called expectedCalls times.
func (*Mock) Called ¶
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 preceeded by appropriate .On .Return() calls)
func (*Mock) On ¶
func (m *Mock) On(methodName string, arguments ...interface{}) *Mock
On starts a description of an expectation of the specified method being called.
Mock.On("MyMethod", arg1, arg2)
func (*Mock) Once ¶
func (m *Mock) Once()
Once indicates that that the mock should only return the value once.
Mock.On("MyMethod", arg1, arg2).Return(returnArg1, returnArg2).Once()
func (*Mock) Return ¶
func (m *Mock) Return(returnArguments ...interface{}) *Mock
Return finishes a description of an expectation of the method (and arguments) specified in the most recent On method call.
Mock.On("MyMethod", arg1, arg2).Return(returnArg1, returnArg2)
func (*Mock) TestData ¶
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.
Source Files