1 /*
2 * Copyright (c) 2023 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 use crate::common::*;
17 use asset_sdk::*;
18
19 #[test]
add_empty_attr()20 fn add_empty_attr() {
21 let mut attrs = AssetMap::new();
22 attrs.insert_attr(Tag::Accessibility, Accessibility::DevicePowerOn);
23 expect_error_eq(ErrCode::InvalidArgument, asset_sdk::Manager::build().unwrap().add(&attrs).unwrap_err());
24 }
25
26 #[test]
add_without_alias()27 fn add_without_alias() {
28 let function_name = function!().as_bytes();
29 let mut attrs = AssetMap::new();
30 attrs.insert_attr(Tag::Accessibility, Accessibility::DevicePowerOn);
31 attrs.insert_attr(Tag::Secret, function_name.to_owned());
32 expect_error_eq(ErrCode::InvalidArgument, asset_sdk::Manager::build().unwrap().add(&attrs).unwrap_err());
33 }
34
35 #[test]
add_alias_with_min_len()36 fn add_alias_with_min_len() {
37 let function_name = function!().as_bytes();
38 let alias = vec![0; MIN_ARRAY_SIZE + 1];
39 let mut attrs = AssetMap::new();
40 attrs.insert_attr(Tag::Alias, alias.clone());
41 attrs.insert_attr(Tag::Secret, function_name.to_owned());
42 attrs.insert_attr(Tag::Accessibility, Accessibility::DevicePowerOn);
43 assert!(asset_sdk::Manager::build().unwrap().add(&attrs).is_ok());
44
45 query_attr_by_alias(&alias).unwrap();
46 remove_by_alias(&alias).unwrap();
47 }
48
49 #[test]
add_alias_with_max_len()50 fn add_alias_with_max_len() {
51 let function_name = function!().as_bytes();
52 let alias = vec![0; MAX_ALIAS_SIZE];
53 let mut attrs = AssetMap::new();
54 attrs.insert_attr(Tag::Alias, alias.clone());
55 attrs.insert_attr(Tag::Secret, function_name.to_owned());
56 attrs.insert_attr(Tag::Accessibility, Accessibility::DevicePowerOn);
57 assert!(asset_sdk::Manager::build().unwrap().add(&attrs).is_ok());
58
59 query_attr_by_alias(&alias).unwrap();
60 remove_by_alias(&alias).unwrap();
61 }
62
63 #[test]
add_invalid_alias()64 fn add_invalid_alias() {
65 let function_name = function!().as_bytes();
66 let mut attrs = AssetMap::new();
67 attrs.insert_attr(Tag::Alias, vec![]);
68 attrs.insert_attr(Tag::Secret, function_name.to_owned());
69 attrs.insert_attr(Tag::Accessibility, Accessibility::DevicePowerOn);
70 expect_error_eq(ErrCode::InvalidArgument, asset_sdk::Manager::build().unwrap().add(&attrs).unwrap_err());
71
72 attrs.insert_attr(Tag::Alias, vec![0; MAX_ALIAS_SIZE + 1]);
73 expect_error_eq(ErrCode::InvalidArgument, asset_sdk::Manager::build().unwrap().add(&attrs).unwrap_err());
74 }
75
76 #[test]
add_alias_with_unmatched_type()77 fn add_alias_with_unmatched_type() {
78 let function_name = function!().as_bytes();
79 let mut attrs = AssetMap::new();
80 attrs.insert_attr(Tag::Secret, function_name.to_owned());
81 attrs.insert_attr(Tag::Alias, 0);
82 attrs.insert_attr(Tag::Accessibility, Accessibility::DevicePowerOn);
83 expect_error_eq(ErrCode::InvalidArgument, asset_sdk::Manager::build().unwrap().add(&attrs).unwrap_err());
84
85 attrs.insert_attr(Tag::Alias, true);
86 expect_error_eq(ErrCode::InvalidArgument, asset_sdk::Manager::build().unwrap().add(&attrs).unwrap_err());
87 }
88
89 #[test]
add_without_secret()90 fn add_without_secret() {
91 let function_name = function!().as_bytes();
92 let mut attrs = AssetMap::new();
93 attrs.insert_attr(Tag::Accessibility, Accessibility::DevicePowerOn);
94 attrs.insert_attr(Tag::Alias, function_name.to_owned());
95 expect_error_eq(ErrCode::InvalidArgument, asset_sdk::Manager::build().unwrap().add(&attrs).unwrap_err());
96 }
97
98 #[test]
add_secret_with_min_len()99 fn add_secret_with_min_len() {
100 let function_name = function!().as_bytes();
101 let mut attrs = AssetMap::new();
102 attrs.insert_attr(Tag::Accessibility, Accessibility::DevicePowerOn);
103 attrs.insert_attr(Tag::Alias, function_name.to_owned());
104 attrs.insert_attr(Tag::Secret, vec![0; MIN_ARRAY_SIZE + 1]);
105 assert!(asset_sdk::Manager::build().unwrap().add(&attrs).is_ok());
106
107 query_attr_by_alias(function_name).unwrap();
108 remove_by_alias(function_name).unwrap();
109 }
110
111 #[test]
add_secret_with_max_len()112 fn add_secret_with_max_len() {
113 let function_name = function!().as_bytes();
114 let mut attrs = AssetMap::new();
115 attrs.insert_attr(Tag::Alias, function_name.to_owned());
116 attrs.insert_attr(Tag::Accessibility, Accessibility::DevicePowerOn);
117 attrs.insert_attr(Tag::Secret, vec![0; MAX_SECRET_SIZE]);
118 assert!(asset_sdk::Manager::build().unwrap().add(&attrs).is_ok());
119
120 remove_by_alias(function_name).unwrap();
121 }
122
123 #[test]
add_invalid_secret()124 fn add_invalid_secret() {
125 let function_name = function!().as_bytes();
126 let mut attrs = AssetMap::new();
127 attrs.insert_attr(Tag::Alias, function_name.to_owned());
128 attrs.insert_attr(Tag::Secret, vec![]);
129 attrs.insert_attr(Tag::Accessibility, Accessibility::DevicePowerOn);
130 expect_error_eq(ErrCode::InvalidArgument, asset_sdk::Manager::build().unwrap().add(&attrs).unwrap_err());
131
132 attrs.insert_attr(Tag::Secret, vec![0; MAX_SECRET_SIZE + 1]);
133 expect_error_eq(ErrCode::InvalidArgument, asset_sdk::Manager::build().unwrap().add(&attrs).unwrap_err());
134 }
135
136 #[test]
add_secret_with_unmatched_type()137 fn add_secret_with_unmatched_type() {
138 let function_name = function!().as_bytes();
139 let mut attrs = AssetMap::new();
140 attrs.insert_attr(Tag::Alias, function_name.to_owned());
141 attrs.insert_attr(Tag::Secret, 0);
142 attrs.insert_attr(Tag::Accessibility, Accessibility::DevicePowerOn);
143 expect_error_eq(ErrCode::InvalidArgument, asset_sdk::Manager::build().unwrap().add(&attrs).unwrap_err());
144
145 attrs.insert_attr(Tag::Secret, true);
146 expect_error_eq(ErrCode::InvalidArgument, asset_sdk::Manager::build().unwrap().add(&attrs).unwrap_err());
147 }
148
149 #[test]
add_invalid_accessibility()150 fn add_invalid_accessibility() {
151 let function_name = function!().as_bytes();
152 let mut attrs = AssetMap::new();
153 attrs.insert_attr(Tag::Alias, function_name.to_owned());
154 attrs.insert_attr(Tag::Secret, function_name.to_owned());
155 attrs.insert_attr(Tag::Accessibility, (Accessibility::DeviceUnlocked as u32) + 1);
156 expect_error_eq(ErrCode::InvalidArgument, asset_sdk::Manager::build().unwrap().add(&attrs).unwrap_err());
157
158 attrs.insert_attr(Tag::Accessibility, Accessibility::DeviceUnlocked);
159 expect_error_eq(ErrCode::InvalidArgument, asset_sdk::Manager::build().unwrap().add(&attrs).unwrap_err());
160
161 attrs.insert_attr(Tag::Accessibility, Accessibility::DeviceFirstUnlocked);
162 expect_error_eq(ErrCode::InvalidArgument, asset_sdk::Manager::build().unwrap().add(&attrs).unwrap_err());
163 }
164
165 #[test]
add_invalid_auth_type()166 fn add_invalid_auth_type() {
167 let function_name = function!().as_bytes();
168 let mut attrs = AssetMap::new();
169 attrs.insert_attr(Tag::Alias, function_name.to_owned());
170 attrs.insert_attr(Tag::Secret, function_name.to_owned());
171 attrs.insert_attr(Tag::Accessibility, Accessibility::DevicePowerOn);
172 attrs.insert_attr(Tag::AuthType, (AuthType::None as u32) + 1);
173 expect_error_eq(ErrCode::InvalidArgument, asset_sdk::Manager::build().unwrap().add(&attrs).unwrap_err());
174
175 attrs.insert_attr(Tag::AuthType, (AuthType::Any as u32) + 1);
176 expect_error_eq(ErrCode::InvalidArgument, asset_sdk::Manager::build().unwrap().add(&attrs).unwrap_err());
177 }
178
179 #[test]
add_invalid_sync_type()180 fn add_invalid_sync_type() {
181 let function_name = function!().as_bytes();
182 let mut attrs = AssetMap::new();
183 attrs.insert_attr(Tag::Alias, function_name.to_owned());
184 attrs.insert_attr(Tag::Secret, function_name.to_owned());
185 attrs.insert_attr(Tag::Accessibility, Accessibility::DevicePowerOn);
186 let sync_type = SyncType::ThisDevice as u32 | SyncType::TrustedDevice as u32 | SyncType::TrustedAccount as u32;
187 attrs.insert_attr(Tag::SyncType, sync_type + 1);
188 expect_error_eq(ErrCode::InvalidArgument, asset_sdk::Manager::build().unwrap().add(&attrs).unwrap_err());
189 }
190
191 #[test]
add_sync_type_with_max_len()192 fn add_sync_type_with_max_len() {
193 let function_name = function!().as_bytes();
194 let mut attrs = AssetMap::new();
195 attrs.insert_attr(Tag::Alias, function_name.to_owned());
196 attrs.insert_attr(Tag::Secret, function_name.to_owned());
197 attrs.insert_attr(Tag::Accessibility, Accessibility::DevicePowerOn);
198 let sync_type = SyncType::ThisDevice as u32 | SyncType::TrustedDevice as u32 | SyncType::TrustedAccount as u32;
199 attrs.insert_attr(Tag::SyncType, sync_type);
200 assert!(asset_sdk::Manager::build().unwrap().add(&attrs).is_ok());
201
202 remove_by_alias(function_name).unwrap();
203 }
204
205 #[test]
add_invalid_conflict_resolution()206 fn add_invalid_conflict_resolution() {
207 let function_name = function!().as_bytes();
208 let mut attrs = AssetMap::new();
209 attrs.insert_attr(Tag::Alias, function_name.to_owned());
210 attrs.insert_attr(Tag::Secret, function_name.to_owned());
211 attrs.insert_attr(Tag::Accessibility, Accessibility::DevicePowerOn);
212 attrs.insert_attr(Tag::ConflictResolution, (ConflictResolution::ThrowError as u32) + 1);
213 expect_error_eq(ErrCode::InvalidArgument, asset_sdk::Manager::build().unwrap().add(&attrs).unwrap_err());
214 }
215
216 #[test]
add_invalid_label()217 fn add_invalid_label() {
218 let function_name = function!().as_bytes();
219 let labels = &[CRITICAL_LABEL_ATTRS, NORMAL_LABEL_ATTRS].concat();
220 for &label in labels {
221 let mut attrs = AssetMap::new();
222 attrs.insert_attr(Tag::Alias, function_name.to_owned());
223 attrs.insert_attr(Tag::Accessibility, Accessibility::DevicePowerOn);
224 attrs.insert_attr(Tag::Secret, function_name.to_owned());
225 attrs.insert_attr(label, vec![]);
226 expect_error_eq(ErrCode::InvalidArgument, asset_sdk::Manager::build().unwrap().add(&attrs).unwrap_err());
227
228 attrs.insert_attr(label, vec![0; MAX_LABEL_SIZE + 1]);
229 expect_error_eq(ErrCode::InvalidArgument, asset_sdk::Manager::build().unwrap().add(&attrs).unwrap_err());
230 }
231 }
232
233 #[test]
add_bool_tag_with_unmatched_type()234 fn add_bool_tag_with_unmatched_type() {
235 let tags = [Tag::RequirePasswordSet, Tag::IsPersistent];
236 let function_name = function!().as_bytes();
237 for tag in tags {
238 let mut attrs = AssetMap::new();
239 attrs.insert_attr(Tag::Alias, function_name.to_owned());
240 attrs.insert_attr(Tag::Secret, function_name.to_owned());
241 attrs.insert_attr(Tag::Accessibility, Accessibility::DevicePowerOn);
242 attrs.insert_attr(tag, vec![]);
243 expect_error_eq(ErrCode::InvalidArgument, asset_sdk::Manager::build().unwrap().add(&attrs).unwrap_err());
244
245 attrs.insert_attr(tag, 0);
246 expect_error_eq(ErrCode::InvalidArgument, asset_sdk::Manager::build().unwrap().add(&attrs).unwrap_err());
247 }
248 }
249
250 #[test]
add_bytes_tag_with_unmatched_type()251 fn add_bytes_tag_with_unmatched_type() {
252 let function_name = function!().as_bytes();
253 let labels = &[CRITICAL_LABEL_ATTRS, NORMAL_LABEL_ATTRS].concat();
254 for &label in labels {
255 let mut attrs = AssetMap::new();
256 attrs.insert_attr(Tag::Alias, function_name.to_owned());
257 attrs.insert_attr(Tag::Secret, function_name.to_owned());
258 attrs.insert_attr(label, 0);
259 attrs.insert_attr(Tag::Accessibility, Accessibility::DevicePowerOn);
260 expect_error_eq(ErrCode::InvalidArgument, asset_sdk::Manager::build().unwrap().add(&attrs).unwrap_err());
261
262 attrs.insert_attr(label, true);
263 expect_error_eq(ErrCode::InvalidArgument, asset_sdk::Manager::build().unwrap().add(&attrs).unwrap_err());
264 }
265 }
266
267 #[test]
add_number_tag_with_unmatched_type()268 fn add_number_tag_with_unmatched_type() {
269 let tags_num = [Tag::Accessibility, Tag::AuthType, Tag::SyncType, Tag::ConflictResolution];
270 for tag in tags_num {
271 let mut attrs = AssetMap::new();
272 attrs.insert_attr(tag, vec![]);
273 attrs.insert_attr(Tag::Accessibility, Accessibility::DevicePowerOn);
274 expect_error_eq(ErrCode::InvalidArgument, asset_sdk::Manager::build().unwrap().add(&attrs).unwrap_err());
275
276 attrs.insert_attr(tag, true);
277 expect_error_eq(ErrCode::InvalidArgument, asset_sdk::Manager::build().unwrap().add(&attrs).unwrap_err());
278 }
279 }
280
281 #[test]
add_unsupported_tags()282 fn add_unsupported_tags() {
283 let function_name = function!().as_bytes();
284 let tags_bytes = [Tag::AuthChallenge, Tag::AuthToken];
285 for tag in tags_bytes {
286 let mut attrs = AssetMap::new();
287 attrs.insert_attr(Tag::Alias, function_name.to_owned());
288 attrs.insert_attr(Tag::Secret, function_name.to_owned());
289 attrs.insert_attr(Tag::Accessibility, Accessibility::DevicePowerOn);
290 attrs.insert_attr(tag, vec![0; MIN_ARRAY_SIZE + 1]);
291 expect_error_eq(ErrCode::InvalidArgument, asset_sdk::Manager::build().unwrap().add(&attrs).unwrap_err());
292 }
293
294 let tags_num =
295 [Tag::AuthValidityPeriod, Tag::ReturnLimit, Tag::ReturnOffset, Tag::ReturnOrderedBy, Tag::ReturnType];
296 for tag in tags_num {
297 let mut attrs = AssetMap::new();
298 attrs.insert_attr(Tag::Alias, function_name.to_owned());
299 attrs.insert_attr(Tag::Secret, function_name.to_owned());
300 attrs.insert_attr(tag, 1);
301 attrs.insert_attr(Tag::Accessibility, Accessibility::DevicePowerOn);
302 expect_error_eq(ErrCode::InvalidArgument, asset_sdk::Manager::build().unwrap().add(&attrs).unwrap_err());
303 }
304 }
305