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