1 /*
2 * Copyright (c) 2024-2025 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 "el5_filekey_manager_service_unittest.h"
17
18 #include "accesstoken_kit.h"
19 #include "el5_filekey_callback_interface_stub.h"
20 #include "el5_filekey_manager_error.h"
21 #include "token_setproc.h"
22
23 using namespace testing::ext;
24 using namespace OHOS::Security::AccessToken;
25 namespace {
26 constexpr uint32_t SCREEN_ON_DELAY_TIME = 30;
27 constexpr int32_t COMMON_EVENT_SERVICE_ID = 3299;
28 constexpr int32_t TIME_SERVICE_ID = 3702;
29 constexpr int32_t SCREENLOCK_SERVICE_ID = 3704;
30 } // namespace
31
SetUpTestCase()32 void El5FilekeyManagerServiceTest::SetUpTestCase()
33 {
34 }
35
TearDownTestCase()36 void El5FilekeyManagerServiceTest::TearDownTestCase()
37 {
38 sleep(SCREEN_ON_DELAY_TIME);
39 }
40
SetUp()41 void El5FilekeyManagerServiceTest::SetUp()
42 {
43 el5FilekeyManagerService_ = DelayedSingleton<El5FilekeyManagerService>::GetInstance();
44 el5FilekeyManagerService_->Init();
45 el5FilekeyManagerService_->OnAddSystemAbility(COMMON_EVENT_SERVICE_ID, "");
46 el5FilekeyManagerService_->OnAddSystemAbility(TIME_SERVICE_ID, "");
47 el5FilekeyManagerService_->OnAddSystemAbility(SCREENLOCK_SERVICE_ID, "");
48 }
49
TearDown()50 void El5FilekeyManagerServiceTest::TearDown()
51 {
52 }
53
54 class TestEl5FilekeyCallback : public El5FilekeyCallbackInterfaceStub {
55 public:
OnRegenerateAppKey(std::vector<AppKeyInfo> & infos)56 OHOS::ErrCode OnRegenerateAppKey(std::vector<AppKeyInfo> &infos)
57 {
58 GTEST_LOG_(INFO) << "OnRegenerateAppKey.";
59 return OHOS::ERR_OK;
60 }
61 };
62
63 /**
64 * @tc.name: AcquireAccess001
65 * @tc.desc: Acquire media type data access without permission.
66 * @tc.type: FUNC
67 * @tc.require: issueI9JGMV
68 */
69 HWTEST_F(El5FilekeyManagerServiceTest, AcquireAccess001, TestSize.Level1)
70 {
71 ASSERT_EQ(el5FilekeyManagerService_->AcquireAccess(DataLockType::MEDIA_DATA), EFM_ERR_NO_PERMISSION);
72 }
73
74 /**
75 * @tc.name: AcquireAccess002
76 * @tc.desc: Acquire all type data access without permission.
77 * @tc.type: FUNC
78 * @tc.require: issueI9JGMV
79 */
80 HWTEST_F(El5FilekeyManagerServiceTest, AcquireAccess002, TestSize.Level1)
81 {
82 ASSERT_EQ(el5FilekeyManagerService_->AcquireAccess(DataLockType::ALL_DATA), EFM_ERR_NO_PERMISSION);
83 }
84
85 /**
86 * @tc.name: AcquireAccess003
87 * @tc.desc: Acquire invalid type data access.
88 * @tc.type: FUNC
89 * @tc.require: issueIAD2MD
90 */
91 HWTEST_F(El5FilekeyManagerServiceTest, AcquireAccess003, TestSize.Level1)
92 {
93 uint32_t type = 3;
94 ASSERT_EQ(el5FilekeyManagerService_->AcquireAccess(static_cast<DataLockType>(type)), EFM_ERR_NO_PERMISSION);
95 }
96
97 /**
98 * @tc.name: ReleaseAccess001
99 * @tc.desc: Release media type data access without permission.
100 * @tc.type: FUNC
101 * @tc.require: issueI9JGMV
102 */
103 HWTEST_F(El5FilekeyManagerServiceTest, ReleaseAccess001, TestSize.Level1)
104 {
105 ASSERT_EQ(el5FilekeyManagerService_->ReleaseAccess(DataLockType::MEDIA_DATA), EFM_ERR_NO_PERMISSION);
106 }
107
108 /**
109 * @tc.name: ReleaseAccess002
110 * @tc.desc: Release all type data access without permission.
111 * @tc.type: FUNC
112 * @tc.require: issueI9JGMV
113 */
114 HWTEST_F(El5FilekeyManagerServiceTest, ReleaseAccess002, TestSize.Level1)
115 {
116 ASSERT_EQ(el5FilekeyManagerService_->ReleaseAccess(DataLockType::ALL_DATA), EFM_ERR_NO_PERMISSION);
117 }
118
119 /**
120 * @tc.name: GenerateAppKey001
121 * @tc.desc: Generate app key by uid and bundle name without permission.
122 * @tc.type: FUNC
123 * @tc.require: issueI9JGMV
124 */
125 HWTEST_F(El5FilekeyManagerServiceTest, GenerateAppKey001, TestSize.Level1)
126 {
127 int32_t uid = 12345;
128 std::string bundleName = "com.ohos.el5_test";
129 std::string keyId;
130 ASSERT_EQ(el5FilekeyManagerService_->GenerateAppKey(uid, bundleName, keyId), EFM_ERR_NO_PERMISSION);
131 }
132
133 /**
134 * @tc.name: DeleteAppKey001
135 * @tc.desc: Delete app key by bundle name and user id without permission.
136 * @tc.type: FUNC
137 * @tc.require: issueI9JGMV
138 */
139 HWTEST_F(El5FilekeyManagerServiceTest, DeleteAppKey001, TestSize.Level1)
140 {
141 std::string bundleName = "";
142 int32_t userId = 100;
143 ASSERT_EQ(el5FilekeyManagerService_->DeleteAppKey(bundleName, userId), EFM_ERR_NO_PERMISSION);
144 }
145
146 /**
147 * @tc.name: GetUserAppKey001
148 * @tc.desc: Find key infos of the specified user id without permission.
149 * @tc.type: FUNC
150 * @tc.require: issueI9JGMV
151 */
152 HWTEST_F(El5FilekeyManagerServiceTest, GetUserAppKey001, TestSize.Level1)
153 {
154 int32_t userId = 100;
155 std::vector<UserAppKeyInfo> keyInfos;
156 ASSERT_EQ(el5FilekeyManagerService_->GetUserAppKey(userId, false, keyInfos), EFM_ERR_NO_PERMISSION);
157 }
158
159 /**
160 * @tc.name: GetUserAppKey002
161 * @tc.desc: Find key infos of the specified user id without permission, userId < 0.
162 * @tc.type: FUNC
163 * @tc.require: issueI9JGMV
164 */
165 HWTEST_F(El5FilekeyManagerServiceTest, GetUserAppKey002, TestSize.Level1)
166 {
167 int32_t userId = -100;
168 std::vector<UserAppKeyInfo> keyInfos;
169 ASSERT_EQ(el5FilekeyManagerService_->GetUserAppKey(userId, false, keyInfos), EFM_ERR_INVALID_PARAMETER);
170 }
171
172 /**
173 * @tc.name: ChangeUserAppkeysLoadInfo001
174 * @tc.desc: Change key infos of the specified user id without permission.
175 * @tc.type: FUNC
176 * @tc.require: issueI9JGMV
177 */
178 HWTEST_F(El5FilekeyManagerServiceTest, ChangeUserAppkeysLoadInfo001, TestSize.Level1)
179 {
180 int32_t userId = 100;
181 std::vector<AppKeyLoadInfo> loadInfos;
182 std::string emptyStr("");
183 loadInfos.emplace_back(AppKeyLoadInfo(emptyStr, true));
184 ASSERT_EQ(el5FilekeyManagerService_->ChangeUserAppkeysLoadInfo(userId, loadInfos), EFM_ERR_NO_PERMISSION);
185 }
186
187 /**
188 * @tc.name: ChangeUserAppkeysLoadInfo002
189 * @tc.desc: Change key infos of the specified user id without permission, userId < 0.
190 * @tc.type: FUNC
191 * @tc.require: issueI9JGMV
192 */
193 HWTEST_F(El5FilekeyManagerServiceTest, ChangeUserAppkeysLoadInfo002, TestSize.Level1)
194 {
195 int32_t userId = -100;
196 std::vector<AppKeyLoadInfo> loadInfos;
197 std::string emptyStr("");
198 loadInfos.emplace_back(AppKeyLoadInfo(emptyStr, true));
199 ASSERT_EQ(el5FilekeyManagerService_->ChangeUserAppkeysLoadInfo(userId, loadInfos), EFM_ERR_INVALID_PARAMETER);
200 }
201
202 /**
203 * @tc.name: SetFilePathPolicy001
204 * @tc.desc: Set path policy without permission.
205 * @tc.type: FUNC
206 * @tc.require: issueI9Q6K2
207 */
208 HWTEST_F(El5FilekeyManagerServiceTest, SetFilePathPolicy001, TestSize.Level1)
209 {
210 ASSERT_EQ(el5FilekeyManagerService_->SetFilePathPolicy(), EFM_ERR_NO_PERMISSION);
211 }
212
213 /**
214 * @tc.name: RegisterCallback001
215 * @tc.desc: Register app key generation callback without permission.
216 * @tc.type: FUNC
217 * @tc.require: issueI9Q6K2
218 */
219 HWTEST_F(El5FilekeyManagerServiceTest, RegisterCallback001, TestSize.Level1)
220 {
221 ASSERT_EQ(el5FilekeyManagerService_->RegisterCallback((new TestEl5FilekeyCallback())), EFM_ERR_NO_PERMISSION);
222 }
223
224 /**
225 * @tc.name: GenerateGroupIDKey001
226 * @tc.desc: Generate data group key by userId and group id without permission.
227 * @tc.type: FUNC
228 * @tc.require: issueI9JGMV
229 */
230 HWTEST_F(El5FilekeyManagerServiceTest, GenerateGroupIDKey001, TestSize.Level1)
231 {
232 uint32_t uid = 100;
233 std::string groupID = "abcdefghijklmn";
234 std::string keyId;
235 ASSERT_EQ(el5FilekeyManagerService_->GenerateGroupIDKey(uid, groupID, keyId), EFM_ERR_NO_PERMISSION);
236 }
237
238 /**
239 * @tc.name: DeleteGroupIDKey001
240 * @tc.desc: Delete data group key by user id and group id without permission.
241 * @tc.type: FUNC
242 * @tc.require: issueI9JGMV
243 */
244 HWTEST_F(El5FilekeyManagerServiceTest, DeleteGroupIDKey001, TestSize.Level1)
245 {
246 uint32_t uid = 100;
247 std::string groupID = "";
248 ASSERT_EQ(el5FilekeyManagerService_->DeleteGroupIDKey(uid, groupID), EFM_ERR_NO_PERMISSION);
249 }
250
251 /**
252 * @tc.name: QueryAppKeyState001
253 * @tc.desc: Query media type app key without permission.
254 * @tc.type: FUNC
255 * @tc.require: issueI9JGMV
256 */
257 HWTEST_F(El5FilekeyManagerServiceTest, QueryAppKeyState001, TestSize.Level1)
258 {
259 ASSERT_EQ(el5FilekeyManagerService_->QueryAppKeyState(DataLockType::MEDIA_DATA), EFM_ERR_NO_PERMISSION);
260 }
261
262 /**
263 * @tc.name: QueryAppKeyState002
264 * @tc.desc: Query all type app key without permission.
265 * @tc.type: FUNC
266 * @tc.require: issueI9JGMV
267 */
268 HWTEST_F(El5FilekeyManagerServiceTest, QueryAppKeyState002, TestSize.Level1)
269 {
270 ASSERT_EQ(el5FilekeyManagerService_->QueryAppKeyState(DataLockType::ALL_DATA), EFM_ERR_NO_PERMISSION);
271 }
272
273 /**
274 * @tc.name: QueryAppKeyState003
275 * @tc.desc: Query invalid type app key.
276 * @tc.type: FUNC
277 * @tc.require: issueIAD2MD
278 */
279 HWTEST_F(El5FilekeyManagerServiceTest, QueryAppKeyState003, TestSize.Level1)
280 {
281 uint32_t type = 3;
282 ASSERT_EQ(el5FilekeyManagerService_->QueryAppKeyState(static_cast<DataLockType>(type)), EFM_ERR_NO_PERMISSION);
283 }
284
285 /**
286 * @tc.name: SetPolicyScreenLocked001
287 * @tc.desc: SetPolicyScreenLocked
288 * @tc.type: FUNC
289 * @tc.require: issueI9Q6K2
290 */
291 HWTEST_F(El5FilekeyManagerServiceTest, SetPolicyScreenLocked001, TestSize.Level1)
292 {
293 ASSERT_EQ(el5FilekeyManagerService_->SetPolicyScreenLocked(), EFM_SUCCESS);
294 }
295
296 /**
297 * @tc.name: Dump001
298 * @tc.desc: Dump fd > 0
299 * @tc.type: FUNC
300 * @tc.require: issueI9Q6K2
301 */
302 HWTEST_F(El5FilekeyManagerServiceTest, Dump001, TestSize.Level1)
303 {
304 int fd = 1;
305 std::vector<std::u16string> args = {};
306 ASSERT_EQ(el5FilekeyManagerService_->Dump(fd, args), EFM_SUCCESS);
307 }
308
309 /**
310 * @tc.name: Dump002
311 * @tc.desc: Dump fd < 0
312 * @tc.type: FUNC
313 * @tc.require: issueI9Q6K2
314 */
315 HWTEST_F(El5FilekeyManagerServiceTest, Dump002, TestSize.Level1)
316 {
317 int fd = -1;
318 std::vector<std::u16string> args = {};
319 ASSERT_EQ(el5FilekeyManagerService_->Dump(fd, args), EFM_ERR_INVALID_PARAMETER);
320 }
321
322 /**
323 * @tc.name: Dump003
324 * @tc.desc: Dump args != null
325 * @tc.type: FUNC
326 * @tc.require: issueI9Q6K2
327 */
328 HWTEST_F(El5FilekeyManagerServiceTest, Dump003, TestSize.Level1)
329 {
330 int fd = 1;
331 std::vector<std::u16string> args = {u"-h"};
332 ASSERT_EQ(el5FilekeyManagerService_->Dump(fd, args), EFM_SUCCESS);
333 }
334
335 /**
336 * @tc.name: IsSystemApp001
337 * @tc.desc: IsSystemApp fun test.
338 * @tc.type: FUNC
339 * @tc.require: issueI9Q6K2
340 */
341 HWTEST_F(El5FilekeyManagerServiceTest, IsSystemApp001, TestSize.Level1)
342 {
343 ASSERT_EQ(el5FilekeyManagerService_->IsSystemApp(), false);
344 }
345