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_all_tags()20 fn add_all_tags() {
21     let alias = function!().as_bytes();
22     add_all_tags_asset(alias).unwrap();
23 
24     let res = query_attr_by_alias(alias).unwrap();
25     assert_eq!(1, res.len());
26     assert_eq!(19, res[0].len());
27     assert_eq!(alias, *res[0].get_bytes_attr(&Tag::Alias).unwrap());
28     assert_eq!(NORMAL_LABEL1, *res[0].get_bytes_attr(&Tag::DataLabelNormal1).unwrap());
29     assert_eq!(NORMAL_LABEL2, *res[0].get_bytes_attr(&Tag::DataLabelNormal2).unwrap());
30     assert_eq!(NORMAL_LABEL3, *res[0].get_bytes_attr(&Tag::DataLabelNormal3).unwrap());
31     assert_eq!(NORMAL_LABEL4, *res[0].get_bytes_attr(&Tag::DataLabelNormal4).unwrap());
32     assert_eq!(NORMAL_LOCAL_LABEL1, *res[0].get_bytes_attr(&Tag::DataLabelNormalLocal1).unwrap());
33     assert_eq!(NORMAL_LOCAL_LABEL2, *res[0].get_bytes_attr(&Tag::DataLabelNormalLocal2).unwrap());
34     assert_eq!(NORMAL_LOCAL_LABEL3, *res[0].get_bytes_attr(&Tag::DataLabelNormalLocal3).unwrap());
35     assert_eq!(NORMAL_LOCAL_LABEL4, *res[0].get_bytes_attr(&Tag::DataLabelNormalLocal4).unwrap());
36     assert_eq!(CRITICAL_LABEL1, *res[0].get_bytes_attr(&Tag::DataLabelCritical1).unwrap());
37     assert_eq!(CRITICAL_LABEL2, *res[0].get_bytes_attr(&Tag::DataLabelCritical2).unwrap());
38     assert_eq!(CRITICAL_LABEL3, *res[0].get_bytes_attr(&Tag::DataLabelCritical3).unwrap());
39     assert_eq!(CRITICAL_LABEL4, *res[0].get_bytes_attr(&Tag::DataLabelCritical4).unwrap());
40     assert_eq!(Accessibility::DevicePowerOn, res[0].get_enum_attr::<Accessibility>(&Tag::Accessibility).unwrap());
41     assert_eq!(AuthType::Any, res[0].get_enum_attr::<AuthType>(&Tag::AuthType).unwrap());
42     assert_eq!(SyncType::ThisDevice, res[0].get_enum_attr::<SyncType>(&Tag::SyncType).unwrap());
43     assert!(!res[0].get_bool_attr(&Tag::IsPersistent).unwrap());
44     assert!(!res[0].get_bool_attr(&Tag::RequirePasswordSet).unwrap());
45 
46     remove_by_alias(alias).unwrap();
47 }
48 
49 #[test]
add_required_tags()50 fn add_required_tags() {
51     let func_name = function!().as_bytes();
52     let mut attrs = AssetMap::new();
53     attrs.insert_attr(Tag::Alias, func_name.to_owned());
54     attrs.insert_attr(Tag::Secret, func_name.to_owned());
55     attrs.insert_attr(Tag::Accessibility, Accessibility::DevicePowerOn);
56     asset_sdk::Manager::build().unwrap().add(&attrs).unwrap();
57 
58     let res = query_all_by_alias(func_name).unwrap();
59     assert_eq!(1, res.len());
60     assert_eq!(8, res[0].len());
61     assert_eq!(func_name, *res[0].get_bytes_attr(&Tag::Alias).unwrap());
62     assert_eq!(func_name, *res[0].get_bytes_attr(&Tag::Secret).unwrap());
63     assert_eq!(Accessibility::DevicePowerOn, res[0].get_enum_attr::<Accessibility>(&Tag::Accessibility).unwrap());
64     assert_eq!(AuthType::None, res[0].get_enum_attr::<AuthType>(&Tag::AuthType).unwrap());
65     assert_eq!(SyncType::Never, res[0].get_enum_attr::<SyncType>(&Tag::SyncType).unwrap());
66     assert!(!res[0].get_bool_attr(&Tag::IsPersistent).unwrap());
67     assert!(!res[0].get_bool_attr(&Tag::RequirePasswordSet).unwrap());
68     remove_by_alias(func_name).unwrap();
69 }
70 
71 #[test]
add_english_secret()72 fn add_english_secret() {
73     let func_name = function!();
74     let mut attrs = AssetMap::new();
75     attrs.insert_attr(Tag::Alias, func_name.as_bytes().to_owned());
76     attrs.insert_attr(Tag::Secret, func_name.as_bytes().to_owned());
77     attrs.insert_attr(Tag::Accessibility, Accessibility::DevicePowerOn);
78     asset_sdk::Manager::build().unwrap().add(&attrs).unwrap();
79 
80     let res = query_all_by_alias(func_name.as_bytes()).unwrap();
81     assert_eq!(1, res.len());
82     let bytes = res[0].get_bytes_attr(&Tag::Secret).unwrap();
83     assert_eq!(func_name, String::from_utf8(bytes.to_owned()).unwrap());
84     remove_by_alias(func_name.as_bytes()).unwrap();
85 }
86 
87 #[test]
add_chinese_secret()88 fn add_chinese_secret() {
89     let alias = "Здравствуйте";
90     let secret = "中文";
91     let mut attrs = AssetMap::new();
92     attrs.insert_attr(Tag::Alias, alias.as_bytes().to_owned());
93     attrs.insert_attr(Tag::Secret, secret.as_bytes().to_owned());
94     attrs.insert_attr(Tag::Accessibility, Accessibility::DevicePowerOn);
95     asset_sdk::Manager::build().unwrap().add(&attrs).unwrap();
96 
97     let res = query_all_by_alias(alias.as_bytes()).unwrap();
98     assert_eq!(1, res.len());
99     let bytes = res[0].get_bytes_attr(&Tag::Secret).unwrap();
100     assert_eq!(secret, String::from_utf8(bytes.to_owned()).unwrap());
101     let bytes = res[0].get_bytes_attr(&Tag::Alias).unwrap();
102     assert_eq!(alias, String::from_utf8(bytes.to_owned()).unwrap());
103     remove_by_alias(alias.as_bytes()).unwrap();
104 }
105 
106 #[test]
add_same_alias_throw_error()107 fn add_same_alias_throw_error() {
108     let function_name = function!().as_bytes();
109 
110     // step1. insert data
111     let mut attrs = AssetMap::new();
112     attrs.insert_attr(Tag::Alias, function_name.to_owned());
113     attrs.insert_attr(Tag::Secret, function_name.to_owned());
114     attrs.insert_attr(Tag::Accessibility, Accessibility::DevicePowerOn);
115     asset_sdk::Manager::build().unwrap().add(&attrs).unwrap();
116 
117     // step2. insert data with the same alias, default resolution: throw error
118     expect_error_eq(ErrCode::Duplicated, asset_sdk::Manager::build().unwrap().add(&attrs).unwrap_err());
119 
120     // step3. insert data with the same alias, specified resolution: throw error
121     attrs.insert_attr(Tag::ConflictResolution, ConflictResolution::ThrowError);
122     expect_error_eq(ErrCode::Duplicated, asset_sdk::Manager::build().unwrap().add(&attrs).unwrap_err());
123 
124     remove_by_alias(function_name).unwrap();
125 }
126 
127 #[test]
add_same_alias_overwrite()128 fn add_same_alias_overwrite() {
129     let function_name = function!().as_bytes();
130 
131     // step1. insert data
132     let mut attrs = AssetMap::new();
133     attrs.insert_attr(Tag::Alias, function_name.to_owned());
134     attrs.insert_attr(Tag::Secret, function_name.to_owned());
135     attrs.insert_attr(Tag::Accessibility, Accessibility::DevicePowerOn);
136     asset_sdk::Manager::build().unwrap().add(&attrs).unwrap();
137 
138     // step2. query data with no label
139     let res = query_attr_by_alias(function_name).unwrap();
140     assert_eq!(1, res.len());
141     assert!(res[0].get(&Tag::DataLabelCritical1).is_none());
142 
143     // step3. insert data with the same alias, specified resolution: overwrite
144     let critical_label = "add_same_alias_overwrite".as_bytes();
145     attrs.insert_attr(Tag::DataLabelCritical1, critical_label.to_owned());
146     attrs.insert_attr(Tag::ConflictResolution, ConflictResolution::Overwrite);
147     attrs.insert_attr(Tag::Accessibility, Accessibility::DevicePowerOn);
148     asset_sdk::Manager::build().unwrap().add(&attrs).unwrap();
149 
150     // step4. query new data with critical label
151     let res = query_attr_by_alias(function_name).unwrap();
152     assert_eq!(1, res.len());
153     assert_eq!(critical_label, *res[0].get_bytes_attr(&Tag::DataLabelCritical1).unwrap());
154 
155     remove_by_alias(function_name).unwrap();
156 }
157 
158 #[test]
add_multiple_sync_types()159 fn add_multiple_sync_types() {
160     let function_name = function!().as_bytes();
161     let sync_type = (SyncType::ThisDevice as u32) | (SyncType::TrustedDevice as u32);
162     let mut attrs = AssetMap::new();
163     attrs.insert_attr(Tag::Alias, function_name.to_owned());
164     attrs.insert_attr(Tag::Secret, function_name.to_owned());
165     attrs.insert_attr(Tag::SyncType, sync_type);
166     attrs.insert_attr(Tag::Accessibility, Accessibility::DevicePowerOn);
167     asset_sdk::Manager::build().unwrap().add(&attrs).unwrap();
168 
169     let res = query_attr_by_alias(function_name).unwrap();
170     assert_eq!(1, res.len());
171     assert_eq!(sync_type, res[0].get_num_attr(&Tag::SyncType).unwrap());
172     remove_by_alias(function_name).unwrap();
173 }
174 
175 #[test]
add_is_persistent_auth_wrong()176 fn add_is_persistent_auth_wrong() {
177     let function_name = function!().as_bytes();
178     let mut attrs = AssetMap::new();
179     attrs.insert_attr(Tag::Alias, function_name.to_owned());
180     attrs.insert_attr(Tag::Secret, function_name.to_owned());
181     attrs.insert_attr(Tag::Accessibility, Accessibility::DevicePowerOn);
182     attrs.insert_attr(Tag::IsPersistent, true);
183     expect_error_eq(ErrCode::PermissionDenied, asset_sdk::Manager::build().unwrap().add(&attrs).unwrap_err());
184 
185     attrs.insert_attr(Tag::IsPersistent, false);
186     expect_error_eq(ErrCode::PermissionDenied, asset_sdk::Manager::build().unwrap().add(&attrs).unwrap_err());
187 }
188