Merge pull request #1775 from mutaiib/bugfix/panic-methodcalled-mutex-release-1731

mock: avoid panic when expected type is nil in Arguments.Diff

Author: brackendawson

mock/mock.go

@@ -833,6 +833,10 @@ type IsTypeArgument struct {
 // For example:
 //
 //	args.Assert(t, IsType(""), IsType(0))
+//
+// Mock cannot match interface types because the contained type will be  passed
+// to both IsType and Mock.Called, for the zero value of all interfaces this
+// will be <nil> type.
 func IsType(t interface{}) *IsTypeArgument {
 	return &IsTypeArgument{t: reflect.TypeOf(t)}
 }
@@ -1034,7 +1038,7 @@ func (args Arguments) Diff(objects []interface{}) (string, int) {
 				if actualT != expected.t {
 					differences++
 					outputRenderers = append(outputRenderers, func() string {
-						return fmt.Sprintf("\t%d: FAIL:  type %s != type %s - %s\n", i, expected.t.Name(), actualT.Name(), actualFmt())
+						return fmt.Sprintf("\t%d: FAIL:  type %s != type %s - %s\n", i, safeTypeName(expected.t), actualT, actualFmt())
 					})
 				}
 			case *FunctionalOptionsArgument:
@@ -1179,6 +1183,15 @@ func (args Arguments) Bool(index int) bool {
 	return s
 }
 
+// safeTypeName returns the reflect.Type's name without causing a panic.
+// If the provided reflect.Type is nil, it returns the placeholder string "<nil>"
+func safeTypeName(t reflect.Type) string {
+	if t == nil {
+		return "<nil>"
+	}
+	return t.Name()
+}
+
 func typeAndKind(v interface{}) (reflect.Type, reflect.Kind) {
 	t := reflect.TypeOf(v)
 	k := t.Kind()

mock/mock_test.go

@@ -1,6 +1,7 @@
 package mock
 
 import (
+	"context"
 	"errors"
 	"fmt"
 	"regexp"
@@ -1998,6 +1999,25 @@ func Test_Arguments_Diff_WithIsTypeArgument_Failing(t *testing.T) {
 	assert.Contains(t, diff, `string != type int - (int=123)`)
 }
 
+func Test_Arguments_Diff_WithIsTypeArgument_InterfaceType(t *testing.T) {
+	t.Parallel()
+	var ctx = context.Background()
+	args := Arguments([]interface{}{IsType(ctx)})
+	_, count := args.Diff([]interface{}{context.Background()})
+	assert.Equal(t, 0, count)
+}
+
+func Test_Arguments_Diff_WithIsTypeArgument_InterfaceType_Failing(t *testing.T) {
+	t.Parallel()
+
+	var ctx context.Context
+	var args = Arguments([]interface{}{IsType(ctx)})
+	diff, count := args.Diff([]interface{}{context.Background()})
+	assert.Equal(t, 1, count)
+	assert.Contains(t, diff, `type <nil> != type `)
+
+}
+
 func Test_Arguments_Diff_WithArgMatcher(t *testing.T) {
 	t.Parallel()