1 /*
2  * Copyright (c) 2021-2022 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 "contactgroup_test.h"
17 
18 #include "test_common.h"
19 
20 namespace Contacts {
21 namespace Test {
ContactGroupTest()22 ContactGroupTest::ContactGroupTest()
23 {
24 }
25 
~ContactGroupTest()26 ContactGroupTest::~ContactGroupTest()
27 {
28 }
29 
ClearData()30 void ContactGroupTest::ClearData()
31 {
32     OHOS::DataShare::DataSharePredicates predicates;
33     predicates.GreaterThan("id", "0");
34     std::string groups = "groups";
35     int deleteCode = ContactDelete(groups, predicates);
36     EXPECT_EQ(deleteCode, 0);
37 }
38 
GroupsInsert(std::string groupName, OHOS::DataShare::DataShareValuesBucket &groupValues)39 int64_t ContactGroupTest::GroupsInsert(std::string groupName, OHOS::DataShare::DataShareValuesBucket &groupValues)
40 {
41     OHOS::Uri uriGroups(ContactsUri::GROUPS);
42     groupValues.Put("group_name", groupName);
43     int64_t code = contactsDataAbility.Insert(uriGroups, groupValues);
44     return code;
45 }
46 
ContactUpdate(const std::string &tableName, OHOS::DataShare::DataShareValuesBucket updateValues, OHOS::DataShare::DataSharePredicates predicates)47 int ContactGroupTest::ContactUpdate(const std::string &tableName, OHOS::DataShare::DataShareValuesBucket updateValues,
48     OHOS::DataShare::DataSharePredicates predicates)
49 {
50     int code = 0;
51     if (tableName == ContactTabName::RAW_CONTACT) {
52         OHOS::Uri uriRawContact(ContactsUri::RAW_CONTACT);
53         code = contactsDataAbility.Update(uriRawContact, predicates, updateValues);
54     } else if (tableName == ContactTabName::CONTACT_DATA) {
55         OHOS::Uri uriContactData(ContactsUri::CONTACT_DATA);
56         code = contactsDataAbility.Update(uriContactData, predicates, updateValues);
57     } else if (tableName == ContactTabName::GROUPS) {
58         OHOS::Uri uriGroups(ContactsUri::GROUPS);
59         code = contactsDataAbility.Update(uriGroups, predicates, updateValues);
60     } else if (tableName == ContactTabName::CONTACT_BLOCKLIST) {
61         OHOS::Uri uriBlocklist(ContactsUri::BLOCKLIST);
62         code = contactsDataAbility.Update(uriBlocklist, predicates, updateValues);
63     } else {
64         HILOG_ERROR("ContactsDataAbility ====>no match uri action");
65     }
66     return code;
67 }
68 
ContactDelete(const std::string &tableName, OHOS::DataShare::DataSharePredicates predicates)69 int ContactGroupTest::ContactDelete(const std::string &tableName, OHOS::DataShare::DataSharePredicates predicates)
70 {
71     int code = 0;
72     if (tableName == ContactTabName::RAW_CONTACT) {
73         OHOS::Uri uriRawContact(ContactsUri::RAW_CONTACT);
74         code = contactsDataAbility.Delete(uriRawContact, predicates);
75     } else if (tableName == ContactTabName::CONTACT_DATA) {
76         OHOS::Uri uriContactData(ContactsUri::CONTACT_DATA);
77         code = contactsDataAbility.Delete(uriContactData, predicates);
78     } else if (tableName == ContactTabName::GROUPS) {
79         OHOS::Uri uriGroups(ContactsUri::GROUPS);
80         code = contactsDataAbility.Delete(uriGroups, predicates);
81     } else if (tableName == ContactTabName::CONTACT_BLOCKLIST) {
82         OHOS::Uri uriBlocklist(ContactsUri::BLOCKLIST);
83         code = contactsDataAbility.Delete(uriBlocklist, predicates);
84     } else if (tableName == ContactTabName::CONTACT) {
85         OHOS::Uri uriContact(ContactsUri::CONTACT);
86         code = contactsDataAbility.Delete(uriContact, predicates);
87     } else {
88         HILOG_ERROR("ContactsDataAbility ====>no match uri action");
89     }
90     return code;
91 }
92 
ContactQuery( const std::string &tableName, std::vector<std::string> columns, OHOS::DataShare::DataSharePredicates predicates)93 std::shared_ptr<OHOS::DataShare::DataShareResultSet> ContactGroupTest::ContactQuery(
94     const std::string &tableName, std::vector<std::string> columns, OHOS::DataShare::DataSharePredicates predicates)
95 {
96     std::shared_ptr<OHOS::DataShare::DataShareResultSet> resultSet;
97     if (tableName == ContactTabName::RAW_CONTACT) {
98         OHOS::Uri uriRawContact(ContactsUri::RAW_CONTACT);
99         resultSet = contactsDataAbility.Query(uriRawContact, predicates, columns);
100     } else if (tableName == ContactTabName::CONTACT_DATA) {
101         OHOS::Uri uriContactData(ContactsUri::CONTACT_DATA);
102         resultSet = contactsDataAbility.Query(uriContactData, predicates, columns);
103     } else if (tableName == ContactTabName::CONTACT) {
104         OHOS::Uri uriContact(ContactsUri::CONTACT);
105         resultSet = contactsDataAbility.Query(uriContact, predicates, columns);
106     } else if (tableName == ContactTabName::GROUPS) {
107         OHOS::Uri uriGroups(ContactsUri::GROUPS);
108         resultSet = contactsDataAbility.Query(uriGroups, predicates, columns);
109     } else if (tableName == ContactTabName::CONTACT_BLOCKLIST) {
110         OHOS::Uri uriBlocklist(ContactsUri::BLOCKLIST);
111         resultSet = contactsDataAbility.Query(uriBlocklist, predicates, columns);
112     } else if (tableName == ContactTabName::DELETED_RAW_CONTACT) {
113         OHOS::Uri uriDeletedRawContact(ContactsUri::DELETED_RAW_CONTACT);
114         resultSet = contactsDataAbility.Query(uriDeletedRawContact, predicates, columns);
115     } else if (tableName == ContactTabName::SEARCH_CONTACT) {
116         OHOS::Uri uriSearchContact(ContactsUri::SEARCH);
117         resultSet = contactsDataAbility.Query(uriSearchContact, predicates, columns);
118     } else {
119         HILOG_ERROR("ContactsDataAbility ====>no match uri action");
120     }
121     return resultSet;
122 }
123 
QueryAndExpectResult(const std::string &tableName, OHOS::DataShare::DataSharePredicates predicates, OHOS::DataShare::DataShareValuesBucket &values, std::string testName)124 void ContactGroupTest::QueryAndExpectResult(const std::string &tableName,
125     OHOS::DataShare::DataSharePredicates predicates, OHOS::DataShare::DataShareValuesBucket &values,
126     std::string testName)
127 {
128     std::vector<std::string> columns;
129     std::shared_ptr<OHOS::DataShare::DataShareResultSet> resultSet = ContactQuery(tableName, columns, predicates);
130     CheckResultSet(values, resultSet, testName);
131 }
132 
GetAllGroupsColumns(std::vector<std::string> &columnInt, std::vector<std::string> &columnStr)133 void ContactGroupTest::GetAllGroupsColumns(std::vector<std::string> &columnInt, std::vector<std::string> &columnStr)
134 {
135     columnInt.push_back("account_id");
136     columnInt.push_back("ringtone_modify_time");
137     columnInt.push_back("lastest_modify_time");
138 
139     columnStr.push_back("group_name");
140     columnStr.push_back("group_notes");
141     columnStr.push_back("group_ringtone");
142 }
143 
MergeColumns( std::vector<std::string> &columns, std::vector<std::string> &columnsInt, std::vector<std::string> &columnsStr)144 void ContactGroupTest::MergeColumns(
145     std::vector<std::string> &columns, std::vector<std::string> &columnsInt, std::vector<std::string> &columnsStr)
146 {
147     int columnsIntSize = columnsInt.size();
148     for (int i = 0; i < columnsIntSize; i++) {
149         columns.push_back(columnsInt[i]);
150     }
151     int columnsStrSize = columnsStr.size();
152     for (int i = 0; i < columnsStrSize; i++) {
153         columns.push_back(columnsStr[i]);
154     }
155 }
156 
157 /**
158  * @brief get ValuesBucket
159  * @params columnsStart column start index
160  * @params columnsEnd column end index
161  * @return ValuesBucket
162  */
GetAllColumnsValues( std::vector<std::string> &columnsInt, std::vector<std::string> &columnsStr)163 OHOS::DataShare::DataShareValuesBucket ContactGroupTest::GetAllColumnsValues(
164     std::vector<std::string> &columnsInt, std::vector<std::string> &columnsStr)
165 {
166     OHOS::DataShare::DataShareValuesBucket valuesBucket;
167     int randomInt = 0;
168     int columnsIntSize = columnsInt.size();
169     for (int i = 0; i < columnsIntSize; i++) {
170         randomInt = ContactsRand();
171         HILOG_INFO("rand=%{public}d", randomInt);
172         valuesBucket.Put(columnsInt[i], randomInt);
173     }
174     std::string randomStr = "";
175     int columnsStringSize = columnsStr.size();
176     for (int i = 0; i < columnsStringSize; i++) {
177         randomStr = columnsStr[i] + std::to_string(ContactsRand());
178         valuesBucket.Put(columnsStr[i], randomStr);
179     }
180 
181     return valuesBucket;
182 }
183 
GroupsInsertValues(OHOS::DataShare::DataShareValuesBucket &values)184 int64_t ContactGroupTest::GroupsInsertValues(OHOS::DataShare::DataShareValuesBucket &values)
185 {
186     OHOS::Uri uriGroups(ContactsUri::GROUPS);
187     int64_t code = contactsDataAbility.Insert(uriGroups, values);
188     return code;
189 }
190 
191 /*
192  * @tc.number  groups_Insert_test_100
193  * @tc.name    Add a single contact group
194  * @tc.desc    Add capabilities for contact groups
195  * @tc.level   Level1
196  * @tc.size    MediumTest
197  * @tc.type    Function
198  */
HWTEST_F(ContactGroupTest, groups_Insert_test_100, testing::ext::TestSize.Level1)199 HWTEST_F(ContactGroupTest, groups_Insert_test_100, testing::ext::TestSize.Level1)
200 {
201     HILOG_INFO("--- groups_Insert_test_100 is staring! ---");
202     OHOS::DataShare::DataShareValuesBucket valuesGroup;
203     int64_t groupId = GroupsInsert("personnel", valuesGroup);
204     HILOG_INFO("groups_Insert_test_100: groupId = %{public}ld", groupId);
205     EXPECT_GT(groupId, 0);
206 
207     OHOS::DataShare::DataSharePredicates predicates;
208     predicates.EqualTo("id", std::to_string(groupId));
209     std::string groups = ContactTabName::GROUPS;
210     QueryAndExpectResult(groups, predicates, valuesGroup, "groups_Insert_test_100");
211     ClearData();
212 }
213 
214 /*
215  * @tc.number  groups_Insert_test_200
216  * @tc.name    Adding multiple contact groups
217  * @tc.desc    Add capabilities for contact groups
218  * @tc.level   Level1
219  * @tc.size    MediumTest
220  * @tc.type    Function
221  */
HWTEST_F(ContactGroupTest, groups_Insert_test_200, testing::ext::TestSize.Level1)222 HWTEST_F(ContactGroupTest, groups_Insert_test_200, testing::ext::TestSize.Level1)
223 {
224     HILOG_INFO("--- groups_Insert_test_200 is staring! ---");
225     OHOS::DataShare::DataShareValuesBucket valuesGroup;
226     int64_t groupId = GroupsInsert("Test a set", valuesGroup);
227     HILOG_INFO("groups_Insert_test_200: groupId = %{public}ld", groupId);
228     EXPECT_GT(groupId, 0);
229     OHOS::DataShare::DataSharePredicates predicates;
230     predicates.EqualTo("id", std::to_string(groupId));
231     std::string groups = ContactTabName::GROUPS;
232     QueryAndExpectResult(groups, predicates, valuesGroup, "groups_Insert_test_200");
233 
234     valuesGroup.Clear();
235     groupId = GroupsInsert("Test group two", valuesGroup);
236     HILOG_INFO("groups_Insert_test_200: groupId = %{public}ld", groupId);
237     EXPECT_GT(groupId, 0);
238     OHOS::DataShare::DataSharePredicates predicates2;
239     predicates2.EqualTo("id", std::to_string(groupId));
240     QueryAndExpectResult(groups, predicates2, valuesGroup, "groups_Insert_test_200");
241 
242     valuesGroup.Clear();
243     groupId = GroupsInsert("Test three groups", valuesGroup);
244     HILOG_INFO("groups_Insert_test_200: groupId = %{public}ld", groupId);
245     EXPECT_GT(groupId, 0);
246     OHOS::DataShare::DataSharePredicates predicates3;
247     predicates3.EqualTo("id", std::to_string(groupId));
248     QueryAndExpectResult(groups, predicates3, valuesGroup, "groups_Insert_test_200");
249     ClearData();
250 }
251 
252 /*
253  * @tc.number  groups_Insert_test_300
254  * @tc.name    Add a full field data to the groups table and verify whether the insertion is successful
255  * @tc.desc    Added ability to groups
256  * @tc.level   Level1
257  * @tc.size    MediumTest
258  * @tc.type    Function
259  */
HWTEST_F(ContactGroupTest, groups_Insert_test_300, testing::ext::TestSize.Level1)260 HWTEST_F(ContactGroupTest, groups_Insert_test_300, testing::ext::TestSize.Level1)
261 {
262     HILOG_INFO("-----groups_Insert_test_300 is starting!-----");
263     std::vector<std::string> columnsInt;
264     std::vector<std::string> columnsStr;
265     std::vector<std::string> columns;
266     std::string groups = ContactTabName::GROUPS;
267     GetAllGroupsColumns(columnsInt, columnsStr);
268     OHOS::DataShare::DataShareValuesBucket valuesBucket = GetAllColumnsValues(columnsInt, columnsStr);
269     int rawId = GroupsInsertValues(valuesBucket);
270     EXPECT_GT(rawId, 0);
271 
272     MergeColumns(columns, columnsInt, columnsStr);
273     OHOS::DataShare::DataSharePredicates predicates;
274     predicates.EqualTo("id", std::to_string(rawId));
275     std::shared_ptr<OHOS::DataShare::DataShareResultSet> resultSet = ContactQuery(groups, columns, predicates);
276     // resultSet count 1
277     int rowCount = -1;
278     resultSet->GetRowCount(rowCount);
279     EXPECT_EQ(1, rowCount);
280     CheckResultSet(valuesBucket, resultSet, "groups_Insert_test_300");
281     HILOG_INFO("-----groups_Insert_test_300 is end!-----");
282     ClearData();
283 }
284 
285 /*
286  * @tc.number  groups_Delete_test_400
287  * @tc.name    Single contact group deletion
288  * @tc.desc    Delete group ability based on group ID
289  * @tc.level   Level1
290  * @tc.size    MediumTest
291  * @tc.type    Function
292  */
HWTEST_F(ContactGroupTest, groups_Delete_test_400, testing::ext::TestSize.Level1)293 HWTEST_F(ContactGroupTest, groups_Delete_test_400, testing::ext::TestSize.Level1)
294 {
295     HILOG_INFO("--- groups_Delete_test_400 is starting! ---");
296     OHOS::DataShare::DataShareValuesBucket valuesGroup;
297     int64_t groupId = GroupsInsert("Personnel Group", valuesGroup);
298     EXPECT_GT(groupId, 0);
299 
300     OHOS::DataShare::DataSharePredicates predicates;
301     predicates.EqualTo("id", std::to_string(groupId));
302     std::string groups = ContactTabName::GROUPS;
303     int deleteCode = ContactDelete(groups, predicates);
304     EXPECT_EQ(deleteCode, 0);
305     std::vector<std::string> columns;
306     std::shared_ptr<OHOS::DataShare::DataShareResultSet> resultSet = ContactQuery(groups, columns, predicates);
307     int rowCount = 0;
308     resultSet->GetRowCount(rowCount);
309     EXPECT_EQ(0, rowCount);
310     ClearData();
311 }
312 
313 /*
314  * @tc.number  groups_Delete_test_500
315  * @tc.name    Multiple contact groups deleted
316  * @tc.desc    Delete group ability based on group ID
317  * @tc.level   Level1
318  * @tc.size    MediumTest
319  * @tc.type    Function
320  */
HWTEST_F(ContactGroupTest, groups_Delete_test_500, testing::ext::TestSize.Level1)321 HWTEST_F(ContactGroupTest, groups_Delete_test_500, testing::ext::TestSize.Level1)
322 {
323     HILOG_INFO("--- groups_Delete_test_500 is starting! ---");
324     OHOS::DataShare::DataShareValuesBucket valuesGroup;
325     int64_t groupIdOne = GroupsInsert("Personnel Group", valuesGroup);
326     EXPECT_GT(groupIdOne, 0);
327 
328     OHOS::DataShare::DataShareValuesBucket valuesGroupTwo;
329     int64_t groupIdTwo = GroupsInsert("Sell one", valuesGroupTwo);
330     EXPECT_GT(groupIdTwo, 0);
331 
332     OHOS::DataShare::DataShareValuesBucket valuesGroupThree;
333     int64_t groupIdThree = GroupsInsert("Develop a group", valuesGroupThree);
334     EXPECT_GT(groupIdThree, 0);
335 
336     OHOS::DataShare::DataSharePredicates predicates;
337     predicates.EqualTo("id", std::to_string(groupIdOne));
338     predicates.Or();
339     predicates.EqualTo("id", std::to_string(groupIdTwo));
340     predicates.Or();
341     predicates.EqualTo("id", std::to_string(groupIdThree));
342     std::string groups = ContactTabName::GROUPS;
343     int deleteCode = ContactDelete(groups, predicates);
344     HILOG_INFO("groups_Delete_test_500: deleteCode = %{public}d", deleteCode);
345     EXPECT_EQ(deleteCode, 0);
346     OHOS::DataShare::DataSharePredicates predicates2;
347     predicates2.EqualTo("id", std::to_string(groupIdOne));
348     predicates2.Or();
349     predicates2.EqualTo("id", std::to_string(groupIdTwo));
350     predicates2.Or();
351     predicates2.EqualTo("id", std::to_string(groupIdThree));
352     std::vector<std::string> columns;
353     std::shared_ptr<OHOS::DataShare::DataShareResultSet> resultSet = ContactQuery(groups, columns, predicates2);
354     int rowCount = 0;
355     resultSet->GetRowCount(rowCount);
356     EXPECT_EQ(0, rowCount);
357     ClearData();
358 }
359 
360 /*
361  * @tc.number  groups_Delete_test_600
362  * @tc.name    Delete a full field data in the groups table and verify whether the deletion is successful
363  * @tc.desc    Groups deletion capability
364  * @tc.level   Level1
365  * @tc.size    MediumTest
366  * @tc.type    Function
367  */
HWTEST_F(ContactGroupTest, groups_Delete_test_600, testing::ext::TestSize.Level1)368 HWTEST_F(ContactGroupTest, groups_Delete_test_600, testing::ext::TestSize.Level1)
369 {
370     HILOG_INFO("-----groups_Delete_test_600 is starting!-----");
371     // insert
372     std::vector<std::string> columns;
373     std::vector<std::string> columnsInt;
374     std::vector<std::string> columnsStr;
375     GetAllGroupsColumns(columnsInt, columnsStr);
376     OHOS::DataShare::DataShareValuesBucket valuesBucket = GetAllColumnsValues(columnsInt, columnsStr);
377     int groupId = GroupsInsertValues(valuesBucket);
378     EXPECT_GT(groupId, 0);
379 
380     // test end delete data
381     OHOS::DataShare::DataSharePredicates predicates;
382     predicates.EqualTo("id", std::to_string(groupId));
383     EXPECT_GT(groupId, 0);
384     std::string groups = ContactTabName::GROUPS;
385     int deleteCode = ContactDelete(groups, predicates);
386     EXPECT_EQ(deleteCode, 0);
387 
388     MergeColumns(columns, columnsInt, columnsStr);
389     std::shared_ptr<OHOS::DataShare::DataShareResultSet> resultSetDeleteQuery =
390         ContactQuery(groups, columns, predicates);
391     int rowCount = -1;
392     resultSetDeleteQuery->GetRowCount(rowCount);
393     EXPECT_EQ(0, rowCount);
394     ClearData();
395 }
396 
397 /*
398  * @tc.number  groups_Query_test_700
399  * @tc.name    Query all contact groups
400  * @tc.desc    Query all group capabilities
401  * @tc.level   Level1
402  * @tc.size    MediumTest
403  * @tc.type    Function
404  */
HWTEST_F(ContactGroupTest, groups_Query_test_700, testing::ext::TestSize.Level1)405 HWTEST_F(ContactGroupTest, groups_Query_test_700, testing::ext::TestSize.Level1)
406 {
407     HILOG_INFO("--- groups_Query_test_700 is starting! ---");
408     OHOS::DataShare::DataShareValuesBucket valuesGroupTwo;
409     GroupsInsert("Sell one1", valuesGroupTwo);
410     valuesGroupTwo.Clear();
411     GroupsInsert("Sell one2", valuesGroupTwo);
412     valuesGroupTwo.Clear();
413     GroupsInsert("Sell one3", valuesGroupTwo);
414     valuesGroupTwo.Clear();
415     GroupsInsert("Sell one4", valuesGroupTwo);
416     valuesGroupTwo.Clear();
417     GroupsInsert("Sell one5", valuesGroupTwo);
418     valuesGroupTwo.Clear();
419     std::vector<std::string> columns;
420     columns.push_back("id");
421     columns.push_back("group_name");
422     OHOS::DataShare::DataSharePredicates predicates;
423     predicates.GreaterThan("id", "0");
424     std::string groups = ContactTabName::GROUPS;
425     std::shared_ptr<OHOS::DataShare::DataShareResultSet> resultSet = ContactQuery(groups, columns, predicates);
426     int rowCount = 0;
427     int currentCount = 5;
428     resultSet->GetRowCount(rowCount);
429     EXPECT_EQ(currentCount, rowCount);
430     ClearData();
431 }
432 
433 /*
434  * @tc.number  groups_Update_test_800
435  * @tc.name    Single contact group update
436  * @tc.desc    Contacts group update capability
437  * @tc.level   Level1
438  * @tc.size    MediumTest
439  * @tc.type    Function
440  */
HWTEST_F(ContactGroupTest, groups_Update_test_800, testing::ext::TestSize.Level1)441 HWTEST_F(ContactGroupTest, groups_Update_test_800, testing::ext::TestSize.Level1)
442 {
443     HILOG_INFO("--- groups_Update_test_800 is staring! ---");
444     OHOS::DataShare::DataShareValuesBucket valuesGroup;
445     int64_t groupId = GroupsInsert("physical education", valuesGroup);
446     EXPECT_GT(groupId, 0);
447 
448     OHOS::DataShare::DataShareValuesBucket updateValues;
449     updateValues.Put("group_name", std::string("Language"));
450     OHOS::DataShare::DataSharePredicates predicates;
451     predicates.EqualTo("id", std::to_string(groupId));
452     std::string groups = ContactTabName::GROUPS;
453     int updateCode = ContactUpdate(groups, updateValues, predicates);
454     EXPECT_EQ(updateCode, 0);
455     QueryAndExpectResult(groups, predicates, updateValues, "groups_Update_test_800");
456     ClearData();
457 }
458 
459 /*
460  * @tc.number  groups_Update_test_900
461  * @tc.name    Multiple contact group updates
462  * @tc.desc    Contacts group update capability
463  * @tc.level   Level1
464  * @tc.size    MediumTest
465  * @tc.type    Function
466  */
HWTEST_F(ContactGroupTest, groups_Update_test_900, testing::ext::TestSize.Level1)467 HWTEST_F(ContactGroupTest, groups_Update_test_900, testing::ext::TestSize.Level1)
468 {
469     HILOG_INFO("--- groups_Update_test_900 is staring! ---");
470     OHOS::DataShare::DataShareValuesBucket valuesGroupOne;
471     int64_t groupIdOne = GroupsInsert("Develop a group", valuesGroupOne);
472     EXPECT_GT(groupIdOne, 0);
473 
474     OHOS::DataShare::DataShareValuesBucket valuesGroupTwo;
475     int64_t groupIdTwo = GroupsInsert("Development Group 2", valuesGroupTwo);
476     EXPECT_GT(groupIdTwo, 0);
477 
478     OHOS::DataShare::DataShareValuesBucket valuesGroupThree;
479     int64_t groupIdThree = GroupsInsert("Development three groups", valuesGroupThree);
480     EXPECT_GT(groupIdThree, 0);
481 
482     OHOS::DataShare::DataShareValuesBucket updateValues;
483     updateValues.Put("group_name", std::string("Develop a group"));
484     OHOS::DataShare::DataSharePredicates predicates;
485     predicates.EqualTo("id", std::to_string(groupIdOne));
486     std::string groups = ContactTabName::GROUPS;
487     int updateCode = ContactUpdate(groups, updateValues, predicates);
488     EXPECT_EQ(updateCode, 0);
489     QueryAndExpectResult(groups, predicates, updateValues, "groups_Update_test_900");
490 
491     updateValues.Clear();
492     updateValues.Put("group_name", std::string("Development Second Group"));
493     OHOS::DataShare::DataSharePredicates predicates2;
494     predicates2.EqualTo("id", std::to_string(groupIdTwo));
495     updateCode = ContactUpdate(groups, updateValues, predicates2);
496     EXPECT_EQ(updateCode, 0);
497     QueryAndExpectResult(groups, predicates2, updateValues, "groups_Update_test_900");
498 
499     updateValues.Clear();
500     updateValues.Put("group_name", std::string("Develop three groups"));
501     OHOS::DataShare::DataSharePredicates predicates3;
502     predicates3.EqualTo("id", std::to_string(groupIdThree));
503     updateCode = ContactUpdate(groups, updateValues, predicates3);
504     EXPECT_EQ(updateCode, 0);
505     QueryAndExpectResult(groups, predicates3, updateValues, "groups_Update_test_900");
506     ClearData();
507 }
508 
509 /*
510  * @tc.number  groups_Update_test_1000
511  * @tc.name    Update a full field data of the groups table and verify whether the update is successful
512  * @tc.desc    Support all groups update capability
513  * @tc.level   Level1
514  * @tc.size    MediumTest
515  * @tc.type    Function
516  */
HWTEST_F(ContactGroupTest, groups_Update_test_1000, testing::ext::TestSize.Level1)517 HWTEST_F(ContactGroupTest, groups_Update_test_1000, testing::ext::TestSize.Level1)
518 {
519     HILOG_INFO("-----groups_Update_test_1000 is starting!-----");
520     std::vector<std::string> columns;
521     std::vector<std::string> columnsInt;
522     std::vector<std::string> columnsStr;
523     std::string groups = ContactTabName::GROUPS;
524     GetAllGroupsColumns(columnsInt, columnsStr);
525     OHOS::DataShare::DataShareValuesBucket valuesBucket = GetAllColumnsValues(columnsInt, columnsStr);
526     int groupId = GroupsInsertValues(valuesBucket);
527     EXPECT_GT(groupId, 0);
528     MergeColumns(columns, columnsInt, columnsStr);
529     OHOS::DataShare::DataSharePredicates predicates;
530     predicates.EqualTo("id", std::to_string(groupId));
531     std::shared_ptr<OHOS::DataShare::DataShareResultSet> resultSetOne = ContactQuery(groups, columns, predicates);
532     CheckResultSet(valuesBucket, resultSetOne, "groups_Update_test_1000");
533 
534     OHOS::DataShare::DataShareValuesBucket upDateValuesBucket = GetAllColumnsValues(columnsInt, columnsStr);
535     int upDateCode = ContactUpdate(groups, upDateValuesBucket, predicates);
536     EXPECT_EQ(upDateCode, 0);
537     std::shared_ptr<OHOS::DataShare::DataShareResultSet> resultSet = ContactQuery(groups, columns, predicates);
538     // resultSet count 1
539     int rowCount = -1;
540     resultSet->GetRowCount(rowCount);
541     EXPECT_EQ(1, rowCount);
542     CheckResultSet(upDateValuesBucket, resultSet, "groups_Update_test_1000");
543     ClearData();
544 }
545 
546 /*
547  * @tc.number  abnormal_groups_Insert_test_1100
548  * @tc.name    An incorrect field or table name was passed in when inserting a group
549  * @tc.desc    Exception use case
550  * @tc.level   Level1
551  * @tc.size    MediumTest
552  * @tc.type    Function
553  */
HWTEST_F(ContactGroupTest, abnormal_groups_Insert_test_1100, testing::ext::TestSize.Level1)554 HWTEST_F(ContactGroupTest, abnormal_groups_Insert_test_1100, testing::ext::TestSize.Level1)
555 {
556     OHOS::Uri uriGroups(ContactsUri::GROUPS);
557     OHOS::Uri errorUri(ContactsUri::GROUPS_ERROR);
558     OHOS::DataShare::DataShareValuesBucket groupValues;
559     groupValues.Put("group_names", "Board of Directors");
560     int64_t groupId = contactsDataAbility.Insert(uriGroups, groupValues);
561     EXPECT_EQ(groupId, -1);
562 
563     groupValues.Clear();
564     groupValues.Put("group_name", "Board of Directors");
565     groupId = contactsDataAbility.Insert(errorUri, groupValues);
566     EXPECT_EQ(groupId, -1);
567     std::vector<std::string> columns;
568     OHOS::DataShare::DataSharePredicates predicates;
569     predicates.EqualTo("group_name", "Board of Directors");
570     std::string groups = ContactTabName::GROUPS;
571     std::shared_ptr<OHOS::DataShare::DataShareResultSet> resultSet = ContactQuery(groups, columns, predicates);
572     int rowCount = 0;
573     resultSet->GetRowCount(rowCount);
574     EXPECT_EQ(0, rowCount);
575     ClearData();
576 }
577 
578 /*
579  * @tc.number  abnormal_groups_Delete_test_1200
580  * @tc.name    When deleting a group, pass in non-existent fields, field values, and table names
581  * @tc.desc    Exception use case
582  * @tc.level   Level1
583  * @tc.size    MediumTest
584  * @tc.type    Function
585  */
HWTEST_F(ContactGroupTest, abnormal_groups_Delete_test_1200, testing::ext::TestSize.Level1)586 HWTEST_F(ContactGroupTest, abnormal_groups_Delete_test_1200, testing::ext::TestSize.Level1)
587 {
588     OHOS::Uri errorUri(ContactsUri::GROUPS_ERROR);
589     OHOS::DataShare::DataShareValuesBucket values;
590     int64_t groupId = GroupsInsert("Board of Directors 2", values);
591     HILOG_INFO("abnormal_groups_Delete_test_1200: groupId = %{public}ld", groupId);
592     EXPECT_GT(groupId, 0);
593 
594     OHOS::DataShare::DataSharePredicates predicates;
595     predicates.EqualTo("ids", std::to_string(groupId));
596     std::string groups = ContactTabName::GROUPS;
597     int deleteCode = ContactDelete(groups, predicates);
598     HILOG_INFO("abnormal_groups_Delete_test_1200: deleteCode = %{public}d", deleteCode);
599     EXPECT_EQ(deleteCode, -1);
600     std::vector<std::string> columns;
601     OHOS::DataShare::DataSharePredicates predicates2;
602     predicates2.EqualTo("id", std::to_string(groupId));
603     std::shared_ptr<OHOS::DataShare::DataShareResultSet> resultSet = ContactQuery(groups, columns, predicates2);
604     int rowCount = 0;
605     resultSet->GetRowCount(rowCount);
606     EXPECT_EQ(1, rowCount);
607 
608     OHOS::DataShare::DataSharePredicates predicates3;
609     predicates3.EqualTo("id", std::to_string(groupId));
610     deleteCode = contactsDataAbility.Delete(errorUri, predicates3);
611     HILOG_INFO("abnormal_groups_Delete_test_1200: deleteCode = %{public}d", deleteCode);
612     EXPECT_EQ(deleteCode, -1);
613 
614     std::shared_ptr<OHOS::DataShare::DataShareResultSet> resultSetTwo = ContactQuery(groups, columns, predicates3);
615     int rowCountTwo = 0;
616     resultSetTwo->GetRowCount(rowCountTwo);
617     EXPECT_EQ(1, rowCountTwo);
618 
619     OHOS::DataShare::DataSharePredicates predicates4;
620     predicates4.EqualTo("id", "10000000");
621     deleteCode = ContactDelete(groups, predicates4);
622     EXPECT_EQ(deleteCode, 0);
623     ClearData();
624 }
625 
626 /*
627  * @tc.number  abnormal_groups_Query_test_1300
628  * @tc.name    When querying a group, pass in non-existent fields, field values, and table names
629  * @tc.desc    Exception use case
630  * @tc.level   Level1
631  * @tc.size    MediumTest
632  * @tc.type    Function
633  */
HWTEST_F(ContactGroupTest, abnormal_groups_Query_test_1300, testing::ext::TestSize.Level1)634 HWTEST_F(ContactGroupTest, abnormal_groups_Query_test_1300, testing::ext::TestSize.Level1)
635 {
636     std::string tag("abnormal_groups_Query_test_1300");
637     OHOS::Uri errorUri(ContactsUri::GROUPS_ERROR);
638     std::string groups = ContactTabName::GROUPS;
639     std::vector<std::string> columns;
640     columns.push_back("id");
641     columns.push_back("group_name");
642     OHOS::DataShare::DataSharePredicates predicates;
643     predicates.GreaterThan("ids", "0");
644     std::shared_ptr<OHOS::DataShare::DataShareResultSet> resultSetOne = ContactQuery(groups, columns, predicates);
645     int rowCountOne = 0;
646     resultSetOne->GetRowCount(rowCountOne);
647     EXPECT_EQ(-1, rowCountOne);
648 
649     OHOS::DataShare::DataSharePredicates predicates2;
650     predicates2.EqualTo("id", "10000000");
651     std::shared_ptr<OHOS::DataShare::DataShareResultSet> resultSetTwo = ContactQuery(groups, columns, predicates2);
652     int rowCountTwo = 0;
653     resultSetTwo->GetRowCount(rowCountTwo);
654     EXPECT_EQ(0, rowCountTwo);
655 
656     OHOS::DataShare::DataSharePredicates predicates3;
657     predicates3.GreaterThan("id", "0");
658     std::shared_ptr<OHOS::DataShare::DataShareResultSet> resultSetThree =
659         contactsDataAbility.Query(errorUri, predicates3, columns);
660     EXPECT_EQ(resultSetThree, nullptr);
661     ClearData();
662 }
663 
664 /*
665  * @tc.number  abnormal_groups_Update_test_1400
666  * @tc.name    When modifying a group, pass in non-existent fields, field values, and table names
667  * @tc.desc    Exception use case
668  * @tc.level   Level1
669  * @tc.size    MediumTest
670  * @tc.type    Function
671  */
HWTEST_F(ContactGroupTest, abnormal_groups_Update_test_1400, testing::ext::TestSize.Level1)672 HWTEST_F(ContactGroupTest, abnormal_groups_Update_test_1400, testing::ext::TestSize.Level1)
673 {
674     OHOS::Uri errorUri(ContactsUri::GROUPS_ERROR);
675     OHOS::DataShare::DataShareValuesBucket valuesInsert;
676     int64_t groupId = GroupsInsert("Board of Directors", valuesInsert);
677     HILOG_INFO("abnormal_groups_Update_test_1400: groupId = %{public}ld", groupId);
678     EXPECT_GT(groupId, 0);
679 
680     OHOS::DataShare::DataShareValuesBucket updateValues;
681     updateValues.Put("group_names", "Develop a group");
682     OHOS::DataShare::DataSharePredicates predicates;
683     predicates.EqualTo("id", std::to_string(groupId));
684     std::string groups = ContactTabName::GROUPS;
685     int updateCode = ContactUpdate(groups, updateValues, predicates);
686     HILOG_INFO("abnormal_groups_Update_test_1400: updateCode = %{public}d", updateCode);
687     EXPECT_EQ(updateCode, -1);
688     QueryAndExpectResult(groups, predicates, valuesInsert, "abnormal_groups_Update_test_1400");
689 
690     updateValues.Clear();
691     updateValues.Put("group_name", "Develop a group");
692     updateCode = contactsDataAbility.Update(errorUri, predicates, updateValues);
693     HILOG_INFO("abnormal_groups_Update_test_1400: updateCode = %{public}d", updateCode);
694     EXPECT_EQ(updateCode, -1);
695     QueryAndExpectResult(groups, predicates, valuesInsert, "abnormal_groups_Update_test_1400");
696 
697     OHOS::DataShare::DataSharePredicates predicates2;
698     predicates2.EqualTo("id", "10000000");
699     updateCode = ContactUpdate(groups, updateValues, predicates2);
700     EXPECT_EQ(updateCode, 0);
701     ClearData();
702 }
703 } // namespace Test
704 } // namespace Contacts