1 /*
2 * Copyright (c) 2023 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 #include <gtest/gtest.h>
16 #include <memory>
17 #include "native_calendar.h"
18 #include "calendar_log.h"
19 #include "native_calendar_manager.h"
20
21
22 namespace OHOS::CalendarApi::Native {
23 const std::string TEST_NAME = "EventFilterTest";
24 static CalendarAccount account {
25 TEST_NAME,
26 "local",
27 "displayName_EventFilterTest"
28 };
29 class EventFilterTest : public testing::Test {
30 public:
SetUpTestSuite(void)31 static void SetUpTestSuite(void)
32 {
33 calendar = CalendarManager::GetInstance().GetCalendar(account);
34 if (calendar != nullptr && calendar->GetAccount().name == TEST_NAME) {
35 CalendarManager::GetInstance().DeleteCalendar(*calendar.get());
36 }
37 calendar = CalendarManager::GetInstance().CreateCalendar(account);
38 ASSERT_TRUE(calendar != nullptr);
39 LOG_INFO("SetUpTestCase SUCCESS");
40 }
41
TearDownTestSuite(void)42 static void TearDownTestSuite(void)
43 {
44 LOG_INFO("DeleteCalendar");
45 auto ret = CalendarManager::GetInstance().DeleteCalendar(*calendar.get());
46 ASSERT_TRUE(ret);
47 LOG_INFO("TearDownTestSuite SUCCESS");
48 }
SetUp()49 void SetUp() {};
TearDown()50 void TearDown()
51 {
52 calendar->DeleteAllEvents();
53 };
54 static std::shared_ptr<Calendar> calendar;
55 };
56
57 std::shared_ptr<Calendar> EventFilterTest::calendar = nullptr;
58
59
60 HWTEST_F(EventFilterTest, FilterByTitle_test_normal, testing::ext::TestSize.Level1)
61 {
62 const string title = "FilterByTitle_test_normal";
63 Event event;
64 event.title = title;
65 auto eventId = calendar->AddEvent(event);
66 ASSERT_NE(eventId, 0);
67 auto events = calendar->GetEvents(FilterByTitle(title), {});
68 ASSERT_FALSE(events.empty());
69 EXPECT_EQ(events.at(0).title.value(), title);
70 }
71
72 HWTEST_F(EventFilterTest, FilterByTitle_test_noexist, testing::ext::TestSize.Level1)
73 {
74 const string title = "FilterByTitle_test_noexist";
75 Event event;
76 event.title = title;
77 auto eventId = calendar->AddEvent(event);
78 ASSERT_NE(eventId, 0);
79 auto events = calendar->GetEvents(FilterByTitle(title + "event"), {});
80 ASSERT_TRUE(events.empty());
81 }
82
83 HWTEST_F(EventFilterTest, FilterByTitle_test_partialMatch, testing::ext::TestSize.Level1)
84 {
85 const string title = "FilterByTitle_test_partialMatch";
86 Event event;
87 event.title = title;
88 auto eventId = calendar->AddEvent(event);
89 ASSERT_NE(eventId, 0);
90 auto events = calendar->GetEvents(FilterByTitle("partialMatch"), {});
91 ASSERT_FALSE(events.empty());
92 EXPECT_EQ(events.at(0).title.value(), title);
93 }
94
95 HWTEST_F(EventFilterTest, FilterByTitle_test_chinese, testing::ext::TestSize.Level1)
96 {
97 const string title = "FilterByTitle_test_中文测试_0302";
98 Event event;
99 event.title = title;
100 auto eventId = calendar->AddEvent(event);
101 ASSERT_NE(eventId, 0);
102 auto events = calendar->GetEvents(FilterByTitle("中文测试"), {});
103 ASSERT_FALSE(events.empty());
104 EXPECT_EQ(events.at(0).title.value(), title);
105 }
106
107 HWTEST_F(EventFilterTest, FilterById_test_normal, testing::ext::TestSize.Level1)
108 {
109 const string title = "FilterById_test_normal";
110 Event event;
111 event.title = title;
112 auto eventId = calendar->AddEvent(event);
113 ASSERT_NE(eventId, 0);
114 auto events = calendar->GetEvents(FilterById({eventId}), {});
115
116 ASSERT_FALSE(events.empty());
117 EXPECT_EQ(events.at(0).title.value(), title);
118 }
119
120 HWTEST_F(EventFilterTest, FilterById_test_empty, testing::ext::TestSize.Level1)
121 {
122 const string title = "FilterById_test_empty";
123 Event event;
124 event.title = title;
125 auto eventId = calendar->AddEvent(event);
126 ASSERT_NE(eventId, 0);
127 auto events = calendar->GetEvents(FilterById({eventId}), {});
128 ASSERT_FALSE(events.empty());
129 EXPECT_EQ(events.at(0).title.value(), title);
130 }
131
132 HWTEST_F(EventFilterTest, FilterById_test_one_not_include, testing::ext::TestSize.Level1)
133 {
134 const string title = "FilterById_test_one_not_include";
135 Event event;
136 event.title = title;
137 auto eventId = calendar->AddEvent(event);
138 ASSERT_NE(eventId, 0);
139 auto events = calendar->GetEvents(FilterById({eventId + 1}), {});
140 ASSERT_TRUE(events.empty());
141 }
142
143 HWTEST_F(EventFilterTest, FilterById_test_all_include, testing::ext::TestSize.Level1)
144 {
145 const string title = "FilterById_test_all_include_1";
146 Event event;
147 event.title = title;
148 const string title1 = "FilterById_test_all_include_2";
149 Event event1;
150 event1.title = title1;
151 auto eventId1 = calendar->AddEvent(event);
152 auto eventId2 = calendar->AddEvent(event1);
153 auto events = calendar->GetEvents(FilterById({eventId1, eventId2}), {});
154 ASSERT_EQ(2, events.size());
155 EXPECT_EQ(events.at(0).title.value(), title);
156 EXPECT_EQ(events.at(1).title.value(), title1);
157 }
158
Now()159 inline static uint64_t Now()
160 {
161 constexpr int64_t secToMicrosec = 1000000;
162 constexpr int64_t microsecToNanosec = 1000;
163 struct timespec ts;
164 clock_gettime(CLOCK_MONOTONIC, &ts);
165 return (ts.tv_sec * secToMicrosec + ts.tv_nsec / microsecToNanosec);
166 }
167
168 HWTEST_F(EventFilterTest, FilterByTime_test_001, testing::ext::TestSize.Level1)
169 {
170 const string title = "FilterByTime_test_001";
171 Event event;
172 event.title = title;
173 auto timeNow = Now();
174 event.startTime = timeNow;
175 event.endTime = timeNow + 100000;
176 auto eventId = calendar->AddEvent(event);
177 ASSERT_TRUE(eventId > 0);
178 auto events = calendar->GetEvents(FilterByTime(event.startTime, event.endTime), {});
179 ASSERT_EQ(1, events.size());
180 EXPECT_EQ(events.at(0).title.value(), title);
181 EXPECT_EQ(events.at(0).startTime, event.startTime);
182 EXPECT_EQ(events.at(0).endTime, event.endTime);
183 }
184
185 HWTEST_F(EventFilterTest, FilterByTime_test_002, testing::ext::TestSize.Level1)
186 {
187 Event event;
188 event.title = "FilterByTime_test_002";
189 auto timeNow = Now();
190 event.startTime = timeNow;
191 const int64_t interval = 100;
192 event.endTime = timeNow + interval;
193 auto eventId = calendar->AddEvent(event);
194 ASSERT_TRUE(eventId > 0);
195 auto events = calendar->GetEvents(FilterByTime(event.startTime - interval * 2, event.startTime - interval), {});
196 EXPECT_TRUE(events.empty());
197 events = calendar->GetEvents(FilterByTime(event.endTime + interval, event.endTime + interval * 2), {});
198 ASSERT_TRUE(events.empty());
199 }
200
201 HWTEST_F(EventFilterTest, FilterByTime_test_003, testing::ext::TestSize.Level1)
202 {
203 const string title1 = "FilterByTime_test_003_1";
204 auto timeNow = Now();
205 Event event1;
206 event1.title = title1;
207 event1.startTime = timeNow;
208 const int64_t interval = 100;
209 event1.endTime = timeNow + interval;
210 const string title2 = "FilterByTime_test_003_2";
211 Event event2;
212 event2.title = title2;
213 event2.startTime = timeNow;
214 event2.endTime = timeNow + interval * 2;
215
216 auto count = calendar->AddEvents({event1, event2});
217 ASSERT_TRUE(count == 2);
218 auto events = calendar->GetEvents(FilterByTime(timeNow, event2.endTime), {});
219 ASSERT_EQ(2, events.size());
220 EXPECT_EQ(events.at(0).title.value(), title1);
221 EXPECT_EQ(events.at(0).startTime, event1.startTime);
222 EXPECT_EQ(events.at(0).endTime, event1.endTime);
223 EXPECT_EQ(events.at(1).title.value(), title2);
224 EXPECT_EQ(events.at(1).startTime, event2.startTime);
225 EXPECT_EQ(events.at(1).endTime, event2.endTime);
226 }
227
228 HWTEST_F(EventFilterTest, FilterById_and_eventKey_001, testing::ext::TestSize.Level1)
229 {
230 const string title = "FilterById_and_eventKey_001";
231 Event event;
232 event.type = EventType::Important;
233 event.title = title;
234 auto timeNow = Now();
235 event.startTime = timeNow;
236 const int64_t interval = 100;
237 event.endTime = timeNow + interval;
238 auto eventId = calendar->AddEvent(event);
239 auto eventResult = calendar->GetEvents(FilterById({eventId}), {"type", "title", "startTime", "endTime"});
240 const auto newEvent = eventResult.at(0);
241 EXPECT_EQ(newEvent.type, event.type);
242 EXPECT_EQ(newEvent.title.value(), title);
243 EXPECT_EQ(newEvent.startTime, event.startTime);
244 EXPECT_EQ(newEvent.endTime, event.endTime);
245 }
246
247 HWTEST_F(EventFilterTest, FilterByTitle_and_eventKey_002, testing::ext::TestSize.Level1)
248 {
249 const string title = "FilterByTitle_and_eventKey_002";
250 Event event;
251 event.title = title;
252 Location testLocation {"test", 123.12, 45.45};
253 event.location = std::make_optional<Location>(testLocation);
254 event.isAllDay = true;
255 event.attendees = {{"xiaoming", "xiaoming@abc.com", NONE, UNKNOWN, REQUIRED},
256 {"xiaoqiang", "test_attendee1@abc.com", PARTICIPANT, TENTATIVE, OPTIONAL},
257 {"abc", "test_attendee2@abc.com", ORGANIZER, ACCEPTED, RESOURCE}};
258 event.timeZone = "shanghai";
259 auto eventId = calendar->AddEvent(event);
260 ASSERT_NE(eventId, 0);
261 auto eventResult = calendar->GetEvents(FilterByTitle(title),
262 {"title", "location", "isAllDay", "attendee", "timeZone"});
263 const auto newEvent = eventResult.at(0);
264 EXPECT_EQ(newEvent.title.value(), title);
265 EXPECT_EQ(newEvent.location.value(), event.location.value());
266 EXPECT_EQ(newEvent.isAllDay.value(), event.isAllDay.value());
267 EXPECT_EQ(newEvent.attendees, event.attendees);
268 EXPECT_EQ(newEvent.timeZone.value(), "shanghai");
269 }
270
271 HWTEST_F(EventFilterTest, FilterByTime_and_eventKey_003, testing::ext::TestSize.Level1)
272 {
273 const string title = "FilterByTime_and_eventKey_003";
274 Event event;
275 event.title = title;
276 auto timeNow = Now();
277 const int64_t interval = 100;
278 event.startTime = timeNow;
279 event.endTime = timeNow + interval;
280 event.reminderTime = {0, 1, 2};
281 event.description = "FilterByTime_and_eventKey_003 description";
282 optional<string> description = std::make_optional<string>("FilterByTime_and_eventKey_003 description");
283 EventService service = {"Meeting", "FilterByTime_and_eventKey_003 uri", description};
284 event.service = std::make_optional<EventService>(service);
285 auto eventId = calendar->AddEvent(event);
286 ASSERT_NE(eventId, 0);
287 auto eventResult = calendar->GetEvents(FilterByTime(timeNow, event.endTime + 100),
288 {"title", "reminderTime", "description", "service"});
289 const auto newEvent = eventResult.at(0);
290 EXPECT_EQ(newEvent.title.value(), title);
291 ASSERT_EQ(newEvent.reminderTime.has_value(), true);
292 EXPECT_EQ(newEvent.reminderTime.value(), event.reminderTime.value());
293 EXPECT_EQ(newEvent.description.value(), event.description.value());
294 ASSERT_EQ(newEvent.service.has_value(), true);
295 EXPECT_EQ(newEvent.service.value().type, event.service.value().type);
296 EXPECT_EQ(newEvent.service.value().uri, event.service.value().uri);
297 EXPECT_EQ(newEvent.service.value().description.value(), event.service.value().description.value());
298 }
299
300 HWTEST_F(EventFilterTest, QueryEventInstances_001, testing::ext::TestSize.Level1)
301 {
302 const string title = "QueryEventInstances_001";
303 Event event;
304 event.title = title;
305 auto timeNow = Now();
306 const int64_t interval = 100;
307 event.startTime = timeNow;
308 event.endTime = timeNow + interval;
309 event.reminderTime = {0, 1, 2};
310 event.description = "QueryEventInstances_001 description";
311 optional<string> description = std::make_optional<string>("QueryEventInstances_001 description");
312 EventService service = {"Meeting", "QueryEventInstances_001 uri", description};
313 event.service = std::make_optional<EventService>(service);
314 auto eventId = calendar->AddEvent(event);
315 ASSERT_NE(eventId, 0);
316 auto eventResult = calendar->QueryEventInstances(event.startTime, event.endTime + 100, {eventId},
317 {"title", "reminderTime", "description", "service"});
318 const auto newEvent = eventResult.at(0);
319 EXPECT_EQ(newEvent.title.value(), title);
320 ASSERT_EQ(newEvent.reminderTime.has_value(), true);
321 EXPECT_EQ(newEvent.reminderTime.value(), event.reminderTime.value());
322 EXPECT_EQ(newEvent.description.value(), event.description.value());
323 ASSERT_EQ(newEvent.service.has_value(), true);
324 EXPECT_EQ(newEvent.service.value().type, event.service.value().type);
325 EXPECT_EQ(newEvent.service.value().uri, event.service.value().uri);
326 EXPECT_EQ(newEvent.service.value().description.value(), event.service.value().description.value());
327 }
328
329 HWTEST_F(EventFilterTest, QueryEventInstances_002, testing::ext::TestSize.Level1)
330 {
331 const string title = "QueryEventInstances_002";
332 Event event;
333 event.type = EventType::Important;
334 event.title = title;
335 auto timeNow = Now();
336 event.startTime = timeNow;
337 const int64_t interval = 100;
338 event.endTime = timeNow + interval;
339 auto eventId = calendar->AddEvent(event);
340 auto eventResult = calendar->QueryEventInstances(event.startTime, event.endTime + 100, {eventId}, {});
341 const auto newEvent = eventResult.at(0);
342 EXPECT_EQ(newEvent.title.value(), title);
343 EXPECT_EQ(newEvent.startTime, event.startTime);
344 EXPECT_EQ(newEvent.endTime, event.endTime);
345 }
346 }