ginkgo

type AggressiveRetryStrategy struct {
	// contains filtered or unexported fields
}

type ClusterStabilityDuringTest string

type Edge struct {
	In, Out *PodElement
}

type GinkgoRunSuiteOptions struct {
	Parallelism int
	Count       int
	FailFast    bool
	Timeout     time.Duration
	JUnitDir    string

	// ShardCount is the total number of partitions the test suite is divided into.
	// Each executor runs one of these partitions.
	ShardCount int

	// ShardStrategy is which strategy we'll use for dividing tests.
	ShardStrategy string

	// ShardID is the 1-based index of the shard this instance is responsible for running.
	ShardID int

	// SyntheticEventTests allows the caller to translate events or outside
	// context into a failure.
	SyntheticEventTests JUnitsForEvents

	ClusterStabilityDuringTest string

	IncludeSuccessOutput bool

	CommandEnv []string

	DryRun        bool
	PrintCommands bool
	genericclioptions.IOStreams

	StartTime time.Time

	ExactMonitorTests   []string
	DisableMonitorTests []string
	Extension           *extension.Extension

	// RetryStrategy controls retry behavior and final outcome decisions
	RetryStrategy RetryStrategy

	// WithHypervisorConfigJSON contains JSON configuration for hypervisor-based recovery operations
	WithHypervisorConfigJSON string
}

type HashSharder struct{}

type JUnitForEventsFunc func(events monitorapi.Intervals, duration time.Duration, kubeClientConfig *rest.Config, testSuite string, recordedResource *monitorapi.ResourcesMap) []*junitapi.JUnitTestCase

type JUnitsForAllEvents []JUnitsForEvents

type JUnitsForEvents interface {
	// JUnitsForEvents returns a set of additional test passes or failures implied by the
	// events sent during the test suite run. If passed is false, the entire suite is failed.
	// To set a test as flaky, return a passing and failing JUnitTestCase with the same name.
	JUnitsForEvents(events monitorapi.Intervals, duration time.Duration, kubeClientConfig *rest.Config, testSuite string, recordedResource *monitorapi.ResourcesMap) []*junitapi.JUnitTestCase
}

type Kind int

type NoRetryStrategy struct{}

type PodCollector struct {
	// contains filtered or unexported fields
}

type PodDisplacements map[string][][]Edge

type PodElement struct {
	Namespace         string       `json:"namespace"`
	Kind              string       `json:"kind"`
	KindName          string       `json:"kindName"`
	PodName           string       `json:"podName"`
	Node              string       `json:"node"`
	CreationTimestamp metav1.Time  `json:"creationTimestamp"`
	DeletionTimestamp *metav1.Time `json:"deletionTimestamp"`
	Events            []string     `json:"events"`
}

type RetryOnceStrategy struct {
	AllowedRetryTests map[string]bool
}

type RetryOutcome int

type RetryStrategy interface {
	// Name returns the strategy name for CLI and logging
	Name() string

	// ShouldAttemptRetries determines if we attempt any retries given the list of failing tests
	ShouldAttemptRetries(failing []*testCase, suite *TestSuite) bool

	// GetMaxRetries returns the upper bound of retries (for reporting/planning)
	GetMaxRetries(testCase *testCase) int

	// ShouldContinue determines if we continue retrying. Allows for early termination of retries.
	ShouldContinue(testCase *testCase, allAttempts []*testCase, nextAttemptNumber int) bool

	// DecideOutcome reports the final result of all attempts.
	DecideOutcome(attempts []*testCase) RetryOutcome
}

type Sharder interface {
	// Shard selects tests for the given executor and total shards.
	// The returned slice must be deterministic and non-overlapping across shards.
	Shard(allTests []*testCase, shardCount, shardID int) ([]*testCase, error)

	// Name returns the name of the strategy (e.g. "hash", "time-balanced").
	Name() string
}

type TestMatchFunc func(name string) bool

type TestScheduler interface {
	// GetNextTestToRun blocks until a test is available, then returns it.
	// Returns nil when all tests have been distributed (queue is empty) or context is cancelled.
	// When a test is returned, it is atomically removed from queue and marked as running.
	// This method can be safely called from multiple goroutines concurrently.
	GetNextTestToRun(ctx context.Context) *testCase

	// MarkTestComplete marks a test as complete, cleaning up its conflicts and taints.
	// This may unblock other tests that were waiting.
	// This method can be safely called from multiple goroutines concurrently.
	MarkTestComplete(test *testCase)
}

type TestState string

type TestSuite struct {
	Name        string `json:"name"`
	Description string `json:"description"`
	Kind        Kind   `json:"kind"`

	SuiteMatcher TestMatchFunc `json:"-"`

	// The number of times to execute each test in this suite.
	Count int `json:"count,omitempty"`
	// The maximum parallelism of this suite based on a minimum of 3 workers.
	// Otherwise, parallelism is automatically scaled down using 1/3 the parallelism value x the number of workers.
	// Jobs can explicitly set the parallelism value via max-parallel-tests
	Parallelism int `json:"parallelism,omitempty"`
	// The number of flakes that may occur before this test is marked as a failure.
	MaximumAllowedFlakes int `json:"maximumAllowedFlakes,omitempty"`

	ClusterStabilityDuringTest ClusterStabilityDuringTest `json:"clusterStabilityDuringTest,omitempty"`

	TestTimeout time.Duration `json:"testTimeout,omitempty"`

	// OTE
	Parents    []string              `json:"parents,omitempty"`
	Qualifiers []string              `json:"qualifiers,omitempty"`
	Extension  *extensions.Extension `json:"-"`
}