cases

type ExpectedAlert struct {
	// OrderingID is the number used to sort the slice of expected alerts for a given label set of an alert.
	OrderingID int

	// TimeTolerance is the tolerance to be considered when
	// comparing the time of the alert receiving and alert payload fields.
	// This is usually the group interval.
	// TODO: have some additional tolerance on the http request delay on top of group interval.
	TimeTolerance time.Duration

	// This alert should come at Ts time.
	Ts time.Time

	// NextState is the time when the next state of this alert is expected.
	// time.Time{} if the state won't change from here.
	// This is used to check if this alert can be ignored.
	NextState time.Time

	// If it is a Resolved alert, Resolved must be set to true.
	Resolved bool

	// Resend is true if this alert was a resend of the earlier alert with same labels.
	Resend bool

	// ResolvedTime is the time when the alert becomes Resolved. time.Unix(0,0) if never Resolved.
	// This is also the EndsAt of the alert when the alert is Resolved.
	ResolvedTime time.Time

	// EndsAtDelta is the duration w.r.t. the alert reception time when the EndsAt must be set.
	// This is only for pending and firing alerts.
	// It is usually 4*resendDelay or 4*groupInterval, whichever is higher.
	EndsAtDelta time.Duration

	// This is the expected alert.
	Alert *notifier.Alert
}

type TestCase interface {
	// Describe returns the test case's rule group name and description.
	// NOTE: The group name must be unique across all the test cases.
	Describe() (groupName string, description string)

	// RuleGroup returns the alerting rule group that this test case is testing.
	// NOTE: All the rules in the group must include a label `rulegroup="<groupName>"`
	//       which should also be attached to the resultant alerts.
	RuleGroup() (rulefmt.RuleGroup, error)

	// SamplesToRemoteWrite gives all the samples that needs to be remote-written at their
	// respective timestamps. The last sample indicates the end of this test case hence appropriate
	// additional samples must be considered beforehand.
	//
	// All the timestamps returned here are in milliseconds and starts at 0,
	// which is the time when the test suite would start the test.
	// The test suite is responsible for translating these 0 based
	// timestamp to the relevant timestamps for the current time.
	//
	// The samples must be delivered to the remote storage after the timestamp specified on the samples
	// and must be delivered within 10 seconds of that timestamp.
	SamplesToRemoteWrite() []prompb.TimeSeries

	// Init tells the test case the actual timestamp for the 0 time.
	Init(zeroTime int64)

	// TestUntil returns a unix timestamp upto which the test must be running on this TestCase.
	// This must be called after Init() and the returned timestamp refers to absolute unix
	// timestamp (i.e. not relative like the SamplesToRemoteWrite())
	TestUntil() int64

	// CheckAlerts returns nil if the alerts provided are as expected at the given timestamp.
	// Returns an error otherwise describing what is the problem.
	// This must be checked with a min interval of the rule group's interval from RuleGroup().
	CheckAlerts(ts int64, alerts []v1.Alert) error

	// CheckRuleGroup returns nil if the rule group provided is as expected at the given timestamp.
	// Returns an error otherwise describing what is the problem.
	// This must be checked with a min interval of the rule group's interval from RuleGroup().
	CheckRuleGroup(ts int64, rg *v1.RuleGroup) error

	// CheckMetrics returns nil if at give timestamp the metrics contain the expected metrics.
	// Returns an error otherwise describing what is the problem.
	// This must be checked with a min interval of the rule group's interval from RuleGroup().
	CheckMetrics(ts int64, metrics []promql.Sample) error

	// ExpectedAlerts returns all the expected alerts that must be received for this test case.
	// This must be called only after Init().
	ExpectedAlerts() []ExpectedAlert
}