1 /*
2 * Copyright (c) 2022 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 #include <cstdio>
17 #include <gtest/gtest.h>
18
19 #include "client/storage_manager_client.h"
20 #include "get_self_permissions.h"
21 #include "storage_service_errno.h"
22 #include "storage_service_log.h"
23 namespace OHOS {
24 namespace StorageManager {
25 using namespace std;
26 using namespace testing::ext;
27
28 class StorageManagerClientTest : public testing::Test {
29 public:
SetUpTestCase(void)30 static void SetUpTestCase(void) {};
TearDownTestCase(void)31 static void TearDownTestCase(void) {};
32 void SetUp();
33 void TearDown();
34
35 StorageManagerClient* storageManagerClient_;
36 };
37
SetUp()38 void StorageManagerClientTest::SetUp()
39 {
40 storageManagerClient_ = new StorageManagerClient();
41 }
42
TearDown(void)43 void StorageManagerClientTest::TearDown(void)
44 {
45 if (storageManagerClient_ != nullptr) {
46 delete storageManagerClient_;
47 storageManagerClient_ = nullptr;
48 }
49 }
50
51 /**
52 * @tc.number: SUB_STORAGE_Client_manager_service_PrepareAddUser_0000
53 * @tc.name: Client_manager_service_PrepareAddUser_0000
54 * @tc.desc: Test function of PrepareAddUser interface for SUCCESS.
55 * @tc.size: MEDIUM
56 * @tc.type: FUNC
57 * @tc.level Level 1
58 * @tc.require: SR000GGUPF
59 */
60 HWTEST_F(StorageManagerClientTest, Client_manager_service_PrepareAddUser_0000, TestSize.Level1)
61 {
62 GTEST_LOG_(INFO) << "StorageManagerClientTest-begin Client_manager_service_PrepareAddUser_0000";
63
64 ASSERT_TRUE(storageManagerClient_ != nullptr);
65
66 uint32_t userId = 121;
67 int32_t flag = CRYPTO_FLAG_EL2;
68 int32_t ret = storageManagerClient_->PrepareAddUser(userId, flag);
69 GTEST_LOG_(INFO) << ret;
70 EXPECT_TRUE(ret == E_OK);
71
72 storageManagerClient_->RemoveUser(userId, flag);
73 GTEST_LOG_(INFO) << "Client_manager_service_PrepareAddUser_0000 end";
74 }
75
76 /**
77 * @tc.number: SUB_STORAGE_Client_manager_service_RemoveUser_0000
78 * @tc.name: Client_manager_service_RemoveUser_0000
79 * @tc.desc: Test function of RemoveUser interface for SUCCESS.
80 * @tc.size: MEDIUM
81 * @tc.type: FUNC
82 * @tc.level Level 1
83 * @tc.require: SR000GGUPF
84 */
85 HWTEST_F(StorageManagerClientTest, Client_manager_service_RemoveUser_0000, TestSize.Level1)
86 {
87 GTEST_LOG_(INFO) << "StorageManagerClientTest-begin Client_manager_service_RemoveUser_0000";
88
89 ASSERT_TRUE(storageManagerClient_ != nullptr);
90
91 uint32_t userId = 102;
92 uint32_t flag = CRYPTO_FLAG_EL2;
93 int32_t ret = storageManagerClient_->PrepareAddUser(userId, flag);
94 EXPECT_TRUE(ret == E_OK);
95
96 ret = storageManagerClient_->RemoveUser(userId, flag);
97 EXPECT_TRUE(ret == E_OK);
98 GTEST_LOG_(INFO) << "Client_manager_service_RemoveUser_0000 end";
99 }
100
101 /**
102 * @tc.number: SUB_STORAGE_Client_manager_service_GenerateUserKeys_0000
103 * @tc.name: Client_manager_service_GenerateUserKeys_0000
104 * @tc.desc: Test function of GenerateUserKeys interface for SUCCESS.
105 * @tc.size: MEDIUM
106 * @tc.type: FUNC
107 * @tc.level Level 1
108 * @tc.require: SR000GGUPF
109 */
110 HWTEST_F(StorageManagerClientTest, Client_manager_service_GenerateUserKeys_0000, TestSize.Level1)
111 {
112 GTEST_LOG_(INFO) << "StorageManagerClientTest-begin Client_manager_service_GenerateUserKeys_0000";
113
114 ASSERT_TRUE(storageManagerClient_ != nullptr);
115
116 uint32_t userId = 103;
117 uint32_t flag = CRYPTO_FLAG_EL2;
118 int32_t ret = storageManagerClient_->GenerateUserKeys(userId, flag);
119 EXPECT_TRUE(ret == E_OK);
120
121 storageManagerClient_->DeleteUserKeys(userId);
122 GTEST_LOG_(INFO) << "Client_manager_service_GenerateUserKeys_0000 end";
123 }
124
125 /**
126 * @tc.number: SUB_STORAGE_Client_manager_service_DeleteUserKeys_0000
127 * @tc.name: Client_manager_service_DeleteUserKeys_0000
128 * @tc.desc: Test function of DeleteUserKeys interface for SUCCESS.
129 * @tc.size: MEDIUM
130 * @tc.type: FUNC
131 * @tc.level Level 1
132 * @tc.require: SR000GGUPF
133 */
134 HWTEST_F(StorageManagerClientTest, Client_manager_service_DeleteUserKeys_0000, TestSize.Level1)
135 {
136 GTEST_LOG_(INFO) << "StorageManagerClientTest-begin Client_manager_service_DeleteUserKeys_0000";
137
138 ASSERT_TRUE(storageManagerClient_ != nullptr);
139
140 uint32_t userId = 104;
141 uint32_t flag = CRYPTO_FLAG_EL2;
142 int32_t ret = storageManagerClient_->GenerateUserKeys(userId, flag);
143 EXPECT_TRUE(ret == E_OK);
144
145 ret = storageManagerClient_->DeleteUserKeys(userId);
146 EXPECT_TRUE(ret == E_OK);
147 GTEST_LOG_(INFO) << "Client_manager_service_DeleteUserKeys_0000 end";
148 }
149
150 /**
151 * @tc.number: SUB_STORAGE_Client_manager_service_UpdateUserAuth_0000
152 * @tc.name: Client_manager_service_UpdateUserAuth_0000
153 * @tc.desc: Test function of UpdateUserAuth interface for SUCCESS.
154 * @tc.size: MEDIUM
155 * @tc.type: FUNC
156 * @tc.level Level 1
157 * @tc.require: SR000GGUPF
158 */
159 HWTEST_F(StorageManagerClientTest, Client_manager_service_UpdateUserAuth_0000, TestSize.Level1)
160 {
161 GTEST_LOG_(INFO) << "StorageManagerClientTest-begin Client_manager_service_UpdateUserAuth_0000";
162
163 ASSERT_TRUE(storageManagerClient_ != nullptr);
164
165 uint32_t userId = 105;
166 uint32_t flag = CRYPTO_FLAG_EL2;
167 int32_t ret = storageManagerClient_->PrepareAddUser(userId, flag);
168 EXPECT_TRUE(ret == E_OK);
169
170 ret = storageManagerClient_->UpdateUserAuth(userId, 0, {}, {}, {});
171 EXPECT_TRUE(ret == E_OK) << "UpdateUserAuth error";
172
173 storageManagerClient_->RemoveUser(userId, flag);
174 GTEST_LOG_(INFO) << "Client_manager_service_UpdateUserAuth_0000 end";
175 }
176
177 /**
178 * @tc.number: SUB_STORAGE_Client_manager_serviceActiveUserKey_0000
179 * @tc.name: Client_manager_service_ActiveUserKey_0000
180 * @tc.desc: Test function of ActiveUserKey interface for SUCCESS.
181 * @tc.size: MEDIUM
182 * @tc.type: FUNC
183 * @tc.level Level 1
184 * @tc.require: SR000GGUPF
185 */
186 HWTEST_F(StorageManagerClientTest, Client_manager_service_ActiveUserKey_0000, TestSize.Level1)
187 {
188 GTEST_LOG_(INFO) << "StorageManagerClientTest-begin Client_manager_service_ActiveUserKey_0000";
189
190 ASSERT_TRUE(storageManagerClient_ != nullptr);
191
192 uint32_t userId = 106;
193 uint32_t flag = CRYPTO_FLAG_EL2;
194 int32_t ret = storageManagerClient_->GenerateUserKeys(userId, flag);
195 EXPECT_TRUE(ret == E_OK);
196
197 ret = storageManagerClient_->ActiveUserKey(userId, {}, {});
198 EXPECT_TRUE(ret == E_OK);
199
200 storageManagerClient_->DeleteUserKeys(userId);
201 GTEST_LOG_(INFO) << "Client_manager_service_ActiveUserKey_0000 end";
202 }
203
204 /**
205 * @tc.number: SUB_STORAGE_Client_manager_InactiveUserKey_0000
206 * @tc.name: Client_manager_service_InactiveUserKey_0000
207 * @tc.desc: Test function of InactiveUserKey interface for SUCCESS.
208 * @tc.size: MEDIUM
209 * @tc.type: FUNC
210 * @tc.level Level 1
211 * @tc.require: SR000GGUPF
212 */
213 HWTEST_F(StorageManagerClientTest, Client_manager_service_InactiveUserKey_0000, TestSize.Level1)
214 {
215 GTEST_LOG_(INFO) << "StorageManagerClientTest-begin Client_manager_service_InactiveUserKey_0000";
216
217 ASSERT_TRUE(storageManagerClient_ != nullptr);
218
219 uint32_t userId = 107;
220 uint32_t flag = CRYPTO_FLAG_EL2;
221 int32_t ret = storageManagerClient_->GenerateUserKeys(userId, flag);
222 EXPECT_TRUE(ret == E_OK);
223
224 ret = storageManagerClient_->ActiveUserKey(userId, {}, {});
225 EXPECT_TRUE(ret == E_OK);
226
227 ret = storageManagerClient_->InactiveUserKey(userId);
228 EXPECT_TRUE(ret == E_OK);
229
230 storageManagerClient_->DeleteUserKeys(userId);
231 GTEST_LOG_(INFO) << "Client_manager_service_InactiveUserKey_0000 end";
232 }
233
234 /**
235 * @tc.number: SUB_STORAGE_Client_manager_UpdateKeyContext_0000
236 * @tc.name: Client_manager_service_UpdateKeyContext_0000
237 * @tc.desc: Test function of UpdateKeyContext interface for SUCCESS.
238 * @tc.size: MEDIUM
239 * @tc.type: FUNC
240 * @tc.level Level 1
241 * @tc.require: SR000GGUPF
242 */
243 HWTEST_F(StorageManagerClientTest, Client_manager_service_UpdateKeyContext_0000, TestSize.Level1)
244 {
245 GTEST_LOG_(INFO) << "StorageManagerClientTest-begin Client_manager_service_UpdateKeyContext_0000";
246
247 ASSERT_TRUE(storageManagerClient_ != nullptr);
248
249 uint32_t userId = 108;
250 uint32_t flag = CRYPTO_FLAG_EL2;
251 storageManagerClient_->DeleteUserKeys(userId);
252 int32_t ret = storageManagerClient_->GenerateUserKeys(userId, flag);
253 EXPECT_TRUE(ret == E_OK);
254
255 ret = storageManagerClient_->UpdateUserAuth(userId, 0, {}, {}, {});
256 EXPECT_TRUE(ret == E_OK) << "UpdateUserAuth error";
257
258 ret = storageManagerClient_->UpdateKeyContext(userId);
259 EXPECT_TRUE(ret == E_OK);
260
261 storageManagerClient_->DeleteUserKeys(userId);
262 GTEST_LOG_(INFO) << "Client_manager_service_UpdateKeyContext_0000 end";
263 }
264
265 /**
266 * @tc.number: SUB_STORAGE_Client_manager_LockUserScreen_0000
267 * @tc.name: Client_manager_service_LockUserScreen_0000
268 * @tc.desc: Test function of LockUserScreen interface for SUCCESS.
269 * @tc.size: MEDIUM
270 * @tc.type: FUNC
271 * @tc.level Level 1
272 * @tc.require: SR000GGUPF
273 */
274 HWTEST_F(StorageManagerClientTest, Client_manager_service_LockUserScreen_0000, TestSize.Level1)
275 {
276 GTEST_LOG_(INFO) << "StorageManagerClientTest-begin Client_manager_service_LockUserScreen_0000";
277
278 ASSERT_TRUE(storageManagerClient_ != nullptr);
279
280 uint32_t userId = 100;
281 int32_t ret = storageManagerClient_->LockUserScreen(userId);
282 EXPECT_TRUE(ret == E_OK);
283
284 GTEST_LOG_(INFO) << "Client_manager_service_LockUserScreen_0000 end";
285 }
286
287 /**
288 * @tc.number: SUB_STORAGE_Client_manager_UnlockUserScreen_0000
289 * @tc.name: Client_manager_service_UnlockUserScreen_0000
290 * @tc.desc: Test function of UnlockUserScreen interface for SUCCESS.
291 * @tc.size: MEDIUM
292 * @tc.type: FUNC
293 * @tc.level Level 1
294 * @tc.require: SR000GGUPF
295 */
296 HWTEST_F(StorageManagerClientTest, Client_manager_service_UnlockUserScreen_0000, TestSize.Level1)
297 {
298 GTEST_LOG_(INFO) << "StorageManagerClientTest-begin Client_manager_service_UnlockUserScreen_0000";
299
300 ASSERT_TRUE(storageManagerClient_ != nullptr);
301
302 uint32_t userId = 104;
303 int32_t ret = storageManagerClient_->UnlockUserScreen(userId, {}, {});
304 EXPECT_TRUE(ret == E_OK);
305
306 GTEST_LOG_(INFO) << "Client_manager_service_UnlockUserScreen_0000 end";
307 }
308
309 /**
310 * @tc.number: SUB_STORAGE_Client_manager_MountDfsDocs_001
311 * @tc.name: Client_manager_service_MountDfsDocs_001
312 * @tc.desc: Test function of MountDfsDocs interface for SUCCESS.
313 * @tc.size: MEDIUM
314 * @tc.type: FUNC
315 * @tc.level Level 1
316 * @tc.require: issueI9G5A0
317 */
318 HWTEST_F(StorageManagerClientTest, Client_manager_service_MountDfsDocs_001, TestSize.Level1)
319 {
320 GTEST_LOG_(INFO) << "StorageManagerClientTest-begin Client_manager_service_MountDfsDocs_001";
321
322 ASSERT_TRUE(storageManagerClient_ != nullptr);
323
324 uint32_t userId = 104;
325 std::string relativePath = "account";
326 std::string networkId = "testnetworkid";
327 std::string deviceId = "testdevid";
328 int32_t ret = storageManagerClient_->MountDfsDocs(userId, relativePath, networkId, deviceId);
329 EXPECT_TRUE(ret == E_OK);
330
331 GTEST_LOG_(INFO) << "Client_manager_service_MountDfsDocs_001 end";
332 }
333
334 /**
335 * @tc.number: SUB_STORAGE_Client_manager_UMountDfsDocs_001
336 * @tc.name: Client_manager_service_UMountDfsDocs_001
337 * @tc.desc: Test function of UMountDfsDocs interface for SUCCESS.
338 * @tc.size: MEDIUM
339 * @tc.type: FUNC
340 * @tc.level Level 1
341 * @tc.require: issueI9G5A0
342 */
343 HWTEST_F(StorageManagerClientTest, Client_manager_service_UMountDfsDocs_001, TestSize.Level1)
344 {
345 GTEST_LOG_(INFO) << "StorageManagerClientTest-begin Client_manager_service_UMountDfsDocs_001";
346
347 ASSERT_TRUE(storageManagerClient_ != nullptr);
348
349 uint32_t userId = 104;
350 std::string relativePath = "account";
351 std::string networkId = "testnetworkid";
352 std::string deviceId = "testdevid";
353 int32_t ret = storageManagerClient_->UMountDfsDocs(userId, relativePath, networkId, deviceId);
354 EXPECT_TRUE(ret == E_OK);
355
356 GTEST_LOG_(INFO) << "Client_manager_service_UMountDfsDocs_001 end";
357 }
358
359 /**
360 * @tc.number: SUB_STORAGE_Client_manager_GetLockScreenStatus_0000
361 * @tc.name: Client_manager_service_GetLockScreenStatus_0000
362 * @tc.desc: Test function of GetLockScreenStatus interface for SUCCESS.
363 * @tc.size: MEDIUM
364 * @tc.type: FUNC
365 * @tc.level Level 1
366 * @tc.require: SR000GGUPF
367 */
368 HWTEST_F(StorageManagerClientTest, Client_manager_service_GetLockScreenStatus_0000, TestSize.Level1)
369 {
370 GTEST_LOG_(INFO) << "StorageManagerClientTest-begin Client_manager_service_GetLockScreenStatus_0000";
371
372 ASSERT_TRUE(storageManagerClient_ != nullptr);
373
374 uint32_t userId = 104;
375 bool lockScreenStatus = false;
376 int32_t ret = storageManagerClient_->GetLockScreenStatus(userId, lockScreenStatus);
377 EXPECT_TRUE(ret == E_OK);
378
379 GTEST_LOG_(INFO) << "Client_manager_service_GetLockScreenStatus_0000 end";
380 }
381 }
382 }
383