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 #include "errors.h"
17 #include "ipc_types.h"
18 #include "iremote_object.h"
19 #include <gtest/gtest.h>
20
21 #include "reminder_agent_service_proxy.h"
22 #include "reminder_request.h"
23 #include "reminder_request_timer.h"
24
25 #include "ans_inner_errors.h"
26 #include "mock_i_remote_object.h"
27
28 using namespace testing::ext;
29
30 namespace {
31 bool g_mockWriteInterfaceTokenRet = true;
32 }
33
MockWriteInterfaceToken(bool mockRet)34 void MockWriteInterfaceToken(bool mockRet)
35 {
36 g_mockWriteInterfaceTokenRet = mockRet;
37 }
38 namespace OHOS {
39 namespace Notification {
40 class ReminderAgentServiceProxyTest : public testing::Test {
41 public:
SetUpTestCase()42 static void SetUpTestCase() {}
TearDownTestCase()43 static void TearDownTestCase() {}
SetUp()44 void SetUp() {}
TearDown()45 void TearDown() {}
46 };
47
48 /*
49 * @tc.name: PublishReminder_0100
50 * @tc.desc: test ReminderAgentServiceProxy's PublishReminder function
51 * @tc.type: FUNC
52 * @tc.require: #I5XO2O
53 */
54 HWTEST_F(ReminderAgentServiceProxyTest, PublishReminder_0100, Function | MediumTest | Level1)
55 {
56 GTEST_LOG_(INFO)
57 << "ReminderAgentServiceProxyTest, PublishReminder_0100, TestSize.Level1";
58 MockWriteInterfaceToken(false);
59 sptr<MockIRemoteObject> iremoteObject = new (std::nothrow) MockIRemoteObject();
60 ASSERT_NE(nullptr, iremoteObject);
61 std::shared_ptr<ReminderAgentServiceProxy> proxy = std::make_shared<ReminderAgentServiceProxy>(iremoteObject);
62 ASSERT_NE(nullptr, proxy);
63
64 ReminderRequest reminderRequest;
65 int32_t reminderId = 0;
66 ErrCode res = proxy->PublishReminder(reminderRequest, reminderId);
67 EXPECT_NE(ERR_OK, res);
68 }
69
70 /*
71 * @tc.name: PublishReminder_0200
72 * @tc.desc: test ReminderAgentServiceProxy's PublishReminder function
73 * @tc.type: FUNC
74 * @tc.require: #I5XO2O
75 */
76 HWTEST_F(ReminderAgentServiceProxyTest, PublishReminder_0200, Function | MediumTest | Level1)
77 {
78 GTEST_LOG_(INFO)
79 << "ReminderAgentServiceProxyTest, PublishReminder_0200, TestSize.Level1";
80 MockWriteInterfaceToken(true);
81 sptr<MockIRemoteObject> iremoteObject = new (std::nothrow) MockIRemoteObject();
82 ASSERT_NE(nullptr, iremoteObject);
83 std::shared_ptr<ReminderAgentServiceProxy> proxy = std::make_shared<ReminderAgentServiceProxy>(iremoteObject);
84 ASSERT_NE(nullptr, proxy);
85
86 ReminderRequestTimer reminderRequest;
87 int32_t reminderId = 0;
88 ErrCode res = proxy->PublishReminder(reminderRequest, reminderId);
89 EXPECT_EQ(ERR_OK, res);
90 }
91
92 /*
93 * @tc.name: CancelReminder_0100
94 * @tc.desc: test ReminderAgentServiceProxy's CancelReminder function
95 * @tc.type: FUNC
96 * @tc.require: #I5XO2O
97 */
98 HWTEST_F(ReminderAgentServiceProxyTest, CancelReminder_0100, Function | MediumTest | Level1)
99 {
100 GTEST_LOG_(INFO)
101 << "ReminderAgentServiceProxyTest, CancelReminder_0100, TestSize.Level1";
102 sptr<MockIRemoteObject> iremoteObject = new (std::nothrow) MockIRemoteObject();
103 ASSERT_NE(nullptr, iremoteObject);
104 std::shared_ptr<ReminderAgentServiceProxy> proxy = std::make_shared<ReminderAgentServiceProxy>(iremoteObject);
105 ASSERT_NE(nullptr, proxy);
106
107 int32_t reminderId = 0;
108 ErrCode res = proxy->CancelReminder(reminderId);
109 EXPECT_EQ(ERR_OK, res);
110 }
111
112 /*
113 * @tc.name: CancelAllReminders_0100
114 * @tc.desc: test ReminderAgentServiceProxy's CancelAllReminders function
115 * @tc.type: FUNC
116 * @tc.require: #I5XO2O
117 */
118 HWTEST_F(ReminderAgentServiceProxyTest, CancelAllReminders_0100, Function | MediumTest | Level1)
119 {
120 GTEST_LOG_(INFO)
121 << "ReminderAgentServiceProxyTest, CancelAllReminders_0100, TestSize.Level1";
122 sptr<MockIRemoteObject> iremoteObject = new (std::nothrow) MockIRemoteObject();
123 ASSERT_NE(nullptr, iremoteObject);
124 std::shared_ptr<ReminderAgentServiceProxy> proxy = std::make_shared<ReminderAgentServiceProxy>(iremoteObject);
125 ASSERT_NE(nullptr, proxy);
126
127 ErrCode res = proxy->CancelAllReminders();
128 EXPECT_EQ(ERR_OK, res);
129 }
130
131 /*
132 * @tc.name: GetValidReminders_0100
133 * @tc.desc: test ReminderAgentServiceProxy's GetValidReminders function
134 * @tc.type: FUNC
135 * @tc.require: #I5XO2O
136 */
137 HWTEST_F(ReminderAgentServiceProxyTest, GetValidReminders_0100, Function | MediumTest | Level1)
138 {
139 GTEST_LOG_(INFO)
140 << "ReminderAgentServiceProxyTest, GetValidReminders_0100, TestSize.Level1";
141 sptr<MockIRemoteObject> iremoteObject = new (std::nothrow) MockIRemoteObject();
142 ASSERT_NE(nullptr, iremoteObject);
143 std::shared_ptr<ReminderAgentServiceProxy> proxy = std::make_shared<ReminderAgentServiceProxy>(iremoteObject);
144 ASSERT_NE(nullptr, proxy);
145 std::vector<ReminderRequestAdaptation> reminderVector;
146 ErrCode res = proxy->GetValidReminders(reminderVector);
147 EXPECT_EQ(ERR_OK, res);
148 }
149
150 /*
151 * @tc.name: AddExcludeDate_0100
152 * @tc.desc: test ReminderAgentServiceProxy's AddExcludeDate function
153 * @tc.type: FUNC
154 * @tc.require: #I5XO2O
155 */
156 HWTEST_F(ReminderAgentServiceProxyTest, AddExcludeDate_0100, Function | MediumTest | Level1)
157 {
158 GTEST_LOG_(INFO)
159 << "ReminderAgentServiceProxyTest, AddExcludeDate_0100, TestSize.Level1";
160 sptr<MockIRemoteObject> iremoteObject = new (std::nothrow) MockIRemoteObject();
161 ASSERT_NE(nullptr, iremoteObject);
162 std::shared_ptr<ReminderAgentServiceProxy> proxy = std::make_shared<ReminderAgentServiceProxy>(iremoteObject);
163 ASSERT_NE(nullptr, proxy);
164 int32_t reminderId = 0;
165 int64_t date = 0;
166 ErrCode res = proxy->AddExcludeDate(reminderId, date);
167 EXPECT_EQ(ERR_OK, res);
168 }
169
170 /*
171 * @tc.name: DelExcludeDates_0100
172 * @tc.desc: test ReminderAgentServiceProxy's DelExcludeDates function
173 * @tc.type: FUNC
174 * @tc.require: #I5XO2O
175 */
176 HWTEST_F(ReminderAgentServiceProxyTest, DelExcludeDates_0100, Function | MediumTest | Level1)
177 {
178 GTEST_LOG_(INFO)
179 << "ReminderAgentServiceProxyTest, DelExcludeDates_0100, TestSize.Level1";
180 sptr<MockIRemoteObject> iremoteObject = new (std::nothrow) MockIRemoteObject();
181 ASSERT_NE(nullptr, iremoteObject);
182 std::shared_ptr<ReminderAgentServiceProxy> proxy = std::make_shared<ReminderAgentServiceProxy>(iremoteObject);
183 ASSERT_NE(nullptr, proxy);
184 int32_t reminderId = 0;
185 ErrCode res = proxy->DelExcludeDates(reminderId);
186 EXPECT_EQ(ERR_OK, res);
187 }
188
189 /*
190 * @tc.name: GetExcludeDates_0100
191 * @tc.desc: test ReminderAgentServiceProxy's GetExcludeDates function
192 * @tc.type: FUNC
193 * @tc.require: #I5XO2O
194 */
195 HWTEST_F(ReminderAgentServiceProxyTest, GetExcludeDates_0100, Function | MediumTest | Level1)
196 {
197 GTEST_LOG_(INFO)
198 << "ReminderAgentServiceProxyTest, GetExcludeDates_0100, TestSize.Level1";
199 sptr<MockIRemoteObject> iremoteObject = new (std::nothrow) MockIRemoteObject();
200 ASSERT_NE(nullptr, iremoteObject);
201 std::shared_ptr<ReminderAgentServiceProxy> proxy = std::make_shared<ReminderAgentServiceProxy>(iremoteObject);
202 ASSERT_NE(nullptr, proxy);
203 int32_t reminderId = 0;
204 std::vector<int64_t> dates;
205 ErrCode res = proxy->GetExcludeDates(reminderId, dates);
206 EXPECT_EQ(ERR_OK, res);
207 }
208
209 /*
210 * @tc.name: UpdateReminder_0100
211 * @tc.desc: test ReminderAgentServiceProxy's UpdateReminder function
212 * @tc.type: FUNC
213 * @tc.require: #I5XO2O
214 */
215 HWTEST_F(ReminderAgentServiceProxyTest, UpdateReminder_0100, Function | MediumTest | Level1)
216 {
217 GTEST_LOG_(INFO)
218 << "ReminderAgentServiceProxyTest, UpdateReminder_0100, TestSize.Level1";
219 MockWriteInterfaceToken(false);
220 sptr<MockIRemoteObject> iremoteObject = new (std::nothrow) MockIRemoteObject();
221 ASSERT_NE(nullptr, iremoteObject);
222 std::shared_ptr<ReminderAgentServiceProxy> proxy = std::make_shared<ReminderAgentServiceProxy>(iremoteObject);
223 ASSERT_NE(nullptr, proxy);
224
225 int32_t reminderId = 0;
226 ReminderRequest reminderRequest;
227 ErrCode res = proxy->UpdateReminder(reminderId, reminderRequest);
228 EXPECT_NE(ERR_OK, res);
229 }
230
231 /*
232 * @tc.name: UpdateReminder_0200
233 * @tc.desc: test ReminderAgentServiceProxy's UpdateReminder function
234 * @tc.type: FUNC
235 * @tc.require: #I5XO2O
236 */
237 HWTEST_F(ReminderAgentServiceProxyTest, UpdateReminder_0200, Function | MediumTest | Level1)
238 {
239 GTEST_LOG_(INFO)
240 << "ReminderAgentServiceProxyTest, UpdateReminder_0200, TestSize.Level1";
241 MockWriteInterfaceToken(true);
242 sptr<MockIRemoteObject> iremoteObject = new (std::nothrow) MockIRemoteObject();
243 ASSERT_NE(nullptr, iremoteObject);
244 std::shared_ptr<ReminderAgentServiceProxy> proxy = std::make_shared<ReminderAgentServiceProxy>(iremoteObject);
245 ASSERT_NE(nullptr, proxy);
246
247 int32_t reminderId = 0;
248 ReminderRequestTimer reminderRequest;
249 ErrCode res = proxy->UpdateReminder(reminderId, reminderRequest);
250 EXPECT_EQ(ERR_OK, res);
251 }
252 }
253 }
254