coverage

type Collector interface {
	LoadSpec(r io.Reader) (err error)
	ReportFailure(endpoint common.Endpoint, method common.Method, req *http.Request, err error)
	ReportUnmet(endpoint common.Endpoint, method common.Method, req *http.Request, exp common.Expectation, err error)
	ReportMet(endpoint common.Endpoint, method common.Method, req *http.Request, exp common.Expectation)
	ReportSkipped(endpoint common.Endpoint, method common.Method, req *http.Request, exp common.Expectation)
	ReportTiming(endpoint common.Endpoint, method common.Method, req *http.Request, dur time.Duration, tt *TraceTiming)
	HasFailures() bool
}

type Common struct {
	Failures []Failure
	Unmet    []Unmet
	Met      []Met
	Skipped  []Skip
	Timings  Timings
}

type Coverage struct {
	Endpoints map[string]*Endpoint
	OAS       *chioas.Definition
	Common
	// contains filtered or unexported fields
}

type Endpoint struct {
	Endpoint common.Endpoint
	Methods  map[string]*Method
	Common
}

type Failure struct {
	Endpoint common.Endpoint
	Method   common.Method
	Request  *http.Request
	Error    error
}

type Met struct {
	Endpoint    common.Endpoint
	Method      common.Method
	Request     *http.Request
	Expectation common.Expectation
}

type Method struct {
	Method common.Method
	Common
}

type Skip struct {
	Endpoint    common.Endpoint
	Method      common.Method
	Request     *http.Request
	Expectation common.Expectation
}

type Spec struct {
	CoveredPaths    map[string]*SpecPath
	NonCoveredPaths map[string]*SpecPath
	UnknownPaths    map[string]*SpecPath
}

type SpecMethod struct {
	Method    string
	MethodDef *chioas.Method
	Common
}

type SpecPath struct {
	Path              string
	PathDef           *chioas.Path
	CoveredMethods    map[string]*SpecMethod
	NonCoveredMethods map[string]*SpecMethod
	UnknownMethods    map[string]*SpecMethod
}

type Timing struct {
	Endpoint common.Endpoint
	Method   common.Method
	Request  *http.Request
	Duration time.Duration
	Trace    *TraceTiming
}

type TimingStats struct {
	// Mean is the mean average response time. Gives a sense of typical latency under the current test conditions
	Mean time.Duration
	// StdDev is the standard deviation - how much individual response times deviate from the mean.
	//
	// A small StdDev means responses are consistent; a large one means erratic latency
	StdDev time.Duration // sqrt(Variance)
	// Variance is how much response times vary - in squared seconds.
	//
	// The lower the value, the better.  A high value indicates jitter and inconsistent response times
	Variance float64 // in seconds²
	// Minimum is the fastest observed response time. Indicates best-case performance
	Minimum time.Duration
	// Maximum is the slowest observed response time. Often reveals worst-case outliers (e.g., cold starts, timeouts)
	Maximum time.Duration
	// P50 is the median response time - half the runs were faster, half slower.
	//
	// Unlike Mean, it’s robust to outliers.  Indicates “Typical” latency.
	P50 time.Duration
	// P90 is the 90th percentile of response times - 9 out of 10 runs were this fast or faster.
	//
	// Useful for SLO/SLA checks.
	P90 time.Duration
	// P99 is the 99th percentile of response times - highlights rare but serious tail latencies.
	P99 time.Duration
	// Count is how many timings the stats are based on.
	//
	// Important for trustworthiness: low counts mean less reliable percentiles.
	Count int
	// Sample is whether the Variance / StdDev were computed using sample (n-1) or population (n) denominator — mostly for internal correctness.
	Sample bool
}

type Timings []Timing

type TraceTiming struct {
	Start               time.Time
	DNSStart, DNSDone   time.Time
	ConnStart, ConnDone time.Time
	TLSStart, TLSDone   time.Time
	WroteReq            time.Time
	FirstByte           time.Time
	ReusedConn          bool
	TTFB                time.Duration
}

type Unmet struct {
	Endpoint    common.Endpoint
	Method      common.Method
	Request     *http.Request
	Expectation common.Expectation
	Error       error
}