ripr 0.8.0

Find static mutation-exposure gaps before expensive mutation testing
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
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112

use crate::app::{CheckOutput, Mode};
use crate::domain::{ExposureClass, LanguageId};
use crate::output::python_repair_card::{PythonRepairCard, python_repair_card};
use std::path::{Path, PathBuf};

pub(crate) const PILOT_SUMMARY_SCHEMA_VERSION: &str = "0.2";

#[derive(Clone, Debug, PartialEq, Eq)]
pub(crate) struct PilotArtifacts {
    pub(crate) repo_exposure_json: PathBuf,
    pub(crate) repo_exposure_md: PathBuf,
    pub(crate) agent_seam_packets_json: PathBuf,
    pub(crate) pilot_summary_json: PathBuf,
    pub(crate) pilot_summary_md: PathBuf,
}

#[derive(Clone, Copy)]
pub(crate) struct PilotSummaryContext<'a> {
    pub(crate) root: &'a Path,
    pub(crate) mode: &'a Mode,
    pub(crate) config_path: Option<&'a Path>,
    pub(crate) max_seams: usize,
    pub(crate) timeout_ms: u64,
    pub(crate) artifacts: &'a PilotArtifacts,
    pub(crate) python_first_use: Option<&'a PilotPythonFirstUse>,
}

#[derive(Clone, Debug, PartialEq, Eq)]
pub(crate) struct PilotPythonFirstUse {
    pub(crate) status: PilotPythonFirstUseStatus,
    pub(crate) findings_total: usize,
    pub(crate) repair_cards_total: usize,
    pub(crate) limitation_count: usize,
    pub(crate) analysis_error: Option<String>,
    pub(crate) top_repair_card: Option<PythonRepairCard>,
}

#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub(crate) enum PilotPythonFirstUseStatus {
    AnalysisUnavailable,
    NoPythonFindings,
    NoRepairCards,
    Ready,
}

impl PilotPythonFirstUse {
    pub(crate) fn analysis_unavailable(error: String) -> Self {
        Self {
            status: PilotPythonFirstUseStatus::AnalysisUnavailable,
            findings_total: 0,
            repair_cards_total: 0,
            limitation_count: 1,
            analysis_error: Some(error),
            top_repair_card: None,
        }
    }

    pub(crate) fn from_check_output(output: &CheckOutput) -> Self {
        let python_findings = output
            .findings
            .iter()
            .filter(|finding| finding.language == Some(LanguageId::Python));
        let findings_total = python_findings.clone().count();
        let limitation_count = python_findings
            .filter(|finding| is_python_limitation(finding))
            .count();
        let cards = output
            .findings
            .iter()
            .filter_map(python_repair_card)
            .collect::<Vec<_>>();
        let repair_cards_total = cards.len();
        let top_repair_card = cards.into_iter().next();
        let status = if top_repair_card.is_some() {
            PilotPythonFirstUseStatus::Ready
        } else if findings_total == 0 {
            PilotPythonFirstUseStatus::NoPythonFindings
        } else {
            PilotPythonFirstUseStatus::NoRepairCards
        };

        Self {
            status,
            findings_total,
            repair_cards_total,
            limitation_count,
            analysis_error: None,
            top_repair_card,
        }
    }
}

impl PilotPythonFirstUseStatus {
    pub(crate) fn as_str(self) -> &'static str {
        match self {
            PilotPythonFirstUseStatus::AnalysisUnavailable => "analysis_unavailable",
            PilotPythonFirstUseStatus::NoPythonFindings => "no_python_findings",
            PilotPythonFirstUseStatus::NoRepairCards => "no_repair_cards",
            PilotPythonFirstUseStatus::Ready => "ready",
        }
    }
}

fn is_python_limitation(finding: &crate::domain::Finding) -> bool {
    finding.static_limit_kind.is_some()
        || matches!(
            finding.class,
            ExposureClass::InfectionUnknown
                | ExposureClass::PropagationUnknown
                | ExposureClass::StaticUnknown
        )
}