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
16use std::collections::HashMap;
17
18use crate::common::*;
19use asset_sdk::*;
20
21#[test]
22fn 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]
29fn 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]
40fn 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]
47fn 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]
64fn 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]
84fn 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]
108fn 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]
149fn 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]
160fn 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]
171fn 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
181fn 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]
223fn 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]
231fn 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]
239fn 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]
247fn 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]
257fn 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]
277fn 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]
309fn 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]
327fn 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]
357fn 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]
380fn 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]
404fn 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]
419fn 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]
436fn 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