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]
query_invalid_alias()20 fn query_invalid_alias() {
21 let mut query = AssetMap::new();
22 query.insert_attr(Tag::Alias, vec![]);
23 expect_error_eq(ErrCode::InvalidArgument, asset_sdk::Manager::build().unwrap().query(&query).unwrap_err());
24
25 query.insert_attr(Tag::Alias, vec![0; MAX_ALIAS_SIZE + 1]);
26 expect_error_eq(ErrCode::InvalidArgument, asset_sdk::Manager::build().unwrap().query(&query).unwrap_err());
27 }
28
29 #[test]
query_invalid_accessibility()30 fn query_invalid_accessibility() {
31 let mut query = AssetMap::new();
32
33 query.insert_attr(Tag::Accessibility, (Accessibility::DeviceUnlocked as u32) + 1);
34 expect_error_eq(ErrCode::InvalidArgument, asset_sdk::Manager::build().unwrap().query(&query).unwrap_err());
35 }
36
37 #[test]
query_invalid_auth_type()38 fn query_invalid_auth_type() {
39 let mut query = AssetMap::new();
40 query.insert_attr(Tag::AuthType, (AuthType::None as u32) + 1);
41 expect_error_eq(ErrCode::InvalidArgument, asset_sdk::Manager::build().unwrap().query(&query).unwrap_err());
42
43 query.insert_attr(Tag::AuthType, (AuthType::Any as u32) + 1);
44 expect_error_eq(ErrCode::InvalidArgument, asset_sdk::Manager::build().unwrap().query(&query).unwrap_err());
45 }
46
47 #[test]
query_invalid_sync_type()48 fn query_invalid_sync_type() {
49 let mut query = AssetMap::new();
50 let sync_type = SyncType::ThisDevice as u32 | SyncType::TrustedDevice as u32;
51 query.insert_attr(Tag::SyncType, sync_type + 1);
52 expect_error_eq(ErrCode::InvalidArgument, asset_sdk::Manager::build().unwrap().query(&query).unwrap_err());
53 }
54
55 #[test]
query_invalid_label()56 fn query_invalid_label() {
57 let labels = &[CRITICAL_LABEL_ATTRS, NORMAL_LABEL_ATTRS].concat();
58 for &label in labels {
59 let mut query = AssetMap::new();
60 query.insert_attr(label, vec![]);
61 expect_error_eq(ErrCode::InvalidArgument, asset_sdk::Manager::build().unwrap().query(&query).unwrap_err());
62
63 query.insert_attr(label, vec![0; MAX_LABEL_SIZE + 1]);
64 expect_error_eq(ErrCode::InvalidArgument, asset_sdk::Manager::build().unwrap().query(&query).unwrap_err());
65 }
66 }
67
68 #[test]
query_invalid_return_limit()69 fn query_invalid_return_limit() {
70 let mut query = AssetMap::new();
71 query.insert_attr(Tag::ReturnLimit, MIN_NUMBER_VALUE);
72 expect_error_eq(ErrCode::InvalidArgument, asset_sdk::Manager::build().unwrap().query(&query).unwrap_err());
73
74 query.insert_attr(Tag::ReturnLimit, MAX_RETURN_LIMIT + 1);
75 expect_error_eq(ErrCode::InvalidArgument, asset_sdk::Manager::build().unwrap().query(&query).unwrap_err());
76 }
77
78 #[test]
query_invalid_return_ordered_by()79 fn query_invalid_return_ordered_by() {
80 let tags = [
81 Tag::Secret,
82 Tag::Alias,
83 Tag::Accessibility,
84 Tag::RequirePasswordSet,
85 Tag::AuthType,
86 Tag::SyncType,
87 Tag::IsPersistent,
88 Tag::AuthValidityPeriod,
89 Tag::ReturnType,
90 Tag::ReturnLimit,
91 Tag::ReturnOffset,
92 Tag::ReturnOrderedBy,
93 Tag::ConflictResolution,
94 Tag::AuthChallenge,
95 Tag::AuthToken,
96 ];
97 for tag in tags {
98 let mut query = AssetMap::new();
99 query.insert_attr(Tag::ReturnOrderedBy, tag);
100 expect_error_eq(ErrCode::InvalidArgument, asset_sdk::Manager::build().unwrap().query(&query).unwrap_err());
101 }
102 }
103
104 #[test]
query_invalid_return_type()105 fn query_invalid_return_type() {
106 let mut query = AssetMap::new();
107 query.insert_attr(Tag::ReturnType, ReturnType::Attributes as u32 + 1);
108 expect_error_eq(ErrCode::InvalidArgument, asset_sdk::Manager::build().unwrap().query(&query).unwrap_err());
109 }
110
111 #[test]
query_invalid_auth_challenge()112 fn query_invalid_auth_challenge() {
113 let mut query = AssetMap::new();
114 query.insert_attr(Tag::AuthChallenge, vec![0; CHALLENGE_SIZE - 1]);
115 expect_error_eq(ErrCode::InvalidArgument, asset_sdk::Manager::build().unwrap().query(&query).unwrap_err());
116
117 query.insert_attr(Tag::AuthChallenge, vec![0; CHALLENGE_SIZE + 1]);
118 expect_error_eq(ErrCode::InvalidArgument, asset_sdk::Manager::build().unwrap().query(&query).unwrap_err());
119 }
120
121 #[test]
query_invalid_auth_token()122 fn query_invalid_auth_token() {
123 let mut query = AssetMap::new();
124 query.insert_attr(Tag::AuthToken, vec![0; AUTH_TOKEN_SIZE - 1]);
125 expect_error_eq(ErrCode::InvalidArgument, asset_sdk::Manager::build().unwrap().query(&query).unwrap_err());
126
127 query.insert_attr(Tag::AuthToken, vec![0; AUTH_TOKEN_SIZE + 1]);
128 expect_error_eq(ErrCode::InvalidArgument, asset_sdk::Manager::build().unwrap().query(&query).unwrap_err());
129 }
130
131 #[test]
query_with_auth_token_without_auth_challenge()132 fn query_with_auth_token_without_auth_challenge() {
133 let function_name = function!().as_bytes();
134 add_default_auth_asset(function_name, function_name).unwrap();
135 let mut query = AssetMap::new();
136 query.insert_attr(Tag::Alias, function_name.to_owned());
137 query.insert_attr(Tag::AuthType, AuthType::Any);
138 query.insert_attr(Tag::ReturnType, ReturnType::All);
139 query.insert_attr(Tag::AuthToken, vec![0; AUTH_TOKEN_SIZE]);
140 expect_error_eq(ErrCode::InvalidArgument, asset_sdk::Manager::build().unwrap().query(&query).unwrap_err());
141 remove_by_alias(function_name).unwrap();
142 }
143
144 #[test]
query_with_auth_challenge_without_auth_token()145 fn query_with_auth_challenge_without_auth_token() {
146 let function_name = function!().as_bytes();
147 add_default_auth_asset(function_name, function_name).unwrap();
148 let mut query = AssetMap::new();
149 query.insert_attr(Tag::Alias, function_name.to_owned());
150 query.insert_attr(Tag::AuthType, AuthType::Any);
151 query.insert_attr(Tag::ReturnType, ReturnType::All);
152 query.insert_attr(Tag::AuthChallenge, vec![0; CHALLENGE_SIZE]);
153 expect_error_eq(ErrCode::InvalidArgument, asset_sdk::Manager::build().unwrap().query(&query).unwrap_err());
154 remove_by_alias(function_name).unwrap();
155 }
156
157 #[test]
query_bool_tag_with_unmatched_type()158 fn query_bool_tag_with_unmatched_type() {
159 let tags = [Tag::RequirePasswordSet, Tag::IsPersistent];
160 for tag in tags {
161 let mut query = AssetMap::new();
162 query.insert_attr(tag, vec![]);
163 expect_error_eq(ErrCode::InvalidArgument, asset_sdk::Manager::build().unwrap().query(&query).unwrap_err());
164
165 query.insert_attr(tag, 0);
166 expect_error_eq(ErrCode::InvalidArgument, asset_sdk::Manager::build().unwrap().query(&query).unwrap_err());
167 }
168 }
169
170 #[test]
query_bytes_tag_with_unmatched_type()171 fn query_bytes_tag_with_unmatched_type() {
172 let mut tags_bytes = [CRITICAL_LABEL_ATTRS, NORMAL_LABEL_ATTRS].concat();
173 tags_bytes.extend(&[Tag::AuthToken, Tag::AuthChallenge, Tag::Alias]);
174 for tag in tags_bytes {
175 let mut query = AssetMap::new();
176 query.insert_attr(tag, 0);
177 expect_error_eq(ErrCode::InvalidArgument, asset_sdk::Manager::build().unwrap().query(&query).unwrap_err());
178
179 query.insert_attr(tag, true);
180 expect_error_eq(ErrCode::InvalidArgument, asset_sdk::Manager::build().unwrap().query(&query).unwrap_err());
181 }
182 }
183
184 #[test]
query_number_tag_with_unmatched_type()185 fn query_number_tag_with_unmatched_type() {
186 let tags_num = [
187 Tag::Accessibility,
188 Tag::AuthType,
189 Tag::SyncType,
190 Tag::ReturnLimit,
191 Tag::ReturnOffset,
192 Tag::ReturnOrderedBy,
193 Tag::ReturnType,
194 ];
195 for tag in tags_num {
196 let mut query = AssetMap::new();
197 query.insert_attr(tag, vec![]);
198 expect_error_eq(ErrCode::InvalidArgument, asset_sdk::Manager::build().unwrap().query(&query).unwrap_err());
199
200 query.insert_attr(tag, true);
201 expect_error_eq(ErrCode::InvalidArgument, asset_sdk::Manager::build().unwrap().query(&query).unwrap_err());
202 }
203 }
204
205 #[test]
query_unsupported_tags()206 fn query_unsupported_tags() {
207 let tags_bytes = [Tag::Secret];
208 for tag in tags_bytes {
209 let mut query = AssetMap::new();
210 query.insert_attr(tag, vec![0; MIN_ARRAY_SIZE + 1]);
211 expect_error_eq(ErrCode::InvalidArgument, asset_sdk::Manager::build().unwrap().query(&query).unwrap_err());
212 }
213
214 let tags_num = [Tag::AuthValidityPeriod, Tag::ConflictResolution];
215 for tag in tags_num {
216 let mut query = AssetMap::new();
217 query.insert_attr(tag, 1);
218 expect_error_eq(ErrCode::InvalidArgument, asset_sdk::Manager::build().unwrap().query(&query).unwrap_err());
219 }
220 }
221