GoMock - a mock framework for Go.

    Standard usage:

    (1) Define an interface that you wish to mock.
          type MyInterface interface {
            SomeMethod(x int64, y string)
    (2) Use mockgen to generate a mock from the interface.
    (3) Use the mock in a test:
          func TestMyThing(t *testing.T) {
            mockCtrl := gomock.NewController(t)
            defer mockCtrl.Finish()
            mockObj := something.NewMockMyInterface(mockCtrl)
            mockObj.EXPECT().SomeMethod(4, "blah")
            // pass mockObj to a real object and play with it.

    By default, expected calls are not enforced to run in any particular order. Call order dependency can be enforced by use of InOrder and/or Call.After. Call.After can create more varied call order dependencies, but InOrder is often more convenient.

    The following examples create equivalent call order dependencies.

    Example of using Call.After to chain expected call order:

    firstCall := mockObj.EXPECT().SomeMethod(1, "first")
    secondCall := mockObj.EXPECT().SomeMethod(2, "second").After(firstCall)
    mockObj.EXPECT().SomeMethod(3, "third").After(secondCall)

    Example of using InOrder to declare expected call order:

        mockObj.EXPECT().SomeMethod(1, "first"),
        mockObj.EXPECT().SomeMethod(2, "second"),
        mockObj.EXPECT().SomeMethod(3, "third"),


    - Handle different argument/return types (e.g. ..., chan, map, interface).



    This section is empty.


    This section is empty.


    func InOrder

    func InOrder(calls ...*Call)

      InOrder declares that the given calls should occur in order.


      type Call

      type Call struct {
      	// contains filtered or unexported fields

        Call represents an expected call to a mock.

        func (*Call) After

        func (c *Call) After(preReq *Call) *Call

          After declares that the call may only match after preReq has been exhausted.

          func (*Call) AnyTimes

          func (c *Call) AnyTimes() *Call

            AnyTimes allows the expectation to be called 0 or more times

            func (*Call) Do

            func (c *Call) Do(f interface{}) *Call

              Do declares the action to run when the call is matched. It takes an interface{} argument to support n-arity functions.

              func (*Call) MaxTimes

              func (c *Call) MaxTimes(n int) *Call

                MaxTimes limits the number of calls to n times. If AnyTimes or MinTimes have not been called, MaxTimes also sets the minimum number of calls to 0.

                func (*Call) MinTimes

                func (c *Call) MinTimes(n int) *Call

                  MinTimes requires the call to occur at least n times. If AnyTimes or MaxTimes have not been called, MinTimes also sets the maximum number of calls to infinity.

                  func (*Call) Return

                  func (c *Call) Return(rets ...interface{}) *Call

                  func (*Call) SetArg

                  func (c *Call) SetArg(n int, value interface{}) *Call

                    SetArg declares an action that will set the nth argument's value, indirected through a pointer.

                    func (*Call) String

                    func (c *Call) String() string

                    func (*Call) Times

                    func (c *Call) Times(n int) *Call

                    type Controller

                    type Controller struct {
                    	// contains filtered or unexported fields

                      A Controller represents the top-level control of a mock ecosystem. It defines the scope and lifetime of mock objects, as well as their expectations. It is safe to call Controller's methods from multiple goroutines.

                      func NewController

                      func NewController(t TestReporter) *Controller

                      func (*Controller) Call

                      func (ctrl *Controller) Call(receiver interface{}, method string, args ...interface{}) []interface{}

                      func (*Controller) Finish

                      func (ctrl *Controller) Finish()

                      func (*Controller) RecordCall

                      func (ctrl *Controller) RecordCall(receiver interface{}, method string, args ...interface{}) *Call

                      func (*Controller) RecordCallWithMethodType

                      func (ctrl *Controller) RecordCallWithMethodType(receiver interface{}, method string, methodType reflect.Type, args ...interface{}) *Call

                      type Matcher

                      type Matcher interface {
                      	// Matches returns whether x is a match.
                      	Matches(x interface{}) bool
                      	// String describes what the matcher matches.
                      	String() string

                        A Matcher is a representation of a class of values. It is used to represent the valid or expected arguments to a mocked method.

                        func Any

                        func Any() Matcher


                          func Eq

                          func Eq(x interface{}) Matcher

                          func Nil

                          func Nil() Matcher

                          func Not

                          func Not(x interface{}) Matcher

                          type TestReporter

                          type TestReporter interface {
                          	Errorf(format string, args ...interface{})
                          	Fatalf(format string, args ...interface{})

                            A TestReporter is something that can be used to report test failures. It is satisfied by the standard library's *testing.T.


                            Path Synopsis