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 #include <gtest/gtest.h>
16 #include <unistd.h>
17 
18 #include <condition_variable>
19 
20 #include "abs_shared_result_set.h"
21 #include "accesstoken_kit.h"
22 #include "data_ability_observer_interface.h"
23 #include "dataobs_mgr_changeinfo.h"
24 #include "datashare_connection.h"
25 #include "datashare_helper.h"
26 #include "datashare_log.h"
27 #include "ext_special_controller.h"
28 #include "extension_manager_proxy.h"
29 #include "general_controller.h"
30 #include "general_controller_provider_impl.h"
31 #include "hap_token_info.h"
32 #include "iservice_registry.h"
33 #include "rdb_data_ability_utils.h"
34 #include "system_ability_definition.h"
35 #include "token_setproc.h"
36 
37 namespace OHOS {
38 namespace DataShare {
39 using namespace testing::ext;
40 using namespace OHOS::Security::AccessToken;
41 
42 class ControllerTest : public testing::Test {
43 public:
44     static void SetUpTestCase(void);
45     static void TearDownTestCase(void);
46     void SetUp();
47     void TearDown();
48 };
49 
SetUpTestCase(void)50 void ControllerTest::SetUpTestCase(void) {}
TearDownTestCase(void)51 void ControllerTest::TearDownTestCase(void) {}
SetUp(void)52 void ControllerTest::SetUp(void) {}
TearDown(void)53 void ControllerTest::TearDown(void) {}
54 
55 HWTEST_F(ControllerTest, ControllerTest_ProviderImplInsertTest_001, TestSize.Level0)
56 {
57     LOG_INFO("ControllerTest_ProviderImplInsertTest_001::Start");
58     Uri uri("");
59     std::shared_ptr<DataShare::GeneralController> tempGenConProImp =
60         std::make_shared<DataShare::GeneralControllerProviderImpl>(nullptr, uri, nullptr);
61     DataShare::DataShareValuesBucket valuesBucket;
62     double valueD1 = 20.07;
63     valuesBucket.Put("phoneNumber", valueD1);
64     int result = tempGenConProImp->Insert(uri, valuesBucket);
65     EXPECT_EQ((result < 0), true);
66     LOG_INFO("ControllerTest_ProviderImplInsertTest_001::End");
67 }
68 
69 HWTEST_F(ControllerTest, ControllerTest_ProviderImplInsertTest_002, TestSize.Level0)
70 {
71     LOG_INFO("ControllerTest_ProviderImplInsertTest_002::Start");
72     Uri uri("");
73     sptr<DataShare::DataShareConnection> connection =
74         new (std::nothrow) DataShare::DataShareConnection(uri, nullptr);
75     auto dataShareConnection =
__anona39fae0e0102(const auto *) 76         std::shared_ptr<DataShare::DataShareConnection>(connection.GetRefPtr(), [holder = connection](const auto *) {
77             holder->DisconnectDataShareExtAbility();
78         });
79     std::shared_ptr<DataShare::GeneralController> tempGenConProImp =
80         std::make_shared<DataShare::GeneralControllerProviderImpl>(dataShareConnection, uri, nullptr);
81     DataShare::DataShareValuesBucket valuesBucket;
82     double valueD1 = 20.07;
83     valuesBucket.Put("phoneNumber", valueD1);
84     int result = tempGenConProImp->Insert(uri, valuesBucket);
85     EXPECT_EQ((result < 0), true);
86     LOG_INFO("ControllerTest_ProviderImplInsertTest_002::End");
87 }
88 
89 HWTEST_F(ControllerTest, ControllerTest_ProviderImplUpdateTest_001, TestSize.Level0)
90 {
91     LOG_INFO("ControllerTest_ProviderImplUpdateTest_001::Start");
92     Uri uri("");
93     std::shared_ptr<DataShare::GeneralController> tempGenConProImp =
94         std::make_shared<DataShare::GeneralControllerProviderImpl>(nullptr, uri, nullptr);
95     DataShare::DataSharePredicates predicates;
96     predicates.EqualTo("name", "Controller_Test001");
97     DataShare::DataShareValuesBucket valuesBucket;
98     valuesBucket.Put("name", "Controller_Test002");
99     int result = tempGenConProImp->Update(uri, predicates, valuesBucket);
100     EXPECT_EQ((result < 0), true);
101     LOG_INFO("ControllerTest_ProviderImplUpdateTest_001::End");
102 }
103 
104 HWTEST_F(ControllerTest, ControllerTest_ProviderImplUpdateTest_002, TestSize.Level0)
105 {
106     LOG_INFO("ControllerTest_ProviderImplUpdateTest_002::Start");
107     Uri uri("");
108     sptr<DataShare::DataShareConnection> connection =
109         new (std::nothrow) DataShare::DataShareConnection(uri, nullptr);
110     auto dataShareConnection =
__anona39fae0e0202(const auto *) 111         std::shared_ptr<DataShare::DataShareConnection>(connection.GetRefPtr(), [holder = connection](const auto *) {
112             holder->DisconnectDataShareExtAbility();
113         });
114     std::shared_ptr<DataShare::GeneralController> tempGenConProImp =
115         std::make_shared<DataShare::GeneralControllerProviderImpl>(dataShareConnection, uri, nullptr);
116     DataShare::DataSharePredicates predicates;
117     predicates.EqualTo("name", "Controller_Test001");
118     DataShare::DataShareValuesBucket valuesBucket;
119     valuesBucket.Put("name", "Controller_Test002");
120     int result = tempGenConProImp->Update(uri, predicates, valuesBucket);
121     EXPECT_EQ((result < 0), true);
122     LOG_INFO("ControllerTest_ProviderImplUpdateTest_002::End");
123 }
124 
125 HWTEST_F(ControllerTest, ControllerTest_ProviderImplDeleteTest_001, TestSize.Level0)
126 {
127     LOG_INFO("ControllerTest_ProviderImplDeleteTest_001::Start");
128     Uri uri("");
129     std::shared_ptr<DataShare::GeneralController> tempGenConProImp =
130         std::make_shared<DataShare::GeneralControllerProviderImpl>(nullptr, uri, nullptr);
131     DataShare::DataSharePredicates predicates;
132     predicates.EqualTo("name", "Controller_Test001");
133     int result = tempGenConProImp->Delete(uri, predicates);
134     EXPECT_EQ((result < 0), true);
135     LOG_INFO("ControllerTest_ProviderImplDeleteTest_001::End");
136 }
137 
138 HWTEST_F(ControllerTest, ControllerTest_ProviderImplDeleteTest_002, TestSize.Level0)
139 {
140     LOG_INFO("ControllerTest_ProviderImplDeleteTest_002::Start");
141     Uri uri("");
142     sptr<DataShare::DataShareConnection> connection =
143         new (std::nothrow) DataShare::DataShareConnection(uri, nullptr);
144     auto dataShareConnection =
__anona39fae0e0302(const auto *) 145         std::shared_ptr<DataShare::DataShareConnection>(connection.GetRefPtr(), [holder = connection](const auto *) {
146             holder->DisconnectDataShareExtAbility();
147         });
148     std::shared_ptr<DataShare::GeneralController> tempGenConProImp =
149         std::make_shared<DataShare::GeneralControllerProviderImpl>(dataShareConnection, uri, nullptr);
150     DataShare::DataSharePredicates predicates;
151     predicates.EqualTo("name", "Controller_Test001");
152     int result = tempGenConProImp->Delete(uri, predicates);
153     EXPECT_EQ((result < 0), true);
154     LOG_INFO("ControllerTest_ProviderImplDeleteTest_002::End");
155 }
156 
157 HWTEST_F(ControllerTest, ControllerTest_ProviderImplQueryTest_001, TestSize.Level0)
158 {
159     LOG_INFO("ControllerTest_ProviderImplQueryTest_001::Start");
160     Uri uri("");
161     std::shared_ptr<DataShare::GeneralController> tempGenConProImp =
162         std::make_shared<DataShare::GeneralControllerProviderImpl>(nullptr, uri, nullptr);
163     DataShare::DataSharePredicates predicates;
164     predicates.EqualTo("name", "Controller_Test001");
165     vector<string> columns;
166     DatashareBusinessError error;
167     auto result = tempGenConProImp->Query(uri, predicates, columns, error);
168     EXPECT_EQ(result, nullptr);
169     LOG_INFO("ControllerTest_ProviderImplQueryTest_001::End");
170 }
171 
172 HWTEST_F(ControllerTest, ControllerTest_ProviderImplQueryTest_002, TestSize.Level0)
173 {
174     LOG_INFO("ControllerTest_ProviderImplQueryTest_002::Start");
175     Uri uri("");
176     sptr<DataShare::DataShareConnection> connection =
177         new (std::nothrow) DataShare::DataShareConnection(uri, nullptr);
178     auto dataShareConnection =
__anona39fae0e0402(const auto *) 179         std::shared_ptr<DataShare::DataShareConnection>(connection.GetRefPtr(), [holder = connection](const auto *) {
180             holder->DisconnectDataShareExtAbility();
181         });
182     std::shared_ptr<DataShare::GeneralController> tempGenConProImp =
183         std::make_shared<DataShare::GeneralControllerProviderImpl>(dataShareConnection, uri, nullptr);
184     DataShare::DataSharePredicates predicates;
185     predicates.EqualTo("name", "Controller_Test001");
186     vector<string> columns;
187     DatashareBusinessError error;
188     auto result = tempGenConProImp->Query(uri, predicates, columns, error);
189     EXPECT_EQ(result, nullptr);
190     LOG_INFO("ControllerTest_ProviderImplQueryTest_002::End");
191 }
192 
193 HWTEST_F(ControllerTest, ControllerTest_ExtSpecialControllerBatchInsertTest_001, TestSize.Level0)
194 {
195     LOG_INFO("ControllerTest_ExtSpecialControllerBatchInsertTest_001::Start");
196     Uri uri("");
197     std::shared_ptr<DataShare::ExtSpecialController> tempExtSpeCon =
198         std::make_shared<DataShare::ExtSpecialController>(nullptr, uri, nullptr);
199     DataShare::DataShareValuesBucket valuesBucket1;
200     valuesBucket1.Put("name", "dataShareTest006");
201     valuesBucket1.Put("phoneNumber", 20.6);
202     DataShare::DataShareValuesBucket valuesBucket2;
203     valuesBucket2.Put("name", "dataShareTest007");
204     valuesBucket2.Put("phoneNumber", 20.5);
205     std::vector<DataShare::DataShareValuesBucket> values;
206     values.push_back(valuesBucket1);
207     values.push_back(valuesBucket2);
208     int result = tempExtSpeCon->BatchInsert(uri, values);
209     EXPECT_EQ((result < 0), true);
210     LOG_INFO("ControllerTest_ExtSpecialControllerBatchInsertTest_001::End");
211 }
212 
213 HWTEST_F(ControllerTest, ControllerTest_ExtSpecialControllerBatchInsertTest_002, TestSize.Level0)
214 {
215     LOG_INFO("ControllerTest_ExtSpecialControllerBatchInsertTest_002::Start");
216     Uri uri("");
217     sptr<DataShare::DataShareConnection> connection =
218         new (std::nothrow) DataShare::DataShareConnection(uri, nullptr);
219     auto dataShareConnection =
__anona39fae0e0502(const auto *) 220         std::shared_ptr<DataShare::DataShareConnection>(connection.GetRefPtr(), [holder = connection](const auto *) {
221             holder->DisconnectDataShareExtAbility();
222         });
223     std::shared_ptr<DataShare::ExtSpecialController> tempExtSpeCon =
224         std::make_shared<DataShare::ExtSpecialController>(dataShareConnection, uri, nullptr);
225     DataShare::DataShareValuesBucket valuesBucket1;
226     valuesBucket1.Put("name", "dataShareTest006");
227     valuesBucket1.Put("phoneNumber", 20.6);
228     DataShare::DataShareValuesBucket valuesBucket2;
229     valuesBucket2.Put("name", "dataShareTest007");
230     valuesBucket2.Put("phoneNumber", 20.5);
231     std::vector<DataShare::DataShareValuesBucket> values;
232     values.push_back(valuesBucket1);
233     values.push_back(valuesBucket2);
234     int result = tempExtSpeCon->BatchInsert(uri, values);
235     EXPECT_EQ((result < 0), true);
236     LOG_INFO("ControllerTest_ExtSpecialControllerBatchInsertTest_002::End");
237 }
238 
239 HWTEST_F(ControllerTest, ControllerTest_ExtSpecialControllerNormalizeUriTest_001, TestSize.Level0)
240 {
241     LOG_INFO("ControllerTest_ExtSpecialControllerNormalizeUriTest_001::Start");
242     Uri uri("");
243     std::shared_ptr<DataShare::ExtSpecialController> tempExtSpeCon =
244         std::make_shared<DataShare::ExtSpecialController>(nullptr, uri, nullptr);
245     Uri result = tempExtSpeCon->NormalizeUri(uri);
246     EXPECT_EQ(result, Uri(""));
247     LOG_INFO("ControllerTest_ExtSpecialControllerNormalizeUriTest_001::End");
248 }
249 
250 HWTEST_F(ControllerTest, ControllerTest_ExtSpecialControllerNormalizeUriTest_002, TestSize.Level0)
251 {
252     LOG_INFO("ControllerTest_ExtSpecialControllerNormalizeUriTest_002::Start");
253     Uri uri("");
254     sptr<DataShare::DataShareConnection> connection =
255         new (std::nothrow) DataShare::DataShareConnection(uri, nullptr);
256     auto dataShareConnection =
__anona39fae0e0602(const auto *) 257         std::shared_ptr<DataShare::DataShareConnection>(connection.GetRefPtr(), [holder = connection](const auto *) {
258             holder->DisconnectDataShareExtAbility();
259         });
260     std::shared_ptr<DataShare::ExtSpecialController> tempExtSpeCon =
261         std::make_shared<DataShare::ExtSpecialController>(dataShareConnection, uri, nullptr);
262     Uri result = tempExtSpeCon->NormalizeUri(uri);
263     EXPECT_EQ(result, Uri(""));
264     LOG_INFO("ControllerTest_ExtSpecialControllerNormalizeUriTest_002::End");
265 }
266 
267 HWTEST_F(ControllerTest, ControllerTest_ExtSpecialControllerDenormalizeUriTest_001, TestSize.Level0)
268 {
269     LOG_INFO("ControllerTest_ExtSpecialControllerDenormalizeUriTest_001::Start");
270     Uri uri("");
271     std::shared_ptr<DataShare::ExtSpecialController> tempExtSpeCon =
272         std::make_shared<DataShare::ExtSpecialController>(nullptr, uri, nullptr);
273     Uri result = tempExtSpeCon->DenormalizeUri(uri);
274     EXPECT_EQ(result, Uri(""));
275     LOG_INFO("ControllerTest_ExtSpecialControllerDenormalizeUriTest_001::End");
276 }
277 
278 HWTEST_F(ControllerTest, ControllerTest_ExtSpecialControllerDenormalizeUriTest_002, TestSize.Level0)
279 {
280     LOG_INFO("ControllerTest_ExtSpecialControllerDenormalizeUriTest_002::Start");
281     Uri uri("");
282     sptr<DataShare::DataShareConnection> connection =
283         new (std::nothrow) DataShare::DataShareConnection(uri, nullptr);
284     auto dataShareConnection =
__anona39fae0e0702(const auto *) 285         std::shared_ptr<DataShare::DataShareConnection>(connection.GetRefPtr(), [holder = connection](const auto *) {
286             holder->DisconnectDataShareExtAbility();
287         });
288     std::shared_ptr<DataShare::ExtSpecialController> tempExtSpeCon =
289         std::make_shared<DataShare::ExtSpecialController>(dataShareConnection, uri, nullptr);
290     Uri result = tempExtSpeCon->DenormalizeUri(uri);
291     EXPECT_EQ(result, Uri(""));
292     LOG_INFO("ControllerTest_ExtSpecialControllerDenormalizeUriTest_002::End");
293 }
294 } // namespace DataShare
295 } // namespace OHOS
296