apicize_lib 0.41.0

Library supporting Apicize request dispatch, testing and serialization
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
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137

use crate::{
    ApicizeExecution, ApicizeGroupResultRow, ApicizeGroupResultRun, ApicizeRequestResultRow,
    ApicizeRequestResultRun, ApicizeResult,
};
use serde::{Deserialize, Serialize};
use serde_json::{Map, Value};
use std::sync::Arc;

/// Active values for a set of results (grouped requests, runs, rows)
#[derive(Serialize, Deserialize, PartialEq, Clone, Default)]
#[serde(rename_all = "camelCase")]
pub struct DataContext {
    /// Variables available from scenario
    #[serde(skip_serializing_if = "Option::is_none")]
    pub scenario: Option<Arc<Map<String, Value>>>,

    /// Variables output from previous test
    #[serde(skip_serializing_if = "Option::is_none")]
    pub output: Option<Arc<Map<String, Value>>>,

    /// Row data assigned to the groups' requests (if applicable)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub data: Option<Arc<Map<String, Value>>>,

    /// Output variables resulting from operation to be sent to next request/group
    #[serde(skip_serializing_if = "Option::is_none")]
    pub output_result: Option<Arc<Map<String, Value>>>,
}

/// Trait to retrieve data contexts
pub trait GetDataContext {
    fn get_data_context(&self) -> &DataContext;
}

impl GetDataContext for ApicizeResult {
    fn get_data_context(&self) -> &DataContext {
        match self {
            ApicizeResult::Request(request) => &request.data_context,
            ApicizeResult::Group(group) => &group.data_context,
        }
    }
}

/// Trait to generate test contexts for arrays of results
pub trait DataContextGenerator {
    fn generate_data_context(&self) -> DataContext;
}

impl DataContextGenerator for Vec<ApicizeGroupResultRow> {
    fn generate_data_context(&self) -> DataContext {
        if let Some(first) = self.first() {
            let last = self.last().unwrap();
            DataContext {
                scenario: first.data_context.scenario.clone(),
                output: first.data_context.output.clone(),
                data: first.data_context.data.clone(),
                output_result: last.data_context.output_result.clone(),
            }
        } else {
            DataContext::default()
        }
    }
}

impl DataContextGenerator for Vec<ApicizeGroupResultRun> {
    fn generate_data_context(&self) -> DataContext {
        if let Some(first) = self.first() {
            let last = self.last().unwrap();
            DataContext {
                scenario: first.data_context.scenario.clone(),
                output: first.data_context.output.clone(),
                data: first.data_context.data.clone(),
                output_result: last.data_context.output_result.clone(),
            }
        } else {
            DataContext::default()
        }
    }
}

impl DataContextGenerator for Vec<ApicizeRequestResultRow> {
    fn generate_data_context(&self) -> DataContext {
        if let Some(first) = self.first() {
            let last = self.last().unwrap();
            DataContext {
                scenario: first.data_context.scenario.clone(),
                output: first.data_context.output.clone(),
                data: first.data_context.data.clone(),
                output_result: last.data_context.output_result.clone(),
            }
        } else {
            DataContext::default()
        }
    }
}

impl DataContextGenerator for Vec<ApicizeRequestResultRun> {
    fn generate_data_context(&self) -> DataContext {
        if let Some(first) = self.first() {
            let first_execution = &first.execution;
            let last_execution = &self.last().unwrap().execution;
            DataContext {
                scenario: first_execution.test_context.scenario.clone(),
                data: first_execution.test_context.data.clone(),
                output: first_execution.test_context.output.clone(),
                output_result: last_execution.output_variables.clone(),
            }
        } else {
            DataContext::default()
        }
    }
}

impl DataContextGenerator for Vec<ApicizeResult> {
    fn generate_data_context(&self) -> DataContext {
        if let Some(first) = self.first() {
            let first_context = first.get_data_context();
            let last_context = self.last().unwrap().get_data_context();
            let mut data_context = first_context.clone();
            data_context.output_result = last_context.output_result.clone();
            data_context
        } else {
            DataContext::default()
        }
    }
}

impl DataContextGenerator for ApicizeExecution {
    fn generate_data_context(&self) -> DataContext {
        DataContext {
            scenario: self.test_context.scenario.clone(),
            output: self.test_context.output.clone(),
            data: self.test_context.data.clone(),
            output_result: self.output_variables.clone(),
        }
    }
}