tmflib 0.1.38

Interface library for processing TMF payloads
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

//! Service Test

use serde::{Deserialize, Serialize};

use super::MOD_PATH;
use crate::common::related_party::RelatedParty;
use crate::common::tmf_error::TMFError;
use crate::{DateTime, HasId, HasName, HasRelatedParty, HasValidity, TimePeriod};
use tmflib_derive::{HasId, HasName, HasRelatedParty, HasValidity};

const CLASS_PATH: &str = "serviceTest";

/// Test execution status
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub enum ExecutionStateType {
    /// Acknowledged
    #[default]
    Acknowledged,
    /// In Progress
    InProgress,
    /// Rejected
    Rejected,
    /// Pending
    Pending,
    /// Cancelled
    Cancelled,
    /// Completed
    Completed,
    /// Failed
    Failed,
}

/// Service Test
#[derive(
    Clone, Debug, Default, Deserialize, HasId, HasName, HasValidity, Serialize, HasRelatedParty,
)]
pub struct ServiceTest {
    #[serde(skip_serializing_if = "Option::is_none")]
    description: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    end_date_time: Option<DateTime>,
    #[serde(skip_serializing_if = "Option::is_none")]
    href: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    id: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    mode: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    name: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    start_date_time: Option<DateTime>,
    #[serde(skip_serializing_if = "Option::is_none")]
    state: Option<ExecutionStateType>,
    #[serde(skip_serializing_if = "Option::is_none")]
    valid_for: Option<TimePeriod>,
    #[serde(skip_serializing_if = "Option::is_none")]
    related_party: Option<Vec<RelatedParty>>,
}

impl ServiceTest {
    /// Create new ServiceTest
    pub fn new(name: impl Into<String>) -> ServiceTest {
        let mut st = ServiceTest::create();
        st.name = Some(name.into());
        st
    }
}

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

    const TEST_NAME: &str = "ATest";
    const EXECSTATE_JSON: &str = "\"Acknowledged\"";
    const SERVICETEST_JSON: &str = "{
        \"name\" : \"ServiceTestName\",
        \"id\" : \"ST123\",
        \"description\" : \"Description\"
    }";

    #[test]
    fn test_service_test_new_name() {
        let test = ServiceTest::new(TEST_NAME);

        assert_eq!(test.get_name().as_str(), TEST_NAME);
    }

    #[test]
    fn test_execstate_deserialize() {
        let execstate: ExecutionStateType = serde_json::from_str(EXECSTATE_JSON).unwrap();

        assert_eq!(execstate, ExecutionStateType::Acknowledged);
    }

    #[test]
    fn test_servicetest_deserialize() {
        let servicetest: ServiceTest = serde_json::from_str(SERVICETEST_JSON).unwrap();

        assert_eq!(servicetest.get_id().as_str(), "ST123");
        assert_eq!(servicetest.get_name().as_str(), "ServiceTestName");
        assert_eq!(servicetest.description.is_some(), true);
        assert_eq!(servicetest.description.unwrap().as_str(), "Description");
    }
}