Running function lambda arguments

[kaedys]

Currently in our project, we have a function in our interface that accepts a lambda, does some logic (specifically, starts a database transaction), then runs the lambda in the context of that logic.

However, gomock doesn't have a way, as far as I've found, to run that lambda argument and then assert its behavior. I've hacked it a bit by replacing that function in the generated file with a simple command to run the argument in question and return its result, but it'd be nice if there was a built in way to do this without editing generated code.

I noticed that the Call type has a Do method which accepts a lambda (with a TODO to actually make sure it's a lambda), then calls it later down the line. Perhaps have a method on Call that, similar to SetArg, runs a particular argument in the same fashion Do does (example, CallArg(n int)). This would let me assert behavior that happens in that lambda (which also utilizes the mock). May be complicated by the fact that the lambda in question (in my code) needs to have the mock _m provided as an argument to it. Maybe CallArg(n int, args ...interface{}) to provide arguments for the call (which I could then feed the mock object to)?

Trimmed down example:

// persist.go
type Persister interface {
    RunInTx(TxFunc) error
    Foo()
    Bar()
}

type TxFunc func(tx Persister) error

func (p persister) RunInTx(f TxFunc) error {
    tx := p.StartTx()
    return f(tx)
}

// main.go
func main() {
    p := persist.NewPersister()
    log.Printf(DoStuff(p))
}

func DoStuff(p persist.Persister) error {
    return p.RunInTx(func(tx persist.Persister) error {
        tx.Foo()
        tx.Bar()
    })
}

// main_test.go
func TestDoStuff(t *testing.T) {
    mockCtrl := gomock.NewController(t)
    mockPersist := mock_persist.NewPersist(mockCtrl)

    // Currently these calls never happen, because the lambda in DoStuff is never run
    mockPersist.EXPECT().Foo()
    mockPersist.EXPECT().Bar()

    DoStuff(mockPersist)
}

And the hacky way I've solved it for now, for reference:

func (_m *MockPersister) RunInTx(_param0 persist.TxFunc) error {
    return _param0(_m)
    //ret := _m.ctrl.Call(_m, "RunInTx", _param0)
    //ret0, _ := ret[0].(error)
    //return ret0
}

[kaedys]

Semi-hackish change that I implemented on my local version of Gomock that seems to function as expected:

--- github.com/golang/mock/gomock/call.go   2016-03-08 16:32:12.000000000 -0600
+++ github.com/golang/mock/gomock/call.go   2016-03-08 16:32:13.000000000 -0600
@@ -39,6 +39,13 @@
    // Actions
    doFunc  reflect.Value
    setArgs map[int]reflect.Value
+   runArgs []runArg
+}
+
+// runArg represents an action to run a particular argument on call
+type runArg struct {
+   arg  int
+   args []interface{}
 }

 func (c *Call) AnyTimes() *Call {
@@ -123,6 +130,20 @@
    return c
 }

+func (c *Call) RunArg(n int, args ...interface{}) *Call {
+   if c.setArgs == nil {
+       c.setArgs = make(map[int]reflect.Value)
+   }
+   mt := c.methodType()
+
+   if n < 0 || n >= mt.NumIn() {
+       c.t.Fatalf("SetArg(%d, ...) called for a method with %d args", n, mt.NumIn())
+   }
+
+   c.runArgs = append(c.runArgs, runArg{n, args})
+   return c
+}
+
 // isPreReq returns true if other is a direct or indirect prerequisite to c.
 func (c *Call) isPreReq(other *Call) bool {
    for _, preReq := range c.preReqs {
@@ -212,6 +233,30 @@
        }
        action = func() { c.doFunc.Call(doArgs) }
    }
+
+   // runArgs
+   for _, v := range c.runArgs {
+       f := reflect.ValueOf(args[v.arg])
+       if f.IsValid() {
+           doArgs := make([]reflect.Value, len(v.args))
+           ft := reflect.TypeOf(args[v.arg])
+           if len(v.args) != ft.NumIn() {
+               panic(fmt.Sprintf("gomock: cannot run argument n with %d arguments, need %d", len(v.args), ft.NumIn()))
+           }
+           for i := 0; i < ft.NumIn(); i++ {
+               if v.args[i] != nil {
+                   doArgs[i] = reflect.ValueOf(v.args[i])
+               } else {
+                   // Use the zero value for the arg.
+                   doArgs[i] = reflect.Zero(ft.In(i))
+               }
+           }
+           action = func() {
+               f.Call(doArgs)
+           }
+       }
+   }
+
    for n, v := range c.setArgs {
        reflect.ValueOf(args[n]).Elem().Set(v)
    }

[balshetzer]

I think the easiest way to handle this case is with Do or DoAndReturn.

In this example I would do:

mockPersist.EXPECT().RunInTx(gomock.Any()).DoAndReturn(
  func (f func(tx persist.Persister) error) error { return f(mockPersist) })

It's possible that RunArg action would be useful but I'm worried it might make things too complex. As the actions get more and more complex, I find that using Do actually makes it easier to understand how the mock behaves. Otherwise, we end up building yet another language that we need to learn to use gomock.