build(deps): bump github.com/onsi/ginkgo/v2 from 2.23.4 to 2.24.0

Bumps [github.com/onsi/ginkgo/v2](https://github.com/onsi/ginkgo) from 2.23.4 to 2.24.0.
- [Changelog](https://github.com/onsi/ginkgo/blob/master/CHANGELOG.md)
- [Commits](https://github.com/onsi/ginkgo/compare/v2.23.4...v2.24.0)

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

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

vendor/github.com/onsi/ginkgo/v2/CHANGELOG.md

@@ -1,3 +1,17 @@
+## 2.24.0
+
+### Features
+
+Specs can now be decorated with (e.g.) `SemVerConstraint("2.1.0")` and `ginkgo --sem-ver-filter="2.1.1"` will only run constrained specs that match the requested version.  Learn more in the docs [here](https://onsi.github.io/ginkgo/#spec-semantic-version-filtering)!  Thanks to @Icarus9913 for the PR.
+
+### Fixes
+
+- remove -o from run command [3f5d379].  fixes [#1582](https://github.com/onsi/ginkgo/issues/1582)
+
+### Maintenance
+
+Numerous dependency bumps and documentation fixes
+
 ## 2.23.4
 
 Prior to this release Ginkgo would compute the incorrect number of available CPUs when running with `-p` in a linux container.  Thanks to @emirot for the fix!

vendor/github.com/onsi/ginkgo/v2/core_dsl.go

@@ -186,6 +186,20 @@ func GinkgoLabelFilter() string {
 	return suiteConfig.LabelFilter
 }
 
+/*
+GinkgoSemVerFilter() returns the semantic version filter configured for this suite via `--sem-ver-filter`.
+
+You can use this to manually check if a set of semantic version constraints would satisfy the filter via:
+
+	if (SemVerConstraint("> 2.6.0", "< 2.8.0").MatchesSemVerFilter(GinkgoSemVerFilter())) {
+		//...
+	}
+*/
+func GinkgoSemVerFilter() string {
+	suiteConfig, _ := GinkgoConfiguration()
+	return suiteConfig.SemVerFilter
+}
+
 /*
 PauseOutputInterception() pauses Ginkgo's output interception.  This is only relevant
 when running in parallel and output to stdout/stderr is being intercepted.  You generally
@@ -254,7 +268,7 @@ func RunSpecs(t GinkgoTestingT, description string, args ...any) bool {
 	}
 	defer global.PopClone()
 
-	suiteLabels := extractSuiteConfiguration(args)
+	suiteLabels, suiteSemVerConstraints := extractSuiteConfiguration(args)
 
 	var reporter reporters.Reporter
 	if suiteConfig.ParallelTotal == 1 {
@@ -297,7 +311,7 @@ func RunSpecs(t GinkgoTestingT, description string, args ...any) bool {
 	suitePath, err = filepath.Abs(suitePath)
 	exitIfErr(err)
 
-	passed, hasFocusedTests := global.Suite.Run(description, suiteLabels, suitePath, global.Failer, reporter, writer, outputInterceptor, interrupt_handler.NewInterruptHandler(client), client, internal.RegisterForProgressSignal, suiteConfig)
+	passed, hasFocusedTests := global.Suite.Run(description, suiteLabels, suiteSemVerConstraints, suitePath, global.Failer, reporter, writer, outputInterceptor, interrupt_handler.NewInterruptHandler(client), client, internal.RegisterForProgressSignal, suiteConfig)
 	outputInterceptor.Shutdown()
 
 	flagSet.ValidateDeprecations(deprecationTracker)
@@ -316,8 +330,9 @@ func RunSpecs(t GinkgoTestingT, description string, args ...any) bool {
 	return passed
 }
 
-func extractSuiteConfiguration(args []any) Labels {
+func extractSuiteConfiguration(args []any) (Labels, SemVerConstraints) {
 	suiteLabels := Labels{}
+	suiteSemVerConstraints := SemVerConstraints{}
 	configErrors := []error{}
 	for _, arg := range args {
 		switch arg := arg.(type) {
@@ -327,6 +342,8 @@ func extractSuiteConfiguration(args []any) Labels {
 			reporterConfig = arg
 		case Labels:
 			suiteLabels = append(suiteLabels, arg...)
+		case SemVerConstraints:
+			suiteSemVerConstraints = append(suiteSemVerConstraints, arg...)
 		default:
 			configErrors = append(configErrors, types.GinkgoErrors.UnknownTypePassedToRunSpecs(arg))
 		}
@@ -342,7 +359,7 @@ func extractSuiteConfiguration(args []any) Labels {
 		os.Exit(1)
 	}
 
-	return suiteLabels
+	return suiteLabels, suiteSemVerConstraints
 }
 
 func getwd() (string, error) {
@@ -365,7 +382,7 @@ func PreviewSpecs(description string, args ...any) Report {
 	}
 	defer global.PopClone()
 
-	suiteLabels := extractSuiteConfiguration(args)
+	suiteLabels, suiteSemVerConstraints := extractSuiteConfiguration(args)
 	priorDryRun, priorParallelTotal, priorParallelProcess := suiteConfig.DryRun, suiteConfig.ParallelTotal, suiteConfig.ParallelProcess
 	suiteConfig.DryRun, suiteConfig.ParallelTotal, suiteConfig.ParallelProcess = true, 1, 1
 	defer func() {
@@ -383,7 +400,7 @@ func PreviewSpecs(description string, args ...any) Report {
 	suitePath, err = filepath.Abs(suitePath)
 	exitIfErr(err)
 
-	global.Suite.Run(description, suiteLabels, suitePath, global.Failer, reporter, writer, outputInterceptor, interrupt_handler.NewInterruptHandler(client), client, internal.RegisterForProgressSignal, suiteConfig)
+	global.Suite.Run(description, suiteLabels, suiteSemVerConstraints, suitePath, global.Failer, reporter, writer, outputInterceptor, interrupt_handler.NewInterruptHandler(client), client, internal.RegisterForProgressSignal, suiteConfig)
 
 	return global.Suite.GetPreviewReport()
 }

vendor/github.com/onsi/ginkgo/v2/decorator_dsl.go

@@ -99,6 +99,23 @@ You can learn more here: https://onsi.github.io/ginkgo/#spec-labels
 */
 type Labels = internal.Labels
 
+/*
+SemVerConstraint decorates specs with SemVerConstraints. Multiple semantic version constraints can be passed to SemVerConstraint and these strings must follow the semantic version constraint rules.
+SemVerConstraints can be applied to container and subject nodes, but not setup nodes. You can provide multiple SemVerConstraints to a given node and a spec's semantic version constraints is the union of all semantic version constraints in its node hierarchy.
+
+You can learn more here: https://onsi.github.io/ginkgo/#spec-semantic-version-filtering
+You can learn more about decorators here: https://onsi.github.io/ginkgo/#decorator-reference
+*/
+func SemVerConstraint(semVerConstraints ...string) SemVerConstraints {
+	return SemVerConstraints(semVerConstraints)
+}
+
+/*
+SemVerConstraints are the type for spec SemVerConstraint decorators. Use SemVerConstraint(...) to construct SemVerConstraints.
+You can learn more here: https://onsi.github.io/ginkgo/#spec-semantic-version-filtering
+*/
+type SemVerConstraints = internal.SemVerConstraints
+
 /*
 PollProgressAfter allows you to override the configured value for --poll-progress-after for a particular node.
 

vendor/github.com/onsi/ginkgo/v2/ginkgo/build/build_command.go

@@ -29,7 +29,6 @@ func BuildBuildCommand() command.Command {
 			var errors []error
 			cliConfig, goFlagsConfig, errors = types.VetAndInitializeCLIAndGoConfig(cliConfig, goFlagsConfig)
 			command.AbortIfErrors("Ginkgo detected configuration issues:", errors)
-
 			buildSpecs(args, cliConfig, goFlagsConfig)
 		},
 	}

vendor/github.com/onsi/ginkgo/v2/ginkgo_t_dsl.go

@@ -2,6 +2,7 @@ package ginkgo
 
 import (
 	"context"
+	"io"
 	"testing"
 
 	"github.com/onsi/ginkgo/v2/internal/testingtproxy"
@@ -69,6 +70,8 @@ type GinkgoTInterface interface {
 	Skipf(format string, args ...any)
 	Skipped() bool
 	TempDir() string
+	Attr(key, value string)
+	Output() io.Writer
 }
 
 /*

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

@@ -56,7 +56,7 @@ This function sets the `Skip` property on specs by applying Ginkgo's focus polic
 
 *Note:* specs with pending nodes are Skipped when created by NewSpec.
 */
-func ApplyFocusToSpecs(specs Specs, description string, suiteLabels Labels, suiteConfig types.SuiteConfig) (Specs, bool) {
+func ApplyFocusToSpecs(specs Specs, description string, suiteLabels Labels, suiteSemVerConstraints SemVerConstraints, suiteConfig types.SuiteConfig) (Specs, bool) {
 	focusString := strings.Join(suiteConfig.FocusStrings, "|")
 	skipString := strings.Join(suiteConfig.SkipStrings, "|")
 
@@ -84,6 +84,13 @@ func ApplyFocusToSpecs(specs Specs, description string, suiteLabels Labels, suit
 		})
 	}
 
+	if suiteConfig.SemVerFilter != "" {
+		semVerFilter, _ := types.ParseSemVerFilter(suiteConfig.SemVerFilter)
+		skipChecks = append(skipChecks, func(spec Spec) bool {
+			return !semVerFilter(UnionOfSemVerConstraints(suiteSemVerConstraints, spec.Nodes.UnionOfSemVerConstraints()))
+		})
+	}
+
 	if len(suiteConfig.FocusFiles) > 0 {
 		focusFilters, _ := types.ParseFileFilters(suiteConfig.FocusFiles)
 		skipChecks = append(skipChecks, func(spec Spec) bool { return !focusFilters.Matches(spec.Nodes.CodeLocations()) })

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

@@ -112,19 +112,21 @@ func newGroup(suite *Suite) *group {
 
 func (g *group) initialReportForSpec(spec Spec) types.SpecReport {
 	return types.SpecReport{
-		ContainerHierarchyTexts:     spec.Nodes.WithType(types.NodeTypeContainer).Texts(),
-		ContainerHierarchyLocations: spec.Nodes.WithType(types.NodeTypeContainer).CodeLocations(),
-		ContainerHierarchyLabels:    spec.Nodes.WithType(types.NodeTypeContainer).Labels(),
-		LeafNodeLocation:            spec.FirstNodeWithType(types.NodeTypeIt).CodeLocation,
-		LeafNodeType:                types.NodeTypeIt,
-		LeafNodeText:                spec.FirstNodeWithType(types.NodeTypeIt).Text,
-		LeafNodeLabels:              []string(spec.FirstNodeWithType(types.NodeTypeIt).Labels),
-		ParallelProcess:             g.suite.config.ParallelProcess,
-		RunningInParallel:           g.suite.isRunningInParallel(),
-		IsSerial:                    spec.Nodes.HasNodeMarkedSerial(),
-		IsInOrderedContainer:        !spec.Nodes.FirstNodeMarkedOrdered().IsZero(),
-		MaxFlakeAttempts:            spec.Nodes.GetMaxFlakeAttempts(),
-		MaxMustPassRepeatedly:       spec.Nodes.GetMaxMustPassRepeatedly(),
+		ContainerHierarchyTexts:             spec.Nodes.WithType(types.NodeTypeContainer).Texts(),
+		ContainerHierarchyLocations:         spec.Nodes.WithType(types.NodeTypeContainer).CodeLocations(),
+		ContainerHierarchyLabels:            spec.Nodes.WithType(types.NodeTypeContainer).Labels(),
+		ContainerHierarchySemVerConstraints: spec.Nodes.WithType(types.NodeTypeContainer).SemVerConstraints(),
+		LeafNodeLocation:                    spec.FirstNodeWithType(types.NodeTypeIt).CodeLocation,
+		LeafNodeType:                        types.NodeTypeIt,
+		LeafNodeText:                        spec.FirstNodeWithType(types.NodeTypeIt).Text,
+		LeafNodeLabels:                      []string(spec.FirstNodeWithType(types.NodeTypeIt).Labels),
+		LeafNodeSemVerConstraints:           []string(spec.FirstNodeWithType(types.NodeTypeIt).SemVerConstraints),
+		ParallelProcess:                     g.suite.config.ParallelProcess,
+		RunningInParallel:                   g.suite.isRunningInParallel(),
+		IsSerial:                            spec.Nodes.HasNodeMarkedSerial(),
+		IsInOrderedContainer:                !spec.Nodes.FirstNodeMarkedOrdered().IsZero(),
+		MaxFlakeAttempts:                    spec.Nodes.GetMaxFlakeAttempts(),
+		MaxMustPassRepeatedly:               spec.Nodes.GetMaxMustPassRepeatedly(),
 	}
 }
 

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

@@ -55,6 +55,7 @@ type Node struct {
 	FlakeAttempts           int
 	MustPassRepeatedly      int
 	Labels                  Labels
+	SemVerConstraints       SemVerConstraints
 	PollProgressAfter       time.Duration
 	PollProgressInterval    time.Duration
 	NodeTimeout             time.Duration
@@ -86,6 +87,7 @@ type MustPassRepeatedly uint
 type Offset uint
 type Done chan<- any // Deprecated Done Channel for asynchronous testing
 type Labels []string
+type SemVerConstraints []string
 type PollProgressInterval time.Duration
 type PollProgressAfter time.Duration
 type NodeTimeout time.Duration
@@ -96,20 +98,32 @@ func (l Labels) MatchesLabelFilter(query string) bool {
 	return types.MustParseLabelFilter(query)(l)
 }
 
-func UnionOfLabels(labels ...Labels) Labels {
-	out := Labels{}
-	seen := map[string]bool{}
-	for _, labelSet := range labels {
-		for _, label := range labelSet {
-			if !seen[label] {
-				seen[label] = true
-				out = append(out, label)
+func (svc SemVerConstraints) MatchesSemVerFilter(version string) bool {
+	return types.MustParseSemVerFilter(version)(svc)
+}
+
+func unionOf[S ~[]E, E comparable](slices ...S) S {
+	out := S{}
+	seen := map[E]bool{}
+	for _, slice := range slices {
+		for _, item := range slice {
+			if !seen[item] {
+				seen[item] = true
+				out = append(out, item)
 			}
 		}
 	}
 	return out
 }
 
+func UnionOfLabels(labels ...Labels) Labels {
+	return unionOf(labels...)
+}
+
+func UnionOfSemVerConstraints(semVerConstraints ...SemVerConstraints) SemVerConstraints {
+	return unionOf(semVerConstraints...)
+}
+
 func PartitionDecorations(args ...any) ([]any, []any) {
 	decorations := []any{}
 	remainingArgs := []any{}
@@ -151,6 +165,8 @@ func isDecoration(arg any) bool {
 		return true
 	case t == reflect.TypeOf(Labels{}):
 		return true
+	case t == reflect.TypeOf(SemVerConstraints{}):
+		return true
 	case t == reflect.TypeOf(PollProgressInterval(0)):
 		return true
 	case t == reflect.TypeOf(PollProgressAfter(0)):
@@ -191,6 +207,7 @@ func NewNode(deprecationTracker *types.DeprecationTracker, nodeType types.NodeTy
 		NodeType:             nodeType,
 		Text:                 text,
 		Labels:               Labels{},
+		SemVerConstraints:    SemVerConstraints{},
 		CodeLocation:         types.NewCodeLocation(baseOffset),
 		NestingLevel:         -1,
 		PollProgressAfter:    -1,
@@ -221,6 +238,7 @@ func NewNode(deprecationTracker *types.DeprecationTracker, nodeType types.NodeTy
 	}
 
 	labelsSeen := map[string]bool{}
+	semVerConstraintsSeen := map[string]bool{}
 	trackedFunctionError := false
 	args = remainingArgs
 	remainingArgs = []any{}
@@ -311,6 +329,18 @@ func NewNode(deprecationTracker *types.DeprecationTracker, nodeType types.NodeTy
 					appendError(err)
 				}
 			}
+		case t == reflect.TypeOf(SemVerConstraints{}):
+			if !nodeType.Is(types.NodeTypesForContainerAndIt) {
+				appendError(types.GinkgoErrors.InvalidDecoratorForNodeType(node.CodeLocation, nodeType, "SemVerConstraint"))
+			}
+			for _, semVerConstraint := range arg.(SemVerConstraints) {
+				if !semVerConstraintsSeen[semVerConstraint] {
+					semVerConstraintsSeen[semVerConstraint] = true
+					semVerConstraint, err := types.ValidateAndCleanupSemVerConstraint(semVerConstraint, node.CodeLocation)
+					node.SemVerConstraints = append(node.SemVerConstraints, semVerConstraint)
+					appendError(err)
+				}
+			}
 		case t.Kind() == reflect.Func:
 			if nodeType.Is(types.NodeTypeContainer) {
 				if node.Body != nil {
@@ -824,6 +854,32 @@ func (n Nodes) UnionOfLabels() []string {
 	return out
 }
 
+func (n Nodes) SemVerConstraints() [][]string {
+	out := make([][]string, len(n))
+	for i := range n {
+		if n[i].SemVerConstraints == nil {
+			out[i] = []string{}
+		} else {
+			out[i] = []string(n[i].SemVerConstraints)
+		}
+	}
+	return out
+}
+
+func (n Nodes) UnionOfSemVerConstraints() []string {
+	out := []string{}
+	seen := map[string]bool{}
+	for i := range n {
+		for _, constraint := range n[i].SemVerConstraints {
+			if !seen[constraint] {
+				seen[constraint] = true
+				out = append(out, constraint)
+			}
+		}
+	}
+	return out
+}
+
 func (n Nodes) CodeLocations() []types.CodeLocation {
 	out := make([]types.CodeLocation, len(n))
 	for i := range n {
@@ -928,7 +984,7 @@ func unrollInterfaceSlice(args any) []any {
 	out := []any{}
 	for i := 0; i < v.Len(); i++ {
 		el := reflect.ValueOf(v.Index(i).Interface())
-		if el.Kind() == reflect.Slice && el.Type() != reflect.TypeOf(Labels{}) {
+		if el.Kind() == reflect.Slice && el.Type() != reflect.TypeOf(Labels{}) && el.Type() != reflect.TypeOf(SemVerConstraints{}) {
 			out = append(out, unrollInterfaceSlice(el.Interface())...)
 		} else {
 			out = append(out, v.Index(i).Interface())

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

@@ -104,13 +104,13 @@ func (suite *Suite) BuildTree() error {
 	return nil
 }
 
-func (suite *Suite) Run(description string, suiteLabels Labels, suitePath string, failer *Failer, reporter reporters.Reporter, writer WriterInterface, outputInterceptor OutputInterceptor, interruptHandler interrupt_handler.InterruptHandlerInterface, client parallel_support.Client, progressSignalRegistrar ProgressSignalRegistrar, suiteConfig types.SuiteConfig) (bool, bool) {
+func (suite *Suite) Run(description string, suiteLabels Labels, suiteSemVerConstraints SemVerConstraints, suitePath string, failer *Failer, reporter reporters.Reporter, writer WriterInterface, outputInterceptor OutputInterceptor, interruptHandler interrupt_handler.InterruptHandlerInterface, client parallel_support.Client, progressSignalRegistrar ProgressSignalRegistrar, suiteConfig types.SuiteConfig) (bool, bool) {
 	if suite.phase != PhaseBuildTree {
 		panic("cannot run before building the tree = call suite.BuildTree() first")
 	}
 	ApplyNestedFocusPolicyToTree(suite.tree)
 	specs := GenerateSpecsFromTreeRoot(suite.tree)
-	specs, hasProgrammaticFocus := ApplyFocusToSpecs(specs, description, suiteLabels, suiteConfig)
+	specs, hasProgrammaticFocus := ApplyFocusToSpecs(specs, description, suiteLabels, suiteSemVerConstraints, suiteConfig)
 
 	suite.phase = PhaseRun
 	suite.client = client
@@ -127,7 +127,7 @@ func (suite *Suite) Run(description string, suiteLabels Labels, suitePath string
 
 	cancelProgressHandler := progressSignalRegistrar(suite.handleProgressSignal)
 
-	success := suite.runSpecs(description, suiteLabels, suitePath, hasProgrammaticFocus, specs)
+	success := suite.runSpecs(description, suiteLabels, suiteSemVerConstraints, suitePath, hasProgrammaticFocus, specs)
 
 	cancelProgressHandler()
 
@@ -428,13 +428,14 @@ func (suite *Suite) processCurrentSpecReport() {
 	}
 }
 
-func (suite *Suite) runSpecs(description string, suiteLabels Labels, suitePath string, hasProgrammaticFocus bool, specs Specs) bool {
+func (suite *Suite) runSpecs(description string, suiteLabels Labels, suiteSemVerConstraints SemVerConstraints, suitePath string, hasProgrammaticFocus bool, specs Specs) bool {
 	numSpecsThatWillBeRun := specs.CountWithoutSkip()
 
 	suite.report = types.Report{
 		SuitePath:                 suitePath,
 		SuiteDescription:          description,
 		SuiteLabels:               suiteLabels,
+		SuiteSemVerConstraints:    suiteSemVerConstraints,
 		SuiteConfig:               suite.config,
 		SuiteHasProgrammaticFocus: hasProgrammaticFocus,
 		PreRunStats: types.PreRunStats{

vendor/github.com/onsi/ginkgo/v2/internal/testingtproxy/testing_t_proxy.go

@@ -229,3 +229,9 @@ func (t *ginkgoTestingTProxy) ParallelTotal() int {
 func (t *ginkgoTestingTProxy) AttachProgressReporter(f func() string) func() {
 	return t.attachProgressReporter(f)
 }
+func (t *ginkgoTestingTProxy) Output() io.Writer {
+	return t.writer
+}
+func (t *ginkgoTestingTProxy) Attr(key, value string) {
+	t.addReportEntry(key, value, internal.Offset(1), types.ReportEntryVisibilityFailureOrVerbose)
+}

vendor/github.com/onsi/ginkgo/v2/reporters/default_reporter.go

@@ -72,6 +72,9 @@ func (r *DefaultReporter) SuiteWillBegin(report types.Report) {
 		if len(report.SuiteLabels) > 0 {
 			r.emit(r.f("{{coral}}[%s]{{/}} ", strings.Join(report.SuiteLabels, ", ")))
 		}
+		if len(report.SuiteSemVerConstraints) > 0 {
+			r.emit(r.f("{{coral}}[%s]{{/}} ", strings.Join(report.SuiteSemVerConstraints, ", ")))
+		}
 		r.emit(r.f("- %d/%d specs ", report.PreRunStats.SpecsThatWillRun, report.PreRunStats.TotalSpecs))
 		if report.SuiteConfig.ParallelTotal > 1 {
 			r.emit(r.f("- %d procs ", report.SuiteConfig.ParallelTotal))
@@ -87,6 +90,13 @@ func (r *DefaultReporter) SuiteWillBegin(report types.Report) {
 				bannerWidth = len(labels) + 2
 			}
 		}
+		if len(report.SuiteSemVerConstraints) > 0 {
+			semVerConstraints := strings.Join(report.SuiteSemVerConstraints, ", ")
+			r.emitBlock(r.f("{{coral}}[%s]{{/}} ", semVerConstraints))
+			if len(semVerConstraints)+2 > bannerWidth {
+				bannerWidth = len(semVerConstraints) + 2
+			}
+		}
 		r.emitBlock(strings.Repeat("=", bannerWidth))
 
 		out := r.f("Random Seed: {{bold}}%d{{/}}", report.SuiteConfig.RandomSeed)
@@ -698,8 +708,8 @@ func (r *DefaultReporter) cycleJoin(elements []string, joiner string) string {
 }
 
 func (r *DefaultReporter) codeLocationBlock(report types.SpecReport, highlightColor string, veryVerbose bool, usePreciseFailureLocation bool) string {
-	texts, locations, labels := []string{}, []types.CodeLocation{}, [][]string{}
-	texts, locations, labels = append(texts, report.ContainerHierarchyTexts...), append(locations, report.ContainerHierarchyLocations...), append(labels, report.ContainerHierarchyLabels...)
+	texts, locations, labels, semVerConstraints := []string{}, []types.CodeLocation{}, [][]string{}, [][]string{}
+	texts, locations, labels, semVerConstraints = append(texts, report.ContainerHierarchyTexts...), append(locations, report.ContainerHierarchyLocations...), append(labels, report.ContainerHierarchyLabels...), append(semVerConstraints, report.ContainerHierarchySemVerConstraints...)
 
 	if report.LeafNodeType.Is(types.NodeTypesForSuiteLevelNodes) {
 		texts = append(texts, r.f("[%s] %s", report.LeafNodeType, report.LeafNodeText))
@@ -707,6 +717,7 @@ func (r *DefaultReporter) codeLocationBlock(report types.SpecReport, highlightCo
 		texts = append(texts, r.f(report.LeafNodeText))
 	}
 	labels = append(labels, report.LeafNodeLabels)
+	semVerConstraints = append(semVerConstraints, report.LeafNodeSemVerConstraints)
 	locations = append(locations, report.LeafNodeLocation)
 
 	failureLocation := report.Failure.FailureNodeLocation
@@ -720,6 +731,7 @@ func (r *DefaultReporter) codeLocationBlock(report types.SpecReport, highlightCo
 		texts = append([]string{fmt.Sprintf("TOP-LEVEL [%s]", report.Failure.FailureNodeType)}, texts...)
 		locations = append([]types.CodeLocation{failureLocation}, locations...)
 		labels = append([][]string{{}}, labels...)
+		semVerConstraints = append([][]string{{}}, semVerConstraints...)
 		highlightIndex = 0
 	case types.FailureNodeInContainer:
 		i := report.Failure.FailureNodeContainerIndex
@@ -747,6 +759,9 @@ func (r *DefaultReporter) codeLocationBlock(report types.SpecReport, highlightCo
 			if len(labels[i]) > 0 {
 				out += r.f(" {{coral}}[%s]{{/}}", strings.Join(labels[i], ", "))
 			}
+			if len(semVerConstraints[i]) > 0 {
+				out += r.f(" {{coral}}[%s]{{/}}", strings.Join(semVerConstraints[i], ", "))
+			}
 			out += "\n"
 			out += r.fi(uint(i), "{{gray}}%s{{/}}\n", locations[i])
 		}
@@ -770,6 +785,10 @@ func (r *DefaultReporter) codeLocationBlock(report types.SpecReport, highlightCo
 		if len(flattenedLabels) > 0 {
 			out += r.f(" {{coral}}[%s]{{/}}", strings.Join(flattenedLabels, ", "))
 		}
+		flattenedSemVerConstraints := report.SemVerConstraints()
+		if len(flattenedSemVerConstraints) > 0 {
+			out += r.f(" {{coral}}[%s]{{/}}", strings.Join(flattenedSemVerConstraints, ", "))
+		}
 		out += "\n"
 		if usePreciseFailureLocation {
 			out += r.f("{{gray}}%s{{/}}", failureLocation)

vendor/github.com/onsi/ginkgo/v2/reporters/junit_report.go

@@ -36,6 +36,9 @@ type JunitReportConfig struct {
 	// Enable OmitSpecLabels to prevent labels from appearing in the spec name
 	OmitSpecLabels bool
 
+	// Enable OmitSpecSemVerConstraints to prevent semantic version constraints from appearing in the spec name
+	OmitSpecSemVerConstraints bool
+
 	// Enable OmitLeafNodeType to prevent the spec leaf node type from appearing in the spec name
 	OmitLeafNodeType bool
 
@@ -169,9 +172,11 @@ func GenerateJUnitReportWithConfig(report types.Report, dst string, config Junit
 				{"SuiteHasProgrammaticFocus", fmt.Sprintf("%t", report.SuiteHasProgrammaticFocus)},
 				{"SpecialSuiteFailureReason", strings.Join(report.SpecialSuiteFailureReasons, ",")},
 				{"SuiteLabels", fmt.Sprintf("[%s]", strings.Join(report.SuiteLabels, ","))},
+				{"SuiteSemVerConstraints", fmt.Sprintf("[%s]", strings.Join(report.SuiteSemVerConstraints, ","))},
 				{"RandomSeed", fmt.Sprintf("%d", report.SuiteConfig.RandomSeed)},
 				{"RandomizeAllSpecs", fmt.Sprintf("%t", report.SuiteConfig.RandomizeAllSpecs)},
 				{"LabelFilter", report.SuiteConfig.LabelFilter},
+				{"SemVerFilter", report.SuiteConfig.SemVerFilter},
 				{"FocusStrings", strings.Join(report.SuiteConfig.FocusStrings, ",")},
 				{"SkipStrings", strings.Join(report.SuiteConfig.SkipStrings, ",")},
 				{"FocusFiles", strings.Join(report.SuiteConfig.FocusFiles, ";")},
@@ -207,6 +212,10 @@ func GenerateJUnitReportWithConfig(report types.Report, dst string, config Junit
 				owner = matches[1]
 			}
 		}
+		semVerConstraints := spec.SemVerConstraints()
+		if len(semVerConstraints) > 0 && !config.OmitSpecSemVerConstraints {
+			name = name + " [" + strings.Join(semVerConstraints, ", ") + "]"
+		}
 		name = strings.TrimSpace(name)
 
 		test := JUnitTestCase{

vendor/github.com/onsi/ginkgo/v2/reporters/teamcity_report.go

@@ -38,9 +38,13 @@ func GenerateTeamcityReport(report types.Report, dst string) error {
 
 	name := report.SuiteDescription
 	labels := report.SuiteLabels
+	semVerConstraints := report.SuiteSemVerConstraints
 	if len(labels) > 0 {
 		name = name + " [" + strings.Join(labels, ", ") + "]"
 	}
+	if len(semVerConstraints) > 0 {
+		name = name + " [" + strings.Join(semVerConstraints, ", ") + "]"
+	}
 	fmt.Fprintf(f, "##teamcity[testSuiteStarted name='%s']\n", tcEscape(name))
 	for _, spec := range report.SpecReports {
 		name := fmt.Sprintf("[%s]", spec.LeafNodeType)
@@ -51,6 +55,10 @@ func GenerateTeamcityReport(report types.Report, dst string) error {
 		if len(labels) > 0 {
 			name = name + " [" + strings.Join(labels, ", ") + "]"
 		}
+		semVerConstraints := spec.SemVerConstraints()
+		if len(semVerConstraints) > 0 {
+			name = name + " [" + strings.Join(semVerConstraints, ", ") + "]"
+		}
 
 		name = tcEscape(name)
 		fmt.Fprintf(f, "##teamcity[testStarted name='%s']\n", name)

vendor/github.com/onsi/ginkgo/v2/types/config.go

@@ -24,6 +24,7 @@ type SuiteConfig struct {
 	FocusFiles            []string
 	SkipFiles             []string
 	LabelFilter           string
+	SemVerFilter          string
 	FailOnPending         bool
 	FailOnEmpty           bool
 	FailFast              bool
@@ -308,6 +309,8 @@ var SuiteConfigFlags = GinkgoFlags{
 
 	{KeyPath: "S.LabelFilter", Name: "label-filter", SectionKey: "filter", UsageArgument: "expression",
 		Usage: "If set, ginkgo will only run specs with labels that match the label-filter.  The passed-in expression can include boolean operations (!, &&, ||, ','), groupings via '()', and regular expressions '/regexp/'.  e.g. '(cat || dog) && !fruit'"},
+	{KeyPath: "S.SemVerFilter", Name: "sem-ver-filter", SectionKey: "filter", UsageArgument: "version",
+		Usage: "If set, ginkgo will only run specs with semantic version constraints that are satisfied by the provided version. e.g. '2.1.0'"},
 	{KeyPath: "S.FocusStrings", Name: "focus", SectionKey: "filter",
 		Usage: "If set, ginkgo will only run specs that match this regular expression. Can be specified multiple times, values are ORed."},
 	{KeyPath: "S.SkipStrings", Name: "skip", SectionKey: "filter",
@@ -443,6 +446,13 @@ func VetConfig(flagSet GinkgoFlagSet, suiteConfig SuiteConfig, reporterConfig Re
 		}
 	}
 
+	if suiteConfig.SemVerFilter != "" {
+		_, err := ParseSemVerFilter(suiteConfig.SemVerFilter)
+		if err != nil {
+			errors = append(errors, err)
+		}
+	}
+
 	switch strings.ToLower(suiteConfig.OutputInterceptorMode) {
 	case "", "dup", "swap", "none":
 	default:
@@ -573,6 +583,9 @@ var GoBuildFlags = GinkgoFlags{
 		Usage: "print the name of the temporary work directory and do not delete it when exiting."},
 	{KeyPath: "Go.X", Name: "x", SectionKey: "go-build",
 		Usage: "print the commands."},
+}
+
+var GoBuildOFlags = GinkgoFlags{
 	{KeyPath: "Go.O", Name: "o", SectionKey: "go-build",
 		Usage: "output binary path (including name)."},
 }
@@ -673,7 +686,7 @@ func GenerateGoTestCompileArgs(goFlagsConfig GoFlagsConfig, packageToBuild strin
 
 	args := []string{"test", "-c", packageToBuild}
 	goArgs, err := GenerateFlagArgs(
-		GoBuildFlags,
+		GoBuildFlags.CopyAppend(GoBuildOFlags...),
 		map[string]any{
 			"Go": &goFlagsConfig,
 		},
@@ -763,6 +776,7 @@ func BuildWatchCommandFlagSet(suiteConfig *SuiteConfig, reporterConfig *Reporter
 func BuildBuildCommandFlagSet(cliConfig *CLIConfig, goFlagsConfig *GoFlagsConfig) (GinkgoFlagSet, error) {
 	flags := GinkgoCLISharedFlags
 	flags = flags.CopyAppend(GoBuildFlags...)
+	flags = flags.CopyAppend(GoBuildOFlags...)
 
 	bindings := map[string]any{
 		"C":  cliConfig,

vendor/github.com/onsi/ginkgo/v2/types/errors.go

@@ -432,6 +432,24 @@ func (g ginkgoErrors) InvalidEmptyLabel(cl CodeLocation) error {
 	}
 }
 
+func (g ginkgoErrors) InvalidSemVerConstraint(semVerConstraint, errMsg string, cl CodeLocation) error {
+	return GinkgoError{
+		Heading:      "Invalid SemVerConstraint",
+		Message:      fmt.Sprintf("'%s' is an invalid SemVerConstraint: %s", semVerConstraint, errMsg),
+		CodeLocation: cl,
+		DocLink:      "spec-semantic-version-filtering",
+	}
+}
+
+func (g ginkgoErrors) InvalidEmptySemVerConstraint(cl CodeLocation) error {
+	return GinkgoError{
+		Heading:      "Invalid Empty SemVerConstraint",
+		Message:      "SemVerConstraint cannot be empty",
+		CodeLocation: cl,
+		DocLink:      "spec-semantic-version-filtering",
+	}
+}
+
 /* Table errors */
 func (g ginkgoErrors) MultipleEntryBodyFunctionsForTable(cl CodeLocation) error {
 	return GinkgoError{

vendor/github.com/onsi/ginkgo/v2/types/semver_filter.go

@@ -0,0 +1,60 @@
+package types
+
+import (
+	"fmt"
+
+	"github.com/Masterminds/semver/v3"
+)
+
+type SemVerFilter func([]string) bool
+
+func MustParseSemVerFilter(input string) SemVerFilter {
+	filter, err := ParseSemVerFilter(input)
+	if err != nil {
+		panic(err)
+	}
+	return filter
+}
+
+func ParseSemVerFilter(filterVersion string) (SemVerFilter, error) {
+	if filterVersion == "" {
+		return func(_ []string) bool { return true }, nil
+	}
+
+	targetVersion, err := semver.NewVersion(filterVersion)
+	if err != nil {
+		return nil, fmt.Errorf("invalid filter version: %w", err)
+	}
+
+	return func(constraints []string) bool {
+		// unconstrained specs always run
+		if len(constraints) == 0 {
+			return true
+		}
+
+		for _, constraintStr := range constraints {
+			constraint, err := semver.NewConstraint(constraintStr)
+			if err != nil {
+				return false
+			}
+
+			if !constraint.Check(targetVersion) {
+				return false
+			}
+		}
+
+		return true
+	}, nil
+}
+
+func ValidateAndCleanupSemVerConstraint(semVerConstraint string, cl CodeLocation) (string, error) {
+	if len(semVerConstraint) == 0 {
+		return "", GinkgoErrors.InvalidEmptySemVerConstraint(cl)
+	}
+	_, err := semver.NewConstraint(semVerConstraint)
+	if err != nil {
+		return "", GinkgoErrors.InvalidSemVerConstraint(semVerConstraint, err.Error(), cl)
+	}
+
+	return semVerConstraint, nil
+}

vendor/github.com/onsi/ginkgo/v2/types/types.go

@@ -30,6 +30,9 @@ type Report struct {
 	//SuiteLabels captures any labels attached to the suite by the DSL's RunSpecs() function
 	SuiteLabels []string
 
+	//SuiteSemVerConstraints captures any semVerConstraints attached to the suite by the DSL's RunSpecs() function
+	SuiteSemVerConstraints []string
+
 	//SuiteSucceeded captures the success or failure status of the test run
 	//If true, the test run is considered successful.
 	//If false, the test run is considered unsuccessful
@@ -129,13 +132,18 @@ type SpecReport struct {
 	// all Describe/Context/When containers in this spec's hierarchy
 	ContainerHierarchyLabels [][]string
 
-	// LeafNodeType, LeadNodeLocation, LeafNodeLabels and LeafNodeText capture the NodeType, CodeLocation, and text
+	// ContainerHierarchySemVerConstraints is a slice containing the semVerConstraints of
+	// all Describe/Context/When containers in this spec's hierarchy
+	ContainerHierarchySemVerConstraints [][]string
+
+	// LeafNodeType, LeafNodeLocation, LeafNodeLabels, LeafNodeSemVerConstraints and LeafNodeText capture the NodeType, CodeLocation, and text
 	// of the Ginkgo node being tested (typically an NodeTypeIt node, though this can also be
 	// one of the NodeTypesForSuiteLevelNodes node types)
-	LeafNodeType     NodeType
-	LeafNodeLocation CodeLocation
-	LeafNodeLabels   []string
-	LeafNodeText     string
+	LeafNodeType              NodeType
+	LeafNodeLocation          CodeLocation
+	LeafNodeLabels            []string
+	LeafNodeSemVerConstraints []string
+	LeafNodeText              string
 
 	// State captures whether the spec has passed, failed, etc.
 	State SpecState
@@ -198,48 +206,52 @@ type SpecReport struct {
 func (report SpecReport) MarshalJSON() ([]byte, error) {
 	//All this to avoid emitting an empty Failure struct in the JSON
 	out := struct {
-		ContainerHierarchyTexts     []string
-		ContainerHierarchyLocations []CodeLocation
-		ContainerHierarchyLabels    [][]string
-		LeafNodeType                NodeType
-		LeafNodeLocation            CodeLocation
-		LeafNodeLabels              []string
-		LeafNodeText                string
-		State                       SpecState
-		StartTime                   time.Time
-		EndTime                     time.Time
-		RunTime                     time.Duration
-		ParallelProcess             int
-		Failure                     *Failure `json:",omitempty"`
-		NumAttempts                 int
-		MaxFlakeAttempts            int
-		MaxMustPassRepeatedly       int
-		CapturedGinkgoWriterOutput  string              `json:",omitempty"`
-		CapturedStdOutErr           string              `json:",omitempty"`
-		ReportEntries               ReportEntries       `json:",omitempty"`
-		ProgressReports             []ProgressReport    `json:",omitempty"`
-		AdditionalFailures          []AdditionalFailure `json:",omitempty"`
-		SpecEvents                  SpecEvents          `json:",omitempty"`
+		ContainerHierarchyTexts             []string
+		ContainerHierarchyLocations         []CodeLocation
+		ContainerHierarchyLabels            [][]string
+		ContainerHierarchySemVerConstraints [][]string
+		LeafNodeType                        NodeType
+		LeafNodeLocation                    CodeLocation
+		LeafNodeLabels                      []string
+		LeafNodeSemVerConstraints           []string
+		LeafNodeText                        string
+		State                               SpecState
+		StartTime                           time.Time
+		EndTime                             time.Time
+		RunTime                             time.Duration
+		ParallelProcess                     int
+		Failure                             *Failure `json:",omitempty"`
+		NumAttempts                         int
+		MaxFlakeAttempts                    int
+		MaxMustPassRepeatedly               int
+		CapturedGinkgoWriterOutput          string              `json:",omitempty"`
+		CapturedStdOutErr                   string              `json:",omitempty"`
+		ReportEntries                       ReportEntries       `json:",omitempty"`
+		ProgressReports                     []ProgressReport    `json:",omitempty"`
+		AdditionalFailures                  []AdditionalFailure `json:",omitempty"`
+		SpecEvents                          SpecEvents          `json:",omitempty"`
 	}{
-		ContainerHierarchyTexts:     report.ContainerHierarchyTexts,
-		ContainerHierarchyLocations: report.ContainerHierarchyLocations,
-		ContainerHierarchyLabels:    report.ContainerHierarchyLabels,
-		LeafNodeType:                report.LeafNodeType,
-		LeafNodeLocation:            report.LeafNodeLocation,
-		LeafNodeLabels:              report.LeafNodeLabels,
-		LeafNodeText:                report.LeafNodeText,
-		State:                       report.State,
-		StartTime:                   report.StartTime,
-		EndTime:                     report.EndTime,
-		RunTime:                     report.RunTime,
-		ParallelProcess:             report.ParallelProcess,
-		Failure:                     nil,
-		ReportEntries:               nil,
-		NumAttempts:                 report.NumAttempts,
-		MaxFlakeAttempts:            report.MaxFlakeAttempts,
-		MaxMustPassRepeatedly:       report.MaxMustPassRepeatedly,
-		CapturedGinkgoWriterOutput:  report.CapturedGinkgoWriterOutput,
-		CapturedStdOutErr:           report.CapturedStdOutErr,
+		ContainerHierarchyTexts:             report.ContainerHierarchyTexts,
+		ContainerHierarchyLocations:         report.ContainerHierarchyLocations,
+		ContainerHierarchyLabels:            report.ContainerHierarchyLabels,
+		ContainerHierarchySemVerConstraints: report.ContainerHierarchySemVerConstraints,
+		LeafNodeType:                        report.LeafNodeType,
+		LeafNodeLocation:                    report.LeafNodeLocation,
+		LeafNodeLabels:                      report.LeafNodeLabels,
+		LeafNodeSemVerConstraints:           report.LeafNodeSemVerConstraints,
+		LeafNodeText:                        report.LeafNodeText,
+		State:                               report.State,
+		StartTime:                           report.StartTime,
+		EndTime:                             report.EndTime,
+		RunTime:                             report.RunTime,
+		ParallelProcess:                     report.ParallelProcess,
+		Failure:                             nil,
+		ReportEntries:                       nil,
+		NumAttempts:                         report.NumAttempts,
+		MaxFlakeAttempts:                    report.MaxFlakeAttempts,
+		MaxMustPassRepeatedly:               report.MaxMustPassRepeatedly,
+		CapturedGinkgoWriterOutput:          report.CapturedGinkgoWriterOutput,
+		CapturedStdOutErr:                   report.CapturedStdOutErr,
 	}
 
 	if !report.Failure.IsZero() {
@@ -312,6 +324,28 @@ func (report SpecReport) Labels() []string {
 	return out
 }
 
+// SemVerConstraints returns a deduped set of all the spec's SemVerConstraints.
+func (report SpecReport) SemVerConstraints() []string {
+	out := []string{}
+	seen := map[string]bool{}
+	for _, semVerConstraints := range report.ContainerHierarchySemVerConstraints {
+		for _, semVerConstraint := range semVerConstraints {
+			if !seen[semVerConstraint] {
+				seen[semVerConstraint] = true
+				out = append(out, semVerConstraint)
+			}
+		}
+	}
+	for _, semVerConstraint := range report.LeafNodeSemVerConstraints {
+		if !seen[semVerConstraint] {
+			seen[semVerConstraint] = true
+			out = append(out, semVerConstraint)
+		}
+	}
+
+	return out
+}
+
 // MatchesLabelFilter returns true if the spec satisfies the passed in label filter query
 func (report SpecReport) MatchesLabelFilter(query string) (bool, error) {
 	filter, err := ParseLabelFilter(query)
@@ -321,6 +355,15 @@ func (report SpecReport) MatchesLabelFilter(query string) (bool, error) {
 	return filter(report.Labels()), nil
 }
 
+// MatchesSemVerFilter returns true if the spec satisfies the passed in label filter query
+func (report SpecReport) MatchesSemVerFilter(version string) (bool, error) {
+	filter, err := ParseSemVerFilter(version)
+	if err != nil {
+		return false, err
+	}
+	return filter(report.SemVerConstraints()), nil
+}
+
 // FileName() returns the name of the file containing the spec
 func (report SpecReport) FileName() string {
 	return report.LeafNodeLocation.FileName

vendor/github.com/onsi/ginkgo/v2/types/version.go

@@ -1,3 +1,3 @@
 package types
 
-const VERSION = "2.23.4"
+const VERSION = "2.24.0"