1use super::BuildTargetIdentifier;
2use serde::{Deserialize, Serialize};
3use serde_json::Value;
4
5#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
9#[serde(rename_all = "camelCase")]
10pub struct BuildTargetTest {
11 target: BuildTargetIdentifier,
13
14 #[serde(skip_serializing_if = "Option::is_none")]
17 origin_id: Option<String>,
18
19 #[serde(skip_serializing_if = "Option::is_none")]
21 arguments: Option<String>,
22
23 #[serde(skip_serializing_if = "Option::is_none")]
25 data_kind: Option<String>,
26
27 #[serde(skip_serializing_if = "Option::is_none")]
30 data: Option<Value>,
31}
32
33impl BuildTargetTest {
34 pub fn new(
35 target: BuildTargetIdentifier,
36 origin_id: Option<String>,
37 arguments: Option<String>,
38 data_kind: Option<String>,
39 data: Option<Value>,
40 ) -> Self {
41 Self {
42 target,
43 origin_id,
44 arguments,
45 data_kind,
46 data,
47 }
48 }
49 pub fn new_simple(target: BuildTargetIdentifier) -> Self {
50 Self {
51 target,
52 origin_id: None,
53 arguments: None,
54 data_kind: None,
55 data: None,
56 }
57 }
58
59 pub fn target(&self) -> &BuildTargetIdentifier {
61 &self.target
62 }
63
64 pub fn set_target(&mut self, target: BuildTargetIdentifier) {
66 self.target = target;
67 }
68
69 pub fn origin_id(&self) -> Option<&String> {
71 self.origin_id.as_ref()
72 }
73
74 pub fn set_origin_id(&mut self, origin_id: Option<String>) {
76 self.origin_id = origin_id;
77 }
78
79 pub fn arguments(&self) -> Option<&String> {
81 self.arguments.as_ref()
82 }
83
84 pub fn set_arguments(&mut self, arguments: Option<String>) {
86 self.arguments = arguments;
87 }
88
89 pub fn data_kind(&self) -> Option<&String> {
91 self.data_kind.as_ref()
92 }
93
94 pub fn set_data_kind(&mut self, data_kind: Option<String>) {
96 self.data_kind = data_kind;
97 }
98
99 pub fn data(&self) -> Option<&Value> {
101 self.data.as_ref()
102 }
103
104 pub fn set_data(&mut self, data: Option<Value>) {
106 self.data = data;
107 }
108}
109
110#[derive(Debug, Serialize, Deserialize, PartialEq, Eq)]
112#[serde(rename_all = "camelCase")]
113pub struct BuildTargetTestResult {
114 #[serde(skip_serializing_if = "Option::is_none")]
116 origin_id: Option<String>,
117
118 status_code: usize,
120
121 #[serde(skip_serializing_if = "Option::is_none")]
123 data_kind: Option<String>,
124
125 #[serde(skip_serializing_if = "Option::is_none")]
128 data: Option<Value>,
129}
130
131impl BuildTargetTestResult {
132 pub fn new(
133 origin_id: Option<String>,
134 status_code: usize,
135 data_kind: Option<String>,
136 data: Option<Value>,
137 ) -> Self {
138 Self {
139 origin_id,
140 status_code,
141 data_kind,
142 data,
143 }
144 }
145 pub fn new_simple(status_code: usize) -> Self {
146 Self {
147 origin_id: None,
148 status_code,
149 data_kind: None,
150 data: None,
151 }
152 }
153
154 pub fn origin_id(&self) -> Option<&String> {
156 self.origin_id.as_ref()
157 }
158
159 pub fn status_code(&self) -> usize {
161 self.status_code
162 }
163
164 pub fn set_origin_id(&mut self, origin_id: Option<String>) {
166 self.origin_id = origin_id;
167 }
168
169 pub fn set_status_code(&mut self, status_code: usize) {
171 self.status_code = status_code;
172 }
173
174 pub fn set_data_kind(&mut self, data_kind: Option<String>) {
176 self.data_kind = data_kind;
177 }
178
179 pub fn data_kind(&self) -> Option<&String> {
181 self.data_kind.as_ref()
182 }
183
184 pub fn set_data(&mut self, data: Option<Value>) {
186 self.data = data;
187 }
188
189 pub fn data(&self) -> Option<&Value> {
191 self.data.as_ref()
192 }
193}