1 /*
2 * Copyright (c) 2021-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 "reminder_agent_service.h"
18
19 #include "accesstoken_kit.h"
20 #include "ans_inner_errors.h"
21 #include "reminder_request.h"
22 #include "reminder_data_manager.h"
23 #include "reminder_request_alarm.h"
24 #include "reminder_request_timer.h"
25 #include "reminder_request_calendar.h"
26
27 #include "mock_accesstoken_kit.h"
28 #include "mock_os_account_manager.h"
29 #include "mock_notification_helper.h"
30 #include "mock_reminder_data_manager.h"
31 #include "mock_reminder_bundle_manager_helper.h"
32
33 #include <chrono>
34 #include <thread>
35
36 using namespace testing::ext;
37
38 namespace OHOS::Notification {
39 class ReminderAgentServiceTest : public testing::Test {
40 public:
41 static void SetUpTestCase();
42 static void TearDownTestCase();
SetUp()43 void SetUp() {}
TearDown()44 void TearDown() {}
45
46 private:
47 static sptr<ReminderAgentService> reminderAgentService_;
48 };
49
50 sptr<ReminderAgentService> ReminderAgentServiceTest::reminderAgentService_ = nullptr;
51
SetUpTestCase()52 void ReminderAgentServiceTest::SetUpTestCase()
53 {
54 reminderAgentService_ = new (std::nothrow) ReminderAgentService();
55 }
56
TearDownTestCase()57 void ReminderAgentServiceTest::TearDownTestCase()
58 {
59 std::this_thread::sleep_for(std::chrono::seconds(1));
60 reminderAgentService_ = nullptr;
61 }
62
63 /**
64 * @tc.name: ReminderAgentServiceTest_001
65 * @tc.desc: Test GetInstance function
66 * @tc.type: FUNC
67 * @tc.require: issueI5S4VP
68 */
69 HWTEST_F(ReminderAgentServiceTest, ReminderAgentServiceTest_001, Function | SmallTest | Level1)
70 {
71 EXPECT_NE(ReminderAgentService::GetInstance(), nullptr);
72 EXPECT_NE(ReminderAgentService::GetInstance(), nullptr);
73 }
74
75 /**
76 * @tc.name: ReminderAgentServiceTest_002
77 * @tc.desc: Test PublishReminder function
78 * @tc.type: FUNC
79 * @tc.require: issueI5S4VP
80 */
81 HWTEST_F(ReminderAgentServiceTest, ReminderAgentServiceTest_002, Function | SmallTest | Level1)
82 {
83 // test CreateReminderRequest
84 int32_t reminderId = 0;
85 ReminderRequest reminder;
86 EXPECT_EQ(reminderAgentService_->PublishReminder(reminder, reminderId), ERR_REMINDER_INVALID_PARAM);
87
88 // test CheckReminderPermission
89 MockAccesstokenKit::MockIsVerifyPermisson(false);
90 ReminderRequestAlarm alarm;
91 EXPECT_EQ(reminderAgentService_->PublishReminder(alarm, reminderId), ERR_REMINDER_PERMISSION_DENIED);
92 MockAccesstokenKit::MockIsVerifyPermisson(true);
93
94 // test AllowUseReminder
95 MockNotificationHelper::MockIsAllowUseReminder(false);
96 EXPECT_EQ(reminderAgentService_->PublishReminder(alarm, reminderId), ERR_REMINDER_NUMBER_OVERLOAD);
97 MockNotificationHelper::MockIsAllowUseReminder(true);
98
99 // test InitReminderRequest
100 auto wantInfo = alarm.GetMaxScreenWantAgentInfo();
101 alarm.SetMaxScreenWantAgentInfo(nullptr);
102 EXPECT_EQ(reminderAgentService_->PublishReminder(alarm, reminderId), ERR_REMINDER_INVALID_PARAM);
103 alarm.SetMaxScreenWantAgentInfo(wantInfo);
104
105 // test IsSystemApp and IsAllowedNotify
106 alarm.SetSystemApp(false);
107 MockNotificationHelper::MockIsAllowedNotify(false, 1);
108 EXPECT_EQ(reminderAgentService_->PublishReminder(alarm, reminderId), ERR_REMINDER_NOTIFICATION_NOT_ENABLE);
109 MockNotificationHelper::MockIsAllowedNotify(false, 0);
110 EXPECT_EQ(reminderAgentService_->PublishReminder(alarm, reminderId), ERR_REMINDER_NOTIFICATION_NOT_ENABLE);
111 MockNotificationHelper::MockIsAllowedNotify(true, 0);
112
113 // test ReminderDataManager::GetInstance()
114 ReminderDataManager::REMINDER_DATA_MANAGER = nullptr;
115 EXPECT_EQ(reminderAgentService_->PublishReminder(alarm, reminderId), ERR_NO_INIT);
116 alarm.SetSystemApp(true);
117 EXPECT_EQ(reminderAgentService_->PublishReminder(alarm, reminderId), ERR_NO_INIT);
118 ReminderDataManager::InitInstance();
119
120 // test ReminderDataManager::PublishReminder
121 MockReminderDataManager::MockPublishReminder(1);
122 EXPECT_EQ(reminderAgentService_->PublishReminder(alarm, reminderId), 1);
123 MockReminderDataManager::MockPublishReminder(0);
124 EXPECT_EQ(reminderAgentService_->PublishReminder(alarm, reminderId), 0);
125 }
126
127 /**
128 * @tc.name: ReminderAgentServiceTest_003
129 * @tc.desc: Test CancelReminder function
130 * @tc.type: FUNC
131 * @tc.require: issueI5S4VP
132 */
133 HWTEST_F(ReminderAgentServiceTest, ReminderAgentServiceTest_003, Function | SmallTest | Level1)
134 {
135 // test CheckReminderPermission
136 MockAccesstokenKit::MockIsVerifyPermisson(false);
137 EXPECT_EQ(reminderAgentService_->CancelReminder(0), ERR_REMINDER_PERMISSION_DENIED);
138 MockAccesstokenKit::MockIsVerifyPermisson(true);
139
140 // test ReminderDataManager::GetInstance()
141 ReminderDataManager::REMINDER_DATA_MANAGER = nullptr;
142 EXPECT_EQ(reminderAgentService_->CancelReminder(0), ERR_NO_INIT);
143 ReminderDataManager::InitInstance();
144
145 // test ReminderDataManager::CancelReminder
146 MockReminderDataManager::MockCancelReminder(1);
147 EXPECT_EQ(reminderAgentService_->CancelReminder(0), 1);
148 MockReminderDataManager::MockCancelReminder(0);
149 EXPECT_EQ(reminderAgentService_->CancelReminder(0), 0);
150 }
151
152 /**
153 * @tc.name: ReminderAgentServiceTest_004
154 * @tc.desc: Test CancelAllReminders function
155 * @tc.type: FUNC
156 * @tc.require: issueI5S4VP
157 */
158 HWTEST_F(ReminderAgentServiceTest, ReminderAgentServiceTest_004, Function | SmallTest | Level1)
159 {
160 // test CheckReminderPermission
161 MockAccesstokenKit::MockIsVerifyPermisson(false);
162 EXPECT_EQ(reminderAgentService_->CancelAllReminders(), ERR_REMINDER_PERMISSION_DENIED);
163 MockAccesstokenKit::MockIsVerifyPermisson(true);
164
165 // test ReminderDataManager::GetInstance()
166 ReminderDataManager::REMINDER_DATA_MANAGER = nullptr;
167 EXPECT_EQ(reminderAgentService_->CancelAllReminders(), ERR_NO_INIT);
168 ReminderDataManager::InitInstance();
169
170 // test ReminderDataManager::CancelAllReminders
171 MockReminderDataManager::MockCancelAllReminders(1);
172 EXPECT_EQ(reminderAgentService_->CancelAllReminders(), 1);
173 MockReminderDataManager::MockCancelAllReminders(0);
174 EXPECT_EQ(reminderAgentService_->CancelAllReminders(), 0);
175 }
176
177 /**
178 * @tc.name: ReminderAgentServiceTest_005
179 * @tc.desc: Test GetValidReminders function
180 * @tc.type: FUNC
181 * @tc.require: issueI5S4VP
182 */
183 HWTEST_F(ReminderAgentServiceTest, ReminderAgentServiceTest_005, Function | SmallTest | Level1)
184 {
185 // test CheckReminderPermission
186 std::vector<ReminderRequestAdaptation> reminders;
187 MockAccesstokenKit::MockIsVerifyPermisson(false);
188 EXPECT_EQ(reminderAgentService_->GetValidReminders(reminders), ERR_REMINDER_PERMISSION_DENIED);
189 MockAccesstokenKit::MockIsVerifyPermisson(true);
190
191 // test ReminderDataManager::GetInstance()
192 ReminderDataManager::REMINDER_DATA_MANAGER = nullptr;
193 EXPECT_EQ(reminderAgentService_->GetValidReminders(reminders), ERR_NO_INIT);
194 ReminderDataManager::InitInstance();
195
196 // test ReminderDataManager::GetValidReminders
197 EXPECT_EQ(reminderAgentService_->GetValidReminders(reminders), ERR_OK);
198 }
199
200 /**
201 * @tc.name: ReminderAgentServiceTest_006
202 * @tc.desc: Test AddExcludeDate function
203 * @tc.type: FUNC
204 * @tc.require: issueI5S4VP
205 */
206 HWTEST_F(ReminderAgentServiceTest, ReminderAgentServiceTest_006, Function | SmallTest | Level1)
207 {
208 // test CheckReminderPermission
209 MockAccesstokenKit::MockIsVerifyPermisson(false);
210 EXPECT_EQ(reminderAgentService_->AddExcludeDate(0, 0), ERR_REMINDER_PERMISSION_DENIED);
211 MockAccesstokenKit::MockIsVerifyPermisson(true);
212
213 // test ReminderDataManager::GetInstance()
214 ReminderDataManager::REMINDER_DATA_MANAGER = nullptr;
215 EXPECT_EQ(reminderAgentService_->AddExcludeDate(0, 0), ERR_NO_INIT);
216 ReminderDataManager::InitInstance();
217
218 // test ReminderDataManager::AddExcludeDate
219 MockReminderDataManager::MockAddExcludeDate(1);
220 EXPECT_EQ(reminderAgentService_->AddExcludeDate(0, 0), 1);
221 MockReminderDataManager::MockAddExcludeDate(0);
222 EXPECT_EQ(reminderAgentService_->AddExcludeDate(0, 0), 0);
223 }
224
225 /**
226 * @tc.name: ReminderAgentServiceTest_007
227 * @tc.desc: Test DelExcludeDates function
228 * @tc.type: FUNC
229 * @tc.require: issueI5S4VP
230 */
231 HWTEST_F(ReminderAgentServiceTest, ReminderAgentServiceTest_007, Function | SmallTest | Level1)
232 {
233 // test CheckReminderPermission
234 MockAccesstokenKit::MockIsVerifyPermisson(false);
235 EXPECT_EQ(reminderAgentService_->DelExcludeDates(0), ERR_REMINDER_PERMISSION_DENIED);
236 MockAccesstokenKit::MockIsVerifyPermisson(true);
237
238 // test ReminderDataManager::GetInstance()
239 ReminderDataManager::REMINDER_DATA_MANAGER = nullptr;
240 EXPECT_EQ(reminderAgentService_->DelExcludeDates(0), ERR_NO_INIT);
241 ReminderDataManager::InitInstance();
242
243 // test ReminderDataManager::DelExcludeDates
244 MockReminderDataManager::MockDelExcludeDates(1);
245 EXPECT_EQ(reminderAgentService_->DelExcludeDates(0), 1);
246 MockReminderDataManager::MockDelExcludeDates(0);
247 EXPECT_EQ(reminderAgentService_->DelExcludeDates(0), 0);
248 }
249
250 /**
251 * @tc.name: ReminderAgentServiceTest_008
252 * @tc.desc: Test GetExcludeDates function
253 * @tc.type: FUNC
254 * @tc.require: issueI5S4VP
255 */
256 HWTEST_F(ReminderAgentServiceTest, ReminderAgentServiceTest_008, Function | SmallTest | Level1)
257 {
258 std::vector<int64_t> dates;
259 // test CheckReminderPermission
260 MockAccesstokenKit::MockIsVerifyPermisson(false);
261 EXPECT_EQ(reminderAgentService_->GetExcludeDates(0, dates), ERR_REMINDER_PERMISSION_DENIED);
262 MockAccesstokenKit::MockIsVerifyPermisson(true);
263
264 // test ReminderDataManager::GetInstance()
265 ReminderDataManager::REMINDER_DATA_MANAGER = nullptr;
266 EXPECT_EQ(reminderAgentService_->GetExcludeDates(0, dates), ERR_NO_INIT);
267 ReminderDataManager::InitInstance();
268
269 // test ReminderDataManager::GetExcludeDates
270 MockReminderDataManager::MockGetExcludeDates(1);
271 EXPECT_EQ(reminderAgentService_->GetExcludeDates(0, dates), 1);
272 MockReminderDataManager::MockGetExcludeDates(0);
273 EXPECT_EQ(reminderAgentService_->GetExcludeDates(0, dates), 0);
274 }
275
276 /**
277 * @tc.name: ReminderAgentServiceTest_009
278 * @tc.desc: Test TryPostDelayUnloadTask function
279 * @tc.type: FUNC
280 * @tc.require: issueI5S4VP
281 */
282 HWTEST_F(ReminderAgentServiceTest, ReminderAgentServiceTest_009, Function | SmallTest | Level1)
283 {
284 reminderAgentService_->TryPostDelayUnloadTask(1000);
285 std::this_thread::sleep_for(std::chrono::seconds(1));
286 EXPECT_NE(reminderAgentService_->tryUnloadTask_, nullptr);
287 reminderAgentService_->TryPostDelayUnloadTask(1000*1000);
288 EXPECT_NE(reminderAgentService_->tryUnloadTask_, nullptr);
289 }
290
291 /**
292 * @tc.name: ReminderAgentServiceTest_010
293 * @tc.desc: Test TryUnloadService function
294 * @tc.type: FUNC
295 * @tc.require: issueI5S4VP
296 */
297 HWTEST_F(ReminderAgentServiceTest, ReminderAgentServiceTest_010, Function | SmallTest | Level1)
298 {
299 ReminderDataManager::REMINDER_DATA_MANAGER = nullptr;
300 reminderAgentService_->TryUnloadService();
301 EXPECT_EQ(reminderAgentService_->tryUnloadTask_, nullptr);
302 ReminderDataManager::InitInstance();
303
304 MockReminderDataManager::MockQueryActiveReminderCount(1);
305 reminderAgentService_->TryUnloadService();
306 EXPECT_EQ(reminderAgentService_->tryUnloadTask_, nullptr);
307 MockReminderDataManager::MockQueryActiveReminderCount(0);
308
309 reminderAgentService_->TryUnloadService();
310 EXPECT_EQ(reminderAgentService_->tryUnloadTask_, nullptr);
311 }
312
313 /**
314 * @tc.name: ReminderAgentServiceTest_011
315 * @tc.desc: Test ChangeReminderAgentLoadConfig function
316 * @tc.type: FUNC
317 * @tc.require: issueI5S4VP
318 */
319 HWTEST_F(ReminderAgentServiceTest, ReminderAgentServiceTest_011, Function | SmallTest | Level1)
320 {
321 reminderAgentService_->ChangeReminderAgentLoadConfig(1);
322 EXPECT_EQ(reminderAgentService_->reminderAgentState_, 1);
323
324 reminderAgentService_->ChangeReminderAgentLoadConfig(0);
325 EXPECT_EQ(reminderAgentService_->reminderAgentState_, 0);
326 }
327
328 /**
329 * @tc.name: ReminderAgentServiceTest_012
330 * @tc.desc: Test CreateReminderRequest function
331 * @tc.type: FUNC
332 * @tc.require: issueI5S4VP
333 */
334 HWTEST_F(ReminderAgentServiceTest, ReminderAgentServiceTest_012, Function | SmallTest | Level1)
335 {
336 ReminderRequestTimer timer;
337 auto reminder = reminderAgentService_->CreateReminderRequest(timer);
338 EXPECT_EQ(reminder->GetReminderType(), ReminderRequest::ReminderType::TIMER);
339
340 ReminderRequestAlarm alarm;
341 reminder = reminderAgentService_->CreateReminderRequest(alarm);
342 EXPECT_EQ(reminder->GetReminderType(), ReminderRequest::ReminderType::ALARM);
343
344 ReminderRequestCalendar calendar;
345 reminder = reminderAgentService_->CreateReminderRequest(calendar);
346 EXPECT_EQ(reminder->GetReminderType(), ReminderRequest::ReminderType::CALENDAR);
347
348 ReminderRequest request;
349 reminder = reminderAgentService_->CreateReminderRequest(request);
350 EXPECT_EQ(reminder, nullptr);
351 }
352
353 /**
354 * @tc.name: ReminderAgentServiceTest_013
355 * @tc.desc: Test InitReminderRequest function
356 * @tc.type: FUNC
357 * @tc.require: issueI5S4VP
358 */
359 HWTEST_F(ReminderAgentServiceTest, ReminderAgentServiceTest_013, Function | SmallTest | Level1)
360 {
361 sptr<ReminderRequest> reminder = new (std::nothrow) ReminderRequestCalendar();
362 auto wantInfo = reminder->wantAgentInfo_;
363 reminder->wantAgentInfo_ = nullptr;
364 EXPECT_EQ(reminderAgentService_->InitReminderRequest(reminder, "test", 0), ERR_REMINDER_INVALID_PARAM);
365 reminder->wantAgentInfo_ = wantInfo;
366
367 auto maxWantInfo = reminder->maxScreenWantAgentInfo_;
368 reminder->maxScreenWantAgentInfo_ = nullptr;
369 EXPECT_EQ(reminderAgentService_->InitReminderRequest(reminder, "test", 0), ERR_REMINDER_INVALID_PARAM);
370 reminder->maxScreenWantAgentInfo_ = maxWantInfo;
371
372 reminder->wantAgentInfo_->pkgName = "want";
373 reminder->maxScreenWantAgentInfo_->pkgName = "maxWant";
374 EXPECT_EQ(reminderAgentService_->InitReminderRequest(reminder, "test", 0), ERR_REMINDER_INVALID_PARAM);
375
376 reminder->maxScreenWantAgentInfo_->pkgName = "";
377 EXPECT_EQ(reminderAgentService_->InitReminderRequest(reminder, "test", 0), ERR_REMINDER_INVALID_PARAM);
378
379 reminder->wantAgentInfo_->pkgName = "";
380 reminder->maxScreenWantAgentInfo_->pkgName = "maxWant";
381 EXPECT_EQ(reminderAgentService_->InitReminderRequest(reminder, "test", 0), ERR_REMINDER_INVALID_PARAM);
382
383 MockOsAccountManager::MockGetForegroundOsAccountLocalId(1);
384 reminder->maxScreenWantAgentInfo_->pkgName = "test";
385 EXPECT_EQ(reminderAgentService_->InitReminderRequest(reminder, "test", 0), ERR_REMINDER_INVALID_PARAM);
386 reminder->SetSystemApp(true);
387 EXPECT_EQ(reminderAgentService_->InitReminderRequest(reminder, "test", 0), ERR_REMINDER_INVALID_PARAM);
388 MockOsAccountManager::MockGetForegroundOsAccountLocalId(0);
389
390 EXPECT_EQ(reminderAgentService_->InitReminderRequest(reminder, "test", 0), ERR_OK);
391 }
392
393 /**
394 * @tc.name: ReminderAgentServiceTest_014
395 * @tc.desc: Test CheckReminderPermission function
396 * @tc.type: FUNC
397 * @tc.require: issueI5S4VP
398 */
399 HWTEST_F(ReminderAgentServiceTest, ReminderAgentServiceTest_014, Function | SmallTest | Level1)
400 {
401 MockAccesstokenKit::MockIsVerifyPermisson(false);
402 EXPECT_EQ(reminderAgentService_->CheckReminderPermission(), false);
403 MockAccesstokenKit::MockIsVerifyPermisson(true);
404 EXPECT_EQ(reminderAgentService_->CheckReminderPermission(), true);
405 }
406
407 /**
408 * @tc.name: ReminderAgentServiceTest_015
409 * @tc.desc: Test IsSystemApp function
410 * @tc.type: FUNC
411 * @tc.require: issueI5S4VP
412 */
413 HWTEST_F(ReminderAgentServiceTest, ReminderAgentServiceTest_015, Function | SmallTest | Level1)
414 {
415 int32_t flag = static_cast<int32_t>(Security::AccessToken::ATokenTypeEnum::TOKEN_HAP);
416 flag = ~flag;
417 MockAccesstokenKit::MockGetTokenTypeFlag(flag);
418 EXPECT_EQ(reminderAgentService_->IsSystemApp(), false);
419 flag = ~flag;
420 MockAccesstokenKit::MockGetTokenTypeFlag(flag);
421 MockAccesstokenKit::MockIsSystemApp(false);
422 EXPECT_EQ(reminderAgentService_->IsSystemApp(), false);
423 MockAccesstokenKit::MockIsSystemApp(true);
424 EXPECT_EQ(reminderAgentService_->IsSystemApp(), true);
425 }
426
427 /**
428 * @tc.name: ReminderAgentServiceTest_017
429 * @tc.desc: Test UpdateReminder function
430 * @tc.type: FUNC
431 * @tc.require: issueI5S4VP
432 */
433 HWTEST_F(ReminderAgentServiceTest, ReminderAgentServiceTest_017, Function | SmallTest | Level1)
434 {
435 // test CreateReminderRequest
436 int32_t reminderId = 0;
437 ReminderRequest reminder;
438 EXPECT_EQ(reminderAgentService_->UpdateReminder(reminderId, reminder), ERR_REMINDER_INVALID_PARAM);
439
440 // test CheckReminderPermission
441 MockAccesstokenKit::MockIsVerifyPermisson(false);
442 ReminderRequestAlarm alarm;
443 EXPECT_EQ(reminderAgentService_->UpdateReminder(reminderId, alarm), ERR_REMINDER_PERMISSION_DENIED);
444 MockAccesstokenKit::MockIsVerifyPermisson(true);
445
446 // test InitReminderRequest
447 auto wantInfo = alarm.GetMaxScreenWantAgentInfo();
448 alarm.SetMaxScreenWantAgentInfo(nullptr);
449 EXPECT_EQ(reminderAgentService_->UpdateReminder(reminderId, alarm), ERR_REMINDER_INVALID_PARAM);
450 alarm.SetMaxScreenWantAgentInfo(wantInfo);
451
452 // test ReminderDataManager::GetInstance()
453 ReminderDataManager::REMINDER_DATA_MANAGER = nullptr;
454 EXPECT_EQ(reminderAgentService_->UpdateReminder(reminderId, alarm), ERR_NO_INIT);
455 alarm.SetSystemApp(true);
456 EXPECT_EQ(reminderAgentService_->UpdateReminder(reminderId, alarm), ERR_NO_INIT);
457 ReminderDataManager::InitInstance();
458
459 // test ReminderDataManager::UpdateReminder
460 MockReminderDataManager::MockUpdateReminder(1);
461 EXPECT_EQ(reminderAgentService_->UpdateReminder(reminderId, alarm), 1);
462 MockReminderDataManager::MockUpdateReminder(0);
463 EXPECT_EQ(reminderAgentService_->UpdateReminder(reminderId, alarm), 0);
464 }
465 } // namespace OHOS::Notification
466