1 /*
2 * Copyright (c) 2021-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 <gtest/gtest.h>
17
18 #include "accesstoken_kit.h"
19 #include "form_ams_helper.h"
20 #include "form_bms_helper.h"
21 #include "form_data_mgr.h"
22 #include "form_host_interface.h"
23 #define private public
24 #include "form_mgr.h"
25 #undef private
26 #include "form_mgr_errors.h"
27 #include "form_mgr_adapter.h"
28 #include "form_mgr_service.h"
29 #include "if_system_ability_manager.h"
30 #include "ipc_skeleton.h"
31 #include "iservice_registry.h"
32
33 #include "mock_ability_manager.h"
34 #include "mock_bundle_manager.h"
35 #include "mock_form_host_client.h"
36 #include "remote_native_token.h"
37 #include "running_process_info.h"
38 #include "system_ability_definition.h"
39
40 using namespace testing::ext;
41 using namespace OHOS;
42 using namespace OHOS::AppExecFwk;
43 using namespace OHOS::Security;
44 using ::testing::Invoke;
45 using ::testing::_;
46
47 extern void MockGetCallingUid(int32_t mockRet);
48 namespace {
49 const std::string PERMISSION_NAME_REQUIRE_FORM = "ohos.permission.REQUIRE_FORM";
50 const std::string PARAM_PROVIDER_PACKAGE_NAME = "com.form.provider.app.test.ability";
51 const std::string FORM_PROVIDER_BUNDLE_NAME = "com.form.provider.service";
52 const std::string PARAM_PROVIDER_MODULE_NAME = "com.form.provider.app.test.ability";
53 const std::string FORM_PROVIDER_ABILITY_NAME = "com.form.provider.app.test.ability";
54 const std::string PARAM_FORM_NAME = "com.form.name.test";
55 const std::string FORM_JS_COMPONENT_NAME = "jsComponentName";
56 const std::string FORM_PROVIDER_MODULE_SOURCE_DIR = "";
57 const std::string FORM_HOST_BUNDLE_NAME = "com.form.host.app";
58 const std::string DEVICE_ID = "ohos-phone1";
59 const std::string DEF_LABEL1 = "PermissionFormRequireGrant";
60
61 class FmsFormMgrUpdateFormTest : public testing::Test {
62 public:
63 static void SetUpTestCase();
64 static void TearDownTestCase();
65 void SetUp();
66 void TearDown();
67
68 protected:
69 sptr<MockFormHostClient> token_;
70 std::shared_ptr<FormMgrService> formyMgrServ_ = DelayedSingleton<FormMgrService>::GetInstance();
71 static sptr<BundleMgrService> mockBundleMgrService;
72 };
73
SetUpTestCase()74 void FmsFormMgrUpdateFormTest::SetUpTestCase()
75 {
76 RemoteNativeToken::SetNativeToken();
77 mockBundleMgrService = new BundleMgrService();
78 FormBmsHelper::GetInstance().SetBundleManager(mockBundleMgrService);
79 FormAmsHelper::GetInstance().SetAbilityManager(new MockAbilityMgrService());
80 }
81
TearDownTestCase()82 void FmsFormMgrUpdateFormTest::TearDownTestCase()
83 {}
84
SetUp()85 void FmsFormMgrUpdateFormTest::SetUp()
86 {
87 HILOG_INFO("fms_form_mgr_client_updateForm_test_001 setup");
88 formyMgrServ_->OnStart();
89 token_ = new (std::nothrow) MockFormHostClient();
90
91 // Permission install
92 int userId = 0;
93 auto tokenId = AccessToken::AccessTokenKit::GetHapTokenID(userId, FORM_PROVIDER_BUNDLE_NAME, 0);
94 auto flag = OHOS::Security::AccessToken::PERMISSION_USER_FIXED;
95 AccessToken::AccessTokenKit::GrantPermission(tokenId, PERMISSION_NAME_REQUIRE_FORM, flag);
96 }
97
TearDown()98 void FmsFormMgrUpdateFormTest::TearDown()
99 {}
100
101 sptr<BundleMgrService> FmsFormMgrUpdateFormTest::mockBundleMgrService = nullptr;
102
103 /*
104 * Feature: FormMgrService
105 * Function: FormMgr
106 * SubFunction: UpdateForm Function
107 * FunctionPoints: FormMgr UpdateForm interface
108 * EnvConditions: Mobile that can run ohos test framework
109 * CaseDescription: Verify if FormMgr invoke UpdateForm works.
110 */
111 HWTEST_F(FmsFormMgrUpdateFormTest, UpdateForm_001, TestSize.Level0)
112 {
113 GTEST_LOG_(INFO) << "fms_form_mgr_client_updateForm_test_001 start";
114
115 // param editor
116 int64_t formId {100L};
117 int32_t callingUid {20000001};
118 std::string bandleName = FORM_PROVIDER_BUNDLE_NAME;
119 FormProviderData formProviderData = FormProviderData(std::string("{\"city\": \"beijing001\"}"));
120
121 // add formRecord
122 FormItemInfo formItemInfo;
123 formItemInfo.SetFormId(formId);
124 formItemInfo.SetProviderBundleName(FORM_PROVIDER_BUNDLE_NAME);
125 formItemInfo.SetAbilityName(FORM_PROVIDER_ABILITY_NAME);
126 formItemInfo.SetTemporaryFlag(false);
127 formItemInfo.SetProviderUid(callingUid);
128 FormDataMgr::GetInstance().AllotFormRecord(formItemInfo, callingUid);
129
130 FormItemInfo formItemInfo1;
131 formItemInfo1.SetFormId(1000L);
132 formItemInfo1.SetProviderBundleName(FORM_PROVIDER_BUNDLE_NAME);
133 formItemInfo1.SetAbilityName(FORM_PROVIDER_ABILITY_NAME);
134 formItemInfo1.SetTemporaryFlag(true);
135 formItemInfo1.SetProviderUid(callingUid);
136 FormDataMgr::GetInstance().AllotFormRecord(formItemInfo1, callingUid);
137
138 // add formHostRecord
139 FormItemInfo itemInfo;
140 FormDataMgr::GetInstance().AllotFormHostRecord(itemInfo, token_, formId, callingUid);
141
__anon56e26cf00202(const int uid, std::string &name) 142 auto bmsTaskGetBundleNameForUid = [] (const int uid, std::string &name) {
143 name = FORM_PROVIDER_BUNDLE_NAME;
144 GTEST_LOG_(INFO) << "AddForm_002 bmsTaskGetBundleNameForUid called";
145 return ERR_OK;
146 };
147 EXPECT_CALL(*mockBundleMgrService, GetNameForUid(_, _)).Times(1).WillOnce(Invoke(bmsTaskGetBundleNameForUid));
148
149 // test exec
150 MockGetCallingUid(callingUid);
151 EXPECT_EQ(ERR_OK, FormMgr::GetInstance().UpdateForm(formId, formProviderData));
152
153 token_->Wait();
154
155 GTEST_LOG_(INFO) << "fms_form_mgr_client_updateForm_test_001 end";
156 }
157
158 /*
159 * Feature: FormMgrService
160 * Function: FormMgr
161 * SubFunction: UpdateForm Function
162 * FunctionPoints: FormMgr UpdateForm interface
163 * EnvConditions: Mobile that can run ohos test framework
164 * CaseDescription: Verify if FormMgr invoke UpdateForm works when passing bandleName is empty.
165 */
166 HWTEST_F(FmsFormMgrUpdateFormTest, UpdateForm_003, TestSize.Level0)
167 {
168 GTEST_LOG_(INFO) << "fms_form_mgr_client_updateForm_test_003 start";
169
170 // param editor
171 int64_t formId {300L};
172 int32_t callingUid {0};
173 FormProviderData formProviderData;
174
175 // add formRecord
176 FormItemInfo formItemInfo;
177 formItemInfo.SetFormId(formId);
178 formItemInfo.SetProviderBundleName(FORM_PROVIDER_BUNDLE_NAME);
179 formItemInfo.SetAbilityName(FORM_PROVIDER_ABILITY_NAME);
180 formItemInfo.SetTemporaryFlag(false);
181 FormDataMgr::GetInstance().AllotFormRecord(formItemInfo, callingUid);
182
183 // add formHostRecord
184 FormItemInfo itemInfo;
185 FormDataMgr::GetInstance().AllotFormHostRecord(itemInfo, token_, formId, callingUid);
186
187 // test exec
188 EXPECT_EQ(ERR_APPEXECFWK_FORM_INVALID_PARAM,
189 FormMgrAdapter::GetInstance().UpdateForm(formId, callingUid, formProviderData));
190
191 GTEST_LOG_(INFO) << "fms_form_mgr_client_updateForm_test_003 end";
192 }
193
194 /*
195 * Feature: FormMgrService
196 * Function: FormMgr
197 * SubFunction: UpdateForm Function
198 * FunctionPoints: FormMgr UpdateForm interface
199 * EnvConditions: Mobile that can run ohos test framework
200 * CaseDescription: Verify if FormMgr invoke UpdateForm works when bandleName not match.
201 */
202 HWTEST_F(FmsFormMgrUpdateFormTest, UpdateForm_004, TestSize.Level0)
203 {
204 GTEST_LOG_(INFO) << "fms_form_mgr_client_updateForm_test_004 start";
205
206 // param editor
207 int64_t formId {400L};
208 int32_t callingUid {0};
209 std::string bandleName = FORM_PROVIDER_BUNDLE_NAME;
210 FormProviderData formProviderData = FormProviderData(std::string("{\"city\": \"beijing004\"}"));
211
212 // add formRecord
213 FormItemInfo formItemInfo;
214 formItemInfo.SetFormId(formId);
215 formItemInfo.SetProviderBundleName(FORM_HOST_BUNDLE_NAME);
216 formItemInfo.SetAbilityName(FORM_PROVIDER_ABILITY_NAME);
217 formItemInfo.SetTemporaryFlag(false);
218 FormDataMgr::GetInstance().AllotFormRecord(formItemInfo, callingUid);
219
220 // add formHostRecord
221 FormItemInfo itemInfo;
222 FormDataMgr::GetInstance().AllotFormHostRecord(itemInfo, token_, formId, callingUid);
223
__anon56e26cf00302(const int uid, std::string &name) 224 auto bmsTaskGetBundleNameForUid = [] (const int uid, std::string &name) {
225 name = FORM_PROVIDER_BUNDLE_NAME;
226 GTEST_LOG_(INFO) << "AddForm_002 bmsTaskGetBundleNameForUid called";
227 return ERR_OK;
228 };
229 EXPECT_CALL(*mockBundleMgrService, GetNameForUid(_, _)).Times(1).WillOnce(Invoke(bmsTaskGetBundleNameForUid));
230
231 // test exec
232 EXPECT_EQ(ERR_APPEXECFWK_FORM_INVALID_PARAM, FormMgr::GetInstance().UpdateForm(formId, formProviderData));
233
234 GTEST_LOG_(INFO) << "fms_form_mgr_client_updateForm_test_004 end";
235 }
236
237 /*
238 * Feature: FormMgrService
239 * Function: FormMgr
240 * SubFunction: UpdateForm Function
241 * FunctionPoints: FormMgr UpdateForm interface
242 * EnvConditions: Mobile that can run ohos test framework
243 * CaseDescription: Verify if FormMgr invoke UpdateForm works when not under current user.
244 */
245 HWTEST_F(FmsFormMgrUpdateFormTest, UpdateForm_005, TestSize.Level0)
246 {
247 GTEST_LOG_(INFO) << "fms_form_mgr_client_updateForm_test_005 start";
248
249 // param editor
250 int64_t formId {500L};
251 int32_t callingUid {1};
252 std::string bandleName = FORM_HOST_BUNDLE_NAME;
253 FormProviderData formProviderData = FormProviderData(std::string("{\"city\": \"beijing005\"}"));
254
255 // add formRecord
256 FormItemInfo formItemInfo;
257 formItemInfo.SetFormId(formId);
258 formItemInfo.SetProviderBundleName(FORM_HOST_BUNDLE_NAME);
259 formItemInfo.SetAbilityName(FORM_PROVIDER_ABILITY_NAME);
260 formItemInfo.SetTemporaryFlag(false);
261 FormDataMgr::GetInstance().AllotFormRecord(formItemInfo, callingUid);
262
263 // add formHostRecord
264 FormItemInfo itemInfo;
265 FormDataMgr::GetInstance().AllotFormHostRecord(itemInfo, token_, formId, callingUid);
266
__anon56e26cf00402(const int uid, std::string &name) 267 auto bmsTaskGetBundleNameForUid = [] (const int uid, std::string &name) {
268 name = FORM_PROVIDER_BUNDLE_NAME;
269 GTEST_LOG_(INFO) << "AddForm_002 bmsTaskGetBundleNameForUid called";
270 return ERR_OK;
271 };
272 EXPECT_CALL(*mockBundleMgrService, GetNameForUid(_, _)).Times(1).WillOnce(Invoke(bmsTaskGetBundleNameForUid));
273
274 // test exec
275 EXPECT_EQ(ERR_APPEXECFWK_FORM_INVALID_PARAM, FormMgr::GetInstance().UpdateForm(formId, formProviderData));
276
277 GTEST_LOG_(INFO) << "fms_form_mgr_client_updateForm_test_005 end";
278 }
279
280 /*
281 * Feature: FormMgrService
282 * Function: FormMgr
283 * SubFunction: UpdateForm Function
284 * FunctionPoints: FormMgr UpdateForm interface
285 * EnvConditions: Mobile that can run ohos test framework
286 * CaseDescription: Verify if FormMgr invoke UpdateForm works when the updated form is not your own.
287 */
288 HWTEST_F(FmsFormMgrUpdateFormTest, UpdateForm_006, TestSize.Level0)
289 {
290 GTEST_LOG_(INFO) << "fms_form_mgr_client_updateForm_test_006 start";
291
292 // param editor
293 int64_t formId {600L};
294 int32_t callingUid {0};
295 std::string bandleName = "com.form.host.app600";
296 FormProviderData formProviderData = FormProviderData(std::string("{\"city\": \"beijing006\"}"));
297
298 // add formRecord
299 FormItemInfo formItemInfo;
300 formItemInfo.SetFormId(formId);
301 formItemInfo.SetProviderBundleName(FORM_HOST_BUNDLE_NAME);
302 formItemInfo.SetAbilityName(FORM_PROVIDER_ABILITY_NAME);
303 formItemInfo.SetTemporaryFlag(false);
304 FormDataMgr::GetInstance().AllotFormRecord(formItemInfo, callingUid);
305
306 // add formHostRecord
307 FormItemInfo itemInfo;
308 FormDataMgr::GetInstance().AllotFormHostRecord(itemInfo, token_, formId, callingUid);
309
__anon56e26cf00502(const int uid, std::string &name) 310 auto bmsTaskGetBundleNameForUid = [] (const int uid, std::string &name) {
311 name = FORM_PROVIDER_BUNDLE_NAME;
312 GTEST_LOG_(INFO) << "AddForm_002 bmsTaskGetBundleNameForUid called";
313 return ERR_OK;
314 };
315 EXPECT_CALL(*mockBundleMgrService, GetNameForUid(_, _)).Times(1).WillOnce(Invoke(bmsTaskGetBundleNameForUid));
316
317 // test exec
318 EXPECT_EQ(ERR_APPEXECFWK_FORM_INVALID_PARAM, FormMgr::GetInstance().UpdateForm(formId, formProviderData));
319
320 GTEST_LOG_(INFO) << "fms_form_mgr_client_updateForm_test_006 end";
321 }
322
323 /*
324 * Feature: FormMgrService
325 * Function: FormMgr
326 * SubFunction: UpdateForm Function
327 * FunctionPoints: FormMgr UpdateForm interface
328 * EnvConditions: Mobile that can run ohos test framework
329 * CaseDescription: Verify if FormMgr invoke UpdateForm works.
330 */
331 HWTEST_F(FmsFormMgrUpdateFormTest, UpdateForm_007, TestSize.Level0)
332 {
333 GTEST_LOG_(INFO) << "fms_form_mgr_client_updateForm_test_007 start";
334
335 // param editor
336 int64_t formId {700L};
337 int32_t callingUid {0};
338 std::string bandleName = FORM_PROVIDER_BUNDLE_NAME;
339 std::string jsonData = std::string("{");
340 for (int i = 0; i < 1024; i = i + 1) {
341 jsonData = jsonData + std::string("\"city" + std::to_string(i) + "\"" + ":" + "\"beijing007\"");
342 if (i != 1023) {
343 jsonData = jsonData + std::string(", ");
344 }
345 }
346 jsonData = jsonData + std::string("}");
347 FormProviderData formProviderData = FormProviderData(jsonData);
348
349 // add formRecord
350 FormItemInfo formItemInfo;
351 formItemInfo.SetFormId(formId);
352 formItemInfo.SetProviderBundleName(FORM_PROVIDER_BUNDLE_NAME);
353 formItemInfo.SetAbilityName(FORM_PROVIDER_ABILITY_NAME);
354 formItemInfo.SetTemporaryFlag(false);
355 formItemInfo.SetProviderUid(callingUid);
356 FormRecord formRecord = FormDataMgr::GetInstance().AllotFormRecord(formItemInfo, callingUid);
357 formRecord.versionUpgrade = true;
358
359 FormItemInfo formItemInfo1;
360 formItemInfo1.SetFormId(7000L);
361 formItemInfo1.SetProviderBundleName(FORM_HOST_BUNDLE_NAME);
362 formItemInfo1.SetAbilityName(FORM_PROVIDER_ABILITY_NAME);
363 formItemInfo1.SetTemporaryFlag(true);
364 formItemInfo1.SetProviderUid(callingUid);
365 FormRecord formRecord1 = FormDataMgr::GetInstance().AllotFormRecord(formItemInfo1, callingUid);
366
367 // add formHostRecord
368 FormItemInfo itemInfo;
369 FormDataMgr::GetInstance().AllotFormHostRecord(itemInfo, token_, formId, callingUid);
370
__anon56e26cf00602(const int uid, std::string &name) 371 auto bmsTaskGetBundleNameForUid = [] (const int uid, std::string &name) {
372 name = FORM_PROVIDER_BUNDLE_NAME;
373 GTEST_LOG_(INFO) << "AddForm_002 bmsTaskGetBundleNameForUid called";
374 return ERR_OK;
375 };
376 EXPECT_CALL(*mockBundleMgrService, GetNameForUid(_, _)).Times(1).WillOnce(Invoke(bmsTaskGetBundleNameForUid));
377
378 // test exec
379 MockGetCallingUid(callingUid);
380 EXPECT_EQ(ERR_OK, FormMgr::GetInstance().UpdateForm(formId, formProviderData));
381
382 token_->Wait();
383
384 GTEST_LOG_(INFO) << "fms_form_mgr_client_updateForm_test_007 end";
385 }
386
387 /**
388 * @tc.name: UpdateForm_008
389 * @tc.desc: Verify linkage update
390 * @tc.type: FUNC
391 * @tc.require: issueI5KIZC
392 */
393 HWTEST_F(FmsFormMgrUpdateFormTest, UpdateForm_008, TestSize.Level1) {
394 GTEST_LOG_(INFO) << "UpdateForm_008 starts";
395 // param editor
396 int64_t formId {100L};
397 int32_t callingUid {20000001};
398 FormProviderData formProviderData = FormProviderData(std::string("{\"city\": \"beijing001\"}"));
399
400 // add formRecord
401 FormItemInfo formItemInfo;
402 formItemInfo.SetFormId(formId);
403 formItemInfo.SetProviderBundleName(FORM_PROVIDER_BUNDLE_NAME);
404 formItemInfo.SetAbilityName(FORM_PROVIDER_ABILITY_NAME);
405 formItemInfo.SetTemporaryFlag(false);
406 formItemInfo.SetProviderUid(callingUid);
407 FormDataMgr::GetInstance().AllotFormRecord(formItemInfo, callingUid);
408
409 // add formHostRecord
410 FormItemInfo itemInfo;
411 itemInfo.SetHostBundleName(FORM_HOST_BUNDLE_NAME);
412 FormDataMgr::GetInstance().AllotFormHostRecord(itemInfo, token_, formId, callingUid);
413 FormItemInfo itemInfo1;
414 itemInfo1.SetHostBundleName(FORM_PROVIDER_BUNDLE_NAME);
415 FormDataMgr::GetInstance().AllotFormHostRecord(itemInfo, token_, formId, callingUid);
416
__anon56e26cf00702(const int uid, std::string &name) 417 auto bmsTaskGetBundleNameForUid = [] (const int uid, std::string &name) {
418 name = FORM_PROVIDER_BUNDLE_NAME;
419 GTEST_LOG_(INFO) << "AddForm_002 bmsTaskGetBundleNameForUid called";
420 return ERR_OK;
421 };
422 EXPECT_CALL(*mockBundleMgrService, GetNameForUid(_, _)).Times(1).WillOnce(Invoke(bmsTaskGetBundleNameForUid));
423
424 // test exec
425 MockGetCallingUid(callingUid);
426 EXPECT_EQ(ERR_OK, FormMgr::GetInstance().UpdateForm(formId, formProviderData));
427
428 token_->Wait();
429
430 GTEST_LOG_(INFO) << "UpdateForm_008 test ends";
431 }
432 }