• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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 /**
17  * @tc.number: SUB_backup_sa_session_GetLastIncrementalTime_0100
18  * @tc.name: SUB_backup_sa_session_GetLastIncrementalTime_0100
19  * @tc.desc: 测试 GetLastIncrementalTime
20  * @tc.size: MEDIUM
21  * @tc.type: FUNC
22  * @tc.level Level 1
23  * @tc.require: I6F3GV
24  */
25 HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_GetLastIncrementalTime_0100, testing::ext::TestSize.Level1)
26 {
27     GTEST_LOG_(INFO) << "SvcSessionManagerTest-begin SUB_backup_sa_session_GetLastIncrementalTime_0100";
28     try {
29         EXPECT_TRUE(sessionManagerPtr_ != nullptr);
30         sessionManagerPtr_->impl_.clientToken = 0;
31         sessionManagerPtr_->GetLastIncrementalTime(BUNDLE_NAME);
32         EXPECT_TRUE(true);
33 
34         sessionManagerPtr_->impl_.clientToken = CLIENT_TOKEN_ID;
35         sessionManagerPtr_->impl_.backupExtNameMap.clear();
36         sessionManagerPtr_->impl_.backupExtNameMap[BUNDLE_NAME] = {};
37         sessionManagerPtr_->GetLastIncrementalTime(BUNDLE_NAME);
38         EXPECT_TRUE(true);
39     } catch (...) {
40         EXPECT_TRUE(false);
41         GTEST_LOG_(INFO) << "SvcSessionManagerTest-an exception occurred by GetLastIncrementalTime.";
42     }
43     GTEST_LOG_(INFO) << "SvcSessionManagerTest-end SUB_backup_sa_session_GetLastIncrementalTime_0100";
44 }
45 
46 /**
47  * @tc.number: SUB_backup_sa_session_DecreaseSessionCnt_0100
48  * @tc.name: SUB_backup_sa_session_DecreaseSessionCnt_0100
49  * @tc.desc: 测试 DecreaseSessionCnt
50  * @tc.size: MEDIUM
51  * @tc.type: FUNC
52  * @tc.level Level 1
53  * @tc.require: I6F3GV
54  */
55 HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_DecreaseSessionCnt_0100, testing::ext::TestSize.Level1)
56 {
57     GTEST_LOG_(INFO) << "SvcSessionManagerTest-begin SUB_backup_sa_session_DecreaseSessionCnt_0100";
58     try {
59         sessionManagerPtr_->DecreaseSessionCnt(__PRETTY_FUNCTION__);
60         EXPECT_TRUE(true);
61     } catch (...) {
62         EXPECT_TRUE(false);
63         GTEST_LOG_(INFO) << "SvcSessionManagerTest-an exception occurred by DecreaseSessionCnt.";
64     }
65     GTEST_LOG_(INFO) << "SvcSessionManagerTest-end SUB_backup_sa_session_DecreaseSessionCnt_0100";
66 }
67 
68 /**
69  * @tc.number: SUB_backup_sa_session_DecreaseSessionCnt_0101
70  * @tc.name: SUB_backup_sa_session_DecreaseSessionCnt_0101
71  * @tc.desc: 测试 DecreaseSessionCnt
72  * @tc.size: MEDIUM
73  * @tc.type: FUNC
74  * @tc.level Level 1
75  * @tc.require: I6F3GV
76  */
77 HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_DecreaseSessionCnt_0101, testing::ext::TestSize.Level1)
78 {
79     GTEST_LOG_(INFO) << "SvcSessionManagerTest-begin SUB_backup_sa_session_DecreaseSessionCnt_0101";
80     try {
81         sessionManagerPtr_->IncreaseSessionCnt(__PRETTY_FUNCTION__);
82         sessionManagerPtr_->DecreaseSessionCnt(__PRETTY_FUNCTION__);
83         EXPECT_TRUE(true);
84     } catch (...) {
85         EXPECT_TRUE(false);
86         GTEST_LOG_(INFO) << "SvcSessionManagerTest-an exception occurred by DecreaseSessionCnt.";
87     }
88     GTEST_LOG_(INFO) << "SvcSessionManagerTest-end SUB_backup_sa_session_DecreaseSessionCnt_0101";
89 }
90 
91 /**
92  * @tc.number: SUB_backup_sa_session_GetServiceSchedAction_0104
93  * @tc.name: SUB_backup_sa_session_GetServiceSchedAction_0104
94  * @tc.desc: 测试 GetServiceSchedAction 获取状态
95  * @tc.size: MEDIUM
96  * @tc.type: FUNC
97  * @tc.level Level 1
98  * @tc.require: I6F3GV
99  */
100 HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_GetServiceSchedAction_0104, testing::ext::TestSize.Level1)
101 {
102     GTEST_LOG_(INFO) << "SvcSessionManagerTest-begin SUB_backup_sa_session_GetServiceSchedAction_0104";
103     try {
104         try {
105             EXPECT_TRUE(sessionManagerPtr_ != nullptr);
106             sessionManagerPtr_->impl_.clientToken = 0;
107             sessionManagerPtr_->GetServiceSchedAction(BUNDLE_NAME);
108             EXPECT_TRUE(true);
109         } catch (BError &err) {
110             EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_INVAL_ARG);
111         }
112     } catch (...) {
113         EXPECT_TRUE(false);
114         GTEST_LOG_(INFO) << "SvcSessionManagerTest-an exception occurred by GetServiceSchedAction.";
115     }
116     GTEST_LOG_(INFO) << "SvcSessionManagerTest-end SUB_backup_sa_session_GetServiceSchedAction_0104";
117 }
118 
119 /**
120  * @tc.number: SUB_backup_sa_session_GetServiceSchedAction_0105
121  * @tc.name: SUB_backup_sa_session_GetServiceSchedAction_0105
122  * @tc.desc: 测试 GetServiceSchedAction 获取状态
123  * @tc.size: MEDIUM
124  * @tc.type: FUNC
125  * @tc.level Level 1
126  * @tc.require: I6F3GV
127  */
128 HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_GetServiceSchedAction_0105, testing::ext::TestSize.Level1)
129 {
130     GTEST_LOG_(INFO) << "SvcSessionManagerTest-begin SUB_backup_sa_session_GetServiceSchedAction_0105";
131     try {
132         try {
133             EXPECT_TRUE(sessionManagerPtr_ != nullptr);
134             sessionManagerPtr_->impl_.clientToken = 0;
135             sessionManagerPtr_->SetServiceSchedAction(BUNDLE_NAME, BConstants::ServiceSchedAction::RUNNING);
136             EXPECT_TRUE(true);
137         } catch (BError &err) {
138             EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_INVAL_ARG);
139         }
140     } catch (...) {
141         EXPECT_TRUE(false);
142         GTEST_LOG_(INFO) << "SvcSessionManagerTest-an exception occurred by GetServiceSchedAction.";
143     }
144     GTEST_LOG_(INFO) << "SvcSessionManagerTest-end SUB_backup_sa_session_GetServiceSchedAction_0105";
145 }
146 
147 /**
148  * @tc.number: SUB_backup_sa_session_CleanAndCheckIfNeedWait_0100
149  * @tc.name: SUB_backup_sa_session_CleanAndCheckIfNeedWait_0100
150  * @tc.desc: 测试 CleanAndCheckIfNeedWait
151  * @tc.size: MEDIUM
152  * @tc.type: FUNC
153  * @tc.level Level 1
154  * @tc.require: I6F3GV
155  */
156 HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_CleanAndCheckIfNeedWait_0100, testing::ext::TestSize.Level1)
157 {
158     GTEST_LOG_(INFO) << "SvcSessionManagerTest-begin SUB_backup_sa_session_CleanAndCheckIfNeedWait_0100";
159     try {
160         ErrCode err;
161         std::vector<std::string> bundleNameList;
162         bundleNameList.push_back(BUNDLE_NAME);
163 
164         sessionManagerPtr_->impl_.clientToken = CLIENT_TOKEN_ID;
165         sessionManagerPtr_->impl_.backupExtNameMap.clear();
166 
167         auto ret = sessionManagerPtr_->CleanAndCheckIfNeedWait(err, bundleNameList);
168         EXPECT_FALSE(ret);
169 
170         sessionManagerPtr_->impl_.backupExtNameMap.clear();
171         sessionManagerPtr_->impl_.backupExtNameMap[BUNDLE_NAME] = {};
172         sessionManagerPtr_->impl_.restoreDataType = RestoreTypeEnum::RESTORE_DATA_READDY;
173         ret = sessionManagerPtr_->CleanAndCheckIfNeedWait(err, bundleNameList);
174         EXPECT_FALSE(ret);
175 
176         sessionManagerPtr_->impl_.backupExtNameMap.clear();
177         sessionManagerPtr_->impl_.backupExtNameMap[BUNDLE_NAME] = {};
178         sessionManagerPtr_->impl_.restoreDataType = RestoreTypeEnum::RESTORE_DATA_WAIT_SEND;
179         ret = sessionManagerPtr_->CleanAndCheckIfNeedWait(err, bundleNameList);
180         EXPECT_FALSE(ret);
181     } catch (...) {
182         EXPECT_TRUE(false);
183         GTEST_LOG_(INFO) << "SvcSessionManagerTest-an exception occurred by CleanAndCheckIfNeedWait.";
184     }
185     GTEST_LOG_(INFO) << "SvcSessionManagerTest-end SUB_backup_sa_session_CleanAndCheckIfNeedWait_0100";
186 }
187 
188 /**
189  * @tc.number: SUB_backup_sa_session_CleanAndCheckIfNeedWait_0200
190  * @tc.name: SUB_backup_sa_session_CleanAndCheckIfNeedWait_0200
191  * @tc.desc: 测试 CleanAndCheckIfNeedWait
192  * @tc.size: MEDIUM
193  * @tc.type: FUNC
194  * @tc.level Level 1
195  * @tc.require: I6F3GV
196  */
197 HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_CleanAndCheckIfNeedWait_0200, testing::ext::TestSize.Level1)
198 {
199     GTEST_LOG_(INFO) << "SvcSessionManagerTest-begin SUB_backup_sa_session_CleanAndCheckIfNeedWait_0200";
200     try {
201         ErrCode err;
202         std::vector<std::string> bundleNameList;
203         bundleNameList.push_back(BUNDLE_NAME);
204 
205         sessionManagerPtr_->impl_.clientToken = CLIENT_TOKEN_ID;
206 
207         BackupExtInfo extInfo {};
208         extInfo.schedAction = BConstants::ServiceSchedAction::WAIT;
209         extInfo.backUpConnection = nullptr;
210         sessionManagerPtr_->impl_.backupExtNameMap.clear();
211         sessionManagerPtr_->impl_.backupExtNameMap[BUNDLE_NAME] = extInfo;
212         auto ret = sessionManagerPtr_->CleanAndCheckIfNeedWait(err, bundleNameList);
213         EXPECT_FALSE(ret);
214 
215         BackupExtInfo extInfo2 {};
216         extInfo2.schedAction = BConstants::ServiceSchedAction::RUNNING;
217         extInfo2.isInPublishFile = true;
218         extInfo2.backUpConnection = nullptr;
219         extInfo2.fwkTimerStatus = true;
220         extInfo2.extTimerStatus = false;
221         sessionManagerPtr_->impl_.backupExtNameMap.clear();
222         sessionManagerPtr_->impl_.backupExtNameMap[BUNDLE_NAME] = extInfo2;
223         ret = sessionManagerPtr_->CleanAndCheckIfNeedWait(err, bundleNameList);
224         EXPECT_TRUE(ret);
225 
226         BackupExtInfo extInfo3 {};
227         extInfo3.schedAction = BConstants::ServiceSchedAction::START;
228         extInfo3.isInPublishFile = true;
229         extInfo3.backUpConnection = nullptr;
230         extInfo3.fwkTimerStatus = true;
231         extInfo3.extTimerStatus = false;
232         sessionManagerPtr_->impl_.backupExtNameMap.clear();
233         sessionManagerPtr_->impl_.backupExtNameMap[BUNDLE_NAME] = extInfo3;
234         ret = sessionManagerPtr_->CleanAndCheckIfNeedWait(err, bundleNameList);
235         EXPECT_FALSE(ret);
236     } catch (...) {
237         EXPECT_TRUE(false);
238         GTEST_LOG_(INFO) << "SvcSessionManagerTest-an exception occurred by CleanAndCheckIfNeedWait.";
239     }
240     GTEST_LOG_(INFO) << "SvcSessionManagerTest-end SUB_backup_sa_session_CleanAndCheckIfNeedWait_0200";
241 }
242 
243 /**
244  * @tc.number: SUB_backup_sa_session_CleanAndCheckIfNeedWait_0300
245  * @tc.name: SUB_backup_sa_session_CleanAndCheckIfNeedWait_0300
246  * @tc.desc: 测试 CleanAndCheckIfNeedWait
247  * @tc.size: MEDIUM
248  * @tc.type: FUNC
249  * @tc.level Level 1
250  * @tc.require: I6F3GV
251  */
252 HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_CleanAndCheckIfNeedWait_0300, testing::ext::TestSize.Level1)
253 {
254     GTEST_LOG_(INFO) << "SvcSessionManagerTest-begin SUB_backup_sa_session_CleanAndCheckIfNeedWait_0300";
255     try {
256         ErrCode err;
257         std::vector<std::string> bundleNameList;
258         bundleNameList.push_back(BUNDLE_NAME);
259 
260         sessionManagerPtr_->impl_.clientToken = CLIENT_TOKEN_ID;
261 
262         BackupExtInfo extInfo {};
263         extInfo.schedAction = BConstants::ServiceSchedAction::WAIT;
264         extInfo.backUpConnection = sptr(new SvcBackupConnection(nullptr, nullptr, BUNDLE_NAME));;
265         sessionManagerPtr_->impl_.backupExtNameMap.clear();
266         sessionManagerPtr_->impl_.backupExtNameMap[BUNDLE_NAME] = extInfo;
267         auto ret = sessionManagerPtr_->CleanAndCheckIfNeedWait(err, bundleNameList);
268         EXPECT_FALSE(ret);
269 
270         BackupExtInfo extInfo2 {};
271         extInfo2.schedAction = BConstants::ServiceSchedAction::RUNNING;
272         extInfo2.isInPublishFile = true;
273         extInfo2.backUpConnection = sptr(new SvcBackupConnection(nullptr, nullptr, BUNDLE_NAME));;
274         extInfo2.fwkTimerStatus = true;
275         extInfo2.extTimerStatus = false;
276         sessionManagerPtr_->impl_.backupExtNameMap.clear();
277         sessionManagerPtr_->impl_.backupExtNameMap[BUNDLE_NAME] = extInfo2;
278         ret = sessionManagerPtr_->CleanAndCheckIfNeedWait(err, bundleNameList);
279         EXPECT_TRUE(ret);
280 
281         BackupExtInfo extInfo3 {};
282         extInfo3.schedAction = BConstants::ServiceSchedAction::START;
283         extInfo3.isInPublishFile = true;
284         extInfo3.backUpConnection = sptr(new SvcBackupConnection(nullptr, nullptr, BUNDLE_NAME));;
285         extInfo3.fwkTimerStatus = true;
286         extInfo3.extTimerStatus = false;
287         sessionManagerPtr_->impl_.backupExtNameMap.clear();
288         sessionManagerPtr_->impl_.backupExtNameMap[BUNDLE_NAME] = extInfo3;
289         ret = sessionManagerPtr_->CleanAndCheckIfNeedWait(err, bundleNameList);
290         EXPECT_FALSE(ret);
291     } catch (...) {
292         EXPECT_TRUE(false);
293         GTEST_LOG_(INFO) << "SvcSessionManagerTest-an exception occurred by CleanAndCheckIfNeedWait.";
294     }
295     GTEST_LOG_(INFO) << "SvcSessionManagerTest-end SUB_backup_sa_session_CleanAndCheckIfNeedWait_0300";
296 }
297 
298 /**
299  * @tc.number: SUB_backup_sa_session_HandleOnRelease_0100
300  * @tc.name: SUB_backup_sa_session_HandleOnRelease_0100
301  * @tc.desc: 测试 HandleOnRelease
302  * @tc.size: MEDIUM
303  * @tc.type: FUNC
304  * @tc.level Level 1
305  * @tc.require: I6F3GV
306  */
307 HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_HandleOnRelease_0100, testing::ext::TestSize.Level1)
308 {
309     GTEST_LOG_(INFO) << "SvcSessionManagerTest-begin SUB_backup_sa_session_HandleOnRelease_0100";
310     try {
311         sptr<SvcExtensionProxyMock> svcProxy = nullptr;
312         sessionManagerPtr_->HandleOnRelease(svcProxy);
313 
314         svcProxy = sptr(new SvcExtensionProxyMock());
315         EXPECT_NE(svcProxy, nullptr);
316         sessionManagerPtr_->impl_.scenario = IServiceReverseType::Scenario::UNDEFINED;
317         sessionManagerPtr_->HandleOnRelease(svcProxy);
318 
319         sessionManagerPtr_->impl_.scenario = IServiceReverseType::Scenario::CLEAN;
320         sessionManagerPtr_->HandleOnRelease(svcProxy);
321 
322         sessionManagerPtr_->impl_.scenario = IServiceReverseType::Scenario::BACKUP;
323         sessionManagerPtr_->HandleOnRelease(svcProxy);
324     } catch (...) {
325         EXPECT_TRUE(false);
326         GTEST_LOG_(INFO) << "SvcSessionManagerTest-an exception occurred by HandleOnRelease.";
327     }
328     GTEST_LOG_(INFO) << "SvcSessionManagerTest-end SUB_backup_sa_session_HandleOnRelease_0100";
329 }
330 
331 /**
332  * @tc.number: SUB_backup_sa_session_SetIsRestoreEnd_0100
333  * @tc.name: SUB_backup_sa_session_SetIsRestoreEnd_0100
334  * @tc.desc: 测试 SetIsRestoreEnd
335  * @tc.size: MEDIUM
336  * @tc.type: FUNC
337  * @tc.level Level 1
338  * @tc.require: I6F3GV
339  */
340 HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_SetIsRestoreEnd_0100, testing::ext::TestSize.Level1)
341 {
342     GTEST_LOG_(INFO) << "SvcSessionManagerTest-begin SUB_backup_sa_session_SetIsRestoreEnd_0100";
343     try {
344         std::string bundleName = "com.test.bundleName";
345         sessionManagerPtr_->impl_.clientToken = 0;
346         sessionManagerPtr_->impl_.backupExtNameMap.clear();
347         sessionManagerPtr_->SetIsRestoreEnd(bundleName);
348         EXPECT_EQ(sessionManagerPtr_->impl_.backupExtNameMap.find(bundleName),
349             sessionManagerPtr_->impl_.backupExtNameMap.end());
350 
351         sessionManagerPtr_->impl_.clientToken = CLIENT_TOKEN_ID;
352         sessionManagerPtr_->SetIsRestoreEnd(bundleName);
353         EXPECT_EQ(sessionManagerPtr_->impl_.backupExtNameMap.find(bundleName),
354             sessionManagerPtr_->impl_.backupExtNameMap.end());
355 
356         BackupExtInfo backupInfo {};
357         sessionManagerPtr_->impl_.backupExtNameMap[bundleName] = backupInfo;
358         EXPECT_NE(sessionManagerPtr_->impl_.backupExtNameMap.find(bundleName),
359             sessionManagerPtr_->impl_.backupExtNameMap.end());
360         sessionManagerPtr_->SetIsRestoreEnd(bundleName);
361         bool ret = sessionManagerPtr_->impl_.backupExtNameMap[bundleName].isRestoreEnd;
362         EXPECT_TRUE(ret);
363     } catch (...) {
364         EXPECT_TRUE(false);
365         GTEST_LOG_(INFO) << "SvcSessionManagerTest-an exception occurred by SetIsRestoreEnd.";
366     }
367     GTEST_LOG_(INFO) << "SvcSessionManagerTest-end SUB_backup_sa_session_SetIsRestoreEnd_0100";
368 }
369 
370 /**
371  * @tc.number: SUB_backup_sa_session_GetIsRestoreEnd_0100
372  * @tc.name: SUB_backup_sa_session_GetIsRestoreEnd_0100
373  * @tc.desc: 测试 GetIsRestoreEnd
374  * @tc.size: MEDIUM
375  * @tc.type: FUNC
376  * @tc.level Level 1
377  * @tc.require: I6F3GV
378  */
379 HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_GetIsRestoreEnd_0100, testing::ext::TestSize.Level1)
380 {
381     GTEST_LOG_(INFO) << "SvcSessionManagerTest-begin SUB_backup_sa_session_GetIsRestoreEnd_0100";
382     try {
383         std::string bundleName = "com.test.bundleName";
384         sessionManagerPtr_->impl_.clientToken = 0;
385         sessionManagerPtr_->impl_.backupExtNameMap.clear();
386         auto ret = sessionManagerPtr_->GetIsRestoreEnd(bundleName);
387         EXPECT_FALSE(ret);
388 
389         sessionManagerPtr_->impl_.clientToken = CLIENT_TOKEN_ID;
390         ret = sessionManagerPtr_->GetIsRestoreEnd(bundleName);
391         EXPECT_FALSE(ret);
392 
393         BackupExtInfo backupInfo {};
394         backupInfo.isRestoreEnd = true;
395         sessionManagerPtr_->impl_.backupExtNameMap[bundleName] = backupInfo;
396         EXPECT_NE(sessionManagerPtr_->impl_.backupExtNameMap.find(bundleName),
397             sessionManagerPtr_->impl_.backupExtNameMap.end());
398         ret = sessionManagerPtr_->GetIsRestoreEnd(bundleName);
399         EXPECT_TRUE(ret);
400     } catch (...) {
401         EXPECT_TRUE(false);
402         GTEST_LOG_(INFO) << "SvcSessionManagerTest-an exception occurred by GetIsRestoreEnd.";
403     }
404     GTEST_LOG_(INFO) << "SvcSessionManagerTest-end SUB_backup_sa_session_GetIsRestoreEnd_0100";
405 }