Bump github.com/onsi/gomega from 1.13.0 to 1.14.0

Bumps [github.com/onsi/gomega](https://github.com/onsi/gomega) from 1.13.0 to 1.14.0.
- [Release notes](https://github.com/onsi/gomega/releases)
- [Changelog](https://github.com/onsi/gomega/blob/master/CHANGELOG.md)
- [Commits](https://github.com/onsi/gomega/compare/v1.13.0...v1.14.0)

---
updated-dependencies:
- dependency-name: github.com/onsi/gomega
  dependency-type: direct:production
  update-type: version-update:semver-minor
...

Signed-off-by: dependabot[bot] <support@github.com>

1 files changed, 74 insertions, 14 deletions

diff --git a/vendor/github.com/onsi/gomega/gomega_dsl.go b/vendor/github.com/onsi/gomega/gomega_dsl.go
index a05b34b27..67f6e45c1 100644
--- a/vendor/github.com/onsi/gomega/gomega_dsl.go
+++ b/vendor/github.com/onsi/gomega/gomega_dsl.go
@@ -14,6 +14,7 @@ Gomega is MIT-Licensed
 package gomega
 
 import (
+	"errors"
 	"fmt"
 	"reflect"
 	"time"
@@ -24,7 +25,7 @@ import (
 	"github.com/onsi/gomega/types"
 )
 
-const GOMEGA_VERSION = "1.13.0"
+const GOMEGA_VERSION = "1.14.0"
 
 const nilFailHandlerPanic = `You are trying to make an assertion, but Gomega's fail handler is nil.
 If you're using Ginkgo then you probably forgot to put your assertion in an It().
@@ -91,10 +92,8 @@ func RegisterTestingT(t types.GomegaTestingT) {
 
 // InterceptGomegaFailures runs a given callback and returns an array of
 // failure messages generated by any Gomega assertions within the callback.
-//
-// This is accomplished by temporarily replacing the *global* fail handler
-// with a fail handler that simply annotates failures.  The original fail handler
-// is reset when InterceptGomegaFailures returns.
+// Exeuction continues after the first failure allowing users to collect all failures
+// in the callback.
 //
 // This is most useful when testing custom matchers, but can also be used to check
 // on a value using a Gomega assertion without causing a test failure.
@@ -104,11 +103,39 @@ func InterceptGomegaFailures(f func()) []string {
 	RegisterFailHandler(func(message string, callerSkip ...int) {
 		failures = append(failures, message)
 	})
+	defer func() {
+		RegisterFailHandler(originalHandler)
+	}()
 	f()
-	RegisterFailHandler(originalHandler)
 	return failures
 }
 
+// InterceptGomegaFailure runs a given callback and returns the first
+// failure message generated by any Gomega assertions within the callback, wrapped in an error.
+//
+// The callback ceases execution as soon as the first failed assertion occurs, however Gomega
+// does not register a failure with the FailHandler registered via RegisterFailHandler - it is up
+// to the user to decide what to do with the returned error
+func InterceptGomegaFailure(f func()) (err error) {
+	originalHandler := globalFailWrapper.Fail
+	RegisterFailHandler(func(message string, callerSkip ...int) {
+		err = errors.New(message)
+		panic("stop execution")
+	})
+
+	defer func() {
+		RegisterFailHandler(originalHandler)
+		if e := recover(); e != nil {
+			if err == nil {
+				panic(e)
+			}
+		}
+	}()
+
+	f()
+	return err
+}
+
 // Ω wraps an actual value allowing assertions to be made on it:
 //    Ω("foo").Should(Equal("foo"))
 //
@@ -177,7 +204,7 @@ func ExpectWithOffset(offset int, actual interface{}, extra ...interface{}) Asse
 // Both intervals can either be specified as time.Duration, parsable duration strings or as floats/integers.  In the
 // last case they are interpreted as seconds.
 //
-// If Eventually is passed an actual that is a function taking no arguments and returning at least one value,
+// If Eventually is passed an actual that is a function taking no arguments,
 // then Eventually will call the function periodically and try the matcher against the function's first return value.
 //
 // Example:
@@ -202,6 +229,34 @@ func ExpectWithOffset(offset int, actual interface{}, extra ...interface{}) Asse
 //
 // Will pass only if the the returned error is nil and the returned string passes the matcher.
 //
+// Eventually allows you to make assertions in the pased-in function.  The function is assumed to have failed and will be retried if any assertion in the function fails.
+// For example:
+//
+//     Eventually(func() Widget {
+//	     resp, err := http.Get(url)
+//       Expect(err).NotTo(HaveOccurred())
+//       defer resp.Body.Close()
+//       Expect(resp.SatusCode).To(Equal(http.StatusOK))
+//       var widget Widget
+//       Expect(json.NewDecoder(resp.Body).Decode(&widget)).To(Succeed())
+//       return widget
+//     }).Should(Equal(expectedWidget))
+//
+// will keep trying the passed-in function until all its assertsions pass (i.e. the http request succeeds) _and_ the returned object satisfies the passed-in matcher.
+//
+// Functions passed to Eventually typically have a return value.  However you are allowed to pass in a function with no return value.  Eventually assumes such a function
+// is making assertions and will turn it into a function that returns an error if any assertion fails, or nil if no assertion fails.  This allows you to use the Succeed() matcher
+// to express that a complex operation should eventually succeed.  For example:
+//
+//    Eventually(func() {
+//        model, err := db.Find("foo")
+//        Expect(err).NotTo(HaveOccurred())
+//        Expect(model.Reticulated()).To(BeTrue())
+//        Expect(model.Save()).To(Succeed())
+//    }).Should(Succeed())
+//
+// will rerun the function until all its assertions pass.
+//
 // Eventually's default timeout is 1 second, and its default polling interval is 10ms
 func Eventually(actual interface{}, intervals ...interface{}) AsyncAssertion {
 	return EventuallyWithOffset(0, actual, intervals...)
@@ -235,13 +290,18 @@ func EventuallyWithOffset(offset int, actual interface{}, intervals ...interface
 // Both intervals can either be specified as time.Duration, parsable duration strings or as floats/integers.  In the
 // last case they are interpreted as seconds.
 //
-// If Consistently is passed an actual that is a function taking no arguments and returning at least one value,
-// then Consistently will call the function periodically and try the matcher against the function's first return value.
+// If Consistently is passed an actual that is a function taking no arguments.
+//
+// If the function returns one value, then Consistently will call the function periodically and try the matcher against the function's first return value.
 //
 // If the function returns more than one value, then Consistently will pass the first value to the matcher and
 // assert that all other values are nil/zero.
 // This allows you to pass Consistently a function that returns a value and an error - a common pattern in Go.
 //
+// Like Eventually, Consistently allows you to make assertions in the function.  If any assertion fails Consistently will fail.  In addition,
+// Consistently also allows you to pass in a function with no return value.  In this case Consistently can be paired with the Succeed() matcher to assert
+// that no assertions in the function fail.
+//
 // Consistently is useful in cases where you want to assert that something *does not happen* over a period of time.
 // For example, you want to assert that a goroutine does *not* send data down a channel.  In this case, you could:
 //
@@ -350,7 +410,7 @@ type OmegaMatcher types.GomegaMatcher
 //
 // Use `NewWithT` to instantiate a `WithT`
 type WithT struct {
-	t types.GomegaTestingT
+	failWrapper *types.GomegaFailWrapper
 }
 
 // GomegaWithT is deprecated in favor of gomega.WithT, which does not stutter.
@@ -367,7 +427,7 @@ type GomegaWithT = WithT
 //     }
 func NewWithT(t types.GomegaTestingT) *WithT {
 	return &WithT{
-		t: t,
+		failWrapper: testingtsupport.BuildTestingTGomegaFailWrapper(t),
 	}
 }
 
@@ -378,7 +438,7 @@ func NewGomegaWithT(t types.GomegaTestingT) *GomegaWithT {
 
 // ExpectWithOffset is used to make assertions. See documentation for ExpectWithOffset.
 func (g *WithT) ExpectWithOffset(offset int, actual interface{}, extra ...interface{}) Assertion {
-	return assertion.New(actual, testingtsupport.BuildTestingTGomegaFailWrapper(g.t), offset, extra...)
+	return assertion.New(actual, g.failWrapper, offset, extra...)
 }
 
 // EventuallyWithOffset is used to make asynchronous assertions. See documentation for EventuallyWithOffset.
@@ -391,7 +451,7 @@ func (g *WithT) EventuallyWithOffset(offset int, actual interface{}, intervals .
 	if len(intervals) > 1 {
 		pollingInterval = toDuration(intervals[1])
 	}
-	return asyncassertion.New(asyncassertion.AsyncAssertionTypeEventually, actual, testingtsupport.BuildTestingTGomegaFailWrapper(g.t), timeoutInterval, pollingInterval, offset)
+	return asyncassertion.New(asyncassertion.AsyncAssertionTypeEventually, actual, g.failWrapper, timeoutInterval, pollingInterval, offset)
 }
 
 // ConsistentlyWithOffset is used to make asynchronous assertions. See documentation for ConsistentlyWithOffset.
@@ -404,7 +464,7 @@ func (g *WithT) ConsistentlyWithOffset(offset int, actual interface{}, intervals
 	if len(intervals) > 1 {
 		pollingInterval = toDuration(intervals[1])
 	}
-	return asyncassertion.New(asyncassertion.AsyncAssertionTypeConsistently, actual, testingtsupport.BuildTestingTGomegaFailWrapper(g.t), timeoutInterval, pollingInterval, offset)
+	return asyncassertion.New(asyncassertion.AsyncAssertionTypeConsistently, actual, g.failWrapper, timeoutInterval, pollingInterval, offset)
 }
 
 // Expect is used to make assertions. See documentation for Expect.