Types Reference

This chapter documents the core types used throughout cargo-ninety-nine.

Test Execution

TestRun

A single test execution record with full metadata.

#![allow(unused)]
fn main() {
pub struct TestRun {
    pub id: Uuid,
    pub test_name: TestName,
    pub test_path: PathBuf,
    pub outcome: TestOutcome,
    pub duration: Duration,
    pub timestamp: DateTime<Utc>,
    pub commit_hash: String,
    pub branch: String,
    pub environment: TestEnvironment,
    pub retry_count: u32,
    pub error_message: Option<String>,
    pub stack_trace: Option<String>,
}
}

TestOutcome

Classification of a test execution result.

#![allow(unused)]
fn main() {
pub enum TestOutcome {
    Passed,
    Failed,
    Ignored,
    Timeout,
    Panic,
}
}

Implements Display and FromStr for serialization. Display values: "passed", "failed", "ignored", "timeout", "panic".

TestEnvironment

Captures the environment where tests execute, used for pattern correlation.

#![allow(unused)]
fn main() {
pub struct TestEnvironment {
    pub os: String,
    pub rust_version: String,
    pub cpu_count: u32,
    pub memory_gb: f64,
    pub is_ci: bool,
    pub ci_provider: Option<String>,
}
}

Auto-detected at runtime from the host system. The is_ci field is inferred from environment variables (GITHUB_ACTIONS, GITLAB_CI, JENKINS_URL, CIRCLECI, TF_BUILD, BUILDKITE).

TestName

Newtype wrapper providing type-safe test names. Prevents accidental confusion with branch names, commit hashes, or other string fields.

#![allow(unused)]
fn main() {
pub struct TestName(String);
}

Conversions:

• From<String>, From<&str> — construct from strings
• Deref<Target = str> — borrow as &str
• AsRef<str> — reference conversion
• Display — format for output
• PartialEq<str>, PartialEq<&str> — compare with string values

Methods:

• into_inner(self) -> String — consume and return the inner string

Flakiness Detection

FlakinessScore

The primary output of the Bayesian detection engine. Contains the computed probability that a test is flaky along with statistical parameters.

#![allow(unused)]
fn main() {
pub struct FlakinessScore {
    pub test_name: TestName,
    pub probability_flaky: f64,
    pub confidence: f64,
    pub pass_rate: f64,
    pub fail_rate: f64,
    pub total_runs: u64,
    pub consecutive_failures: u32,
    pub last_updated: DateTime<Utc>,
    pub bayesian_params: BayesianParams,
}
}

BayesianParams

Full Bayesian computation state stored for auditability.

#![allow(unused)]
fn main() {
pub struct BayesianParams {
    pub alpha: f64,
    pub beta: f64,
    pub posterior_mean: f64,
    pub posterior_variance: f64,
    pub credible_interval_lower: f64,
    pub credible_interval_upper: f64,
}
}

FlakinessCategory

Human-readable classification of flakiness severity.

#![allow(unused)]
fn main() {
pub enum FlakinessCategory {
    Stable,
    Occasional,
    Moderate,
    Frequent,
    Critical,
}
}

Methods:

• from_score(score: f64) -> Self — classify a probability value
• label(&self) -> &'static str — human-readable label

Sessions

ActiveSession

Represents a running test session. Created via start(); to_run_session() produces the storable RunSession snapshot while the session stays live.

#![allow(unused)]
fn main() {
pub struct ActiveSession { /* private fields */ }
}

Methods:

RunSession

A session record suitable for storage. May represent a running or completed session.

#![allow(unused)]
fn main() {
pub struct RunSession {
    pub id: Uuid,
    pub started_at: DateTime<Utc>,
    pub finished_at: Option<DateTime<Utc>>,
    pub test_count: u32,
    pub flaky_count: u32,
    pub commit_hash: String,
    pub branch: String,
}
}

QuarantineEntry

A quarantined test record.

#![allow(unused)]
fn main() {
pub struct QuarantineEntry {
    pub test_name: TestName,
    pub quarantined_at: DateTime<Utc>,
    pub reason: String,
    pub flakiness_score: f64,
    pub auto_quarantined: bool,
}
}

Analysis

TrendDirection

Direction of flakiness change over time.

#![allow(unused)]
fn main() {
pub enum TrendDirection {
    Improving,
    Stable,
    Degrading,
}
}

A delta exceeding 0.05 (5%) triggers Improving (decreased flakiness) or Degrading (increased flakiness). Otherwise Stable.

TrendSummary

Trend analysis result comparing recent vs. historical flakiness.

#![allow(unused)]
fn main() {
pub struct TrendSummary {
    pub test_name: TestName,
    pub direction: TrendDirection,
    pub recent_score: f64,
    pub previous_score: f64,
    pub score_delta: f64,
    pub window_runs: u64,
}
}

FailurePattern

A detected failure pattern with correlation strength.

#![allow(unused)]
fn main() {
pub struct FailurePattern {
    pub pattern_type: PatternType,
    pub occurrences: u32,
    pub correlation: f64,
    pub examples: Vec<String>,
}
}

PatternType

Classification of detected failure patterns.

#![allow(unused)]
fn main() {
pub enum PatternType {
    TimeOfDay,
    Environmental,
    Random,
}
}