servicetest

type BlockingService struct {
	StartFailure error
	StartLimit   int
	StartDelay   time.Duration
	RunFailure   error
	HaltDelay    time.Duration
	// contains filtered or unexported fields
}

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

type ErrorService struct {
	Name       service.Name
	StartDelay time.Duration
	// contains filtered or unexported fields
}

type FloatRange struct {
	Min float64
	Max float64
}

type FloatRangeMaker struct {
	Min FloatRange
	Max FloatRange
}

type FuzzError struct {
	Name  string
	Err   string
	Count int
}

type FuzzServiceStats struct {
	ServiceHalt    *ErrorCounter
	ServiceStart   *ErrorCounter
	ServiceRestart *ErrorCounter
	// contains filtered or unexported fields
}

type FuzzStats struct {
	Duration        time.Duration
	Seed            int64
	Tick            int32
	RunnersStarted  int32
	RunnersCurrent  int32
	RunnersHalted   int32
	ServicesCurrent int32

	Service           *FuzzServiceStats
	StateCheckResults map[service.State]int
	// contains filtered or unexported fields
}

type IntRange struct {
	Min int
	Max int
}

type IntRangeMaker struct {
	Min IntRange
	Max IntRange
}

type Listener interface {
	OnServiceEnd() service.OnEnd
	OnServiceError() service.OnError
}

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

type ListenerCollectorEnd struct {
	Stage service.Stage
	Err   error
}

type RunnerFuzzer struct {
	RunnerSource RunnerSource

	Duration     time.Duration
	Tick         time.Duration
	RunnerLimit  int
	ServiceLimit int

	RunnerCreateChance float64

	// This is a wonderful mess-maker. It will attempt, in a goroutine,
	// to halt every service it finds in a runner. It does NOT a happy
	// path make.
	RunnerHaltChance float64

	ServiceCreateChance float64

	// Chance that the fuzzer will randomly halt a service, regardless of
	// whether it is an appropriate time:
	ServiceHaltChance float64

	ServiceStartFailureChance float64
	ServiceRunFailureChance   float64

	// Chance that the fuzzer will attempt to restart a random service at a
	// random moment.
	ServiceRestartChance float64

	// Chance that a service started by the fuzzer will be restartable.
	ServiceRestartableChance float64

	// The amount of time the service will take before it calls ctx.Ready().
	ServiceStartTime TimeRange

	// The amount of time the fuzzer will wait for the service to start. If
	// this is shorter than ServiceStartTime, the fuzzer will experience start
	// failures.
	StartWaitTimeout TimeRange

	ServiceRunTime     TimeRange
	ServiceHaltAfter   TimeRange
	ServiceHaltDelay   TimeRange
	ServiceHaltTimeout TimeRange
	StateCheckChance   float64

	Stats *FuzzStats `json:"-"`
	// contains filtered or unexported fields
}

type RunnerFuzzerBuilder struct {
	StateCheckChance FloatRange

	RunnerCreateChance FloatRange
	RunnerHaltChance   FloatRange

	ServiceCreateChance FloatRange

	StartWaitChance           FloatRange
	ServiceStartFailureChance FloatRange
	ServiceRunFailureChance   FloatRange

	ServiceStartTime   TimeRangeMaker
	StartWaitTimeout   TimeRangeMaker
	ServiceRunTime     TimeRangeMaker
	ServiceHaltAfter   TimeRangeMaker
	ServiceHaltDelay   TimeRangeMaker
	ServiceHaltTimeout TimeRangeMaker
}

type RunnerSource interface {
	CanHaltRunner() bool
	CanCreateRunner() bool

	FirstRunner(l Listener) service.Runner
	CreateRunner(l Listener) service.Runner

	End()
}

type ServiceRunnerSource struct{}

type StateWaiter interface {
	TakeN(n int, timeout time.Duration) []service.StateChange
	Take(timeout time.Duration) *service.StateChange
	C() <-chan service.StateChange
}

type TimeRange struct {
	Min time.Duration
	Max time.Duration
}

type TimeRangeMaker struct {
	Min TimeRange
	Max TimeRange
}

type TimedService struct {
	StartFailure    error
	StartDelay      time.Duration
	StartLimit      int
	RunFailure      error
	RunTime         time.Duration
	HaltDelay       time.Duration
	UnhaltableSleep bool
	// contains filtered or unexported fields
}

type UnhaltableService struct {
	Name service.Name
	// contains filtered or unexported fields
}

type Waiter interface {
	TakeN(n int, timeout time.Duration) []error
	Take(timeout time.Duration) error
	C() <-chan error
}