rebase: bump github.com/onsi/ginkgo/v2 from 2.3.1 to 2.4.0

Bumps [github.com/onsi/ginkgo/v2](https://github.com/onsi/ginkgo) from 2.3.1 to 2.4.0.
- [Release notes](https://github.com/onsi/ginkgo/releases)
- [Changelog](https://github.com/onsi/ginkgo/blob/master/CHANGELOG.md)
- [Commits](https://github.com/onsi/ginkgo/compare/v2.3.1...v2.4.0)

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

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

vendor/github.com/onsi/ginkgo/v2/internal/group.go

@@ -118,6 +118,8 @@ func (g *group) initialReportForSpec(spec Spec) types.SpecReport {
 		ParallelProcess:             g.suite.config.ParallelProcess,
 		IsSerial:                    spec.Nodes.HasNodeMarkedSerial(),
 		IsInOrderedContainer:        !spec.Nodes.FirstNodeMarkedOrdered().IsZero(),
+		MaxFlakeAttempts:            spec.Nodes.GetMaxFlakeAttempts(),
+		MaxMustPassRepeatedly:       spec.Nodes.GetMaxMustPassRepeatedly(),
 	}
 }
 
@@ -299,16 +301,29 @@ func (g *group) run(specs Specs) {
 
 		g.suite.currentSpecReport.StartTime = time.Now()
 		if !skip {
-			maxAttempts := max(1, spec.FlakeAttempts())
-			if g.suite.config.FlakeAttempts > 0 {
+
+			var maxAttempts = 1
+
+			if g.suite.currentSpecReport.MaxMustPassRepeatedly > 0 {
+				maxAttempts = max(1, spec.MustPassRepeatedly())
+			} else if g.suite.config.FlakeAttempts > 0 {
 				maxAttempts = g.suite.config.FlakeAttempts
+				g.suite.currentSpecReport.MaxFlakeAttempts = maxAttempts
+			} else if g.suite.currentSpecReport.MaxFlakeAttempts > 0 {
+				maxAttempts = max(1, spec.FlakeAttempts())
 			}
+
 			for attempt := 0; attempt < maxAttempts; attempt++ {
 				g.suite.currentSpecReport.NumAttempts = attempt + 1
 				g.suite.writer.Truncate()
 				g.suite.outputInterceptor.StartInterceptingOutput()
 				if attempt > 0 {
-					fmt.Fprintf(g.suite.writer, "\nGinkgo: Attempt #%d Failed.  Retrying...\n", attempt)
+					if g.suite.currentSpecReport.MaxMustPassRepeatedly > 0 {
+						fmt.Fprintf(g.suite.writer, "\nGinkgo: Attempt #%d Passed.  Repeating...\n", attempt)
+					}
+					if g.suite.currentSpecReport.MaxFlakeAttempts > 0 {
+						fmt.Fprintf(g.suite.writer, "\nGinkgo: Attempt #%d Failed.  Retrying...\n", attempt)
+					}
 				}
 
 				g.attemptSpec(attempt == maxAttempts-1, spec)
@@ -318,8 +333,15 @@ func (g *group) run(specs Specs) {
 				g.suite.currentSpecReport.CapturedGinkgoWriterOutput += string(g.suite.writer.Bytes())
 				g.suite.currentSpecReport.CapturedStdOutErr += g.suite.outputInterceptor.StopInterceptingAndReturnOutput()
 
-				if g.suite.currentSpecReport.State.Is(types.SpecStatePassed | types.SpecStateSkipped | types.SpecStateAborted | types.SpecStateInterrupted) {
-					break
+				if g.suite.currentSpecReport.MaxMustPassRepeatedly > 0 {
+					if g.suite.currentSpecReport.State.Is(types.SpecStateFailureStates | types.SpecStateSkipped) {
+						break
+					}
+				}
+				if g.suite.currentSpecReport.MaxFlakeAttempts > 0 {
+					if g.suite.currentSpecReport.State.Is(types.SpecStatePassed | types.SpecStateSkipped | types.SpecStateAborted | types.SpecStateInterrupted) {
+						break
+					}
 				}
 			}
 		}

vendor/github.com/onsi/ginkgo/v2/internal/node.go

@@ -54,6 +54,7 @@ type Node struct {
 	MarkedOncePerOrdered            bool
 	MarkedSuppressProgressReporting bool
 	FlakeAttempts                   int
+	MustPassRepeatedly              int
 	Labels                          Labels
 	PollProgressAfter               time.Duration
 	PollProgressInterval            time.Duration
@@ -80,6 +81,7 @@ const OncePerOrdered = honorsOrderedType(true)
 const SuppressProgressReporting = suppressProgressReporting(true)
 
 type FlakeAttempts uint
+type MustPassRepeatedly uint
 type Offset uint
 type Done chan<- interface{} // Deprecated Done Channel for asynchronous testing
 type Labels []string
@@ -138,6 +140,8 @@ func isDecoration(arg interface{}) bool {
 		return true
 	case t == reflect.TypeOf(FlakeAttempts(0)):
 		return true
+	case t == reflect.TypeOf(MustPassRepeatedly(0)):
+		return true
 	case t == reflect.TypeOf(Labels{}):
 		return true
 	case t == reflect.TypeOf(PollProgressInterval(0)):
@@ -253,6 +257,11 @@ func NewNode(deprecationTracker *types.DeprecationTracker, nodeType types.NodeTy
 			if !nodeType.Is(types.NodeTypesForContainerAndIt) {
 				appendError(types.GinkgoErrors.InvalidDecoratorForNodeType(node.CodeLocation, nodeType, "FlakeAttempts"))
 			}
+		case t == reflect.TypeOf(MustPassRepeatedly(0)):
+			node.MustPassRepeatedly = int(arg.(MustPassRepeatedly))
+			if !nodeType.Is(types.NodeTypesForContainerAndIt) {
+				appendError(types.GinkgoErrors.InvalidDecoratorForNodeType(node.CodeLocation, nodeType, "MustPassRepeatedly"))
+			}
 		case t == reflect.TypeOf(PollProgressAfter(0)):
 			node.PollProgressAfter = time.Duration(arg.(PollProgressAfter))
 			if nodeType.Is(types.NodeTypeContainer) {
@@ -403,6 +412,10 @@ func NewNode(deprecationTracker *types.DeprecationTracker, nodeType types.NodeTy
 		appendError(types.GinkgoErrors.UnknownDecorator(node.CodeLocation, nodeType, arg))
 	}
 
+	if node.FlakeAttempts > 0 && node.MustPassRepeatedly > 0 {
+		appendError(types.GinkgoErrors.InvalidDeclarationOfFlakeAttemptsAndMustPassRepeatedly(node.CodeLocation, nodeType))
+	}
+
 	if len(errors) > 0 {
 		return Node{}, errors
 	}
@@ -495,6 +508,8 @@ func extractSynchronizedBeforeSuiteAllProcsBody(arg interface{}) (func(SpecConte
 	}, hasContext
 }
 
+var errInterface = reflect.TypeOf((*error)(nil)).Elem()
+
 func NewCleanupNode(deprecationTracker *types.DeprecationTracker, fail func(string, types.CodeLocation), args ...interface{}) (Node, []error) {
 	decorations, remainingArgs := PartitionDecorations(args...)
 	baseOffset := 2
@@ -517,7 +532,7 @@ func NewCleanupNode(deprecationTracker *types.DeprecationTracker, fail func(stri
 	}
 
 	callback := reflect.ValueOf(remainingArgs[0])
-	if !(callback.Kind() == reflect.Func && callback.Type().NumOut() <= 1) {
+	if !(callback.Kind() == reflect.Func) {
 		return Node{}, []error{types.GinkgoErrors.DeferCleanupInvalidFunction(cl)}
 	}
 
@@ -537,8 +552,12 @@ func NewCleanupNode(deprecationTracker *types.DeprecationTracker, fail func(stri
 	}
 
 	handleFailure := func(out []reflect.Value) {
-		if len(out) == 1 && !out[0].IsNil() {
-			fail(fmt.Sprintf("DeferCleanup callback returned error: %v", out[0]), cl)
+		if len(out) == 0 {
+			return
+		}
+		last := out[len(out)-1]
+		if last.Type().Implements(errInterface) && !last.IsNil() {
+			fail(fmt.Sprintf("DeferCleanup callback returned error: %v", last), cl)
 		}
 	}
 
@@ -842,6 +861,26 @@ func (n Nodes) FirstNodeMarkedOrdered() Node {
 	return Node{}
 }
 
+func (n Nodes) GetMaxFlakeAttempts() int {
+	maxFlakeAttempts := 0
+	for i := range n {
+		if n[i].FlakeAttempts > 0 {
+			maxFlakeAttempts = n[i].FlakeAttempts
+		}
+	}
+	return maxFlakeAttempts
+}
+
+func (n Nodes) GetMaxMustPassRepeatedly() int {
+	maxMustPassRepeatedly := 0
+	for i := range n {
+		if n[i].MustPassRepeatedly > 0 {
+			maxMustPassRepeatedly = n[i].MustPassRepeatedly
+		}
+	}
+	return maxMustPassRepeatedly
+}
+
 func unrollInterfaceSlice(args interface{}) []interface{} {
 	v := reflect.ValueOf(args)
 	if v.Kind() != reflect.Slice {

vendor/github.com/onsi/ginkgo/v2/internal/spec.go

@@ -41,6 +41,17 @@ func (s Spec) FlakeAttempts() int {
 	return flakeAttempts
 }
 
+func (s Spec) MustPassRepeatedly() int {
+	mustPassRepeatedly := 0
+	for i := range s.Nodes {
+		if s.Nodes[i].MustPassRepeatedly > 0 {
+			mustPassRepeatedly = s.Nodes[i].MustPassRepeatedly
+		}
+	}
+
+	return mustPassRepeatedly
+}
+
 func (s Spec) SpecTimeout() time.Duration {
 	return s.FirstNodeWithType(types.NodeTypeIt).SpecTimeout
 }

vendor/github.com/onsi/ginkgo/v2/internal/writer.go

@@ -5,6 +5,9 @@ import (
 	"fmt"
 	"io"
 	"sync"
+
+	"github.com/go-logr/logr"
+	"github.com/go-logr/logr/funcr"
 )
 
 type WriterMode uint
@@ -101,3 +104,9 @@ func (w *Writer) Printf(format string, a ...interface{}) {
 func (w *Writer) Println(a ...interface{}) {
 	fmt.Fprintln(w, a...)
 }
+
+func GinkgoLogrFunc(writer *Writer) logr.Logger {
+	return funcr.New(func(prefix, args string) {
+		writer.Printf("%s", args)
+	}, funcr.Options{})
+}