GOMODULES
/
testify
mirror of https://github.com/stretchr/testify.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Merge branch 'master' into master

pull/1637/head
Bracken 2024-10-02 17:21:55 +01:00 committed by GitHub
parent f17409f81f 16a09b7086
commit 85a526818c
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
2 changed files with 21 additions and 24 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

35
mock/mock.go
View File

@ -505,11 +505,12 @@ func (m *Mock) MethodCalled(methodName string, arguments ...interface{}) Argumen
m.mutex.Unlock() m.mutex.Unlock()
if closestCall != nil { if closestCall != nil {
m.fail("\n\nmock: Unexpected Method Call\n-----------------------------\n\n%s\n\nThe closest call I have is: \n\n%s\n\n%s\nDiff: %s", m.fail("\n\nmock: Unexpected Method Call\n-----------------------------\n\n%s\n\nThe closest call I have is: \n\n%s\n\n%s\nDiff: %s\nat: %s\n",
callString(methodName, arguments, true), callString(methodName, arguments, true),
callString(methodName, closestCall.Arguments, true), callString(methodName, closestCall.Arguments, true),
diffArguments(closestCall.Arguments, arguments), diffArguments(closestCall.Arguments, arguments),
strings.TrimSpace(mismatch), strings.TrimSpace(mismatch),
assert.CallerInfo(),
) )
} else { } else {
m.fail("\nassert: mock: I don't know what to return because the method call was unexpected.\n\tEither do Mock.On(\"%s\").Return(...) first, or remove the %s() call.\n\tThis method was unexpected:\n\t\t%s\n\tat: %s", methodName, methodName, callString(methodName, arguments, true), assert.CallerInfo()) m.fail("\nassert: mock: I don't know what to return because the method call was unexpected.\n\tEither do Mock.On(\"%s\").Return(...) first, or remove the %s() call.\n\tThis method was unexpected:\n\t\t%s\n\tat: %s", methodName, methodName, callString(methodName, arguments, true), assert.CallerInfo())
@ -825,21 +826,20 @@ func IsType(t interface{}) *IsTypeArgument {
return &IsTypeArgument{t: reflect.TypeOf(t)} return &IsTypeArgument{t: reflect.TypeOf(t)}
} }
// FunctionalOptionsArgument is a struct that contains the type and value of an functional option argument // FunctionalOptionsArgument contains a list of functional options arguments
// for use when type checking. // expected for use when matching a list of arguments.
type FunctionalOptionsArgument struct { type FunctionalOptionsArgument struct {
value interface{} values []interface{}
} }
// String returns the string representation of FunctionalOptionsArgument // String returns the string representation of FunctionalOptionsArgument
func (f *FunctionalOptionsArgument) String() string { func (f *FunctionalOptionsArgument) String() string {
var name string var name string
tValue := reflect.ValueOf(f.value) if len(f.values) > 0 {
if tValue.Len() > 0 { name = "[]" + reflect.TypeOf(f.values[0]).String()
name = "[]" + reflect.TypeOf(tValue.Index(0).Interface()).String()
} }
return strings.Replace(fmt.Sprintf("%#v", f.value), "[]interface {}", name, 1) return strings.Replace(fmt.Sprintf("%#v", f.values), "[]interface {}", name, 1)
} }
// FunctionalOptions returns an [FunctionalOptionsArgument] object containing // FunctionalOptions returns an [FunctionalOptionsArgument] object containing
@ -847,10 +847,10 @@ func (f *FunctionalOptionsArgument) String() string {
// //
// For example: // For example:
// //
// Assert(t, FunctionalOptions(foo.Opt1("strValue"), foo.Opt2(613))) // args.Assert(t, FunctionalOptions(foo.Opt1("strValue"), foo.Opt2(613)))
func FunctionalOptions(value ...interface{}) *FunctionalOptionsArgument { func FunctionalOptions(values ...interface{}) *FunctionalOptionsArgument {
return &FunctionalOptionsArgument{ return &FunctionalOptionsArgument{
value: value, values: values,
} }
} }
@ -1004,20 +1004,17 @@ func (args Arguments) Diff(objects []interface{}) (string, int) {
output = fmt.Sprintf("%s\t%d: FAIL: type %s != type %s - %s\n", output, i, expected.t.Name(), actualT.Name(), actualFmt) output = fmt.Sprintf("%s\t%d: FAIL: type %s != type %s - %s\n", output, i, expected.t.Name(), actualT.Name(), actualFmt)
} }
case *FunctionalOptionsArgument: case *FunctionalOptionsArgument:
t := expected.value
var name string var name string
tValue := reflect.ValueOf(t) if len(expected.values) > 0 {
if tValue.Len() > 0 { name = "[]" + reflect.TypeOf(expected.values[0]).String()
name = "[]" + reflect.TypeOf(tValue.Index(0).Interface()).String()
} }
tName := reflect.TypeOf(t).Name() const tName = "[]interface{}"
if name != reflect.TypeOf(actual).String() && tValue.Len() != 0 { if name != reflect.TypeOf(actual).String() && len(expected.values) != 0 {
differences++ differences++
output = fmt.Sprintf("%s\t%d: FAIL: type %s != type %s - %s\n", output, i, tName, reflect.TypeOf(actual).Name(), actualFmt) output = fmt.Sprintf("%s\t%d: FAIL: type %s != type %s - %s\n", output, i, tName, reflect.TypeOf(actual).Name(), actualFmt)
} else { } else {
if ef, af := assertOpts(t, actual); ef == "" && af == "" { if ef, af := assertOpts(expected.values, actual); ef == "" && af == "" {
// match // match
output = fmt.Sprintf("%s\t%d: PASS: %s == %s\n", output, i, tName, tName) output = fmt.Sprintf("%s\t%d: PASS: %s == %s\n", output, i, tName, tName)
} else { } else {

10
mock/mock_test.go
View File

@ -2030,7 +2030,7 @@ func TestArgumentMatcherToPrintMismatch(t *testing.T) {
defer func() { defer func() {
if r := recover(); r != nil { if r := recover(); r != nil {
matchingExp := regexp.MustCompile( matchingExp := regexp.MustCompile(
`\s+mock: Unexpected Method Call\s+-*\s+GetTime\(int\)\s+0: 1\s+The closest call I have is:\s+GetTime\(mock.argumentMatcher\)\s+0: mock.argumentMatcher\{.*?\}\s+Diff:.*\(int=1\) not matched by func\(int\) bool`) `\s+mock: Unexpected Method Call\s+-*\s+GetTime\(int\)\s+0: 1\s+The closest call I have is:\s+GetTime\(mock.argumentMatcher\)\s+0: mock.argumentMatcher\{.*?\}\s+Diff:.*\(int=1\) not matched by func\(int\) bool\nat: \[[^\]]+mock\/mock_test.go`)
assert.Regexp(t, matchingExp, r) assert.Regexp(t, matchingExp, r)
} }
}() }()
@ -2047,7 +2047,7 @@ func TestArgumentMatcherToPrintMismatchWithReferenceType(t *testing.T) {
defer func() { defer func() {
if r := recover(); r != nil { if r := recover(); r != nil {
matchingExp := regexp.MustCompile( matchingExp := regexp.MustCompile(
`\s+mock: Unexpected Method Call\s+-*\s+GetTimes\(\[\]int\)\s+0: \[\]int\{1\}\s+The closest call I have is:\s+GetTimes\(mock.argumentMatcher\)\s+0: mock.argumentMatcher\{.*?\}\s+Diff:.*\(\[\]int=\[1\]\) not matched by func\(\[\]int\) bool`) `\s+mock: Unexpected Method Call\s+-*\s+GetTimes\(\[\]int\)\s+0: \[\]int\{1\}\s+The closest call I have is:\s+GetTimes\(mock.argumentMatcher\)\s+0: mock.argumentMatcher\{.*?\}\s+Diff:.*\(\[\]int=\[1\]\) not matched by func\(\[\]int\) bool\nat: \[[^\]]+mock\/mock_test.go`)
assert.Regexp(t, matchingExp, r) assert.Regexp(t, matchingExp, r)
} }
}() }()
@ -2078,7 +2078,7 @@ func TestClosestCallMismatchedArgumentInformationShowsTheClosest(t *testing.T) {
func TestClosestCallFavorsFirstMock(t *testing.T) { func TestClosestCallFavorsFirstMock(t *testing.T) {
defer func() { defer func() {
if r := recover(); r != nil { if r := recover(); r != nil {
diffRegExp := `Difference found in argument 0:\s+--- Expected\s+\+\+\+ Actual\s+@@ -2,4 \+2,4 @@\s+\(bool\) true,\s+- \(bool\) true,\s+- \(bool\) true\s+\+ \(bool\) false,\s+\+ \(bool\) false\s+}\s+` diffRegExp := `Difference found in argument 0:\s+--- Expected\s+\+\+\+ Actual\s+@@ -2,4 \+2,4 @@\s+\(bool\) true,\s+- \(bool\) true,\s+- \(bool\) true\s+\+ \(bool\) false,\s+\+ \(bool\) false\s+}\s+Diff: 0: FAIL: \(\[\]bool=\[(true\s?|false\s?){3}]\) != \(\[\]bool=\[(true\s?|false\s?){3}\]\)`
matchingExp := regexp.MustCompile(unexpectedCallRegex(`TheExampleMethod7([]bool)`, `0: \[\]bool{true, false, false}`, `0: \[\]bool{true, true, true}`, diffRegExp)) matchingExp := regexp.MustCompile(unexpectedCallRegex(`TheExampleMethod7([]bool)`, `0: \[\]bool{true, false, false}`, `0: \[\]bool{true, true, true}`, diffRegExp))
assert.Regexp(t, matchingExp, r) assert.Regexp(t, matchingExp, r)
} }
@ -2094,7 +2094,7 @@ func TestClosestCallFavorsFirstMock(t *testing.T) {
func TestClosestCallUsesRepeatabilityToFindClosest(t *testing.T) { func TestClosestCallUsesRepeatabilityToFindClosest(t *testing.T) {
defer func() { defer func() {
if r := recover(); r != nil { if r := recover(); r != nil {
diffRegExp := `Difference found in argument 0:\s+--- Expected\s+\+\+\+ Actual\s+@@ -1,4 \+1,4 @@\s+\(\[\]bool\) \(len=3\) {\s+- \(bool\) false,\s+- \(bool\) false,\s+\+ \(bool\) true,\s+\+ \(bool\) true,\s+\(bool\) false\s+` diffRegExp := `Difference found in argument 0:\s+--- Expected\s+\+\+\+ Actual\s+@@ -1,4 \+1,4 @@\s+\(\[\]bool\) \(len=3\) {\s+- \(bool\) false,\s+- \(bool\) false,\s+\+ \(bool\) true,\s+\+ \(bool\) true,\s+\(bool\) false\s+Diff: 0: FAIL: \(\[\]bool=\[(true\s?|false\s?){3}]\) != \(\[\]bool=\[(true\s?|false\s?){3}\]\)`
matchingExp := regexp.MustCompile(unexpectedCallRegex(`TheExampleMethod7([]bool)`, `0: \[\]bool{true, true, false}`, `0: \[\]bool{false, false, false}`, diffRegExp)) matchingExp := regexp.MustCompile(unexpectedCallRegex(`TheExampleMethod7([]bool)`, `0: \[\]bool{true, true, false}`, `0: \[\]bool{false, false, false}`, diffRegExp))
assert.Regexp(t, matchingExp, r) assert.Regexp(t, matchingExp, r)
} }
@ -2151,7 +2151,7 @@ func Test_isBetterMatchThanReturnsFalseIfRepeatabilityIsLessThanOrEqualToOther(t
func unexpectedCallRegex(method, calledArg, expectedArg, diff string) string { func unexpectedCallRegex(method, calledArg, expectedArg, diff string) string {
rMethod := regexp.QuoteMeta(method) rMethod := regexp.QuoteMeta(method)
return fmt.Sprintf(`\s+mock: Unexpected Method Call\s+-*\s+%s\s+%s\s+The closest call I have is:\s+%s\s+%s\s+%s`, return fmt.Sprintf(`\s+mock: Unexpected Method Call\s+-*\s+%s\s+%s\s+The closest call I have is:\s+%s\s+%s\s+%s\nat: \[[^\]]+mock\/mock_test.go`,
rMethod, calledArg, rMethod, expectedArg, diff) rMethod, calledArg, rMethod, expectedArg, diff)
} }