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 std::collections::HashMap;
17 
18 use crate::common::*;
19 use asset_sdk::*;
20 
21 #[test]
query_non_exist_with_alias()22 fn query_non_exist_with_alias() {
23     let alias = function!().as_bytes();
24     expect_error_eq(ErrCode::NotFound, query_attr_by_alias(alias).unwrap_err());
25     expect_error_eq(ErrCode::NotFound, query_all_by_alias(alias).unwrap_err());
26 }
27 
28 #[test]
query_with_wrong_alias()29 fn query_with_wrong_alias() {
30     let function_name = function!().as_bytes();
31     add_default_asset(function_name, function_name).unwrap();
32 
33     let alias_new = "query_with_wrong_alias_wrong_alias".as_bytes();
34     expect_error_eq(ErrCode::NotFound, query_attr_by_alias(alias_new).unwrap_err());
35     expect_error_eq(ErrCode::NotFound, query_all_by_alias(alias_new).unwrap_err());
36     remove_by_alias(function_name).unwrap();
37 }
38 
39 #[test]
query_non_exist_without_alias()40 fn query_non_exist_without_alias() {
41     let mut query = AssetMap::new();
42     query.insert_attr(Tag::RequirePasswordSet, true);
43     expect_error_eq(ErrCode::NotFound, asset_sdk::Manager::build().unwrap().query(&query).unwrap_err());
44 }
45 
46 #[test]
query_without_alias_with_wrong_condition()47 fn query_without_alias_with_wrong_condition() {
48     let function_name = function!().as_bytes();
49     let mut add = AssetMap::new();
50     add.insert_attr(Tag::RequirePasswordSet, false);
51     add.insert_attr(Tag::Alias, function_name.to_owned());
52     add.insert_attr(Tag::Secret, function_name.to_owned());
53     add.insert_attr(Tag::Accessibility, Accessibility::DevicePowerOn);
54     asset_sdk::Manager::build().unwrap().add(&add).unwrap();
55 
56     let mut query = AssetMap::new();
57     query.insert_attr(Tag::RequirePasswordSet, true);
58     expect_error_eq(ErrCode::NotFound, asset_sdk::Manager::build().unwrap().query(&query).unwrap_err());
59 
60     remove_by_alias(function_name).unwrap();
61 }
62 
63 #[test]
query_without_limit()64 fn query_without_limit() {
65     let _ = remove_all();
66     let function_name = function!().as_bytes();
67     let asset_num = 10;
68     for i in 0..asset_num {
69         let new_name = format!("{:?}{}", function_name, i);
70         add_default_asset(new_name.as_bytes(), new_name.as_bytes()).unwrap();
71     }
72 
73     let query = AssetMap::new();
74 
75     assert_eq!(asset_num, asset_sdk::Manager::build().unwrap().query(&query).unwrap().len() as u32);
76 
77     for i in 0..asset_num {
78         let new_name = format!("{:?}{}", function_name, i);
79         remove_by_alias(new_name.as_bytes()).unwrap();
80     }
81 }
82 
83 #[test]
query_with_offset_without_limit()84 fn query_with_offset_without_limit() {
85     let _ = remove_all();
86     let function_name = function!().as_bytes();
87     let asset_num = 10;
88     for i in 0..asset_num {
89         let new_name = format!("{:?}{}", function_name, i);
90         add_default_asset(new_name.as_bytes(), new_name.as_bytes()).unwrap();
91     }
92 
93     let offset = 15;
94     let query = AssetMap::from([(Tag::ReturnOffset, Value::Number(offset))]);
95     expect_error_eq(ErrCode::NotFound, asset_sdk::Manager::build().unwrap().query(&query).unwrap_err());
96 
97     let offset = 3;
98     let query = AssetMap::from([(Tag::ReturnOffset, Value::Number(offset))]);
99     assert_eq!(asset_num - offset, asset_sdk::Manager::build().unwrap().query(&query).unwrap().len() as u32);
100 
101     for i in 0..(asset_num - offset) {
102         let new_name = format!("{:?}{}", function_name, i + offset);
103         remove_by_alias(new_name.as_bytes()).unwrap();
104     }
105 }
106 
107 #[test]
query_with_limit_with_without_offset()108 fn query_with_limit_with_without_offset() {
109     let _ = remove_all();
110     let function_name = function!().as_bytes();
111     let asset_num = 10;
112     for i in 0..asset_num {
113         let new_name = format!("{:?}{}", function_name, i);
114         add_default_asset(new_name.as_bytes(), new_name.as_bytes()).unwrap();
115     }
116 
117     let mut query = AssetMap::new();
118     let limit = 15u32;
119     query.insert_attr(Tag::ReturnLimit, limit);
120     let assets = asset_sdk::Manager::build().unwrap().query(&query).unwrap();
121     assert_eq!(asset_num, assets.len() as u32);
122 
123     let limit = 3u32;
124     query.insert_attr(Tag::ReturnLimit, limit);
125     let assets = asset_sdk::Manager::build().unwrap().query(&query).unwrap();
126     assert_eq!(limit, assets.len() as u32);
127     for (i, asset) in assets.iter().enumerate() {
128         assert!(asset.get_bytes_attr(&Tag::Alias).unwrap().eq(format!("{:?}{}", function_name, i).as_bytes()));
129     }
130 
131     let offset = 2u32;
132     query.insert_attr(Tag::ReturnOffset, offset);
133     let assets = asset_sdk::Manager::build().unwrap().query(&query).unwrap();
134     assert_eq!(limit, assets.len() as u32);
135     for (i, asset) in assets.iter().enumerate() {
136         assert!(asset
137             .get_bytes_attr(&Tag::Alias)
138             .unwrap()
139             .eq(format!("{:?}{}", function_name, i + offset as usize).as_bytes()));
140     }
141 
142     for i in 0..asset_num {
143         let new_name = format!("{:?}{}", function_name, i);
144         remove_by_alias(new_name.as_bytes()).unwrap();
145     }
146 }
147 
148 #[test]
query_with_without_return_type()149 fn query_with_without_return_type() {
150     let function_name = function!().as_bytes();
151     add_default_asset(function_name, function_name).unwrap();
152 
153     assert!(!query_attr_by_alias(function_name).unwrap()[0].contains_key(&Tag::Secret));
154     assert!(query_all_by_alias(function_name).unwrap()[0].contains_key(&Tag::Secret));
155 
156     remove_by_alias(function_name).unwrap();
157 }
158 
159 #[test]
query_with_secret()160 fn query_with_secret() {
161     let function_name = function!().as_bytes();
162     add_default_asset(function_name, function_name).unwrap();
163 
164     let query = AssetMap::from([(Tag::Secret, Value::Bytes(function_name.to_vec()))]);
165     expect_error_eq(ErrCode::InvalidArgument, asset_sdk::Manager::build().unwrap().query(&query).unwrap_err());
166 
167     remove_by_alias(function_name).unwrap();
168 }
169 
170 #[test]
query_with_return_all_without_alias()171 fn query_with_return_all_without_alias() {
172     let function_name = function!().as_bytes();
173     add_default_asset(function_name, function_name).unwrap();
174 
175     let query = AssetMap::from([(Tag::ReturnType, Value::Number(ReturnType::All as u32))]);
176     expect_error_eq(ErrCode::Unsupported, asset_sdk::Manager::build().unwrap().query(&query).unwrap_err());
177 
178     remove_by_alias(function_name).unwrap();
179 }
180 
query_with_order(order: &[u8], suffix: &[&[u8]])181 fn query_with_order(order: &[u8], suffix: &[&[u8]]) {
182     let _ = remove_all();
183     let function_name = function!();
184     let asset_num = 4;
185     let mut add = AssetMap::new();
186     add.insert_attr(Tag::Secret, function_name.as_bytes().to_vec());
187     for item in suffix.iter().take(asset_num) {
188         let mut alias_new: Vec<u8> = Vec::new();
189         alias_new.extend_from_slice(function_name.as_bytes());
190         alias_new.extend_from_slice(item);
191         let mut order_new: Vec<u8> = Vec::new();
192         order_new.extend_from_slice(order);
193         order_new.extend_from_slice(item);
194         add_default_asset(&alias_new, function_name.as_bytes()).unwrap();
195     }
196 
197     let mut query = AssetMap::new();
198     let limit = 3u32;
199     query.insert_attr(Tag::ReturnLimit, limit);
200     query.insert_attr(Tag::ReturnOrderedBy, Tag::DataLabelNormal1 as u32);
201     let assets = asset_sdk::Manager::build().unwrap().query(&query).unwrap();
202     assert_eq!(limit, assets.len() as u32);
203 
204     for (i, asset) in assets.iter().enumerate() {
205         let get_alias = asset.get_bytes_attr(&Tag::Alias).unwrap();
206 
207         let mut alias_new: Vec<u8> = Vec::new();
208         alias_new.extend_from_slice(function_name.as_bytes());
209         alias_new.extend_from_slice(suffix[i]);
210         assert_eq!(&alias_new, get_alias);
211     }
212 
213     for item in suffix.iter().take(asset_num) {
214         let mut alias_new: Vec<u8> = Vec::new();
215         alias_new.extend_from_slice(function_name.as_bytes());
216         alias_new.extend_from_slice(item);
217 
218         remove_by_alias(&alias_new).unwrap();
219     }
220 }
221 
222 #[test]
query_with_order_with_english()223 fn query_with_order_with_english() {
224     let order = "query_with_order_with_english".as_bytes();
225     let mut suffix: Vec<&[u8]> = ["one", "two", "three", "four"].iter().map(|s| s.as_bytes()).collect();
226     suffix.sort_by(|a, b| b.cmp(a));
227     query_with_order(order, &suffix);
228 }
229 
230 #[test]
query_with_order_with_chinese()231 fn query_with_order_with_chinese() {
232     let order = "排序".as_bytes();
233     let mut suffix: Vec<&[u8]> = ["一", "二", "三", "四"].iter().map(|s| s.as_bytes()).collect();
234     suffix.sort_by(|a, b| b.cmp(a));
235     query_with_order(order, &suffix);
236 }
237 
238 #[test]
query_with_order_with_number()239 fn query_with_order_with_number() {
240     let order = "123".as_bytes();
241     let mut suffix: Vec<&[u8]> = ["11", "22", "33", "44"].iter().map(|s| s.as_bytes()).collect();
242     suffix.sort_by(|a, b| b.cmp(a));
243     query_with_order(order, &suffix);
244 }
245 
246 #[test]
query_with_order_with_unreadible()247 fn query_with_order_with_unreadible() {
248     let order = [11u8, 22u8, 33u8];
249     let suffix: Vec<[u8; 4]> = [11u32, 22u32, 33u32, 44u32].iter().map(|s| s.to_le_bytes()).collect();
250 
251     let mut suffix: Vec<&[u8]> = suffix.iter().map(|s| s as &[u8]).collect();
252     suffix.sort_by(|a, b| b.cmp(a));
253     query_with_order(&order, &suffix);
254 }
255 
256 #[test]
query_with_wrong_auth_token()257 fn query_with_wrong_auth_token() {
258     let function_name = function!().as_bytes();
259     add_default_auth_asset(function_name, function_name).unwrap();
260 
261     let mut query = AssetMap::new();
262     let challenge = asset_sdk::Manager::build().unwrap().pre_query(&query).unwrap();
263     query.insert_attr(Tag::Alias, function_name.to_owned());
264     query.insert_attr(Tag::AuthType, AuthType::Any);
265     query.insert_attr(Tag::ReturnType, ReturnType::All);
266     query.insert_attr(Tag::AuthToken, vec![0; AUTH_TOKEN_SIZE]);
267     query.insert_attr(Tag::AuthChallenge, challenge.clone());
268     expect_error_eq(ErrCode::AccessDenied, asset_sdk::Manager::build().unwrap().query(&query).unwrap_err());
269 
270     let mut query = AssetMap::new();
271     query.insert_attr(Tag::AuthChallenge, challenge);
272     asset_sdk::Manager::build().unwrap().post_query(&query).unwrap();
273     remove_by_alias(function_name).unwrap();
274 }
275 
276 #[test]
query_with_bytes_tag()277 fn query_with_bytes_tag() {
278     let function_name = function!().as_bytes();
279     add_all_tags_asset(function_name).unwrap();
280     let alias = "default_alias".as_bytes();
281     add_default_asset(alias, alias).unwrap();
282 
283     let mut bytes_tags: HashMap<Tag, &[u8]> = HashMap::new();
284     bytes_tags.insert(Tag::Alias, function_name);
285     bytes_tags.insert(Tag::DataLabelCritical1, CRITICAL_LABEL1);
286     bytes_tags.insert(Tag::DataLabelCritical2, CRITICAL_LABEL2);
287     bytes_tags.insert(Tag::DataLabelCritical3, CRITICAL_LABEL3);
288     bytes_tags.insert(Tag::DataLabelCritical4, CRITICAL_LABEL4);
289     bytes_tags.insert(Tag::DataLabelNormal1, NORMAL_LABEL1);
290     bytes_tags.insert(Tag::DataLabelNormal2, NORMAL_LABEL2);
291     bytes_tags.insert(Tag::DataLabelNormal3, NORMAL_LABEL3);
292     bytes_tags.insert(Tag::DataLabelNormal4, NORMAL_LABEL4);
293     bytes_tags.insert(Tag::DataLabelNormalLocal1, NORMAL_LOCAL_LABEL1);
294     bytes_tags.insert(Tag::DataLabelNormalLocal2, NORMAL_LOCAL_LABEL2);
295     bytes_tags.insert(Tag::DataLabelNormalLocal3, NORMAL_LOCAL_LABEL3);
296     bytes_tags.insert(Tag::DataLabelNormalLocal4, NORMAL_LOCAL_LABEL4);
297 
298     for (tag, val) in bytes_tags.into_iter() {
299         let mut query = AssetMap::new();
300         query.insert_attr(tag, val.to_vec());
301         let assets = asset_sdk::Manager::build().unwrap().query(&query).unwrap();
302         assert_eq!(1, assets.len() as u32);
303     }
304     remove_by_alias(function_name).unwrap();
305     remove_by_alias(alias).unwrap();
306 }
307 
308 #[test]
query_with_accessibility()309 fn query_with_accessibility() {
310     let function_name = function!().as_bytes();
311     add_all_tags_asset(function_name).unwrap();
312 
313     let mut query = AssetMap::new();
314     query.insert_attr(Tag::Accessibility, Accessibility::DevicePowerOn);
315     let assets = asset_sdk::Manager::build().unwrap().query(&query).unwrap();
316     assert_eq!(1, assets.len() as u32);
317 
318     query.insert_attr(Tag::Accessibility, Accessibility::DeviceUnlocked);
319     expect_error_eq(ErrCode::NotFound, asset_sdk::Manager::build().unwrap().query(&query).unwrap_err());
320 
321     query.insert_attr(Tag::Accessibility, Accessibility::DeviceFirstUnlocked);
322     expect_error_eq(ErrCode::NotFound, asset_sdk::Manager::build().unwrap().query(&query).unwrap_err());
323     remove_by_alias(function_name).unwrap();
324 }
325 
326 #[test]
query_with_return_order_by()327 fn query_with_return_order_by() {
328     let alias = "return_order_by_alias".as_bytes();
329     let mut attrs = AssetMap::new();
330     let normal_label = "return_order_by_label1".as_bytes();
331     attrs.insert_attr(Tag::Alias, alias.to_vec());
332     attrs.insert_attr(Tag::Secret, alias.to_vec());
333     attrs.insert_attr(Tag::DataLabelNormal1, normal_label.to_vec());
334     attrs.insert_attr(Tag::Accessibility, Accessibility::DevicePowerOn as u32);
335     asset_sdk::Manager::build().unwrap().add(&attrs).unwrap();
336 
337     let function_name = function!().as_bytes();
338     add_all_tags_asset(function_name).unwrap();
339 
340     let mut query = AssetMap::new();
341     query.insert_attr(Tag::ReturnOrderedBy, Tag::DataLabelNormal1 as u32);
342     let mut assets = asset_sdk::Manager::build().unwrap().query(&query).unwrap();
343     let expect_query_len = 2;
344     assert_eq!(expect_query_len, assets.len() as u32);
345     assert!(assets[0].get_bytes_attr(&Tag::DataLabelNormal1).unwrap().eq(NORMAL_LABEL1));
346 
347     query.remove(&Tag::ReturnOrderedBy);
348     assets = asset_sdk::Manager::build().unwrap().query(&query).unwrap();
349     assert_eq!(expect_query_len, assets.len() as u32);
350     assert!(!assets[0].get_bytes_attr(&Tag::DataLabelNormal1).unwrap().eq(NORMAL_LABEL1));
351 
352     remove_by_alias(function_name).unwrap();
353     remove_by_alias(alias).unwrap();
354 }
355 
356 #[test]
query_with_return_limit()357 fn query_with_return_limit() {
358     let function_name = function!().as_bytes();
359     add_all_tags_asset(function_name).unwrap();
360     let alias = "default_return_limit".as_bytes();
361     add_default_asset(alias, alias).unwrap();
362 
363     let mut query = AssetMap::new();
364     query.insert_attr(Tag::ReturnLimit, 1);
365     let mut assets = asset_sdk::Manager::build().unwrap().query(&query).unwrap();
366     assert_eq!(1, assets.len() as u32);
367 
368     query.insert_attr(Tag::ReturnLimit, 0);
369     expect_error_eq(ErrCode::InvalidArgument, asset_sdk::Manager::build().unwrap().query(&query).unwrap_err());
370 
371     query.remove(&Tag::ReturnLimit);
372     assets = asset_sdk::Manager::build().unwrap().query(&query).unwrap();
373     let expect_query_len = 2;
374     assert_eq!(expect_query_len, assets.len() as u32);
375     remove_by_alias(function_name).unwrap();
376     remove_by_alias(alias).unwrap();
377 }
378 
379 #[test]
query_with_return_offset()380 fn query_with_return_offset() {
381     let function_name = function!().as_bytes();
382     add_all_tags_asset(function_name).unwrap();
383     let alias = "default_return_offset".as_bytes();
384     add_default_asset(alias, alias).unwrap();
385 
386     let mut query = AssetMap::new();
387     query.insert_attr(Tag::ReturnOffset, 1);
388     let mut assets = asset_sdk::Manager::build().unwrap().query(&query).unwrap();
389     assert_eq!(1, assets.len() as u32);
390 
391     query.remove(&Tag::ReturnOffset);
392     assets = asset_sdk::Manager::build().unwrap().query(&query).unwrap();
393     let expect_query_len = 2;
394     assert_eq!(expect_query_len, assets.len() as u32);
395 
396     let offset_start = 2;
397     query.insert_attr(Tag::ReturnOffset, offset_start);
398     expect_error_eq(ErrCode::NotFound, asset_sdk::Manager::build().unwrap().query(&query).unwrap_err());
399     remove_by_alias(function_name).unwrap();
400     remove_by_alias(alias).unwrap();
401 }
402 
403 #[test]
query_with_return_type()404 fn query_with_return_type() {
405     let function_name = function!().as_bytes();
406     add_all_tags_asset(function_name).unwrap();
407 
408     let mut query = AssetMap::new();
409     query.insert_attr(Tag::ReturnType, ReturnType::Attributes as u32);
410     let assets = asset_sdk::Manager::build().unwrap().query(&query).unwrap();
411     assert_eq!(1, assets.len() as u32);
412 
413     query.insert_attr(Tag::ReturnType, ReturnType::All as u32);
414     expect_error_eq(ErrCode::Unsupported, asset_sdk::Manager::build().unwrap().query(&query).unwrap_err());
415     remove_by_alias(function_name).unwrap();
416 }
417 
418 #[test]
query_with_auth_type()419 fn query_with_auth_type() {
420     let function_name = function!().as_bytes();
421     add_all_tags_asset(function_name).unwrap();
422     let alias = "default_number_alias".as_bytes();
423     add_default_asset(alias, alias).unwrap();
424 
425     for auth_type in vec![AuthType::Any as u32, AuthType::None as u32].into_iter() {
426         let mut query = AssetMap::new();
427         query.insert_attr(Tag::AuthType, auth_type);
428         let assets = asset_sdk::Manager::build().unwrap().query(&query).unwrap();
429         assert_eq!(1, assets.len() as u32);
430     }
431     remove_by_alias(function_name).unwrap();
432     remove_by_alias(alias).unwrap();
433 }
434 
435 #[test]
query_with_sync_type()436 fn query_with_sync_type() {
437     let function_name = function!().as_bytes();
438     add_all_tags_asset(function_name).unwrap();
439 
440     let mut query = AssetMap::new();
441     let mut sync_type = SyncType::ThisDevice as u32 | SyncType::TrustedDevice as u32 | SyncType::TrustedAccount as u32;
442     query.insert_attr(Tag::SyncType, sync_type);
443     expect_error_eq(ErrCode::NotFound, asset_sdk::Manager::build().unwrap().query(&query).unwrap_err());
444 
445     sync_type = SyncType::ThisDevice as u32;
446     query.insert_attr(Tag::SyncType, sync_type);
447     let assets = asset_sdk::Manager::build().unwrap().query(&query).unwrap();
448     assert_eq!(1, assets.len() as u32);
449 
450     remove_by_alias(function_name).unwrap();
451 }
452