frame2

type AlwaysDisruptor interface {
	// This is just a marker; it does nothing
	AlwaysDisruptor()
}

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

type DefaultMonitor struct {
	// A list of validators and their names, which cannot conflict
	// with those in ValidatorConfigs
	Validators map[string]Validator

	// The interval between Validator runs.  For ValidatorConfigs, that's
	// the default, if not specified there
	Interval time.Duration

	// Same as Validators, but allow for per-Validator configuration
	ValidatorConfigs []ValidatorConfig

	// TODO Path where the report should be put.  If not set, TODO
	Path string

	Results map[string][]MonitorResult

	Log
	// contains filtered or unexported fields
}

type DefaultRunDealer struct {
	// Perhaps make this private?
	// For now it is public to break less things
	Runner *Run

	// TODO
	// When implemented, should it really be here, or have another one
	// for it?
	// This needs to be public, so user can change it at will?
	Ctx context.Context
}

type Disruptor interface {
	DisruptorEnvValue() string
}

type DisruptorConfigurer interface {
	Configure(string) error
}

type Execute struct {
}

type Executor interface {
	Execute() error
}

type Expect struct {
	StdOut      []string
	StdErr      []string
	StdOutRe    []regexp.Regexp
	StdErrRe    []regexp.Regexp
	StdOutReNot []regexp.Regexp
	StdErrReNot []regexp.Regexp
}

type FinalizerHook interface {

	// FinalizerHook will be executed at the end of the
	// test, before all other finalizer tasks, such as the
	// re-run of validators marked as final
	PreFinalizerHook(runner *Run) error

	// PostSubFinalizerHook will be executed after the
	// final validators are run.  It can be used, for example,
	// to reset the disruptor, so it starts a new on the
	// next sub test.  On an upgrade disruptor, for example,
	// the next cycle that has a subfinalizer needs to start
	// with the old version again.
	PostSubFinalizerHook(runner *Run) error
}

type FrameLogger interface {
	// passes its parameters to a log.Logger's Printf.  Either
	// the one returned by GetLogger, or the default logger if
	// that call returns nil
	Printf(format string, v ...any)
	GetLogger() *log.Logger
	SetLogger(logger *log.Logger)

	// Sets the logger, but only if it is currently nil
	OrSetLogger(logger *log.Logger)
}

type Inspector interface {
	Inspect(step *Step, phase *Phase)
}

type Log struct {
	Logger *log.Logger
}

type Monitor interface {
	Executor

	// Starts the monitoring in a different goroutine
	Monitor(*Run) error

	// Result() error
	Report() error
}

type MonitorResult struct {
	Timestamp time.Time
	Duration  time.Duration
	Step      *Step
	Id        string
	Result    error
}

type Phase struct {
	Name      string
	Doc       string
	Setup     []Step
	Teardown  []Step
	MainSteps []Step

	Runner *Run

	Log
	DefaultRunDealer
	// contains filtered or unexported fields
}

type PostMainSetupHook interface {
	PostMainSetupHook(runner *Run) error
}

type Procedure struct {
	Fn func()
}

type Retry struct {
	Fn      RetryFunction // The thing to be retried
	Options RetryOptions
}

type RetryFunction func() (err error)

type RetryOptions struct {
	Allow    int           // for initial failures
	Ignore   int           // initial successes
	Ensure   int           // last n tries are successful.  Minimum 1
	Retries  int           // after Allow phase
	Interval time.Duration // if not given, the default is 1s
	Quiet    bool          // if true, no attempt logs

	Min int // TODO Run as normal, but delay report until that number of tries have been done

	Rate float32 // TODO: "Ensure" will not be 100%, but based on this rate.  So, if Ensure is 100

	KeepTrying bool
	Ctx        context.Context
	Timeout    time.Duration
}

type Run struct {
	T                  *testing.T
	Doc                string      // TODO this is currently unused (ie, it's not printed)
	RequiredDisruptors []Disruptor // TODO
	// contains filtered or unexported fields
}

type RunDealer interface {
	SetRunner(parent *Run, kind RunnerType)
	GetRunner() *Run
}

type RunnerType int

type Step struct {
	Doc   string
	Name  string
	Level int
	// Whether the step should always print logs
	// Even if false, logs will be done if SKUPPER_TEST_FRAME2_VERBOSE
	Verbose      bool
	PreValidator Validator

	// TODO make this require a pointer, like validator does, to avoid
	// Runner disconnects
	Modify            Executor
	Validator         Validator
	Validators        []Validator
	ValidatorRetry    RetryOptions
	ValidatorFinal    bool // final validators are re-run at the test's end
	ValidatorSubFinal bool // and subfinal, at the end of subtests
	Substep           Stepper
	Substeps          []*Step
	SubstepRetry      RetryOptions
	// A simple way to invert the meaning of the Validator.  Validators
	// are encouraged to provide more specific negative testing behaviors,
	// but this serves for simpler testing.  If set, it inverts the
	// response from the call sent to Retry, so it can be used to wait
	// until an error is returned (but there is no control on which kind
	// of error that will be)
	// TODO: change this by OnError: Fail, Skip, Ignore, Expect?
	// TODO: add option to inspect error message for specific error; perhaps a function (error) bool,
	// function(error)error or function(error)frame2.action (where action is fail, skip, etc)
	ExpectError bool
	// TODO: ExpectIs, ExpectAs; use errors.Is, errors.As against a list of expected errors?
	SkipWhen bool
}

type Stepper interface {
	GetStep() *Step
}

type TearDowner interface {
	Teardown() Executor
}

type TransformFunc func(any) (any, error)

type ValidationResultHook interface {
	ValidationResultHook(runner *Run, step Step, err error) error
}

type Validator interface {
	Validate() error
	FrameLogger
}

type ValidatorConfig struct {
	Name      string
	Validator Validator
	Interval  time.Duration
}