bump gotest.tools v2.3.0, google/go-cmp v0.2.0

Signed-off-by: Sebastiaan van Stijn <github@gone.nl>

vendor/gotest.tools/assert/cmp/compare.go

@@ -4,6 +4,7 @@ package cmp // import "gotest.tools/assert/cmp"
 import (
 	"fmt"
 	"reflect"
+	"regexp"
 	"strings"
 
 	"github.com/google/go-cmp/cmp"
@@ -58,6 +59,39 @@ func toResult(success bool, msg string) Result {
 	return ResultFailure(msg)
 }
 
+// RegexOrPattern may be either a *regexp.Regexp or a string that is a valid
+// regexp pattern.
+type RegexOrPattern interface{}
+
+// Regexp succeeds if value v matches regular expression re.
+//
+// Example:
+//   assert.Assert(t, cmp.Regexp("^[0-9a-f]{32}$", str))
+//   r := regexp.MustCompile("^[0-9a-f]{32}$")
+//   assert.Assert(t, cmp.Regexp(r, str))
+func Regexp(re RegexOrPattern, v string) Comparison {
+	match := func(re *regexp.Regexp) Result {
+		return toResult(
+			re.MatchString(v),
+			fmt.Sprintf("value %q does not match regexp %q", v, re.String()))
+	}
+
+	return func() Result {
+		switch regex := re.(type) {
+		case *regexp.Regexp:
+			return match(regex)
+		case string:
+			re, err := regexp.Compile(regex)
+			if err != nil {
+				return ResultFailure(err.Error())
+			}
+			return match(re)
+		default:
+			return ResultFailure(fmt.Sprintf("invalid type %T for regex pattern", regex))
+		}
+	}
+}
+
 // Equal succeeds if x == y. See assert.Equal for full documentation.
 func Equal(x, y interface{}) Comparison {
 	return func() Result {
@@ -186,7 +220,7 @@ func Error(err error, message string) Comparison {
 			return ResultFailure("expected an error, got nil")
 		case err.Error() != message:
 			return ResultFailure(fmt.Sprintf(
-				"expected error %q, got %+v", message, err))
+				"expected error %q, got %s", message, formatErrorMessage(err)))
 		}
 		return ResultSuccess
 	}
@@ -201,12 +235,22 @@ func ErrorContains(err error, substring string) Comparison {
 			return ResultFailure("expected an error, got nil")
 		case !strings.Contains(err.Error(), substring):
 			return ResultFailure(fmt.Sprintf(
-				"expected error to contain %q, got %+v", substring, err))
+				"expected error to contain %q, got %s", substring, formatErrorMessage(err)))
 		}
 		return ResultSuccess
 	}
 }
 
+func formatErrorMessage(err error) string {
+	if _, ok := err.(interface {
+		Cause() error
+	}); ok {
+		return fmt.Sprintf("%q\n%+v", err, err)
+	}
+	// This error was not wrapped with github.com/pkg/errors
+	return fmt.Sprintf("%q", err)
+}
+
 // Nil succeeds if obj is a nil interface, pointer, or function.
 //
 // Use NilError() for comparing errors. Use Len(obj, 0) for comparing slices,

vendor/gotest.tools/assert/cmp/result.go

@@ -9,31 +9,37 @@ import (
 	"gotest.tools/internal/source"
 )
 
-// Result of a Comparison.
+// A Result of a Comparison.
 type Result interface {
 	Success() bool
 }
 
-type result struct {
+// StringResult is an implementation of Result that reports the error message
+// string verbatim and does not provide any templating or formatting of the
+// message.
+type StringResult struct {
 	success bool
 	message string
 }
 
-func (r result) Success() bool {
+// Success returns true if the comparison was successful.
+func (r StringResult) Success() bool {
 	return r.success
 }
 
-func (r result) FailureMessage() string {
+// FailureMessage returns the message used to provide additional information
+// about the failure.
+func (r StringResult) FailureMessage() string {
 	return r.message
 }
 
 // ResultSuccess is a constant which is returned by a ComparisonWithResult to
 // indicate success.
-var ResultSuccess = result{success: true}
+var ResultSuccess = StringResult{success: true}
 
 // ResultFailure returns a failed Result with a failure message.
-func ResultFailure(message string) Result {
-	return result{message: message}
+func ResultFailure(message string) StringResult {
+	return StringResult{message: message}
 }
 
 // ResultFromError returns ResultSuccess if err is nil. Otherwise ResultFailure