1 /*
2 * Copyright (c) 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 #include <regex>
18 #include <bundle_mgr_interface.h>
19 #include <bundlemgr/launcher_service.h>
20
21 #include "common_test_utils.h"
22 #include "context.h"
23 #include "interfaces/include/ws_common.h"
24 #include "iremote_object_mocker.h"
25 #include "mock/mock_session_stage.h"
26 #include "mock/mock_scene_session.h"
27 #include "mock/mock_window_event_channel.h"
28 #include "mock/mock_accesstoken_kit.h"
29 #include "session_info.h"
30 #include "session_manager.h"
31 #include "session_manager/include/scene_session_manager.h"
32 #include "session/host/include/scene_session.h"
33 #include "session/host/include/main_session.h"
34 #include "window_manager_agent.h"
35 #include "zidl/window_manager_agent_interface.h"
36 #include "mock/mock_window_manager_agent_lite.h"
37 #include "session_manager/include/session_manager_agent_controller.h"
38
39 using namespace testing;
40 using namespace testing::ext;
41
42 namespace OHOS {
43 namespace Rosen {
44 class SceneSessionManagerKioskTest : public testing::Test {
45 public:
46 static void SetUpTestCase();
47 static void TearDownTestCase();
48 void SetUp() override;
49 void TearDown() override;
50
51 static sptr<SceneSessionManager> ssm_;
52
53 private:
54 static constexpr uint32_t WAIT_SYNC_IN_NS = 200000;
55 };
56
57 sptr<SceneSessionManager> SceneSessionManagerKioskTest::ssm_ = nullptr;
58
SetUpTestCase()59 void SceneSessionManagerKioskTest::SetUpTestCase()
60 {
61 ssm_ = &SceneSessionManager::GetInstance();
62 }
63
TearDownTestCase()64 void SceneSessionManagerKioskTest::TearDownTestCase()
65 {
66 ssm_ = nullptr;
67 }
68
SetUp()69 void SceneSessionManagerKioskTest::SetUp() {}
70
TearDown()71 void SceneSessionManagerKioskTest::TearDown()
72 {
73 usleep(WAIT_SYNC_IN_NS);
74 }
75
76 namespace {
77 /**
78 * @tc.name : ExitKioskMode_ShouleReturnInvalidPermission_WhenCalledByNonSystemApp
79 * @tc.number: ExitKioskModeTest_001
80 * @tc.desc : When a non-system application calls ExitKioskMode, it should return WM_ERROR_INVALID_PERMISSION.
81 */
82 HWTEST_F(SceneSessionManagerKioskTest,
83 ATC_ExitKioskMode_ShouleReturnInvalidPermission_WhenCalledByNonSystemApp, TestSize.Level0)
84 {
85 MockAccesstokenKit::MockIsSystemApp(false);
86 MockAccesstokenKit::MockIsSACalling(false);
87 WMError result = ssm_->ExitKioskMode();
88 EXPECT_EQ(result, WMError::WM_ERROR_INVALID_PERMISSION);
89 }
90
91 /**
92 * @tc.name : ExitKioskMode_ShouldCallKioskModeChangeFunc_WhenKioskModeChangeFuncIsNotNull
93 * @tc.number: ExitKioskModeTest_002
94 * @tc.desc : When kioskModeChangeFunc_ is not empty, it should be called and WM_OK should be returned.
95 */
96 HWTEST_F(SceneSessionManagerKioskTest,
97 ATC_ExitKioskMode_ShouldCallKioskModeChangeFunc_WhenKioskModeChangeFuncIsNotNull, TestSize.Level0)
98 {
99 MockAccesstokenKit::MockIsSystemApp(false);
100 MockAccesstokenKit::MockIsSACalling(true);
__anon23781b060202(bool mode, int sessionId) 101 ssm_->kioskModeChangeFunc_ = [](bool mode, int sessionId) {
102 return WMError::WM_OK;
103 };
104 WMError result = ssm_->ExitKioskMode();
105 EXPECT_EQ(result, WMError::WM_OK);
106 }
107
108 /**
109 * @tc.name : ExitKioskMode_ShouldCallKioskModeChangeFunc_WhenKioskModeChangeFuncIsNull
110 * @tc.number: ExitKioskModeTest_003
111 * @tc.desc : When kioskModeChangeFunc_ is empty, isKioskMode_ should be set and WM_OK should be returned.
112 */
113 HWTEST_F(SceneSessionManagerKioskTest,
114 ATC_ExitKioskMode_ShouldCallKioskModeChangeFunc_WhenKioskModeChangeFuncIsNull, TestSize.Level0)
115 {
116 MockAccesstokenKit::MockIsSystemApp(true);
117 MockAccesstokenKit::MockIsSACalling(true);
118 ssm_->kioskModeChangeFunc_ = nullptr;
119 WMError result = ssm_->ExitKioskMode();
120 EXPECT_EQ(result, WMError::WM_OK);
121 EXPECT_FALSE(ssm_->isKioskMode_);
122 EXPECT_EQ(ssm_->kioskAppPersistentId_, INVALID_SESSION_ID);
123 }
124
125 /**
126 * @tc.name : EnterKioskMode_ShouldReturnInvalidPermission_WhenCalledByNonSystemOrSA
127 * @tc.number: EnterKioskMode_001
128 * @tc.desc : When the caller is not a system application or SA, it should return WM_ERROR_INVALID_PERMISSION
129 */
130 HWTEST_F(SceneSessionManagerKioskTest,
131 ATC_EnterKioskMode_ShouldReturnInvalidPermission_WhenCalledByNonSystemOrSA, TestSize.Level0)
132 {
133 MockAccesstokenKit::MockIsSystemApp(false);
134 MockAccesstokenKit::MockIsSACalling(false);
135 sptr<IRemoteObject> token = new MockIRemoteObject();
136 EXPECT_EQ(ssm_->EnterKioskMode(token), WMError::WM_ERROR_INVALID_PERMISSION);
137 }
138
139 /**
140 * @tc.name : EnterKioskMode_ShouldReturnInvalidParam_WhenSessionNotFound
141 * @tc.number: EnterKioskMode_002
142 * @tc.desc : When the corresponding session cannot be found, EnterKioskMode should return WM_ERROR_INVALID_PARAM
143 */
144 HWTEST_F(SceneSessionManagerKioskTest,
145 ATC_EnterKioskMode_ShouldReturnInvalidParam_WhenSessionNotFound, TestSize.Level0)
146 {
147 MockAccesstokenKit::MockIsSystemApp(true);
148 MockAccesstokenKit::MockIsSACalling(false);
149 sptr<IRemoteObject> token = new MockIRemoteObject();
150 EXPECT_EQ(ssm_->EnterKioskMode(token), WMError::WM_ERROR_INVALID_PARAM);
151 }
152
153 /**
154 * @tc.name : EnterKioskMode_ShouldCallKioskModeChangeFunc_WhenKioskModeChangeFuncIsNotNull
155 * @tc.number: EnterKioskMode_003
156 * @tc.desc : Test when kioskModeChangeFunc_ is not empty, EnterKioskMode should call func and return WM_OK
157 */
158 HWTEST_F(SceneSessionManagerKioskTest,
159 ATC_EnterKioskMode_ShouldCallKioskModeChangeFunc_WhenKioskModeChangeFuncIsNotNull, TestSize.Level0)
160 {
161 MockAccesstokenKit::MockIsSystemApp(false);
162 MockAccesstokenKit::MockIsSACalling(true);
163 SessionInfo info;
164 info.persistentId_ = 101;
165 sptr<SceneSession> session = sptr<MainSession>::MakeSptr(info, nullptr);
166 session->property_->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
__anon23781b060302(bool, uint64_t) 167 ssm_->kioskModeChangeFunc_ = [](bool, uint64_t) {};
168 sptr<IRemoteObject> token = new MockIRemoteObject();
169 session->SetAbilityToken(token);
170 ssm_->sceneSessionMap_[101] = session;
171 EXPECT_EQ(ssm_->EnterKioskMode(token), WMError::WM_OK);
172 }
173
174 /**
175 * @tc.name : EnterKioskMode_ShouldSetKioskModeAndPersistentId_WhenKioskModeChangeFuncIsNull
176 * @tc.number: EnterKioskMode_004
177 * @tc.desc : Test that when kioskModeChangeFun_ is empty, EnterKioskMode should set isKioskMode_ and return WM_OK
178 */
179 HWTEST_F(SceneSessionManagerKioskTest,
180 ATC_EnterKioskMode_ShouldSetKioskModeAndPersistentId_WhenKioskModeChangeFuncIsNull, TestSize.Level0)
181 {
182 MockAccesstokenKit::MockIsSystemApp(true);
183 MockAccesstokenKit::MockIsSACalling(true);
184 SessionInfo info;
185 info.persistentId_ = 101;
186 sptr<SceneSession> session = sptr<MainSession>::MakeSptr(info, nullptr);
187 session->property_->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
188 ssm_->kioskModeChangeFunc_ = nullptr;
189 sptr<IRemoteObject> token = new MockIRemoteObject();
190 session->SetAbilityToken(token);
191 ssm_->sceneSessionMap_[101] = session;
192 EXPECT_EQ(ssm_->EnterKioskMode(token), WMError::WM_OK);
193 EXPECT_TRUE(ssm_->isKioskMode_);
194 EXPECT_EQ(ssm_->kioskAppPersistentId_, session->GetPersistentId());
195 }
196
197 /**
198 * @tc.name : UpdateKioskAppList_ShouldReturnInvalidPermission_WhenCalledByNonSystemOrSA
199 * @tc.number: UpdateKioskAppList_001
200 * @tc.desc : when the caller is not a system application or SA, it should return WM_ERROR_INVALID_PERMISSION
201 */
202 HWTEST_F(SceneSessionManagerKioskTest,
203 ATC_UpdateKioskAppList_ShouldReturnInvalidPermission_WhenCalledByNonSystemOrSA, TestSize.Level0)
204 {
205 MockAccesstokenKit::MockIsSystemApp(false);
206 MockAccesstokenKit::MockIsSACalling(false);
207 std::vector<std::string> kioskAppList = {"app1", "app2"};
208 WMError result = ssm_->UpdateKioskAppList(kioskAppList);
209 EXPECT_EQ(result, WMError::WM_ERROR_INVALID_PERMISSION);
210 }
211
212 /**
213 * @tc.name : UpdateKioskAppList_ShouldReturnInvalidParam_WhenKioskAppListIsEmpty
214 * @tc.number: UpdateKioskAppList_002
215 * @tc.desc : Test: When the passed kioskAppList is empty, UpdateKioskAppList should return WM_ERROR_INVALID_PARAM
216 */
217 HWTEST_F(SceneSessionManagerKioskTest,
218 ATC_UpdateKioskAppList_ShouldReturnInvalidParam_WhenKioskAppListIsEmpty, TestSize.Level0)
219 {
220 MockAccesstokenKit::MockIsSystemApp(true);
221 MockAccesstokenKit::MockIsSACalling(true);
222 std::vector<std::string> kioskAppList = {};
223 WMError result = ssm_->UpdateKioskAppList(kioskAppList);
224 EXPECT_EQ(result, WMError::WM_ERROR_INVALID_PARAM);
225 }
226
227 /**
228 * @tc.name : UpdateKioskAppList_ShouldCallUpdateKioskAppListFunc_WhenUpdateKioskAppListFuncIsNotNull
229 * @tc.number: UpdateKioskAppList_003
230 * @tc.desc : When updateKioskAppListFun_ is not empty, UpdateKioskAppList should call updateKisokAppListFunc_
231 */
232 HWTEST_F(SceneSessionManagerKioskTest,
233 ATC_UpdateKioskAppList_ShouldCallUpdateKioskAppListFunc_WhenUpdateKioskAppListFuncIsNotNull, TestSize.Level0)
234 {
235 MockAccesstokenKit::MockIsSystemApp(false);
236 MockAccesstokenKit::MockIsSACalling(true);
__anon23781b060402(const std::vector<std::string>& kioskAppList) 237 ssm_->updateKioskAppListFunc_ = [](const std::vector<std::string>& kioskAppList) {
238 return WMError::WM_OK;
239 };
240 std::vector<std::string> kioskAppList = {"app1", "app2"};
241 WMError result = ssm_->UpdateKioskAppList(kioskAppList);
242 EXPECT_EQ(result, WMError::WM_OK);
243 }
244
245 /**
246 * @tc.name : UpdateKioskAppList_ShouldCacheKioskAppList_WhenUpdateKioskAppListFuncIsNull
247 * @tc.number: UpdateKioskAppList_004
248 * @tc.desc : When updateKioskAppListFun_ is empty, UpdateKioskAppList should cache kioskAppList to kioskAppListCache_
249 */
250 HWTEST_F(SceneSessionManagerKioskTest,
251 ATC_UpdateKioskAppList_ShouldCacheKioskAppList_WhenUpdateKioskAppListFuncIsNull, TestSize.Level0)
252 {
253 MockAccesstokenKit::MockIsSystemApp(true);
254 MockAccesstokenKit::MockIsSACalling(false);
255 ssm_->updateKioskAppListFunc_ = nullptr;
256 std::vector<std::string> kioskAppList = {"app1", "app2"};
257 WMError result = ssm_->UpdateKioskAppList(kioskAppList);
258 usleep(WAIT_SYNC_IN_NS);
259 EXPECT_EQ(result, WMError::WM_OK);
260 EXPECT_EQ(ssm_->kioskAppListCache_.size(), kioskAppList.size());
261 }
262
263 /**
264 * @tc.name : RegisterUpdateKioskAppListCallback_ShouldRegisterCallBack_WhenFuncProvided
265 * @tc.number: RegisterUpdateKioskAppListCallbackTest_001
266 * @tc.desc : Test when providing a callback function, RegisterUpdateKioskAppListCallback should succeed
267 */
268 HWTEST_F(SceneSessionManagerKioskTest,
269 ATC_RegisterUpdateKioskAppListCallback_ShouldRegisterCallBack_WhenFuncProvided, TestSize.Level0)
270 {
__anon23781b060502(const std::vector<std::string>& appList) 271 auto mockFunc = [](const std::vector<std::string>& appList) {};
272 ssm_->RegisterUpdateKioskAppListCallback(std::move(mockFunc));
273 usleep(WAIT_SYNC_IN_NS);
274 EXPECT_TRUE(ssm_->updateKioskAppListFunc_ != nullptr);
275 }
276
277 /**
278 * @tc.name : RegisterUpdateKioskAppListCallback_ShouldCallCallback_WhenKioskAppListCacheNotEmpty
279 * @tc.number: RegisterUpdateKioskAppListCallbackTest_002
280 * @tc.desc : Test when kioskAppListCache_ is not null, callback function should be called
281 */
282 HWTEST_F(SceneSessionManagerKioskTest,
283 ATC_RegisterUpdateKioskAppListCallback_ShouldCallCallback_WhenKioskAppListCacheNotEmpty, TestSize.Level0)
284 {
285 bool callbackCalled = false;
__anon23781b060602(const std::vector<std::string>& appList) 286 auto mockFunc = [&callbackCalled](const std::vector<std::string>& appList) {
287 callbackCalled = true;
288 };
289 ssm_->kioskAppListCache_.push_back("app1");
290 ssm_->kioskAppListCache_.push_back("app2");
291 ssm_->RegisterUpdateKioskAppListCallback(std::move(mockFunc));
292 usleep(WAIT_SYNC_IN_NS);
293 EXPECT_EQ(callbackCalled, true);
294 }
295
296 /**
297 * @tc.name : RegisterKioskModeChangeCallback_ShouldCallCallback_WhenValidFuncIsProvided
298 * @tc.number: RegisterKioskModeChangeCallbackTest_001
299 * @tc.desc : 测试在传入有效回调函数时，函数是否被正确调用
300 */
301 HWTEST_F(SceneSessionManagerKioskTest,
302 ATC_RegisterKioskModeChangeCallback_ShouldCallCallback_WhenValidFuncIsProvided, TestSize.Level0)
303 {
304 ssm_->isKioskMode_ = false;
__anon23781b060702(bool isKioskMode, int32_t kioskAppPersistentId) 305 auto callback = [](bool isKioskMode, int32_t kioskAppPersistentId) {
306 EXPECT_FALSE(isKioskMode);
307 };
308 ssm_->RegisterKioskModeChangeCallback(std::move(callback));
309 usleep(WAIT_SYNC_IN_NS);
310 EXPECT_TRUE(ssm_->kioskModeChangeFunc_ != nullptr);
311 }
312 }
313 }
314 }