buck2-quokka 0.1.1

A better external test runner for Buck2
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84

//! The two distinct caching concepts, kept apart so one bit is not written by
//! several places with no precedence.
//!
//! - [`CacheClass`] is the target's base test-execution cacheability, derived
//!   from labels (hermetic vs non-hermetic).
//! - [`TestExecutionCaching`] is the per-action decision actually sent in
//!   `ExecuteRequest2.disable_test_execution_caching`.

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum CacheClass {
    Cacheable,
    Disabled,
}

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum TestExecutionCaching {
    Enabled,
    Disabled,
}

impl TestExecutionCaching {
    pub fn disable_flag(self) -> bool {
        matches!(self, TestExecutionCaching::Disabled)
    }

    /// Derives the final cache enablement per execution action.
    pub fn resolve(
        base: CacheClass,
        is_default_variant: bool,
        is_stress: bool,
        attempt_index: u32,
    ) -> Self {
        if base == CacheClass::Disabled
            || !is_default_variant
            || is_stress
            || attempt_index > 0
        {
            TestExecutionCaching::Disabled
        } else {
            TestExecutionCaching::Enabled
        }
    }
}

pub fn cache_class(labels: &[String]) -> CacheClass {
    let disabled = labels.iter().any(|l| {
        let suffix = l.split_once(':').unwrap_or(("", l)).1;
        matches!(
            suffix,
            "cache_disabled"
                | "flaky"
                | "uses_network"
                | "uses_wall_clock"
                | "uses_randomness_without_seed"
                | "requires_external_service"
                | "serial_global_state"
                | "stress"
                | "network-private"
        )
    });
    if disabled {
        CacheClass::Disabled
    } else {
        CacheClass::Cacheable
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn cache_class_disabled_for_nonhermetic() {
        assert_eq!(cache_class(&["rust:flaky".to_owned()]), CacheClass::Disabled);
        assert_eq!(
            cache_class(&["python:uses_network".to_owned()]),
            CacheClass::Disabled
        );
        assert_eq!(
            cache_class(&["pkg".to_owned()]),
            CacheClass::Cacheable
        );
    }
}