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 "gtest/gtest.h"
17
18 #include "ability_config.h"
19 #define private public
20 #include "dialog_session_manager.h"
21 #undef private
22 #include "hilog_tag_wrapper.h"
23 #include "mock_ability_token.h"
24 #include "start_ability_utils.h"
25
26 using OHOS::AppExecFwk::AbilityType;
27 using namespace testing::ext;
28
29 namespace OHOS {
30 namespace AAFwk {
31 namespace {
32 constexpr int32_t TEST_USER_ID = 10001;
33 constexpr int32_t TEST_ERMS_ISALLOW_RESULTCODE = 9;
34 const std::string TEST_BUNDLE_NAME = "com.test.demo";
35 const std::string TEST_DIALOG_SESSION_ID = "dialogSessionId";
36 const std::string APP_LAUNCH_TRUSTLIST = "ohos.params.appLaunchTrustList";
37 const std::string SHOW_DEFAULT_PICKER_FLAG = "ohos.ability.params.showDefaultPicker";
38 }
39
40 class DialogSessionManagerTest : public testing::Test {
41 public:
42 static void SetUpTestCase();
43 static void TearDownTestCase();
44 void SetUp() override;
45 void TearDown() override;
46 std::shared_ptr<AbilityRecord> MockAbilityRecord(AbilityType);
47 sptr<Token> MockToken(AbilityType);
48 };
49
SetUpTestCase(void)50 void DialogSessionManagerTest::SetUpTestCase(void)
51 {}
52
TearDownTestCase(void)53 void DialogSessionManagerTest::TearDownTestCase(void)
54 {}
55
SetUp()56 void DialogSessionManagerTest::SetUp()
57 {}
58
TearDown()59 void DialogSessionManagerTest::TearDown()
60 {}
61
MockAbilityRecord(AbilityType abilityType)62 std::shared_ptr<AbilityRecord> DialogSessionManagerTest::MockAbilityRecord(AbilityType abilityType)
63 {
64 AbilityRequest abilityRequest;
65 abilityRequest.appInfo.bundleName = TEST_BUNDLE_NAME;
66 abilityRequest.abilityInfo.name = "MainAbility";
67 abilityRequest.abilityInfo.type = abilityType;
68 return AbilityRecord::CreateAbilityRecord(abilityRequest);
69 }
70
MockToken(AbilityType abilityType)71 sptr<Token> DialogSessionManagerTest::MockToken(AbilityType abilityType)
72 {
73 std::shared_ptr<AbilityRecord> abilityRecord = MockAbilityRecord(abilityType);
74 if (!abilityRecord) {
75 return nullptr;
76 }
77 return abilityRecord->GetToken();
78 }
79
80 /**
81 * @tc.name: GetStartupSessionInfoTest_0100
82 * @tc.desc: Test GetStartupSessionInfo
83 * @tc.type: FUNC
84 */
85 HWTEST_F(DialogSessionManagerTest, GetStartupSessionInfoTest_0100, TestSize.Level1)
86 {
87 GTEST_LOG_(INFO) << "GetStartupSessionInfoTest_0100 start";
88 DialogSessionManager dialogSessionManager;
89 std::shared_ptr<StartupSessionInfo> ret = dialogSessionManager.GetStartupSessionInfo(TEST_DIALOG_SESSION_ID);
90 EXPECT_EQ(ret, nullptr);
91
92 AbilityRequest abilityRequest;
93 dialogSessionManager.SetStartupSessionInfo(TEST_DIALOG_SESSION_ID, abilityRequest);
94 ret = dialogSessionManager.GetStartupSessionInfo(TEST_DIALOG_SESSION_ID);
95 EXPECT_NE(ret, nullptr);
96 GTEST_LOG_(INFO) << "GetStartupSessionInfoTest_0100 end";
97 }
98
99 /**
100 * @tc.name: SendDialogResultTest_0100
101 * @tc.desc: Test SendDialogResult
102 * @tc.type: FUNC
103 */
104 HWTEST_F(DialogSessionManagerTest, SendDialogResultTest_0100, TestSize.Level1)
105 {
106 GTEST_LOG_(INFO) << "SendDialogResultTest_0100 start";
107 AbilityRequest abilityRequest;
108 DialogSessionManager dialogSessionManager;
109 Want want;
110 bool isAllowed = false;
111 int32_t ret = dialogSessionManager.SendDialogResult(want, TEST_DIALOG_SESSION_ID, isAllowed);
112 EXPECT_EQ(ret, ERR_OK);
113
114 isAllowed = true;
115 ret = dialogSessionManager.SendDialogResult(want, TEST_DIALOG_SESSION_ID, isAllowed);
116 EXPECT_EQ(ret, ERR_INVALID_VALUE);
117
118 dialogSessionManager.SetStartupSessionInfo(TEST_DIALOG_SESSION_ID, abilityRequest);
119 ret = dialogSessionManager.SendDialogResult(want, TEST_DIALOG_SESSION_ID, isAllowed);
120 EXPECT_EQ(ret, ERR_INVALID_VALUE);
121 GTEST_LOG_(INFO) << "SendDialogResultTest_0100 end";
122 }
123
124 /**
125 * @tc.name: SendDialogResultTest_0200
126 * @tc.desc: Test SendDialogResult
127 * @tc.type: FUNC
128 */
129 HWTEST_F(DialogSessionManagerTest, SendDialogResultTest_0200, TestSize.Level1)
130 {
131 GTEST_LOG_(INFO) << "SendDialogResultTest_0200 start";
132 AbilityRequest abilityRequest;
133 DialogSessionManager dialogSessionManager;
134 Want want;
135 bool isAllowed = true;
136 sptr<DialogSessionInfo> dilogSessionInfo = nullptr;
137 std::shared_ptr<DialogCallerInfo> dialogCallerInfo = std::make_shared<DialogCallerInfo>();
138
139 dialogSessionManager.SetDialogSessionInfo(TEST_DIALOG_SESSION_ID, dilogSessionInfo, dialogCallerInfo);
140 int32_t ret = dialogSessionManager.SendDialogResult(want, TEST_DIALOG_SESSION_ID, isAllowed);
141 EXPECT_EQ(ret, ERR_INVALID_VALUE);
142
143 want.SetParam(Want::PARAM_APP_CLONE_INDEX_KEY, 0);
144 ret = dialogSessionManager.SendDialogResult(want, TEST_DIALOG_SESSION_ID, isAllowed);
145 EXPECT_EQ(ret, ERR_INVALID_VALUE);
146 GTEST_LOG_(INFO) << "SendDialogResultTest_0200 end";
147 }
148
149 /**
150 * @tc.name: NotifySCBToRecoveryAfterInterceptionTest_0100
151 * @tc.desc: Test NotifySCBToRecoveryAfterInterception
152 * @tc.type: FUNC
153 */
154 HWTEST_F(DialogSessionManagerTest, NotifySCBToRecoveryAfterInterceptionTest_0100, TestSize.Level1)
155 {
156 GTEST_LOG_(INFO) << "NotifySCBToRecoveryAfterInterceptionTest_0100 start";
157 AbilityRequest abilityRequest;
158 DialogSessionManager dialogSessionManager;
159
160 int32_t ret = dialogSessionManager.NotifySCBToRecoveryAfterInterception(TEST_DIALOG_SESSION_ID, abilityRequest);
161 EXPECT_EQ(ret, ERR_INVALID_VALUE);
162 GTEST_LOG_(INFO) << "NotifySCBToRecoveryAfterInterceptionTest_0100 end";
163 }
164
165 /**
166 * @tc.name: CreateModalDialogCommonTest_0100
167 * @tc.desc: Test CreateModalDialogCommon
168 * @tc.type: FUNC
169 */
170 HWTEST_F(DialogSessionManagerTest, CreateModalDialogCommonTest_0100, TestSize.Level1)
171 {
172 GTEST_LOG_(INFO) << "CreateModalDialogCommonTest_0100 start";
173 Want replaceWant;
174 sptr<IRemoteObject> callerToken = MockToken(AbilityType::PAGE);
175 DialogSessionManager dialogSessionManager;
176
177 int32_t ret = dialogSessionManager.CreateModalDialogCommon(replaceWant, callerToken, TEST_DIALOG_SESSION_ID);
178 EXPECT_EQ(ret, ERR_INVALID_VALUE);
179 GTEST_LOG_(INFO) << "CreateModalDialogCommonTest_0100 end";
180 }
181
182 /**
183 * @tc.name: IsCreateCloneSelectorDialogTest_0100
184 * @tc.desc: Test IsCreateCloneSelectorDialog
185 * @tc.type: FUNC
186 */
187 HWTEST_F(DialogSessionManagerTest, IsCreateCloneSelectorDialogTest_0100, TestSize.Level1)
188 {
189 GTEST_LOG_(INFO) << "IsCreateCloneSelectorDialogTest_0100 start";
190 DialogSessionManager dialogSessionManager;
191
192 StartAbilityUtils::isWantWithAppCloneIndex = true;
193 bool ret = dialogSessionManager.IsCreateCloneSelectorDialog(TEST_BUNDLE_NAME, TEST_USER_ID);
194 EXPECT_FALSE(ret);
195 GTEST_LOG_(INFO) << "IsCreateCloneSelectorDialogTest_0100 end";
196 }
197
198 /**
199 * @tc.name: UpdateExtensionWantWithDialogCallerInfo_0100
200 * @tc.desc: callerToken is nullptr
201 * @tc.type: FUNC
202 */
203 HWTEST_F(DialogSessionManagerTest, UpdateExtensionWantWithDialogCallerInfo_0100, TestSize.Level1)
204 {
205 GTEST_LOG_(INFO) << "UpdateExtensionWantWithDialogCallerInfo_0100 start";
206 std::string dialogSessionId = "";
207 AbilityRequest abilityRequest;
208 bool isSCBCall = false;
209 sptr<IRemoteObject> callerToken = nullptr;
210 abilityRequest.want.SetParam(TEST_DIALOG_SESSION_ID, dialogSessionId);
211 DialogSessionManager dialogSessionManager;
212 auto ret = dialogSessionManager.UpdateExtensionWantWithDialogCallerInfo(abilityRequest, callerToken, isSCBCall);
213 EXPECT_FALSE(ret);
214 GTEST_LOG_(INFO) << "UpdateExtensionWantWithDialogCallerInfo_0100 end";
215 }
216
217 /**
218 * @tc.name: UpdateExtensionWantWithDialogCallerInfo_0200
219 * @tc.desc: dialogSessionId is empty
220 * @tc.type: FUNC
221 */
222 HWTEST_F(DialogSessionManagerTest, UpdateExtensionWantWithDialogCallerInfo_0200, TestSize.Level1)
223 {
224 GTEST_LOG_(INFO) << "UpdateExtensionWantWithDialogCallerInfo_0200 start";
225 std::string dialogSessionId = "";
226 AbilityRequest abilityRequest;
227 bool isSCBCall = false;
228 sptr<IRemoteObject> callerToken = sptr<AppExecFwk::MockAbilityToken>::MakeSptr();
229 abilityRequest.want.SetParam(TEST_DIALOG_SESSION_ID, dialogSessionId);
230 DialogSessionManager dialogSessionManager;
231 auto ret = dialogSessionManager.UpdateExtensionWantWithDialogCallerInfo(abilityRequest, callerToken, isSCBCall);
232 EXPECT_FALSE(ret);
233 GTEST_LOG_(INFO) << "UpdateExtensionWantWithDialogCallerInfo_0200 end";
234 }
235
236 /**
237 * @tc.name: UpdateExtensionWantWithDialogCallerInfo_0300
238 * @tc.desc: can not find dialogCallerInfo by dialogSessionId
239 * @tc.type: FUNC
240 */
241 HWTEST_F(DialogSessionManagerTest, UpdateExtensionWantWithDialogCallerInfo_0300, TestSize.Level1)
242 {
243 GTEST_LOG_(INFO) << "UpdateExtensionWantWithDialogCallerInfo_0300 start";
244 std::string dialogSessionId = "1000001";
245 AbilityRequest abilityRequest;
246 bool isSCBCall = false;
247 sptr<IRemoteObject> callerToken = sptr<AppExecFwk::MockAbilityToken>::MakeSptr();
248 abilityRequest.want.SetParam(TEST_DIALOG_SESSION_ID, dialogSessionId);
249 DialogSessionManager dialogSessionManager;
250 auto ret = dialogSessionManager.UpdateExtensionWantWithDialogCallerInfo(abilityRequest, callerToken, isSCBCall);
251 EXPECT_FALSE(ret);
252 GTEST_LOG_(INFO) << "UpdateExtensionWantWithDialogCallerInfo_0300 end";
253 }
254
255 /**
256 * @tc.name: UpdateExtensionWantWithDialogCallerInfo_0400
257 * @tc.desc: dialog callerInfo do not need grant uri permission
258 * @tc.type: FUNC
259 */
260 HWTEST_F(DialogSessionManagerTest, UpdateExtensionWantWithDialogCallerInfo_0400, TestSize.Level1)
261 {
262 GTEST_LOG_(INFO) << "UpdateExtensionWantWithDialogCallerInfo_0400 start";
263 std::string dialogSessionId = "1000001";
264 AbilityRequest abilityRequest;
265 bool isSCBCall = false;
266 sptr<IRemoteObject> callerToken = sptr<AppExecFwk::MockAbilityToken>::MakeSptr();
267 abilityRequest.want.SetParam(TEST_DIALOG_SESSION_ID, dialogSessionId);
268
269 std::shared_ptr<DialogCallerInfo> dialogCallerInfo = std::make_shared<DialogCallerInfo>();
270 dialogCallerInfo->needGrantUriPermission = false;
271 DialogSessionManager dialogSessionManager;
272 dialogSessionManager.dialogCallerInfoMap_[dialogSessionId] = dialogCallerInfo;
273 auto ret = dialogSessionManager.UpdateExtensionWantWithDialogCallerInfo(abilityRequest, callerToken, isSCBCall);
274 EXPECT_FALSE(ret);
275 GTEST_LOG_(INFO) << "UpdateExtensionWantWithDialogCallerInfo_0400 end";
276 }
277
278 /**
279 * @tc.name: UpdateExtensionWantWithDialogCallerInfo_0500
280 * @tc.desc: do not have uri permission flag
281 * @tc.type: FUNC
282 */
283 HWTEST_F(DialogSessionManagerTest, UpdateExtensionWantWithDialogCallerInfo_0500, TestSize.Level1)
284 {
285 GTEST_LOG_(INFO) << "UpdateExtensionWantWithDialogCallerInfo_0500 start";
286 std::string dialogSessionId = "1000001";
287 AbilityRequest abilityRequest;
288 bool isSCBCall = false;
289 sptr<IRemoteObject> callerToken = sptr<AppExecFwk::MockAbilityToken>::MakeSptr();
290 abilityRequest.want.SetParam(TEST_DIALOG_SESSION_ID, dialogSessionId);
291
292 std::shared_ptr<DialogCallerInfo> dialogCallerInfo = std::make_shared<DialogCallerInfo>();
293 dialogCallerInfo->needGrantUriPermission = true;
294 DialogSessionManager dialogSessionManager;
295 dialogSessionManager.dialogCallerInfoMap_[dialogSessionId] = dialogCallerInfo;
296 auto ret = dialogSessionManager.UpdateExtensionWantWithDialogCallerInfo(abilityRequest, callerToken, isSCBCall);
297 EXPECT_FALSE(ret);
298 GTEST_LOG_(INFO) << "UpdateExtensionWantWithDialogCallerInfo_0500 end";
299 }
300
301 /**
302 * @tc.name: UpdateExtensionWantWithDialogCallerInfo_0600
303 * @tc.desc: not scb call and have uri permission flag
304 * @tc.type: FUNC
305 */
306 HWTEST_F(DialogSessionManagerTest, UpdateExtensionWantWithDialogCallerInfo_0600, TestSize.Level1)
307 {
308 GTEST_LOG_(INFO) << "UpdateExtensionWantWithDialogCallerInfo_0600 start";
309 std::string dialogSessionId = "1000001";
310 AbilityRequest abilityRequest;
311 bool isSCBCall = false;
312 sptr<IRemoteObject> callerToken = sptr<AppExecFwk::MockAbilityToken>::MakeSptr();
313 abilityRequest.want.SetParam(TEST_DIALOG_SESSION_ID, dialogSessionId);
314
315 std::shared_ptr<DialogCallerInfo> dialogCallerInfo = std::make_shared<DialogCallerInfo>();
316 uint32_t flag = 1;
317 dialogCallerInfo->targetWant.SetFlags(flag);
318 dialogCallerInfo->needGrantUriPermission = true;
319
320 DialogSessionManager dialogSessionManager;
321 dialogSessionManager.dialogCallerInfoMap_[dialogSessionId] = dialogCallerInfo;
322 auto ret = dialogSessionManager.UpdateExtensionWantWithDialogCallerInfo(abilityRequest, callerToken, isSCBCall);
323 EXPECT_FALSE(ret);
324 GTEST_LOG_(INFO) << "UpdateExtensionWantWithDialogCallerInfo_0600 end";
325 }
326
327 /**
328 * @tc.name: UpdateExtensionWantWithDialogCallerInfo_0700
329 * @tc.desc: scb call and have uri permission flag
330 * @tc.type: FUNC
331 */
332 HWTEST_F(DialogSessionManagerTest, UpdateExtensionWantWithDialogCallerInfo_0700, TestSize.Level1)
333 {
334 GTEST_LOG_(INFO) << "UpdateExtensionWantWithDialogCallerInfo_0600 start";
335 std::string dialogSessionId = "1000001";
336 AbilityRequest abilityRequest;
337 bool isSCBCall = true;
338 sptr<IRemoteObject> callerToken = sptr<AppExecFwk::MockAbilityToken>::MakeSptr();
339 abilityRequest.want.SetParam(TEST_DIALOG_SESSION_ID, dialogSessionId);
340
341 std::shared_ptr<DialogCallerInfo> dialogCallerInfo = std::make_shared<DialogCallerInfo>();
342 uint32_t flag = 1;
343 std::string uri = "file://com.example.test/temp.txt";
344 std::vector<std::string> uriVec = { uri };
345 dialogCallerInfo->targetWant.SetFlags(flag);
346 dialogCallerInfo->targetWant.SetUri(uri);
347 dialogCallerInfo->targetWant.SetParam(AbilityConfig::PARAMS_STREAM, uriVec);
348 dialogCallerInfo->needGrantUriPermission = true;
349
350 DialogSessionManager dialogSessionManager;
351 dialogSessionManager.dialogCallerInfoMap_[dialogSessionId] = dialogCallerInfo;
352 auto ret = dialogSessionManager.UpdateExtensionWantWithDialogCallerInfo(abilityRequest, callerToken, isSCBCall);
353 EXPECT_FALSE(ret);
354
355 EXPECT_EQ(abilityRequest.want.GetFlags(), flag);
356 EXPECT_EQ(abilityRequest.want.GetUriString(), uri);
357 EXPECT_EQ(abilityRequest.want.GetStringArrayParam(AbilityConfig::PARAMS_STREAM).size(), 1);
358 GTEST_LOG_(INFO) << "UpdateExtensionWantWithDialogCallerInfo_0700 end";
359 }
360
361 /**
362 * @tc.name: CreateImplicitSelectorModalDialog_0001
363 * @tc.desc: No APP_LAUNCH_TRUSTLIST
364 * @tc.type: FUNC
365 */
366 HWTEST_F(DialogSessionManagerTest, CreateImplicitSelectorModalDialog_0001, TestSize.Level1)
367 {
368 GTEST_LOG_(INFO) << "CreateImplicitSelectorModalDialog_0001 start";
369 std::string dialogSessionId = "1000001";
370 AbilityRequest abilityRequest;
371 abilityRequest.want.SetParam(TEST_DIALOG_SESSION_ID, dialogSessionId);
372 AAFwk::Want want;
373 int32_t userId = 0;
374 std::vector<DialogAppInfo> dialogAppInfos;
375 abilityRequest.want.SetParam("deviceType", 1);
376 abilityRequest.want.SetParam("userId", userId);
377 std::string mockAction = "mockAction";
378 abilityRequest.want.SetParam("action", mockAction);
379 std::string mockType = "mockType";
380 abilityRequest.want.SetParam("wantType", mockType);
381 std::string mockUri = "mockUri";
382 abilityRequest.want.SetParam("uri", mockUri);
383 std::vector<std::string> mockEntities = {"mockEntities"};
384 abilityRequest.want.SetParam("entities", mockEntities);
385 abilityRequest.want.SetParam("appselector.selectorType", static_cast<int>(SelectorType::IMPLICIT_START_SELECTOR));
386 abilityRequest.want.SetParam("showCaller", false);
387 abilityRequest.want.SetParam(SHOW_DEFAULT_PICKER_FLAG, false);
388
389 std::shared_ptr<DialogCallerInfo> dialogCallerInfo = std::make_shared<DialogCallerInfo>();
390 DialogSessionManager dialogSessionManager;
391 dialogSessionManager.dialogCallerInfoMap_[dialogSessionId] = dialogCallerInfo;
392 auto ret = dialogSessionManager.CreateImplicitSelectorModalDialog(abilityRequest,
393 want, userId, dialogAppInfos, false);
394
395 EXPECT_NE(ret, ERR_INVALID_VALUE);
396 GTEST_LOG_(INFO) << "CreateImplicitSelectorModalDialog_0001 end";
397 }
398
399 /**
400 * @tc.name: CreateImplicitSelectorModalDialog_0002
401 * @tc.desc: Has APP_LAUNCH_TRUSTLIST
402 * @tc.type: FUNC
403 */
404 HWTEST_F(DialogSessionManagerTest, CreateImplicitSelectorModalDialog_0002, TestSize.Level1)
405 {
406 GTEST_LOG_(INFO) << "CreateImplicitSelectorModalDialog_0002 start";
407 std::string dialogSessionId = "1000001";
408 AbilityRequest abilityRequest;
409 abilityRequest.want.SetParam(TEST_DIALOG_SESSION_ID, dialogSessionId);
410 AAFwk::Want want;
411 int32_t userId = 0;
412 std::vector<DialogAppInfo> dialogAppInfos;
413 abilityRequest.want.SetParam("deviceType", 1);
414 abilityRequest.want.SetParam("userId", userId);
415 std::string mockAction = "mockAction";
416 abilityRequest.want.SetParam("action", mockAction);
417 std::string mockType = "mockType";
418 abilityRequest.want.SetParam("wantType", mockType);
419 std::string mockUri = "mockUri";
420 abilityRequest.want.SetParam("uri", mockUri);
421 std::vector<std::string> mockEntities = {"mockEntities"};
422 abilityRequest.want.SetParam("entities", mockEntities);
423 abilityRequest.want.SetParam("appselector.selectorType", static_cast<int>(SelectorType::IMPLICIT_START_SELECTOR));
424 abilityRequest.want.SetParam("showCaller", false);
425 abilityRequest.want.SetParam(SHOW_DEFAULT_PICKER_FLAG, false);
426 std::vector<std::string> mockTrustlist = {"abc", "bca", "cab"};
427 abilityRequest.want.SetParam(APP_LAUNCH_TRUSTLIST, mockTrustlist);
428
429 std::shared_ptr<DialogCallerInfo> dialogCallerInfo = std::make_shared<DialogCallerInfo>();
430 DialogSessionManager dialogSessionManager;
431 dialogSessionManager.dialogCallerInfoMap_[dialogSessionId] = dialogCallerInfo;
432 auto ret = dialogSessionManager.CreateImplicitSelectorModalDialog(abilityRequest,
433 want, userId, dialogAppInfos, false);
434
435 EXPECT_NE(ret, ERR_INVALID_VALUE);
436 GTEST_LOG_(INFO) << "CreateImplicitSelectorModalDialog_0002 end";
437 }
438 } // namespace AAFwk
439 } // namespace OHOS
440