call.go

// Copyright 2010 Google Inc.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

package gomock

import (
	"encoding/json"
	"fmt"
	"io"
	"io/ioutil"
	"reflect"
	"strconv"
	"strings"

	"github.com/davecgh/go-spew/spew"
	"github.com/pmezard/go-difflib/difflib"
)

// Call represents an expected call to a mock.
type Call struct {
	t TestHelper // for triggering test failures on invalid call setup

	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
	origin     string       // file and line number of call setup

	preReqs []*Call // prerequisite calls

	// Expectations
	minCalls, maxCalls int

	numCalls int // actual number made

	// actions are called when this Call is called. Each action gets the args and
	// can set the return values by returning a non-nil slice. Actions run in the
	// order they are created.
	actions []func([]interface{}) []interface{}
}

// newCall creates a *Call. It requires the method type in order to support
// unexported methods.
func newCall(t TestHelper, receiver interface{}, method string, methodType reflect.Type, args ...interface{}) *Call {
	t.Helper()

	// TODO: check arity, types.
	margs := make([]Matcher, len(args))
	for i, arg := range args {
		if m, ok := arg.(Matcher); ok {
			margs[i] = m
		} else if arg == nil {
			// Handle nil specially so that passing a nil interface value
			// will match the typed nils of concrete args.
			margs[i] = Nil()
		} else {
			margs[i] = Eq(arg)
		}
	}

	// callerInfo's skip should be updated if the number of calls between the user's test
	// and this line changes, i.e. this code is wrapped in another anonymous function.
	// 0 is us, 1 is RecordCallWithMethodType(), 2 is the generated recorder, and 3 is the user's test.
	origin := callerInfo(3)
	actions := []func([]interface{}) []interface{}{func([]interface{}) []interface{} {
		// Synthesize the zero value for each of the return args' types.
		rets := make([]interface{}, methodType.NumOut())
		for i := 0; i < methodType.NumOut(); i++ {
			rets[i] = reflect.Zero(methodType.Out(i)).Interface()
		}
		return rets
	}}
	return &Call{t: t, receiver: receiver, method: method, methodType: methodType,
		args: margs, origin: origin, minCalls: 1, maxCalls: 1, actions: actions}
}

// AnyTimes allows the expectation to be called 0 or more times
func (c *Call) AnyTimes() *Call {
	c.minCalls, c.maxCalls = 0, 1e8 // close enough to infinity
	return c
}

// MinTimes requires the call to occur at least n times. If AnyTimes or MaxTimes have not been called or if MaxTimes
// was previously called with 1, MinTimes also sets the maximum number of calls to infinity.
func (c *Call) MinTimes(n int) *Call {
	c.minCalls = n
	if c.maxCalls == 1 {
		c.maxCalls = 1e8
	}
	return c
}

// MaxTimes limits the number of calls to n times. If AnyTimes or MinTimes have not been called or if MinTimes was
// previously called with 1, MaxTimes also sets the minimum number of calls to 0.
func (c *Call) MaxTimes(n int) *Call {
	c.maxCalls = n
	if c.minCalls == 1 {
		c.minCalls = 0
	}
	return c
}

// DoAndReturn declares the action to run when the call is matched.
// The return values from this function are returned by the mocked function.
// It takes an interface{} argument to support n-arity functions.
func (c *Call) DoAndReturn(f interface{}) *Call {
	// TODO: Check arity and types here, rather than dying badly elsewhere.
	v := reflect.ValueOf(f)

	c.addAction(func(args []interface{}) []interface{} {
		vargs := make([]reflect.Value, len(args))
		ft := v.Type()
		for i := 0; i < len(args); i++ {
			if args[i] != nil {
				vargs[i] = reflect.ValueOf(args[i])
			} else {
				// Use the zero value for the arg.
				vargs[i] = reflect.Zero(ft.In(i))
			}
		}
		vrets := v.Call(vargs)
		rets := make([]interface{}, len(vrets))
		for i, ret := range vrets {
			rets[i] = ret.Interface()
		}
		return rets
	})
	return c
}

// Do declares the action to run when the call is matched. The function's
// return values are ignored to retain backward compatibility. To use the
// return values call DoAndReturn.
// It takes an interface{} argument to support n-arity functions.
func (c *Call) Do(f interface{}) *Call {
	// TODO: Check arity and types here, rather than dying badly elsewhere.
	v := reflect.ValueOf(f)

	c.addAction(func(args []interface{}) []interface{} {
		vargs := make([]reflect.Value, len(args))
		ft := v.Type()
		for i := 0; i < len(args); i++ {
			if args[i] != nil {
				vargs[i] = reflect.ValueOf(args[i])
			} else {
				// Use the zero value for the arg.
				vargs[i] = reflect.Zero(ft.In(i))
			}
		}
		v.Call(vargs)
		return nil
	})
	return c
}

// Return declares the values to be returned by the mocked function call.
func (c *Call) Return(rets ...interface{}) *Call {
	c.t.Helper()

	mt := c.methodType
	if len(rets) != mt.NumOut() {
		c.t.Fatalf("wrong number of arguments to Return for %T.%v: got %d, want %d [%s]",
			c.receiver, c.method, len(rets), mt.NumOut(), c.origin)
	}
	for i, ret := range rets {
		if got, want := reflect.TypeOf(ret), mt.Out(i); got == want {
			// Identical types; nothing to do.
		} else if got == nil {
			// Nil needs special handling.
			switch want.Kind() {
			case reflect.Chan, reflect.Func, reflect.Interface, reflect.Map, reflect.Ptr, reflect.Slice:
				// ok
			default:
				c.t.Fatalf("argument %d to Return for %T.%v is nil, but %v is not nillable [%s]",
					i, c.receiver, c.method, want, c.origin)
			}
		} else if got.AssignableTo(want) {
			// Assignable type relation. Make the assignment now so that the generated code
			// can return the values with a type assertion.
			v := reflect.New(want).Elem()
			v.Set(reflect.ValueOf(ret))
			rets[i] = v.Interface()
		} else {
			c.t.Fatalf("wrong type of argument %d to Return for %T.%v: %v is not assignable to %v [%s]",
				i, c.receiver, c.method, got, want, c.origin)
		}
	}

	c.addAction(func([]interface{}) []interface{} {
		return rets
	})

	return c
}

// Times declares the exact number of times a function call is expected to be executed.
func (c *Call) Times(n int) *Call {
	c.minCalls, c.maxCalls = n, n
	return c
}

// SetArg declares an action that will set the nth argument's value,
// indirected through a pointer. Or, in the case of a slice, SetArg
// will copy value's elements into the nth argument.
func (c *Call) SetArg(n int, value interface{}) *Call {
	c.t.Helper()

	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() {
		c.t.Fatalf("SetArg(%d, ...) called for a method with %d args [%s]",
			n, mt.NumIn(), c.origin)
	}
	// Permit setting argument through an interface.
	// In the interface case, we don't (nay, can't) check the type here.
	at := mt.In(n)
	switch at.Kind() {
	case reflect.Ptr:
		dt := at.Elem()
		if vt := reflect.TypeOf(value); !vt.AssignableTo(dt) {
			c.t.Fatalf("SetArg(%d, ...) argument is a %v, not assignable to %v [%s]",
				n, vt, dt, c.origin)
		}
	case reflect.Interface:
		// nothing to do
	case reflect.Slice:
		// nothing to do
	default:
		c.t.Fatalf("SetArg(%d, ...) referring to argument of non-pointer non-interface non-slice type %v [%s]",
			n, at, c.origin)
	}

	c.addAction(func(args []interface{}) []interface{} {
		v := reflect.ValueOf(value)
		switch reflect.TypeOf(args[n]).Kind() {
		case reflect.Slice:
			setSlice(args[n], v)
		default:
			reflect.ValueOf(args[n]).Elem().Set(v)
		}
		return nil
	})
	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 {
		if other == preReq || preReq.isPreReq(other) {
			return true
		}
	}
	return false
}

// After declares that the call may only match after preReq has been exhausted.
func (c *Call) After(preReq *Call) *Call {
	c.t.Helper()

	if c == preReq {
		c.t.Fatalf("A call isn't allowed to be its own prerequisite")
	}
	if preReq.isPreReq(c) {
		c.t.Fatalf("Loop in call order: %v is a prerequisite to %v (possibly indirectly).", c, preReq)
	}

	c.preReqs = append(c.preReqs, preReq)
	return c
}

// Returns true if the minimum number of calls have been made.
func (c *Call) satisfied() bool {
	return c.numCalls >= c.minCalls
}

// Returns true if the maximum number of calls have been made.
func (c *Call) exhausted() bool {
	return c.numCalls >= c.maxCalls
}

func (c *Call) String() string {
	args := make([]string, len(c.args))
	for i, arg := range c.args {
		sarg := fmt.Sprintf("arg%d: %s", i, arg.String())
		if len(sarg) > 75 {
			sarg = sarg[:72] + "..."
		}
		args[i] = sarg
	}
	arguments := strings.Join(args, ",\n  ")
	if len(args) > 1 {
		arguments = "\n  " + arguments + ",\n"
	}
	return fmt.Sprintf("%T.%v(%s) %s", c.receiver, c.method, arguments, c.origin)
}

// Tests if the given call matches the expected call.
// If yes, returns nil. If no, returns error with message explaining why it does not match.
func (c *Call) matches(args []interface{}) error {
	if !c.methodType.IsVariadic() {
		if len(args) != len(c.args) {
			return fmt.Errorf("expected call at %s has the wrong number of arguments. Got: %d, want: %d",
				c.origin, len(args), len(c.args))
		}

		var argMatchError error
		for i, m := range c.args {
			if !m.Matches(args[i]) {
				if argMatchError == nil {
					argMatchError = fmt.Errorf("Expected call at %s doesn't match the argument at index %s.\n%s",
						c.origin, strconv.Itoa(i), diff(args[i], m))
				} else {
					argMatchError = fmt.Errorf("%sExpected call at %s doesn't match the argument at index %s.\n%s",
						argMatchError, c.origin, strconv.Itoa(i), diff(args[i], m))
				}
			}
		}
		if argMatchError != nil {
			return argMatchError
		}
	} else {
		if len(c.args) < c.methodType.NumIn()-1 {
			return fmt.Errorf("expected call at %s has the wrong number of matchers. Got: %d, want: %d",
				c.origin, len(c.args), c.methodType.NumIn()-1)
		}
		if len(c.args) != c.methodType.NumIn() && len(args) != len(c.args) {
			return fmt.Errorf("expected call at %s has the wrong number of arguments. Got: %d, want: %d",
				c.origin, len(args), len(c.args))
		}
		if len(args) < len(c.args)-1 {
			return fmt.Errorf("expected call at %s has the wrong number of arguments. Got: %d, want: greater than or equal to %d",
				c.origin, len(args), len(c.args)-1)
		}

		for i, m := range c.args {
			if i < c.methodType.NumIn()-1 {
				// Non-variadic args
				if !m.Matches(args[i]) {
					return fmt.Errorf("Expected call at %s doesn't match the argument at index %s.\n%s",
						c.origin, strconv.Itoa(i), diff(args[i], m))
				}
				continue
			}
			// The last arg has a possibility of a variadic argument, so let it branch

			// sample: Foo(a int, b int, c ...int)
			if i < len(c.args) && i < len(args) {
				if m.Matches(args[i]) {
					// Got Foo(a, b, c) want Foo(matcherA, matcherB, gomock.Any())
					// Got Foo(a, b, c) want Foo(matcherA, matcherB, someSliceMatcher)
					// Got Foo(a, b, c) want Foo(matcherA, matcherB, matcherC)
					// Got Foo(a, b) want Foo(matcherA, matcherB)
					// Got Foo(a, b, c, d) want Foo(matcherA, matcherB, matcherC, matcherD)
					continue
				} else {
				}
			}

			// The number of actual args don't match the number of matchers,
			// or the last matcher is a slice and the last arg is not.
			// If this function still matches it is because the last matcher
			// matches all the remaining arguments or the lack of any.
			// Convert the remaining arguments, if any, into a slice of the
			// expected type.
			vargsType := c.methodType.In(c.methodType.NumIn() - 1)
			vargs := reflect.MakeSlice(vargsType, 0, len(args)-i)
			for _, arg := range args[i:] {
				vargs = reflect.Append(vargs, reflect.ValueOf(arg))
			}
			if m.Matches(vargs.Interface()) {
				// Got Foo(a, b, c, d, e) want Foo(matcherA, matcherB, gomock.Any())
				// Got Foo(a, b, c, d, e) want Foo(matcherA, matcherB, someSliceMatcher)
				// Got Foo(a, b) want Foo(matcherA, matcherB, gomock.Any())
				// Got Foo(a, b) want Foo(matcherA, matcherB, someEmptySliceMatcher)
				break
			}
			// Wrong number of matchers or not match. Fail.
			// Got Foo(a, b) want Foo(matcherA, matcherB, matcherC, matcherD)
			// Got Foo(a, b, c) want Foo(matcherA, matcherB, matcherC, matcherD)
			// Got Foo(a, b, c, d) want Foo(matcherA, matcherB, matcherC, matcherD, matcherE)
			// Got Foo(a, b, c, d, e) want Foo(matcherA, matcherB, matcherC, matcherD)
			// Got Foo(a, b, c) want Foo(matcherA, matcherB)
			//return fmt.Errorf("Expected call at %s doesn't match the argument at index %s.\n%s",
			//	c.origin, strconv.Itoa(i), diff(args[i], m))
			return fmt.Errorf("expected call at %s doesn't match the argument at index %s.\nGot: %v\nWant: %v",
				c.origin, strconv.Itoa(i), formatGottenArg(m, args[i:]), c.args[i])
		}
	}

	// Check that all prerequisite calls have been satisfied.
	for _, preReqCall := range c.preReqs {
		if !preReqCall.satisfied() {
			return fmt.Errorf("Expected call at %s doesn't have a prerequisite call satisfied:\n%v\nshould be called before:\n%v",
				c.origin, preReqCall, c)
		}
	}

	// Check that the call is not exhausted.
	if c.exhausted() {
		return fmt.Errorf("expected call at %s has already been called the max number of times", c.origin)
	}

	return nil
}

// dropPrereqs tells the expected Call to not re-check prerequisite calls any
// longer, and to return its current set.
func (c *Call) dropPrereqs() (preReqs []*Call) {
	preReqs = c.preReqs
	c.preReqs = nil
	return
}

func (c *Call) call() []func([]interface{}) []interface{} {
	c.numCalls++
	return c.actions
}

// InOrder declares that the given calls should occur in order.
func InOrder(calls ...*Call) {
	for i := 1; i < len(calls); i++ {
		calls[i].After(calls[i-1])
	}
}

func setSlice(arg interface{}, v reflect.Value) {
	va := reflect.ValueOf(arg)
	for i := 0; i < v.Len(); i++ {
		va.Index(i).Set(v.Index(i))
	}
}

func (c *Call) addAction(action func([]interface{}) []interface{}) {
	c.actions = append(c.actions, action)
}

func formatGottenArg(m Matcher, arg interface{}) string {
	got := fmt.Sprintf("%v", arg)
	if gs, ok := m.(GotFormatter); ok {
		got = gs.Got(arg)
	}
	return got
}

var spewConfig = spew.ConfigState{
	Indent:                  " ",
	DisablePointerAddresses: true,
	DisableCapacities:       true,
	SortKeys:                true,
}

// diff returns a diff of both values as long as both are of the same type and
// are a struct, map, slice, array or string. Otherwise it tries its best to return something useful
func diff(actualOrig interface{}, matcher Matcher) string {
	// first, use the Got func if we have one
	if gs, ok := matcher.(GotFormatter); ok {
		return fmt.Sprintf("Got: %s\nWant: %s", gs.Got(actualOrig), matcher.String())
	}

	var actual interface{}
	var expected interface{}
	if diffable, ok := matcher.(DiffableMatcher); ok {
		expected = diffable.Value()
		if diffable, ok := actualOrig.(DiffableMatcher); ok {
			actual = diffable.Value()
		} else {
			actual = actualOrig
		}
	} else {
		expected = matcher.String() // keep the types the same
		actual = fmt.Sprintf("%s", actualOrig)
	}
	if expected == nil || actual == nil {
		return fmt.Sprintf("Got: %v\nWant: %v", actual, matcher.String())
	}

	et, ek, _ := typeAndKindAndValue(expected)
	at, _, _ := typeAndKindAndValue(actual)

	if et != at {
		return fmt.Sprintf("Incorrect types. Got: %v Want: %v", at, et)
	}

	if ek != reflect.Struct && ek != reflect.Map && ek != reflect.Slice && ek != reflect.Array && ek != reflect.String {
		return fmt.Sprintf("Got: %v\nWant: %v", actual, matcher.String())
	}

	var e, a string
	if et != reflect.TypeOf("") {
		e = strings.ReplaceAll(spewConfig.Sdump(expected), "\\n", "\n")
		a = strings.ReplaceAll(spewConfig.Sdump(actual), "\\n", "\n")
	} else {
		e = reflect.ValueOf(expected).String()
		a = reflect.ValueOf(actual).String()
	}

	// maybe the data is a json string, in which case it should be formatted as such
	e, a = maybeJson(e, a, expected, actual)

	diff, _ := difflib.GetUnifiedDiffString(difflib.UnifiedDiff{
		A:        difflib.SplitLines(a),
		B:        difflib.SplitLines(e),
		FromFile: "Got",
		FromDate: "",
		ToFile:   "Want",
		ToDate:   "",
		Context:  0,
	})

	return "Diff:\n" + diff
}

func typeAndKindAndValue(v interface{}) (reflect.Type, reflect.Kind, reflect.Value) {
	t := reflect.TypeOf(v)
	k := t.Kind()
	va := reflect.Indirect(reflect.ValueOf(v))

	if k == reflect.Ptr {
		t = t.Elem()
		k = t.Kind()
	}
	return t, k, va
}

func maybeJson(eOrig string, aOrig string, expected interface{}, actual interface{}) (eOut string, aOut string) {
	eObj := map[string]interface{}{}
	aObj := map[string]interface{}{}

	eBytes := originalBytes(eOrig, expected)
	aBytes := originalBytes(aOrig, actual)

	eErr := json.Unmarshal(eBytes, &eObj)
	aErr := json.Unmarshal(aBytes, &aObj)

	if eErr == nil && aErr == nil { // we only dump them as json if they are both json
		// both were json
		eOut = spewConfig.Sdump(eObj)
		aOut = spewConfig.Sdump(aObj)
	} else if eErr == nil && aErr != nil {
		// expected is json, actual is not
		eOut = "Valid JSON"
		aOut = "Invalid JSON: " + aErr.Error()
	} else if aErr == nil && eErr != nil {
		// actual is json, expected is not
		aOut = "Valid JSON"
		eOut = "Invalid JSON: " + eErr.Error()
	} else {
		// neither was json
		eOut = eOrig
		aOut = aOrig
	}

	return
}

func originalBytes(orig string, unknown interface{}) []byte {
	if s, ok := unknown.(io.Reader); ok {
		reset(s)
		bytes, _ := ioutil.ReadAll(s) // no one else will read it, so I may as well
		reset(s)
		return bytes
	} else if s, ok := unknown.(fmt.Stringer); ok {
		bytes := []byte(s.String())
		return bytes
	}
	if bytes, err := json.Marshal(unknown); err == nil {
		return bytes
	}

	return []byte(orig)
}

// for the debugs
func allTheTypes(unknown interface{}) string {
	ut, uk, uv := typeAndKindAndValue(unknown)
	switch uk {
	case reflect.Struct:
		return structTypes(ut, uv)
	case reflect.Map:
		return mapTypes(ut, uv)
	case reflect.Slice:
		return sliceTypes(ut, uv)
	case reflect.Array:
		return sliceTypes(ut, uv)
	}

	return fmt.Sprintf("%T", unknown)
}

func structTypes(ut reflect.Type, uv reflect.Value) string {
	values := make([]string, uv.NumField())

	for i := 0; i < uv.NumField(); i++ {
		typeField := ut.Field(i)
		valueField := uv.Field(i)
		if valueField.CanSet() {
			values[i] = fmt.Sprintf("%s:%s", typeField.Name, allTheTypes(valueField.Interface()))
		} else {
			values[i] = fmt.Sprintf("%s:%s", typeField.Name, "unexported")
		}
	}

	return "[" + strings.Join(values, " ") + "]"
}

func mapTypes(ut reflect.Type, uv reflect.Value) string {
	start := fmt.Sprintf("[%v", reflect.MapOf(ut.Key(), ut.Elem()))
	iter := uv.MapRange()
	for iter.Next() {
		k := iter.Key()
		v := iter.Value()
		start = fmt.Sprintf("%s %s:%s", start, k, allTheTypes(v.Interface()))
	}

	return start + "]"
}

func sliceTypes(ut reflect.Type, uv reflect.Value) string {
	middle := make([]string, uv.Len())
	for i := 0; i < uv.Len(); i++ {
		v := uv.Index(i)
		middle[i] = allTheTypes(v.Interface())
	}
	return fmt.Sprintf("[]%s{%s}", getType(ut), strings.Join(middle, " "))
}

func getType(ut reflect.Type) string {
	if ut.Kind() == reflect.Ptr {
		return "*" + ut.Elem().Name()
	} else {
		name := ut.Name()
		if name == "" {
			return "interface{}"
		}
		return name
	}
}

func reset(r io.Reader) {
	if s, ok := r.(io.Seeker); ok {
		s.Seek(0, 0)
	}
}