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]
update_query_without_alias()20 fn update_query_without_alias() {
21 let function_name = function!().as_bytes();
22 let mut update = AssetMap::new();
23 update.insert_attr(Tag::Secret, function_name.to_owned());
24
25 let query = AssetMap::new();
26 expect_error_eq(
27 ErrCode::InvalidArgument,
28 asset_sdk::Manager::build().unwrap().update(&query, &update).unwrap_err(),
29 );
30 }
31
32 #[test]
update_query_invalid_alias()33 fn update_query_invalid_alias() {
34 let function_name = function!().as_bytes();
35 let mut update = AssetMap::new();
36 update.insert_attr(Tag::Secret, function_name.to_owned());
37
38 let mut query = AssetMap::new();
39 query.insert_attr(Tag::Alias, vec![]);
40 expect_error_eq(
41 ErrCode::InvalidArgument,
42 asset_sdk::Manager::build().unwrap().update(&query, &update).unwrap_err(),
43 );
44
45 query.insert_attr(Tag::Alias, vec![0; MAX_ALIAS_SIZE + 1]);
46 expect_error_eq(
47 ErrCode::InvalidArgument,
48 asset_sdk::Manager::build().unwrap().update(&query, &update).unwrap_err(),
49 );
50 }
51
52 #[test]
update_query_alias_with_unmatched_type()53 fn update_query_alias_with_unmatched_type() {
54 let function_name = function!().as_bytes();
55 let mut update = AssetMap::new();
56 update.insert_attr(Tag::Secret, function_name.to_owned());
57
58 let mut query = AssetMap::new();
59 query.insert_attr(Tag::Alias, 0);
60 expect_error_eq(
61 ErrCode::InvalidArgument,
62 asset_sdk::Manager::build().unwrap().update(&query, &update).unwrap_err(),
63 );
64
65 query.insert_attr(Tag::Alias, true);
66 expect_error_eq(
67 ErrCode::InvalidArgument,
68 asset_sdk::Manager::build().unwrap().update(&query, &update).unwrap_err(),
69 );
70 }
71
72 #[test]
update_query_invalid_accessibility()73 fn update_query_invalid_accessibility() {
74 let function_name = function!().as_bytes();
75 let mut update = AssetMap::new();
76 update.insert_attr(Tag::Secret, function_name.to_owned());
77 let mut query = AssetMap::new();
78 query.insert_attr(Tag::Alias, function_name.to_owned());
79
80 query.insert_attr(Tag::Accessibility, (Accessibility::DeviceUnlocked as u32) + 1);
81 expect_error_eq(
82 ErrCode::InvalidArgument,
83 asset_sdk::Manager::build().unwrap().update(&query, &update).unwrap_err(),
84 );
85 }
86
87 #[test]
update_query_invalid_auth_type()88 fn update_query_invalid_auth_type() {
89 let function_name = function!().as_bytes();
90 let mut update = AssetMap::new();
91 update.insert_attr(Tag::Secret, function_name.to_owned());
92 let mut query = AssetMap::new();
93 query.insert_attr(Tag::Alias, function_name.to_owned());
94 query.insert_attr(Tag::AuthType, (AuthType::None as u32) + 1);
95 expect_error_eq(
96 ErrCode::InvalidArgument,
97 asset_sdk::Manager::build().unwrap().update(&query, &update).unwrap_err(),
98 );
99
100 query.insert_attr(Tag::AuthType, (AuthType::Any as u32) + 1);
101 expect_error_eq(
102 ErrCode::InvalidArgument,
103 asset_sdk::Manager::build().unwrap().update(&query, &update).unwrap_err(),
104 );
105 }
106
107 #[test]
update_query_invalid_sync_type()108 fn update_query_invalid_sync_type() {
109 let function_name = function!().as_bytes();
110 let mut update = AssetMap::new();
111 update.insert_attr(Tag::Secret, function_name.to_owned());
112 let mut query = AssetMap::new();
113 query.insert_attr(Tag::Alias, function_name.to_owned());
114 let sync_type = SyncType::ThisDevice as u32 | SyncType::TrustedDevice as u32 | SyncType::TrustedAccount as u32;
115 query.insert_attr(Tag::SyncType, sync_type + 1);
116 expect_error_eq(
117 ErrCode::InvalidArgument,
118 asset_sdk::Manager::build().unwrap().update(&query, &update).unwrap_err(),
119 );
120 }
121
122 #[test]
update_query_invalid_label()123 fn update_query_invalid_label() {
124 let function_name = function!().as_bytes();
125 let mut update = AssetMap::new();
126 update.insert_attr(Tag::Secret, function_name.to_owned());
127 let labels = &[CRITICAL_LABEL_ATTRS, NORMAL_LABEL_ATTRS].concat();
128 for &label in labels {
129 let mut query = AssetMap::new();
130 query.insert_attr(Tag::Alias, function_name.to_owned());
131 query.insert_attr(label, vec![]);
132 expect_error_eq(
133 ErrCode::InvalidArgument,
134 asset_sdk::Manager::build().unwrap().update(&query, &update).unwrap_err(),
135 );
136
137 query.insert_attr(label, vec![0; MAX_LABEL_SIZE + 1]);
138 expect_error_eq(
139 ErrCode::InvalidArgument,
140 asset_sdk::Manager::build().unwrap().update(&query, &update).unwrap_err(),
141 );
142 }
143 }
144
145 #[test]
update_query_bool_tag_with_unmatched_type()146 fn update_query_bool_tag_with_unmatched_type() {
147 let tags = [Tag::RequirePasswordSet, Tag::IsPersistent];
148 let function_name = function!().as_bytes();
149 let mut update = AssetMap::new();
150 update.insert_attr(Tag::Secret, function_name.to_owned());
151
152 for tag in tags {
153 let mut query = AssetMap::new();
154 query.insert_attr(Tag::Alias, function_name.to_owned());
155 query.insert_attr(tag, vec![]);
156 expect_error_eq(
157 ErrCode::InvalidArgument,
158 asset_sdk::Manager::build().unwrap().update(&query, &update).unwrap_err(),
159 );
160
161 query.insert_attr(tag, 0);
162 expect_error_eq(
163 ErrCode::InvalidArgument,
164 asset_sdk::Manager::build().unwrap().update(&query, &update).unwrap_err(),
165 );
166 }
167 }
168
169 #[test]
update_query_bytes_tag_with_unmatched_type()170 fn update_query_bytes_tag_with_unmatched_type() {
171 let function_name = function!().as_bytes();
172 let mut update = AssetMap::new();
173 update.insert_attr(Tag::Secret, function_name.to_owned());
174
175 let tags_bytes = [CRITICAL_LABEL_ATTRS, NORMAL_LABEL_ATTRS].concat();
176 for tag in tags_bytes {
177 let mut query = AssetMap::new();
178 query.insert_attr(Tag::Alias, function_name.to_owned());
179 query.insert_attr(tag, 0);
180 expect_error_eq(
181 ErrCode::InvalidArgument,
182 asset_sdk::Manager::build().unwrap().update(&query, &update).unwrap_err(),
183 );
184
185 query.insert_attr(tag, true);
186 expect_error_eq(
187 ErrCode::InvalidArgument,
188 asset_sdk::Manager::build().unwrap().update(&query, &update).unwrap_err(),
189 );
190 }
191 }
192
193 #[test]
update_query_number_tag_with_unmatched_type()194 fn update_query_number_tag_with_unmatched_type() {
195 let function_name = function!().as_bytes();
196 let mut update = AssetMap::new();
197 update.insert_attr(Tag::Secret, function_name.to_owned());
198 let tags_num = [Tag::Accessibility, Tag::AuthType, Tag::SyncType];
199 for tag in tags_num {
200 let mut query = AssetMap::new();
201 query.insert_attr(Tag::Alias, function_name.to_owned());
202 query.insert_attr(tag, vec![]);
203 expect_error_eq(
204 ErrCode::InvalidArgument,
205 asset_sdk::Manager::build().unwrap().update(&query, &update).unwrap_err(),
206 );
207
208 query.insert_attr(tag, true);
209 expect_error_eq(
210 ErrCode::InvalidArgument,
211 asset_sdk::Manager::build().unwrap().update(&query, &update).unwrap_err(),
212 );
213 }
214 }
215
216 #[test]
update_query_unsupported_tags()217 fn update_query_unsupported_tags() {
218 let function_name = function!().as_bytes();
219 let mut update = AssetMap::new();
220 update.insert_attr(Tag::Secret, function_name.to_owned());
221 let tags_bytes = [Tag::Secret, Tag::AuthChallenge, Tag::AuthToken];
222 for tag in tags_bytes {
223 let mut query = AssetMap::new();
224 query.insert_attr(Tag::Alias, function_name.to_owned());
225 query.insert_attr(tag, vec![0; MIN_ARRAY_SIZE + 1]);
226 expect_error_eq(
227 ErrCode::InvalidArgument,
228 asset_sdk::Manager::build().unwrap().update(&query, &update).unwrap_err(),
229 );
230 }
231
232 let tags_num = [
233 Tag::AuthValidityPeriod,
234 Tag::ConflictResolution,
235 Tag::ReturnLimit,
236 Tag::ReturnOffset,
237 Tag::ReturnOrderedBy,
238 Tag::ReturnType,
239 ];
240 for tag in tags_num {
241 let mut query = AssetMap::new();
242 query.insert_attr(Tag::Alias, function_name.to_owned());
243 query.insert_attr(tag, 1);
244 expect_error_eq(
245 ErrCode::InvalidArgument,
246 asset_sdk::Manager::build().unwrap().update(&query, &update).unwrap_err(),
247 );
248 }
249 }
250
251 #[test]
update_empty_attrs()252 fn update_empty_attrs() {
253 let function_name = function!().as_bytes();
254 let mut query = AssetMap::new();
255 query.insert_attr(Tag::Alias, function_name.to_owned());
256
257 let update = AssetMap::new();
258 expect_error_eq(
259 ErrCode::InvalidArgument,
260 asset_sdk::Manager::build().unwrap().update(&query, &update).unwrap_err(),
261 );
262 }
263
264 #[test]
update_invalid_secret()265 fn update_invalid_secret() {
266 let function_name = function!().as_bytes();
267 let mut query = AssetMap::new();
268 query.insert_attr(Tag::Alias, function_name.to_owned());
269
270 let mut update = AssetMap::new();
271 update.insert_attr(Tag::Secret, vec![]);
272 expect_error_eq(
273 ErrCode::InvalidArgument,
274 asset_sdk::Manager::build().unwrap().update(&query, &update).unwrap_err(),
275 );
276
277 update.insert_attr(Tag::Secret, vec![0; MAX_SECRET_SIZE + 1]);
278 expect_error_eq(
279 ErrCode::InvalidArgument,
280 asset_sdk::Manager::build().unwrap().update(&query, &update).unwrap_err(),
281 );
282 }
283
284 #[test]
update_invalid_label()285 fn update_invalid_label() {
286 let function_name = function!().as_bytes();
287 let mut query = AssetMap::new();
288 query.insert_attr(Tag::Alias, function_name.to_owned());
289
290 let labels = NORMAL_LABEL_ATTRS.to_vec();
291 for label in labels {
292 let mut update = AssetMap::new();
293 update.insert_attr(Tag::Secret, function_name.to_owned());
294 update.insert_attr(label, vec![]);
295 expect_error_eq(
296 ErrCode::InvalidArgument,
297 asset_sdk::Manager::build().unwrap().update(&query, &update).unwrap_err(),
298 );
299
300 update.insert_attr(label, vec![0; MAX_LABEL_SIZE + 1]);
301 expect_error_eq(
302 ErrCode::InvalidArgument,
303 asset_sdk::Manager::build().unwrap().update(&query, &update).unwrap_err(),
304 );
305 }
306 }
307
308 #[test]
update_bytes_tag_with_unmatched_type()309 fn update_bytes_tag_with_unmatched_type() {
310 let function_name = function!().as_bytes();
311 let mut query = AssetMap::new();
312 query.insert_attr(Tag::Alias, function_name.to_owned());
313
314 let mut tags_bytes = NORMAL_LABEL_ATTRS.to_vec();
315 tags_bytes.extend(&[Tag::Secret]);
316 for tag in tags_bytes {
317 let mut update = AssetMap::new();
318 update.insert_attr(Tag::Secret, function_name.to_owned());
319 update.insert_attr(tag, 0);
320 expect_error_eq(
321 ErrCode::InvalidArgument,
322 asset_sdk::Manager::build().unwrap().update(&query, &update).unwrap_err(),
323 );
324
325 update.insert_attr(tag, true);
326 expect_error_eq(
327 ErrCode::InvalidArgument,
328 asset_sdk::Manager::build().unwrap().update(&query, &update).unwrap_err(),
329 );
330 }
331 }
332
333 #[test]
update_unsupported_tags()334 fn update_unsupported_tags() {
335 let function_name = function!().as_bytes();
336 let mut query = AssetMap::new();
337 query.insert_attr(Tag::Alias, function_name.to_owned());
338
339 let mut tags_bytes = CRITICAL_LABEL_ATTRS.to_vec();
340 tags_bytes.extend(&[Tag::Alias, Tag::AuthChallenge, Tag::AuthToken]);
341 for tag in tags_bytes {
342 let mut update = AssetMap::new();
343 update.insert_attr(Tag::Secret, function_name.to_owned());
344 update.insert_attr(tag, vec![0; MIN_ARRAY_SIZE + 1]);
345 expect_error_eq(
346 ErrCode::InvalidArgument,
347 asset_sdk::Manager::build().unwrap().update(&query, &update).unwrap_err(),
348 );
349 }
350
351 let tags_num = [
352 Tag::Accessibility,
353 Tag::AuthType,
354 Tag::SyncType,
355 Tag::IsPersistent,
356 Tag::RequirePasswordSet,
357 Tag::AuthValidityPeriod,
358 Tag::ConflictResolution,
359 Tag::ReturnLimit,
360 Tag::ReturnOffset,
361 Tag::ReturnOrderedBy,
362 Tag::ReturnType,
363 ];
364 for tag in tags_num {
365 let mut update = AssetMap::new();
366 update.insert_attr(Tag::Secret, function_name.to_owned());
367 update.insert_attr(tag, 1);
368 expect_error_eq(
369 ErrCode::InvalidArgument,
370 asset_sdk::Manager::build().unwrap().update(&query, &update).unwrap_err(),
371 );
372 }
373 }
374