provola-core 0.2.0

A tool for quick development/test cycle in any language
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

use serde::{Deserialize, Serialize};

use crate::test::xunit::FullyQualifiedTestCaseId;

pub type Timestamp = chrono::DateTime<chrono::Utc>;
pub type Duration = std::time::Duration;
pub type Count = usize;
pub type Name = String;
pub type Hostname = String;
pub type Id = String;
pub type Package = String;
pub type ClassName = String;
pub type FailureType = String;
pub type Message = String;

#[derive(Serialize, Deserialize, Debug, Clone, Copy)]
pub enum CoreStatus {
    Unknown,
    Pass,
    Fail,
    Ignored,
    Skipped,
}

impl Default for CoreStatus {
    fn default() -> Self {
        CoreStatus::Unknown
    }
}

impl From<Option<bool>> for CoreStatus {
    fn from(ok: Option<bool>) -> Self {
        match ok {
            None => CoreStatus::Unknown,
            Some(true) => CoreStatus::Pass,
            Some(false) => CoreStatus::Fail,
        }
    }
}

#[derive(Serialize, Deserialize, Debug, Default, Clone)]
pub struct CoreReport {
    pub disabled: Option<Count>,
    pub errors: Option<Count>,
    /// The total number of rule violations
    pub failures: Option<Count>,
    /// The label of the scan
    pub name: Option<Name>,
    /// The total number of rules that were applied
    pub tests: Option<Count>,
    pub testsuites: Vec<CoreTestSuite>,
    /// The time that was required to process all the rules
    pub time: Option<Duration>,
    pub timestamp: Option<Timestamp>,
}

impl CoreReport {
    pub fn sort(&mut self) {
        self.testsuites.sort_by(|x, y| x.name.cmp(&y.name));
        for test_suite in &mut self.testsuites {
            test_suite.testcases.sort_by(|x, y| x.name.cmp(&y.name));
        }
    }
}

#[derive(Serialize, Deserialize, Debug, Default, Clone)]
pub struct CoreTestSuite {
    // TODO properties
    // TODO system-err
    // TODO system-out
    pub disabled: Option<Count>,
    pub errors: Option<Count>,
    pub failures: Option<Count>,
    pub hostname: Option<Hostname>,
    pub id: Option<Id>,
    /// The label of the provider
    pub name: Name,
    pub package: Option<Package>,
    pub skipped: Option<Count>,
    pub testcases: Vec<CoreTestCase>,
    /// The number of rules in the provider that were applied
    pub tests: Count,
    /// The time that was required to process the rules in the provider
    pub time: Option<Duration>,
    pub timestamp: Option<Timestamp>,
}

#[derive(Serialize, Deserialize, Debug, Default, Clone)]
pub struct CoreTestCase {
    // TODO fqtc should not be an Option
    pub fqtc: Option<FullyQualifiedTestCaseId>,
    // TODO error
    // TODO assertions
    // TODO skipped
    // TODO system-err
    // TODO system-out
    pub classname: Option<ClassName>,
    /// The label of the rule
    pub name: Name,
    pub status: CoreStatus,
    /// The time that was required to process all the applications of this rule
    pub time: Option<Duration>,
    pub failures: Vec<CoreFailure>,
}

#[derive(Serialize, Deserialize, Debug, Default, Clone)]
pub struct CoreFailure {
    pub ttype: FailureType,
    pub message: Message,
}