Merge pull request #89 from golang/unexported_methods

Fix mocks with unexported methods

Author: balshetzer

gomock/call.go

@@ -24,10 +24,11 @@ import (
 type Call struct {
 	t TestReporter // for triggering test failures on invalid call setup
 
-	receiver interface{}   // the receiver of the method call
-	method   string        // the name of the method
-	args     []Matcher     // the args
-	rets     []interface{} // the return values (if any)
+	receiver   interface{}   // the receiver of the method call
+	method     string        // the name of the method
+	methodType reflect.Type  // the type of the method
+	args       []Matcher     // the args
+	rets       []interface{} // the return values (if any)
 
 	preReqs []*Call // prerequisite calls
 
@@ -76,7 +77,7 @@ func (c *Call) Do(f interface{}) *Call {
 }
 
 func (c *Call) Return(rets ...interface{}) *Call {
-	mt := c.methodType()
+	mt := c.methodType
 	if len(rets) != mt.NumOut() {
 		c.t.Fatalf("wrong number of arguments to Return for %T.%v: got %d, want %d",
 			c.receiver, c.method, len(rets), mt.NumOut())
@@ -120,7 +121,7 @@ func (c *Call) SetArg(n int, value interface{}) *Call {
 	if c.setArgs == nil {
 		c.setArgs = make(map[int]reflect.Value)
 	}
-	mt := c.methodType()
+	mt := c.methodType
 	// TODO: This will break on variadic methods.
 	// We will need to check those at invocation time.
 	if n < 0 || n >= mt.NumIn() {
@@ -239,7 +240,7 @@ func (c *Call) call(args []interface{}) (rets []interface{}, action func()) {
 	rets = c.rets
 	if rets == nil {
 		// Synthesize the zero value for each of the return args' types.
-		mt := c.methodType()
+		mt := c.methodType
 		rets = make([]interface{}, mt.NumOut())
 		for i := 0; i < mt.NumOut(); i++ {
 			rets[i] = reflect.Zero(mt.Out(i)).Interface()
@@ -249,16 +250,6 @@ func (c *Call) call(args []interface{}) (rets []interface{}, action func()) {
 	return
 }
 
-func (c *Call) methodType() reflect.Type {
-	recv := reflect.ValueOf(c.receiver)
-	for i := 0; i < recv.Type().NumMethod(); i++ {
-		if recv.Type().Method(i).Name == c.method {
-			return recv.Method(i).Type()
-		}
-	}
-	panic(fmt.Sprintf("gomock: failed finding method %s on %T", c.method, c.receiver))
-}
-
 // InOrder declares that the given calls should occur in order.
 func InOrder(calls ...*Call) {
 	for i := 1; i < len(calls); i++ {

gomock/controller.go

@@ -55,7 +55,10 @@
 //	- Handle different argument/return types (e.g. ..., chan, map, interface).
 package gomock
 
-import "sync"
+import (
+	"reflect"
+	"sync"
+)
 
 // A TestReporter is something that can be used to report test failures.
 // It is satisfied by the standard library's *testing.T.
@@ -80,7 +83,7 @@ func NewController(t TestReporter) *Controller {
 	}
 }
 
-func (ctrl *Controller) RecordCall(receiver interface{}, method string, args ...interface{}) *Call {
+func (ctrl *Controller) RecordCall(receiver interface{}, method string, methodType reflect.Type, args ...interface{}) *Call {
 	// TODO: check arity, types.
 	margs := make([]Matcher, len(args))
 	for i, arg := range args {
@@ -98,7 +101,7 @@ func (ctrl *Controller) RecordCall(receiver interface{}, method string, args ...
 	ctrl.mu.Lock()
 	defer ctrl.mu.Unlock()
 
-	call := &Call{t: ctrl.t, receiver: receiver, method: method, args: margs, minCalls: 1, maxCalls: 1}
+	call := &Call{t: ctrl.t, receiver: receiver, method: method, methodType: methodType, args: margs, minCalls: 1, maxCalls: 1}
 
 	ctrl.expectedCalls.Add(call)
 	return call

gomock/controller_test.go

@@ -48,7 +48,7 @@ func (e *ErrorReporter) assertPass(msg string) {
 
 func (e *ErrorReporter) assertFail(msg string) {
 	if !e.failed {
-		e.t.Error("Expected failure, but got pass: %s", msg)
+		e.t.Errorf("Expected failure, but got pass: %s", msg)
 	}
 }
 
@@ -119,9 +119,14 @@ func (s *Subject) BarMethod(arg string) int {
 	return 0
 }
 
+var (
+	FooMethodType = reflect.TypeOf((*Subject).FooMethod)
+	BarMethodType = reflect.TypeOf((*Subject).BarMethod)
+)
+
 func assertEqual(t *testing.T, expected interface{}, actual interface{}) {
 	if !reflect.DeepEqual(expected, actual) {
-		t.Error("Expected %+v, but got %+v", expected, actual)
+		t.Errorf("Expected %+v, but got %+v", expected, actual)
 	}
 }
 
@@ -144,7 +149,7 @@ func TestExpectedMethodCall(t *testing.T) {
 	reporter, ctrl := createFixtures(t)
 	subject := new(Subject)
 
-	ctrl.RecordCall(subject, "FooMethod", "argument")
+	ctrl.RecordCall(subject, "FooMethod", FooMethodType, "argument")
 	ctrl.Call(subject, "FooMethod", "argument")
 	ctrl.Finish()
 
@@ -166,7 +171,7 @@ func TestRepeatedCall(t *testing.T) {
 	reporter, ctrl := createFixtures(t)
 	subject := new(Subject)
 
-	ctrl.RecordCall(subject, "FooMethod", "argument").Times(3)
+	ctrl.RecordCall(subject, "FooMethod", FooMethodType, "argument").Times(3)
 	ctrl.Call(subject, "FooMethod", "argument")
 	ctrl.Call(subject, "FooMethod", "argument")
 	ctrl.Call(subject, "FooMethod", "argument")
@@ -183,7 +188,7 @@ func TestUnexpectedArgCount(t *testing.T) {
 	defer reporter.recoverUnexpectedFatal()
 	subject := new(Subject)
 
-	ctrl.RecordCall(subject, "FooMethod", "argument")
+	ctrl.RecordCall(subject, "FooMethod", FooMethodType, "argument")
 	reporter.assertFatal(func() {
 		// This call is made with the wrong number of arguments...
 		ctrl.Call(subject, "FooMethod", "argument", "extra_argument")
@@ -202,7 +207,7 @@ func TestAnyTimes(t *testing.T) {
 	reporter, ctrl := createFixtures(t)
 	subject := new(Subject)
 
-	ctrl.RecordCall(subject, "FooMethod", "argument").AnyTimes()
+	ctrl.RecordCall(subject, "FooMethod", FooMethodType, "argument").AnyTimes()
 	for i := 0; i < 100; i++ {
 		ctrl.Call(subject, "FooMethod", "argument")
 	}
@@ -214,22 +219,22 @@ func TestMinTimes1(t *testing.T) {
 	// It fails if there are no calls
 	reporter, ctrl := createFixtures(t)
 	subject := new(Subject)
-	ctrl.RecordCall(subject, "FooMethod", "argument").MinTimes(1)
+	ctrl.RecordCall(subject, "FooMethod", FooMethodType, "argument").MinTimes(1)
 	reporter.assertFatal(func() {
 		ctrl.Finish()
 	})
 
 	// It succeeds if there is one call
 	reporter, ctrl = createFixtures(t)
 	subject = new(Subject)
-	ctrl.RecordCall(subject, "FooMethod", "argument").MinTimes(1)
+	ctrl.RecordCall(subject, "FooMethod", FooMethodType, "argument").MinTimes(1)
 	ctrl.Call(subject, "FooMethod", "argument")
 	ctrl.Finish()
 
 	// It succeeds if there are many calls
 	reporter, ctrl = createFixtures(t)
 	subject = new(Subject)
-	ctrl.RecordCall(subject, "FooMethod", "argument").MinTimes(1)
+	ctrl.RecordCall(subject, "FooMethod", FooMethodType, "argument").MinTimes(1)
 	for i := 0; i < 100; i++ {
 		ctrl.Call(subject, "FooMethod", "argument")
 	}
@@ -240,20 +245,20 @@ func TestMaxTimes1(t *testing.T) {
 	// It succeeds if there are no calls
 	_, ctrl := createFixtures(t)
 	subject := new(Subject)
-	ctrl.RecordCall(subject, "FooMethod", "argument").MaxTimes(1)
+	ctrl.RecordCall(subject, "FooMethod", FooMethodType, "argument").MaxTimes(1)
 	ctrl.Finish()
 
 	// It succeeds if there is one call
 	_, ctrl = createFixtures(t)
 	subject = new(Subject)
-	ctrl.RecordCall(subject, "FooMethod", "argument").MaxTimes(1)
+	ctrl.RecordCall(subject, "FooMethod", FooMethodType, "argument").MaxTimes(1)
 	ctrl.Call(subject, "FooMethod", "argument")
 	ctrl.Finish()
 
 	//It fails if there are more
 	reporter, ctrl := createFixtures(t)
 	subject = new(Subject)
-	ctrl.RecordCall(subject, "FooMethod", "argument").MaxTimes(1)
+	ctrl.RecordCall(subject, "FooMethod", FooMethodType, "argument").MaxTimes(1)
 	ctrl.Call(subject, "FooMethod", "argument")
 	reporter.assertFatal(func() {
 		ctrl.Call(subject, "FooMethod", "argument")
@@ -265,7 +270,7 @@ func TestMinMaxTimes(t *testing.T) {
 	// It fails if there are less calls than specified
 	reporter, ctrl := createFixtures(t)
 	subject := new(Subject)
-	ctrl.RecordCall(subject, "FooMethod", "argument").MinTimes(2).MaxTimes(2)
+	ctrl.RecordCall(subject, "FooMethod", FooMethodType, "argument").MinTimes(2).MaxTimes(2)
 	ctrl.Call(subject, "FooMethod", "argument")
 	reporter.assertFatal(func() {
 		ctrl.Finish()
@@ -274,7 +279,7 @@ func TestMinMaxTimes(t *testing.T) {
 	// It fails if there are more calls than specified
 	reporter, ctrl = createFixtures(t)
 	subject = new(Subject)
-	ctrl.RecordCall(subject, "FooMethod", "argument").MinTimes(2).MaxTimes(2)
+	ctrl.RecordCall(subject, "FooMethod", FooMethodType, "argument").MinTimes(2).MaxTimes(2)
 	ctrl.Call(subject, "FooMethod", "argument")
 	ctrl.Call(subject, "FooMethod", "argument")
 	reporter.assertFatal(func() {
@@ -284,7 +289,7 @@ func TestMinMaxTimes(t *testing.T) {
 	// It succeeds if there is just the right number of calls
 	reporter, ctrl = createFixtures(t)
 	subject = new(Subject)
-	ctrl.RecordCall(subject, "FooMethod", "argument").MaxTimes(2).MinTimes(2)
+	ctrl.RecordCall(subject, "FooMethod", FooMethodType, "argument").MaxTimes(2).MinTimes(2)
 	ctrl.Call(subject, "FooMethod", "argument")
 	ctrl.Call(subject, "FooMethod", "argument")
 	ctrl.Finish()
@@ -296,7 +301,7 @@ func TestDo(t *testing.T) {
 
 	doCalled := false
 	var argument string
-	ctrl.RecordCall(subject, "FooMethod", "argument").Do(
+	ctrl.RecordCall(subject, "FooMethod", FooMethodType, "argument").Do(
 		func(arg string) {
 			doCalled = true
 			argument = arg
@@ -322,8 +327,8 @@ func TestReturn(t *testing.T) {
 	subject := new(Subject)
 
 	// Unspecified return should produce "zero" result.
-	ctrl.RecordCall(subject, "FooMethod", "zero")
-	ctrl.RecordCall(subject, "FooMethod", "five").Return(5)
+	ctrl.RecordCall(subject, "FooMethod", FooMethodType, "zero")
+	ctrl.RecordCall(subject, "FooMethod", FooMethodType, "five").Return(5)
 
 	assertEqual(
 		t,
@@ -343,10 +348,10 @@ func TestUnorderedCalls(t *testing.T) {
 	subjectTwo := new(Subject)
 	subjectOne := new(Subject)
 
-	ctrl.RecordCall(subjectOne, "FooMethod", "1")
-	ctrl.RecordCall(subjectOne, "BarMethod", "2")
-	ctrl.RecordCall(subjectTwo, "FooMethod", "3")
-	ctrl.RecordCall(subjectTwo, "BarMethod", "4")
+	ctrl.RecordCall(subjectOne, "FooMethod", FooMethodType, "1")
+	ctrl.RecordCall(subjectOne, "BarMethod", BarMethodType, "2")
+	ctrl.RecordCall(subjectTwo, "FooMethod", FooMethodType, "3")
+	ctrl.RecordCall(subjectTwo, "BarMethod", BarMethodType, "4")
 
 	// Make the calls in a different order, which should be fine.
 	ctrl.Call(subjectOne, "BarMethod", "2")
@@ -368,9 +373,9 @@ func commonTestOrderedCalls(t *testing.T) (reporter *ErrorReporter, ctrl *gomock
 	subjectTwo = new(Subject)
 
 	gomock.InOrder(
-		ctrl.RecordCall(subjectOne, "FooMethod", "1").AnyTimes(),
-		ctrl.RecordCall(subjectTwo, "FooMethod", "2"),
-		ctrl.RecordCall(subjectTwo, "BarMethod", "3"),
+		ctrl.RecordCall(subjectOne, "FooMethod", FooMethodType, "1").AnyTimes(),
+		ctrl.RecordCall(subjectTwo, "FooMethod", FooMethodType, "2"),
+		ctrl.RecordCall(subjectTwo, "BarMethod", BarMethodType, "3"),
 	)
 
 	return
@@ -423,9 +428,9 @@ func TestCallAfterLoopPanic(t *testing.T) {
 
 	subject := new(Subject)
 
-	firstCall := ctrl.RecordCall(subject, "Foo", "1")
-	secondCall := ctrl.RecordCall(subject, "Foo", "2")
-	thirdCall := ctrl.RecordCall(subject, "Foo", "3")
+	firstCall := ctrl.RecordCall(subject, "FooMethod", FooMethodType, "1")
+	secondCall := ctrl.RecordCall(subject, "FooMethod", FooMethodType, "2")
+	thirdCall := ctrl.RecordCall(subject, "FooMethod", FooMethodType, "3")
 
 	gomock.InOrder(firstCall, secondCall, thirdCall)
 
@@ -445,7 +450,7 @@ func TestPanicOverridesExpectationChecks(t *testing.T) {
 	reporter := NewErrorReporter(t)
 
 	reporter.assertFatal(func() {
-		ctrl.RecordCall(new(Subject), "FooMethod", "1")
+		ctrl.RecordCall(new(Subject), "FooMethod", FooMethodType, "1")
 		defer ctrl.Finish()
 		reporter.Fatalf("Intentional panic")
 	})
@@ -458,7 +463,7 @@ func TestSetArgWithBadType(t *testing.T) {
 	s := new(Subject)
 	// This should catch a type error:
 	rep.assertFatal(func() {
-		ctrl.RecordCall(s, "FooMethod", "1").SetArg(0, "blah")
+		ctrl.RecordCall(s, "FooMethod", FooMethodType, "1").SetArg(0, "blah")
 	})
 	ctrl.Call(s, "FooMethod", "1")
 }
@@ -468,7 +473,7 @@ func TestTimes0(t *testing.T) {
 	defer ctrl.Finish()
 
 	s := new(Subject)
-	ctrl.RecordCall(s, "FooMethod", "arg").Times(0)
+	ctrl.RecordCall(s, "FooMethod", FooMethodType, "arg").Times(0)
 	rep.assertFatal(func() {
 		ctrl.Call(s, "FooMethod", "arg")
 	})

gomock/mock_matcher/mock_matcher.go

@@ -193,6 +193,7 @@ func (g *generator) Generate(pkg *model.Package, pkgName string) error {
 	// Get all required imports, and generate unique names for them all.
 	im := pkg.Imports()
 	im[gomockImportPath] = true
+	im["reflect"] = true
 
 	// Sort keys to make import alias generation predictable
 	sorted_paths := make([]string, len(im), len(im))
@@ -424,7 +425,7 @@ func (g *generator) GenerateMockRecorderMethod(mockType string, m *model.Method)
 			callArgs = ", _s..."
 		}
 	}
-	g.p(`return _mr.mock.ctrl.RecordCall(_mr.mock, "%v"%v)`, m.Name, callArgs)
+	g.p(`return _mr.mock.ctrl.RecordCall(_mr.mock, "%s", reflect.TypeOf((*%s)(nil).%s)%s)`, m.Name, mockType, m.Name, callArgs)
 
 	g.out()
 	g.p("}")

mockgen/mockgen.go

@@ -0,0 +1 @@
+From #52, this tests an unexported method in the mocked interface.

mockgen/tests/unexported_method/README.md

@@ -0,0 +1,15 @@
+//go:generate mockgen -destination bugreport_mock.go -package bugreport -source=bugreport.go Example
+
+package bugreport
+
+import "fmt"
+
+// Example is an interface with a non exported method
+type Example interface {
+	someMethod(string) string
+}
+
+// CallExample is a simple function that uses the interface
+func CallExample(e Example) {
+	fmt.Println(e.someMethod("test"))
+}