cicada

type ArrivalRateOutput struct {
	Succeeded  int
	Failed     int
	FinalUsers int
	FinalRPS   int
	LastOutput interface{}
}

type BackendBuilder interface {
	GetTestBackend() TestBackend
	GetTestEventBackend() TestEventBackend
	GetScenarioBackend(scenario *Scenario, state *State) ScenarioBackend
}

type ConstantArrivalRateConfig struct {
	TargetRPS             int
	MinUsers              int
	MaxUsers              int
	Duration              time.Duration
	ResultMetricConverter ResultMetricConverter
}

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

type DefaultScenarioSummary struct {
	Succeeded  int
	Failed     int
	LastOutput interface{}
}

type EmojiString string

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

type EngineConfig struct {
	BackendBuilder BackendBuilder
}

type Event struct {
	Kind    string
	Payload interface{}
}

type LoadModel = func(sc ScenarioCommands, state *State) (interface{}, error)

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

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

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

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

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

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

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

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

type LocalUserCommands struct {
	Scenario *Scenario
	// contains filtered or unexported fields
}

type MetricAggregator interface {
	GetScenarioMetricNames() map[string][]string
	GetCount(scenario, name string) int
	GetTotal(scenario, name string) float64
	GetMin(scenario, name string) float64
	GetMedian(scenario, name string) float64
	GetMax(scenario, name string) float64
	GetAverage(scenario, name string) float64
	GetRateAbove(scenario, name string, splitPoint float64) float64
	GetLast(scenario, name string) float64
}

type MetricPrinter interface {
	GetPrintouts(scenario string) []string
}

type MetricsCollector func(results []*UserResult) []*ScenarioMetric

type NIterationsConfig struct {
	Iterations            int
	Users                 int
	ResultMetricConverter ResultMetricConverter
}

type NSecondsConfig struct {
	Users                 int
	Duration              time.Duration
	ResultMetricConverter ResultMetricConverter
}

type PoppedScenarioMetric struct {
	Metric *ScenarioMetric
	Err    error
}

type PoppedScenarioResult struct {
	Result *ScenarioResult
	Err    error
}

type PoppedTestEvent struct {
	Event *TestEvent
	Err   error
}

type PoppedTestResult struct {
	Result *TestResult
	Err    error
}

type PoppedUserEvent struct {
	Event *Event
	Err   error
}

type PoppedUserResult struct {
	Result *UserResult
	Err    error
}

type PoppedWork struct {
	Err error
}

type PrinterFunction struct {
	Scenario string
	Name     string
	Printer  func(scenario, name string, agg MetricAggregator) string
}

type ResultAggregator func(result *UserResult, previous interface{}) interface{}

type ResultMetricConverter = func(output interface{}) map[string]float64

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

type ScaleOutFunction func(currentUsers int) int

type Scenario struct {
	Name         string
	Fn           ScenarioFunction
	Dependencies []*Scenario
	LoadModel    LoadModel
	UserLoop     UserLoop
}

type ScenarioBackend interface {
	StartUsers(users int) error
	StopUsers(users int) error
	DistributeWork(work int) error
	SendUserEvents(kind string, payload interface{}) error
	GetUserResults() <-chan *PoppedUserResult
	SetScenarioResult(output interface{}, exception error, timeTaken time.Duration) error
	AddMetric(name string, value float64) error
	ShutdownChannel() <-chan error
	Stop()
}

type ScenarioCommands interface {
	GetNumUsers() (int, error)
	StartUsers(users int) error
	StopUsers(users int) error
	ScaleUsers(users int) error
	AddWork(amount int) error
	SendUserEvents(kind string, payload interface{}) error
	GetLatestResults() <-chan *PoppedUserResult
	AddDatastoreMetric(name string, value float64) error
	ShutdownChannel() <-chan error
}

type ScenarioFunction = func(state *State) (interface{}, error)

type ScenarioMetric struct {
	Scenario string
	Name     string
	Value    float64
}

type ScenarioOptions struct {
	Dependencies []*Scenario
	LoadModel    LoadModel
	UserLoop     UserLoop
}

type ScenarioResult struct {
	ScenarioName string
	Result       interface{}
	Exception    error
	TimeTaken    time.Duration
}

type ScenarioStatus string

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

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

type StatPrinterConfig struct {
	MetricAggregator MetricAggregator
	PrinterFunctions []*PrinterFunction
}

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

type TestBackend interface {
	StartScenario(scenario *Scenario, state *State) error
	GetScenarioResults() <-chan *PoppedScenarioResult
	SendTestEvent(event *TestEvent) error
	SetTestResult(result *TestResult) error
	Stop()
}

type TestEvent struct {
	Text             string
	ScenarioStatuses map[string]ScenarioStatus
}

type TestEventBackend interface {
	GetTestEvents() <-chan *PoppedTestEvent
	GetTestResult() <-chan *PoppedTestResult
	GetTestMetrics() <-chan *PoppedScenarioMetric
	Stop()
}

type TestResult struct {
	State            *State
	ScenarioStatuses map[string]ScenarioStatus
}

type ThresholdConfig struct {
	StartingUsers         int
	ScalingPeriod         time.Duration
	ScaleOutFunction      ScaleOutFunction
	ResultMetricConverter ResultMetricConverter
	ResultAggregator      ResultAggregator
	ThresholdFunction     ThresholdFunction
}

type ThresholdFunction func(stats *ThresholdOutput) bool

type ThresholdOutput struct {
	ResultsCollected int64
	Rps              float64
	SuccessRate      float64
	Aggregate        interface{}
	FinalUsers       int
}

type UserBackend interface {
	GetUserEvents(kind string) <-chan *PoppedUserEvent
	AddUserResult(result *UserResult) error
	ShutdownChannel() <-chan error
	Stop()
}

type UserCommands interface {
	GetUserID() string
	GetEvents(kind string) <-chan *PoppedUserEvent
	GetWork() <-chan *PoppedWork
	Run(state *State) (interface{}, error)
	ShutdownChannel() <-chan error
	ReportResult(
		output interface{},
		exception error,

		timeTaken time.Duration,
	) error
}

type UserLoop = func(uc UserCommands, state *State)

type UserResult struct {
	Output    interface{}
	Exception error
	// Logs      string
	TimeTaken time.Duration
}